koneck 2.25.8 → 2.25.10

package/dist/ink-chat.js

@@ -194,6 +194,15 @@ function Shimmer({ text, frame, base }) {
         }) }));
 }
 export const WORK_WORDS = {
+    // No tool ran: it thought and answered. A cooking metaphor is wrong here — nothing was made.
+    reply: [
+        ['Thinking', 'Thought it through'], ['Weighing it up', 'Weighed it up'],
+        ['Talking it through', 'Talked it through'], ['Laying it out', 'Laid it out'],
+        ['Reading you', 'Read you'], ['Working it out', 'Worked it out'],
+        ['Turning it over', 'Turned it over'], ['Sizing it up', 'Sized it up'],
+        ['Consulting', 'Consulted'], ['Advising', 'Advised'],
+        ['Counselling', 'Counselled'], ['Explaining', 'Explained'],
+    ],
     // Under ~3s. Snappy, almost dismissive — it barely counted as work.
     quick: [
         ['Sharp-sharp', 'Sharp-sharp'], ['Doing it now-now', 'Done now-now'],
@@ -203,6 +212,13 @@ export const WORK_WORDS = {
         ['Zapping', 'Zapped'], ['Sorting', 'Sorted'],
         ['Hot-reloading', 'Hot-reloaded'], ['JIT-compiling', 'JIT-compiled'],
         ['Instant-noodling', 'Instant-noodled'], ['Wazza-ing', "Wazza'd"],
+        // Counter work: over before you have put your wallet away.
+        ['Ringing it up', 'Rung up'], ['Swiping the card', 'Card swiped'],
+        ['Stamping it', 'Stamped'], ['Checking you in', 'Checked in'],
+        ['Taking the register', 'Register taken'], ['Triaging', 'Triaged'],
+        ['Waving it through', 'Waved through'], ['Blowing the whistle', 'Whistle blown'],
+        ['Ticking the box', 'Box ticked'], ['Handing over the key', 'Key handed over'],
+        ['Weighing it', 'Weighed'], ['Bagging it', 'Bagged'],
     ],
     // The everyday middle. General flex and completion.
     normal: [
@@ -220,6 +236,25 @@ export const WORK_WORDS = {
         ['Noodling', 'Noodled'], ['Rubber-ducking', 'Rubber-ducked'],
         ['Tree-shaking', 'Tree-shook'], ['Reticulating', 'Reticulated'],
         ['Letting it cook', 'Let it cook'], ['Getting it oga-certified', 'Oga-certified'],
+        // A shift's honest work: clinic, classroom, shop floor, counting house.
+        ['Doing the rounds', 'Rounds done'], ['Dispensing', 'Dispensed'],
+        ['Dressing the wound', 'Wound dressed'], ['Taking the pulse', 'Pulse taken'],
+        ['Marking the papers', 'Papers marked'], ['Setting the homework', 'Homework set'],
+        ['Taking the lesson', 'Lesson taken'], ['Turning down the beds', 'Beds turned down'],
+        ['Working the front desk', 'Front desk worked'], ['Laying the tables', 'Tables laid'],
+        ['Balancing the books', 'Books balanced'], ['Reconciling', 'Reconciled'],
+        ['Counting the till', 'Till counted'], ['Clearing the cheque', 'Cheque cleared'],
+        ['Running the line', 'Line ran'], ['Tooling up', 'Tooled up'],
+        ['Cutting the pattern', 'Pattern cut'], ['Stitching', 'Stitched'],
+        ['Pressing and finishing', 'Pressed and finished'], ['Grading the sizes', 'Sizes graded'],
+        ['Filing the papers', 'Papers filed'], ['Taking statements', 'Statements taken'],
+        ['Serving the summons', 'Summons served'], ['Standing guard', 'Guard stood'],
+        ['Walking the beat', 'Beat walked'], ['Canvassing', 'Canvassed'],
+        ['Working the room', 'Room worked'], ['Tabling the motion', 'Motion tabled'],
+        ['Haggling', 'Haggled'], ['Setting out the stall', 'Stall set out'],
+        ['Restocking the shelves', 'Shelves restocked'], ['Cashing up', 'Cashed up'],
+        ['Pounding the mealies', 'Mealies pounded'], ['Beating the drum', 'Drum beaten'],
+        ['Sitting with the elders', 'Elders consulted'], ['Weaving the mat', 'Mat woven'],
     ],
     // Over ~10s. Slow heat and visible effort — it earned the wait.
     heavy: [
@@ -234,6 +269,18 @@ export const WORK_WORDS = {
         ['Locking all the way in', 'Locked all the way in'],
         ['Negotiating with malloc', 'Negotiated with malloc'],
         ['Arguing with the type checker', 'Out-argued the type checker'],
+        // The long jobs: a night shift, a whole ward, a case that ran all day.
+        ['Doing the ward round', 'Ward round done'], ['Scrubbing in', 'Scrubbed out'],
+        ['Sitting the long clinic', 'Clinic finished'], ['Marking the whole class', 'Whole class marked'],
+        ['Sitting the exam', 'Exam sat'], ['Running the night shift', 'Night shift done'],
+        ['Working the full run', 'Full run done'], ['Cutting the whole marker', 'Marker cut'],
+        ['Closing the books', 'Books closed'], ['Auditing', 'Audited'],
+        ['Doing the stocktake', 'Stock taken'], ['Arguing the case', 'Case argued'],
+        ['Sitting in chambers', 'Judgment handed down'], ['Building the docket', 'Docket built'],
+        ['Doing the night patrol', 'Patrol done'], ['Standing the long watch', 'Watch stood'],
+        ['Holding the indaba', 'Indaba held'], ['Filibustering', 'Filibustered'],
+        ['Brewing umqombothi', 'Umqombothi brewed'], ['Keeping the fire going', 'Fire kept going'],
+        ['Walking it to market', 'Walked it to market'],
         ['Herding promises', 'Herded the promises'],
         ['Bribing the scheduler', 'Bribed the scheduler'],
         ['Smashing wazobia', 'Smashed wazobia'],
@@ -254,20 +301,49 @@ export const WORK_WORDS = {
         ['Duct-taping', 'Duct-taped'],
     ],
 };
-/** Which vocabulary the wait deserves. */
-export function tierFor(elapsedMs, recovered = false) {
-    if (recovered)
+/**
+ * Whether the turn earned a verb at all.
+ *
+ * "Cooked lekker in 5.0s" for answering "hi" is a boast about nothing: no tool ran, ten tokens
+ * came back, and the only reason it took five seconds is that the provider is slow. Elapsed time
+ * alone cannot tell effort from latency, so a turn that ran no tools and said almost nothing gets
+ * its timing reported plainly and no verb.
+ */
+export function shouldName(effort) {
+    if (effort.recovered)
+        return true; // recovering from a failure is real work
+    if (effort.tools > 0)
+        return true; // it did something to the world
+    return effort.tokens >= 60; // a substantial answer is work; "hi" is not
+}
+/**
+ * Which family of words fits.
+ *
+ * Time still decides between quick, normal and heavy, but only once the turn has done something.
+ * A turn with no tools belongs to `reply` however long it took, because nothing was built and a
+ * cooking verb would be describing work that never happened.
+ */
+export function tierFor(effort) {
+    if (effort.recovered)
         return 'recovery';
-    if (elapsedMs < 3_000)
+    if (effort.tools === 0)
+        return 'reply';
+    if (effort.elapsedMs < 3_000)
         return 'quick';
-    if (elapsedMs > 10_000)
+    if (effort.elapsedMs > 10_000)
         return 'heavy';
     return 'normal';
 }
-/** The gerund to show while working, and the past tense to report when the turn lands. */
-export function workWord(elapsedMs, seed, recovered = false) {
-    const bucket = WORK_WORDS[tierFor(elapsedMs, recovered)];
-    return bucket[Math.abs(seed) % bucket.length];
+/**
+ * The gerund to show while working, and the past tense to report when the turn lands.
+ *
+ * The past tense is empty when the turn did not earn one, which the caller renders as timing
+ * alone.
+ */
+export function workWord(effort, seed) {
+    const bucket = WORK_WORDS[tierFor(effort)];
+    const [gerund, past] = bucket[Math.abs(seed) % bucket.length];
+    return [gerund, shouldName(effort) ? past : ''];
 }
 /** Every slash command, shown in the `/` palette and filtered as you type. */
 const COMMANDS = [
@@ -284,6 +360,7 @@ const COMMANDS = [
     { cmd: '/ask', desc: 'Ask another session and wait: /ask <repo> <question>' },
     { cmd: '/agents', desc: 'How parallel sub-agents are configured' },
     { cmd: '/subtask', desc: 'Run a task in an isolated sub-agent' },
+    { cmd: '/btw', desc: 'Ask a side question without interrupting the running task' },
     { cmd: '/clear', desc: 'Clear conversation history' },
     { cmd: '/new', desc: 'New session (alias of /clear)' },
     { cmd: '/reset', desc: 'Reset session (alias of /clear)' },
@@ -387,6 +464,7 @@ Slash commands:
   /mode [auto|plan|code] Show or set mode
   /effort [low|med|high|max] Set reasoning effort
   /config [key] [value] View or set persistent config
+  /btw <question>       Ask a side question without interrupting the running task
   /usage                Usage pane: session, context, models, limits
   /tokens               Show token usage breakdown
   /cost                 Show session cost
@@ -417,6 +495,8 @@ function App({ config: initialConfig }) {
     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. */
     const [providerFrames, setProviderFrames] = useState(0);
     /**
@@ -435,6 +515,13 @@ function App({ config: initialConfig }) {
     const entriesRef = useRef(null);
     /** Where the `@` being completed starts in the draft. */
     const atStartRef = useRef(-1);
+    /**
+     * Prompts typed while a turn was running.
+     *
+     * Enter used to be swallowed outright, so a thought had to be held until the agent finished or
+     * typed again from memory. Queued prompts run in order as soon as the current turn ends.
+     */
+    const [queued, setQueued] = useState([]);
     /** Pre-edit contents of the files the running tool said it would touch. */
     const pendingDiffRef = useRef([]);
     const charsRef = useRef(0); // streamed chars, for the live token estimate
@@ -456,6 +543,7 @@ function App({ config: initialConfig }) {
      * whatever is left in the buffer.
      */
     function pushSay(text) {
+        lastActivityRef.current = Date.now();
         sayRef.current += text;
         streamedRef.current += text;
         charsRef.current += text.length;
@@ -500,6 +588,8 @@ function App({ config: initialConfig }) {
     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) }));
         liveToolRef.current = { kind: 'tool', name, detail: toolDetail(name, args), startedAt: Date.now() };
@@ -547,6 +637,11 @@ function App({ config: initialConfig }) {
         onChunk: (text) => pushSay(text),
         onToolCall: (name, args) => pushTool(name, args),
         onToolResult: (name, ok, ms) => finishTool(name, ok, ms),
+        onToolOutput: (_name, line) => {
+            lastActivityRef.current = Date.now();
+            if (liveToolRef.current)
+                liveToolRef.current.output = line;
+        },
         onStreamActivity: (frames) => setProviderFrames(frames),
         onAgentProgress: (list) => { agentsRef.current = list; setAgents(list); },
         onTokens: (s) => {
@@ -672,7 +767,9 @@ function App({ config: initialConfig }) {
      *  killing the session or losing what is already in the composer. */
     const abortRef = useRef(null);
     const turnWordRef = useRef(0); // rotation seed, so consecutive turns differ
-    const turnRecoveredRef = useRef(false); // a tool failed and was worked around
+    const turnRecoveredRef = useRef(false);
+    /** Tools this turn has run, which is what separates work from a plain answer. */
+    const turnToolsRef = useRef(0); // a tool failed and was worked around
     const busyStart = useRef(0);
     const wordTimer = useRef(0);
     // Register on the session bus so other running KONECK instances can reach this one.
@@ -732,20 +829,47 @@ function App({ config: initialConfig }) {
         }
         busyStart.current = Date.now();
         wordTimer.current = 0;
-        // 150ms, not 100ms: every tick repaints the whole live region, so the animation frame rate
-        // is also the flicker rate. Six-and-a-bit frames a second still reads as a smooth sweep.
-        const id = setInterval(() => {
+        // The frame rate is the flicker rate. Every tick makes Ink erase and rewrite the whole live
+        // region — measured at 188 line-erases a second, which on a modest terminal reads as the
+        // bottom of the screen flashing. So the rate follows how much is actually happening: quick
+        // while output is arriving, and much slower once a single long command is all that is left,
+        // where a spinner turning four times a second says as much as one turning seven.
+        let timer;
+        const tick = () => {
+            const elapsed = Date.now() - busyStart.current;
             setSpinFrame(f => (f + 1) % SPINNER.length);
             setShimmerFrame(f => f + 1);
-            setElapsedMs(Date.now() - busyStart.current);
+            setElapsedMs(elapsed);
             wordTimer.current += 1;
-            // 150 ticks = 15s. Long enough to read and settle on, short enough that a slow turn
-            // still shows signs of life.
-            if (wordTimer.current % 100 === 0)
-                setSpinWord(w => w + 1); // ~15s per word
-        }, 150);
-        return () => clearInterval(id);
+            // Roughly every 25 seconds, whatever the current rate. Long enough to read the word,
+            // notice it, and still see it change before the wait starts feeling stuck.
+            if (wordTimer.current % Math.max(20, Math.round(25_000 / currentDelay())) === 0) {
+                setSpinWord(w => w + 1);
+            }
+            timer = setTimeout(tick, currentDelay());
+        };
+        const currentDelay = () => {
+            const idleFor = Date.now() - lastActivityRef.current;
+            // Something is still arriving, so keep it lively.
+            if (idleFor < 2_000)
+                return 150;
+            // A long wait with nothing to show: slow right down.
+            return idleFor > 15_000 ? 500 : 250;
+        };
+        timer = setTimeout(tick, 150);
+        return () => clearTimeout(timer);
     }, [busy]);
+    // A queued prompt runs the moment the agent is free again. Keyed on `busy` rather than done
+    // inside the turn's own exit paths, so every way a turn can end — success, failure, cancel —
+    // drains the queue the same way.
+    useEffect(() => {
+        if (busy || queued.length === 0)
+            return;
+        const [next, ...rest] = queued;
+        setQueued(rest);
+        if (next)
+            submitDraft(next);
+    }, [busy, queued]);
     // Ask the terminal to bracket pasted text. Without this a paste is indistinguishable from
     // typing, and there is no way to keep it out of the composer or preserve its line breaks.
     useEffect(() => {
@@ -878,6 +1002,35 @@ function App({ config: initialConfig }) {
             return []; // the pane says so rather than showing zeroes
         }
     }
+    /**
+     * Answers a question without disturbing the turn in flight.
+     *
+     * The agent's own conversation is left untouched: the question runs in a separate, isolated
+     * session, so asking "which model am I on?" mid-build neither interrupts the build nor pollutes
+     * the history the agent is reasoning over. It is the one thing that may jump the queue.
+     */
+    async function askAside(question) {
+        if (!question.trim()) {
+            addSystem('Usage: /btw <question> — answers alongside the running task, without interrupting it.');
+            return;
+        }
+        addRow({ role: 'user', text: `/btw ${question}` });
+        try {
+            const { runAgent } = await import('./engine.js');
+            const result = await runAgent(question, {
+                ...cfg, ci: true, silent: true,
+                // A side question answers from what it is told; it must not edit files behind the
+                // running task's back, so it is given no reason to and kept to a couple of turns.
+                maxTurns: Math.min(cfg.maxTurns, 3),
+            });
+            const last = [...result.messages].reverse()
+                .find(m => m.role === 'assistant' && typeof m.content === 'string' && m.content.trim());
+            addRow({ role: 'agent', text: typeof last?.content === 'string' ? last.content : '(no answer)' });
+        }
+        catch (e) {
+            addSystem(`/btw failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    }
     /** Opens the update panel, checking the registry each time it is opened deliberately. */
     async function openUpdatePane() {
         setUpdatePane({ current: VERSION, latest: null, behind: false, manager: 'npm' });
@@ -1151,6 +1304,11 @@ function App({ config: initialConfig }) {
                 addSystem(`Effort → ${arg}`);
                 return;
             }
+            case '/btw': {
+                // Also available when nothing is running, where it simply answers in a clean context.
+                await askAside(arg);
+                return;
+            }
             case '/usage': {
                 const wanted = USAGE_TABS.find(t => t.startsWith(arg.trim().toLowerCase()));
                 await openUsagePane(wanted ?? 'session');
@@ -1769,8 +1927,24 @@ function App({ config: initialConfig }) {
         // while it works can be typed as it arrives rather than held until the turn ends — and
         // cancelling with esc then hands the keyboard back to a composer that still has it.
         if (key.return) {
-            if (busy)
+            if (busy) {
+                const text = draft.trim();
+                if (!text)
+                    return;
+                // A side question is answered straight away and separately; everything else waits its turn.
+                if (/^\/btw(\s|$)/.test(text)) {
+                    setDraft('');
+                    setCaret(0);
+                    void askAside(text.replace(/^\/btw\s*/, ''));
+                    return;
+                }
+                setQueued(q => [...q, expandPastes(text, pastesRef.current)]);
+                setDraft('');
+                setCaret(0);
+                pastesRef.current = [];
+                setPasteCount(0);
                 return;
+            }
             submitDraft(draft);
             return;
         }
@@ -1917,6 +2091,7 @@ function App({ config: initialConfig }) {
             sayRef.current = '';
             streamedRef.current = '';
             replyStartedRef.current = false;
+            lastActivityRef.current = Date.now();
             setProviderFrames(0);
             liveToolRef.current = null;
             charsRef.current = 0;
@@ -1924,6 +2099,7 @@ function App({ config: initialConfig }) {
             tokBaseRef.current = stats.completionTokens;
             turnWordRef.current = spinWord;
             turnRecoveredRef.current = false;
+            turnToolsRef.current = 0;
             void (async () => {
                 const outTokBefore = stats.completionTokens;
                 try {
@@ -1978,7 +2154,12 @@ function App({ config: initialConfig }) {
                         { role: 'agent', text: body,
                             ...(streamed !== '' && replyStartedRef.current ? { continued: true } : {}),
                             tokens: Math.max(0, active.stats.completionTokens - outTokBefore), elapsed,
-                            done: workWord(elapsed, turnWordRef.current, turnRecoveredRef.current)[1] },
+                            done: workWord({
+                                elapsedMs: elapsed,
+                                tools: turnToolsRef.current,
+                                tokens: Math.max(0, active.stats.completionTokens - outTokBefore),
+                                recovered: turnRecoveredRef.current,
+                            }, turnWordRef.current)[1] },
                     ]);
                     setAgentState('completed');
                     setTimeout(() => setAgentState('ready'), 700);
@@ -2080,7 +2261,7 @@ function App({ config: initialConfig }) {
         const ms = (step.endedAt ?? Date.now()) - step.startedAt;
         const glyph = running ? SPINNER[spinFrame] : step.ok === false ? '✖' : '✓';
         const color = running ? AMBER : step.ok === false ? CRIMSON : GREEN;
-        return (_jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsxs(Box, { gap: 1, children: [_jsx(Text, { color: color, children: glyph }), _jsx(Text, { color: AMBER, bold: true, children: step.name }), _jsx(Text, { color: DIM, children: "\u00B7" }), _jsx(Text, { color: MUTED, children: fmtElapsed(ms) })] }), step.detail !== '' && (step.diffs ?? []).length === 0 && (_jsxs(Box, { paddingLeft: 2, gap: 1, children: [_jsx(Text, { color: DIM, children: "\u2514" }), _jsx(Text, { color: MUTED, children: step.detail })] })), (step.diffs ?? []).map((d, i) => renderDiff(d, i))] }, key));
+        return (_jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsxs(Box, { gap: 1, children: [_jsx(Text, { color: color, children: glyph }), _jsx(Text, { color: AMBER, bold: true, children: step.name }), _jsx(Text, { color: DIM, children: "\u00B7" }), _jsx(Text, { color: MUTED, children: fmtElapsed(ms) })] }), step.detail !== '' && (step.diffs ?? []).length === 0 && (_jsxs(Box, { paddingLeft: 2, gap: 1, children: [_jsx(Text, { color: DIM, children: "\u2514" }), _jsx(Text, { color: MUTED, children: step.detail })] })), running && step.output && (_jsx(Box, { paddingLeft: 4, children: _jsx(Text, { color: DIM, children: fitCells(step.output, Math.max(20, barWidth - 6)) }) })), (step.diffs ?? []).map((d, i) => renderDiff(d, i))] }, key));
     };
     return (_jsxs(Box, { flexDirection: "column", width: uiWidth, paddingX: 2, children: [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: rows, children: (row, index) => row.role === 'header' ? (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { flexDirection: "column", alignItems: "center", marginTop: 1, marginBottom: 1, children: [_jsx(Text, { color: CYAN, bold: true, children: "KONECK  /  SOFTWARE DELIVERY SYSTEM" }), _jsx(Text, { color: MUTED, children: "Deliberate engineering, with control at every change." })] }), _jsx(Panel, { width: barWidth, color: CYAN, title: "KONECK", children: [`MODEL: \`${modelShort}\`   PROVIDER: \`${cfg.provider}\`   WORKSPACE: \`${workspace}\``] })] }, index)) : row.role === 'user' ? (
                 // Painted as a filled bar so the user's own words are the most findable thing
@@ -2096,8 +2277,8 @@ function App({ config: initialConfig }) {
                 // content, so the right edge stepped in and out; and a box inside a box left
                 // markdown tables needlessly narrow. A marker plus the content reads better and
                 // cannot misalign, which is how Claude Code presents its own answers.
-                _jsxs(Box, { flexDirection: "column", marginTop: row.continued ? 0 : 1, children: [_jsxs(Box, { gap: 1, children: [_jsx(Text, { color: CYAN, bold: true, children: row.continued ? '  ' : 'ꞰK' }), _jsx(Box, { flexDirection: "column", children: _jsx(Markdown, { text: row.text ?? '', width: barWidth - 3 }) })] }), row.tokens != null && (_jsxs(Text, { color: MUTED, children: [_jsx(Text, { color: GREEN, children: "* " }), row.done ?? 'Done', " in ", fmtElapsed(row.elapsed ?? 0), '  |  ', row.tokens, " tokens", '  |  ', cfg.provider, " ", modelShort] }))] }, index)) }), _jsx(Box, { flexDirection: "column", 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 ? '  ' : 'ꞰK' }), _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), agents.length > 0 && (() => {
+                _jsxs(Box, { flexDirection: "column", marginTop: row.continued ? 0 : 1, children: [_jsxs(Box, { gap: 1, children: [_jsx(Text, { color: CYAN, bold: true, children: row.continued ? '  ' : 'ꞰK' }), _jsx(Box, { flexDirection: "column", children: _jsx(Markdown, { text: row.text ?? '', width: barWidth - 3 }) })] }), row.tokens != null && (_jsxs(Text, { color: MUTED, children: [_jsx(Text, { color: GREEN, children: "* " }), row.done ? `${row.done} in ${fmtElapsed(row.elapsed ?? 0)}` : fmtElapsed(row.elapsed ?? 0), '  |  ', row.tokens, " tokens", '  |  ', cfg.provider, " ", modelShort] }))] }, index)) }), _jsx(Box, { flexDirection: "column", 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 ? '  ' : 'ꞰK' }), _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 /btw 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;
                             const tokens = agents.reduce((n, a) => n + a.tokens, 0);
@@ -2114,7 +2295,10 @@ function App({ config: initialConfig }) {
                                         const task = a.task.length > taskWidth ? a.task.slice(0, taskWidth - 3) + '...' : a.task;
                                         return (_jsxs(Box, { paddingLeft: 2, gap: 1, children: [_jsx(Text, { color: color, children: glyph }), _jsx(Text, { color: DIM, children: String(a.index + 1).padStart(2) }), _jsx(Text, { color: a.status === 'running' ? INK : MUTED, children: fitCells(task, taskWidth) }), _jsx(Text, { color: DIM, children: humanTokens(a.tokens).padStart(6) }), _jsx(Text, { color: DIM, children: fmtElapsed(took).padStart(6) })] }, a.index));
                                     })] }));
-                        })(), _jsx(Box, { marginTop: 1, children: _jsxs(Text, { children: [_jsxs(Text, { color: GREEN, children: [SPINNER[spinFrame], " "] }), _jsx(Shimmer, { text: workWord(elapsedMs, spinWord, turnRecoveredRef.current)[0], frame: shimmerFrame, base: MUTED }), _jsx(Text, { color: MUTED, children: "\u2026 " }), _jsxs(Text, { color: DIM, children: ["(", fmtElapsed(elapsedMs), " | ", liveTokens > 0
+                        })(), _jsx(Box, { marginTop: 1, children: _jsxs(Text, { children: [_jsxs(Text, { color: GREEN, children: [SPINNER[spinFrame], " "] }), _jsx(Shimmer, { text: workWord({
+                                            elapsedMs, tools: turnToolsRef.current,
+                                            tokens: liveTokens, recovered: turnRecoveredRef.current,
+                                        }, spinWord)[0], frame: shimmerFrame, base: MUTED }), _jsx(Text, { color: MUTED, children: "\u2026 " }), _jsxs(Text, { color: DIM, children: ["(", fmtElapsed(elapsedMs), " | ", liveTokens > 0
                                                 ? `${fmtTokens(liveTokens)} tokens`
                                                 // A gateway routing to several backends sends content-free frames while it
                                                 // finds one. Saying "waiting for the first token" through that reads as a