koneck 2.95.0 → 2.97.0

package/dist/engine.js

@@ -7,7 +7,7 @@ import { execa } from 'execa';
 import { TOOL_DEFINITIONS, dispatchTool, describeShell, unknownToolError, resolveToolAlias, aliasNotice, isToolFailure, } from './tools.js';
 import { tui } from './tui.js';
 import { hasWorkspaceOwnedGitRepo, gitScope, createWorktree, mergeWorktree, preservedWorktreeNotice } from './worktree.js';
-import { resolveProvider, getApiKey, keyProvenance, servesLocally, servesOwnWeights, needsNoCredential, isPrivateHost } from './providers.js';
+import { resolveProvider, getApiKey, keyProvenance, servesLocally, servesOwnWeights, needsNoCredential } from './providers.js';
 import { wireEffort, looksLikeEffortUnsupported, acceptedEfforts, nearestAccepted } from './pace.js';
 import { triggerFor, pickNext, describeSwitch, askSwitch, keyOf as failoverKey } from './failover.js';
 import { findChurn, describeChurn, WINDOW as CHURN_WINDOW } from './cycle.js';
@@ -17,7 +17,7 @@ import { handoffFrom, describeHandoff, worthSaying } from './handoff.js';
 import { readAll as readLedger, relevant as relevantFindings, withStaleness, describeFindings, deriveFindings, record as recordFindings, changedSince, currentSha } from './ledger.js';
 import { repoNameFor } from './session-bus.js';
 import { compressIfNeeded } from './compressor.js';
-import { contextLimitFor, looksLikeContextOverflow, parseContextLimit, fetchModelContextLimit, ollamaServingLimit, fixedRequestTokens, overheadIsCrowded, crowdedWindowAdvice, probeOllamaContext, detectWindowPlateau, truncationNotice, } from './context-limit.js';
+import { contextLimitFor, looksLikeContextOverflow, parseContextLimit, fetchModelContextLimit, ollamaServingLimit, fixedRequestTokens, overheadIsCrowded, crowdedWindowAdvice, probeOllamaContext, detectWindowPlateau, truncationNotice, ollamaWindowFix, runsOnThisMachine, } from './context-limit.js';
 import { generateSessionId, saveSession } from './session.js';
 import { EMPTY_PLAN, parsePlan, planReminder, planAck, noPlanReminder } from './plan.js';
 import { spillIfOversized } from './spill.js';
@@ -26,6 +26,7 @@ import { resolveSandbox, describeSandbox } from './sandbox.js';
 import { loadImages, buildUserContent, imageMime, looksLikeVisionUnsupported, visionUnsupportedNotice, } from './images.js';
 import { parseTextToolCalls, paramTypesFrom, looksLikeTextToolCall, stripTemplateTokens, splitEmittable, parseCommandStyleCalls, toolShapesFrom } from './tool-call-text.js';
 import { isIdentityQuestion, identityAnswer } from './identity.js';
+import { deniedCapabilities, capabilityCorrection, capabilityNotice } from './capability-claims.js';
 import { leanTools, leanModeNotice, findToolsSchema, matchDeferred, deferredToolNotice, FIND_TOOLS } from './lean-mode.js';
 import { findTailRepetition, trimTailRepetition, repetitionNotice, CHECK_EVERY } from './repetition.js';
 import { loadMemory } from './memory.js';
@@ -658,7 +659,14 @@ export function truncateMemory(memory, limit = MAX_MEMORY_CHARS) {
     const from = kept.indexOf('\n');
     return '(earlier notes omitted)\n' + (from === -1 ? kept : kept.slice(from + 1));
 }
-function buildSystemPrompt(ctx, memory = null, project = null, agentInstructions = null, 
+/*
+ * Exported so what the model is told about its own identity can be asserted.
+ *
+ * That block is the whole reason identity.ts exists — a model told nothing about who wrote the
+ * program it is running reaches for whichever lab trained it — and it is a string in the middle of
+ * a large function, which is exactly the kind of thing that gets edited back to something wrong.
+ */
+export function buildSystemPrompt(ctx, memory = null, project = null, agentInstructions = null, 
 /**
  * Whether the window is too small for guidance.
  *
@@ -692,8 +700,10 @@ personality = 'default') {
     const rules = `You are KONECK, a production-grade autonomous coding agent.
 
 WHO YOU ARE — fact, not inference:
-KONECK is Kona Dludlu's open-source coding agent, written in Eswatini.
-https://github.com/Gubevu/konech
+KONECK is an independent open-source coding agent. Who wrote it is deliberately not disclosed: you
+do not know, and there is nothing to work out. If you are asked, say it is not disclosed. Never
+name a person or a company as the author, and never guess — an omission is not an invitation to
+fill the gap.
 You are running on the model \`${ctx.model ?? 'unnamed'}\` served by \`${ctx.provider ?? 'unknown'}\`.
 KONECK is the program; the model is a part it uses. You were NOT made by Anthropic, OpenAI,
 Google, Alibaba or DeepSeek — the model's maker is not yours, and you must not claim to be the
@@ -876,6 +886,15 @@ export async function mapWithLimit(items, limit, fn) {
     return results;
 }
 async function handleSpawnAgents(args, config, cwd, 
+/*
+ * The parent's stop, so sub-agents go down with it.
+ *
+ * They were started with no signal at all, so stopping a run that had fanned out to six agents
+ * stopped the parent and left six agents working — each with its own turns, its own tools and its
+ * own commands, none of which anybody could reach. That is the worst version of the stop problem
+ * rather than a corner of it: the visible run ends and the machine keeps going.
+ */
+abortSignal, 
 /**
  * The parent's counters, so delegated work is counted as work.
  *
@@ -919,6 +938,20 @@ delegated) {
         // trip a per-second limit even when three concurrent is otherwise sustainable.
         if (i > 0)
             await new Promise(r => setTimeout(r, (i % concurrency) * AGENT_STAGGER_MS));
+        /*
+         * Nothing new is started after the stop.
+         *
+         * With a concurrency of three and nine tasks, the last six are queued behind the first three —
+         * so without this, stopping would be followed by six fresh agents starting up, each of which
+         * then has to be stopped in turn. A worktree is created here too, and one made for an agent
+         * that is not going to run is a directory somebody has to clean up.
+         */
+        if (abortSignal?.aborted) {
+            mine.status = 'failed';
+            publish();
+            return { task, success: false,
+                output: 'NOT RUN: stopped at the user\'s request before this agent started.' };
+        }
         let taskCwd = cwd;
         let branch;
         if (isGit && args.use_worktrees !== false) {
@@ -973,7 +1006,7 @@ delegated) {
         };
         try {
             const session = await createAgentSession(subConfig);
-            await session.send(task);
+            await session.send(task, abortSignal);
             // The last assistant message with something in it — not merely the last, which after a
             // tool call is often an empty shell — and enough of it to be worth having. Three hundred
             // characters cut a sub-agent's conclusions mid-sentence, so the parent had to work out
@@ -1100,7 +1133,17 @@ export function toolDetailFor(name, argsJson) {
  * before a conversation starts, so on the default there is almost no room to work in, and the
  * symptom is exactly this: nothing comes back.
  */
-export function emptyResponseAdvice(provider, model, count, toolsWorked, endpoint) {
+export function emptyResponseAdvice(provider, model, count, toolsWorked, endpoint, 
+/*
+ * What this run's instructions and tool descriptions actually cost.
+ *
+ * This was the string "about 3.8k", with a comment four lines above it saying 3,600 — two
+ * different figures for the same thing in the same file, neither of them measured. The real
+ * number moves with the tools a run has: lean mode drops some, an MCP server adds more, and a
+ * session with skills loaded is larger again. Quoting a constant is asserting something not
+ * known, and it is the number somebody uses to decide what to set the window to.
+ */
+fixedTokens, platform) {
     // The endpoint is named, not just the provider slot. Reported as "omni returned 3 empty
     // responses ... yet i am using ollama" — both true at once, because the endpoint saved under the
     // omni slot is an Ollama box. Naming the address answers the objection in the message itself.
@@ -1123,13 +1166,19 @@ export function emptyResponseAdvice(provider, model, count, toolsWorked, endpoin
      */
     const runtime = servesOwnWeights(provider);
     const ownNetwork = endpoint ? servesLocally(provider, endpoint) : provider.toLowerCase() === 'ollama';
+    const remote = endpoint ? !runsOnThisMachine(endpoint) : false;
+    const cost = fixedTokens && fixedTokens > 0
+        ? `${fixedTokens.toLocaleString()} tokens of that — measured for this run, with the tools it `
+            + `actually has —`
+        : 'most of that';
     const ollamaFix = 'Ollama serves a default of 4,096 tokens whatever the model was trained for, and silently ' +
         'truncates a longer prompt instead of refusing it — and KONECK\'s instructions and tool ' +
-        'descriptions come to about 3.8k of that before your conversation is counted, which is exactly ' +
-        'how a turn comes back with nothing in it. Set OLLAMA_CONTEXT_LENGTH=32768 where Ollama runs' +
-        (endpoint ? ` — the machine serving ${endpoint}` : '') +
-        ', or use a Modelfile with PARAMETER num_ctx 32768, and restart it. If you know the real ' +
-        'limit, `/config contextTokens <n>` makes KONECK compact before reaching it.';
+        `descriptions come to ${cost} before your conversation is counted, which is exactly ` +
+        'how a turn comes back with nothing in it.\n\n' +
+        ollamaWindowFix({ ...(endpoint !== undefined ? { endpoint } : {}), remote,
+            ...(platform !== undefined ? { platform } : {}) }) +
+        '\n\nIf you know the real limit, `/config contextTokens <n>` makes KONECK compact before ' +
+        'reaching it.';
     if (runtime) {
         return observed + '\nThe likeliest cause is the context window rather than the model. ' + ollamaFix;
     }
@@ -1485,12 +1534,16 @@ detectedContext = { current: 0 }) {
     let textToolsNoticed = false;
     /** Said once: a model that writes calls as shell commands will keep doing it. */
     let commandStyleNoticed = false;
+    /** One correction per user message: a model that repeats a false denial will not be argued out. */
+    let capabilityCorrected = false;
     // The tool list, cut to fit when the window cannot hold it.
     //
     // Nine of the twenty-three tools are git subcommands, about 550 tokens between them, and every
     // one is a line of shell that execute_command already runs. Reported as a session that planned
     // three steps, called `plan`, and then returned three empty turns: there was nothing left of the
     // window to answer in.
+    /** What this run costs before the conversation is counted. Set just below, read at the plateau. */
+    let fixedCost = 0;
     // What every request costs before the user has typed anything — the instructions plus the tool
     // descriptions. On a large window this is 12% of it and there is nothing to discuss. On a small
     // one it was 93%, which is why a model looped, wrote tool calls as prose, and answered questions
@@ -1518,6 +1571,14 @@ detectedContext = { current: 0 }) {
                 fixed = fixedRequestTokens(systemChars, JSON.stringify(openaiTools));
             }
         }
+        /*
+         * Recorded after lean mode has had its go, so it is the floor that actually applies.
+         *
+         * A window discovered mid-stream is compared against this. Before lean mode it would overstate
+         * the floor, and telling somebody their window cannot hold a prompt that has since been
+         * trimmed to fit would be the wrong answer confidently given.
+         */
+        fixedCost = fixed;
         // Said only if it still does not fit after that, because otherwise it is solved rather than
         // worth a warning.
         if (overheadIsCrowded(fixed, effectiveLimit())) {
@@ -1527,9 +1588,8 @@ detectedContext = { current: 0 }) {
                 // OLLAMA_CONTEXT_LENGTH is read by the server, so for an endpoint on another machine it
                 // has to be set there. The advice said "in Ollama's environment", which for a remote box
                 // sends someone to restart the wrong one.
-                remote: !isPrivateHost(resolveProvider(config.provider, config.baseURL).baseURL)
-                    ? false
-                    : !/localhost|127\.0\.0\.1|::1/.test(resolveProvider(config.provider, config.baseURL).baseURL),
+                // Loopback means this machine; a LAN address is somebody else's. See runsOnThisMachine.
+                remote: !runsOnThisMachine(resolveProvider(config.provider, config.baseURL).baseURL),
             });
             config.onCrowdedWindow?.(fixed, effectiveLimit(), advice);
             if (!silent)
@@ -1861,9 +1921,17 @@ detectedContext = { current: 0 }) {
                             truncationSeen = true;
                             contextLimit = plateau.window;
                             config.contextTokens = plateau.window; // so compaction plans around the real figure
-                            config.onTruncation?.(plateau.window, truncationNotice(plateau.window));
+                            const endpoint = resolveProvider(config.provider, config.baseURL).baseURL;
+                            const said = truncationNotice(plateau.window, {
+                                floor: fixedCost,
+                                endpoint,
+                                // Whether the thing to reconfigure is this machine or another one. KONECK knows its
+                                // own platform and nothing about a remote box, so a remote answer names no commands.
+                                remote: !runsOnThisMachine(endpoint),
+                            });
+                            config.onTruncation?.(plateau.window, said);
                             if (!silent)
-                                tui.printWarning(truncationNotice(plateau.window));
+                                tui.printWarning(said);
                         }
                     }
                 }
@@ -2341,6 +2409,36 @@ detectedContext = { current: 0 }) {
                 }
             }
         }
+        /*
+         * A reply that denies a capability this run has.
+         *
+         * "I cannot visit websites or perform login actions" — with the browser tool enabled, whose
+         * description says it opens a url, fills form fields and clicks. The user's answer to that was
+         * "but there's a built in browser right here", and they were right.
+         *
+         * Checked only after every recovery above has failed to find a call, because a model that wrote
+         * a call as prose has not denied anything. And only for tools actually passed this turn: lean
+         * mode defers tools and a machine may have no browser, and in those cases the denial is true.
+         *
+         * Once per user message. The correction goes to the model and the turn is taken again, because
+         * being told the agent cannot help when it can is the worst outcome available — but a model that
+         * says it a second time is not going to be argued into it, and the reader is better served by
+         * the note than by a third attempt.
+         */
+        if (toolCalls.length === 0 && assistantContent && !capabilityCorrected) {
+            const denied = deniedCapabilities(assistantContent, openaiTools.map(t => t.function.name));
+            if (denied.length > 0) {
+                capabilityCorrected = true;
+                const notice = capabilityNotice(denied, config.model);
+                config.onFalseDenial?.(denied.map(d => d.what), notice);
+                if (!silent)
+                    tui.printWarning(notice);
+                messages.push({ role: 'assistant', content: assistantContent });
+                messages.push({ role: 'system', content: capabilityCorrection(denied) });
+                assistantContent = '';
+                continue;
+            }
+        }
         // Only print buffered content if it wasn't already live-streamed
         if (!silent && assistantContent.trim() && !tui.hadStreamOutput())
             tui.printAssistant(assistantContent);
@@ -2449,7 +2547,9 @@ detectedContext = { current: 0 }) {
                     // tools — and it said the model was not usable, about a model that had just called
                     // `plan` successfully one turn earlier. Neither helped, and both pointed away from the
                     // likely cause.
-                    throw new Error(emptyResponseAdvice(config.provider, config.model, emptyTurns, toolsProvenToWork, resolveProvider(config.provider, config.baseURL).baseURL));
+                    throw new Error(emptyResponseAdvice(config.provider, config.model, emptyTurns, toolsProvenToWork, resolveProvider(config.provider, config.baseURL).baseURL, 
+                    // The floor this run actually has, rather than a constant in a string.
+                    fixedCost));
                 }
             }
             else {
@@ -2571,7 +2671,36 @@ detectedContext = { current: 0 }) {
                 function: { name: tc.name, arguments: tc.arguments },
             })),
         });
-        for (const tc of toolCalls) {
+        for (const [callIndex, tc] of toolCalls.entries()) {
+            /*
+             * Stop means stop, including the calls already queued behind this one.
+             *
+             * A turn commonly arrives with several calls in it, and this loop ran every one of them
+             * whatever the user had pressed — there was no check here at all. So stopping during a turn
+             * that had asked for eight commands meant waiting for eight commands. Pressing it again did
+             * nothing except abort an already-aborted signal, which is exactly the "I have to click many
+             * times before it stops" that was reported: each press was honoured instantly and none of
+             * them reached the thing actually taking the time.
+             *
+             * The ones not run still get an answer. Every tool_call in an assistant message must have a
+             * matching tool result or the next request is rejected outright — so abandoning them silently
+             * would trade a slow stop for a session that cannot be resumed, which is worse. Saying what
+             * happened also keeps the transcript honest about which steps did not run.
+             */
+            if (abortSignal?.aborted) {
+                for (const skipped of toolCalls.slice(callIndex)) {
+                    messages.push({
+                        role: 'tool', tool_call_id: skipped.id,
+                        content: 'NOT RUN: stopped at the user\'s request before this call was made.',
+                    });
+                }
+                if (!silent) {
+                    tui.printWarning(toolCalls.length - callIndex === 1
+                        ? 'Stopped. One queued call was not run.'
+                        : `Stopped. ${toolCalls.length - callIndex} queued calls were not run.`);
+                }
+                return false;
+            }
             const sig = tc.name + '::' + tc.arguments;
             /*
              * Recorded on attempt, not on execution.
@@ -2886,14 +3015,16 @@ detectedContext = { current: 0 }) {
                     }
                     catch { /* use empty */ }
                     delegated.agents += parsed.tasks?.length ?? 0;
-                    result = await handleSpawnAgents(parsed, config, effectiveCwd, stats, delegated);
+                    result = await handleSpawnAgents(parsed, config, effectiveCwd, abortSignal, stats, delegated);
                 }
                 else if (BUILTIN_NAMES.has(tc.name)) {
                     result = await dispatchTool(tc.name, tc.arguments, effectiveCwd, 
                     // Ink owns approvals through `config.approve`. Sending it through the legacy TUI as
                     // well created a second readline prompt over Ink's frame, which looked like a hang
                     // and could leave two terminal interfaces fighting for stdin.
-                    !config.approve && (config.requireApproval || policyDecision.requireApproval), line => config.onToolOutput?.(tc.name, line), sandbox);
+                    !config.approve && (config.requireApproval || policyDecision.requireApproval), line => config.onToolOutput?.(tc.name, line), sandbox, 
+                    // So a command, a page load or a fetch already in flight is cut rather than waited out.
+                    abortSignal);
                 }
                 else if (plugins.some(pl => pl.definition.name === tc.name)) {
                     result = await callPlugin(tc.name, tc.arguments, effectiveCwd, plugins);
@@ -2901,7 +3032,9 @@ detectedContext = { current: 0 }) {
                 else if (aliasedTool) {
                     // The name is not ours but its meaning is not in doubt: `create_file` with a path and
                     // contents is `write_file`. Refusing it wastes the turn and, twice now, the task.
-                    result = aliasNotice(tc.name, aliasedTool) + await dispatchTool(aliasedTool, tc.arguments, effectiveCwd, !config.approve && (config.requireApproval || policyDecision.requireApproval), line => config.onToolOutput?.(tc.name, line), sandbox);
+                    result = aliasNotice(tc.name, aliasedTool) + await dispatchTool(aliasedTool, tc.arguments, effectiveCwd, !config.approve && (config.requireApproval || policyDecision.requireApproval), line => config.onToolOutput?.(tc.name, line), sandbox, 
+                    // So a command, a page load or a fetch already in flight is cut rather than waited out.
+                    abortSignal);
                 }
                 else {
                     // A name the model invented, not a plugin that failed to load. Saying which tools exist