@dsh-cc/tui 0.5.0

package/lib/harness/driver-pickers.js

@@ -0,0 +1,249 @@
+/**
+ * Model / effort / permission pickers for the in-process driver. Verbatim
+ * extraction from harness/driver.ts (openModelPicker / applyModelSwitch /
+ * openEffortPicker / openPermissionPicker plus the return-literal picker
+ * bodies), reading shared state through a DriverPickersCtx instead of
+ * createDriver's closures.
+ *
+ * The pickers are stateless overlays: each open parks picker state and each
+ * submit reads-then-closes before validating. The bare model switch writes
+ * synchronously; a carried effort validates detached via resolveEfforts /
+ * stalePair, kept in createDriver and passed in.
+ * @module @dsh-cc/tui/harness/driver-pickers
+ */
+import { ReasoningEffortId } from '@deepseek-ai/dsh-llm';
+import { BYPASS_MODE, PERMISSION_MODE_OPTIONS } from '@dsh-cc/command-permissions';
+import { moveEffortPickerFocus, moveModelPickerFocus, movePermissionPickerFocus, setEffortPicker, setModelPicker, setPermissionPicker, upsertRow, } from "../store.js";
+import { formatModelCatalog } from "../model-catalog.js";
+/**
+ * Free-function collaborator implementing the three pickers. Reads all shared
+ * state/functions off `rt` (DriverPickersCtx) so it never imports the
+ * createDriver factory. `selection` is passed by reference so writes land on
+ * createDriver's live ref across switchSession; resolveEfforts / stalePair /
+ * loadCatalog stay in createDriver and arrive on the ctx.
+ */
+export function createPickersSection(rt) {
+    // `/model` (no args) opens a modal picker instead of dumping a text catalog.
+    // The arg path (`/model <n|provider/id>`) stays text-based for scripts.
+    const openModelPicker = async () => {
+        const catalog = await rt.loadCatalog();
+        const currentRoute = rt.selection.current === undefined
+            ? undefined
+            : { provider: rt.selection.current.provider, model: rt.selection.current.model };
+        if (catalog.length === 0) {
+            rt.emit(upsertRow(rt.state(), { kind: 'status', text: formatModelCatalog(catalog, currentRoute) }));
+            return;
+        }
+        const entries = catalog.map(entry => ({
+            provider: entry.provider,
+            id: entry.id,
+            name: entry.name,
+        }));
+        let focused = 0;
+        if (currentRoute !== undefined) {
+            const index = entries.findIndex(entry => entry.provider === currentRoute.provider && entry.id === currentRoute.model);
+            if (index >= 0)
+                focused = index;
+        }
+        rt.emit(setModelPicker(rt.state(), {
+            entries,
+            focused,
+            ...currentRoute === undefined ? {} : { current: currentRoute },
+        }));
+    };
+    /**
+     * Apply a `/model` switch to `provider`/`model`, carrying the live effort
+     * when the new model still supports it. The bare pair needs no validation,
+     * so the no-carried-effort path writes synchronously in the caller's tick;
+     * the carried path validates via rt.resolveEfforts and degrades to a
+     * bare pair + reset notice when the effort is unsupported OR unresolvable —
+     * the switch itself never fails on validation. The stale-pair guard covers
+     * the detached continuation: a selection that moved while validation was in
+     * flight is never clobbered.
+     */
+    const applyModelSwitch = async (provider, model) => {
+        const captured = rt.selection.current;
+        const carried = captured?.reasoningEffort;
+        if (captured === undefined || carried === undefined) {
+            rt.selection.current = { provider, model };
+            rt.emit(upsertRow(rt.state(), { kind: 'status', text: `Model is now ${provider}/${model}.` }));
+            return;
+        }
+        const efforts = await rt.resolveEfforts(provider, model);
+        if (rt.stalePair(captured))
+            return;
+        const supported = efforts?.some(level => level.id === carried) === true;
+        rt.selection.current = supported
+            ? { provider, model, reasoningEffort: ReasoningEffortId(carried) }
+            : { provider, model };
+        rt.emit(upsertRow(rt.state(), { kind: 'status', text: `Model is now ${provider}/${model}.` }));
+        if (!supported) {
+            rt.emit(upsertRow(rt.state(), {
+                kind: 'status',
+                text: `Effort "${carried}" not supported by ${model}; reset to default.`,
+            }));
+        }
+    };
+    /**
+     * Open the `/effort` picker: resolve the live model's advertised efforts
+     * and park `effortPicker` state — entries are the effort ids plus the
+     * trailing reserved `default` entry, focus on the live effort (the
+     * `default` entry when none is set or it is no longer in the list). Fail
+     * closed: an unresolved model emits the no-model notice and unresolvable
+     * levels emit a notice — never a fabricated list.
+     */
+    const openEffortPicker = async () => {
+        const route = rt.selection.current;
+        if (route === undefined) {
+            rt.emit(upsertRow(rt.state(), { kind: 'status', text: 'No model configured. Use /model first.' }));
+            return;
+        }
+        const efforts = await rt.resolveEfforts(route.provider, route.model);
+        if (efforts === undefined || efforts.length === 0) {
+            rt.emit(upsertRow(rt.state(), { kind: 'status', text: `Cannot resolve effort levels for ${route.model}.` }));
+            return;
+        }
+        const entries = [...efforts.map(level => level.id), 'default'];
+        const index = route.reasoningEffort === undefined ? -1 : entries.indexOf(route.reasoningEffort);
+        rt.emit(setEffortPicker(rt.state(), {
+            entries,
+            focused: index >= 0 ? index : entries.length - 1,
+            current: route.reasoningEffort,
+        }));
+    };
+    /**
+     * Open the `/permissions` picker: park the five CC rule-engine modes,
+     * focused on the live mode (row 0 when the live mode is not in the list).
+     * The overlay always opens — an unmounted engine surfaces as a host-command
+     * error on submit, matching the argued `/permissions <mode>` path.
+     */
+    const openPermissionPicker = () => {
+        const currentMode = rt.liveMode(rt.current.agent);
+        const index = PERMISSION_MODE_OPTIONS.findIndex(option => option.id === currentMode);
+        rt.emit(setPermissionPicker(rt.state(), {
+            entries: PERMISSION_MODE_OPTIONS,
+            focused: index >= 0 ? index : 0,
+            current: currentMode,
+        }));
+    };
+    return {
+        openModelPicker,
+        applyModelSwitch,
+        openEffortPicker,
+        openPermissionPicker,
+        modelPickerMove(delta) {
+            rt.emit(moveModelPickerFocus(rt.state(), delta));
+        },
+        modelPickerSubmit() {
+            const picker = rt.state().modelPicker;
+            if (picker === undefined)
+                return Promise.resolve();
+            const entry = picker.entries[picker.focused];
+            // Read-then-close: capture the focused entry BEFORE the synchronous
+            // close-emit so the overlay never lingers while validation runs.
+            rt.emit(setModelPicker(rt.state(), undefined));
+            if (entry === undefined)
+                return Promise.resolve();
+            // Effort-preserving switch with the stale-pair guard inside; the bare
+            // fast path writes synchronously, a carried effort continues detached.
+            return applyModelSwitch(entry.provider, entry.id);
+        },
+        modelPickerCancel() {
+            rt.emit(setModelPicker(rt.state(), undefined));
+        },
+        effortPickerMove(delta) {
+            rt.emit(moveEffortPickerFocus(rt.state(), delta));
+        },
+        async effortPickerSubmit() {
+            const picker = rt.state().effortPicker;
+            if (picker === undefined)
+                return;
+            const entry = picker.entries[picker.focused];
+            // Read-then-close (mirror modelPickerSubmit): capture the focused entry
+            // BEFORE the synchronous close-emit, then validate+write detached.
+            rt.emit(setEffortPicker(rt.state(), undefined));
+            if (entry === undefined)
+                return;
+            const captured = rt.selection.current;
+            if (captured === undefined) {
+                rt.emit(upsertRow(rt.state(), { kind: 'status', text: 'No model configured. Use /model first.' }));
+                return;
+            }
+            // The reserved `default` entry resets to the bare pair with zero
+            // validation (the provider default is always legal); the stale-pair
+            // guard still applies.
+            if (entry === 'default') {
+                if (rt.stalePair(captured))
+                    return;
+                rt.selection.current = { provider: captured.provider, model: captured.model };
+                rt.emit(upsertRow(rt.state(), { kind: 'status', text: 'Reasoning effort reset to the provider default.' }));
+                return;
+            }
+            const efforts = await rt.resolveEfforts(captured.provider, captured.model);
+            // Stale-pair guard: the captured model must still be the live selection
+            // when the validation continuation resumes — a concurrent /model or
+            // switchSession re-seed in between refuses the write.
+            if (rt.stalePair(captured))
+                return;
+            const level = efforts?.find(candidate => candidate.id === entry);
+            if (level === undefined) {
+                rt.emit(upsertRow(rt.state(), { kind: 'status', text: `Cannot resolve effort levels for ${captured.model}.` }));
+                return;
+            }
+            rt.selection.current = {
+                provider: captured.provider,
+                model: captured.model,
+                reasoningEffort: ReasoningEffortId(level.id),
+            };
+            rt.emit(upsertRow(rt.state(), { kind: 'status', text: `Reasoning effort is now ${level.name}.` }));
+        },
+        effortPickerCancel() {
+            rt.emit(setEffortPicker(rt.state(), undefined));
+        },
+        permissionPickerMove(delta) {
+            rt.emit(movePermissionPickerFocus(rt.state(), delta));
+        },
+        async permissionPickerSubmit() {
+            const picker = rt.state().permissionPicker;
+            if (picker === undefined)
+                return;
+            const entry = picker.entries[picker.focused];
+            if (entry === undefined) {
+                rt.emit(setPermissionPicker(rt.state(), undefined));
+                return;
+            }
+            // bypassPermissions parks an in-overlay confirmation first; a second
+            // enter (or any other mode) closes then writes through the host command.
+            if (entry.id === BYPASS_MODE && picker.confirmingBypass !== true) {
+                rt.emit(setPermissionPicker(rt.state(), { ...picker, confirmingBypass: true }));
+                return;
+            }
+            rt.emit(setPermissionPicker(rt.state(), undefined));
+            await rt.runHarness(`/permissions ${entry.id}`);
+        },
+        permissionPickerCancel() {
+            const picker = rt.state().permissionPicker;
+            if (picker === undefined)
+                return;
+            if (picker.confirmingBypass === true) {
+                const { confirmingBypass: _dropped, ...rest } = picker;
+                rt.emit(setPermissionPicker(rt.state(), rest));
+                return;
+            }
+            rt.emit(setPermissionPicker(rt.state(), undefined));
+        },
+        async loadModelCatalog() {
+            return rt.loadCatalog();
+        },
+        async loadModelEfforts() {
+            const route = rt.selection.current;
+            if (route === undefined)
+                return [];
+            const efforts = await rt.resolveEfforts(route.provider, route.model);
+            if (efforts === undefined)
+                return [];
+            return [...efforts.map(level => level.id), 'default'];
+        },
+    };
+}
+//# sourceMappingURL=driver-pickers.js.map

package/lib/harness/driver-pickers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"driver-pickers.js","sourceRoot":"","sources":["../../src/harness/driver-pickers.ts"],"names":[],"mappings":"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"}

package/lib/harness/driver-promote.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Ctrl+B promotion section (UX plan §3.4): promote every armed foreground
+ * subagent collect of the CURRENT session to background. Structural split of
+ * the same logic from `./driver.ts`.
+ * @module @dsh-cc/tui/harness/driver-promote
+ */
+import type { Context } from '@deepseek-ai/cordis';
+/**
+ * Create the promote handler for one driver instance. The collect path (Task
+ * tool) registers each in-flight foreground collect under parentSessionId +
+ * toolCallToken in the root-realm `ccCollectorRegistry` (published by the
+ * cc-subagent-task plugin, CcPlugins pattern); `promote()` on a handle
+ * releases the wait (`async_launched` + `backgroundedByUser: true` tool
+ * result) and leaves the child untouched — its settlement notice later
+ * delivers normally. Gated by the env kill switch; an absent registry or
+ * session change degrades to 0 (nothing promotable).
+ *
+ * The session filter compares against the LIVE agent's session id via the
+ * `current` holder, so a switch after construction promotes the new session's
+ * collects, exactly like the previous inline closure.
+ */
+export declare function createPromoteSection(ctx: Context, current: {
+    agent: {
+        session: {
+            id: unknown;
+        };
+    };
+}): () => number;
+//# sourceMappingURL=driver-promote.d.ts.map

package/lib/harness/driver-promote.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"driver-promote.d.ts","sourceRoot":"","sources":["../../src/harness/driver-promote.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAA;AAGlD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,oBAAoB,CAClC,GAAG,EAAE,OAAO,EACZ,OAAO,EAAE;IAAE,KAAK,EAAE;QAAE,OAAO,EAAE;YAAE,EAAE,EAAE,OAAO,CAAA;SAAE,CAAA;KAAE,CAAA;CAAE,GAC/C,MAAM,MAAM,CAYd"}

package/lib/harness/driver-promote.js

@@ -0,0 +1,36 @@
+/**
+ * Ctrl+B promotion section (UX plan §3.4): promote every armed foreground
+ * subagent collect of the CURRENT session to background. Structural split of
+ * the same logic from `./driver.ts`.
+ * @module @dsh-cc/tui/harness/driver-promote
+ */
+import { backgroundTasksDisabled } from '@dsh-cc/subagent-task';
+/**
+ * Create the promote handler for one driver instance. The collect path (Task
+ * tool) registers each in-flight foreground collect under parentSessionId +
+ * toolCallToken in the root-realm `ccCollectorRegistry` (published by the
+ * cc-subagent-task plugin, CcPlugins pattern); `promote()` on a handle
+ * releases the wait (`async_launched` + `backgroundedByUser: true` tool
+ * result) and leaves the child untouched — its settlement notice later
+ * delivers normally. Gated by the env kill switch; an absent registry or
+ * session change degrades to 0 (nothing promotable).
+ *
+ * The session filter compares against the LIVE agent's session id via the
+ * `current` holder, so a switch after construction promotes the new session's
+ * collects, exactly like the previous inline closure.
+ */
+export function createPromoteSection(ctx, current) {
+    const promoteForegroundCollects = () => {
+        if (backgroundTasksDisabled())
+            return 0;
+        const registry = ctx.get('ccCollectorRegistry');
+        if (registry?.collectorsForSession === undefined)
+            return 0;
+        const armed = registry.collectorsForSession(String(current.agent.session.id));
+        for (const handle of armed)
+            handle.promote();
+        return armed.length;
+    };
+    return promoteForegroundCollects;
+}
+//# sourceMappingURL=driver-promote.js.map

package/lib/harness/driver-promote.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"driver-promote.js","sourceRoot":"","sources":["../../src/harness/driver-promote.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,EAAE,uBAAuB,EAAE,MAAM,uBAAuB,CAAA;AAE/D;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,oBAAoB,CAClC,GAAY,EACZ,OAAgD;IAEhD,MAAM,yBAAyB,GAAG,GAAW,EAAE;QAC7C,IAAI,uBAAuB,EAAE;YAAE,OAAO,CAAC,CAAA;QACvC,MAAM,QAAQ,GAAI,GAAG,CAAC,GAAG,CAAC,qBAAqB,CAEjC,CAAA;QACd,IAAI,QAAQ,EAAE,oBAAoB,KAAK,SAAS;YAAE,OAAO,CAAC,CAAA;QAC1D,MAAM,KAAK,GAAG,QAAQ,CAAC,oBAAoB,CAAC,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC,CAAA;QAC7E,KAAK,MAAM,MAAM,IAAI,KAAK;YAAE,MAAM,CAAC,OAAO,EAAE,CAAA;QAC5C,OAAO,KAAK,CAAC,MAAM,CAAA;IACrB,CAAC,CAAA;IACD,OAAO,yBAAyB,CAAA;AAClC,CAAC"}

package/lib/harness/driver-queue.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Outbox queue, submit, and interrupt pipeline extracted from harness/driver.ts.
+ * Free-function collaborator: takes a {@link DriverQueueCtx} instead of closing
+ * over createDriver's locals, so the harness factory stays out of this leaf.
+ * @module @dsh-cc/tui/harness/driver-queue
+ */
+import type { DriverQueueCtx } from './driver-ctx.ts';
+/**
+ * Build the queue/sumit/interrupt section of createDriver. `rt` supplies live
+ * state, emit, and neighbor-section seams (bash/local/harness/permission picker).
+ */
+export declare function createQueueSection(rt: DriverQueueCtx): {
+    flushQueue(): void;
+    steerQueued(): void;
+    recallQueued(): string | undefined;
+    submit(text?: string): Promise<void>;
+    interrupt(): void;
+};
+//# sourceMappingURL=driver-queue.d.ts.map

package/lib/harness/driver-queue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"driver-queue.d.ts","sourceRoot":"","sources":["../../src/harness/driver-queue.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAeH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAA;AA2QrD;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,EAAE,EAAE,cAAc,GAAG;IACtD,UAAU,IAAI,IAAI,CAAA;IAClB,WAAW,IAAI,IAAI,CAAA;IACnB,YAAY,IAAI,MAAM,GAAG,SAAS,CAAA;IAClC,MAAM,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IACpC,SAAS,IAAI,IAAI,CAAA;CAClB,CAQA"}

package/lib/harness/driver-queue.js

@@ -0,0 +1,281 @@
+/**
+ * Outbox queue, submit, and interrupt pipeline extracted from harness/driver.ts.
+ * Free-function collaborator: takes a {@link DriverQueueCtx} instead of closing
+ * over createDriver's locals, so the harness factory stays out of this leaf.
+ * @module @dsh-cc/tui/harness/driver-queue
+ */
+import { createUserMessage } from '@deepseek-ai/dsh-llm';
+import { LOCAL_SLASH, parseSlash } from "../slash.js";
+import { saveHistory } from "../history.js";
+import { clearQueue, clearTurn, enqueue, popQueued, setBusy, setDraft, setTurnActive, upsertRow, } from "../store.js";
+const asUserMessage = (text) => createUserMessage({
+    content: [{ type: 'text', text }],
+    source: { kind: 'user' },
+});
+/**
+ * Dispatch one queued outbox entry. A queued plugin command (`/codex:review
+ * args`) is re-classified here instead of being forwarded verbatim: flush and
+ * steer otherwise leak the raw slash line to the model as prompt text. A local
+ * name that is NOT a TUI-owned LOCAL_SLASH entry is a plugin command — it
+ * routes through the ccPlugins service. Anything else (plain prose, ordinary
+ * local names) sends as the original followup/steer, unchanged.
+ *
+ * Returns whether the entry was handed off to the agent (raw send or a
+ * successful plugin dispatch) — false means dropped with a notice. flushQueue
+ * uses this to avoid anchoring a busy turn nothing will arrive for.
+ */
+const dispatchQueued = (rt, text, mode) => {
+    const send = (raw) => {
+        const message = asUserMessage(raw);
+        if (mode === 'followup')
+            rt.current.agent.followup(message);
+        else
+            rt.current.agent.steer(message);
+        return true;
+    };
+    const parsed = parseSlash(text);
+    if (parsed.kind !== 'local') {
+        return send(text);
+    }
+    if (LOCAL_SLASH.includes(parsed.name)) {
+        // Ordinary TUI-local names never enter the outbox while busy, but if one
+        // ever does, keep the historical behavior: forward the text verbatim.
+        return send(text);
+    }
+    // Plugin command. The raw-line fallback is reserved for names that are no
+    // longer in the plugin command table (uninstalled between enqueue and
+    // flush) or a vanished service — the same unknown-slash fall-through
+    // philosophy as the submit path. A name that IS still registered but fails
+    // ({ok:false} or reject) must never reach the model as raw slash text: it
+    // surfaces a notice instead and the queued line is dropped.
+    const plugins = rt.ctx.get('ccPlugins');
+    if (plugins === undefined || typeof plugins.runPluginCommand !== 'function') {
+        return send(text);
+    }
+    const { name, rawInput } = parsed;
+    // Live membership check against the CURRENT table, mirrored at failure
+    // time: a name that left the table degrades to the raw line; a name that is
+    // still registered keeps the line local.
+    const stillListed = () => {
+        if (typeof plugins.listPluginCommands !== 'function')
+            return true;
+        try {
+            return plugins.listPluginCommands().some(c => c.name.toLowerCase() === name);
+        }
+        catch {
+            return true; // undecidable → keep the line local, never raw-send
+        }
+    };
+    const failWithNotice = (reason) => {
+        rt.showNotice(`Plugin command /${name} failed: ${reason}`);
+        return false;
+    };
+    return plugins.runPluginCommand(name, { agent: rt.current.agent, rawInput })
+        .then((result) => {
+        if (!(result !== null && typeof result === 'object' && result.ok === false))
+            return true;
+        if (!stillListed())
+            return send(text);
+        const reason = result.reason ?? 'unknown error';
+        return failWithNotice(reason);
+    })
+        .catch((error) => {
+        if (!stillListed())
+            return send(text);
+        return failWithNotice(error instanceof Error ? error.message : String(error));
+    });
+};
+/**
+ * Outbox flush, anchored to the durable `turn/end` event: snapshot the queue,
+ * dispatch every entry FIFO through `followup`, and clear the queue in one
+ * atomic stroke — so the queue never holds an entry that was already sent and
+ * ↑ recall cannot race a flush. Busy is re-asserted optimistically (the
+ * flushed followups start a new turn immediately; the fold's `turn/end`
+ * handling just set it false), but only when at least one entry was handed
+ * off.
+ *
+ * The stroke is deferred until the agent converges to idle (agent.whenIdle,
+ * falling back to one microtask for hosts without it). Two hazards force the
+ * wait, both proven by live e2e:
+ *
+ * 1. The call sites are `session/event` observers running INSIDE the session
+ *    append publication window; `followup` → `inbox.splice` appends
+ *    `agent/inbox/spliced` synchronously and hits the session reentrancy
+ *    guard ("session append cannot reenter while another append is being
+ *    published").
+ * 2. A bare microtask lands in the driver teardown gap: kick()'s loop already
+ *    made its last inbox claim but setPhase(idle) hasn't run, so wakeDriver
+ *    takes the non-idle branch — which neither latches the wake (not an
+ *    abort/maintenance) nor has a live driver to claim the work. The spliced
+ *    message strands in the inbox and the UI sits on a zombie busy anchor.
+ *    whenIdle resolves only after kick's finally sets the idle phase, where
+ *    wakeDriver's idle path reliably starts the next driver.
+ */
+const flushQueue = (rt) => {
+    const flush = () => {
+        const s = rt.state();
+        const pending = [...s.queued];
+        if (pending.length === 0)
+            return;
+        rt.emit(clearQueue(s));
+        const handedOff = pending.map(text => dispatchQueued(rt, text, 'followup'));
+        // Anchor the followup turn only once we know at least one entry was
+        // actually handed off: an all-dropped flush (e.g. a plugin command that
+        // failed with a notice) must not leave a zombie busy spinner behind.
+        void Promise.all(handedOff).then(results => {
+            if (!results.some(Boolean))
+                return;
+            rt.emit(setTurnActive(setBusy(rt.state(), true), { startedAt: Date.now(), outputBase: s.hud?.tokens?.output }));
+        });
+    };
+    // Await the agent that ENDED the turn (captured now); dispatchQueued reads
+    // rt.current.agent at fire time, so a session switch still targets the
+    // live session. A rejected whenIdle must not strand the queue.
+    const endingAgent = rt.current.agent;
+    if (typeof endingAgent.whenIdle === 'function') {
+        void endingAgent.whenIdle().then(flush, flush);
+    }
+    else {
+        queueMicrotask(flush);
+    }
+};
+/**
+ * Ctrl+S queue-jump: inject every queued entry into the RUNNING turn
+ * immediately — same synchronous snapshot-then-clear discipline as
+ * {@link flushQueue}, but via `agent.steer` and without a busy flip (the
+ * turn is already running).
+ */
+const steerQueued = (rt) => {
+    const s = rt.state();
+    const pending = [...s.queued];
+    if (pending.length === 0)
+        return;
+    for (const text of pending) {
+        // Semantic trade-off: a queued plugin command reaches the running turn as
+        // a followup (queued work) rather than a steer — running it through the
+        // plugin seam is more important than steering semantics.
+        void dispatchQueued(rt, text, 'steer');
+    }
+    rt.emit(clearQueue(s));
+};
+/**
+ * Recall for editing: pop the most recent queued entry back out of the outbox
+ * and hand it to the caller (root.ts puts it into the composer). Race-free by
+ * construction — flush and steer always clear synchronously, so the queue only
+ * ever holds entries that were never sent.
+ */
+const recallQueued = (rt) => {
+    const popped = popQueued(rt.state());
+    if (popped.text === undefined)
+        return undefined;
+    rt.emit(popped.state);
+    return popped.text;
+};
+const submit = async (rt, text) => {
+    const draft = text ?? rt.state().draft;
+    if (draft.trim().length === 0)
+        return;
+    rt.emit(setDraft(rt.state(), ''));
+    // A leading `!` marks a LOCAL shell command no matter how the text was
+    // entered — typed in shell mode or pasted wholesale. It runs even while
+    // the agent is busy (a local command never touches the turn) and is neither
+    // a prompt nor a slash command.
+    if (draft.startsWith('!')) {
+        await rt.runShellCommand(draft.slice(1));
+        return;
+    }
+    const parsed = parseSlash(draft);
+    if (parsed.kind === 'local') {
+        await rt.runLocal(parsed.name, parsed.rawInput);
+        return;
+    }
+    if (parsed.kind === 'harness') {
+        // Bare `/permissions` is the TUI analogue of the browser popupSelect
+        // decoration: open the overlay instead of dumping the rule listing.
+        // `/permissions <mode>` stays scriptable through the host command.
+        if (/^\/permissions$/i.test(parsed.line)) {
+            rt.openPermissionPicker();
+            return;
+        }
+        // An empty name segment (bare `/` or `/   `) is not a command, a skill,
+        // or a prompt worth a model turn.
+        const name = parsed.line.slice(1).split(/\s/, 1)[0] ?? '';
+        if (name.length === 0) {
+            rt.showNotice('Empty slash command.');
+            return;
+        }
+        const result = await rt.runHarness(parsed.line);
+        if (result !== undefined) {
+            // A result object (success or error) means a known command ran in the
+            // command plane; `null` means no command registry is mounted (runHarness
+            // already noticed). Neither becomes a prompt.
+            return;
+        }
+        // Unknown name: fall through to the prompt path below. This is the whole
+        // user-invocable-skill mechanism — the TUI never decides "is this a
+        // skill?"; the host's closed-set matching does. The followup message
+        // below MUST keep `source: { kind: 'user' }` because dsh-tool-skill's
+        // pre-step gesture boundary only scans `source.kind === 'user'` messages;
+        // if the name is a user-invocable skill it injects <skill_content>, and
+        // otherwise the line stays ordinary prose.
+    }
+    // W4 await-late seam: the boot seed (deployment default model) must be
+    // SETTLED before this turn is enqueued or dispatched — the harness
+    // snapshots `selection.current` at the start of prompt assembly
+    // (@deepseek-ai/dsh-agent model-selection.ts `system-prompt/assemble`),
+    // so dispatching earlier would run the turn with an undefined model.
+    // Local `!` shell lines and slash commands above already returned.
+    await rt.waitForModel();
+    // Persist the prompt (not slash commands — they are commands, not prompts,
+    // and would dilute the recall signal; an unknown slash IS a prompt and
+    // persists here via the fall-through above). Consecutive duplicates and the
+    // cap are handled inside saveHistory. This is also the first real-content
+    // signal: mark the session so the launcher can resume it.
+    rt.setHistory(saveHistory([...rt.getHistory(), draft], rt.historyDir));
+    rt.setMarkedContent(true);
+    rt.persistResumeTarget();
+    const s = rt.state();
+    if (s.busy) {
+        // Outbox: park the text as a pending chip only. It reaches the agent on
+        // the next durable `turn/end` (flushQueue) or immediately via Ctrl+S
+        // (steerQueued). No injection into the running turn here — that is what
+        // makes recall-then-edit meaningful.
+        rt.emit(enqueue(s, draft));
+        return;
+    }
+    // Idle sends bypass the outbox entirely — the row surfaces from the durable
+    // `user/message` event, and a sent text must not stay recallable.
+    rt.current.agent.followup(createUserMessage({
+        content: [{ type: 'text', text: draft }],
+        source: { kind: 'user' },
+    }));
+    // Anchor the working line at dispatch: elapsed counts from here, the token
+    // delta from the current HUD total (undefined when unseeded — the tokenUsage
+    // rebase pins it on the first change).
+    rt.emit(setTurnActive(setBusy(rt.state(), true), { startedAt: Date.now(), outputBase: s.hud?.tokens?.output }));
+};
+const interrupt = (rt) => {
+    rt.current.agent.cancel({ kind: 'user' });
+    // cancel discards queued/steering inbox items; mirror that in UI state.
+    // Clearing BEFORE the abort's turn/end lands also guarantees the flush
+    // anchor finds an empty queue — an interrupt never resurrects entries.
+    // The working-line anchor clears with the turn.
+    rt.emit(upsertRow(clearTurn(clearQueue(setBusy(rt.state(), false))), {
+        kind: 'status',
+        text: 'Interrupted by user.',
+    }));
+};
+/**
+ * Build the queue/sumit/interrupt section of createDriver. `rt` supplies live
+ * state, emit, and neighbor-section seams (bash/local/harness/permission picker).
+ */
+export function createQueueSection(rt) {
+    return {
+        flushQueue: () => flushQueue(rt),
+        steerQueued: () => steerQueued(rt),
+        recallQueued: () => recallQueued(rt),
+        submit: (text) => submit(rt, text),
+        interrupt: () => interrupt(rt),
+    };
+}
+//# sourceMappingURL=driver-queue.js.map