muonroi-cli 1.3.4 → 1.4.1

package/dist/src/orchestrator/council-manager.js

@@ -14,6 +14,7 @@ import { generateText, stepCountIs } from "ai";
 import { getModelByTier, getModelsForProvider } from "../models/registry.js";
 import { loadKeyForProvider } from "../providers/keychain.js";
 import { createProviderFactory, detectProviderForModel, resolveModelRuntime, shouldDropParam, } from "../providers/runtime.js";
+import { ALL_PROVIDER_IDS } from "../providers/types.js";
 import { appendSystemMessage } from "../storage/index.js";
 import { createBuiltinTools } from "../tools/registry.js";
 import { isProviderDisabled } from "../utils/settings.js";
@@ -293,7 +294,7 @@ export class CouncilManager {
         const combined = parts.join("\n\n---\n\n");
         // Rough token estimate: char/4
         if (combined.length > 12000) {
-            return combined.slice(0, 12000) + "\n\n[... context truncated to fit token budget]";
+            return `${combined.slice(0, 12000)}\n\n[... context truncated to fit token budget]`;
         }
         return combined;
     }
@@ -408,15 +409,7 @@ export class CouncilManager {
      * Falls back to the session model if no alternative is available.
      */
     async resolveNonDisabledFallback() {
-        const fallbackProviders = [
-            "anthropic",
-            "openai",
-            "google",
-            "deepseek",
-            "siliconflow",
-            "xai",
-            "ollama",
-        ];
+        const fallbackProviders = ALL_PROVIDER_IDS;
         for (const p of fallbackProviders) {
             if (!isProviderDisabled(p)) {
                 const key = await loadKeyForProvider(p).catch(() => null);

package/dist/src/orchestrator/cross-turn-dedup.js

@@ -79,7 +79,8 @@ export class CrossTurnDedup {
             // Refresh LRU position so frequently-reused outputs survive eviction.
             this.cache.delete(hash);
             this.cache.set(hash, existing);
-            return `[tool_result identical to earlier turn — dedup ref sha256=${hash}, originally from tool=${existing.firstSeenToolName} turn=${existing.firstSeenTurn}]`;
+            // G3 — short marker. Old format was ~110 chars; this is ~45.
+            return `[dup of ${existing.firstSeenToolName} from turn ${existing.firstSeenTurn} — reuse]`;
         }
         // Insert new entry, evicting oldest if over cap.
         this.cache.set(hash, {
@@ -147,6 +148,25 @@ function dedupResult(dedup, toolName, raw) {
             if (stub !== null)
                 return { ...obj, output: stub };
         }
+        // MCP tool result shape: { type: "content", value: [{type:"text", text}, ...] }.
+        // Without this branch a re-fetched MCP payload (same docs page, same query)
+        // re-billed full content every turn — the dedup never saw it. Dedup each
+        // text part; non-text parts (images/media) pass through untouched.
+        if (obj.type === "content" && Array.isArray(obj.value)) {
+            const value = obj.value.map((part) => {
+                if (part &&
+                    typeof part === "object" &&
+                    part.type === "text" &&
+                    typeof part.text === "string") {
+                    const text = part.text;
+                    const stub = dedup.maybeDedup(toolName, text);
+                    if (stub !== null)
+                        return { ...part, text: stub };
+                }
+                return part;
+            });
+            return { ...obj, value };
+        }
     }
     return raw;
 }

package/dist/src/orchestrator/delegations.js

@@ -231,7 +231,13 @@ function createSummary(text) {
     const compact = text.replace(/\s+/g, " ").trim();
     if (!compact)
         return "No summary available.";
-    return compact.length <= 180 ? compact : `${compact.slice(0, 177).trimEnd()}...`;
+    // Re-insert space when model token-stream glommed sentence terminators
+    // against the next capital ("changes.Now" → "changes. Now").
+    const spaced = compact.replace(/([.!?:])(?=[A-Z])/g, "$1 ");
+    // Prefer the first sentence so the notification stays a one-liner.
+    const sentenceMatch = spaced.match(/^.+?[.!?](?=\s|$)/);
+    const candidate = (sentenceMatch ? sentenceMatch[0] : spaced).trim();
+    return candidate.length <= 120 ? candidate : `${candidate.slice(0, 117).trimEnd()}...`;
 }
 function renderOutput(record, content) {
     const title = record.title || record.id;

package/dist/src/orchestrator/delegations.test.js

@@ -40,7 +40,7 @@ async function importDelegationsModule(options = {}) {
 }
 afterEach(() => {
     for (const dir of tempDirs.splice(0)) {
-        fs.rmSync(dir, { recursive: true, force: true });
+        fs.rmSync(dir, { recursive: true, force: true, maxRetries: 10, retryDelay: 50 });
     }
     vi.restoreAllMocks();
     vi.resetModules();

package/dist/src/orchestrator/error-utils.d.ts

@@ -2,6 +2,32 @@ declare const STATUS_MESSAGES: Record<number, string>;
 export declare function isContextLimitError(error: unknown): boolean;
 export declare function isAuthenticationError(error: unknown): boolean;
 export declare function isMalformedFunctionNameError(error: unknown): boolean;
-export declare function humanizeApiError(error: unknown): string;
+/** Routing context for humanizeApiError — the model/provider that actually ran. */
+export interface ApiErrorContext {
+    modelId?: string;
+    providerId?: string;
+}
+export declare function humanizeApiError(error: unknown, ctx?: ApiErrorContext): string;
 declare function extractResponseDetail(body: string | undefined): string | null;
+/**
+ * Forensics envelope for opaque provider 4xx errors. SiliconFlow / DeepSeek
+ * routinely return "The parameter is invalid. Please check again." with no
+ * indication of WHICH parameter — sessions hit by that string in
+ * interaction_logs leave no actionable trace because we only persisted the
+ * friendly message. This helper extracts the wire-level shape from an
+ * APICallError so logInteraction can persist enough info to diagnose without
+ * needing a repro.
+ *
+ * Body and headers are truncated/redacted. Request body is reduced to the
+ * top-level parameter names — values may contain secrets or PII and must
+ * NEVER be persisted.
+ */
+export interface ApiErrorForensics {
+    statusCode: number | undefined;
+    urlHost: string | undefined;
+    responseBodyTrunc: string | undefined;
+    requestParamKeys: string[] | undefined;
+    isRetryable: boolean | undefined;
+}
+export declare function summarizeApiErrorForLog(error: unknown): ApiErrorForensics | null;
 export { extractResponseDetail, STATUS_MESSAGES };

package/dist/src/orchestrator/error-utils.js

@@ -24,7 +24,44 @@ export function isMalformedFunctionNameError(error) {
     const message = error instanceof Error ? error.message : String(error);
     return /Expected ['"]function\.name['"] to be a string/i.test(message);
 }
-export function humanizeApiError(error) {
+/** Statuses where the model/provider CHOICE is the lever, so naming it helps. */
+const ROUTING_STATUSES = new Set([401, 402, 403, 429]);
+function getStatusCode(error) {
+    if (APICallError.isInstance(error))
+        return error.statusCode ?? undefined;
+    const e = error;
+    return e?.statusCode ?? e?.status;
+}
+/**
+ * For account/auth/rate errors, append the routed model + provider and a
+ * targeted fix hint. Reveals e.g. a project-pinned deepseek model overriding
+ * the user's default (the "402 Insufficient Balance" mystery) and points at the
+ * lever (`-m`, `keys login`, top-up). Returns "" for non-routing errors so a
+ * server-side 5xx isn't mislabeled as the user's routing problem.
+ */
+function routingSuffix(error, ctx) {
+    if (!ctx?.modelId)
+        return "";
+    const message = error instanceof Error ? error.message : String(error);
+    let status = getStatusCode(error);
+    // Some gateways surface a balance error without a clean statusCode.
+    if (status === undefined && /insufficient balance|out of (balance|credit)/i.test(message)) {
+        status = 402;
+    }
+    if (status === undefined || !ROUTING_STATUSES.has(status))
+        return "";
+    const where = `routed to model "${ctx.modelId}"${ctx.providerId ? ` via provider "${ctx.providerId}"` : ""}`;
+    const hint = status === 402
+        ? "out of balance/credit — top up the provider account, or switch model with `-m <model>`."
+        : status === 401 || status === 403
+            ? "not authenticated for this provider — run `keys login <provider>` (or set its API key), or switch model with `-m <model>`."
+            : "rate-limited — wait and retry, or switch model with `-m <model>`.";
+    return ` [${where}] — ${hint}`;
+}
+export function humanizeApiError(error, ctx) {
+    return `${humanizeApiErrorBase(error)}${routingSuffix(error, ctx)}`;
+}
+function humanizeApiErrorBase(error) {
     if (isMalformedFunctionNameError(error)) {
         return "Model emitted a malformed tool call (function.name missing). Skipping this turn — please retry or rephrase.";
     }
@@ -62,5 +99,30 @@ function extractResponseDetail(body) {
     }
     return null;
 }
+const RESPONSE_BODY_CAP = 1000;
+export function summarizeApiErrorForLog(error) {
+    if (!APICallError.isInstance(error))
+        return null;
+    let urlHost;
+    try {
+        urlHost = new URL(error.url).host;
+    }
+    catch {
+        urlHost = undefined;
+    }
+    let requestParamKeys;
+    if (error.requestBodyValues && typeof error.requestBodyValues === "object") {
+        requestParamKeys = Object.keys(error.requestBodyValues).sort();
+    }
+    const body = typeof error.responseBody === "string" ? error.responseBody : undefined;
+    const responseBodyTrunc = body && body.length > RESPONSE_BODY_CAP ? `${body.slice(0, RESPONSE_BODY_CAP)}…[truncated]` : body;
+    return {
+        statusCode: error.statusCode,
+        urlHost,
+        responseBodyTrunc,
+        requestParamKeys,
+        isRetryable: error.isRetryable,
+    };
+}
 export { extractResponseDetail, STATUS_MESSAGES };
 //# sourceMappingURL=error-utils.js.map

package/dist/src/orchestrator/grounding-check.d.ts

@@ -0,0 +1,50 @@
+/**
+ * src/orchestrator/grounding-check.ts
+ *
+ * Summary-phase grounding validator (the runtime half of the Agent Operating
+ * Contract — see src/pil/agent-operating-contract.ts for the prompt half).
+ *
+ * At turn finalize, the orchestrator scans the model's FINAL synthesis text for
+ * factual claims that are cheap to fabricate and high-impact when wrong:
+ *   - exact COUNTS ("67 tests", "1,273 commits"), and
+ *   - FILE:LINE references ("app.tsx:836"),
+ * then cross-references them against the corpus of tool outputs produced THIS
+ * turn. A claim whose value never appears in any tool output is "unverified".
+ *
+ * Behaviour is SOFT-FLAG only: the caller emits a `grounding-flag` event and a
+ * warn toast, and may append an advisory footnote. It never blocks the turn or
+ * rewrites the model's text. The classic case it catches: deepseek-v4-flash
+ * reporting "67 tests" (actual 401) with no command output containing 67.
+ *
+ * This module is PURE (no I/O, no globals) so it is trivially unit-testable; the
+ * caller builds the corpus string and handles the env gate / chitchat skip.
+ *
+ * Designed for LOW false positives because it can surface a user-visible toast
+ * on EVERY tier:
+ *   - only integers >= 10 (single digits are too common to be claims),
+ *   - only when immediately followed by a recognised count noun,
+ *   - hedged/approximate numbers ("~130,220", "about 500") are skipped — they
+ *     are presented as estimates, not asserted facts,
+ *   - percentages / multipliers / versions / money never match (no whitespace
+ *     after the digit, or excluded by the count-noun requirement),
+ *   - file:line only flags when the file name is absent from the corpus.
+ */
+export interface UnverifiedClaim {
+    kind: "count" | "fileline";
+    /** Normalised claim value: "67", "1273", or "app.tsx:836". */
+    value: string;
+    /** The literal claim text as written, e.g. "67 tests" or "app.tsx:836". */
+    text: string;
+}
+/**
+ * Find factual claims in `finalText` that are NOT supported by `corpus` (the
+ * concatenation of this turn's tool outputs). Returns at most MAX_CLAIMS,
+ * deduped by (kind, value).
+ */
+export declare function findUnverifiedClaims(finalText: string, corpus: string): UnverifiedClaim[];
+/**
+ * Build an advisory footnote for the flagged claims. Non-accusatory — the
+ * numbers MAY be legitimately derived; the note just asks the user to confirm.
+ * Returns "" when there are no claims.
+ */
+export declare function buildGroundingFootnote(claims: UnverifiedClaim[]): string;

package/dist/src/orchestrator/grounding-check.js

@@ -0,0 +1,123 @@
+/**
+ * src/orchestrator/grounding-check.ts
+ *
+ * Summary-phase grounding validator (the runtime half of the Agent Operating
+ * Contract — see src/pil/agent-operating-contract.ts for the prompt half).
+ *
+ * At turn finalize, the orchestrator scans the model's FINAL synthesis text for
+ * factual claims that are cheap to fabricate and high-impact when wrong:
+ *   - exact COUNTS ("67 tests", "1,273 commits"), and
+ *   - FILE:LINE references ("app.tsx:836"),
+ * then cross-references them against the corpus of tool outputs produced THIS
+ * turn. A claim whose value never appears in any tool output is "unverified".
+ *
+ * Behaviour is SOFT-FLAG only: the caller emits a `grounding-flag` event and a
+ * warn toast, and may append an advisory footnote. It never blocks the turn or
+ * rewrites the model's text. The classic case it catches: deepseek-v4-flash
+ * reporting "67 tests" (actual 401) with no command output containing 67.
+ *
+ * This module is PURE (no I/O, no globals) so it is trivially unit-testable; the
+ * caller builds the corpus string and handles the env gate / chitchat skip.
+ *
+ * Designed for LOW false positives because it can surface a user-visible toast
+ * on EVERY tier:
+ *   - only integers >= 10 (single digits are too common to be claims),
+ *   - only when immediately followed by a recognised count noun,
+ *   - hedged/approximate numbers ("~130,220", "about 500") are skipped — they
+ *     are presented as estimates, not asserted facts,
+ *   - percentages / multipliers / versions / money never match (no whitespace
+ *     after the digit, or excluded by the count-noun requirement),
+ *   - file:line only flags when the file name is absent from the corpus.
+ */
+const MAX_CLAIMS = 5;
+// Count nouns whose preceding integer is a verifiable codebase metric.
+const COUNT_NOUN = "tests?|specs?|files?|commits?|lines?|errors?|warnings?|modules?|packages?|functions?|classes?|methods?|dependencies|deps|endpoints?|routes?|components?|contributors?|branches?|tables?|columns?|rows?|occurrences?|matches?|references?|callers?|imports?|exports?|todos?|issues?";
+// number (2+ digits, or thousands-separated) + up to 2 filler words + count noun.
+const COUNT_RE = new RegExp(`\\b(\\d{1,3}(?:,\\d{3})+|\\d{2,})\\b(?:\\s+(?:\\w+\\s+){0,2}?)(?:${COUNT_NOUN})\\b`, "gi");
+// count noun … : | = … number — the inverse shape ("total lines: 10026",
+// "modules = 240"). Requires an explicit ':' or '=' separator so it stays a
+// narrow "noun = value" assertion and never matches "line 42" prose. The span
+// before the separator excludes '.' so it can't bridge across sentences.
+const NOUN_SEP_NUM_RE = new RegExp(`\\b(?:${COUNT_NOUN})\\b[^.\\n:=]{0,40}?[:=]\\s*(\\d{1,3}(?:,\\d{3})+|\\d{2,})\\b`, "gi");
+// filename.ext:line — basename only (the char class excludes "/").
+const FILELINE_RE = /\b([\w.-]+\.[a-z]{1,5}):(\d+)\b/gi;
+// Hedge markers immediately before a number mean it is an estimate, not a fact.
+const HEDGE_RE = /(~|≈|\babout\b|\bapprox(?:imately)?\b|\broughly\b|\baround\b|\bnearly\b|\best\.?\b)\s*$/i;
+function stripCommas(s) {
+    return s.replace(/,/g, "");
+}
+/**
+ * Find factual claims in `finalText` that are NOT supported by `corpus` (the
+ * concatenation of this turn's tool outputs). Returns at most MAX_CLAIMS,
+ * deduped by (kind, value).
+ */
+export function findUnverifiedClaims(finalText, corpus) {
+    if (!finalText)
+        return [];
+    const corpusNorm = stripCommas(corpus).toLowerCase();
+    const corpusLower = corpus.toLowerCase();
+    const out = [];
+    const seen = new Set();
+    const push = (claim) => {
+        const key = `${claim.kind}:${claim.value.toLowerCase()}`;
+        if (seen.has(key))
+            return;
+        seen.add(key);
+        out.push(claim);
+    };
+    // Consider one count match: hedge-skip, corpus-check, then push.
+    const considerCount = (raw, numberIdxInText, text) => {
+        if (out.length >= MAX_CLAIMS)
+            return;
+        // Skip hedged numbers (the chars right before the digit say "estimate").
+        const before = finalText.slice(Math.max(0, numberIdxInText - 16), numberIdxInText);
+        if (HEDGE_RE.test(before))
+            return;
+        const norm = stripCommas(raw);
+        if (corpusNorm.includes(norm))
+            return; // value appears in a tool output → verified
+        push({ kind: "count", value: norm, text: text.trim() });
+    };
+    // --- Count claims: number → noun ("67 tests") ---
+    for (const m of finalText.matchAll(COUNT_RE)) {
+        if (out.length >= MAX_CLAIMS)
+            break;
+        considerCount(m[1], m.index ?? 0, m[0]);
+    }
+    // --- Count claims: noun → :|= → number ("total lines: 10026") ---
+    for (const m of finalText.matchAll(NOUN_SEP_NUM_RE)) {
+        if (out.length >= MAX_CLAIMS)
+            break;
+        const raw = m[1];
+        // Locate the number within the match so the hedge look-back checks the
+        // chars immediately before the digits, not before the noun.
+        const numberIdxInText = (m.index ?? 0) + m[0].lastIndexOf(raw);
+        considerCount(raw, numberIdxInText, m[0]);
+    }
+    // --- file:line claims ---
+    for (const m of finalText.matchAll(FILELINE_RE)) {
+        if (out.length >= MAX_CLAIMS)
+            break;
+        const idx = m.index ?? 0;
+        // Skip path/URL/port shapes ("http://host:8080", "a/b.ts:1" handled by basename).
+        if (idx > 0 && finalText[idx - 1] === "/")
+            continue;
+        const basename = m[1];
+        if (corpusLower.includes(basename.toLowerCase()))
+            continue; // file was read/grepped → verified
+        push({ kind: "fileline", value: `${basename}:${m[2]}`, text: `${basename}:${m[2]}` });
+    }
+    return out.slice(0, MAX_CLAIMS);
+}
+/**
+ * Build an advisory footnote for the flagged claims. Non-accusatory — the
+ * numbers MAY be legitimately derived; the note just asks the user to confirm.
+ * Returns "" when there are no claims.
+ */
+export function buildGroundingFootnote(claims) {
+    if (claims.length === 0)
+        return "";
+    const list = claims.map((c) => c.text).join(", ");
+    return `\n\n> ⚠ Unverified (not found in this turn's tool output): ${list}. These may be derived — confirm before relying on them.`;
+}
+//# sourceMappingURL=grounding-check.js.map

package/dist/src/orchestrator/grounding-check.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/orchestrator/grounding-check.test.js

@@ -0,0 +1,94 @@
+import { describe, expect, it } from "vitest";
+import { buildGroundingFootnote, findUnverifiedClaims } from "./grounding-check.js";
+describe("findUnverifiedClaims — count claims", () => {
+    it("flags an exact count not present in the tool-output corpus", () => {
+        // The decisive live case: deepseek claimed 67 tests while no command output
+        // contained 67 (actual 401). corpus has no '67'.
+        const claims = findUnverifiedClaims("There are 67 tests in the repository.", "ran find; output: 401\n");
+        expect(claims.some((c) => c.kind === "count" && c.value === "67")).toBe(true);
+    });
+    it("does NOT flag a count that appears verbatim in the corpus", () => {
+        const claims = findUnverifiedClaims("There are 401 tests.", "$ find src -name '*.test.ts' | wc -l\n401\n");
+        expect(claims).toHaveLength(0);
+    });
+    it("matches counts with thousands separators against an unseparated corpus", () => {
+        // Model prints '1,273 commits'; git output is '1273'. Should be VERIFIED.
+        const claims = findUnverifiedClaims("The repo has 1,273 commits.", "$ git rev-list --count HEAD\n1273\n");
+        expect(claims).toHaveLength(0);
+    });
+    it("ignores small numbers (< 10) — too common, low risk", () => {
+        expect(findUnverifiedClaims("Fixed 3 files.", "")).toHaveLength(0);
+    });
+    it("ignores percentages, multipliers, versions, money", () => {
+        const text = "97% cache hit, 16x faster, v0.4.0 shipped, $50 saved across 99 files.";
+        // Only "99 files" is a real count claim; the rest must be skipped. corpus
+        // lacks 99 -> 99 flagged, others NOT.
+        const claims = findUnverifiedClaims(text, "");
+        expect(claims.map((c) => c.value)).toEqual(["99"]);
+    });
+    it("ignores hedged/approximate numbers (presented as estimates, not facts)", () => {
+        const text = "~130,220 lines, about 500 files, roughly 40 modules.";
+        expect(findUnverifiedClaims(text, "")).toHaveLength(0);
+    });
+    it("only counts a number when followed by a recognised count noun", () => {
+        // A bare number with no count noun is not a verifiable 'count claim'.
+        expect(findUnverifiedClaims("The answer is 42 ultimately.", "")).toHaveLength(0);
+    });
+    // Gap found in the live deepseek-vs-gemini comparison (2026-06-04): deepseek
+    // emitted "total lines of code across all .ts files in src/: 10026" — a
+    // fabricated count where the NOUN precedes the NUMBER (separated by a colon),
+    // which the number-then-noun pattern missed. Cover the noun→:/=→number shape.
+    it("flags a noun-before-number count claim (noun : number)", () => {
+        const claims = findUnverifiedClaims("Total lines of code across all .ts files in src/: 10026.", "");
+        expect(claims.some((c) => c.kind === "count" && c.value === "10026")).toBe(true);
+    });
+    it("flags a noun = number claim", () => {
+        const claims = findUnverifiedClaims("Estimated modules = 240 in the repo.", "");
+        expect(claims.some((c) => c.kind === "count" && c.value === "240")).toBe(true);
+    });
+    it("does NOT flag a noun:number when the number is in the corpus", () => {
+        expect(findUnverifiedClaims("Total commits: 1,273.", "$ git rev-list --count HEAD\n1273\n")).toHaveLength(0);
+    });
+    it("does NOT flag a hedged noun:number", () => {
+        expect(findUnverifiedClaims("Total lines: ~10026.", "")).toHaveLength(0);
+    });
+    it("does NOT treat 'line 42' (no separator) as a count claim", () => {
+        // file:line context — handled separately; must not become a count claim.
+        expect(findUnverifiedClaims("See line 42 for details.", "").filter((c) => c.kind === "count")).toHaveLength(0);
+    });
+});
+describe("findUnverifiedClaims — file:line claims", () => {
+    it("flags a file:line whose file never appears in the corpus", () => {
+        const claims = findUnverifiedClaims("The bug is at app.tsx:836.", "read src/index.ts lines 1-40\n");
+        expect(claims.some((c) => c.kind === "fileline" && c.value === "app.tsx:836")).toBe(true);
+    });
+    it("does NOT flag a file:line whose file was read/grepped this turn", () => {
+        const claims = findUnverifiedClaims("See app.tsx:836.", "$ read_file app.tsx\n...contents of app.tsx...\n");
+        expect(claims).toHaveLength(0);
+    });
+});
+describe("findUnverifiedClaims — bounds & dedup", () => {
+    it("caps the number of returned claims", () => {
+        const text = "100 files, 200 files, 300 files, 400 files, 500 files, 600 files, 700 files.";
+        expect(findUnverifiedClaims(text, "").length).toBeLessThanOrEqual(5);
+    });
+    it("returns empty for empty text", () => {
+        expect(findUnverifiedClaims("", "anything")).toHaveLength(0);
+    });
+});
+describe("buildGroundingFootnote", () => {
+    it("returns empty string when there are no claims", () => {
+        expect(buildGroundingFootnote([])).toBe("");
+    });
+    it("lists the unverified claims with an advisory (non-accusatory) tone", () => {
+        const note = buildGroundingFootnote([
+            { kind: "count", value: "67", text: "67 tests" },
+            { kind: "fileline", value: "app.tsx:836", text: "app.tsx:836" },
+        ]);
+        expect(note).toMatch(/unverified/i);
+        expect(note).toMatch(/67 tests/);
+        expect(note).toMatch(/app\.tsx:836/);
+        expect(note).toMatch(/may be derived|confirm/i);
+    });
+});
+//# sourceMappingURL=grounding-check.test.js.map

package/dist/src/orchestrator/interrupted-turn.d.ts

@@ -0,0 +1,19 @@
+/**
+ * src/orchestrator/interrupted-turn.ts
+ *
+ * When an agent turn is abandoned mid-flight — a model stall (the stall-watchdog
+ * surfaces an "abort" stream part) or an unrecoverable stream error — the
+ * orchestrator used to `return` without persisting anything. The turn's work
+ * (tool calls + on-disk edits) then left NO trace in conversation history, so
+ * the NEXT user turn was amnesiac: live obs (2026-06-04, deepseek-v4-flash) the
+ * model literally answered "there was no previous turn in this session" and
+ * re-did the work from scratch, leaving the earlier edit orphaned.
+ *
+ * The fix persists at least this note as the assistant turn, so the next turn
+ * (a) knows a prior turn happened, and (b) is warned the work may be partially
+ * applied and must be re-checked rather than blindly redone.
+ *
+ * Pure + tiny so it is unit-testable; the orchestrator wires it into the stall
+ * return path.
+ */
+export declare function buildInterruptedTurnNote(assistantText: string, toolCallNames: readonly string[]): string;

package/dist/src/orchestrator/interrupted-turn.js

@@ -0,0 +1,28 @@
+/**
+ * src/orchestrator/interrupted-turn.ts
+ *
+ * When an agent turn is abandoned mid-flight — a model stall (the stall-watchdog
+ * surfaces an "abort" stream part) or an unrecoverable stream error — the
+ * orchestrator used to `return` without persisting anything. The turn's work
+ * (tool calls + on-disk edits) then left NO trace in conversation history, so
+ * the NEXT user turn was amnesiac: live obs (2026-06-04, deepseek-v4-flash) the
+ * model literally answered "there was no previous turn in this session" and
+ * re-did the work from scratch, leaving the earlier edit orphaned.
+ *
+ * The fix persists at least this note as the assistant turn, so the next turn
+ * (a) knows a prior turn happened, and (b) is warned the work may be partially
+ * applied and must be re-checked rather than blindly redone.
+ *
+ * Pure + tiny so it is unit-testable; the orchestrator wires it into the stall
+ * return path.
+ */
+export function buildInterruptedTurnNote(assistantText, toolCallNames) {
+    const base = (assistantText ?? "").trim();
+    const names = (toolCallNames ?? []).filter(Boolean);
+    const uniq = [...new Set(names)];
+    const tail = uniq.length
+        ? `[Previous turn was interrupted (model stall) after ${names.length} tool call(s) (${uniq.slice(0, 8).join(", ")}${uniq.length > 8 ? ", …" : ""}). File changes may be PARTIALLY applied — re-check current state before redoing anything.]`
+        : "[Previous turn was interrupted (model stall) before completing. Re-check current state before redoing anything.]";
+    return base ? `${base}\n\n${tail}` : tail;
+}
+//# sourceMappingURL=interrupted-turn.js.map

package/dist/src/orchestrator/interrupted-turn.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/orchestrator/interrupted-turn.test.js

@@ -0,0 +1,34 @@
+import { describe, expect, it } from "vitest";
+import { buildInterruptedTurnNote } from "./interrupted-turn.js";
+describe("buildInterruptedTurnNote", () => {
+    it("is never empty — so the stalled turn always leaves a trace in history", () => {
+        expect(buildInterruptedTurnNote("", []).length).toBeGreaterThan(0);
+    });
+    it("records the interruption and the tools that were issued", () => {
+        const note = buildInterruptedTurnNote("", ["bash", "read_file", "grep"]);
+        expect(note).toMatch(/interrupted|stall/i);
+        expect(note).toMatch(/bash/);
+        expect(note).toMatch(/read_file/);
+        expect(note).toMatch(/3 tool/); // count
+    });
+    it("warns against blindly redoing partially-applied work", () => {
+        expect(buildInterruptedTurnNote("", ["bash"])).toMatch(/partial|re-check|recheck/i);
+    });
+    it("prepends any partial assistant text before the note", () => {
+        const note = buildInterruptedTurnNote("Here is what I found so far:", ["bash"]);
+        expect(note.startsWith("Here is what I found so far:")).toBe(true);
+        expect(note).toMatch(/interrupted|stall/i);
+    });
+    it("dedupes tool names but keeps the raw count", () => {
+        const note = buildInterruptedTurnNote("", ["bash", "bash", "bash", "read_file"]);
+        expect(note).toMatch(/4 tool/); // raw count
+        // bash listed once
+        expect(note.match(/bash/g)?.length).toBe(1);
+    });
+    it("handles the no-tools case with a generic note", () => {
+        const note = buildInterruptedTurnNote("", []);
+        expect(note).toMatch(/interrupted|stall/i);
+        expect(note).not.toMatch(/tool call/);
+    });
+});
+//# sourceMappingURL=interrupted-turn.test.js.map

package/dist/src/orchestrator/message-processor.d.ts

@@ -11,6 +11,7 @@ import type { CouncilManager } from "./council-manager.js";
 import type { CrossTurnDedup } from "./cross-turn-dedup.js";
 import type { PendingCallsLog } from "./pending-calls.js";
 import type { ReadPathBudget } from "./read-path-budget.js";
+import { type ToolLoopCapAsk } from "./tool-loop-cap.js";
 import type { TurnRunnerDepsBase } from "./turn-runner-deps.js";
 /**
  * Dependency surface the MessageProcessor needs to reach back into Agent
@@ -90,6 +91,16 @@ export interface MessageProcessorDeps extends TurnRunnerDepsBase {
     estimateProjectSize(): "small" | "medium" | "large" | null;
     countFilesTouched(): number;
     respondToToolApproval(approvalId: string, approved: boolean): void;
+    /**
+     * Tool-loop cap askcard hook (Claude-Code-style "continue?" prompt).
+     *
+     * Fires when the streamText loop reaches `maxToolRounds`. Returning
+     * `"continue"` raises the cap by `bumpBy` and lets the loop run; `"stop"`
+     * halts gracefully (no error). When undefined the loop hard-stops as before
+     * — preserves backward compat for batch / headless paths that have no UI to
+     * surface the askcard.
+     */
+    askToolLoopContinue?: ToolLoopCapAsk;
     runCouncilV2(userMessage: string, opts: {
         skipClarification: boolean;
         observer?: ProcessMessageObserver;
@@ -111,16 +122,6 @@ export interface MessageProcessorDeps extends TurnRunnerDepsBase {
         signal: AbortSignal;
     }): AsyncGenerator<StreamChunk, void, unknown>;
 }
-/**
- * MessageProcessor — extracted streaming turn loop.
- *
- * Lifecycle:
- *   const processor = new MessageProcessor(deps);
- *   yield* processor.run(userMessage, observer, images);
- *
- * Constructed per call (heap allocation is negligible against the streamText
- * cost), matching the StreamRunner / CouncilManager pattern.
- */
 export declare class MessageProcessor {
     private deps;
     constructor(deps: MessageProcessorDeps);