jeo-code 0.11.0 → 0.11.1

package/CHANGELOG.md

@@ -9,6 +9,21 @@ The README mirrors the latest 5 entries — regenerate with `bun run changelog:s
 
 ## [Unreleased]
 
+## [0.11.1] - 2026-08-25
+_Every non-interactive `jeo` run hung forever once Telegram notifications were configured — `echo "..." | jeo`, `jeo -p "..."` in CI, any scripted use. The work completed and the command returned; the process just never exited._
+
+### Fixed
+- **A one-shot run never exited when `notifications.enabled` was set** (`src/agent/notify/session-endpoint.ts`, `src/commands/launch.ts`) — `startSessionNotifyEndpoint` binds a `Bun.serve` socket plus a snapshot-poll `setInterval` for the whole launch lifetime, but its teardown lived only on the interactive REPL's exit path. A one-shot run leaves through one of ~17 early `return`s, none of which reach it, so the listening socket and the ref'd timer kept the event loop alive indefinitely. Fixed on both sides: the server and poll timer are now `unref`'d so the endpoint can never be the reason the process stays up, and the entire one-shot block is wrapped in a `try/finally` that stops the endpoint — which also removes the session discovery file, so the Telegram daemon stops dialling a dead socket after a scripted run.
+  - This was invisible for two compounding reasons: it only reproduces on a machine with notifications actually configured, and Bun timers/servers do not appear in `process._getActiveHandles()` — so the hung process reported **zero** active handles while refusing to exit. It was found by monkey-patching `setInterval`/`setTimeout` to record creation sites and dumping the still-ref'd ones after `dispatch()` returned.
+- **The `bashTool` orphan-reaping assertions compared raw command output to the string `"0"`** (`test/tools-fs.test.ts`) — `bashTool` merges stdout and stderr, so any warning `pgrep` wrote to stderr false-failed a run in which zero strays actually existed. The count is now parsed rather than string-matched, and the orphan check is gated on process enumeration actually working (hardened sandboxes answer `pgrep: Cannot get process list`). The abort **contract** itself (`success:false` / `"Command aborted"`) is still asserted unconditionally, so a restricted host keeps covering the behaviour that matters.
+
+### Added
+- `test/notify-endpoint-exit.test.ts` — pins the exit contract deterministically by pointing `JEO_CONFIG_DIR` at a temp config with notifications ON, rather than depending on the developer's real `~/.jeo/config.json`. Covers both halves independently: the `finally` teardown (one-shot exits, no leftover discovery file) and the `unref` guard (any future path that forgets `stop()` still cannot pin the process open).
+
+### Verified
+- `bun run typecheck` clean; `bun test` **3348 pass, 0 fail** — down from 22 failures two releases ago and 6 at 0.11.0. Suite wall time also dropped ~148s → ~88s, since the hung specs no longer burn their full 25s/5s timeouts.
+- The unref guard was verified by reverting it and confirming the new unit test fails, then restoring it.
+
 ## [0.11.0] - 2026-08-25
 _One bad boundary check was corrupting agent context, subagent fan-out, and the Telegram daemon's kill safety at the same time — and none of the three looked related from the outside._
 

package/README.ja.md

@@ -319,10 +319,10 @@ CI は `.github/workflows/npm-publish.yml` で公開します — GitHub リリ
 
 <!-- CHANGELOG:START (auto-generated from CHANGELOG.md — run `bun run changelog:sync`) -->
 - **[Unreleased]**
+- **[0.11.1]** (2026-08-25) — Every non-interactive `jeo` run hung forever once Telegram notifications were configured — `echo "..." | jeo`, `jeo -p "..."` in CI, any scripted use. The work completed and the command returned; the process just never exited.
 - **[0.11.0]** (2026-08-25) — One bad boundary check was corrupting agent context, subagent fan-out, and the Telegram daemon's kill safety at the same time — and none of the three looked related from the outside.
 - **[0.10.0]** (2026-08-25) — jeo could only be pointed at ONE user-supplied endpoint (`config.openaiBaseUrl`), and doing so rebound the built-in `openai` provider: it stole the `openai/` routing prefix, collided with real OpenAI model ids, and could not speak the Anthropic Messages protocol at all. There was no way to run a company LiteLLM proxy and a self-hosted vLLM box at the same time, or to reach either from a script.
 - **[0.9.17]** (2026-08-18) — Live model discovery already existed (`listProviderModels`/`discoverModels`), but only `jeo auth login openai` ever called it — logging into Anthropic or Antigravity left the account pinned to the maintained static catalog snapshot until the next unrelated live-discovery call happened to run.
-- **[0.9.16]** (2026-08-18) — Routing looked broken while it was actually working: the idle status bar and `/compact`/`/handoff` never reflected which model `routePrompt` actually routed to.
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/README.ko.md

@@ -320,10 +320,10 @@ CI는 `.github/workflows/npm-publish.yml`로 배포합니다 — GitHub 릴리
 
 <!-- CHANGELOG:START (auto-generated from CHANGELOG.md — run `bun run changelog:sync`) -->
 - **[Unreleased]**
+- **[0.11.1]** (2026-08-25) — Every non-interactive `jeo` run hung forever once Telegram notifications were configured — `echo "..." | jeo`, `jeo -p "..."` in CI, any scripted use. The work completed and the command returned; the process just never exited.
 - **[0.11.0]** (2026-08-25) — One bad boundary check was corrupting agent context, subagent fan-out, and the Telegram daemon's kill safety at the same time — and none of the three looked related from the outside.
 - **[0.10.0]** (2026-08-25) — jeo could only be pointed at ONE user-supplied endpoint (`config.openaiBaseUrl`), and doing so rebound the built-in `openai` provider: it stole the `openai/` routing prefix, collided with real OpenAI model ids, and could not speak the Anthropic Messages protocol at all. There was no way to run a company LiteLLM proxy and a self-hosted vLLM box at the same time, or to reach either from a script.
 - **[0.9.17]** (2026-08-18) — Live model discovery already existed (`listProviderModels`/`discoverModels`), but only `jeo auth login openai` ever called it — logging into Anthropic or Antigravity left the account pinned to the maintained static catalog snapshot until the next unrelated live-discovery call happened to run.
-- **[0.9.16]** (2026-08-18) — Routing looked broken while it was actually working: the idle status bar and `/compact`/`/handoff` never reflected which model `routePrompt` actually routed to.
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/README.md

@@ -327,10 +327,10 @@ Huge thanks to [gajae-code](https://github.com/Yeachan-Heo/gajae-code) for the i
 
 <!-- CHANGELOG:START (auto-generated from CHANGELOG.md — run `bun run changelog:sync`) -->
 - **[Unreleased]**
+- **[0.11.1]** (2026-08-25) — Every non-interactive `jeo` run hung forever once Telegram notifications were configured — `echo "..." | jeo`, `jeo -p "..."` in CI, any scripted use. The work completed and the command returned; the process just never exited.
 - **[0.11.0]** (2026-08-25) — One bad boundary check was corrupting agent context, subagent fan-out, and the Telegram daemon's kill safety at the same time — and none of the three looked related from the outside.
 - **[0.10.0]** (2026-08-25) — jeo could only be pointed at ONE user-supplied endpoint (`config.openaiBaseUrl`), and doing so rebound the built-in `openai` provider: it stole the `openai/` routing prefix, collided with real OpenAI model ids, and could not speak the Anthropic Messages protocol at all. There was no way to run a company LiteLLM proxy and a self-hosted vLLM box at the same time, or to reach either from a script.
 - **[0.9.17]** (2026-08-18) — Live model discovery already existed (`listProviderModels`/`discoverModels`), but only `jeo auth login openai` ever called it — logging into Anthropic or Antigravity left the account pinned to the maintained static catalog snapshot until the next unrelated live-discovery call happened to run.
-- **[0.9.16]** (2026-08-18) — Routing looked broken while it was actually working: the idle status bar and `/compact`/`/handoff` never reflected which model `routePrompt` actually routed to.
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/README.zh.md

@@ -317,10 +317,10 @@ CI 通过 `.github/workflows/npm-publish.yml` 发布 — GitHub 发布 release
 
 <!-- CHANGELOG:START (auto-generated from CHANGELOG.md — run `bun run changelog:sync`) -->
 - **[Unreleased]**
+- **[0.11.1]** (2026-08-25) — Every non-interactive `jeo` run hung forever once Telegram notifications were configured — `echo "..." | jeo`, `jeo -p "..."` in CI, any scripted use. The work completed and the command returned; the process just never exited.
 - **[0.11.0]** (2026-08-25) — One bad boundary check was corrupting agent context, subagent fan-out, and the Telegram daemon's kill safety at the same time — and none of the three looked related from the outside.
 - **[0.10.0]** (2026-08-25) — jeo could only be pointed at ONE user-supplied endpoint (`config.openaiBaseUrl`), and doing so rebound the built-in `openai` provider: it stole the `openai/` routing prefix, collided with real OpenAI model ids, and could not speak the Anthropic Messages protocol at all. There was no way to run a company LiteLLM proxy and a self-hosted vLLM box at the same time, or to reach either from a script.
 - **[0.9.17]** (2026-08-18) — Live model discovery already existed (`listProviderModels`/`discoverModels`), but only `jeo auth login openai` ever called it — logging into Anthropic or Antigravity left the account pinned to the maintained static catalog snapshot until the next unrelated live-discovery call happened to run.
-- **[0.9.16]** (2026-08-18) — Routing looked broken while it was actually working: the idle status bar and `/compact`/`/handoff` never reflected which model `routePrompt` actually routed to.
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jeo-code",
-  "version": "0.11.0",
+  "version": "0.11.1",
   "description": "Clean, highly optimized AI coding agent using spec-first loop",
   "type": "module",
   "main": "src/cli.ts",

package/src/agent/notify/session-endpoint.ts

@@ -229,7 +229,22 @@ export class SessionNotifyEndpoint {
         },
       },
     });
+    // Same reasoning as the poll timer below: a listening socket also keeps the Bun
+    // event loop alive. This server exists to MIRROR a session, never to outlive it,
+    // so it must not be able to decide the process stays up. `stop()` still tears it
+    // down explicitly on the paths that have one — this only removes its veto over exit.
+    (this.server as { unref?: () => void }).unref?.();
     this.pollTimer = setInterval(() => this.broadcastIfChanged(), SNAPSHOT_POLL_MS);
+    // Unref the poll timer so it can NEVER be the reason the process stays alive.
+    // This endpoint mirrors an already-running session; it has no work of its own
+    // worth holding the event loop open for. Left ref'd, any code path that starts
+    // the endpoint but does not reach an explicit `stop()` hangs the process
+    // forever — which is exactly what happened to every non-interactive invocation
+    // (`echo "…" | jeo`, `jeo -p "…"` in CI): the one-shot branch returns long
+    // before the interactive REPL's exit teardown runs. Bun timers do not appear in
+    // `process._getActiveHandles()`, so that hang presented as a process with zero
+    // active handles refusing to exit.
+    (this.pollTimer as { unref?: () => void }).unref?.();
     await fs.mkdir(notifySessionsDir(), { recursive: true, mode: 0o700 });
     const payload = {
       url: `ws://127.0.0.1:${this.server.port}`,

package/src/commands/launch.ts

@@ -1974,239 +1974,250 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
   };
 
   if (isOneShot) {
-    let messageContent = joinedArgs;
-    if (!process.stdin.isTTY && joinedArgs.length === 0) {
-      messageContent = (await Bun.stdin.text()).trim();
-    }
-    if (!messageContent) {
-      console.log("No input provided.");
-      return;
-    }
-    // One-shot piped/`-p` input that is a control slash command must be handled
-    // HERE — never forwarded to the model. `echo "/clear" | jeo` (and Ctrl-D after
-    // a piped command) previously sent the literal "/clear" to the LLM as a prompt:
-    // a slow, flaky, and semantically wrong round-trip. These no-arg session/system
-    // commands have a meaningful one-shot effect (or are simple no-ops) and exit.
-    {
-      const cmd = messageContent.trim();
-      if (cmd === "/exit" || cmd === "/quit") {
-        return;
-      }
-      if (cmd === "/clear" || cmd === "/session new" || cmd === "/session drop" || cmd === "/session delete") {
-        // Reset history to just the system prompt and overwrite the session file so
-        // the persisted transcript matches (a fresh session for /session new and /session drop).
-        history.length = 1;
-        if (sessionId && !flags.noSession) {
-          try {
-            sessionId = (await createSession(cwd, undefined, sessionModel)).id;
-          } catch { /* best-effort: in-memory clear already done */ }
-        }
-        console.log("(history cleared)");
-        return;
-      }
-      if (cmd === "/" || cmd === "/?" || cmd === "/help") {
-        for (const line of formatSlashCommandList("/", skillSlashDetails)) console.log(line);
-        console.log("Tools: read / write / edit / bash / find / search. Sessions persist to .jeo/sessions/.");
-        return;
-      }
-      if (cmd === "/usage") {
-        const cfg = await readGlobalConfig();
-        const ctx: SlashContext = { history, sessionModel, sessionId, cwd, config: cfg };
-        const result = handleUsage(ctx, sessionUsage);
-        if (result && "lines" in result) for (const line of result.lines) console.log(line);
-        return;
-      }
-      if (cmd === "/context") {
-        const cfg = await readGlobalConfig();
-        const ctx: SlashContext = { history, sessionModel, sessionId, cwd, config: cfg };
-        const result = await handleContext(ctx);
-        if (result && "lines" in result) for (const line of result.lines) console.log(line);
-        return;
-      }
-      if (cmd === "/tools") {
-        const cfg = await readGlobalConfig();
-        const ctx: SlashContext = { history, sessionModel, sessionId, cwd, config: cfg };
-        const result = await handleTools(ctx);
-        if (result && "lines" in result) for (const line of result.lines) console.log(line);
-        return;
-      }
-      if (cmd === "/hotkeys") {
-        const cfg = await readGlobalConfig();
-        const ctx: SlashContext = { history, sessionModel, sessionId, cwd, config: cfg };
-        const result = handleHotkeys(ctx);
-        if (result && "lines" in result) for (const line of result.lines) console.log(line);
-        return;
+    // A one-shot run has ~17 exit points below. The session notify endpoint (a
+    // listening socket + a discovery file the Telegram daemon polls) is created for
+    // the WHOLE launch lifetime up at `startSessionNotifyEndpoint`, but its teardown
+    // lives on the interactive REPL's exit path — which none of those 17 returns
+    // reach. The endpoint's socket/timer are unref'd so a leak can no longer HANG the
+    // process, but a one-shot run would still leave a stale discovery file behind for
+    // the daemon to keep dialling. One `finally` covers every exit point.
+    try {
+      let messageContent = joinedArgs;
+      if (!process.stdin.isTTY && joinedArgs.length === 0) {
+        messageContent = (await Bun.stdin.text()).trim();
       }
-      if (cmd === "/handoff" || cmd.startsWith("/handoff ")) {
-        const parsed = parseHandoffCommand(cmd) ?? {};
-        const cfg = await readGlobalConfig();
-        const activeModel = sessionModel || defaultModel;
-        // `Config` (state.ts) predates config-schema.ts's `compaction` field and is
-        // out of this change's scope — read the passthrough-preserved value via a
-        // narrow structural cast instead of widening the shared interface.
-        const focus = parsed.focus ?? (cfg as { compaction?: { handoffFocus?: string } }).compaction?.handoffFocus;
-        const res = await buildHandoffDocument(history, { model: activeModel, focus });
-        for (const line of handoffLines(res, process.stdout.columns)) console.log(line);
+      if (!messageContent) {
+        console.log("No input provided.");
         return;
       }
-      if (cmd === "/theme" || cmd.startsWith("/theme ")) {
-        const decision = decideThemeSlash(cmd, listThemes(), resolveTheme().name);
-        for (const line of decision.lines) console.log(line);
-        if (decision.kind === "set") {
-          process.env.JEO_TUI_THEME = decision.themeName!;
-          await saveConfigPatch(raw => ({ theme: decision.themeName }));
-          // No refreshUiTheme() here — one-shot mode returns immediately after this
-          // block, so there is no live TUI paint state to re-resolve (and
-          // refreshUiTheme is declared later in this closure, out of scope here).
+      // One-shot piped/`-p` input that is a control slash command must be handled
+      // HERE — never forwarded to the model. `echo "/clear" | jeo` (and Ctrl-D after
+      // a piped command) previously sent the literal "/clear" to the LLM as a prompt:
+      // a slow, flaky, and semantically wrong round-trip. These no-arg session/system
+      // commands have a meaningful one-shot effect (or are simple no-ops) and exit.
+      {
+        const cmd = messageContent.trim();
+        if (cmd === "/exit" || cmd === "/quit") {
+          return;
         }
-        return;
-      }
-      if (cmd === "/wiki" || cmd.startsWith("/wiki ")) {
-        const decision = decideWikiSlash(
-          cmd,
-          resolveWikiRoot(await readGlobalConfig()),
-          !!jeoEnv("WIKI_ROOT"),
-        );
-        for (const line of decision.lines) console.log(line);
-        if (decision.kind === "clear") {
-          await saveConfigPatch(() => ({ wikiRoot: undefined }));
-          delete process.env.JEO_WIKI_ROOT;
-          sessionWikiRoot = undefined;
-          await refreshSessionMemory("");
-        } else if (decision.kind === "set") {
-          await saveConfigPatch(() => ({ wikiRoot: decision.persistArg }));
-          process.env.JEO_WIKI_ROOT = decision.root;
-          sessionWikiRoot = decision.root;
-          await refreshSessionMemory("");
+        if (cmd === "/clear" || cmd === "/session new" || cmd === "/session drop" || cmd === "/session delete") {
+          // Reset history to just the system prompt and overwrite the session file so
+          // the persisted transcript matches (a fresh session for /session new and /session drop).
+          history.length = 1;
+          if (sessionId && !flags.noSession) {
+            try {
+              sessionId = (await createSession(cwd, undefined, sessionModel)).id;
+            } catch { /* best-effort: in-memory clear already done */ }
+          }
+          console.log("(history cleared)");
+          return;
         }
-        return;
-      }
-      if (cmd === "/config" || cmd === "/settings") {
-        for (const line of await buildConfigPanelLines({ sessionModel, sessionThinking, sessionId })) console.log(line);
-        return;
-      }
-      if (cmd === "/evolve") {
-        await runEvolveSimulation(animateAsciiArt);
-        return;
-      }
-    }
-    // One skill run (bundle workflow → engine; regular skill → agent turn). Shared by the
-    // single-invocation path and the `$a $b …` chain path so every `$` skill actually runs.
-    const runOneSkillShot = async (inv: SkillInvocation): Promise<void> => {
-      const isBundleWorkflow = isWorkflowSkill(inv.skill.name);
-      if (isBundleWorkflow) {
-        const startMsg: Message = {
-          role: "system",
-          content: `[workflow:${inv.skill.name}:start]${inv.intent ? ` intent: ${inv.intent}` : ""}`
-        };
-        history.push(startMsg);
-        if (sessionId) {
-          await appendMessage(sessionId, startMsg, cwd);
+        if (cmd === "/" || cmd === "/?" || cmd === "/help") {
+          for (const line of formatSlashCommandList("/", skillSlashDetails)) console.log(line);
+          console.log("Tools: read / write / edit / bash / find / search. Sessions persist to .jeo/sessions/.");
+          return;
         }
+        if (cmd === "/usage") {
+          const cfg = await readGlobalConfig();
+          const ctx: SlashContext = { history, sessionModel, sessionId, cwd, config: cfg };
+          const result = handleUsage(ctx, sessionUsage);
+          if (result && "lines" in result) for (const line of result.lines) console.log(line);
+          return;
+        }
+        if (cmd === "/context") {
+          const cfg = await readGlobalConfig();
+          const ctx: SlashContext = { history, sessionModel, sessionId, cwd, config: cfg };
+          const result = await handleContext(ctx);
+          if (result && "lines" in result) for (const line of result.lines) console.log(line);
+          return;
+        }
+        if (cmd === "/tools") {
+          const cfg = await readGlobalConfig();
+          const ctx: SlashContext = { history, sessionModel, sessionId, cwd, config: cfg };
+          const result = await handleTools(ctx);
+          if (result && "lines" in result) for (const line of result.lines) console.log(line);
+          return;
+        }
+        if (cmd === "/hotkeys") {
+          const cfg = await readGlobalConfig();
+          const ctx: SlashContext = { history, sessionModel, sessionId, cwd, config: cfg };
+          const result = handleHotkeys(ctx);
+          if (result && "lines" in result) for (const line of result.lines) console.log(line);
+          return;
+        }
+        if (cmd === "/handoff" || cmd.startsWith("/handoff ")) {
+          const parsed = parseHandoffCommand(cmd) ?? {};
+          const cfg = await readGlobalConfig();
+          const activeModel = sessionModel || defaultModel;
+          // `Config` (state.ts) predates config-schema.ts's `compaction` field and is
+          // out of this change's scope — read the passthrough-preserved value via a
+          // narrow structural cast instead of widening the shared interface.
+          const focus = parsed.focus ?? (cfg as { compaction?: { handoffFocus?: string } }).compaction?.handoffFocus;
+          const res = await buildHandoffDocument(history, { model: activeModel, focus });
+          for (const line of handoffLines(res, process.stdout.columns)) console.log(line);
+          return;
+        }
+        if (cmd === "/theme" || cmd.startsWith("/theme ")) {
+          const decision = decideThemeSlash(cmd, listThemes(), resolveTheme().name);
+          for (const line of decision.lines) console.log(line);
+          if (decision.kind === "set") {
+            process.env.JEO_TUI_THEME = decision.themeName!;
+            await saveConfigPatch(raw => ({ theme: decision.themeName }));
+            // No refreshUiTheme() here — one-shot mode returns immediately after this
+            // block, so there is no live TUI paint state to re-resolve (and
+            // refreshUiTheme is declared later in this closure, out of scope here).
+          }
+          return;
+        }
+        if (cmd === "/wiki" || cmd.startsWith("/wiki ")) {
+          const decision = decideWikiSlash(
+            cmd,
+            resolveWikiRoot(await readGlobalConfig()),
+            !!jeoEnv("WIKI_ROOT"),
+          );
+          for (const line of decision.lines) console.log(line);
+          if (decision.kind === "clear") {
+            await saveConfigPatch(() => ({ wikiRoot: undefined }));
+            delete process.env.JEO_WIKI_ROOT;
+            sessionWikiRoot = undefined;
+            await refreshSessionMemory("");
+          } else if (decision.kind === "set") {
+            await saveConfigPatch(() => ({ wikiRoot: decision.persistArg }));
+            process.env.JEO_WIKI_ROOT = decision.root;
+            sessionWikiRoot = decision.root;
+            await refreshSessionMemory("");
+          }
+          return;
+        }
+        if (cmd === "/config" || cmd === "/settings") {
+          for (const line of await buildConfigPanelLines({ sessionModel, sessionThinking, sessionId })) console.log(line);
+          return;
+        }
+        if (cmd === "/evolve") {
+          await runEvolveSimulation(animateAsciiArt);
+          return;
+        }
+      }
+      // One skill run (bundle workflow → engine; regular skill → agent turn). Shared by the
+      // single-invocation path and the `$a $b …` chain path so every `$` skill actually runs.
+      const runOneSkillShot = async (inv: SkillInvocation): Promise<void> => {
+        const isBundleWorkflow = isWorkflowSkill(inv.skill.name);
+        if (isBundleWorkflow) {
+          const startMsg: Message = {
+            role: "system",
+            content: `[workflow:${inv.skill.name}:start]${inv.intent ? ` intent: ${inv.intent}` : ""}`
+          };
+          history.push(startMsg);
+          if (sessionId) {
+            await appendMessage(sessionId, startMsg, cwd);
+          }
 
-        const harness = createInFlightAbortHarness({
-          captureEsc: false,
-          onAbortNotice: msg => console.log(msg),
-          onHardExit: () => forceExitFromCtrlC(),
-        });
-        const ac = harness.controller;
+          const harness = createInFlightAbortHarness({
+            captureEsc: false,
+            onAbortNotice: msg => console.log(msg),
+            onHardExit: () => forceExitFromCtrlC(),
+          });
+          const ac = harness.controller;
 
-        const opts = {
-          cwd,
-          signal: ac.signal,
-          onProgress: (e: { skill: string; phase: string; detail?: string }) => console.log(`[workflow:${e.skill}] ${e.phase}${e.detail ? ` — ${e.detail}` : ""}`),
-          io: {
-            output: (line: string) => {
-              console.log(line);
+          const opts = {
+            cwd,
+            signal: ac.signal,
+            onProgress: (e: { skill: string; phase: string; detail?: string }) => console.log(`[workflow:${e.skill}] ${e.phase}${e.detail ? ` — ${e.detail}` : ""}`),
+            io: {
+              output: (line: string) => {
+                console.log(line);
+              },
+              // This `$a $b …` one-shot chain runs BEFORE the interactive REPL's
+              // `promptInput`/`rl` exist (this whole dispatch is reached and returns
+              // long before the `const promptInput = …` further down the function
+              // executes) — referencing `promptInput` here throws a TDZ
+              // ReferenceError ("Cannot access 'promptInput' before initialization")
+              // the instant the workflow engine asks its first question. That error
+              // is caught and stashed into session history (never printed to the
+              // terminal), so the visible symptom is just a frozen prompt forever
+              // (the "jeo --tmux $deep-interview hangs" / "$deep-interview hangs"
+              // report). Omitting `input` here is safe and correct: no other
+              // readline exists yet at this point, so deep-interview.ts's own
+              // fallback `createInterface({input: process.stdin, ...})` (used
+              // whenever `opts.io?.input` is absent) has nothing to fight over raw
+              // mode with. The INTERACTIVE `runSkillInvocation` sibling path below
+              // runs AFTER `promptInput` is declared and correctly wires it — do not
+              // "fix" this block by copying that wiring here again.
             },
-            // This `$a $b …` one-shot chain runs BEFORE the interactive REPL's
-            // `promptInput`/`rl` exist (this whole dispatch is reached and returns
-            // long before the `const promptInput = …` further down the function
-            // executes) — referencing `promptInput` here throws a TDZ
-            // ReferenceError ("Cannot access 'promptInput' before initialization")
-            // the instant the workflow engine asks its first question. That error
-            // is caught and stashed into session history (never printed to the
-            // terminal), so the visible symptom is just a frozen prompt forever
-            // (the "jeo --tmux $deep-interview hangs" / "$deep-interview hangs"
-            // report). Omitting `input` here is safe and correct: no other
-            // readline exists yet at this point, so deep-interview.ts's own
-            // fallback `createInterface({input: process.stdin, ...})` (used
-            // whenever `opts.io?.input` is absent) has nothing to fight over raw
-            // mode with. The INTERACTIVE `runSkillInvocation` sibling path below
-            // runs AFTER `promptInput` is declared and correctly wires it — do not
-            // "fix" this block by copying that wiring here again.
-          },
 
-          args: inv.skill.name === "deep-interview" ? (inv.intent ? inv.intent.split(/\s+/) : []) : undefined
+            args: inv.skill.name === "deep-interview" ? (inv.intent ? inv.intent.split(/\s+/) : []) : undefined
 
-        };
+          };
 
-        let ok = false;
-        let reason: string | undefined;
-        try {
-          const res: { ok: boolean; reason?: string } = await runWorkflowEngine(inv.skill.name, opts);
-          ok = res.ok;
-          reason = res.reason;
-        } catch (err: any) {
-          ok = false;
-          reason = err.message;
-        } finally {
-          harness.dispose();
-        }
+          let ok = false;
+          let reason: string | undefined;
+          try {
+            const res: { ok: boolean; reason?: string } = await runWorkflowEngine(inv.skill.name, opts);
+            ok = res.ok;
+            reason = res.reason;
+          } catch (err: any) {
+            ok = false;
+            reason = err.message;
+          } finally {
+            harness.dispose();
+          }
 
-        const endMsg: Message = {
-          role: "system",
-          content: ok
-            ? `[workflow:${inv.skill.name}:finish]`
-            : `[workflow:${inv.skill.name}:abort]${reason ? ` reason: ${reason}` : ""}`
-        };
-        if (sessionId) {
-          await appendMessage(sessionId, endMsg, cwd);
+          const endMsg: Message = {
+            role: "system",
+            content: ok
+              ? `[workflow:${inv.skill.name}:finish]`
+              : `[workflow:${inv.skill.name}:abort]${reason ? ` reason: ${reason}` : ""}`
+          };
+          if (sessionId) {
+            await appendMessage(sessionId, endMsg, cwd);
+          }
+          return;
         }
-        return;
-      }
 
-      const useOneShotTui = shouldUseOneShotTui(flags.noTui);
-      if (!useOneShotTui) {
-        console.log(`▶ Running skill: ${inv.skill.name}${inv.intent ? ` — ${inv.intent}` : ""}`);
-      }
-      const task = buildSkillTask(inv.skill, inv.intent, inv.invokedAs);
-      const { reply, rendered, usage } = await runTurn(task, useOneShotTui, undefined, { userCard: null });
-      if (!rendered) console.log(stripMarkdown(renderMarkdownTables(reply)) + usage);
-      else if (usage) console.log(usage.trim());
-    };
+        const useOneShotTui = shouldUseOneShotTui(flags.noTui);
+        if (!useOneShotTui) {
+          console.log(`▶ Running skill: ${inv.skill.name}${inv.intent ? ` — ${inv.intent}` : ""}`);
+        }
+        const task = buildSkillTask(inv.skill, inv.intent, inv.invokedAs);
+        const { reply, rendered, usage } = await runTurn(task, useOneShotTui, undefined, { userCard: null });
+        if (!rendered) console.log(stripMarkdown(renderMarkdownTables(reply)) + usage);
+        else if (usage) console.log(usage.trim());
+      };
 
-    // `$a $b … [intent]` — run every resolved skill in order; a lone `$skill` is a chain of 1.
-    const skillChain = parseSkillChain(messageContent, resolvedSkills);
-    if (skillChain && skillChain.invocations.length) {
-      if (skillChain.unresolved.length) {
-        console.log(`(skipping unknown skill${skillChain.unresolved.length > 1 ? "s" : ""}: ${skillChain.unresolved.map(u => `$${u}`).join(", ")})`);
+      // `$a $b … [intent]` — run every resolved skill in order; a lone `$skill` is a chain of 1.
+      const skillChain = parseSkillChain(messageContent, resolvedSkills);
+      if (skillChain && skillChain.invocations.length) {
+        if (skillChain.unresolved.length) {
+          console.log(`(skipping unknown skill${skillChain.unresolved.length > 1 ? "s" : ""}: ${skillChain.unresolved.map(u => `$${u}`).join(", ")})`);
+        }
+        if (skillChain.invocations.length > 1) {
+          console.log(`▶ Chaining ${skillChain.invocations.length} skills: ${skillChain.invocations.map(i => `$${i.skill.name}`).join(" → ")}`);
+        }
+        for (const inv of skillChain.invocations) {
+          await runOneSkillShot(inv);
+        }
+        await maybeDistillOneShot();
+        return;
       }
-      if (skillChain.invocations.length > 1) {
-        console.log(`▶ Chaining ${skillChain.invocations.length} skills: ${skillChain.invocations.map(i => `$${i.skill.name}`).join(" → ")}`);
+      // A `$skill` invocation resolves to a single skill (by name, declared alias, or unique prefix).
+      const skillInvocation = parseSkillInvocation(messageContent, resolvedSkills);
+      if (skillInvocation) {
+        await runOneSkillShot(skillInvocation);
+        await maybeDistillOneShot();
+        return;
       }
-      for (const inv of skillChain.invocations) {
-        await runOneSkillShot(inv);
+      try {
+        const { reply, rendered, usage } = await runTurn(messageContent, shouldUseOneShotTui(flags.noTui));
+        if (!rendered) console.log(stripMarkdown(renderMarkdownTables(reply)) + usage);
+        else if (usage) console.log(usage.trim());
+      } catch (err) {
+        console.log(`! ${friendlyProviderError(err)}`);
       }
       await maybeDistillOneShot();
       return;
+    } finally {
+      await sessionNotifyEndpoint?.stop().catch(() => {});
     }
-    // A `$skill` invocation resolves to a single skill (by name, declared alias, or unique prefix).
-    const skillInvocation = parseSkillInvocation(messageContent, resolvedSkills);
-    if (skillInvocation) {
-      await runOneSkillShot(skillInvocation);
-      await maybeDistillOneShot();
-      return;
-    }
-    try {
-      const { reply, rendered, usage } = await runTurn(messageContent, shouldUseOneShotTui(flags.noTui));
-      if (!rendered) console.log(stripMarkdown(renderMarkdownTables(reply)) + usage);
-      else if (usage) console.log(usage.trim());
-    } catch (err) {
-      console.log(`! ${friendlyProviderError(err)}`);
-    }
-    await maybeDistillOneShot();
-    return;
   }
 
   // INTERACTIVE mode