@trenchwork/coder 1.3.0

package/dist/ui/ink/InkPromptController.js

@@ -0,0 +1,667 @@
+/**
+ * InkPromptController — the CLI's prompt controller, backed by the Ink
+ * renderer. Constructed via createPromptController(); it is the only
+ * renderer the shell uses.
+ *
+ * Goal: satisfy every method that src/headless/interactiveShell.ts calls
+ * so the rest of the codebase doesn't notice the swap. Live methods
+ * (status, history, secret mode, menu) drive an Ink reconciler commit;
+ * decorative methods that don't yet have an Ink implementation are
+ * marked as TODOs and behave as no-ops, with the call recorded so
+ * future hardening can fill the gaps with real behaviour rather than
+ * silent drift.
+ *
+ * Renderer shim: interactiveShell.ts also calls a handful of methods
+ * directly via promptController.getRenderer() — addEvent, addOutputTap,
+ * captureInput, clearBuffer, setSecretMode, forceRender. We expose a
+ * facade implementing exactly those.
+ */
+import { EventEmitter } from 'node:events';
+import { cyclePermissionMode, permissionHint, permissionStatusChip } from '../../core/permissionMode.js';
+import { isGenericThinking } from '../../core/thinkingVerbs.js';
+/** Map RendererEventType (UnifiedUIRenderer) to ChatItem.kind. */
+const EVENT_KIND_MAP = {
+    banner: 'banner',
+    system: 'system',
+    error: 'error',
+    response: 'assistant',
+    stream: 'assistant',
+    thought: 'system',
+    tool: 'tool',
+    'tool-call': 'tool',
+    'tool-result': 'toolResult',
+    raw: 'system',
+    streaming: 'system',
+};
+/**
+ * The minimal subset of the legacy UnifiedUIRenderer that
+ * interactiveShell.ts actually calls. Backed by Ink state under the
+ * hood. Method signatures match the legacy renderer exactly — the
+ * caller can't tell which implementation it's holding.
+ */
+class InkRendererShim extends EventEmitter {
+    owner;
+    taps = new Set();
+    resolveCapture = null;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    constructor(owner) {
+        super();
+        this.owner = owner;
+    }
+    addEvent(type, content) {
+        // Always feed the taps first — they observe the raw event stream
+        // even if the type is filtered out of the visible history.
+        for (const tap of this.taps) {
+            try {
+                tap(type, content);
+            }
+            catch { /* tap errors must not break rendering */ }
+        }
+        // Thoughts are the model's pre-response reasoning. Showing them as
+        // plain chat lines (which my previous map did) leaks "The user
+        // just said 'hi' — this is a greeting…" into the visible
+        // transcript right above the actual answer. Drop them from the
+        // chat surface; debug mode can re-enable later.
+        if (type === 'thought' || type === 'streaming')
+            return;
+        if (type === 'stream') {
+            // Coalesce streaming deltas into a single growing assistant
+            // message. Pre-fix this rendered "Hi How can I help you today"
+            // as one word per line because each delta became its own
+            // ChatItem. Now the in-progress message lives in
+            // owner._streamingText and renders in a non-Static slot above
+            // the prompt; on the next non-stream event (typically the
+            // 'response' completion) we commit it as a Static entry.
+            this.owner._appendStreamingDelta(content);
+            return;
+        }
+        if (type === 'response') {
+            // Streaming is finishing. Replace the in-progress text with the
+            // canonical final content (the streamed chunks may have lost
+            // formatting under markdown wrapping) and commit to history.
+            this.owner._commitStreaming(content);
+            return;
+        }
+        // Non-streaming events: a brand-new committed history entry. Also
+        // finalises any in-progress streaming message in case the model
+        // emitted a tool/system event between deltas.
+        this.owner._finalizeStreamingIfAny();
+        const kind = EVENT_KIND_MAP[type] ?? 'system';
+        this.owner._appendHistoryEntry({ id: `e-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`, kind, text: content });
+    }
+    addOutputTap(fn) {
+        this.taps.add(fn);
+        return () => { this.taps.delete(fn); };
+    }
+    /**
+     * Resolve the next user submission with the typed text. Used by the
+     * sudo-password capture flow in interactiveShell.ts.
+     *
+     * Implementation: stash a resolver, swap the prompt callbacks for one
+     * that resolves it, restore on submit. The owner runs setSecretMode
+     * around the call site.
+     */
+    captureInput(_opts = {}) {
+        return new Promise((resolve) => {
+            this.resolveCapture = resolve;
+            this.owner._installCaptureHandler((text) => {
+                const trim = _opts.trim !== false;
+                const value = trim ? text.trim() : text;
+                if (this.resolveCapture) {
+                    const r = this.resolveCapture;
+                    this.resolveCapture = null;
+                    this.owner._restoreSubmitHandler();
+                    if (_opts.resetBuffer !== false)
+                        this.owner._setBuffer('');
+                    r(value);
+                }
+            });
+        });
+    }
+    clearBuffer() {
+        this.owner._setBuffer('');
+    }
+    setSecretMode(enabled) {
+        this.owner._setSecretMode(enabled);
+    }
+    /** No-op. Ink owns its render loop; manual force is unnecessary. */
+    forceRender() { }
+    /** Shape parity with the legacy renderer; returns a fixed false. */
+    supportsInlinePanel() { return true; }
+    /**
+     * Used by interactiveShell.ts when re-rendering a tool result after
+     * the user expands it. Live update: append a new history entry with
+     * the expanded content.
+     */
+    expandLastToolResult() { return false; }
+    getCollapsedResultCount() { return 0; }
+    // Live follow-up queue (Claude Code parity). interactiveShell.ts drives the
+    // queue through getRenderer() (this shim), but the state lives on the owning
+    // controller — proxy through so the call doesn't throw "is not a function"
+    // and crash the shell when a prompt is submitted while the agent is busy.
+    setFollowUpQueueMode(on) { this.owner.setFollowUpQueueMode(on); }
+    setQueuedPrompts(prompts) { this.owner.setQueuedPrompts(prompts); }
+    addUserHistoryItem(text) { this.owner.addUserHistoryItem(text); }
+}
+export class InkPromptController extends EventEmitter {
+    callbacks;
+    // ink module + App component imported lazily on start() so non-Ink
+    // codepaths don't pay the React parse cost.
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    inkRender = null;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    React = null;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    AppComponent = null;
+    inst = null;
+    shim = new InkRendererShim(this);
+    stdin;
+    stdout;
+    // In-progress assistant message — accumulates 'stream' deltas. While
+    // non-null it renders below <Static> in a regular Ink Box so the text
+    // grows in place. Committed to history on 'response' (or finalised
+    // when any non-stream event arrives mid-flight).
+    streamingText = '';
+    // Monotonic suffix for ChatItem ids: Date.now() alone collides when several
+    // entries are appended in the same millisecond (e.g. the synchronous /resume
+    // replay), producing duplicate React keys in <Static>.
+    idSeq = 0;
+    // ── live state ────────────────────────────────────────────────
+    statusMain = null;
+    statusOverride = null;
+    statusStreaming = null;
+    activityMessage = null;
+    mode = 'idle';
+    metaInfo = {};
+    // ms timestamp the current spinner run began — drives the elapsed counter in
+    // StatusLine. Set when the UI transitions into a spinning state, cleared when
+    // it stops, so each working run reports its own elapsed time.
+    spinStart = null;
+    history = [];
+    suggestions = [];
+    inlinePanel = null;
+    secretMode = false;
+    editMode = 'display-edits';
+    pinnedPrompt = null;
+    modeToggleState = {
+        autoMode: 'on',
+        autoContinueHotkey: '⌥G',
+        hitlMode: 'off',
+        hitlHotkey: '⌥V',
+    };
+    buffer = '';
+    // Submitted prompts (oldest→newest) for Up/Down shell history navigation.
+    promptHistory = [];
+    // Workspace files (repo-relative) for @-mention autocomplete.
+    completionFiles = [];
+    // Set by InkRendererShim.captureInput — temporarily replaces onSubmit.
+    captureSubmit = null;
+    menuCallback = null;
+    menuItems = [];
+    // Live follow-up queue (Claude Code parity): when true, the onSubmit wrapper
+    // skips appending the user line to permanent <Static> history. The line is
+    // shown only in the transient queued region (App) until its turn is dequeued.
+    // At dequeue time the shell calls addUserHistoryItem just before processPrompt.
+    followUpQueueMode = false;
+    queuedPrompts = [];
+    menuTitle;
+    menuOpen = false;
+    started = false;
+    disposed = false;
+    // Resolves once Ink has finished its async mount (the dynamic ink/react/App
+    // imports + first render). Callers that drive events right after start()
+    // must await this, or a fast process.exit() can pre-empt the mount and the
+    // first frame never reaches stdout (empty-output flake under CPU contention).
+    resolveReady;
+    readyPromise = new Promise((r) => { this.resolveReady = r; });
+    constructor(stdin, stdout, callbacks) {
+        super();
+        this.stdin = stdin;
+        this.stdout = stdout;
+        this.callbacks = callbacks;
+    }
+    // ── lifecycle ─────────────────────────────────────────────────
+    /**
+     * Async start so the Ink + React modules can be loaded via dynamic
+     * import (the dist build emits ESM under `module: NodeNext`, where
+     * `require()` mixed with top-level await is a hard error in Node 22+).
+     * Call sites that go through createPromptController() should await
+     * .start(); the legacy controller's start() is sync, so the IPrompt
+     * interface defines start() as `void` and we coerce here.
+     */
+    start() { void this.startAsync(); }
+    /** Resolves once Ink has mounted and rendered its first frame. */
+    whenReady() { return this.readyPromise; }
+    async startAsync() {
+        if (this.started || this.disposed) {
+            this.resolveReady();
+            return;
+        }
+        this.started = true;
+        try {
+            const [ink, react, appMod] = await Promise.all([
+                import('ink'),
+                import('react'),
+                import('./App.js'),
+            ]);
+            this.React = react;
+            this.AppComponent = appMod.App;
+            this.inkRender = ink.render;
+            this.inst = this.inkRender(this.buildTree(), {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                stdin: this.stdin,
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                stdout: this.stdout,
+                // exitOnCtrlC=false so the host's onCtrlC callback fires first.
+                exitOnCtrlC: false,
+            });
+        }
+        finally {
+            // Always resolve — a waiter must never hang even if mount throws.
+            this.resolveReady();
+        }
+    }
+    stop() {
+        if (this.disposed)
+            return;
+        this.disposed = true;
+        this.started = false;
+        try {
+            this.inst?.unmount();
+        }
+        catch { /* ignore */ }
+        this.inst = null;
+    }
+    dispose() { this.stop(); }
+    /** Manual repaint hook — Ink owns its tick, so render/forceRender are coalesced into a rerender(). */
+    render() { this.rerender(); }
+    forceRender() { this.rerender(); }
+    handleResize() { }
+    /**
+     * Reset the chat surface (the shell's /clear). Ink's <Static> is
+     * append-only — it slices items from an internal index that only grows
+     * — so shrinking the history array cannot clear committed scrollback.
+     * The only correct reset is to unmount, clear the terminal while Ink is
+     * NOT mounted (so the escape can't desync a live render), and remount
+     * with empty history; the fresh <Static> restarts at index 0.
+     */
+    clearScreen() {
+        this.history = [];
+        this.streamingText = '';
+        if (this.inst && this.inkRender && this.React && this.AppComponent) {
+            try {
+                this.inst.unmount();
+            }
+            catch { /* ignore */ }
+            this.inst = null;
+            // \x1b[3J also drops scrollback so the cleared content can't be scrolled to.
+            try {
+                this.stdout.write('\x1b[2J\x1b[3J\x1b[H');
+            }
+            catch { /* ignore */ }
+            this.inst = this.inkRender(this.buildTree(), {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                stdin: this.stdin,
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                stdout: this.stdout,
+                exitOnCtrlC: false,
+            });
+        }
+        else {
+            this.rerender();
+        }
+    }
+    // ── status / activity / streaming ─────────────────────────────
+    setStatusMessage(message) { this.statusMain = (message?.trim() || null); this.rerender(); }
+    setOverrideStatus(message) { this.statusOverride = (message?.trim() || null); this.rerender(); }
+    setStreamingLabel(label) { this.statusStreaming = (label?.trim() || null); this.rerender(); }
+    setStatusLine(status) {
+        if ('main' in status)
+            this.statusMain = status.main?.trim() || null;
+        if ('override' in status)
+            this.statusOverride = status.override?.trim() || null;
+        if ('streaming' in status)
+            this.statusStreaming = status.streaming?.trim() || null;
+        this.rerender();
+    }
+    clearAllStatus() {
+        this.statusMain = null;
+        this.statusOverride = null;
+        this.statusStreaming = null;
+        this.activityMessage = null;
+        this.rerender();
+    }
+    setActivityMessage(message) { this.activityMessage = message; this.rerender(); }
+    setStreaming(streaming) { this.mode = streaming ? 'streaming' : 'idle'; this.rerender(); }
+    getMode() { return this.mode; }
+    setContextUsage(percentage) {
+        if (percentage !== null) {
+            this.metaInfo.contextPercent = percentage;
+            this.rerender();
+        }
+    }
+    setMetaStatus(meta) {
+        if (typeof meta.elapsedSeconds === 'number' && Number.isFinite(meta.elapsedSeconds) && meta.elapsedSeconds >= 0) {
+            const m = Math.floor(meta.elapsedSeconds / 60);
+            const s = meta.elapsedSeconds % 60;
+            this.metaInfo.sessionTime = `${m}:${s < 10 ? '0' : ''}${s}`;
+        }
+        if (typeof meta.tokensUsed === 'number' && meta.tokensUsed >= 0) {
+            this.metaInfo.tokensUsed = meta.tokensUsed;
+        }
+        if (meta.tokensUsed != null && meta.tokenLimit != null) {
+            this.metaInfo.contextPercent = meta.tokenLimit > 0 ? Math.round((meta.tokensUsed / meta.tokenLimit) * 100) : 0;
+        }
+        this.rerender();
+    }
+    setModelContext(options) {
+        if (options.model !== undefined)
+            this.metaInfo.model = options.model || undefined;
+        if (options.provider !== undefined)
+            this.metaInfo.provider = options.provider || undefined;
+        this.rerender();
+    }
+    setChromeMeta(meta) {
+        if (meta.workspace !== undefined)
+            this.metaInfo.workspace = meta.workspace;
+        if (meta.directory !== undefined)
+            this.metaInfo.directory = meta.directory;
+        this.rerender();
+    }
+    // ── toggles ───────────────────────────────────────────────────
+    setModeToggles(options) {
+        this.modeToggleState = { ...this.modeToggleState, ...options };
+        this.rerender();
+    }
+    setDebugMode(enabled) { this.modeToggleState.debugEnabled = enabled; this.rerender(); }
+    toggleAutoContinue() {
+        this.modeToggleState.autoMode = this.modeToggleState.autoMode === 'off' ? 'on' : 'off';
+        this.rerender();
+        this.callbacks.onToggleAutoContinue?.();
+    }
+    getAutoMode() { return this.modeToggleState.autoMode; }
+    setAutoMode(mode) { this.modeToggleState.autoMode = mode; this.rerender(); }
+    toggleHITL() {
+        this.modeToggleState.hitlMode = this.modeToggleState.hitlMode === 'off' ? 'on' : 'off';
+        this.rerender();
+        this.callbacks.onToggleHITL?.();
+    }
+    getHITLMode() { return this.modeToggleState.hitlMode; }
+    getModeToggleState() { return this.modeToggleState; }
+    // ── inline panel / pinned prompt / menu / suggestions ──────
+    setAvailableCommands(commands) {
+        this.suggestions = commands.map((c) => ({ label: c.command, hint: c.description }));
+        this.rerender();
+    }
+    setInlinePanel(lines) { this.inlinePanel = [...lines]; this.rerender(); }
+    clearInlinePanel() { this.inlinePanel = null; this.rerender(); }
+    supportsInlinePanel() { return true; }
+    setPinnedPrompt(text) { this.pinnedPrompt = text; this.rerender(); }
+    getPinnedPrompt() { return this.pinnedPrompt; }
+    clearPinnedPrompt() { this.pinnedPrompt = null; this.rerender(); }
+    setMenu(items, options, callback) {
+        this.menuItems = items;
+        this.menuCallback = callback;
+        this.menuTitle = options.title;
+        this.menuOpen = true;
+        this.rerender();
+    }
+    closeMenu() { this.resolveMenu(null); }
+    isMenuActive() { return this.menuOpen; }
+    /** Close the menu and fire the stored callback exactly once. */
+    resolveMenu(item) {
+        if (!this.menuOpen)
+            return;
+        this.menuOpen = false;
+        const callback = this.menuCallback;
+        this.menuCallback = null;
+        this.menuItems = [];
+        this.menuTitle = undefined;
+        this.rerender();
+        if (callback) {
+            try {
+                callback(item);
+            }
+            catch { /* selection-handler errors must not break the UI */ }
+        }
+    }
+    // ── input buffer ──────────────────────────────────────────────
+    setSecretMode(enabled) { this.secretMode = enabled; this.rerender(); }
+    setEditMode(mode) { this.editMode = mode; this.callbacks.onEditModeChange?.(mode); }
+    applyEditMode(mode) { this.setEditMode(mode); }
+    getEditMode() { return this.editMode; }
+    /**
+     * The input buffer in the Ink path is owned by the Prompt component,
+     * not by this controller. We keep `this.buffer` as a snapshot for
+     * legacy callers asking for getBuffer/getCursor; updates flow when the
+     * Prompt's onSubmit / clear actions fire. setBuffer drives a new
+     * `initial` prop on the next mount.
+     */
+    getBuffer() { return this.buffer; }
+    getCursor() { return this.buffer.length; }
+    setBuffer(text, _cursorPos) { this.buffer = text; this.rerender(); }
+    clear() { this.buffer = ''; this.rerender(); }
+    // Live follow-up queue support (see followUpQueueMode comment above)
+    setFollowUpQueueMode(on) { this.followUpQueueMode = !!on; this.rerender(); }
+    setQueuedPrompts(prompts) { this.queuedPrompts = Array.isArray(prompts) ? prompts.slice() : []; this.rerender(); }
+    setCompletionFiles(files) { this.completionFiles = Array.isArray(files) ? files : []; this.rerender(); }
+    addUserHistoryItem(text) {
+        const t = (text || '').trim();
+        if (!t)
+            return;
+        this.history = [...this.history, { id: `u-${Date.now()}-q-${this.idSeq++}`, kind: 'user', text: t }];
+        this.rerender();
+    }
+    // ── renderer facade ───────────────────────────────────────────
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    getRenderer() { return this.shim; }
+    // ── internal ──────────────────────────────────────────────────
+    /** Append history (used by the renderer shim's addEvent). */
+    _appendHistoryEntry(item) {
+        this.history = [...this.history, item];
+        this.rerender();
+    }
+    /**
+     * Streaming accumulators. Deltas append to streamingText, which App
+     * renders live as the dynamic region below ChatStatic (<Static>). The
+     * old duplication bug — partial text orphaned in scrollback when a
+     * Static item appended below it — cannot recur: ChatStatic is the ONLY
+     * Static node and renders first, so nothing Static ever appends below
+     * the live region, and _commitStreaming pushes history + clears
+     * streamingText in a single atomic rerender.
+     */
+    _appendStreamingDelta(delta) {
+        this.streamingText = (this.streamingText || '') + (delta || '');
+        this.rerender();
+    }
+    _commitStreaming(finalText) {
+        // The real delta path ends with addEvent('response', '\n') — the body
+        // lives in the accumulated streamingText, NOT in finalText. The
+        // non-delta path carries the full text in finalText with an empty
+        // streamingText. A tools run emits a "Next steps" addendum as a
+        // distinct response. So: commit the buffered body if present, then
+        // commit finalText when it is real and not a duplicate of the body.
+        const incoming = (finalText || '').trim();
+        const buffered = (this.streamingText || '').trim();
+        this.streamingText = '';
+        const additions = [];
+        if (buffered)
+            additions.push({ id: `r-${Date.now()}-b-${this.idSeq++}`, kind: 'assistant', text: buffered });
+        if (incoming && incoming !== buffered)
+            additions.push({ id: `r-${Date.now()}-c-${this.idSeq++}`, kind: 'assistant', text: incoming });
+        if (additions.length)
+            this.history = [...this.history, ...additions];
+        // Single rerender: ChatStatic gains the entries AND the live region
+        // (streamingMessage) goes null in the same commit — atomic swap, no
+        // duplicate of the streamed body in scrollback.
+        this.rerender();
+    }
+    _finalizeStreamingIfAny() {
+        if (!this.streamingText)
+            return;
+        const text = this.streamingText.trim();
+        this.streamingText = '';
+        if (text) {
+            this.history = [...this.history, { id: `r-${Date.now()}-${this.idSeq++}`, kind: 'assistant', text }];
+        }
+        // No rerender — the caller is about to push another history entry
+        // and rerender once. Avoid the double commit.
+    }
+    /** Shift+Tab from the Prompt: advance the permission mode and repaint. */
+    cyclePermissionModeFromUI() {
+        const next = cyclePermissionMode();
+        this.rerender();
+        this.callbacks.onCyclePermissionMode?.(next);
+    }
+    _setBuffer(text) { this.buffer = text; this.rerender(); }
+    _setSecretMode(enabled) { this.secretMode = enabled; this.rerender(); }
+    _installCaptureHandler(handler) { this.captureSubmit = handler; this.rerender(); }
+    _restoreSubmitHandler() { this.captureSubmit = null; this.rerender(); }
+    rerender() {
+        if (!this.inst)
+            return;
+        try {
+            this.inst.rerender(this.buildTree());
+        }
+        catch { /* swallow rerender races */ }
+    }
+    buildTree() {
+        const composedStatus = this.statusOverride
+            || (this.mode === 'streaming' ? this.statusStreaming : null)
+            || this.activityMessage
+            || this.statusMain;
+        const modeChips = this.formatModeChips();
+        const spinning = this.mode === 'streaming' || Boolean(this.activityMessage);
+        const thinkingGerund = spinning && isGenericThinking(composedStatus);
+        // Stamp the start of a working run on the rising edge; clear it when the
+        // spinner stops so the next run's elapsed counter restarts from zero.
+        if (spinning) {
+            if (this.spinStart == null)
+                this.spinStart = Date.now();
+        }
+        else {
+            this.spinStart = null;
+        }
+        return this.React.createElement(this.AppComponent, {
+            history: this.history,
+            streamingMessage: this.streamingText || null,
+            status: {
+                message: composedStatus,
+                modeMessage: modeChips,
+                spinning,
+                startTime: this.spinStart,
+                tokensUsed: this.metaInfo.tokensUsed ?? null,
+                thinkingGerund,
+            },
+            suggestions: this.suggestions.length ? this.suggestions : undefined,
+            inlinePanel: this.inlinePanel && this.inlinePanel.length ? this.inlinePanel : undefined,
+            permissionHint: permissionHint(),
+            queuedPrompts: this.queuedPrompts.length ? this.queuedPrompts : undefined,
+            menu: this.menuOpen ? {
+                items: this.menuItems,
+                title: this.menuTitle,
+                onSelect: (item) => this.resolveMenu(item),
+                onCancel: () => this.resolveMenu(null),
+            } : undefined,
+            prompt: {
+                initial: this.buffer,
+                secret: this.secretMode,
+                onSubmit: (text) => {
+                    if (this.captureSubmit) {
+                        this.captureSubmit(text);
+                        return;
+                    }
+                    // Commit the user's submitted text into history before
+                    // dispatching to the host. The legacy renderer auto-emitted
+                    // an 'addEvent("prompt", text)' on its own submit path; the
+                    // Ink path didn't, so submitted prompts vanished from the
+                    // chat surface. Symptom: user typed "hi", saw the agent
+                    // respond, but their own "hi" was never in the transcript.
+                    // Skip secret submissions (passwords) and slash commands —
+                    // both are interpreted by the host, not user-visible
+                    // history. Keeps history aligned with what the agent saw.
+                    //
+                    // For live follow-up queue (while isProcessing): we *skip* the
+                    // permanent history append here. The text lives only in the
+                    // transient queuedPrompts region (App) until the shell dequeues
+                    // it and calls addUserHistoryItem right before starting its turn.
+                    // This guarantees response always appears immediately after its
+                    // triggering user line (correct ordering, no clumping).
+                    const trimmed = text.trim();
+                    if (!this.secretMode && trimmed && !trimmed.startsWith('/')) {
+                        if (!this.followUpQueueMode) {
+                            this.history = [
+                                ...this.history,
+                                { id: `u-${Date.now()}-${this.idSeq++}`, kind: 'user', text: trimmed },
+                            ];
+                        }
+                    }
+                    // Record into the Up/Down shell history (skip secrets + consecutive
+                    // dupes; cap to keep it bounded).
+                    if (!this.secretMode && trimmed && this.promptHistory[this.promptHistory.length - 1] !== trimmed) {
+                        this.promptHistory.push(trimmed);
+                        if (this.promptHistory.length > 200)
+                            this.promptHistory.shift();
+                    }
+                    this.buffer = '';
+                    this.rerender();
+                    this.callbacks.onSubmit(text);
+                },
+                onCancel: () => {
+                    this.callbacks.onCtrlC?.({ hadBuffer: this.buffer.length > 0 });
+                    this.callbacks.onInterrupt();
+                },
+                onCyclePermissionMode: () => this.cyclePermissionModeFromUI(),
+                onExpandToolResult: () => this.callbacks.onExpandToolResult?.(),
+                onEscape: () => this.callbacks.onEscape?.(),
+                onShowShortcuts: () => this.callbacks.onShowShortcuts?.(),
+                panelOpen: Boolean(this.inlinePanel && this.inlinePanel.length),
+                onDismissPanel: () => this.callbacks.onDismissPanel?.(),
+                history: this.promptHistory,
+                completionFiles: this.completionFiles,
+            },
+        });
+    }
+    /**
+     * The dim mode line under the spinner. Claude Code keeps this minimal and
+     * emoji-free: product, model, context left, then active toggles. The cwd and
+     * elapsed time deliberately don't live here (cwd is in the welcome box;
+     * elapsed rides the spinner).
+     */
+    formatModeChips() {
+        const parts = ['trenchwork-coder'];
+        const meta = this.metaInfo;
+        if (meta.model)
+            parts.push(meta.model);
+        if (meta.contextPercent != null) {
+            const left = Math.max(0, 100 - meta.contextPercent);
+            parts.push(`${left}% context left`);
+        }
+        const permChip = permissionStatusChip();
+        if (permChip)
+            parts.push(permChip);
+        if (this.modeToggleState.autoMode === 'on')
+            parts.push('auto');
+        if (this.modeToggleState.hitlMode === 'on')
+            parts.push('HITL');
+        if (this.modeToggleState.debugEnabled)
+            parts.push('debug');
+        if (this.pinnedPrompt)
+            parts.push(this.pinnedPrompt.slice(0, 40));
+        // The inline panel now renders as its own block (see App.inlinePanel); it
+        // no longer leaks its first line into the meta chips.
+        return parts.length ? parts.join(' · ') : null;
+    }
+}
+/**
+ * Factory — returns the Ink-backed controller. Ink is now the only
+ * renderer; the legacy UnifiedUIRenderer + PromptController have been
+ * removed. interactiveShell.ts exits early on non-TTY so Ink's
+ * raw-mode requirement is always satisfied here. Plain mode
+ * (NO_COLOR / TERM=dumb) still flows through Ink — Ink itself
+ * down-styles when colours are disabled.
+ */
+export async function createPromptController(stdin, stdout, callbacks) {
+    return new InkPromptController(stdin, stdout, callbacks);
+}
+//# sourceMappingURL=InkPromptController.js.map