@yjjeong/omg 0.1.0

package/dist/cli/interactive/index.js

@@ -0,0 +1,731 @@
+// omg — interactive chat assembler, moved verbatim from cli.ts
+// runInteractive (Phase 282 refactor 4). The in-process Ink REPL: builds
+// per-tab adapters, the event bus, the permission/ask/hooked-tool brokers,
+// the slash + turn contexts, and runs the main input loop. Pure move —
+// behavior is byte-identical; only the file location and import depths
+// changed.
+import { makeAdapter, } from "../../core/orchestration/orchestrator.js";
+import { RoleRouter, UnknownRoleError } from "../../core/orchestration/roleRouter.js";
+import { contextWindowForProvider } from "../../core/context/contextWindows.js";
+import { RollingUsage, planCapFor } from "../../core/context/usageWindow.js";
+import { loadUsageCache, usageStatusFields } from "../../core/context/usageCache.js";
+import { appendEntry as appendContinuumEntry } from "../../core/continuum/index.js";
+import { buildInjectionPrefix } from "../../core/state/memory.js";
+import { dispatchSlash, } from "../slash.js";
+import { runTurnFor } from "../turn.js";
+import { runProviderLogin } from "../login.js";
+import { makeTabManager } from "./tabManager.js";
+import { makeBrokers } from "./brokers.js";
+import { looksLikeTeamResume } from "./teamHint.js";
+export async function runInteractive(opts) {
+    const router = RoleRouter.default();
+    let config;
+    try {
+        config = router.configFor(opts.role);
+    }
+    catch (e) {
+        if (e instanceof UnknownRoleError) {
+            process.stderr.write(`${e.message}\n`);
+            return 2;
+        }
+        throw e;
+    }
+    // Phase 48: provider+model are per-tab. The default tab uses the
+    // CLI-supplied or policy-resolved provider; later tabs created
+    // via /new can pick their own with `--provider <p>`.
+    const defaultProvider = opts.provider === "policy"
+        ? config.llm.provider
+        : opts.provider;
+    const defaultModel = defaultProvider === config.llm.provider ? config.llm.model : "";
+    const adapterOptsBase = { ...opts.adapterOpts };
+    // Phase 160: ask_user is an available tool the model uses if it wants —
+    // we no longer force it via the system prompt. Pushing a model to call
+    // a specific tool is unreliable (it just asks in prose anyway) and only
+    // pollutes the prompt; a plain-text question is a fine normal turn, and
+    // the message queue lets the user answer mid-stream. The picker shows
+    // when the model naturally chooses ask_user.
+    // Force session resume on; bind throttle forwarder later (post-pushStatus).
+    // Phase 238: the forwarder now takes an optional tab so the
+    // throttle status lands on the adapter's owning tab — not on
+    // whichever tab the user happens to be viewing. buildAdapter
+    // accepts a deferred `owningTab` callback because the Tab object
+    // is constructed AFTER the adapter (see makeTab); the callback is
+    // invoked only on stderr fire, by which time the Tab exists.
+    let throttleForwarder = null;
+    // Phase 309: when on, codex-cli adapters are built WITHOUT session
+    // resume so omg sends the full conversation each turn and owns the
+    // context (tab.messages) — which lets /compact + auto-compact actually
+    // shrink it. codex `exec` can't compact its own thread (upstream bugs
+    // openai/codex#16033/#16068; it hard-errors at the window), so this is
+    // the only way to keep a long codex turn under the limit. Phase 333 (W1):
+    // default ON now (explicit OMG_CODEX_STATELESS=0 opts out) — stateless
+    // also re-prepends the behavioral nudges (composeSystem) on every fresh
+    // exec, so codex gets `via claude`-equivalent guidance each turn, not
+    // just the first. Toggled at runtime via /codex-stateless.
+    let codexStateless = process.env.OMG_CODEX_STATELESS !== "0";
+    const buildAdapter = async (provider, model, owningTab) => makeAdapter(provider, model, {
+        ...adapterOptsBase,
+        // Codex stateless mode drops resume so omg manages context.
+        enableSessionResume: !(provider === "codex-cli" && codexStateless),
+        onThrottle: (info) => throttleForwarder?.(info, owningTab?.()),
+        // Phase 243: claudeCli adapter threads this into OMG_TAB_NAME
+        // on each spawn so the PreToolUse hook can name the source
+        // tab when it forwards AskUserQuestion to the broker.
+        getTabName: owningTab ? () => owningTab()?.name : undefined,
+    });
+    // Phase 344: one-shot provider-setup nudge before the TUI takes the
+    // screen. No-op when every required provider is usable, for the stub
+    // provider, or with OMG_SKIP_PREFLIGHT=1.
+    const { runPreflightNudge } = await import("../modes/doctor.js");
+    await runPreflightNudge({ defaultProvider });
+    const { launchInk } = await import("../../ui/launcher.js");
+    // Phase 294: `let` (not const) so /login can unmount Ink, hand the TTY
+    // to a provider login, then repoint this to a fresh session. pushNotif
+    // and the input loop read `ink` through this binding, so reassigning
+    // it after relaunch is enough — no other rewiring of those closures.
+    let ink = launchInk();
+    // Phase 51: pushNotif optionally targets a specific tab so the
+    // turn writer can route to whichever tab owned the user message
+    // — even after the user has /switch'd elsewhere. The default
+    // (no tab) routes to whatever tab is currently active, which is
+    // what slash handlers want.
+    //   - log events (text / thinking / tool_use_* / end / verdict)
+    //     get appended to the target tab's event log so /switch can
+    //     replay them later.
+    //   - the ink push only fires when the target tab is the active
+    //     tab — otherwise the user sees a background-tab's stream
+    //     leaking into the tab they're actively reading.
+    // Phase 240 (audit): `tab.events` had no cap — every event/text
+    // chunk on every turn lived forever, and the auto-compact in Phase
+    // 182 only trimmed `tab.messages` (conversation tokens), not the
+    // event log. A 10-hour session × N tabs reached easy 100K+ entries
+    // per tab. Cap is generous (5000 entries ≈ thousands of chat
+    // rows); when we exceed it we trim the oldest 1000 in one shot so
+    // amortized cost stays at O(1). The user loses oldest scrollback
+    // history, but the trade-off is bounded memory for arbitrarily
+    // long sessions.
+    const EVENTS_CAP = 5000;
+    const EVENTS_TRIM = 1000;
+    const pushNotif = (n, tab) => {
+        const target = tab ?? currentTab();
+        const method = n.method;
+        if (method === "event/text" ||
+            method === "event/thinking" ||
+            method === "event/user_echo" ||
+            method === "event/tool_use_start" ||
+            method === "event/tool_use_progress" ||
+            method === "event/tool_use_end" ||
+            method === "event/end" ||
+            method === "event/verdict") {
+            target.events.push(n);
+            if (target.events.length > EVENTS_CAP) {
+                target.events.splice(0, EVENTS_TRIM);
+            }
+        }
+        if (target === currentTab()) {
+            ink.push(n);
+        }
+    };
+    // Phase 220 (hotfix, post-219 distribution): `tab` parameter routes
+    // the status through pushNotif's `target === currentTab()` filter so
+    // per-tab transient state (teamPhase / teamRoles / etc.) emitted by
+    // a background tab does NOT leak into the currently-displayed tab's
+    // UI. Without the routing, /team on tab 2 while the user was viewing
+    // tab 1 made the team status panel pop up on tab 1.
+    const pushStatus = (s, tab) => {
+        pushNotif({ jsonrpc: "2.0", method: "event/status", params: s }, tab);
+    };
+    // Phase 162: catch handler for fire-and-forget async work. An
+    // uncaught rejection in a `void (async …)()` used to vanish silently
+    // (the team / turn just stalled with no message). Surface it, and —
+    // for a turn — clear the tab's in-flight state so it isn't stuck.
+    const reportAsyncError = (label, tab) => (e) => {
+        if (tab) {
+            tab.inFlight = false;
+            tab.inFlightSince = undefined;
+            tab.cancel = undefined;
+        }
+        pushNotif({
+            jsonrpc: "2.0",
+            method: "event/text",
+            params: {
+                text: `\n[${label} error: ${e instanceof Error ? e.message : String(e)}]\n`,
+            },
+        }, tab);
+    };
+    // Phase 37: bind the throttle forwarder now that pushStatus exists.
+    // Adapter stderr → onThrottle → event/status carrying the resetMs
+    // deadline. UI ticks it down to zero, then auto-clears.
+    // Phase 238: route to the owning tab so a background adapter's 429
+    // doesn't paint the throttle badge on whichever tab the user is
+    // looking at.
+    throttleForwarder = (info, tab) => {
+        // Some lines (bare "429") report no number; show a 5 s default so
+        // the indicator still flashes — better than nothing.
+        const resetMs = info.resetMs > 0 ? info.resetMs : 5_000;
+        pushStatus({
+            throttleUntil: Date.now() + resetMs,
+            throttleReason: info.reason,
+        }, tab);
+    };
+    const slashState = {
+        activeTabName: "main",
+        nextTabSerial: 2,
+        askMode: !!opts.ask,
+        planMode: false,
+        predictMode: true,
+    };
+    // Phase 283 (refactor 4b): the tabs Map and its lifecycle closures
+    // live in tabManager.ts. buildAdapter is injected because it closes
+    // over the throttle forwarder bound just above.
+    const { tabs, makeTab, persistTabs, currentTab, tabIndex, readyCount, snapshotTabsState, renameTab, maybeAutoName, } = await makeTabManager({
+        slashState,
+        buildAdapter,
+        defaultProvider,
+        defaultModel,
+    });
+    // Phase 284 (refactor 4b): the permission / ask / hooked-tool brokers,
+    // their pending-reply maps, findAskingTab, and the AskUserQuestion
+    // handler live in brokers.ts. They round-trip through the Ink UI, so
+    // ink + the event bus + the tab accessors are injected. The factory
+    // sets the OMG_*_SOCKET env vars; the finally below owns the deletes.
+    const brokers = await makeBrokers({
+        ink,
+        slashState,
+        tabs,
+        currentTab,
+        pushStatus,
+        snapshotTabsState,
+    });
+    // Phase 340: the resolved value carries optional image attachments
+    // (absolute paths) alongside the text so a turn can attach images.
+    let userInputResolver = null;
+    let quitRequested = false;
+    // Phase 120 → 155: next-message prediction (/predict). Default ON —
+    // each turn fires a small (haiku) inference to ghost the likely next
+    // message. `/predict off` disables it for the session.
+    const sessionStartedAt = Date.now();
+    // Phase 45: rolling-window usage trackers. Each adapter usage chunk
+    // (output_tokens for that turn) feeds these; the bar reads the
+    // resulting sums and a user-supplied cap (if any) to display a %.
+    const usage5h = new RollingUsage(5 * 3600_000);
+    const usageWeekly = new RollingUsage(7 * 24 * 3600_000);
+    // Phase 175 (B2): session total wrapped in an object so the extracted
+    // turn module can mutate it by reference (a context field can't reassign
+    // a parent `let`).
+    const usageSession = { tokens: 0 };
+    const capFiveHour = planCapFor("five_hour");
+    const capWeekly = planCapFor("weekly");
+    const capSession = planCapFor("session");
+    // Phase 112: opt-in usage cache (OMG_USAGE_CACHE). When set, push
+    // the real cap + used numbers from the cache so the status-bar
+    // gauges show true percentages. Re-read each time (the producing
+    // tool refreshes the file independently).
+    const refreshUsageFromCache = () => {
+        const snap = loadUsageCache();
+        if (!snap)
+            return;
+        const fields = usageStatusFields(snap);
+        if (Object.keys(fields).length > 0)
+            pushStatus(fields);
+    };
+    // Phase 229: poll git status for the active tab's cwd every ~5s
+    // and on turn end. Status bar's git field renders branch + diff
+    // line counts in color. Out-of-repo cwds push `git: null` so the
+    // field hides cleanly.
+    const { readGitStatus } = await import("../gitStatus.js");
+    let lastGitCwd = "";
+    const refreshGit = async () => {
+        const t = currentTab();
+        const cwd = t.cwd;
+        lastGitCwd = cwd;
+        try {
+            const status = await readGitStatus(cwd);
+            // Skip the push if the active cwd changed mid-call — the next
+            // poll will catch the new tab.
+            if (lastGitCwd !== cwd)
+                return;
+            pushStatus({ git: status });
+        }
+        catch {
+            pushStatus({ git: null });
+        }
+    };
+    void refreshGit();
+    const gitInterval = setInterval(() => void refreshGit(), 5000);
+    gitInterval.unref?.();
+    // Slash handlers that mutate runInteractive's local state. The TUI
+    // already wipes its own event log for /clear and /reset; here we
+    // also drop our conversation memory + (for /reset) the adapter
+    // session id so the next user message starts a fresh CLI session.
+    // Phase 239: on /close we have to settle any in-flight broker
+    // round-trips that were targeted at the dying tab. The proxy ask
+    // map holds Promise resolvers; if we just drop the tab, those
+    // resolvers stay parked forever (memory leak + the calling broker
+    // thread hangs). Resolve with the NO_ANSWER sentinel so the
+    // adapter side gets a finite reply and clears its own state.
+    const cleanupTabBrokers = (tab) => {
+        // brokers.ts resolves the dying tab's parked ask_user round-trips
+        // with the NO_ANSWER sentinel so the calling broker thread doesn't
+        // hang; the bg-task watcher untrack (Phase 257) stays here because
+        // bgTaskWatcher is built later in this scope.
+        const { dropped } = brokers.cleanupPendingForTab(tab);
+        bgTaskWatcher.untrackTab(tab.name);
+        return { dropped };
+    };
+    const slashCtx = {
+        state: slashState,
+        tabs,
+        ink,
+        adapterOptsBase,
+        pushNotif,
+        pushStatus,
+        currentTab,
+        tabIndex,
+        readyCount,
+        snapshotTabsState,
+        makeTab,
+        renameTab,
+        buildAdapter,
+        cleanupTabBrokers,
+    };
+    // Phase 294: in-TUI provider login. Unmount Ink so the login CLI owns
+    // the real terminal, run it, then relaunch a fresh session and repaint
+    // the active tab. State lives in core (tabs/events), so the new Ink is
+    // just re-fed via log_replace — nothing is lost. Returns the login
+    // exit code. NOTE: the unmount/relaunch path needs a real TTY to
+    // verify; it is a no-op-safe sequence but untested under the sandbox.
+    // Defined after slashCtx so it can repoint slashCtx.ink: pushNotif
+    // reads the `ink` binding (repointed below), but slash handlers reach
+    // the session through `ctx.ink` (e.g. tabs.ts replays pickers via
+    // ctx.ink.push), so that reference must follow the relaunch too.
+    const suspendForLogin = async (provider) => {
+        ink.unmount();
+        await ink.waitUntilExit();
+        const code = await runProviderLogin(provider);
+        ink = launchInk();
+        ink.onOutbound(handleOutbound);
+        slashCtx.ink = ink;
+        // Repaint the active tab into the fresh session (same shape /switch
+        // uses): replace the log wholesale, then re-emit the tab snapshot.
+        const cur = currentTab();
+        ink.push({
+            jsonrpc: "2.0",
+            method: "event/log_replace",
+            params: { events: cur.events },
+        });
+        pushStatus({ tabsState: snapshotTabsState() });
+        return code;
+    };
+    slashCtx.suspendForLogin = suspendForLogin;
+    // Phase 309: toggle codex stateless mode. Flips the flag and, if the
+    // active tab is codex, rebuilds its adapter so the change takes effect
+    // now (rebuild starts a fresh session — the old codex thread, which omg
+    // can't compact, is dropped; omg owns the context from here). Returns
+    // the new state.
+    slashCtx.toggleCodexStateless = async (force) => {
+        codexStateless = force === undefined ? !codexStateless : force;
+        const tab = currentTab();
+        if (tab.provider === "codex-cli") {
+            try {
+                const a = await buildAdapter(tab.provider, tab.model, () => tab);
+                a.setCwd?.(tab.cwd);
+                tab.adapter = a;
+                tab.adapter.resetSession?.();
+                tab.sessionId = undefined;
+                tab.messages.length = 0;
+                pushStatus({ sessionId: "—", tokensIn: 0, tokensOut: 0 }, tab);
+            }
+            catch (e) {
+                reportAsyncError("codex-stateless", tab)(e);
+            }
+        }
+        return codexStateless;
+    };
+    const onSlash = (name, args) => dispatchSlash(name, args, slashCtx);
+    // Phase 294: named so a post-/login relaunch can re-register it on the
+    // fresh InkSession (onOutbound holds a single handler).
+    const handleOutbound = (msg) => {
+        const m = msg;
+        // UI reply (no `method`, has `id`) → resolve against whichever
+        // broker pending-map owns it. brokers.ts holds the three maps.
+        if (brokers.resolvePendingReply(m))
+            return;
+        if (m.method === "user/quit") {
+            quitRequested = true;
+            if (userInputResolver) {
+                userInputResolver({ text: null, attachments: [] });
+                userInputResolver = null;
+            }
+            return;
+        }
+        if (m.method === "user/input") {
+            const text = m.params?.text;
+            // Phase 340: absolute image paths attached to this turn (clipboard
+            // capture / @path), validated to a string[] of non-empty entries.
+            const rawAtt = m.params?.attachments;
+            const attachments = Array.isArray(rawAtt)
+                ? rawAtt.filter((a) => typeof a === "string" && a.length > 0)
+                : [];
+            if (typeof text === "string" && userInputResolver) {
+                // Phase 225 (hotfix, root cause): persist the user echo on
+                // the tab's own event log via pushNotif. Pre-225, App.tsx
+                // pushed the echo only to its local events state; on /switch
+                // the log_replace overwrote App.events with tab.events and
+                // the echo vanished. /team-route echoes were fine because
+                // slash.ts already used pushNotif; only the regular-turn
+                // path was missing the persistence step.
+                const echoTab = currentTab();
+                pushNotif({
+                    jsonrpc: "2.0",
+                    method: "event/user_echo",
+                    params: { text },
+                }, echoTab);
+                // Phase 77: optionally prefix the *first* user message of a
+                // tab with persistent memory bullets. Only fires when the
+                // tab has no prior messages — subsequent turns reuse the
+                // adapter's session and don't need re-injection.
+                let resolved = text;
+                if (process.env.OMG_INJECT_MEMORY &&
+                    echoTab.messages.length === 0) {
+                    const prefix = buildInjectionPrefix();
+                    if (prefix)
+                        resolved = prefix + text;
+                }
+                userInputResolver({ text: resolved, attachments });
+                userInputResolver = null;
+            }
+            return;
+        }
+        if (m.method === "user/slash") {
+            const name = typeof m.params?.name === "string" ? m.params.name : "";
+            const args = typeof m.params?.args === "string" ? m.params.args : "";
+            // Phase 72: persist tab layout after each slash dispatch.
+            // onSlash mutates Tab state for new/switch/close/rename/cd/dup
+            // /team; covering the dispatcher with one save keeps the
+            // individual handlers free of bookkeeping.
+            void onSlash(name, args)
+                .then(() => persistTabs())
+                // Phase 229: cwd may have changed (/cd, /switch, /new) — refresh
+                // git status immediately rather than waiting for the next poll.
+                .then(() => refreshGit())
+                .catch(reportAsyncError("slash"));
+            return;
+        }
+        if (m.method === "user/cancel") {
+            // Phase 149: cancel whatever the active tab is running. The
+            // per-tab hook handles both a plain turn (SIGTERM the adapter)
+            // and a team run (abort the loop + kill every role adapter). Fall
+            // back to the adapter directly for tabs without a hook.
+            const tab = currentTab();
+            if (typeof tab.cancel === "function") {
+                tab.cancel();
+            }
+            else {
+                tab.adapter.cancel?.();
+            }
+            // The dispatcher.run will see the child exit and throw; the catch
+            // block in the turn loop pushes an error event + stream_end.
+            return;
+        }
+        if (m.method === "user/picker_close") {
+            pushNotif({
+                jsonrpc: "2.0",
+                method: "event/text",
+                params: { text: `[sessions] cancelled\n` },
+            });
+            return;
+        }
+        if (m.method === "user/select_session") {
+            const params = m.params;
+            const id = typeof params?.id === "string" ? params.id : "";
+            if (!id)
+                return;
+            const pickedProvider = typeof params?.provider === "string" ? params.provider : "";
+            const tab = currentTab();
+            void (async () => {
+                // Phase 76: if the session belongs to a different provider
+                // than the active tab (cross-provider "all" picker), rebuild
+                // the tab's adapter for that provider first.
+                if (pickedProvider && pickedProvider !== tab.provider) {
+                    try {
+                        const newAdapter = await buildAdapter(pickedProvider, "", () => tab);
+                        newAdapter.setCwd?.(tab.cwd);
+                        tab.adapter = newAdapter;
+                        tab.provider = pickedProvider;
+                        tab.model = "";
+                        pushStatus({
+                            provider: tab.provider,
+                            model: "(default)",
+                            contextWindow: contextWindowForProvider(tab.provider, ""),
+                        });
+                    }
+                    catch (e) {
+                        pushNotif({
+                            jsonrpc: "2.0",
+                            method: "event/text",
+                            params: {
+                                text: `[sessions] failed to switch to ${pickedProvider}: ${e.message}\n`,
+                            },
+                        });
+                        return;
+                    }
+                }
+                // Inject the chosen id into the adapter; runInteractive always
+                // turns enableSessionResume on so the next turn's buildArgs
+                // will use it.
+                tab.adapter.restoreSession?.(id);
+                tab.sessionId = id;
+                tab.messages.length = 0;
+                pushStatus({ sessionId: id, tokensIn: 0, tokensOut: 0 });
+                pushNotif({
+                    jsonrpc: "2.0",
+                    method: "event/text",
+                    params: {
+                        text: `[sessions] resuming ${id.slice(0, 8)}${pickedProvider ? ` on ${pickedProvider}` : ""} — type a message to continue.\n`,
+                    },
+                });
+            })();
+            return;
+        }
+    };
+    ink.onOutbound(handleOutbound);
+    // Phase 340: resolves text + image attachments for the next turn.
+    const waitForUserInput = () => new Promise((resolve) => {
+        userInputResolver = resolve;
+    });
+    // Seed status bar with everything we know up front.
+    pushStatus({
+        role: opts.role,
+        provider: currentTab().provider,
+        model: currentTab().model || "(default)",
+        cwd: currentTab().cwd,
+        mode: "chat",
+        tokensIn: 0,
+        tokensOut: 0,
+        ask: !!opts.ask,
+        plan: slashState.planMode,
+        contextWindow: contextWindowForProvider(currentTab().provider, currentTab().model),
+        sessionStartedAt,
+        toolCalls: 0,
+    });
+    // Phase 112: seed usage gauges from the cache (if configured).
+    refreshUsageFromCache();
+    // Phase 257: claude-cli's `run_in_background` Bash promises a
+    // notification when the task completes, but the print-mode
+    // process exits at end-of-turn — there's no live session to
+    // surface the notification on. The watcher polls the task's
+    // output file and auto-injects a continuation into the owning tab
+    // when the file settles. See bgTasks.ts for the polling heuristic.
+    const { BgTaskWatcher } = await import("../bgTasks.js");
+    const bgTaskWatcher = new BgTaskWatcher((task, output) => {
+        const owning = tabs.get(task.tabName);
+        if (!owning)
+            return; // tab was /closed before the task finished
+        // Truncate massive outputs so the continuation prompt doesn't
+        // blow past the model's context — Read can pull more if needed.
+        const MAX_INLINE = 8000;
+        const trimmed = output.length > MAX_INLINE
+            ? output.slice(0, MAX_INLINE) +
+                `\n\n[…truncated; ${output.length - MAX_INLINE} more bytes available at ${task.outputPath}]`
+            : output;
+        const text = `[Background task completed: ${task.command}]\n\n` +
+            (trimmed.trim().length > 0 ? trimmed : "(no output captured)");
+        // Echo into the owning tab's events so the user sees what just
+        // resumed — without this they'd see a sudden response with no
+        // visible cause.
+        pushNotif({
+            jsonrpc: "2.0",
+            method: "event/text",
+            params: {
+                text: `\n[bg] ${task.command} completed — auto-resuming\n`,
+            },
+        }, owning);
+        // Inject into the owning tab. If a turn is in flight we queue
+        // (same path as type-ahead); if idle, push directly and start a
+        // fresh turn. Either way the message threads through the
+        // adapter's resumed session.
+        if (owning.inFlight) {
+            (owning.queued ??= []).push(text);
+        }
+        else {
+            owning.messages.push({ role: "user", text });
+            void runTurnFor(owning, turnCtx).catch(reportAsyncError("bgtask-resume", owning));
+        }
+    });
+    // Phase 175 (B2): turn execution lives in ./cli/turn.ts. The closures
+    // it replaced captured runInteractive scope; that travels through
+    // turnCtx. runTurn is set after construction so the queued-drain
+    // recursion can re-enter the module function.
+    const turnCtx = {
+        state: slashState,
+        tabs,
+        pushNotif,
+        pushStatus,
+        currentTab,
+        tabIndex,
+        readyCount,
+        snapshotTabsState,
+        maybeAutoName,
+        persistTabs,
+        refreshUsageFromCache,
+        adapterOptsBase,
+        usage: {
+            five: usage5h,
+            weekly: usageWeekly,
+            session: usageSession,
+            capFive: capFiveHour,
+            capWeekly,
+            capSession,
+        },
+        reportAsyncError,
+        runTurn: (tab) => runTurnFor(tab, turnCtx),
+        bgTasks: bgTaskWatcher,
+    };
+    try {
+        // Seed first user input (either from CLI arg or interactive).
+        let firstText;
+        let firstAttachments = [];
+        if (opts.initialPrompt !== undefined && opts.initialPrompt.length > 0) {
+            firstText = opts.initialPrompt;
+        }
+        else {
+            const seed = await waitForUserInput();
+            firstText = seed.text;
+            firstAttachments = seed.attachments;
+        }
+        if (quitRequested || firstText === null)
+            return 0;
+        let pendingText = firstText;
+        // Phase 340: image paths for the pending turn (cleared after consumed).
+        let pendingAttachments = firstAttachments;
+        while (!quitRequested) {
+            if (pendingText !== null) {
+                const owning = currentTab();
+                // Phase 287 (B): on a team-* tab, a chat message that reads like
+                // "resume the team" can't drive omg's /team pipeline — it only
+                // talks to this tab's single adapter. Surface a one-line hint
+                // (non-blocking; the turn still runs) pointing at /team.
+                // Phase 287 (B) / 288: the team-resume hint only applies to a
+                // solo follow-up turn (input goes to this tab's single adapter).
+                // During an active team pipeline, mid-run input IS folded into
+                // the team as checkpoint steering, so suppress the misleading
+                // "single adapter only" hint while teamInFlight.
+                if (owning.name.startsWith("team-") &&
+                    !owning.teamInFlight &&
+                    looksLikeTeamResume(pendingText)) {
+                    pushNotif({
+                        jsonrpc: "2.0",
+                        method: "event/text",
+                        params: {
+                            text: "[team] omg 팀은 슬래시 명령으로 동작합니다 — 멀티역할로 다시 실행하려면 `/team <작업>`을 쓰세요. (이 메시지는 이 탭의 단일 어댑터로만 전달됩니다.)\n",
+                        },
+                    }, owning);
+                }
+                if (owning.inFlight) {
+                    // Phase 159 / 288: queue it. On an active team pipeline this is
+                    // checkpoint steering — the runner drains tab.queued at the next
+                    // role boundary and folds it into the implementer. On any other
+                    // in-flight turn it's plain type-ahead (claude-cli print mode
+                    // can't be steered mid-turn), auto-sent when the turn ends.
+                    (owning.queued ??= []).push(pendingText);
+                    const steering = owning.teamInFlight === true;
+                    pushNotif({
+                        jsonrpc: "2.0",
+                        method: "event/text",
+                        params: {
+                            text: steering
+                                ? `[steering] 다음 역할 경계에서 팀 implementer에 반영됩니다 (${owning.queued.length} 대기). Esc는 팀 전체를 취소합니다.\n`
+                                : `[queued] will send when the current turn ends (${owning.queued.length} waiting). Esc cancels the current turn to send sooner.\n`,
+                        },
+                    });
+                }
+                else {
+                    // Phase 340: attach this turn's images (idle send only; ephemeral).
+                    owning.messages.push(pendingAttachments.length > 0
+                        ? { role: "user", text: pendingText, attachments: pendingAttachments }
+                        : { role: "user", text: pendingText });
+                    // Phase 201b: mirror to the continuum so the persistent
+                    // transcript captures user prompts across sessions.
+                    if (owning.continuumId) {
+                        try {
+                            appendContinuumEntry(owning.continuumId, {
+                                version: 1,
+                                kind: "user",
+                                text: pendingText,
+                                ts: Date.now(),
+                                tabName: owning.name,
+                            });
+                        }
+                        catch {
+                            /* continuum write best-effort */
+                        }
+                    }
+                    // Fire-and-forget: don't await. The main loop loops back
+                    // to waitForUserInput so the user can switch tabs / start
+                    // another turn elsewhere immediately.
+                    void runTurnFor(owning, turnCtx).catch(reportAsyncError("turn", owning));
+                }
+                pendingText = null;
+                pendingAttachments = [];
+            }
+            const next = await waitForUserInput();
+            if (quitRequested || next.text === null)
+                break;
+            pendingText = next.text;
+            pendingAttachments = next.attachments;
+        }
+        // Phase 207: cancel ALL adapter children (and any tab.cancel
+        // wired by /team) and put a hard ceiling on the cleanup wait.
+        // Pre-Phase-207, an in-flight haiku from continuum auto-digest
+        // or a /team's per-role pool would keep the process alive for
+        // ~30s while the user wondered if /q was even acknowledged.
+        for (const t of tabs.values()) {
+            try {
+                t.cancel?.();
+            }
+            catch {
+                /* tab cancel best-effort */
+            }
+            try {
+                t.adapter.cancel?.();
+            }
+            catch {
+                /* adapter cancel best-effort */
+            }
+        }
+        // Brief grace for cancels to land + writers to drain.
+        const deadline = Date.now() + 1_000;
+        while (Date.now() < deadline) {
+            const busy = [...tabs.values()].filter((t) => t.inFlight);
+            if (busy.length === 0)
+                break;
+            await new Promise((r) => setTimeout(r, 25));
+        }
+        return 0;
+    }
+    finally {
+        ink.close();
+        // Phase 207: hard cap on shutdown. Brokers / continuum digest /
+        // detached children that haven't drained get cut off here so /q
+        // can't appear to hang. waitUntilExit + broker.close races a
+        // 1.5s ceiling; whichever finishes first wins.
+        const SHUTDOWN_CEILING_MS = 1_500;
+        const ceiling = new Promise((resolve) => setTimeout(resolve, SHUTDOWN_CEILING_MS));
+        // Phase 257: stop the bg-task polling timer so node can exit
+        // cleanly on /quit even if a task was mid-watch.
+        bgTaskWatcher.close();
+        const drain = Promise.all([
+            ink.waitUntilExit(),
+            brokers.permBroker.close(),
+            brokers.askBroker.close(),
+            brokers.hookedToolBroker.close(),
+        ]).then(() => undefined);
+        await Promise.race([drain, ceiling]);
+        delete process.env.OMG_PERMISSION_SOCKET;
+        delete process.env.OMG_ASK_SOCKET;
+        delete process.env.OMG_HOOKED_TOOL_SOCKET;
+        delete process.env.OMG_HOOKED_TOOLS;
+    }
+}
+//# sourceMappingURL=index.js.map