koneck 2.128.36 → 2.128.38

package/dist/ink-chat.js

@@ -4,7 +4,7 @@ import { Box, Static, Text, render, useApp, useInput, useStdin } from 'ink';
 import { execa } from 'execa';
 import chalk from 'chalk';
 import { resolveAgentConcurrency, toolsUnsupportedNotice } from './engine-facts.js';
-import { withSynchronizedFrames, probeSynchronizedOutput } from './frame-sync.js';
+import { withSynchronizedFrames, withUsableSize, probeSynchronizedOutput } from './frame-sync.js';
 import { pacedInterval, startingInterval, floorFor, shouldDrawFrame } from './frame-pace.js';
 import { estimateCost, formatCost, rateText } from './pricing.js';
 import { generateSessionId, saveSession, listSessions, loadSession, relativeAge, renameSession, forkSession, archiveSession, findSession, } from './session.js';
@@ -48,6 +48,7 @@ const VERSION = (() => {
 import { startBus, listSessions as listBusSessions, resolveTarget, deliver, } from './session-bus.js';
 import { MODES as MODE_SPECS, modeSpec, decide, loadRules, saveRules, addRule, commandPrefixSuggestion, describeRule, ruleMatches, toolRisk, isReadOnlyCommand, } from './permissions.js';
 import { AskQueue } from './ask-queue.js';
+import { contextLimitWithSource } from './context-limit.js';
 import { planSummary } from './plan.js';
 import { savePlan, plansDir, PLAN_CHOICES, PROCEED_PROMPT } from './plan-file.js';
 import { logoFor } from './logo.js';
@@ -2052,8 +2053,25 @@ export function App({ config: initialConfig, clearFrame, synchronizedFrames = fa
                 liveToolRef.current.output = line;
         },
         onStreamActivity: (frames) => {
+            /*
+             * A keep-alive is not news, and only the first one changes anything on screen.
+             *
+             * A gateway looking for a backend sends content-free frames, several a second, for as long
+             * as it takes. Each one asked for a repaint, so a turn waiting on a slow provider redrew
+             * the interface two or three times a second to show a clock — measured against the live
+             * session: 13KB a second written to the terminal and 13% of a core, two hours into a turn
+             * that was still waiting. On a terminal that cannot composite a redraw, every one of those
+             * is a visible flash.
+             *
+             * The first frame is worth painting: it is what turns "starting" into "the provider is
+             * holding the line, no output yet". After that nothing it carries is new, and the heartbeat
+             * — once a second, and only while nothing else is painting — is what says the session is
+             * still alive.
+             */
+            const first = providerFramesRef.current === 0 && frames > 0;
             providerFramesRef.current = frames;
-            requestIncomingPaint();
+            if (first)
+                requestIncomingPaint(true);
         },
         onIncomplete: (reason) => { incompleteRef.current = reason; },
         onToolsUnsupported: (model) => {
@@ -2751,7 +2769,7 @@ export function App({ config: initialConfig, clearFrame, synchronizedFrames = fa
                  * a keystroke.
                  */
                 if (prev !== cols)
-                    redrawScreenRef.current?.();
+                    redrawScreenRef.current?.({ keepScrollback: true });
                 return cols;
             });
         };
@@ -3209,7 +3227,17 @@ export function App({ config: initialConfig, clearFrame, synchronizedFrames = fa
      * lives in the session rather than in the terminal's memory of it.
      */
     redrawScreenRef.current = redrawScreen;
-    function redrawScreen() {
+    /**
+     * Repaint the terminal from scratch.
+     *
+     * `keepScrollback` is the difference between the two callers. Ctrl+L is somebody asking for a
+     * clean slate after something has gone wrong on screen, and a stranded frame that has scrolled
+     * out of view is still in the buffer waiting to come back — so that one takes the scrollback
+     * with it. A resize is not a request for anything: it re-flows the conversation because the
+     * width changed, and throwing away everything the person had scrolled past would be a far
+     * larger thing than they asked for.
+     */
+    function redrawScreen(opts = {}) {
         if (!process.stdout.isTTY)
             return;
         // Ink's own clear first. It erases the frame using its own count of it and then resets that
@@ -3219,7 +3247,7 @@ export function App({ config: initialConfig, clearFrame, synchronizedFrames = fa
         // Then the screen, and the scrollback with it — a stranded frame that has scrolled out of view
         // is still in the buffer, and leaving it there means it comes back on the next scroll — and
         // home the cursor, which is where Ink will now draw.
-        process.stdout.write('\u001b[2J\u001b[3J\u001b[H');
+        process.stdout.write(opts.keepScrollback ? '\u001b[2J\u001b[H' : '\u001b[2J\u001b[3J\u001b[H');
         // The transcript has just been erased along with everything else, so it has to be written
         // again — and writing it again is also what re-flows it to the current width.
         setStaticEpoch(n => n + 1);
@@ -3329,7 +3357,19 @@ export function App({ config: initialConfig, clearFrame, synchronizedFrames = fa
                 ...cfg,
                 provider,
                 model: meta.model || cfg.model,
-                baseURL: endpointFor(provider).url,
+                /*
+                 * An endpoint the session was started with survives the resume.
+                 *
+                 * This re-resolved from the provider's saved endpoint unconditionally, which is right
+                 * when the resume changes provider and wrong when it does not: a session started against
+                 * an explicit `--base-url`, a company gateway, or a local runtime on another machine was
+                 * silently moved back to whatever the config file named. The request then went somewhere
+                 * the person had deliberately pointed away from, and the first sign of it was a rejected
+                 * credential from an endpoint they were not using.
+                 */
+                baseURL: provider !== cfg.provider
+                    ? endpointFor(provider).url
+                    : (cfg.baseURL ?? endpointFor(provider).url),
                 ...(typeof meta.requireApproval === 'boolean' ? { requireApproval: meta.requireApproval } : {}),
             };
             cfgRef.current = restoredCfg;
@@ -3359,14 +3399,58 @@ export function App({ config: initialConfig, clearFrame, synchronizedFrames = fa
             setSessionId(id); // continue this session rather than forking a new one
             resumedIdRef.current = id;
             startedAtRef.current = meta.startedAt ?? startedAtRef.current;
+            /*
+             * The conversation as it was, tool calls included.
+             *
+             * Only prose was restored before, so a resumed session came back as a handful of stray
+             * sentences with nothing between them — every file read, command and edit dropped on the
+             * floor. Measured on a real saved session: eighteen messages, of which five were the
+             * assistant calling tools and nine were the results, and seven survived the restore.
+             * Reported as resuming "differently, as a summary".
+             *
+             * A tool result says whether it worked, so the marks are the ones the session showed at the
+             * time rather than a row of hopeful ticks. There are no timings in the file — durations are
+             * not saved — so each step is written as having taken no measurable time, which is honest:
+             * this is a record of what happened, not a replay of how long it took.
+             */
+            const resultFor = new Map();
+            for (const m of messages) {
+                if (m.role !== 'tool')
+                    continue;
+                const body = typeof m.content === 'string' ? m.content : '';
+                resultFor.set(String(m.tool_call_id ?? ''), {
+                    // The engine writes failures into the result body; nothing else records the outcome.
+                    ok: !/^\s*(error|failed|could not|cannot)\b/i.test(body),
+                    text: body,
+                });
+            }
             const restored = [{ role: 'header' }];
             for (const m of messages) {
                 if (m.role === 'user' && typeof m.content === 'string' && !m.content.startsWith('[')) {
                     restored.push({ role: 'user', text: m.content });
+                    continue;
                 }
-                else if (m.role === 'assistant' && typeof m.content === 'string' && m.content.trim()) {
+                if (m.role !== 'assistant')
+                    continue;
+                if (typeof m.content === 'string' && m.content.trim()) {
                     restored.push({ role: 'agent', text: m.content });
                 }
+                const calls = m.tool_calls;
+                if (!calls?.length)
+                    continue;
+                const steps = calls.map(c => {
+                    const name = c.function?.name ?? 'tool';
+                    const result = resultFor.get(String(c.id ?? ''));
+                    return {
+                        kind: 'tool',
+                        name,
+                        detail: toolDetail(name, c.function?.arguments ?? '{}'),
+                        startedAt: 0,
+                        endedAt: 0,
+                        ...(result ? { ok: result.ok } : {}),
+                    };
+                });
+                restored.push({ role: 'steps', steps });
             }
             setRows(restored);
             setStats({
@@ -3377,8 +3461,33 @@ export function App({ config: initialConfig, clearFrame, synchronizedFrames = fa
                 `  ${meta.turns} turns, ${meta.totalTokens.toLocaleString()} tokens\n` +
                 `  originally: ${meta.provider}/${meta.model}\n` +
                 `  posture: ${meta.mode ?? 'auto'} mode · ${meta.effort ?? 'medium'} effort · approval ${typeof meta.requireApproval === 'boolean' ? (meta.requireApproval ? 'on' : 'off') : 'current'}\n` +
-                `  task: ${meta.task.slice(0, 90)}\n\n` +
-                `The agent has the full history; carry on where it left off.`);
+                `  task: ${meta.task.slice(0, 90)}`);
+            /*
+             * Pick up where it stopped, when there is somewhere to pick up from.
+             *
+             * Resuming used to restore everything and then wait, so the first thing anybody typed was
+             * some version of "carry on" — retyping an instruction the session already held. Reported
+             * against Claude Code, which resumes and continues.
+             *
+             * Only when the plan says there is work left. A session whose plan is finished has nothing
+             * to continue and resuming it is almost always somebody looking at what happened, so
+             * spending tokens on their behalf would be presumptuous. With unfinished steps it is the
+             * opposite: the session exists precisely because that work is not done.
+             *
+             * `resumeContinues: false` turns it off, and it never fires for a session with no plan —
+             * there would be nothing to say about what remained.
+             */
+            const unfinished = restoredPlan?.steps.filter(st => st.state !== 'done') ?? [];
+            if (cfg.resumeContinues !== false && unfinished.length > 0) {
+                const next = unfinished[0].text;
+                addSystem(`Carrying on — ${unfinished.length} step${unfinished.length === 1 ? '' : 's'} `
+                    + `left, starting with "${next.slice(0, 70)}". Esc stops it.`);
+                setTimeout(() => submitDraft('Continue the plan above from where it stopped. Do not restate it or start again — '
+                    + 'pick up the first step that is not done and carry on.'), 0);
+            }
+            else {
+                addSystem('The agent has the full history; carry on where it left off.');
+            }
         }
         catch (e) {
             addSystem(`Could not resume ${id}: ${e instanceof Error ? e.message : String(e)}`);
@@ -6949,7 +7058,22 @@ export function App({ config: initialConfig, clearFrame, synchronizedFrames = fa
                                     }
                                 }
                                 if (usagePane === 'context') {
-                                    const window = modelCatalog.find(m => m.id === cfg.model)?.contextLength ?? contextWindowFor(cfg.model);
+                                    /*
+                                     * Where the number came from, said out loud.
+                                     *
+                                     * The window drives compaction, and compaction is the difference between a session that
+                                     * remembers what it found and one that keeps going back to re-read it. When the figure
+                                     * is a guess from the model's name — which it is for most hosted models, because almost
+                                     * none of them publish a context length in `/models` — the person needs to know that,
+                                     * because they are the only one who can correct it.
+                                     */
+                                    const published = modelCatalog.find(m => m.id === cfg.model)?.contextLength;
+                                    const guess = contextLimitWithSource(cfg.model, cfg.contextTokens, servesOwnWeights(cfg.provider));
+                                    const window = published ?? guess.limit;
+                                    const source = published !== undefined ? 'published by the provider'
+                                        : guess.source === 'configured' ? 'set by you'
+                                            : guess.source === 'known' ? 'known for this model'
+                                                : 'assumed — this model publishes no window';
                                     lines.push('**Context window**', '');
                                     if (window) {
                                         // This is cumulative across the session, not a made-up claim about the next request.
@@ -6957,6 +7081,11 @@ export function App({ config: initialConfig, clearFrame, synchronizedFrames = fa
                                         // history, but only the provider can count the exact request after compaction.
                                         const used = stats.promptTokens;
                                         lines.push(...meter(Math.min(1, used / window), `${humanTokens(used)} session prompt total · ${humanTokens(window)} window · ${cfg.model}`));
+                                        lines.push(`Window: ${window.toLocaleString()} tokens — ${source}.`);
+                                        if (guess.source === 'assumed' && published === undefined) {
+                                            lines.push('If the real one is larger, say so: `/config contextTokens <number>`. '
+                                                + 'Compacting earlier than necessary makes a session forget what it just read.');
+                                        }
                                         if (used / window > 0.7) {
                                             lines.push('Close to the window. `/clear` starts fresh,');
                                             lines.push('`/rewind` drops just the last exchange.');
@@ -7253,7 +7382,34 @@ export async function runInkChatMode(config) {
      * frame is a visible blink of the whole screen. 150ms at worst, once, on startup.
      */
     const synchronizedFrames = await probeSynchronizedOutput().catch(() => false);
-    const app = render(_jsx(App, { config: config, synchronizedFrames: synchronizedFrames, clearFrame: () => inkClear?.() }), { stdout: withSynchronizedFrames(process.stdout),
+    /*
+     * A clean screen to start on.
+     *
+     * KONECK opened wherever the shell had got to, so a session begun after an `npm install` sat
+     * under a wall of its output with the banner halfway down the screen — it read as another
+     * command that had printed something, rather than as a program that had taken over. Reported
+     * exactly that way: "it fails to take over the terminal and not appear as if it's a command".
+     *
+     * `ESC[2J ESC[H` and nothing more. Deliberately not `ESC[3J`, which empties the scrollback too:
+     * whatever was on screen a moment ago is still there to scroll back to, which is the difference
+     * between clearing the screen and throwing away somebody's last command. Same sequence `clear`
+     * uses, for the same reason.
+     *
+     * Written before Ink starts, so its idea of what it has drawn begins at zero and matches the
+     * screen. Doing this after the first frame is what once left a dead copy of the interface
+     * pinned below a working one.
+     *
+     * Not on the alternate screen, which arrives blank by definition, and not when the output is
+     * not a terminal at all.
+     */
+    if (config.clearOnStart !== false && process.stdout.isTTY
+        && initialAltScreen(config, synchronizedFrames) === false) {
+        process.stdout.write('\u001b[2J\u001b[H');
+    }
+    const app = render(_jsx(App, { config: config, synchronizedFrames: synchronizedFrames, clearFrame: () => inkClear?.() }), 
+    // Sized first, then bracketed: Ink must never be handed a stream that
+    // says it is zero rows tall. See withUsableSize.
+    { stdout: withSynchronizedFrames(withUsableSize(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