@sema-agent/core 2.13.0 → 3.0.0

package/dist/agents/verify.js

@@ -102,7 +102,8 @@ export async function verifyCompleted(runner, result, specBase, objective, confi
             signal: specBase.signal,
         });
         try {
-            return { verdict: v.structuredOutput, cost: (v.stats.costMicroUsd ?? 0) + (v.stats.nested?.costMicroUsd ?? 0) };
+            const cost = (v.stats.costMicroUsd ?? 0) + (v.stats.nested?.costMicroUsd ?? 0);
+            return { verdict: v.structuredOutput, cost, ...(isDurablePause(v.status) ? { paused: v } : {}) };
         }
         finally {
             if (!isDurablePause(v.status))
@@ -115,9 +116,43 @@ export async function verifyCompleted(runner, result, specBase, objective, confi
     let spend = 0;
     let verifierSpend = 0;
     for (let round = 1; round <= maxRounds; round++) {
+        if (round > 1) {
+            if (config.totalTimeoutMs != null && Date.now() - startedAt >= config.totalTimeoutMs)
+                break;
+            if (config.costCeilingMicroUsd != null && spend >= config.costCeilingMicroUsd)
+                break;
+        }
         const v = await runVerifier(current, round);
         spend += v.cost;
         verifierSpend += v.cost;
+        if (v.paused) {
+            outcome = {
+                verdict: "unverified",
+                unverifiedReason: "verifier_paused",
+                rounds: round,
+                findings: [],
+                verifierCost: verifierSpend,
+                verifierPause: {
+                    status: v.paused.status,
+                    sessionId: v.paused.sessionId,
+                    ...(v.paused.checkpointToken ? { checkpointToken: v.paused.checkpointToken } : {}),
+                    ...(v.paused.checkpointGate ? { checkpointGate: v.paused.checkpointGate } : {}),
+                },
+            };
+            try {
+                config.onVerifierPause?.({
+                    round,
+                    status: v.paused.status,
+                    sessionId: v.paused.sessionId,
+                    ...(v.paused.checkpointToken ? { checkpointToken: v.paused.checkpointToken } : {}),
+                    ...(v.paused.checkpointGate ? { checkpointGate: v.paused.checkpointGate } : {}),
+                });
+            }
+            catch {
+            }
+            config.onRound?.({ round, verdict: outcome.verdict, findings: outcome.findings });
+            break;
+        }
         const rawVerdict = v.verdict?.verdict ?? "unverified";
         const verdict = rawVerdict === "PARTIAL" ? "unverified" : rawVerdict;
         const unverifiedReason = !v.verdict ? "no_verdict" : rawVerdict === "PARTIAL" ? "could_not_verify" : undefined;

package/dist/bin/sema-tb.js

@@ -289,7 +289,7 @@ async function main() {
         switch (e.kind) {
             case "brain.call":
                 lastServedModel = e.model;
-                line(`[call] model=${e.model} in=${e.promptTokens} out=${e.completionTokens} cache=${e.cacheRead} latMs=${e.latencyMs}` +
+                line(`[call] model=${e.model} in=${e.promptTokens} tot=${e.totalInputTokens} out=${e.completionTokens} cache=${e.cacheRead} latMs=${e.latencyMs}` +
                     (e.firstTokenMs !== undefined ? ` ttftMs=${e.firstTokenMs}` : "") +
                     (e.stopReason !== undefined ? ` stop=${e.stopReason}` : "") +
                     (e.callCap !== undefined ? ` cap=${e.callCap}${e.capThinkingSkipped ? "(think-skip)" : ""}` : "") +
@@ -403,7 +403,7 @@ async function main() {
                     reason.flush();
                     turns++;
                     const u = ev.usage;
-                    line(`[turn] ${turns}${u ? ` in=${u.inputTokens} out=${u.outputTokens} cache=${u.cacheReadTokens}` : ""}` +
+                    line(`[turn] ${turns}${u ? ` in=${u.inputTokens} tot=${u.totalInputTokens} out=${u.outputTokens} cache=${u.cacheReadTokens}` : ""}` +
                         (ev.usageMissing ? " usageMissing=1" : "") +
                         (ev.stopReason !== undefined ? ` stop=${ev.stopReason}` : ""));
                     break;

package/dist/brain/circuit-breaker.d.ts

@@ -8,6 +8,7 @@ export interface BreakerSnapshot {
     failures: number;
     openedAt?: number;
     halfOpenInFlight?: number;
+    halfOpenAt?: number;
 }
 export interface BreakerState {
     get(key: string): BreakerSnapshot | undefined;

package/dist/brain/circuit-breaker.js

@@ -11,14 +11,14 @@ class InMemoryBreakerState {
         this.m.set(k, s);
     }
 }
-function errorAssistantMessage(model, code, detail) {
+function errorAssistantMessage(model, code, detail, stopReason = "error") {
     return {
         role: "assistant",
         content: [{ type: "text", text: "" }],
         api: model.api,
         provider: model.provider,
         model: model.id,
-        stopReason: "error",
+        stopReason,
         errorMessage: `[${code}] ${detail}`,
         usage: ZERO_USAGE,
         timestamp: Date.now(),
@@ -44,21 +44,33 @@ export function createCircuitBreakerBrain(inner, opts = {}) {
         if (s.phase === "closed")
             return { pass: true };
         if (s.phase === "open") {
-            if (s.openedAt === undefined)
-                return { pass: false };
+            if (s.openedAt === undefined) {
+                state.set(key, { ...s, openedAt: now() });
+                return { pass: false, retryInMs: cooldownMs };
+            }
             const elapsed = now() - s.openedAt;
             if (elapsed >= cooldownMs) {
-                setState(key, s.phase, { ...s, phase: "half-open", halfOpenInFlight: 1 });
+                setState(key, s.phase, { ...s, phase: "half-open", halfOpenInFlight: 1, halfOpenAt: now() });
                 return { pass: true };
             }
             return { pass: false, retryInMs: cooldownMs - elapsed };
         }
         const inFlight = s.halfOpenInFlight ?? 0;
         if (inFlight < halfOpenProbes) {
-            state.set(key, { ...s, halfOpenInFlight: inFlight + 1 });
+            state.set(key, { ...s, halfOpenInFlight: inFlight + 1, halfOpenAt: s.halfOpenAt ?? now() });
             return { pass: true };
         }
-        return { pass: false };
+        const leaseStart = s.halfOpenAt;
+        if (leaseStart === undefined) {
+            state.set(key, { ...s, halfOpenAt: now() });
+            return { pass: false, retryInMs: cooldownMs };
+        }
+        const held = now() - leaseStart;
+        if (held >= cooldownMs) {
+            state.set(key, { ...s, halfOpenInFlight: 1, halfOpenAt: now() });
+            return { pass: true };
+        }
+        return { pass: false, retryInMs: cooldownMs - held };
     };
     const record = (key, failedCode, viaProbe = true) => {
         const s = snap(key);
@@ -118,9 +130,14 @@ export function createCircuitBreakerBrain(inner, opts = {}) {
                 }
             }
             catch (e) {
+                const aborted = options?.signal?.aborted === true || (e instanceof Error && e.name === "AbortError");
                 const code = e instanceof BrainError ? e.code : "network";
-                record(key, code, !bypass);
-                out.push({ type: "error", reason: "error", error: errorAssistantMessage(model, code, e instanceof Error ? e.message : String(e)) });
+                record(key, aborted ? "http" : code, !bypass);
+                out.push({
+                    type: "error",
+                    reason: aborted ? "aborted" : "error",
+                    error: errorAssistantMessage(model, code, e instanceof Error ? e.message : String(e), aborted ? "aborted" : "error"),
+                });
             }
         })();
         return out;

package/dist/brain/degrading.js

@@ -91,8 +91,20 @@ export function passthroughStream(brain, model, context, options) {
     void (async () => {
         try {
             const inner = await brain.stream(model, context, options);
-            for await (const ev of inner)
+            let sawTerminal = false;
+            for await (const ev of inner) {
+                if (ev.type === "done" || ev.type === "error")
+                    sawTerminal = true;
                 out.push(ev);
+            }
+            if (!sawTerminal) {
+                await inner.result();
+                out.push({
+                    type: "error",
+                    reason: "error",
+                    error: errorMessageOf(model, new Error("brain stream ended without a terminal event"), false),
+                });
+            }
         }
         catch (e) {
             const aborted = options?.signal?.aborted === true ||

package/dist/brain/failover.js

@@ -53,6 +53,8 @@ export function createFailoverBrain(brains) {
                             ...(lastFailedCode !== undefined ? { errorCode: lastFailedCode } : {}),
                         });
                     }
+                    if (!sawContent && heldStart)
+                        out.push(heldStart);
                     out.push(terminal ?? {
                         type: "done",
                         reason: message.stopReason,

package/dist/brain/repetition.js

@@ -11,6 +11,15 @@ const SEGMENT_MAX = 120;
 function clipSegment(s) {
     return s.length > SEGMENT_MAX ? s.slice(0, SEGMENT_MAX) : s;
 }
+function trailingRepeats(text, unit, cap) {
+    let n = 0;
+    let end = text.length;
+    while (n < cap && end - unit.length >= 0 && text.startsWith(unit, end - unit.length)) {
+        n++;
+        end -= unit.length;
+    }
+    return n;
+}
 function looksLikeCodeLineUnit(unit) {
     if (!unit.includes("\n")) {
         return false;
@@ -59,7 +68,7 @@ export function inspectDegenerate(text) {
             if (!looksLikeCodeLineUnit(unit)) {
                 return { degenerate: true, cut: event, spared };
             }
-            if (t === WINDOW && reps >= SATURATION_REPS && reps * p >= t - p) {
+            if (t === WINDOW && reps * p >= t - p && trailingRepeats(text, unit, SATURATION_REPS) >= SATURATION_REPS) {
                 return { degenerate: true, cut: event, spared };
             }
             if (!sparedUnitLoop) {

package/dist/brain/routing.js

@@ -17,7 +17,11 @@ export function createRoutingBrain(routes, opts = {}) {
     const by = opts.by ?? "provider";
     const stream = (model, context, options) => {
         const key = by === "api" ? model.api : model.provider;
-        const target = routes[key] ?? opts.fallback;
+        const routed = Object.hasOwn(routes, key) ? routes[key] : undefined;
+        const matched = routed !== null && typeof routed === "object" && typeof routed.stream === "function"
+            ? routed
+            : undefined;
+        const target = matched ?? opts.fallback;
         if (!target) {
             const out = createAssistantMessageEventStream();
             out.push({

package/dist/brain/status-sink.js

@@ -4,7 +4,11 @@ export function runWithStatusSink(emit, fn) {
     return statusSinkStore.run({ emit }, fn);
 }
 export function emitBrainStatus(status) {
-    statusSinkStore.getStore()?.emit(status);
+    try {
+        statusSinkStore.getStore()?.emit(status);
+    }
+    catch {
+    }
 }
 const telemetrySinkStore = new AsyncLocalStorage();
 export function runWithBrainTelemetry(emit, fn) {

package/dist/brain/tool-call-repair.js

@@ -3,7 +3,7 @@ const FENCE_RE = /```(?:json|tool_call|tool|function)?\s*([\s\S]*?)```/gi;
 function asRecord(v) {
     return v && typeof v === "object" && !Array.isArray(v) ? v : undefined;
 }
-function extractCall(obj, toolNames) {
+function extractCall(obj, toolNames, framed) {
     const rec = asRecord(obj);
     if (!rec) {
         return undefined;
@@ -13,16 +13,32 @@ function extractCall(obj, toolNames) {
     if (typeof name !== "string" || !toolNames.has(name)) {
         return undefined;
     }
-    let rawArgs = rec.arguments ?? rec.parameters ?? rec.input ?? rec.args ?? fn?.arguments;
-    if (typeof rawArgs === "string") {
+    const rawArgs = rec.arguments ?? rec.parameters ?? rec.input ?? rec.args ?? fn?.arguments;
+    let args;
+    if (rawArgs === undefined) {
+        if (!framed)
+            return undefined;
+        args = {};
+    }
+    else if (typeof rawArgs === "string") {
+        let parsed;
         try {
-            rawArgs = JSON.parse(rawArgs);
+            parsed = JSON.parse(rawArgs);
         }
         catch {
-            rawArgs = {};
+            return undefined;
         }
+        const rec2 = asRecord(parsed);
+        if (!rec2)
+            return undefined;
+        args = rec2;
+    }
+    else {
+        const rec2 = asRecord(rawArgs);
+        if (!rec2)
+            return undefined;
+        args = rec2;
     }
-    const args = asRecord(rawArgs) ?? {};
     return {
         type: "toolCall",
         id: `repair_${name}_${Math.random().toString(36).slice(2, 8)}`,
@@ -30,28 +46,30 @@ function extractCall(obj, toolNames) {
         arguments: args,
     };
 }
-function parseBlock(raw, toolNames, out) {
+function parseBlock(raw, toolNames, out, framed) {
     let parsed;
     try {
         parsed = JSON.parse(raw.trim());
     }
     catch {
-        return false;
+        return "none";
     }
     const items = Array.isArray(parsed) ? parsed : [parsed];
-    let any = false;
+    let promoted = 0;
     for (const item of items) {
-        const call = extractCall(item, toolNames);
+        const call = extractCall(item, toolNames, framed);
         if (call) {
             out.push(call);
-            any = true;
+            promoted++;
         }
     }
-    return any;
+    if (promoted === 0)
+        return "none";
+    return promoted === items.length ? "all" : "some";
 }
 export function repairTextToolCalls(text, toolNames) {
     const toolCalls = [];
-    let cleaned = text.replace(TAG_RE, (m, _tag, inner) => parseBlock(inner, toolNames, toolCalls) ? "" : m);
-    cleaned = cleaned.replace(FENCE_RE, (m, inner) => parseBlock(inner, toolNames, toolCalls) ? "" : m);
+    let cleaned = text.replace(TAG_RE, (m, _tag, inner) => parseBlock(inner, toolNames, toolCalls, true) === "all" ? "" : m);
+    cleaned = cleaned.replace(FENCE_RE, (m, inner) => parseBlock(inner, toolNames, toolCalls, false) === "all" ? "" : m);
     return { toolCalls, cleanedText: cleaned.trim() };
 }

package/dist/core/auto-compaction.js

@@ -1,4 +1,4 @@
-import { DEFAULT_CHARS_PER_TOKEN, DEFAULT_CLAMP_TOLERANCE, DEFAULT_COMPACTION_SETTINGS, CompactionError, compact, computeFileLists, dryRunSummarizationClamp, estimateContextTokens, estimateTokens, formatPersistedOutputRefs, prepareCompaction, shouldCompact, } from "../internal/harness.js";
+import { DEFAULT_CHARS_PER_TOKEN, DEFAULT_CLAMP_TOLERANCE, DEFAULT_COMPACTION_SETTINGS, CompactionError, compact, computeFileLists, dryRunSummarizationClamp, estimateContextTokens, estimateTokens, formatFileOperations, formatPersistedOutputRefs, prepareCompaction, shouldCompact, } from "../internal/harness.js";
 import { fileArgPath } from "../tools/fs/safety.js";
 import { contextEditFrontier } from "./context-edit.js";
 import { selectCompactionEpoch } from "../prompt-assembly/epoch.js";
@@ -17,6 +17,10 @@ export function sanitizeCompactionInstructions(text) {
         ? cps.slice(0, COMPACTION_INSTRUCTIONS_MAX_CHARS).join("")
         : defused;
 }
+const WORKING_FILE_BREAKOUT_TAGS = ["working-file", "summary"];
+function escapeWorkingFilePathAttr(path) {
+    return path.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/[\r\n]+/g, " ");
+}
 export const COMPACTION_THROUGHPUT_PRIOR_TOKENS_PER_MS = 3;
 const COMPACTION_THROUGHPUT_EWMA_ALPHA = 0.3;
 const COMPACTION_WALLTIME_ABORT_FLAG = "semaCompactionWalltimeAbort";
@@ -69,8 +73,11 @@ export async function maybeCompact(opts) {
     const anchorStale = est.usageTokens > 0 && est.tokens > structuralTokens * STALE_ANCHOR_STRUCTURAL_MARGIN + overhead;
     const tokens = anchorStale || est.usageTokens === 0 ? structuralTokens + overhead : est.tokens;
     const window = opts.model.autoCompactTokens ?? opts.model.contextTokens ?? opts.model.contextWindow;
+    const windowKnown = Number.isFinite(window) && window > 0;
     const settings = sanitizeCompactionSettings(rawSettings, window);
-    const contextUsage = { usedTokens: tokens, windowTokens: window, compactAtTokens: window - settings.reserveTokens };
+    const contextUsage = windowKnown
+        ? { usedTokens: tokens, windowTokens: window, compactAtTokens: window - settings.reserveTokens }
+        : undefined;
     const wantsCompact = shouldCompact(tokens, window, settings);
     const naturalTrigger = wantsCompact && tokens >= (opts.minTokens ?? 0);
     const force = opts.force || (opts.forceUnderThreshold === true && !naturalTrigger);
@@ -118,7 +125,7 @@ export async function maybeCompact(opts) {
             : hookSanitized
         : specInstructions;
     const maxReuse = opts.maxConsecutiveProviderReuse ?? 3;
-    const forceRealSummary = (opts.consecutiveProviderReuse ?? 0) >= maxReuse;
+    const forceRealSummary = maxReuse > 0 && (opts.consecutiveProviderReuse ?? 0) >= maxReuse;
     let providerSummary;
     if (opts.summaryProvider && !forceRealSummary && !prep.value.isSplitTurn) {
         const providerModifiedFiles = computeFileLists(prep.value.fileOps).modifiedFilesByRecency;
@@ -151,7 +158,9 @@ export async function maybeCompact(opts) {
         summary = providerSummary;
         firstKeptEntryId = prep.value.firstKeptEntryId;
         summaryTokensBefore = prep.value.tokensBefore;
-        details = computeFileLists(prep.value.fileOps);
+        const providerFileLists = computeFileLists(prep.value.fileOps);
+        details = providerFileLists;
+        summary += formatFileOperations(providerFileLists.readFiles, providerFileLists.modifiedFiles);
         if (prep.value.invokedSkills.length > 0) {
             details.invokedSkills = prep.value.invokedSkills;
         }
@@ -330,7 +339,7 @@ export async function maybeCompact(opts) {
     const rawCandidateFiles = recentlyRead.length > 0 ? recentlyRead : (details?.modifiedFilesByRecency ?? details?.modifiedFiles);
     const maxFilesForSelection = Math.max(1, att?.maxFiles ?? 3);
     const excludedReadStatePreserveKeys = [];
-    const candidateFiles = Array.isArray(rawCandidateFiles) && rawCandidateFiles.length > 0
+    const candidateFiles = att !== undefined && Array.isArray(rawCandidateFiles) && rawCandidateFiles.length > 0
         ? await (async () => {
             const keptTailReadPathsRaw = new Set();
             const firstKeptIdx = branch.findIndex((e) => e.id === firstKeptEntryId);
@@ -417,7 +426,8 @@ export async function maybeCompact(opts) {
     if (att && Array.isArray(candidateFiles) && candidateFiles.length > 0) {
         const maxFiles = maxFilesForSelection;
         const perFileCap = Math.max(200, att.maxCharsPerFile ?? 16_000);
-        let remaining = Math.min(maxFiles * perFileCap, Math.floor(window * 0.15) * cpt);
+        const windowShareChars = windowKnown ? Math.floor(window * 0.15) * cpt : Number.POSITIVE_INFINITY;
+        let remaining = Math.min(maxFiles * perFileCap, windowShareChars);
         const blocks = [];
         for (const path of candidateFiles.slice(0, maxFiles)) {
             if (remaining <= 0)
@@ -437,7 +447,7 @@ export async function maybeCompact(opts) {
                 ? `${content.slice(0, cap)}\n[... ${content.length - cap} more characters truncated — read the file for the rest]`
                 : content;
             remaining -= clipped.length;
-            blocks.push(`<working-file path="${path}">\n${clipped}\n</working-file>`);
+            blocks.push(`<working-file path="${escapeWorkingFilePathAttr(path)}">\n${sanitizeUntrustedText(clipped, WORKING_FILE_BREAKOUT_TAGS)}\n</working-file>`);
             attachedFiles.push({ path, chars: Math.min(content.length, cap), truncated: wasClipped });
             if (!wasClipped)
                 attachedComplete.push({ path, content });

package/dist/core/checkpoint-store.d.ts

@@ -30,6 +30,7 @@ export declare function riskSeverity(axes: {
     shell?: boolean;
 }): 1 | 2 | 3 | 4 | 5;
 export declare const MAX_TOOL_INPUT_PREVIEW_CHARS = 512;
+export declare const MAX_PENDING_STEER_CHARS = 16000;
 export declare function buildRiskDescriptor(input: {
     toolName: string;
     args: unknown;

package/dist/core/checkpoint-store.js

@@ -25,6 +25,7 @@ const MAX_TOUCHED_PATHS = 8;
 const MAX_DIGEST_KEYS = 16;
 const MAX_DIGEST_SCAN_KEYS = 256;
 export const MAX_TOOL_INPUT_PREVIEW_CHARS = 512;
+export const MAX_PENDING_STEER_CHARS = 16_000;
 function isPlainRecord(x) {
     try {
         if (x === null || typeof x !== "object" || Array.isArray(x))
@@ -130,26 +131,40 @@ export const MAX_SUPPORTED_CHECKPOINT_VERSION = 4;
 export function checkpointVersionOf(cp) {
     return cp.version ?? 0;
 }
+function finiteBound(v) {
+    return v !== undefined && Number.isFinite(v) ? v : undefined;
+}
+function finiteSpend(v) {
+    return v !== undefined && Number.isFinite(v) ? v : undefined;
+}
 export function debitLedger(prior, slice, total, opts) {
     return {
-        totalBudgetMicroUsd: prior?.totalBudgetMicroUsd ?? total?.totalBudgetMicroUsd,
-        totalWalltimeSec: prior?.totalWalltimeSec ?? total?.totalWalltimeSec,
-        spentMicroUsd: (prior?.spentMicroUsd ?? 0) + Math.max(0, slice.costMicroUsd),
-        spentTokens: (prior?.spentTokens ?? 0) + Math.max(0, slice.tokens),
-        spentTurns: (prior?.spentTurns ?? 0) + Math.max(0, slice.turns),
-        spentWalltimeMs: (prior?.spentWalltimeMs ?? 0) + Math.max(0, slice.walltimeMs ?? 0),
+        totalBudgetMicroUsd: finiteBound(prior?.totalBudgetMicroUsd) ?? finiteBound(total?.totalBudgetMicroUsd),
+        totalWalltimeSec: finiteBound(prior?.totalWalltimeSec) ?? finiteBound(total?.totalWalltimeSec),
+        spentMicroUsd: (finiteSpend(prior?.spentMicroUsd) ?? 0) + Math.max(0, finiteSpend(slice.costMicroUsd) ?? 0),
+        spentTokens: (finiteSpend(prior?.spentTokens) ?? 0) + Math.max(0, finiteSpend(slice.tokens) ?? 0),
+        spentTurns: (finiteSpend(prior?.spentTurns) ?? 0) + Math.max(0, finiteSpend(slice.turns) ?? 0),
+        spentWalltimeMs: (finiteSpend(prior?.spentWalltimeMs) ?? 0) + Math.max(0, finiteSpend(slice.walltimeMs) ?? 0),
         sliceCount: (prior?.sliceCount ?? 0) + (opts?.countSlice === false ? 0 : 1),
     };
 }
 export function remainingBudgetMicroUsd(ledger) {
-    if (ledger?.totalBudgetMicroUsd === undefined)
+    const total = ledger?.totalBudgetMicroUsd;
+    if (total === undefined || !Number.isFinite(total))
         return undefined;
-    return Math.max(0, ledger.totalBudgetMicroUsd - ledger.spentMicroUsd);
+    const spent = ledger?.spentMicroUsd;
+    if (spent !== undefined && !Number.isFinite(spent))
+        return 0;
+    return Math.max(0, total - (spent ?? 0));
 }
 export function remainingWalltimeMs(ledger) {
-    if (ledger?.totalWalltimeSec === undefined)
+    const total = ledger?.totalWalltimeSec;
+    if (total === undefined || !Number.isFinite(total))
         return undefined;
-    return Math.max(0, ledger.totalWalltimeSec * 1000 - (ledger.spentWalltimeMs ?? 0));
+    const spent = ledger?.spentWalltimeMs;
+    if (spent !== undefined && !Number.isFinite(spent))
+        return 0;
+    return Math.max(0, total * 1000 - (spent ?? 0));
 }
 export function summarizeCheckpoint(cp) {
     const riskDescriptor = cp.gate.kind === "human" || cp.gate.kind === "irreversible_ask" ? cp.gate.riskDescriptor : undefined;
@@ -217,6 +232,9 @@ export function validatePendingSteer(steer) {
     if (/[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/.test(steer.text)) {
         throw new CheckpointError("steering.invalid_content", "steering text must not contain control characters");
     }
+    if (steer.text.length > MAX_PENDING_STEER_CHARS) {
+        throw new CheckpointError("steering.invalid_content", `steering text must be at most ${MAX_PENDING_STEER_CHARS} characters (got ${steer.text.length})`);
+    }
     return { text: steer.text, trusted: steer.trusted };
 }
 export class InMemoryCheckpointStore {

package/dist/core/consolidate-scope.js

@@ -3,9 +3,9 @@ import { runMemoryConsolidation, DEFAULT_CONSOLIDATION_BAND, DEFAULT_CONSOLIDATI
 function maxMarker(a, b) {
     return a === undefined || b > a ? b : a;
 }
-function cappedHighWater(seen, failed) {
+function cappedHighWater(seen, blockers) {
     let floor;
-    for (const id of failed)
+    for (const id of blockers)
         if (floor === undefined || id < floor)
             floor = id;
     let hw;
@@ -66,7 +66,8 @@ export async function consolidateScope(scope, deps, opts = {}) {
             });
         }
         const seen = [...batchIds, ...(stats?.addedIds ?? [])];
-        const highWater = cappedHighWater(seen, stats?.failedIds ?? []);
+        const unfedTail = pending.slice(maxNotes).map((h) => h.id);
+        const highWater = cappedHighWater(seen, [...(stats?.failedIds ?? []), ...unfedTail]);
         if (highWater !== undefined && highWater !== cursor && (cursor === undefined || highWater > cursor)) {
             await store.setConsolidationCursor(scope, highWater);
         }

package/dist/core/context-edit.js

@@ -114,5 +114,8 @@ export function clearStaleToolResults(messages, opts) {
 }
 export function editBudget(model) {
     const window = model.autoCompactTokens ?? model.contextTokens ?? model.contextWindow;
+    if (!Number.isFinite(window) || window <= 0) {
+        return Number.POSITIVE_INFINITY;
+    }
     return contextEditFrontier(window);
 }

package/dist/core/context-guard.js

@@ -116,5 +116,8 @@ export function dropOrphanToolResults(messages) {
 }
 export function guardBudget(model) {
     const window = model.contextTokens ?? model.contextWindow;
+    if (!Number.isFinite(window) || window <= 0) {
+        return Number.POSITIVE_INFINITY;
+    }
     return Math.max(window - GUARD_HEADROOM_TOKENS, Math.floor(window * GUARD_FRACTION));
 }

package/dist/core/git-worktree-env.d.ts

@@ -12,4 +12,9 @@ export declare function addWorktree(baseEnv: ExecutionEnv, opts: AddWorktreeOpti
     };
     worktreeDir: string;
 }>;
-export declare function pruneWorktrees(baseEnv: ExecutionEnv, repoRoot: string): Promise<void>;
+export declare function pruneWorktrees(baseEnv: ExecutionEnv, repoRoot: string): Promise<{
+    ok: true;
+} | {
+    ok: false;
+    detail: string;
+}>;

package/dist/core/git-worktree-env.js

@@ -59,5 +59,16 @@ export async function addWorktree(baseEnv, opts) {
     return { env, worktreeDir };
 }
 export async function pruneWorktrees(baseEnv, repoRoot) {
-    await baseEnv.exec("git worktree prune", { cwd: repoRoot });
+    try {
+        const r = await baseEnv.exec("git worktree prune", { cwd: repoRoot });
+        if (r.ok && r.value.exitCode === 0)
+            return { ok: true };
+        return {
+            ok: false,
+            detail: r.ok ? (r.value.stderr || r.value.stdout || `exit ${r.value.exitCode}`).trim() : String(r.error),
+        };
+    }
+    catch (err) {
+        return { ok: false, detail: String(err) };
+    }
 }

package/dist/core/hooks.d.ts

@@ -121,6 +121,7 @@ export interface ToolGateInput {
     approvalTimeoutMs?: number;
     abortSignal?: AbortSignal;
     permissionDenied?: (payload: PermissionDeniedPayload) => void | Promise<void>;
+    onHookError?: (err: unknown) => void;
     shellGated?: boolean;
     autoMode?: {
         decider: import("./auto-mode.js").AutoModeDecider;

package/dist/core/hooks.js

@@ -16,6 +16,20 @@ export function cloneObserverInput(input) {
 export function formatHookFeedback(text) {
     return `<system-reminder>\n${text}\n</system-reminder>`;
 }
+function preToolUseCrashReason(subject, err) {
+    const raw = err instanceof Error ? err.message.trim() || err.name : String(err);
+    const cause = inlineUntrusted(raw, 200);
+    return (`a PreToolUse hook crashed while screening ${subject}; the call was NOT executed (fail-closed). ` +
+        `This is a failure of the deployment's hook, NOT of the tool itself — an identical retry reaches the ` +
+        `same hook and fails the same way. Hook error: ${cause || "(no message)"}`);
+}
+function traceHookCrash(input, err) {
+    try {
+        input.onHookError?.(err);
+    }
+    catch {
+    }
+}
 function withProbeTimeout(p, ms, signal) {
     if (ms === undefined && signal === undefined)
         return p;
@@ -49,7 +63,22 @@ export async function runToolGate(input) {
     const preToolContext = [];
     let hookAsk;
     if (preToolUse) {
-        const r = await preToolUse(toolName, currentInput, { toolCallId, toolName });
+        let r;
+        try {
+            r = await preToolUse(toolName, currentInput, { toolCallId, toolName });
+        }
+        catch (err) {
+            const reason = preToolUseCrashReason(`this call to "${toolName}"`, err);
+            traceHookCrash(input, err);
+            if (input.permissionDenied) {
+                try {
+                    await input.permissionDenied({ toolName, input: cloneObserverInput(currentInput), toolCallId, reason, source: "hook" });
+                }
+                catch {
+                }
+            }
+            return { block: true, reason: formatHookFeedback(reason), preToolContext };
+        }
         if (r) {
             if (r.additionalContext) {
                 preToolContext.push(r.additionalContext);
@@ -182,7 +211,16 @@ export async function runToolGate(input) {
                         break;
                     }
                     if (preToolUse) {
-                        const hr = await preToolUse(toolName, editArgs, { toolCallId, toolName });
+                        let hr;
+                        try {
+                            hr = await preToolUse(toolName, editArgs, { toolCallId, toolName });
+                        }
+                        catch (err) {
+                            traceHookCrash(input, err);
+                            editDenied = { action: "deny", reason: preToolUseCrashReason(`the approved edit for "${toolName}"`, err) };
+                            denySource = "hook";
+                            break;
+                        }
                         if (hr) {
                             if (hr.additionalContext)
                                 preToolContext.push(hr.additionalContext);