@nexrall/code-core 1.4.12 → 1.4.14

package/dist/agent/loop.d.ts

@@ -102,4 +102,17 @@ export declare function compactMessagesForResume(messages: Message[], opts: {
     onNotice?: (text: string) => void;
 }): Promise<boolean>;
 export declare function runAgentLoop(initialMessages: Message[], options: AgentLoopOptions): Promise<Message[]>;
+/**
+ * Cut a history back to the last point the API will accept as a resumable
+ * prefix, WITHOUT mutating the input.
+ *
+ * Anthropic rejects a conversation whose final assistant turn contains
+ * `tool_use` blocks that never got a matching `tool_result`. The main loop
+ * always appends in complete pairs so it can't produce that shape, but a crash
+ * in the middle of executing a tool round can: the assistant turn was already
+ * pushed, the tool_result carrier never was. Dropping that dangling assistant
+ * turn costs one model response and makes the rest of the (often very long)
+ * history resumable, instead of throwing all of it away.
+ */
+export declare function trimToResumableBoundary(messages: Message[]): Message[];
 //# sourceMappingURL=loop.d.ts.map

package/dist/agent/loop.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"loop.d.ts","sourceRoot":"","sources":["../../src/agent/loop.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,OAAO,EAMP,gBAAgB,EAChB,UAAU,EACX,MAAM,UAAU,CAAC;AAsKlB,wBAAgB,oBAAoB,CAClC,WAAW,EAAE,MAAM,GAAG,SAAS,EAC/B,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GACnC,MAAM,CAWR;AA4TD,+EAA+E;AAC/E,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,OAAO,EAAE,GAAG,MAAM,CAM7D;AAsBD,iFAAiF;AACjF,eAAO,MAAM,gBAAgB,aAA+G,CAAC;AAC7I,gGAAgG;AAChG,eAAO,MAAM,aAAa,QAA2J,CAAC;AAEtL;;;;;;;;;;;;GAYG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,OAAO,EAAE,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAK5E;AAUD;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAAC,QAAQ,EAAE,OAAO,EAAE,GAAG,MAAM,CAwBxD;AAoBD,MAAM,WAAW,cAAc;IAC7B,YAAY,EAAE,GAAG,CAAC,MAAM,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC3D,aAAa,EAAE,KAAK,CAAC;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,EAAE,EAAE,OAAO,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAClE,qFAAqF;IACrF,aAAa,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACvD;;;;OAIG;IACH,KAAK,EAAE,MAAM,CAAC;CACf;AAED,wBAAgB,YAAY,IAAI,cAAc,CAE7C;AAED,kFAAkF;AAClF,wBAAgB,YAAY,CAC1B,MAAM,EAAE,cAAc,EACtB,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,EAC1C,EAAE,EAAE,OAAO,EACX,MAAM,CAAC,EAAE,MAAM,EACf,QAAQ,CAAC,EAAE,MAAM,GAChB,IAAI,CAoDN;AAED,kFAAkF;AAClF,wBAAgB,aAAa,CAAC,MAAM,EAAE,cAAc,GAAG,MAAM,CA6B5D;AAmBD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,OAAO,EAAE,EAAE,eAAe,SAAI,GAAG,MAAM,CAgCpF;AAsHD,gFAAgF;AAChF,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,OAAO,EAAE,GAAG,MAAM,CAE/D;AAED;;;;;;;;;GASG;AACH,wBAAsB,wBAAwB,CAC5C,QAAQ,EAAE,OAAO,EAAE,EACnB,IAAI,EAAE;IACJ,KAAK,CAAC,EAAE,OAAO,GAAG,KAAK,GAAG,OAAO,CAAC;IAClC,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,GAAG,CAAC,EAAE,UAAU,CAAC;IACjB,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;CACnC,GACA,OAAO,CAAC,OAAO,CAAC,CAqElB;AAID,wBAAsB,YAAY,CAChC,eAAe,EAAE,OAAO,EAAE,EAC1B,OAAO,EAAE,gBAAgB,GACxB,OAAO,CAAC,OAAO,EAAE,CAAC,CA4nBpB"}
+{"version":3,"file":"loop.d.ts","sourceRoot":"","sources":["../../src/agent/loop.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,OAAO,EAMP,gBAAgB,EAChB,UAAU,EACX,MAAM,UAAU,CAAC;AAyKlB,wBAAgB,oBAAoB,CAClC,WAAW,EAAE,MAAM,GAAG,SAAS,EAC/B,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GACnC,MAAM,CAWR;AA+UD,+EAA+E;AAC/E,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,OAAO,EAAE,GAAG,MAAM,CAM7D;AAsBD,iFAAiF;AACjF,eAAO,MAAM,gBAAgB,aAA+G,CAAC;AAC7I,gGAAgG;AAChG,eAAO,MAAM,aAAa,QAA2J,CAAC;AAEtL;;;;;;;;;;;;GAYG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,OAAO,EAAE,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAK5E;AAUD;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAAC,QAAQ,EAAE,OAAO,EAAE,GAAG,MAAM,CAwBxD;AAoBD,MAAM,WAAW,cAAc;IAC7B,YAAY,EAAE,GAAG,CAAC,MAAM,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC3D,aAAa,EAAE,KAAK,CAAC;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,EAAE,EAAE,OAAO,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAClE,qFAAqF;IACrF,aAAa,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACvD;;;;OAIG;IACH,KAAK,EAAE,MAAM,CAAC;CACf;AAED,wBAAgB,YAAY,IAAI,cAAc,CAE7C;AAED,kFAAkF;AAClF,wBAAgB,YAAY,CAC1B,MAAM,EAAE,cAAc,EACtB,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,EAC1C,EAAE,EAAE,OAAO,EACX,MAAM,CAAC,EAAE,MAAM,EACf,QAAQ,CAAC,EAAE,MAAM,GAChB,IAAI,CAoDN;AAED,kFAAkF;AAClF,wBAAgB,aAAa,CAAC,MAAM,EAAE,cAAc,GAAG,MAAM,CA6B5D;AAmBD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,OAAO,EAAE,EAAE,eAAe,SAAI,GAAG,MAAM,CAgCpF;AAsKD,gFAAgF;AAChF,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,OAAO,EAAE,GAAG,MAAM,CAE/D;AAED;;;;;;;;;GASG;AACH,wBAAsB,wBAAwB,CAC5C,QAAQ,EAAE,OAAO,EAAE,EACnB,IAAI,EAAE;IACJ,KAAK,CAAC,EAAE,OAAO,GAAG,KAAK,GAAG,OAAO,CAAC;IAClC,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,GAAG,CAAC,EAAE,UAAU,CAAC;IACjB,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;CACnC,GACA,OAAO,CAAC,OAAO,CAAC,CAqElB;AAID,wBAAsB,YAAY,CAChC,eAAe,EAAE,OAAO,EAAE,EAC1B,OAAO,EAAE,gBAAgB,GACxB,OAAO,CAAC,OAAO,EAAE,CAAC,CA+sBpB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,OAAO,EAAE,GAAG,OAAO,EAAE,CAqCtE"}

package/dist/agent/loop.js

@@ -45,15 +45,19 @@ exports.pruneOldToolResults = pruneOldToolResults;
 exports.estimateTokensRough = estimateTokensRough;
 exports.compactMessagesForResume = compactMessagesForResume;
 exports.runAgentLoop = runAgentLoop;
+exports.trimToResumableBoundary = trimToResumableBoundary;
+const types_1 = require("../types");
 const client_1 = require("../api/client");
 const executor_1 = require("../tools/executor");
 const agentTypes_1 = require("./agentTypes");
+const skills_1 = require("./skills");
 const rules_1 = require("../permissions/rules");
 const sandbox_1 = require("../tools/sandbox");
 const index_1 = require("../plugins/index");
 const testIntegrity_1 = require("./testIntegrity");
 const flaky_1 = require("./flaky");
 const claimEvidence_1 = require("./claimEvidence");
+const memory_1 = require("./memory");
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const child_process_1 = require("child_process");
@@ -299,6 +303,8 @@ function humanDescription(name, input) {
             const preview = typeof input.prompt === 'string' ? input.prompt.slice(0, 60) : '';
             return `Sub-task: ${desc || preview}${!desc && preview.length === 60 ? '…' : ''}`;
         }
+        case 'use_skill':
+            return `Use skill: /${input.name ?? '(unknown)'}`;
         case 'get_diagnostics':
             return input.path ? `Get diagnostics: ${input.path}` : 'Get workspace diagnostics';
         case 'go_to_definition':
@@ -362,6 +368,22 @@ async function runSubTask(input, options, agentTypes) {
             nexrallMd: subNexrallMd,
             requestPermission: gatedPermission,
             onText: () => { }, // sub-agent text is returned as the tool result, not streamed live
+            // Forwarded DELIBERATELY, and it must be a real handler rather than a no-op.
+            //
+            // A sub-agent streams no text (onText above is a no-op) but it DOES stream thinking
+            // through the parent's UI (see onThinking/onThinkingDelta below), and thinking sets
+            // `emittedToCaller`. So a sub-agent stream that dies after reasoning genuinely has
+            // rendered output to discard — a no-op here would let the restart proceed and then
+            // re-stream that reasoning on top of the copy still on screen, the exact duplication
+            // the opt-in exists to prevent.
+            //
+            // Forwarding is safe because the parent's own output is already closed by this
+            // point: dispatching the `task` tool goes through options.onToolUse, which finalizes
+            // the parent's bubble (VS Code) / flushes the renderer (CLI) before the sub-agent
+            // starts. The only live, discardable element at restart time is the sub-agent's own
+            // thinking block. Completed tool rows are left alone — those are real side effects
+            // that actually happened.
+            onStreamRestart: (reason, chars) => options.onStreamRestart?.(reason, chars),
             // Forward tool events with isSubTask=true so the UI can render a badge
             // instead of prepending "[sub-task]" to the tool name (which caused double-prefix
             // when the name was already labelled, and mixed display concerns into the data layer).
@@ -798,6 +820,11 @@ async function autoCompactMessages(messages, options, ledger) {
             env: options.env,
             clientType: options.clientType,
             abortSignal: options.abortSignal,
+            // The summariser renders NOTHING (onEvent below is a no-op) and its result is
+            // read only from the returned message, so a restart has nothing to roll back —
+            // always safe. Worth enabling: a blip here used to abandon compaction entirely,
+            // which then let the very next turn hit the context wall it was meant to prevent.
+            allowRestartAfterRender: true,
         }, () => { });
         summary = reply.content
             .filter((b) => b.type === 'text')
@@ -831,6 +858,45 @@ async function autoCompactMessages(messages, options, ledger) {
     void kept;
     return true;
 }
+// ─── Periodic memory compaction ────────────────────────────────────────────
+// A memory file (project or global — see agent/memory.ts) can grow large over
+// many sessions since memory_write only ever appends. writeMemory() already
+// applies an immediate, synchronous byte-cap eviction (oldest entries dropped)
+// as a hard backstop, but that's a blunt instrument — this periodically
+// consolidates the file with a real LLM summarization pass instead, so old
+// facts are condensed into fewer, denser bullets rather than silently lost.
+// Checked opportunistically right after a successful memory_write (see the
+// call site below) rather than on every tool call — cheap to check (a single
+// file stat), and memory_write is the only thing that can push a file over
+// the trigger threshold in the first place.
+async function maybeCompactMemory(scope, options) {
+    try {
+        await (0, memory_1.compactMemoryIfNeeded)(scope, options.workDir, async (prompt) => {
+            const reply = await (0, client_1.streamChat)([{ role: 'user', content: [{ type: 'text', text: prompt }] }], {
+                // Same reasoning as autoCompactMessages' summariser: a mechanical
+                // consolidation task, always run on the cheapest 1M-context tier
+                // regardless of the user's chosen model for the actual conversation.
+                model: 'turbo',
+                mode: 'ask',
+                env: options.env,
+                clientType: options.clientType,
+                abortSignal: options.abortSignal,
+                // Same as the transcript summariser: no rendered output, result read only from
+                // the returned message, so restarting on a blip is always safe.
+                allowRestartAfterRender: true,
+            }, () => { });
+            return reply.content
+                .filter((b) => b.type === 'text')
+                .map((b) => b.text ?? '')
+                .join('');
+        });
+    }
+    catch {
+        // Best-effort — a failed/aborted compaction just means the file stays as-is
+        // until the next memory_write call tries again; writeMemory's synchronous
+        // byte cap already bounds worst-case growth in the meantime.
+    }
+}
 // ─── Resume-time proactive compaction ─────────────────────────────────────────
 //
 // The in-loop auto-compact above only reacts to `lastPromptTokens`, which is
@@ -940,6 +1006,11 @@ async function runAgentLoop(initialMessages, options) {
     // catalogue (sub-agents can't spawn further), but every level resolves types.
     const agentTypes = (0, agentTypes_1.loadAgentTypes)(options.workDir);
     const agentsCatalogue = depth === 0 ? (0, agentTypes_1.summariseAgents)(agentTypes) : '';
+    // Skills catalogue — unlike agentsCatalogue, available at every depth: a skill is
+    // just a reusable prompt template (via use_skill), not another spawn point, so
+    // sub-agents benefit from the same playbooks without the recursion concerns that
+    // gate agentsCatalogue to the top level.
+    const skillsCatalogue = (0, skills_1.summariseSkills)((0, skills_1.loadSkills)(options.workDir));
     // Optional OS-level bash sandbox (opt-in via settings.json "sandbox").
     const settings = (0, rules_1.loadSettings)(options.workDir);
     const sandboxCfg = (0, sandbox_1.parseSandboxConfig)(settings.raw.sandbox) ?? undefined;
@@ -965,6 +1036,11 @@ async function runAgentLoop(initialMessages, options) {
     // iteration backstop, so we can tell the user what happened rather than
     // silently returning a half-done task.
     let completedCleanly = false;
+    // Tool rounds actually completed in this call. Counted explicitly rather than derived
+    // from `messages.length` because auto-compaction splices the history SHORTER mid-run:
+    // a long session that compacted and then lost its connection would show a negative
+    // length delta and be judged "no progress", discarding the work it most needs to keep.
+    let completedRounds = 0;
     let stalledOut = false; // tripped the runaway guard (all-failed rounds)
     let consecutiveErrorRounds = 0; // rounds where every tool call errored
     let budget = maxIterations; // extended by auto-continue, capped at hardCap
@@ -1065,8 +1141,6 @@ async function runAgentLoop(initialMessages, options) {
             if (!autoContinue && iteration === budget - 5 && budget > 5) {
                 options.onText(`\n⚠️ Approaching the ${budget}-step limit (step ${iteration + 1}). Please wrap up and summarise what has been done.\n`);
             }
-            // Collect tool_use blocks emitted during this stream
-            const pendingToolUse = [];
             // Build SSE event handler
             const onEvent = (event) => {
                 switch (event.type) {
@@ -1083,21 +1157,33 @@ async function runAgentLoop(initialMessages, options) {
                         options.onThinkingProgress?.(event.tokens);
                         break;
                     case 'tool_use':
-                        // Collect tool use blocks — they may arrive incrementally
-                        // We use message_complete to finalize them, so just track here
-                        pendingToolUse.push({
-                            type: 'tool_use',
-                            id: event.id,
-                            name: event.name,
-                            input: event.input,
-                        });
+                        // Nothing to do here. Streamed tool_use events are a PREVIEW only (their
+                        // `input` can still be partial JSON mid-stream); the blocks actually
+                        // executed are read from the completed message's content at the end of
+                        // this iteration. An accumulator here used to exist but was never read —
+                        // keeping it invited the assumption that dispatch happens from the stream,
+                        // which would break the restart guarantee below.
                         break;
                     case 'usage':
-                        lastPromptTokens =
-                            (event.usage.input_tokens ?? 0) +
-                                (event.usage.cache_creation_input_tokens ?? 0) +
-                                (event.usage.cache_read_input_tokens ?? 0);
-                        options.onUsage(event.usage);
+                        // A `partial` report belongs to an attempt that was cut short and restarted.
+                        // Its token counts are real spend (already billed upstream) and are forwarded
+                        // so a cost display stays honest — but they must NOT drive `lastPromptTokens`,
+                        // which feeds the auto-compaction trigger: a truncated attempt understates the
+                        // prompt size, and letting it overwrite a correct reading would suppress a
+                        // compaction the next turn actually needs.
+                        if (!event.partial) {
+                            // A `replayed` report DOES update this: it describes the real, complete turn
+                            // (served from the backend's idempotency cache after a dropped connection),
+                            // so its prompt size is accurate and needed for the compaction decision.
+                            // Only `partial` — a truncated attempt — must be excluded.
+                            lastPromptTokens =
+                                (event.usage.input_tokens ?? 0) +
+                                    (event.usage.cache_creation_input_tokens ?? 0) +
+                                    (event.usage.cache_read_input_tokens ?? 0);
+                        }
+                        // Both flags mean "do not add these tokens to a running cost total": `partial`
+                        // was a discarded attempt, `replayed` was already counted when first billed.
+                        options.onUsage(event.usage, event.partial === true || event.replayed === true);
                         break;
                     case 'message_complete':
                         // The complete message is returned from streamChat, we handle it below
@@ -1108,11 +1194,29 @@ async function runAgentLoop(initialMessages, options) {
                     case 'retry_resolved':
                         options.onRetryResolved?.();
                         break;
+                    case 'stream_restart':
+                        // The attempt that died had already rendered text/thinking; the replacement
+                        // attempt re-sends the turn in full, so the caller must drop that partial
+                        // render or it shows up twice.
+                        //
+                        // Nothing else needs undoing, and that is a property of the code below, not
+                        // an assumption: tools are dispatched from `assistantMessage.content` AFTER
+                        // streamChat() returns, and a restarted attempt threw instead of returning.
+                        // So no tool ran, no file changed, no checkpoint or hook fired.
+                        options.onStreamRestart?.(event.reason, event.discardedChars);
+                        break;
                     case 'balance_status':
                         options.onBalanceStatus?.(event.balance, event.zero);
                         break;
                     case 'done':
+                        break;
                     case 'error':
+                        // Reaching the loop means the stream did NOT reject on this — i.e. the turn's
+                        // message had already been delivered and the error arrived late (typically the
+                        // backend's post-turn billing write failing). The answer stands, so this must
+                        // not fail the turn, but it must not vanish either: route it to the system-
+                        // notice channel so it is visible and logged rather than silently swallowed.
+                        options.onNotice?.(`⚠️ ${event.message}`);
                         break;
                 }
             };
@@ -1130,6 +1234,12 @@ async function runAgentLoop(initialMessages, options) {
                     abortSignal: options.abortSignal,
                     extraTools: options.mcpManager?.getAnthropicTools(),
                     agents: agentsCatalogue || undefined,
+                    skills: skillsCatalogue || undefined,
+                    // Only allow a post-render restart when the caller actually implements the
+                    // rollback. Without a handler the partial output can't be un-rendered, so we
+                    // keep the old conservative behaviour (fail the turn) rather than duplicate
+                    // text on screen.
+                    allowRestartAfterRender: !!options.onStreamRestart,
                 }, onEvent);
             }
             catch (err) {
@@ -1146,7 +1256,14 @@ async function runAgentLoop(initialMessages, options) {
                     break;
                 }
                 runSimpleHooks(hooks.OnError, options.workDir);
-                throw new Error(`Stream failed: ${err.message}`);
+                // Carry the work already done in this turn out with the error. The loop
+                // owns a COPY of the caller's history, so a plain throw would strand every
+                // completed tool round inside this function and the caller would fall back
+                // to a history containing only the original user message — the user pays
+                // for N minutes of agent work and then has to start over because
+                // "continue" remembers none of it. `messages` always ends on a complete
+                // assistant→tool_result pair here, so it is valid to resend as-is.
+                throw new types_1.AgentTurnError(`Stream failed: ${err.message}`, trimToResumableBoundary(messages), completedRounds, err);
             }
             if (options.abortSignal?.aborted)
                 break;
@@ -1393,6 +1510,14 @@ async function runAgentLoop(initialMessages, options) {
                         catch (err) {
                             result = { error: `Tool execution failed: ${err.message}` };
                         }
+                        // Opportunistic memory compaction — memory_write is the only tool that can
+                        // grow a memory file, so this is the cheapest point to check whether it just
+                        // crossed the compaction threshold. Fire-and-forget: never blocks the turn,
+                        // never surfaces its own errors to the model (see maybeCompactMemory).
+                        if (name === 'memory_write' && result.error === undefined) {
+                            const scope = input.scope === 'global' ? 'global' : 'project';
+                            void maybeCompactMemory(scope, options);
+                        }
                         // PostToolUse can inject context for the model or flag a problem.
                         const post = runToolHooks(hooks.PostToolUse, 'PostToolUse', name, input, options.workDir, result);
                         const injected = [pre.context, post.context].filter(Boolean).join('\n');
@@ -1470,6 +1595,9 @@ async function runAgentLoop(initialMessages, options) {
                 content: toolResultContent,
             };
             messages.push(toolResultMessage);
+            // A complete assistant→tool_result pair just landed: the history is valid to
+            // resend from here, so this is exactly one unit of salvageable progress.
+            completedRounds++;
             // Incremental persistence hook: history is valid here (ends on a
             // tool_result user turn). Let the caller checkpoint progress so a crash
             // mid-run loses only the in-flight step, not the whole session.
@@ -1510,9 +1638,69 @@ async function runAgentLoop(initialMessages, options) {
             }
         }
     }
+    catch (err) {
+        // Every other failure path (a tool executor blowing up, a hook throwing, an
+        // out-of-memory in a large read) gets the same treatment as a dead stream:
+        // the turn's completed work leaves with the error instead of dying inside
+        // this function's private copy of the history. Already-tagged errors pass
+        // straight through so we don't double-wrap and lose the original message.
+        if (err instanceof types_1.AgentTurnError)
+            throw err;
+        if (options.abortSignal?.aborted || err.name === 'AbortError')
+            throw err;
+        throw new types_1.AgentTurnError(err?.message || 'The turn ended unexpectedly', trimToResumableBoundary(messages), completedRounds, err);
+    }
     finally {
         runSimpleHooks(hooks.OnStop, options.workDir);
     }
     return messages;
 }
+/**
+ * Cut a history back to the last point the API will accept as a resumable
+ * prefix, WITHOUT mutating the input.
+ *
+ * Anthropic rejects a conversation whose final assistant turn contains
+ * `tool_use` blocks that never got a matching `tool_result`. The main loop
+ * always appends in complete pairs so it can't produce that shape, but a crash
+ * in the middle of executing a tool round can: the assistant turn was already
+ * pushed, the tool_result carrier never was. Dropping that dangling assistant
+ * turn costs one model response and makes the rest of the (often very long)
+ * history resumable, instead of throwing all of it away.
+ */
+function trimToResumableBoundary(messages) {
+    // A trailing assistant turn is unresumable if it invoked ANY tool whose result is
+    // missing. That includes server-side invocations (`server_tool_use`, produced by
+    // web search / tool search), which carry a DIFFERENT block type than a client tool
+    // call: matching only 'tool_use' would let a dangling web-search turn through, and
+    // it would 400 on resend exactly like a dangling client call. `chooseFinalContent`
+    // in api/client.ts deliberately preserves these blocks verbatim, so they really do
+    // reach this function.
+    const isUnansweredInvocation = (m) => {
+        if (m?.role !== 'assistant' || !Array.isArray(m.content))
+            return false;
+        const blocks = m.content;
+        // A client tool_use is answered by a tool_result in the NEXT (user) message, which
+        // by definition doesn't exist if this is the last turn — so any of them is dangling.
+        if (blocks.some((b) => b?.type === 'tool_use'))
+            return true;
+        // Server-side invocations are different: Anthropic pairs each `server_tool_use` with
+        // its `*_tool_result` inside this SAME message, so a completed search turn is
+        // perfectly resumable and must not be discarded.
+        //
+        // Pair by id rather than asking "is there any result block at all". A turn cut off
+        // after two searches where only the first returned would otherwise look complete and
+        // 400 on resend — exactly the mid-turn-death case this helper exists for. Matching on
+        // the `_tool_result` suffix also covers result types beyond web/tool search
+        // (code_execution, mcp) without needing to enumerate them.
+        const answeredIds = new Set(blocks.filter((b) => /_tool_result$/.test(b?.type ?? '')).map((b) => b?.tool_use_id));
+        return blocks.some((b) => b?.type === 'server_tool_use' && !answeredIds.has(b?.id));
+    };
+    // Loop rather than a single check: this is an exported helper that accepts any
+    // history, not only the strictly-paired ones the agent loop builds, so consecutive
+    // dangling assistant turns must all be removed for the result to be resendable.
+    let end = messages.length;
+    while (end > 0 && isUnansweredInvocation(messages[end - 1]))
+        end--;
+    return end === messages.length ? messages : messages.slice(0, end);
+}
 //# sourceMappingURL=loop.js.map

package/dist/agent/memory.d.ts

@@ -0,0 +1,45 @@
+export type MemoryScope = 'project' | 'global';
+/** Per-workDir file, keyed the same way CheckpointManager keys its store
+ *  (sha1 of the resolved absolute path) so two differently-named checkouts of
+ *  the same repo don't collide, and the same repo always maps to the same file
+ *  regardless of cwd casing/trailing-slash quirks. */
+export declare function memoryFilePath(scope: MemoryScope, workDir?: string): string;
+export declare const MEMORY_ENTRY_MAX_CHARS = 400;
+export declare const MEMORY_MAX_BYTES = 12000;
+export declare const MEMORY_COMPACT_TRIGGER_BYTES = 16000;
+export declare const MEMORY_HARD_CAP_BYTES: number;
+export interface MemoryWriteResult {
+    ok: boolean;
+    already: boolean;
+    scope: MemoryScope;
+    file: string;
+}
+export declare function writeMemory(content: string, scope: MemoryScope, workDir?: string): Promise<MemoryWriteResult>;
+export declare function readMemory(scope: MemoryScope, workDir?: string): string;
+/** Merge BOTH scopes for prompt injection — project-specific first (most
+ *  relevant to what the agent is doing right now), global preferences after. */
+export declare function readAllMemory(workDir?: string): string;
+export declare function clearMemory(scope: MemoryScope, workDir?: string): void;
+export declare function memoryStats(scope: MemoryScope, workDir?: string): {
+    file: string;
+    bytes: number;
+    entries: number;
+};
+/**
+ * Summarize the OLDEST half of a memory file into a few consolidated bullets via
+ * an LLM call, keeping the most recent entries verbatim — same "compact, don't
+ * silently drop" instinct as the conversation-history auto-compactor, applied to
+ * memory instead of a transcript. This is the EXPECTED bounding mechanism for
+ * memory file size — called opportunistically (fire-and-forget) right after a
+ * successful memory_write (see maybeCompactMemory in loop.ts) once a file crosses
+ * MEMORY_COMPACT_TRIGGER_BYTES. writeMemory's own emergency synchronous eviction
+ * (MEMORY_HARD_CAP_BYTES) sits well above this threshold specifically so this
+ * summarizing pass gets the chance to run first in the common case; the blunt
+ * eviction is a last resort for if compaction has been failing/unavailable.
+ *
+ * `summarize` is injected (rather than importing streamChat directly) to avoid
+ * pulling api/client.ts's network/auth machinery into every consumer of this
+ * module and to keep this file trivially unit-testable.
+ */
+export declare function compactMemoryIfNeeded(scope: MemoryScope, workDir: string | undefined, summarize: (prompt: string) => Promise<string>): Promise<boolean>;
+//# sourceMappingURL=memory.d.ts.map

package/dist/agent/memory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory.d.ts","sourceRoot":"","sources":["../../src/agent/memory.ts"],"names":[],"mappings":"AAiCA,MAAM,MAAM,WAAW,GAAG,SAAS,GAAG,QAAQ,CAAC;AAE/C;;;sDAGsD;AACtD,wBAAgB,cAAc,CAAC,KAAK,EAAE,WAAW,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,CAI3E;AAED,eAAO,MAAM,sBAAsB,MAAM,CAAC;AAC1C,eAAO,MAAM,gBAAgB,QAAS,CAAC;AACvC,eAAO,MAAM,4BAA4B,QAAS,CAAC;AAMnD,eAAO,MAAM,qBAAqB,QAAmC,CAAC;AA4CtE,MAAM,WAAW,iBAAiB;IAChC,EAAE,EAAE,OAAO,CAAC;IACZ,OAAO,EAAE,OAAO,CAAC;IACjB,KAAK,EAAE,WAAW,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;CACd;AAED,wBAAsB,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,WAAW,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAuBnH;AAED,wBAAgB,UAAU,CAAC,KAAK,EAAE,WAAW,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,CAGvE;AAED;gFACgF;AAChF,wBAAgB,aAAa,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,CAStD;AAED,wBAAgB,WAAW,CAAC,KAAK,EAAE,WAAW,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAGtE;AAED,wBAAgB,WAAW,CAAC,KAAK,EAAE,WAAW,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAKlH;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAsB,qBAAqB,CACzC,KAAK,EAAE,WAAW,EAClB,OAAO,EAAE,MAAM,GAAG,SAAS,EAC3B,SAAS,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,GAC7C,OAAO,CAAC,OAAO,CAAC,CA+BlB"}