koneck 2.123.0 → 2.125.0

package/dist/ink-chat.js

@@ -2,8 +2,10 @@ import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-run
 import React, { useState, useEffect, useRef } from 'react';
 import { Box, Static, Text, render, useApp, useInput, useStdin } from 'ink';
 import { execa } from 'execa';
-import { createAgentSession, buildClient, resolveAgentConcurrency, toolsUnsupportedNotice } from './engine.js';
-import { estimateCost, formatCost } from './pricing.js';
+import { resolveAgentConcurrency, toolsUnsupportedNotice } from './engine-facts.js';
+import { withSynchronizedFrames } from './frame-sync.js';
+import { pacedInterval } from './frame-pace.js';
+import { estimateCost, formatCost, rateText } from './pricing.js';
 import { generateSessionId, saveSession, listSessions, loadSession, relativeAge, renameSession, forkSession, archiveSession, findSession, } from './session.js';
 import { loadMemory } from './memory.js';
 import { loadKoneckConfig, saveKoneckConfig, setConfigKey, configKeyDescriptions, CONFIG_FILE, CONFIG_SCHEMA, stepValue, displayValue } from './config-store.js';
@@ -49,16 +51,18 @@ import { logoFor } from './logo.js';
 import { describeActivity } from './activity.js';
 import { redactSecrets, containsSecret } from './redact.js';
 import { renderTrajectory } from './trajectory.js';
-import { describeSandbox, resolveSandbox } from './sandbox.js';
-import { doctorChecks, doctorReport } from './doctor.js';
-import { runQualityGate } from './quality-gate.js';
-import { runPreflight, preflightReport, isPreflightReady } from './preflight.js';
+// sandbox.js and doctor.js are loaded by /status and /doctor. sandbox.js imports execaSync to run
+// bubblewrap and doctor.js shells out to check the environment, and both are reached only from
+// handleCommand, which is async. Measured: 122ms and 150ms.
+// quality-gate.js, mcp.js and refactor.js are loaded at the one command that uses each. Each
+// reaches something large — quality-gate takes shellFor from tools.js, refactor takes runAgent
+// from engine.js and ts-morph with it — and an eager import here undid the engine being lazy,
+// because the graph simply arrived by another road. Measured: 339ms, 141ms and 75ms.
+// preflight.js is loaded by the command that runs it: it imports quality-gate.js, and so
+// tools.js, for 505ms that a session which never types /preflight should not pay.
 import { listAuditEvents } from './audit.js';
 import { initializePolicy, loadPolicy, POLICY_FILE } from './policy.js';
 import { isWorkspaceTrusted, trustWorkspace, untrustWorkspace } from './workspace-trust.js';
-import { loadMCPConfig } from './mcp.js';
-import { renameSymbol, extractInterface, moveSymbol } from './refactor.js';
-import { rateText } from './model-catalog.js';
 const CYAN = '#54D7E7';
 const GREEN = '#9BCB8F';
 const CRIMSON = '#E8878D';
@@ -382,9 +386,62 @@ export function liveReplyLines(termRows) {
     const rows = termRows && termRows > 0 ? termRows : 24;
     return rows < 12 ? 1 : 2;
 }
-/** Sampling cadence for live stream refs: quick enough to read, slow enough not to flash. */
-export function liveRefreshDelay(idleForMs) {
-    return idleForMs < 2_000 ? 500 : 1_000;
+/**
+ * The engine, loaded the first time a turn needs it.
+ *
+ * Importing it at the top of this module cost 645ms of the 1,163ms it took to load the terminal
+ * app on a Raspberry Pi 5 — it reaches the OpenAI SDK, execa and ts-morph through fifty-seven
+ * modules — and not one line of it is needed to draw the banner, the prompt or the status bar.
+ * Nothing here is on a render path: every caller already runs inside an async handler, and the
+ * two things the interface prints synchronously are in engine-facts.js for that reason.
+ *
+ * The promise is cached, so concurrent callers share one import and later turns pay nothing. It is
+ * also warmed in the background as soon as the interface is up, which is why the first turn does
+ * not feel the move either.
+ */
+let enginePromise;
+function engine() {
+    return (enginePromise ??= import('./engine.js'));
+}
+/**
+ * How long one animation frame lasts.
+ *
+ * Every tick both advances the animation and reveals whatever the stream has added since the
+ * last one, so this is the interface's frame rate. It was 500ms while a stream was active and
+ * 1,000ms once it went quiet, which is where "the loader is moving slowly ... even 10x slower
+ * than a tortoise" came from: the spinner took ten seconds to turn once and the shimmer
+ * forty-eight to cross a word.
+ *
+ * The reason it was that slow was flicker, and the flicker was real — but the rate was never its
+ * cause. Ink writes a frame by erasing the previous one and drawing the next, and the terminal
+ * showed the gap between the two. Repainting less often only made the flash rarer. It is now
+ * fixed where it happens, in frame-sync.ts, by presenting each frame atomically, which leaves the
+ * frame rate free to be a frame rate.
+ *
+ * 80ms is what cli-spinners and ora use for braille spinners, and it is comfortably above Ink's
+ * own 32ms write throttle (`throttle(this.onRender, 32)` in ink/build/ink.js), so each tick
+ * becomes exactly one write rather than being coalesced with its neighbours. Measured cost of a
+ * tick on a Raspberry Pi 5: 0.7ms of React render and about 700 bytes written, or roughly 1% of
+ * one core at this rate.
+ */
+export const FRAME_MS = 80;
+/**
+ * How long one work word is held before the next is shown.
+ *
+ * The word is there to be read and enjoyed, not to reassure by moving, so it outlasts the
+ * animation by a long way.
+ */
+export const WORD_HOLD_MS = 60_000;
+/**
+ * Which spinner cell and shimmer column a turn is showing after this much work.
+ *
+ * One function so the two cannot drift apart, and pure so the rates can be asserted rather than
+ * eyeballed: both advance one step per frame, the spinner wrapping around its glyphs and the
+ * shimmer running on for `Shimmer` to wrap over the word plus its trailing gap.
+ */
+export function animFrames(elapsedMs, spinnerLength) {
+    const frame = Math.floor(Math.max(0, elapsedMs) / FRAME_MS);
+    return { spin: frame % spinnerLength, shimmer: frame };
 }
 const SPINNER = G.spinner;
 /**
@@ -1215,7 +1272,7 @@ export function App({ config: initialConfig, clearFrame }) {
     // Tool approval callbacks belong to a session created on an earlier render. Keep the control
     // posture live so turning approval on during a turn governs its next consequential tool call.
     const cfgRef = useRef(initialConfig);
-    // Live activity accumulates in a ref and is painted by the 100 ms ticker. Mutating a ref
+    // Live activity accumulates in a ref and is painted by the FRAME_MS ticker. Mutating a ref
     // instead of calling setState per token keeps a Raspberry Pi from re-rendering on every chunk.
     const sayRef = useRef(''); // narration not yet committed
     const liveToolRef = useRef(null); // the one tool still running
@@ -1223,8 +1280,6 @@ export function App({ config: initialConfig, clearFrame }) {
     const replyStartedRef = useRef(false);
     /** Everything streamed this turn. Empty means the provider did not stream at all. */
     const streamedRef = useRef('');
-    /** When the live region last had something new to show, used to pick the repaint rate. */
-    const lastActivityRef = useRef(Date.now());
     /**
      * Frames received before any content — proof the provider has the request and is working.
      *
@@ -1336,7 +1391,6 @@ export function App({ config: initialConfig, clearFrame }) {
      * whatever is left in the buffer.
      */
     function pushSay(text) {
-        lastActivityRef.current = Date.now();
         sayRef.current += text;
         streamedRef.current += text;
         charsRef.current += text.length;
@@ -1391,7 +1445,6 @@ export function App({ config: initialConfig, clearFrame }) {
     function pushTool(name, args) {
         commitSay();
         // Photograph every file this tool has announced it will touch, before it touches it.
-        lastActivityRef.current = Date.now();
         turnToolsRef.current += 1;
         pendingDiffRef.current = filesTouchedBy(name, args).slice(0, MAX_DIFF_FILES)
             .map(rel => ({ rel, before: readForDiff(rel) }));
@@ -1545,10 +1598,9 @@ export function App({ config: initialConfig, clearFrame }) {
         },
         onToolResult: (name, ok, ms, detail) => finishTool(name, ok, ms, detail),
         onToolOutput: (_name, line) => {
-            // Deliberately does not count as activity for the frame rate. A dev server logs a request
-            // every second or two, and treating each one as "something is happening" held the UI in its
-            // fastest repaint band for as long as the server ran — which is the flicker. The line still
-            // updates; the whole region just stops being redrawn eight times a second to show it.
+            // Written to the ref rather than to state: a dev server logs a request every second or two,
+            // and a setState per line re-rendered the interface on each one. The ticker paints whatever
+            // the ref holds when the next frame comes round, so a chatty tool costs nothing extra.
             if (liveToolRef.current)
                 liveToolRef.current.output = line;
         },
@@ -1597,7 +1649,6 @@ export function App({ config: initialConfig, clearFrame }) {
             // produce tens of thousands of characters per turn, and what anyone watching wants is what
             // it is thinking now.
             thinkingTextRef.current = (thinkingTextRef.current + text).slice(-THINKING_TAIL_CHARS);
-            lastActivityRef.current = Date.now();
         },
         onAgentProgress: (list) => { agentsRef.current = list; setAgents(list); },
         onWindowDetected: (limit, source) => setDetectedContext({ limit, source }),
@@ -1923,11 +1974,14 @@ export function App({ config: initialConfig, clearFrame }) {
      */
     const sessionNow = () => {
         if (!activeSession.p) {
-            activeSession.p = hold(createAgentSession({
+            // The options are built here, not inside the then, so the hooks and refs are read at the
+            // moment the session was asked for rather than a microtask later.
+            const opts = {
                 ...initialConfig,
                 pace: paceFrom(initialConfig.pace ?? savedEffort(undefined), 'medium'),
                 ...failoverHooks(), silent: true, ...sessionOpts,
-            }));
+            };
+            activeSession.p = hold(engine().then(m => m.createAgentSession(opts)));
         }
         return activeSession.p;
     };
@@ -2207,36 +2261,38 @@ export function App({ config: initialConfig, clearFrame }) {
         }
         busyStart.current = Date.now();
         wordTimer.current = 0;
-        // The frame rate is the flicker rate. Every tick makes Ink update the live region, so network
-        // activity must be sampled for a human reader rather than mirrored frame-for-frame. Half a
-        // second keeps streamed prose feeling live; an idle tool only needs a once-a-second
-        // heartbeat. This is particularly important in terminals that repaint an ANSI line update as
-        // a flash.
+        // One rate, whether or not the stream is saying anything. The spinner earns its place
+        // precisely when nothing is arriving — the 2m 44s wait on a provider that had gone quiet is
+        // what this was reported from — so backing the animation off when a turn goes idle stopped
+        // it in the one situation it exists for. Flicker is handled where it is caused, by writing
+        // each frame atomically; see frame-sync.ts.
         let timer;
+        const wordEvery = Math.max(1, Math.round(WORD_HOLD_MS / FRAME_MS));
+        /*
+         * The rate this machine can actually sustain, not the one we would like.
+         *
+         * Each frame records how long the timer really took to arrive. On time means the loop is
+         * keeping up and the rate stands; late means the event loop had more work than the frame's own
+         * budget, and asking again just as soon only queues a frame that cannot be painted — which is
+         * how a Pi ends up lagging while the same build feels instant on a laptop. See frame-pace.ts.
+         */
+        let interval = FRAME_MS;
+        let asked = Date.now();
         const tick = () => {
-            const elapsed = Date.now() - busyStart.current;
-            const delay = currentDelay();
-            // Do not animate several cells for every content refresh. The spinner moves once a second
-            // and the shimmer once every two seconds; the intervening refreshes are solely to reveal
-            // new streamed text.
-            setAnim({
-                spin: Math.floor(elapsed / 1_000) % SPINNER.length,
-                shimmer: Math.floor(elapsed / 2_000),
-                elapsed,
-            });
+            const now = Date.now();
+            interval = pacedInterval(interval, now - asked);
+            // Elapsed is read from the clock rather than counted in ticks, so a frame the event loop
+            // delivers late moves the animation on by what actually passed instead of falling behind.
+            const elapsed = now - busyStart.current;
+            const { spin, shimmer } = animFrames(elapsed, SPINNER.length);
+            setAnim({ spin, shimmer, elapsed });
             wordTimer.current += 1;
-            // Roughly every 60 seconds, whatever the current rate. Twenty-five felt churned on a long
-            // run — the word is there to be read and enjoyed, not to reassure by moving.
-            if (wordTimer.current % Math.max(20, Math.round(60_000 / delay)) === 0) {
+            if (wordTimer.current % wordEvery === 0)
                 setSpinWord(w => w + 1);
-            }
-            timer = setTimeout(tick, delay);
-        };
-        const currentDelay = () => {
-            const idleFor = Date.now() - lastActivityRef.current;
-            return liveRefreshDelay(idleFor);
+            asked = Date.now();
+            timer = setTimeout(tick, interval);
         };
-        timer = setTimeout(tick, liveRefreshDelay(0));
+        timer = setTimeout(tick, interval);
         return () => clearTimeout(timer);
     }, [busy]);
     // A queued prompt runs the moment the agent is free again. Keyed on `busy` rather than done
@@ -2325,7 +2381,8 @@ export function App({ config: initialConfig, clearFrame }) {
         const c = newCfg ?? cfg;
         cfgRef.current = c;
         setDetectedContext(null);
-        activeSession.p = hold(createAgentSession({ ...c, pace: paceFrom(effortRef.current, 'medium'), ...failoverHooks(), silent: true, ...sessionOpts }));
+        const opts = { ...c, pace: paceFrom(effortRef.current, 'medium'), ...failoverHooks(), silent: true, ...sessionOpts };
+        activeSession.p = hold(engine().then(m => m.createAgentSession(opts)));
         if (newCfg)
             setCfg(newCfg);
     }
@@ -2419,7 +2476,7 @@ export function App({ config: initialConfig, clearFrame }) {
             : 'The sending session has not done any work yet; this is a fresh instruction.';
         if (transcript.trim() !== '') {
             try {
-                const client = buildClient(cfg);
+                const client = (await engine()).buildClient(cfg);
                 const res = await client.chat.completions.create({
                     model: cfg.model,
                     max_tokens: 220,
@@ -2481,7 +2538,8 @@ export function App({ config: initialConfig, clearFrame }) {
                         ...(st.note ? { note: st.note } : {}),
                     })), updatedAt: Date.now() }
                 : undefined;
-            activeSession.p = hold(createAgentSession({ ...restoredCfg, silent: true, ...sessionOpts }, messages, { turns: meta.turns, totalTokens: meta.totalTokens }, restoredPlan));
+            const resumeOpts = { ...restoredCfg, silent: true, ...sessionOpts };
+            activeSession.p = hold(engine().then(m => m.createAgentSession(resumeOpts, messages, { turns: meta.turns, totalTokens: meta.totalTokens }, restoredPlan)));
             if (restoredPlan)
                 setPlan(restoredPlan);
             setSessionGoal(meta.goal ?? null);
@@ -3104,6 +3162,7 @@ export function App({ config: initialConfig, clearFrame }) {
                 // question that actually matters when a provider misbehaves unanswered: where did the
                 // request go? Working that out took a proxy and half an hour.
                 const endpoint = resolveProvider(cfg.provider, cfg.baseURL).baseURL;
+                const { describeSandbox, resolveSandbox } = await import('./sandbox.js');
                 addSystem(`Provider   : ${cfg.provider}\n` +
                     `Endpoint   : ${endpoint}\n` +
                     `Model      : ${cfg.model}\n` +
@@ -3199,6 +3258,7 @@ export function App({ config: initialConfig, clearFrame }) {
                 // rather than a stale global default.
                 addSystem(`**KONECK Doctor** — checking ${cfg.provider} and this workspace…`);
                 try {
+                    const { doctorChecks, doctorReport } = await import('./doctor.js');
                     const checks = await doctorChecks(cfg.cwd, cfg.provider, cfg.baseURL, cfg.apiKey);
                     setRows(prev => prev.slice(0, -1));
                     addSystem(`**KONECK Doctor**\n\n${doctorReport(checks)}`);
@@ -3210,6 +3270,7 @@ export function App({ config: initialConfig, clearFrame }) {
                 return;
             }
             case '/mcp': {
+                const { loadMCPConfig } = await import('./mcp.js');
                 const configured = await loadMCPConfig(cfg.cwd);
                 const session = await sessionNow().catch(() => null);
                 addSystem(mcpStatusText(Object.keys(configured?.servers ?? {}), session?.mcpServers ?? []));
@@ -3306,6 +3367,7 @@ export function App({ config: initialConfig, clearFrame }) {
                 addSystem(`Running native TypeScript refactor: ${cmd}…`);
                 try {
                     if (cmd === '/rename') {
+                        const { renameSymbol } = await import('./refactor.js');
                         const result = await renameSymbol(parts[0], parts[1], cfg.cwd, { announce: false });
                         addSystem(`Renamed \`${parts[0]}\` → \`${parts[1]}\` in ${result.filesChanged.length} file(s) (${result.occurrences} occurrence(s)).` +
                             (checkpoint
@@ -3313,11 +3375,13 @@ export function App({ config: initialConfig, clearFrame }) {
                                 : '\n\nNo Git restore point was available. Run `/preflight` before committing.'));
                     }
                     else if (cmd === '/extract') {
+                        const { extractInterface } = await import('./refactor.js');
                         await extractInterface(parts[0], parts[1], cfg.cwd, { announce: false });
                         addSystem(`Extracted interface for \`${parts[1]}\` from \`${parts[0]}\`.` +
                             (checkpoint ? `\n\nRestore point: \`${checkpoint.id}\` — run \`/preflight\`, or \`/revert ${checkpoint.id} --confirm\` to undo.` : '\n\nRun `/preflight` before committing.'));
                     }
                     else {
+                        const { moveSymbol } = await import('./refactor.js');
                         await moveSymbol(parts[0], parts[1], parts[2], cfg.cwd, { announce: false });
                         addSystem(`Moved \`${parts[0]}\` from \`${parts[1]}\` to \`${parts[2]}\` and updated imports.` +
                             (checkpoint ? `\n\nRestore point: \`${checkpoint.id}\` — run \`/preflight\`, or \`/revert ${checkpoint.id} --confirm\` to undo.` : '\n\nRun `/preflight` before committing.'));
@@ -3835,6 +3899,7 @@ export function App({ config: initialConfig, clearFrame }) {
                 // the same independent proof on demand, without the legacy TUI writing over Ink's frame.
                 addSystem('**Quality gate** — running detected lint and test checks…');
                 try {
+                    const { runQualityGate } = await import('./quality-gate.js');
                     const result = await runQualityGate(cfg.cwd, { report: false });
                     setRows(prev => prev.slice(0, -1));
                     if (result.checks.length === 0) {
@@ -3861,6 +3926,7 @@ export function App({ config: initialConfig, clearFrame }) {
             case '/preflight': {
                 addSystem('**Preflight** — checking patch integrity and detected quality gates…');
                 try {
+                    const { runPreflight, preflightReport } = await import('./preflight.js');
                     const result = await runPreflight(cfg.cwd);
                     setRows(prev => prev.slice(0, -1));
                     addSystem(preflightReport(result));
@@ -3878,6 +3944,7 @@ export function App({ config: initialConfig, clearFrame }) {
                 }
                 addSystem('**Ship check** — running deterministic readiness checks…');
                 try {
+                    const { runPreflight, preflightReport, isPreflightReady } = await import('./preflight.js');
                     const result = await runPreflight(cfg.cwd);
                     setRows(prev => prev.slice(0, -1));
                     addSystem(preflightReport(result));
@@ -5130,7 +5197,6 @@ export function App({ config: initialConfig, clearFrame }) {
             thinkingRef.current = { chars: 0, at: 0 };
             thinkingTextRef.current = '';
             incompleteRef.current = null;
-            lastActivityRef.current = Date.now();
             providerFramesRef.current = 0;
             liveToolRef.current = null;
             charsRef.current = 0;
@@ -5422,7 +5488,7 @@ export function App({ config: initialConfig, clearFrame }) {
                             //
                             // Both halves matter. Clipping the bottom would hide what just happened; anchoring
                             // always to the bottom is what put the banner there.
-                            _jsx(Box, { flexGrow: 0, flexShrink: 1, flexDirection: "column", justifyContent: "flex-end", overflowY: "hidden", children: visibleRows.map((row, i) => (_jsx(Box, { flexDirection: "column", flexShrink: 0, children: renderRow(row, i) }, i))) })), altScreen && scrollBack > 0 && (_jsx(Text, { color: AMBER, children: `${G.caret} scrolled back ${scrollBack} rows — PageDown, or just type, to follow again` })), showAnalytics && (_jsxs(Box, { borderStyle: "round", borderColor: AMBER, paddingX: 1, marginBottom: 1, flexDirection: "column", width: barWidth, children: [_jsx(Text, { color: AMBER, bold: true, children: "\u25C6 Session Analytics" }), _jsxs(Text, { color: MUTED, children: ["Turns      : ", _jsx(Text, { color: INK, children: stats.turns })] }), _jsxs(Text, { color: MUTED, children: ["Prompt tok : ", _jsx(Text, { color: INK, children: stats.promptTokens.toLocaleString() })] }), _jsxs(Text, { color: MUTED, children: ["Output tok : ", _jsx(Text, { color: INK, children: stats.completionTokens.toLocaleString() })] }), _jsxs(Text, { color: MUTED, children: ["Total tok  : ", _jsx(Text, { color: INK, children: stats.totalTokens.toLocaleString() })] }), _jsxs(Text, { color: MUTED, children: ["Model      : ", _jsx(Text, { color: INK, children: modelShort }), "  Provider: ", _jsx(Text, { color: INK, children: cfg.provider })] }), _jsx(Text, { color: DIM, children: "Tab to close" })] })), _jsx(Static, { items: altScreen ? [] : rows, children: (row, index) => renderRow(row, index) }), _jsx(Box, { flexDirection: "column", flexShrink: 0, children: busy && (agentState === 'processing' || agentState === 'syncing') && (_jsxs(Box, { flexDirection: "column", children: [sayRef.current.trim() !== '' && (_jsxs(Box, { gap: 1, children: [_jsx(Text, { color: CYAN, bold: true, children: replyStartedRef.current ? '  ' : G.brand }), _jsx(Box, { flexDirection: "column", children: tailLines(sayRef.current, liveReplyLines(termRows), replyWidth - 3)
+                            _jsx(Box, { flexGrow: 0, flexShrink: 1, flexDirection: "column", justifyContent: "flex-end", overflowY: "hidden", children: visibleRows.map((row, i) => (_jsx(Box, { flexDirection: "column", flexShrink: 0, children: renderRow(row, i) }, i))) })), altScreen && scrollBack > 0 && (_jsx(Text, { color: AMBER, children: `${G.caret} scrolled back ${scrollBack} rows — PageDown, or just type, to follow again` })), showAnalytics && (_jsxs(Box, { borderStyle: "round", borderColor: AMBER, paddingX: 1, marginBottom: 1, flexDirection: "column", width: barWidth, children: [_jsx(Text, { color: AMBER, bold: true, children: "\u25C6 Session Analytics" }), _jsxs(Text, { color: MUTED, children: ["Turns      : ", _jsx(Text, { color: INK, children: stats.turns })] }), _jsxs(Text, { color: MUTED, children: ["Prompt tok : ", _jsx(Text, { color: INK, children: stats.promptTokens.toLocaleString() })] }), _jsxs(Text, { color: MUTED, children: ["Output tok : ", _jsx(Text, { color: INK, children: stats.completionTokens.toLocaleString() })] }), _jsxs(Text, { color: MUTED, children: ["Total tok  : ", _jsx(Text, { color: INK, children: stats.totalTokens.toLocaleString() })] }), _jsxs(Text, { color: MUTED, children: ["Model      : ", _jsx(Text, { color: INK, children: modelShort }), "  Provider: ", _jsx(Text, { color: INK, children: cfg.provider })] }), _jsx(Text, { color: DIM, children: "Tab to close" })] })), _jsx(Static, { items: altScreen ? [] : rows, children: (row, index) => renderRow(row, index) }), _jsx(Box, { flexDirection: "column", flexShrink: 0, children: busy && (agentState === 'processing' || agentState === 'syncing') && (_jsxs(Box, { flexDirection: "column", children: [!ask && sayRef.current.trim() !== '' && (_jsxs(Box, { gap: 1, children: [_jsx(Text, { color: CYAN, bold: true, children: replyStartedRef.current ? '  ' : G.brand }), _jsx(Box, { flexDirection: "column", children: tailLines(sayRef.current, liveReplyLines(termRows), replyWidth - 3)
                                                         .split('\n').map((line, i) => _jsx(Text, { color: INK, children: line }, i)) })] })), liveToolRef.current && renderStep(liveToolRef.current, 1), queued.length > 0 && (_jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsxs(Box, { gap: 1, children: [_jsx(Text, { color: AMBER, children: "\u25AA" }), _jsxs(Text, { color: MUTED, children: [queued.length, " queued, will run when this finishes \u00B7 /aside to ask without waiting"] })] }), queued.map((q, i) => (_jsx(Box, { paddingLeft: 2, children: _jsx(Text, { color: DIM, children: fitCells(q.split('\n')[0] ?? '', Math.max(20, barWidth - 6), true) }) }, i)))] })), agents.length > 0 && (() => {
                                             const done = agents.filter(a => a.status !== 'running').length;
                                             const failed = agents.filter(a => a.status === 'failed').length;
@@ -5452,7 +5518,7 @@ export function App({ config: initialConfig, clearFrame }) {
                                                                     : elapsedMs > 8_000 ? `no response from ${cfg.provider} yet`
                                                                         : 'starting', thinkingRef.current.chars > 0 && Date.now() - thinkingRef.current.at < 2_000
                                                                 ? ` | thinking, ${fmtTokens(Math.round(thinkingRef.current.chars / 4))} reasoning tokens`
-                                                                : '', ")"] })] }) }), showThinking && thinkingTextRef.current.trim() !== '' && (_jsx(Box, { flexDirection: "column", paddingLeft: 2, children: thinkingTail(thinkingTextRef.current, THINKING_LINES, barWidth - 6).map((line, i) => (_jsx(Text, { color: DIM, italic: true, children: line }, i))) })), _jsx(Box, { paddingLeft: 2, children: _jsx(Text, { color: DIM, children: "esc to cancel and keep your input \u00B7 ctrl+c to exit" }) })] })) }), usagePane && (() => {
+                                                                : '', ")"] })] }) }), showThinking && !ask && thinkingTextRef.current.trim() !== '' && (_jsx(Box, { flexDirection: "column", paddingLeft: 2, children: thinkingTail(thinkingTextRef.current, THINKING_LINES, barWidth - 6).map((line, i) => (_jsx(Text, { color: DIM, italic: true, children: line }, i))) })), _jsx(Box, { paddingLeft: 2, children: _jsx(Text, { color: DIM, children: "esc to cancel and keep your input \u00B7 ctrl+c to exit" }) })] })) }), usagePane && (() => {
                                 const width = Math.min(barWidth, usagePane === 'settings' ? 96 : 66);
                                 const inner = width - 4;
                                 const BAR_W = Math.max(12, inner - 14);
@@ -5789,8 +5855,19 @@ export async function runInkChatMode(config) {
     // appearing at the top with a dead copy of the interface below it — caused by the first version
     // of this repaint, which did exactly that.
     let inkClear;
-    const app = render(_jsx(App, { config: config, clearFrame: () => inkClear?.() }), { exitOnCtrlC: false, patchConsole: false });
+    // Frames go out bracketed as synchronized updates, so the erase-then-redraw Ink performs on
+    // every repaint is composited by the terminal instead of being shown as a blank flash. That is
+    // what allows the animation to run at FRAME_MS; see frame-sync.ts.
+    const app = render(_jsx(App, { config: config, clearFrame: () => inkClear?.() }), { stdout: withSynchronizedFrames(process.stdout),
+        exitOnCtrlC: false, patchConsole: false });
     inkClear = app.clear;
+    // The engine is imported on demand so the banner and the prompt are not waiting on the OpenAI
+    // SDK, execa and ts-morph — 645ms of the 1,163ms it took to load this module on a Raspberry Pi
+    // 5. Warmed here, one tick after the interface is up, so the first turn does not pay for it
+    // either: by the time anything has been typed it is already in memory. Failures are ignored
+    // because this is only a head start — the real import happens at the call site and reports
+    // there.
+    setTimeout(() => { void engine().catch(() => { }); }, 0);
     await app.waitUntilExit();
 }
 //# sourceMappingURL=ink-chat.js.map