tui: say so when a hand-off exits without running

"deepseek exited (code 0). back in the pit." is what the pit printed for a
CLI that never ran a single line, and it reads as a clean session — so the
bug looked like it was in the hand-off rather than in the engine.

It is a real failure mode, not a hypothetical: @serjm/deepseek-code 0.5.0
decides whether it is the entrypoint by comparing resolve(process.argv[1])
against import.meta.url, and npm installs every global bin as a symlink, so
the comparison never matches, the program falls off the end having done
nothing, and exits 0.

The child owns the terminal, so its output is not ours to read — but the
clock is enough. An exit of 0 in under a second and a half did not host a
session anybody used, and saying "this usually means a broken install"
points at the right program without claiming to know why.

Only for silent success: a non-zero exit already says something went wrong,
and the engine has usually printed why.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: ralyodio

src/tui.mjs

@@ -464,6 +464,35 @@ let activeMirror = null;
  */
 const childSink = () => (activeMirror ? (chunk) => activeMirror?.write(chunk) : undefined);
 
+/**
+ * How fast an exit has to be before it is worth remarking on.
+ *
+ * A person who opens an agent and immediately quits takes longer than this.
+ * Nothing that actually started a session lands under it.
+ */
+const INSTANT_EXIT_MS = 1500;
+
+/**
+ * The note for a hand-off that ended the moment it began, or null.
+ *
+ * A CLI that exits 0 without doing anything is indistinguishable, from out
+ * here, from one the operator opened and closed — both are "exited (code 0)",
+ * which reads as success and sent somebody looking for the bug in the wrong
+ * program. It happens for real: @serjm/deepseek-code 0.5.0 compares
+ * `resolve(process.argv[1])` against `import.meta.url` to decide whether it is
+ * the entrypoint, and npm installs every global bin as a symlink, so the
+ * comparison fails and the whole CLI silently runs nothing.
+ *
+ * Timing is all we have — the child owns the terminal, so its output is not
+ * ours to inspect — and it is enough to say "this looks wrong" without
+ * claiming to know why.
+ */
+export function instantExitNote({ key, bin, code, ms }) {
+  if (code !== 0 || ms >= INSTANT_EXIT_MS) return null;
+  return `${key} exited instantly without running — that usually means a broken install, not a clean session.`
+    + ` check it directly with \`${bin} --version\`, and reinstall with /install ${key} if that prints nothing.`;
+}
+
 async function openEngine(key, engine, args, { agentMode = false } = {}) {
   if (!engine.installed && !args.length) {
     console.log(info(`${key} isn't installed — try ${acid("/install " + key)} first.`));
@@ -479,7 +508,9 @@ async function openEngine(key, engine, args, { agentMode = false } = {}) {
   console.log(info(`opening ${bone(key)}${agentMode ? " autonomously" : " raw"} — hand-off to its CLI, exit it to come back…`));
   console.log(hr());
   activeMirror?.setEngine(key);
+  const startedAt = Date.now();
   const r = await openSession(engine, agentMode ? agentLaunchArgs(engine, args) : args, { onOutput: childSink() });
+  const elapsed = Date.now() - startedAt;
   activeMirror?.setEngine(null);
   console.log(hr());
   if (!r.ok) {
@@ -488,6 +519,8 @@ async function openEngine(key, engine, args, { agentMode = false } = {}) {
       : err(`couldn't launch ${key}: ${r.error?.message || r.error}`));
   } else {
     console.log(info(`${key} exited${r.code != null ? ` (code ${r.code})` : ""}. back in the pit.`));
+    const note = instantExitNote({ key, bin: engine.bin, code: r.code, ms: elapsed });
+    if (note) console.log(warn(note));
   }
 }
 
@@ -497,14 +530,18 @@ async function openWorkflowTool(key, tool, args) {
   }
   console.log(info(`opening ${bone(key)} — native CLI owns the terminal until it exits…`));
   console.log(hr());
+  const toolStartedAt = Date.now();
   const result = await openTool(tool, args, { onOutput: childSink() });
+  const toolElapsed = Date.now() - toolStartedAt;
   console.log(hr());
   if (!result.ok) {
     console.log(result.error?.code === "ENOENT"
       ? err(`${key} isn't on PATH (\`${tool.bin}\`). install it with /install ${key}`)
       : err(`couldn't launch ${key}: ${result.error?.message || result.error}`));
   } else {
     console.log(info(`${key} exited${result.code != null ? ` (code ${result.code})` : result.signal ? ` (${result.signal})` : ""}. back in the pit.`));
+    const note = instantExitNote({ key, bin: tool.bin, code: result.code, ms: toolElapsed });
+    if (note) console.log(warn(note));
   }
 }
 

test/tui.test.mjs

@@ -6,7 +6,7 @@ import { join } from "node:path";
 import test from "node:test";
 import { fileURLToPath } from "node:url";
 
-import { splitCommandLine } from "../src/tui.mjs";
+import { instantExitNote, splitCommandLine } from "../src/tui.mjs";
 
 const BIN = fileURLToPath(new URL("../bin/moshcode.mjs", import.meta.url));
 
@@ -233,3 +233,27 @@ test("TUI tightens a history file that was already world-readable", posixMode, a
   assert.equal(statSync(file).mode & 0o777, 0o600);
   assert.match(readFileSync(file, "utf8"), /Bearer sk-live/); // history itself survives
 });
+
+test("an engine that exits instantly is called out, not reported as a clean session", () => {
+  // @serjm/deepseek-code 0.5.0 compares resolve(process.argv[1]) against
+  // import.meta.url to decide whether it is the entrypoint. npm installs every
+  // global bin as a symlink, so that comparison fails and the CLI runs nothing
+  // and exits 0 — which the pit printed as "exited (code 0). back in the pit."
+  const note = instantExitNote({ key: "deepseek", bin: "deepseek-code", code: 0, ms: 40 });
+  assert.match(note, /exited instantly/);
+  assert.match(note, /deepseek-code --version/);
+  assert.match(note, /\/install deepseek/);
+});
+
+test("a session someone actually used says nothing extra", () => {
+  assert.equal(instantExitNote({ key: "claude", bin: "claude", code: 0, ms: 90_000 }), null);
+  // Right at the line: only faster than the threshold counts.
+  assert.equal(instantExitNote({ key: "claude", bin: "claude", code: 0, ms: 1500 }), null);
+});
+
+test("a real failure is left to the exit code — this note is only for silent success", () => {
+  // A non-zero exit already says something went wrong, and the engine has
+  // usually printed why. Adding "that was fast" on top would be noise.
+  assert.equal(instantExitNote({ key: "codex", bin: "codex", code: 1, ms: 30 }), null);
+  assert.equal(instantExitNote({ key: "codex", bin: "codex", code: null, ms: 30 }), null);
+});