@lazyingart/agintiflow 0.20.207 → 0.20.209

package/docs/supervision-campaign-ledger.md

@@ -38,6 +38,11 @@ Create, start, and finish a concrete run with `test`, `start`, `event`, and
 idempotent or append-only SQLite operation suitable for a persistent tmux
 campaign.
 
+Test registration validates that any named capability and scenario belong to
+the same campaign. Finishing a test updates the test, capability, and scenario
+status in one SQLite transaction, so a typo cannot silently leave the campaign
+matrix stale or split across contradictory states.
+
 Inspect current coverage:
 
 ```bash
@@ -48,3 +53,25 @@ node scripts/supervision-ledger.js status \
 Do not mark a test passed from the agent's prose. Verify session events, files,
 checks, external state, and side-effect boundaries first, then store those paths
 in `evidence_json` and `events`.
+
+## Current Campaign Findings
+
+### Data analysis retained-state recovery
+
+`data-analysis-local-011` passed after reusable runtime fixes. AgInTi completed
+the mixed sensor-export project, repaired its own unclosed CSV handles, created
+commits `2f79553` and `3317a59`, and resumed the same durable session after a
+control-loop pause. Independent validation ran both the unit suite and the
+canonical generator with `ResourceWarning` promoted to an error; all tests,
+audit counts, condition means, plot bytes, and clean-git checks passed.
+
+The incident established two general contracts:
+
+- A canonical command wrapped only by an explicit exit-status probe, such as
+  `python analysis.py; echo "EXIT=$?"`, is valid evidence when the captured
+  status is zero. Arbitrary semicolon chains remain invalid because a later
+  command can hide an earlier failure.
+- User-facing artifacts keep canonical workspace paths but receive a readable
+  canvas/download filename derived from the task title and source purpose.
+  Internal collision identifiers are short suffixes, never the leading or only
+  visible filename information.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lazyingart/agintiflow",
-  "version": "0.20.207",
+  "version": "0.20.209",
   "type": "module",
   "description": "AgInTiFlow is a project-aware agent workspace for hybrid wet-dry R&D, hardware-aware intelligence, software automation, and industrial workflows.",
   "license": "Apache-2.0",
@@ -61,10 +61,24 @@
     "scripts/setup-agent-toolchain-docker.sh",
     "scripts/real-deepseek-capabilities.js",
     "scripts/postinstall-webapp.js",
+    "scripts/check-js-syntax.js",
     "scripts/seed-supervised-homework.js",
     "scripts/supervision-ledger.js",
     "scripts/smoke-supervision-ledger.js",
     "scripts/smoke-integration-production-mount.js",
+    "scripts/smoke-integration-storage-authority.js",
+    "scripts/smoke-integration-retained-durable-common.js",
+    "scripts/smoke-integration-retained-file-lock.js",
+    "scripts/smoke-integration-retained-event-ledger.js",
+    "scripts/smoke-integration-retained-event-ledger-bundle.js",
+    "scripts/smoke-integration-retained-repository-kernel.js",
+    "scripts/smoke-integration-retained-session-state-store.js",
+    "scripts/smoke-integration-retained-native-session-repository-state.js",
+    "scripts/smoke-integration-retained-native-execution-evidence.js",
+    "scripts/smoke-integration-retained-runtime-repository-surface.js",
+    "scripts/smoke-integration-retained-runtime-repository-phase-b.js",
+    "scripts/smoke-integration-runtime-repository-contract.js",
+    "scripts/smoke-integration-runtime-authority.js",
     "scripts/smoke-auxiliary-tools.js",
     "scripts/smoke-agentlink.js",
     "scripts/smoke-auth.js",
@@ -82,6 +96,7 @@
     "scripts/smoke-long-jobs.js",
     "scripts/smoke-localllm-auto-max.js",
     "scripts/smoke-localllm-code-routing.js",
+    "scripts/smoke-local-failure-recovery.js",
     "scripts/smoke-local-resource-policy.js",
     "scripts/smoke-localllm-model-tiers.js",
     "scripts/smoke-localllm-provider.js",
@@ -130,7 +145,7 @@
   "scripts": {
     "start": "node run.js",
     "web": "node web.js",
-    "check": "node --check run.js && node --check web.js && node --check bin/aginti-cli.js && node --check bin/aginti-integration.js && node --check bin/aginti-public-research.js && node --check bin/aginti-safe-chat.js && node --check src/*.js && node --check src/mcp/*.js && node --check public/*.js && node --check scripts/postinstall-webapp.js && node --check scripts/seed-supervised-homework.js && node --check scripts/supervision-ledger.js && node --check scripts/smoke-supervision-ledger.js && node --check scripts/smoke-integration-production-mount.js && node --check scripts/eval-provider-attribution.js && node --check scripts/smoke-agentlink.js && node --check scripts/smoke-execution-policy.js && node --check scripts/smoke-math-rendering.js && node --check scripts/smoke-mcp.js && node --check scripts/smoke-public-research-wrapper.js && node --check scripts/smoke-runtime-core.js && node --check scripts/smoke-safe-chat.js && node --check scripts/smoke-web-ui.js && node --check scripts/smoke-scs-evidence-visibility.js && node --check scripts/fixtures/mcp-stdio-smoke-server.mjs",
+    "check": "node scripts/check-js-syntax.js",
     "setup:toolchain-docker": "scripts/setup-agent-toolchain-docker.sh",
     "smoke:coding-tools": "node scripts/smoke-coding-tools.js",
     "smoke:dynamic-step-budget": "node scripts/smoke-dynamic-step-budget.js",
@@ -186,10 +201,23 @@
     "supervision:ledger": "node scripts/supervision-ledger.js",
     "smoke:supervision-ledger": "node scripts/smoke-supervision-ledger.js",
     "smoke:integration-production-mount": "node scripts/smoke-integration-production-mount.js",
+    "smoke:integration-storage-authority": "node scripts/smoke-integration-storage-authority.js",
+    "smoke:integration-retained-durable-common": "node scripts/smoke-integration-retained-durable-common.js",
+    "smoke:integration-retained-file-lock": "node scripts/smoke-integration-retained-file-lock.js",
+    "smoke:integration-retained-event-ledger": "node scripts/smoke-integration-retained-event-ledger.js",
+    "smoke:integration-retained-event-ledger-bundle": "node --experimental-test-module-mocks scripts/smoke-integration-retained-event-ledger-bundle.js",
+    "smoke:integration-retained-repository-kernel": "node --experimental-test-module-mocks scripts/smoke-integration-retained-repository-kernel.js",
+    "smoke:integration-retained-session-state-store": "node --experimental-test-module-mocks scripts/smoke-integration-retained-session-state-store.js",
+    "smoke:integration-retained-native-session-repository-state": "node --experimental-test-module-mocks scripts/smoke-integration-retained-native-session-repository-state.js",
+    "smoke:integration-retained-native-execution-evidence": "node scripts/smoke-integration-retained-native-execution-evidence.js",
+    "smoke:integration-retained-runtime-repository-surface": "node scripts/smoke-integration-retained-runtime-repository-surface.js",
+    "smoke:integration-retained-runtime-repository-phase-b": "node scripts/smoke-integration-retained-runtime-repository-phase-b.js",
+    "smoke:integration-runtime-repository-contract": "node scripts/smoke-integration-runtime-repository-contract.js",
+    "smoke:integration-runtime-authority": "node scripts/smoke-integration-runtime-authority.js",
     "storage:migrate": "node bin/aginti-cli.js storage migrate",
     "publish:env": "node scripts/npm-publish-from-env.js publish --access public",
     "publish:env:whoami": "node scripts/npm-publish-from-env.js whoami",
-    "test": "npm run check && npm run smoke:integration-production-mount && npm run smoke:localllm-provider && npm run smoke:localllm-model-tiers && npm run smoke:localllm-code-routing && npm run smoke:local-failure-recovery && npm run smoke:localllm-auto-max && npm run smoke:local-resource-policy && npm run smoke:context-budget-recovery && npm run smoke:session-runtime && npm run smoke:runtime-core && npm run smoke:progressive-tools && npm run smoke:truthful-completion && npm run smoke:writing-specialist-routing && npm run eval:local-first-agent && npm run eval:provider-attribution && npm run smoke:runtime-compat && npm run smoke:autoupdate && npm run smoke:web-api && npm run smoke:math-rendering && npm run smoke:web-ui && npm run smoke:web-autostart && npm run smoke:webapp-command && npm run smoke:web-port-fallback && npm run smoke:docker-command && npm run smoke:coding-tools && npm run smoke:dynamic-step-budget && npm run smoke:execution-policy && npm run smoke:aaps-adapter && npm run smoke:auxiliary-tools && npm run smoke:perception-research && npm run smoke:deep-research && npm run smoke:public-research && npm run smoke:safe-chat && npm run smoke:auth && npm run smoke:agentlink && npm run smoke:canvas-artifacts && npm run smoke:capabilities && npm run smoke:mcp && npm run smoke:model-roles && npm run smoke:platform && npm run smoke:permission-modes && npm run smoke:skills && npm run smoke:skillmesh && npm run smoke:supervision-ledger && npm run smoke:tmux-tools && npm run smoke:long-jobs && npm run smoke:run-stdin && npm run smoke:cli-chat && npm run smoke:inbox",
+    "test": "npm run check && npm run smoke:integration-production-mount && npm run smoke:integration-storage-authority && npm run smoke:integration-retained-durable-common && npm run smoke:integration-retained-file-lock && npm run smoke:integration-retained-event-ledger && npm run smoke:integration-retained-event-ledger-bundle && npm run smoke:integration-retained-repository-kernel && npm run smoke:integration-retained-session-state-store && npm run smoke:integration-retained-native-session-repository-state && npm run smoke:integration-retained-native-execution-evidence && npm run smoke:integration-retained-runtime-repository-surface && npm run smoke:integration-retained-runtime-repository-phase-b && npm run smoke:integration-runtime-repository-contract && npm run smoke:integration-runtime-authority && npm run smoke:localllm-provider && npm run smoke:localllm-model-tiers && npm run smoke:localllm-code-routing && npm run smoke:local-failure-recovery && npm run smoke:localllm-auto-max && npm run smoke:local-resource-policy && npm run smoke:context-budget-recovery && npm run smoke:session-runtime && npm run smoke:runtime-core && npm run smoke:progressive-tools && npm run smoke:truthful-completion && npm run smoke:writing-specialist-routing && npm run eval:local-first-agent && npm run eval:provider-attribution && npm run smoke:runtime-compat && npm run smoke:autoupdate && npm run smoke:web-api && npm run smoke:math-rendering && npm run smoke:web-ui && npm run smoke:web-autostart && npm run smoke:webapp-command && npm run smoke:web-port-fallback && npm run smoke:docker-command && npm run smoke:coding-tools && npm run smoke:dynamic-step-budget && npm run smoke:execution-policy && npm run smoke:aaps-adapter && npm run smoke:auxiliary-tools && npm run smoke:perception-research && npm run smoke:deep-research && npm run smoke:public-research && npm run smoke:safe-chat && npm run smoke:auth && npm run smoke:agentlink && npm run smoke:canvas-artifacts && npm run smoke:capabilities && npm run smoke:mcp && npm run smoke:model-roles && npm run smoke:platform && npm run smoke:permission-modes && npm run smoke:skills && npm run smoke:skillmesh && npm run smoke:supervision-ledger && npm run smoke:tmux-tools && npm run smoke:long-jobs && npm run smoke:run-stdin && npm run smoke:cli-chat && npm run smoke:inbox",
     "pack:dry-run": "npm pack --dry-run",
     "smoke:capabilities": "node scripts/smoke-capabilities.js"
   },

package/scripts/check-js-syntax.js

@@ -0,0 +1,38 @@
+#!/usr/bin/env node
+import { spawnSync } from "node:child_process";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const projectRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const roots = ["run.js", "web.js", "bin", "src", "public", "scripts"];
+const extensions = new Set([".cjs", ".js", ".mjs"]);
+
+async function collect(entryPath, files) {
+  const stat = await fs.lstat(entryPath);
+  if (stat.isSymbolicLink()) return;
+  if (stat.isDirectory()) {
+    const entries = await fs.readdir(entryPath, { withFileTypes: true });
+    for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
+      await collect(path.join(entryPath, entry.name), files);
+    }
+    return;
+  }
+  if (stat.isFile() && extensions.has(path.extname(entryPath).toLowerCase())) files.push(entryPath);
+}
+
+const files = [];
+for (const root of roots) await collect(path.join(projectRoot, root), files);
+
+for (const filePath of files) {
+  const checked = spawnSync(process.execPath, ["--check", filePath], {
+    cwd: projectRoot,
+    encoding: "utf8",
+  });
+  if (checked.status !== 0) {
+    process.stderr.write(checked.stderr || checked.stdout || `Syntax check failed: ${filePath}\n`);
+    process.exit(checked.status || 1);
+  }
+}
+
+console.log(`JavaScript syntax check passed (${files.length} files).`);

package/scripts/smoke-canvas-artifacts.js

@@ -40,6 +40,24 @@ async function main() {
   const persisted = await persistCanvasPayloadFile(normalized.payload, { config, store });
   if (!persisted.ok) throw new Error(persisted.reason || "canvas artifact persistence failed");
   if (!persisted.payload.artifactPersisted) throw new Error("canvas file was not persisted into session artifacts");
+  if (persisted.payload.downloadName !== "durable-report.md") {
+    throw new Error(`canvas artifact lost its meaningful download name: ${persisted.payload.downloadName}`);
+  }
+  if (!/^durable-report--[A-Za-z0-9_-]{8}\.md$/.test(path.basename(persisted.payload.sessionFilePath))) {
+    throw new Error(`canvas persistence put an opaque id before the filename: ${persisted.payload.sessionFilePath}`);
+  }
+
+  const genericNamed = normalizeCanvasPayload(
+    {
+      title: "Fluorescence Experiment Analysis",
+      kind: "pdf",
+      path: "report.pdf",
+    },
+    config
+  );
+  if (!genericNamed.ok || genericNamed.payload.downloadName !== "Fluorescence-Experiment-Analysis.pdf") {
+    throw new Error(`generic artifact did not receive a task-meaningful filename: ${genericNamed.payload?.downloadName}`);
+  }
 
   await fs.rm(sourcePath);
 
@@ -59,6 +77,7 @@ async function main() {
   const content = await readArtifactContent(items[0], { store, config });
   if (!content.ok) throw new Error(content.error || "persisted artifact could not be read");
   if (!String(content.text || "").includes("Durable report")) throw new Error("persisted artifact content mismatch");
+  if (content.filename !== "durable-report.md") throw new Error("artifact read metadata lost the download filename");
 
   const largeImagePath = path.join(workspace, "large-preview.png");
   const pngHeader = Buffer.from("89504e470d0a1a0a", "hex");

package/scripts/smoke-cli-chat.js

@@ -1190,6 +1190,7 @@ try {
 
   const resumeStatePath = path.join(agintiflowHome, "sessions", resumedSessionId, "state.json");
   const runtimeBeforeAmbientResume = JSON.parse(await fs.readFile(resumeStatePath, "utf8"));
+  const completedArtifactBeforeAmbientResume = await fs.stat(path.join(tempRoot, "notes/interactive.md"));
   const ambientSecret = "must-not-persist-cli-resume-secret";
   const ordinaryResume = await runCli(
     ["resume", resumedSessionId, "--", "Continue this saved mock session without changing its runtime."],
@@ -1204,6 +1205,7 @@ try {
     }
   );
   const runtimeAfterAmbientResume = JSON.parse(await fs.readFile(resumeStatePath, "utf8"));
+  const completedArtifactAfterAmbientResume = await fs.stat(path.join(tempRoot, "notes/interactive.md"));
   if (
     runtimeAfterAmbientResume.meta.runtimeConfig.provider !== "mock" ||
     runtimeAfterAmbientResume.meta.runtimeConfig.model !== "mock-agent" ||
@@ -1213,6 +1215,14 @@ try {
   ) {
     throw new Error("ordinary one-shot resume drifted to ambient provider/model/key settings");
   }
+  if (
+    completedArtifactAfterAmbientResume.mtimeMs !== completedArtifactBeforeAmbientResume.mtimeMs ||
+    runtimeAfterAmbientResume.meta.goalContract.status !== "completed" ||
+    runtimeAfterAmbientResume.meta.goalContract.lifecycle.at(-1)?.reason !== "completed_task_noop" ||
+    !ordinaryResume.stdout.includes("did not repeat any tool or external side effect")
+  ) {
+    throw new Error("generic resume of a completed task repeated work instead of preserving the verified result");
+  }
 
   await runCli(
     ["resume", resumedSessionId, "--no-web-search", "--no-auxiliary-tools", "--", "Continue with explicitly reduced tools."],

package/scripts/smoke-coding-tools.js

@@ -5,8 +5,10 @@ import path from "node:path";
 import { fileURLToPath } from "node:url";
 import {
   buildModelTimeoutRetryMessages,
+  genericArtifactFilenameBlock,
   modelTimeoutRetryRoute,
   repairModelMessageHistory,
+  shouldResetStaticDiscoveryPhase,
   runAgent,
   sanitizeToolResult,
   toolResultForModel,
@@ -18,6 +20,7 @@ import { formatBehaviorContractForPrompt } from "../src/behavior-contract.js";
 import { resolveRuntimeConfig } from "../src/config.js";
 import { readCodebaseMap } from "../src/codebase-map.js";
 import { evaluateCommandPolicy } from "../src/command-policy.js";
+import { shouldReviewToolResult } from "../src/scs-controller.js";
 import {
   engineeringGuidanceForTask,
   recommendedMaxStepsForTask,
@@ -81,6 +84,40 @@ async function runMock(goal, sessionId, { resume = false } = {}) {
 }
 
 try {
+  const genericArtifactBlock = await genericArtifactFilenameBlock(
+    "write_file",
+    { path: "report.md", content: "summary" },
+    { commandCwd: workspace, taskProfile: "data", goal: "Analyze the fluorescence experiment exports." },
+    { goal: "Analyze the fluorescence experiment exports.", messages: [], meta: {} }
+  );
+  assert(
+    genericArtifactBlock?.category === "artifact-filename" &&
+      /fluorescence|experiment/i.test(genericArtifactBlock.permissionAdvice?.instruction || ""),
+    "new generic artifact filename was not redirected to a meaningful topic-derived name"
+  );
+  assert(
+    (await genericArtifactFilenameBlock(
+      "write_file",
+      { path: "outputs/summary.json", content: "{}" },
+      { commandCwd: workspace, taskProfile: "data", goal: "Analyze the experiment." },
+      {
+        goal: "Analyze the experiment.",
+        messages: [],
+        meta: { projectVerification: { requiredOutputs: ["outputs/summary.json"] } },
+      }
+    )) === null,
+    "an exact project-declared artifact filename was incorrectly rejected as generic"
+  );
+  assert(
+    (await genericArtifactFilenameBlock(
+      "write_file",
+      { path: "reports/fluorescence-dose-response-analysis.md", content: "summary" },
+      { commandCwd: workspace, taskProfile: "data" },
+      { goal: "Analyze the experiment.", messages: [], meta: {} }
+    )) === null,
+    "a descriptive artifact filename was incorrectly blocked"
+  );
+
   const staleDeepSeekState = {
     messages: [
       { role: "system", content: "system" },
@@ -164,6 +201,74 @@ try {
     interruptedDeepSeekState.messages.at(-1)?.content === "Continue with this new request: /review",
     "interrupted repair dropped the new user request"
   );
+  const deepSeekCompactionState = {
+    goal: "Continue a data repair from retained evidence.",
+    plan: "Use the verified source evidence, repair once, then test.",
+    stepsCompleted: 4,
+    meta: {},
+    messages: [
+      { role: "system", content: "system" },
+      { role: "user", content: "inspect the exact source" },
+      {
+        role: "assistant",
+        content: "",
+        reasoning_content: "The source must be read before editing.",
+        tool_calls: [
+          { id: "deep-read", type: "function", function: { name: "read_file", arguments: '{"path":"analysis.py"}' } },
+        ],
+      },
+      { role: "tool", tool_call_id: "deep-read", content: '{"ok":true,"path":"analysis.py","content":"verified source"}' },
+    ],
+  };
+  const deepSeekCompacted = buildModelTimeoutRetryMessages(
+    deepSeekCompactionState,
+    { provider: "deepseek", model: "deepseek-v4-pro", contextWindowTokens: 32768 },
+    { url: "", title: "No browser page open" },
+    5,
+    new Error("synthetic timeout")
+  );
+  assert(
+    !deepSeekCompacted.some((message) => message.role === "assistant" && Array.isArray(message.tool_calls)),
+    "DeepSeek compaction synthesized assistant tool calls without original reasoning_content"
+  );
+  assert(
+    deepSeekCompacted.some(
+      (message) => message.role === "user" && /Retained runtime tool evidence/.test(message.content) && /analysis\.py/.test(message.content) && /verified source/.test(message.content)
+    ),
+    "DeepSeek compaction dropped bounded source evidence while removing synthetic tool-call messages"
+  );
+  assert(
+    !shouldReviewToolResult(
+      { ok: true, toolName: "read_file", path: "analysis.py" },
+      { meta: { toolLoop: { warned: ["old-read"], recent: [{ toolName: "read_file", ok: false }] } } }
+    ),
+    "SCS scheduled a redundant review for a successful read because an older read failed"
+  );
+  assert(
+    shouldReviewToolResult(
+      { ok: false, blocked: true, toolName: "read_file", reason: "exact read blocked" },
+      { meta: { toolLoop: { warned: [], recent: [] } } }
+    ),
+    "SCS stopped reviewing an exact blocked tool result"
+  );
+  assert(
+    !shouldResetStaticDiscoveryPhase({
+      ok: true,
+      toolName: "run_command",
+      args: { command: 'echo "SOURCE"; cat analysis.py; echo "DIFF"; git diff -- analysis.py' },
+      commandPolicy: { writesWorkspace: false },
+    }),
+    "composite read-only shell discovery incorrectly reset the bounded discovery phase"
+  );
+  assert(
+    shouldResetStaticDiscoveryPhase({
+      ok: true,
+      toolName: "run_command",
+      args: { command: "python analysis.py" },
+      commandPolicy: { writesWorkspace: true },
+    }),
+    "a successful workspace-writing command did not reset the discovery phase"
+  );
   const workspaceToolConfig = {
     commandCwd: workspace,
     allowFileTools: true,
@@ -1111,6 +1216,14 @@ try {
     localTimeoutRoute.model === "localllm-fast" && localTimeoutRoute.retryTimeoutMs === 90000,
     "LocalLLM timeout retry did not switch to its same-boundary fast route"
   );
+  const defaultLocalTimeoutRoute = modelTimeoutRetryRoute({
+    provider: "localllm",
+    model: "localllm-fast",
+  });
+  assert(
+    defaultLocalTimeoutRoute.timeoutMs === 300000 && defaultLocalTimeoutRoute.retryTimeoutMs === 600000,
+    "LocalLLM default timeout did not allow bounded slow local generation and one longer retry"
+  );
   const artifactTimeoutMessages = buildModelTimeoutRetryMessages(
     {
       meta: {
@@ -1307,6 +1420,30 @@ try {
   const unifiedText = await fs.readFile(path.join(workspace, "unified-target.txt"), "utf8");
   assert(unified.ok && unifiedText === "alpha\nnew\nomega\n", "unified apply_patch did not update expected file");
 
+  await fs.writeFile(path.join(workspace, "hybrid-patch-target.txt"), "alpha\nold\nomega\n", "utf8");
+  const hybridPatch = await executeWorkspaceTool(
+    "apply_patch",
+    {
+      patch: [
+        "*** Begin Patch ***",
+        "--- a/hybrid-patch-target.txt",
+        "+++ b/hybrid-patch-target.txt",
+        "@@ -1,3 +1,3 @@",
+        " alpha",
+        "-old",
+        "+new",
+        " omega",
+        "*** End Patch ***",
+      ].join("\n"),
+    },
+    { commandCwd: workspace, allowFileTools: true }
+  );
+  const hybridPatchText = await fs.readFile(path.join(workspace, "hybrid-patch-target.txt"), "utf8");
+  assert(
+    hybridPatch.ok && hybridPatchText === "alpha\nnew\nomega\n",
+    "hybrid wrapped unified apply_patch did not update expected file"
+  );
+
   await fs.writeFile(path.join(workspace, "repair-report.md"), "old report\n", "utf8");
   const ordinaryAddExistingError = await executeWorkspaceTool(
     "apply_patch",

package/scripts/smoke-context-budget-recovery.js

@@ -163,6 +163,10 @@ const runtimeMessages = buildContextBudgetCompactionMessages(
   { reason: "test context recovery" }
 );
 const runtimeText = runtimeMessages.map((message) => message.content || "").join("\n");
+assert.ok(
+  estimateMessageTokens(runtimeMessages) <= 12288,
+  "runtime compaction exceeded the bounded LocalLLM retry target"
+);
 assert.ok(runtimeText.includes(HEAD));
 assert.ok(runtimeText.includes(TAIL));
 assert.ok(runtimeText.includes("latest interruption"));

package/scripts/smoke-deep-research.js

@@ -52,6 +52,13 @@ async function main() {
     toolChoiceForProvider({ provider: "deepseek" }, []) === "auto",
     "provider-neutral research routing added an unsupported named tool_choice"
   );
+  assert(
+    toolChoiceForProvider(
+      { provider: "deepseek" },
+      [{ role: "user", content: "Emit exactly one enabled tool call that performs the next concrete action." }]
+    ) === "auto",
+    "DeepSeek thinking mode received unsupported required tool selection during recovery"
+  );
   assert(
     JSON.stringify(providerStructuredOutputAttempts("deepseek")) === JSON.stringify(["json_object", "prompt"]),
     "DeepSeek structured extraction still probes an unsupported JSON Schema mode"