jeo-code 0.9.12 → 0.9.14

package/CHANGELOG.md

@@ -8,6 +8,36 @@ The README mirrors the latest 5 entries — regenerate with `bun run changelog:s
 
 ## [Unreleased]
 
+## [0.9.14] - 2026-08-04
+_A `$a $b … [intent]` skill-chain invocation of a bundled workflow skill (deep-interview/ralplan/team/ultragoal) hung forever with no error and no prompt._
+
+### Fixed
+- **`$a $b …` skill-chain workflow invocations hung silently** (`src/commands/launch.ts`) — the chain path (`runOneSkillShot`) wired `io.output` to a bundled workflow engine but omitted `io.input`. `runDeepInterviewEngine` (and the other workflow engines) only spin up their own `readline.Interface` on `process.stdin` when `opts.io?.input` is absent; the interactive REPL already owns a `readline.Interface` on the same stdin via `promptInput`, so the two interfaces silently fought over raw mode — no prompt was ever drawn and no input was ever delivered, so the workflow just hung forever. The sibling single-invocation path (`runSkillInvocation`) already wired `promptInput` through `io.input`; the chain path now does the same (including the preview-arm/disarm dance around the prompt).
+
+### Verified
+- `bun run typecheck` clean.
+- `test/deep-interview-noninteractive.test.ts`, `test/launch-flags.test.ts` pass.
+- `test/launch-repl-eof.test.ts`'s 2 failures are pre-existing (reproduce identically on the unmodified branch).
+
+
+## [0.9.13] - 2026-08-03
+_The provider-login browser tab now actually goes away — by itself on macOS, by a working button everywhere else._
+
+### Fixed
+- **The OAuth login tab stayed open after "Login complete"** (`src/auth/callback-server.ts`, new `src/auth/browser-tab.ts`) — two separate defects:
+  - The page decided whether the close worked from `window.close()`'s return value, which is `undefined` on EVERY browser. The failure branch therefore always ran and hid the "Close" button on the first countdown tick, so the tab was left open with its only manual control gone. Success is now inferred from the document actually going away (`pagehide` / `document.hidden`); the button stays visible and re-attempts on every press, and the countdown hint is replaced by an explicit "press ⌘W / Ctrl+W" instruction only when the browser refuses.
+  - `window.close()` cannot close a tab the page's own script did not open, and jeo hands the auth URL to the OS (`open` / `xdg-open` / `start`), so the request was always ignored. jeo now closes the tab from the OUTSIDE on macOS: after the callback page is served, it lists running processes (no Automation permission needed), builds an AppleScript naming ONLY the browsers that are actually running, and closes just the tabs whose URL contains this login's `localhost:<port>/callback`. `window.open("","_self")` is also tried first for the engines that still honor the legacy self-adopt, and the countdown is 3s instead of 5s.
+- **A single missing browser silently disabled the whole close script** — AppleScript resolves app terminology at COMPILE time, which `try` cannot guard, so one static `tell application "Arc"` block on a machine without Arc made the entire script fail to compile and close nothing (`osacompile`: "Expected class name but found property"). The script is now generated only for browsers found in the live process list.
+
+### Added
+- `JEO_AUTH_TAB_CLOSE=0` opts out of the OS-level tab close entirely; the attempt is hard-capped at 2s, never surfaces an error, and is skipped when the login finished through a manual code paste (no tab of ours was ever rendered).
+
+### Verified
+- Real Chromium (Playwright) against the actual served page: the scripted close is refused exactly as it is for a real OAuth tab, and the page survives intact — URL unchanged (`window.open("","_self")` does not blank it), "Login complete ✓" still rendered, countdown hint swapped for the manual instruction, Close button still visible; `window.close()` is invoked once by the countdown and again on every button press (the old build stopped after the first).
+- `osacompile` on the generated AppleScript: fails on the full browser list (reproducing the compile bug) and compiles cleanly for the running-process-derived list.
+- `closeAuthTab` against a live loopback callback URL returns in ~2s without hanging when macOS withholds Automation permission, so a login can never stall behind it.
+- Suites: oauth, browser-tab, openai-oauth, antigravity-login, kimi-oauth, oauth-lock, auth-matrix, doctor — 53 pass / 0 fail. `bun run typecheck` clean, `bun run pack:check` 283 files.
+
 ## [0.9.12] - 2026-08-02
 _Fixes the boxed prompt's stolen keystrokes, drifting caret, and paste/attachment spacing under `jeo --tmux`._
 

package/README.ja.md

@@ -287,10 +287,10 @@ CI は `.github/workflows/npm-publish.yml` で公開します — GitHub リリ
 
 <!-- CHANGELOG:START (auto-generated from CHANGELOG.md — run `bun run changelog:sync`) -->
 - **[Unreleased]**
+- **[0.9.14]** (2026-08-04) — A `$a $b … [intent]` skill-chain invocation of a bundled workflow skill (deep-interview/ralplan/team/ultragoal) hung forever with no error and no prompt.
+- **[0.9.13]** (2026-08-03) — The provider-login browser tab now actually goes away — by itself on macOS, by a working button everywhere else.
 - **[0.9.12]** (2026-08-02) — Fixes the boxed prompt's stolen keystrokes, drifting caret, and paste/attachment spacing under `jeo --tmux`.
 - **[0.9.11]** (2026-07-30) — Imports GJC v5 sessions safely, exposes bounded slash controls, and gates the release artifact before publication.
-- **[0.9.10]** (2026-07-27) — `jeo update` now verifies the binary you actually run, and recovers from bun's stale registry cache.
-- **[0.9.9]** (2026-07-27) — Root-causes the frozen `jeo --tmux` TUI: the window was pinned to its launch size, so resizing the terminal only cut the view.
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/README.ko.md

@@ -288,10 +288,10 @@ CI는 `.github/workflows/npm-publish.yml`로 배포합니다 — GitHub 릴리
 
 <!-- CHANGELOG:START (auto-generated from CHANGELOG.md — run `bun run changelog:sync`) -->
 - **[Unreleased]**
+- **[0.9.14]** (2026-08-04) — A `$a $b … [intent]` skill-chain invocation of a bundled workflow skill (deep-interview/ralplan/team/ultragoal) hung forever with no error and no prompt.
+- **[0.9.13]** (2026-08-03) — The provider-login browser tab now actually goes away — by itself on macOS, by a working button everywhere else.
 - **[0.9.12]** (2026-08-02) — Fixes the boxed prompt's stolen keystrokes, drifting caret, and paste/attachment spacing under `jeo --tmux`.
 - **[0.9.11]** (2026-07-30) — Imports GJC v5 sessions safely, exposes bounded slash controls, and gates the release artifact before publication.
-- **[0.9.10]** (2026-07-27) — `jeo update` now verifies the binary you actually run, and recovers from bun's stale registry cache.
-- **[0.9.9]** (2026-07-27) — Root-causes the frozen `jeo --tmux` TUI: the window was pinned to its launch size, so resizing the terminal only cut the view.
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/README.md

@@ -295,10 +295,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.9.14]** (2026-08-04) — A `$a $b … [intent]` skill-chain invocation of a bundled workflow skill (deep-interview/ralplan/team/ultragoal) hung forever with no error and no prompt.
+- **[0.9.13]** (2026-08-03) — The provider-login browser tab now actually goes away — by itself on macOS, by a working button everywhere else.
 - **[0.9.12]** (2026-08-02) — Fixes the boxed prompt's stolen keystrokes, drifting caret, and paste/attachment spacing under `jeo --tmux`.
 - **[0.9.11]** (2026-07-30) — Imports GJC v5 sessions safely, exposes bounded slash controls, and gates the release artifact before publication.
-- **[0.9.10]** (2026-07-27) — `jeo update` now verifies the binary you actually run, and recovers from bun's stale registry cache.
-- **[0.9.9]** (2026-07-27) — Root-causes the frozen `jeo --tmux` TUI: the window was pinned to its launch size, so resizing the terminal only cut the view.
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/README.zh.md

@@ -287,10 +287,10 @@ CI 通过 `.github/workflows/npm-publish.yml` 发布 — GitHub 发布 release
 
 <!-- CHANGELOG:START (auto-generated from CHANGELOG.md — run `bun run changelog:sync`) -->
 - **[Unreleased]**
+- **[0.9.14]** (2026-08-04) — A `$a $b … [intent]` skill-chain invocation of a bundled workflow skill (deep-interview/ralplan/team/ultragoal) hung forever with no error and no prompt.
+- **[0.9.13]** (2026-08-03) — The provider-login browser tab now actually goes away — by itself on macOS, by a working button everywhere else.
 - **[0.9.12]** (2026-08-02) — Fixes the boxed prompt's stolen keystrokes, drifting caret, and paste/attachment spacing under `jeo --tmux`.
 - **[0.9.11]** (2026-07-30) — Imports GJC v5 sessions safely, exposes bounded slash controls, and gates the release artifact before publication.
-- **[0.9.10]** (2026-07-27) — `jeo update` now verifies the binary you actually run, and recovers from bun's stale registry cache.
-- **[0.9.9]** (2026-07-27) — Root-causes the frozen `jeo --tmux` TUI: the window was pinned to its launch size, so resizing the terminal only cut the view.
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/package.json

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

package/src/auth/browser-tab.ts

@@ -0,0 +1,182 @@
+/**
+ * Best-effort closing of the OAuth callback TAB the login opened.
+ *
+ * Why this exists: the callback page already asks the browser to close itself
+ * (`window.close()` after a short countdown), but every current browser REFUSES
+ * that for a tab the page's own script did not open. jeo hands the auth URL to
+ * the OS (`open` / `xdg-open` / `start`), so the tab is user-opened by that rule
+ * and the request is silently ignored — the login succeeds in the terminal while
+ * a dead "Login complete" tab lingers in the browser (the reported bug).
+ *
+ * The only reliable way to close such a tab is to drive the browser from the
+ * outside. macOS exposes exactly that through AppleScript, so this module builds
+ * a targeted script that closes ONLY tabs whose URL contains the loopback
+ * callback (e.g. `localhost:1455/callback`) — never any other tab — in whichever
+ * of the common browsers is ALREADY running (`is running` never launches one).
+ *
+ * Everything here is best effort and failure-silent: no automation permission, a
+ * browser without an AppleScript dictionary (Firefox), Linux/Windows, or a user
+ * who already closed the tab all end as a no-op. `JEO_AUTH_TAB_CLOSE=0` opts out.
+ */
+import { jeoEnv } from "../util/env";
+
+/** Chromium-family browsers whose AppleScript dictionary exposes `windows`/`tabs`
+ *  with a `URL` property and a `close` command. Safari uses the same shape and is
+ *  appended by {@link closeAuthTabScript}. Firefox has no tab-level dictionary at
+ *  all, so it cannot be driven this way — its tab keeps the page's own fallback. */
+export const APPLESCRIPT_BROWSERS: readonly string[] = [
+  "Google Chrome",
+  "Google Chrome Beta",
+  "Google Chrome Canary",
+  "Chromium",
+  "Brave Browser",
+  "Microsoft Edge",
+  "Vivaldi",
+  "Arc",
+  "Safari",
+];
+
+/** Escape a string for embedding inside an AppleScript double-quoted literal. */
+function escapeAppleScript(value: string): string {
+  return value.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+}
+
+/**
+ * The AppleScript that closes every tab whose URL contains `fragment`.
+ *
+ * One STATIC `tell` block per browser (never a dynamic `tell application appName`):
+ * app-specific terms like `URL of t` only compile inside a literal tell block, so a
+ * variable-driven loop would fail to compile and close nothing.
+ *
+ * Pass ONLY browsers that are actually running (see {@link runningBrowserApps}). A
+ * block naming an app that is not INSTALLED cannot resolve its terminology and
+ * fails at COMPILE time — which `try` cannot catch, since `try` guards runtime
+ * errors only — so one missing browser would sink the whole script and close
+ * nothing (verified with `osacompile`: "Expected class name but found property").
+ * Each block keeps its own `try` + `is running` guard for the runtime races: a
+ * browser quitting mid-script, or a window that refuses the query.
+ */
+export function closeAuthTabScript(fragment: string, browsers: readonly string[] = APPLESCRIPT_BROWSERS): string {
+  const frag = escapeAppleScript(fragment);
+  const blocks = browsers.map(
+    app => `try
+  if application "${escapeAppleScript(app)}" is running then
+    tell application "${escapeAppleScript(app)}"
+      repeat with w in (every window)
+        repeat with t in (every tab of w)
+          try
+            if (URL of t) contains "${frag}" then close t
+          end try
+        end repeat
+      end repeat
+    end tell
+  end if
+end try`,
+  );
+  return blocks.join("\n");
+}
+
+/** The subset of {@link APPLESCRIPT_BROWSERS} currently running, derived from
+ *  `ps -Ax -o comm=` output (each line is an executable path such as
+ *  `/Applications/Google Chrome.app/Contents/MacOS/Google Chrome`). Reading the
+ *  process list needs no Automation permission, so this narrows the generated
+ *  script — and with it the compile surface and the number of permission prompts —
+ *  to the browsers that could actually be holding the callback tab. */
+export function runningBrowserApps(psOutput: string, browsers: readonly string[] = APPLESCRIPT_BROWSERS): string[] {
+  const lines = psOutput.split("\n");
+  return browsers.filter(app => lines.some(line => line.includes(`/${app}.app/`)));
+}
+
+/** The command to run for `platform`, or null when the platform has no reliable
+ *  way to close a tab it did not open (Linux/Windows: no scriptable, browser-
+ *  agnostic tab API — the callback page's own message is the fallback there). */
+export function browserTabCloseCommand(
+  platform: NodeJS.Platform,
+  fragment: string,
+  browsers: readonly string[] = APPLESCRIPT_BROWSERS,
+): string[] | null {
+  if (platform !== "darwin") return null;
+  if (!fragment) return null;
+  return ["osascript", "-e", closeAuthTabScript(fragment, browsers)];
+}
+
+/** The `host:port/path` slice of a redirect URI — the narrowest fragment that still
+ *  identifies THIS login's callback tab (the port is unique per flow/run), so no
+ *  unrelated tab can ever match. Returns "" when the URI cannot be parsed. */
+export function callbackUrlFragment(redirectUri: string): string {
+  try {
+    const url = new URL(redirectUri);
+    return `${url.host}${url.pathname}`;
+  } catch {
+    return "";
+  }
+}
+
+export interface CloseAuthTabOptions {
+  platform?: NodeJS.Platform;
+  env?: Record<string, string | undefined>;
+  /** Hard cap so a hung/permission-prompting osascript can never stall the login.
+   *  The FIRST close on a machine raises macOS's "control Google Chrome" Automation
+   *  prompt; if the user does not answer in time this kills the helper and the page's
+   *  own fallback message takes over. Answering it once makes later logins instant. */
+  timeoutMs?: number;
+  /** Injected for tests; defaults to the real spawn. */
+  spawn?: (cmd: string[]) => { exited: Promise<number>; kill: () => void };
+  /** Running-process listing (`ps -Ax -o comm=`); injected for tests. Returning ""
+   *  means "cannot tell", which is treated as "no known browser running". */
+  listProcesses?: () => string;
+}
+
+/**
+ * Close the browser tab still showing this login's callback page. Resolves `true`
+ * only when the OS accepted the request; every other outcome (unsupported
+ * platform, opt-out, spawn failure, timeout, non-zero exit) resolves `false` and
+ * is silent — the terminal already reported the login result, so this must never
+ * surface an error of its own.
+ */
+export async function closeAuthTab(redirectUri: string, opts: CloseAuthTabOptions = {}): Promise<boolean> {
+  const env = opts.env ?? process.env;
+  if (jeoEnv("AUTH_TAB_CLOSE", env) === "0") return false;
+  const platform = opts.platform ?? process.platform;
+  if (platform !== "darwin") return false;
+  const fragment = callbackUrlFragment(redirectUri);
+  if (!fragment) return false;
+  const listProcesses =
+    opts.listProcesses ??
+    (() => {
+      try {
+        return Bun.spawnSync(["ps", "-Ax", "-o", "comm="], { stdout: "pipe", stderr: "ignore" }).stdout.toString();
+      } catch {
+        return "";
+      }
+    });
+  // Never script a browser that is not running: an uninstalled app breaks the whole
+  // script at compile time, and a running-only list keeps the Automation prompt to
+  // the browser the user actually has open.
+  const browsers = runningBrowserApps(listProcesses());
+  if (browsers.length === 0) return false;
+  const cmd = browserTabCloseCommand(platform, fragment, browsers);
+  if (!cmd) return false;
+  const timeoutMs = opts.timeoutMs ?? 2000;
+  const spawn =
+    opts.spawn ??
+    ((c: string[]) => {
+      const proc = Bun.spawn(c, { stdout: "ignore", stderr: "ignore", stdin: "ignore" });
+      return { exited: proc.exited, kill: () => proc.kill() };
+    });
+  try {
+    const proc = spawn(cmd);
+    let timer: ReturnType<typeof setTimeout> | undefined;
+    const timeout = new Promise<number>(resolve => {
+      timer = setTimeout(() => {
+        try { proc.kill(); } catch { /* already gone */ }
+        resolve(-1);
+      }, timeoutMs);
+    });
+    const code = await Promise.race([proc.exited, timeout]);
+    if (timer) clearTimeout(timer);
+    return code === 0;
+  } catch {
+    return false;
+  }
+}

package/src/auth/callback-server.ts

@@ -9,6 +9,7 @@
  */
 import type { OAuthController, OAuthCredentials } from "./types";
 import { generateState } from "./pkce";
+import { closeAuthTab } from "./browser-tab";
 
 const DEFAULT_TIMEOUT_MS = 300_000;
 // Loopback callback host. `localhost` (not the 127.0.0.1 IP literal) is the intentional
@@ -64,34 +65,58 @@ button:hover{background:#1b1c27}
 <img class="wordmark" alt="jeo" src="${JEO_WORDMARK_DATA_URI}">
 <h1 class="__STATUS__">__TITLE__</h1>
 <p>__MSG__</p>
-<button id="jeo-close" type="button">Close</button>
-<p class="hint">Closing automatically in <span id="jeo-countdown">__SECONDS__</span>s…</p>
-<p class="hint closed" id="jeo-closed-msg">Window closed. You can close this tab.</p>
+<button id="jeo-close" type="button">Close this tab</button>
+<p class="hint" id="jeo-countdown-msg">Closing automatically in <span id="jeo-countdown">__SECONDS__</span>s…</p>
+<p class="hint closed" id="jeo-closed-msg">This browser refuses to close a tab it opened itself — press \u2318W (Ctrl+W) to close it.</p>
 </div>
 <script>__SCRIPT__</script>
 </body></html>`;
 
-// Seconds before the tab auto-closes — applies to BOTH the success and the
-// failure page now (previously only success auto-closed). Pressing "Close"
-// closes immediately without waiting out the countdown. `window.close()` only
-// succeeds on tabs the script itself opened; browsers may ignore it for
-// OS-launched OAuth tabs, so the button remains as the reliable fallback.
-const AUTO_CLOSE_SECONDS = 5;
+// Seconds before the tab tries to close itself — applies to BOTH the success and
+// the failure page (each is a final page that should not linger). Pressing
+// "Close this tab" runs the same attempt immediately, without waiting out the
+// countdown, and stays clickable afterwards.
+const AUTO_CLOSE_SECONDS = 3;
 
 function renderHtml(ok: boolean, msg: string): string {
+  // Closing contract, in order of what actually works:
+  //  1. `window.open("","_self")` before `window.close()` — the legacy self-adopt
+  //     trick that still lets Firefox (and older engines) close an OS-opened tab.
+  //  2. `window.close()` — succeeds only where the tab counts as script-opened.
+  //  3. If the tab is still here a moment later, the browser refused: tell the
+  //     user how to close it and KEEP the button working.
+  //
+  // The old code branched on `window.close()`'s return value — that call returns
+  // `undefined` ALWAYS, so the failure branch fired unconditionally and hid the
+  // Close button on the first tick. That left the tab open with its only manual
+  // control gone (the "인증 브라우저가 종료되지 않는다" report). Success is now
+  // detected by observing that the document is actually going away
+  // (`document.hidden` / the `pagehide` unload path), never by a return value.
+  //
+  // The CLI side additionally closes the tab through the OS on macOS once the
+  // callback lands (`closeAuthTab` in ./browser-tab.ts), which is the only path
+  // that works when the browser refuses the scripted close outright.
   const script = `(function(){
-    var n=${AUTO_CLOSE_SECONDS},el=document.getElementById("jeo-countdown"),btn=document.getElementById("jeo-close"),closedMsg=document.getElementById("jeo-closed-msg"),t;
-    function closeNow(){
-      clearInterval(t);
-      var closed=window.close();
-      if(!closed){
-        btn.style.display="none";
-        el.parentElement.style.display="none";
-        closedMsg.classList.remove("closed");
-      }
+    var n=${AUTO_CLOSE_SECONDS},
+        el=document.getElementById("jeo-countdown"),
+        countdownMsg=document.getElementById("jeo-countdown-msg"),
+        btn=document.getElementById("jeo-close"),
+        closedMsg=document.getElementById("jeo-closed-msg"),
+        t,gone=false;
+    window.addEventListener("pagehide",function(){gone=true;});
+    function showManual(){
+      if(gone||document.hidden)return;
+      if(countdownMsg)countdownMsg.style.display="none";
+      if(closedMsg)closedMsg.classList.remove("closed");
+    }
+    function attemptClose(){
+      if(t){clearInterval(t);t=null;}
+      try{window.open("","_self");}catch(e){}
+      try{window.close();}catch(e){}
+      setTimeout(showManual,250);
     }
-    t=setInterval(function(){n-=1;if(el)el.textContent=String(Math.max(n,0));if(n<=0)closeNow();},1000);
-    if(btn)btn.addEventListener("click",closeNow);
+    t=setInterval(function(){n-=1;if(el)el.textContent=String(Math.max(n,0));if(n<=0)attemptClose();},1000);
+    if(btn)btn.addEventListener("click",attemptClose);
   })();`;
   return PAGE_HTML
     .replace("__STATUS__", ok ? "ok" : "fail")
@@ -110,6 +135,9 @@ export abstract class OAuthCallbackFlow {
   protected fixedRedirectUri?: string;
   #resolve?: (r: CallbackResult) => void;
   #reject?: (e: Error) => void;
+  /** Set for the duration of one `login()`; fired the moment the callback PAGE is
+   *  served, which is the only proof a browser tab of ours exists to close. */
+  #onPageServed?: () => void;
 
   constructor(ctrl: OAuthController, opts: number | OAuthCallbackFlowOptions, callbackPath = DEFAULT_CALLBACK_PATH) {
     this.ctrl = ctrl;
@@ -131,6 +159,11 @@ export abstract class OAuthCallbackFlow {
   async login(): Promise<OAuthCredentials> {
     const state = generateState();
     const { server, redirectUri } = this.#startServer(state);
+    // Whether the browser actually reached the callback page. A manual paste (or a
+    // cancelled/timed-out flow) never rendered a tab of ours, so there is nothing to
+    // close and no reason to pay for an osascript spawn.
+    let servedCallbackPage = false;
+    this.#onPageServed = () => { servedCallbackPage = true; };
     try {
       const { url, instructions } = await this.generateAuthUrl(state, redirectUri);
       this.ctrl.onAuth?.({ url, instructions });
@@ -140,9 +173,23 @@ export abstract class OAuthCallbackFlow {
       return await this.exchangeToken(code, returnedState || state, redirectUri);
     } finally {
       server.stop();
+      this.#onPageServed = undefined;
+      // Close the leftover callback tab from the OUTSIDE (macOS only; see
+      // ./browser-tab.ts). Awaited — a one-shot `jeo auth login` exits as soon as
+      // this returns, so a fire-and-forget spawn would be killed before it ran —
+      // but hard-capped, silent, and never able to fail the login it follows.
+      if (servedCallbackPage) {
+        try { await this.closeBrowserTab(redirectUri); } catch { /* best effort only */ }
+      }
     }
   }
 
+  /** OS-level close of the callback tab (see ./browser-tab.ts). Overridable so tests
+   *  can observe the attempt without driving a real browser. */
+  protected closeBrowserTab(redirectUri: string): Promise<boolean> {
+    return closeAuthTab(redirectUri);
+  }
+
   #startServer(expectedState: string): { server: Bun.Server<unknown>; redirectUri: string } {
     const serve = (port: number) =>
       Bun.serve({
@@ -186,6 +233,7 @@ export abstract class OAuthCallbackFlow {
       message = "Authentication succeeded. Return to the terminal — jeo is ready.";
     }
 
+    this.#onPageServed?.(); // a real browser tab now holds this page — it can be closed
     const resolve = this.#resolve;
     const reject = this.#reject;
     queueMicrotask(() => {

package/src/commands/launch.ts

@@ -2093,8 +2093,18 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
           io: {
             output: (line: string) => {
               console.log(line);
-            }
+            },
+            // Reuse the SAME readline interface the interactive REPL already owns
+            // (via promptInput) instead of letting the workflow engine spin up a
+            // second `readline.Interface` on process.stdin — deep-interview.ts only
+            // creates its own internal rl when `opts.io?.input` is absent, and two
+            // concurrent readline interfaces on one stdin silently fight over raw
+            // mode: no error, no visible prompt, the workflow just hangs forever.
+            // The sibling `runSkillInvocation` path already wires `promptInput`
+            // here; this `$a $b …` chain path must match it.
+            input: () => promptInput("")
           },
+
           args: inv.skill.name === "deep-interview" ? (inv.intent ? inv.intent.split(/\s+/) : []) : undefined
         };