@lazyingart/agintiflow 0.20.246 → 0.20.248

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lazyingart/agintiflow",
-  "version": "0.20.246",
+  "version": "0.20.248",
   "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",

package/scripts/smoke-capabilities.js

@@ -49,6 +49,20 @@ async function runCliIn(cwd, args, envOverrides = {}) {
   return result.stdout;
 }
 
+async function runCliAllowStopped(args, envOverrides = {}) {
+  try {
+    const stdout = await runCli(args, envOverrides);
+    return { stdout, stderr: "", exitCode: 0 };
+  } catch (error) {
+    if (!Number.isInteger(error?.code)) throw error;
+    return {
+      stdout: String(error.stdout || ""),
+      stderr: String(error.stderr || ""),
+      exitCode: error.code,
+    };
+  }
+}
+
 try {
   await runCli(["init"]);
   const agintiMd = await fs.readFile(path.join(tempRoot, "AGINTI.md"), "utf8");
@@ -188,7 +202,7 @@ try {
   const doctor = JSON.parse(await runCli(["doctor", "--capabilities", "--json"]));
   assert(doctor.project.root === tempRoot, "doctor --capabilities used the wrong project root");
   assert(doctor.project.instructionsPresent, "doctor --capabilities did not report AGINTI.md");
-  const envSandboxRun = await runCli(
+  const envSandboxRun = await runCliAllowStopped(
     ["--provider", "mock", "--routing", "manual", "--model", "mock-agent", "--max-steps", "1", "env sandbox smoke"],
     {
       SANDBOX_MODE: "host",
@@ -196,8 +210,19 @@ try {
       USE_DOCKER_SANDBOX: "false",
     }
   );
-  assert(envSandboxRun.includes("Shell: host policy=allow"), "one-shot CLI did not respect host sandbox env defaults");
-  assert(!envSandboxRun.includes("Docker workspace:"), "one-shot CLI forced Docker despite host sandbox env defaults");
+  assert(envSandboxRun.exitCode === 1, "a step-budget-stopped one-shot CLI run did not report failure");
+  assert(
+    envSandboxRun.stderr.includes("Stopped after 1 steps without finish()."),
+    "a step-budget-stopped one-shot CLI run did not expose its terminal reason"
+  );
+  assert(
+    envSandboxRun.stdout.includes("Shell: host policy=allow"),
+    "one-shot CLI did not respect host sandbox env defaults"
+  );
+  assert(
+    !envSandboxRun.stdout.includes("Docker workspace:"),
+    "one-shot CLI forced Docker despite host sandbox env defaults"
+  );
 
   console.log(
     JSON.stringify(

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

@@ -51,6 +51,25 @@ const artifactContract = deriveScsTaskContract({
   taskProfile: "chatops",
 });
 assert.equal(artifactContract.requiresExternalEvidence, true, "real chat artifact work lost its evidence gate");
+const retainedReportContract = deriveScsTaskContract({
+  goal: [
+    "The completed evidence is already saved in tmp/reliability-evidence-pass.md and must remain read-only.",
+    "Read only missing bounded ranges of tmp/reliability-evidence-pass.md.",
+    "Rewrite agent-reliability-evidence-review.md as a concise decision document.",
+    "Rebuild sources.json so it contains only cited sources.",
+  ].join("\n"),
+  taskProfile: "research",
+});
+assert.deepEqual(
+  retainedReportContract.exactOutputPaths,
+  ["agent-reliability-evidence-review.md", "sources.json"],
+  "report continuation confused an existing saved input with rewrite/rebuild outputs"
+);
+assert.deepEqual(
+  retainedReportContract.exactInputPaths,
+  ["tmp/reliability-evidence-pass.md"],
+  "report continuation lost the read-only evidence input"
+);
 assert.ok(artifactContract.requiredEvidence.some((item) => item.category === "artifact"));
 const scopedArtifactRootContract = deriveScsTaskContract({
   goal:
@@ -355,11 +374,176 @@ function noisyFullReadPair(index, generation) {
   ];
 }
 
+function boundedOutputReadPair(index, generation) {
+  const id = `output-${generation}-${index}`;
+  return [
+    {
+      role: "assistant",
+      content: "",
+      reasoning_content: "Inspect the existing mutable output.",
+      tool_calls: [
+        {
+          id,
+          type: "function",
+          function: {
+            name: "read_file",
+            arguments: JSON.stringify({
+              path: "agent-reliability-evidence-review.md",
+              startLine: 1 + (index - 1) * 40,
+              lineLimit: 40,
+            }),
+          },
+        },
+      ],
+    },
+    {
+      role: "tool",
+      tool_call_id: id,
+      content: JSON.stringify({
+        ok: true,
+        toolName: "read_file",
+        path: "agent-reliability-evidence-review.md",
+        startLine: 1 + (index - 1) * 40,
+        lineLimit: 40,
+        lineCount: 240,
+        bytes: 24000,
+        sha256: `${generation}${String(index).padStart(2, "0")}`.repeat(24).slice(0, 64),
+        contentTruncated: false,
+        content: `MUTABLE-OUTPUT-${generation}-${index}\n${"old output content ".repeat(170)}`,
+      }),
+    },
+  ];
+}
+
+function exactInputEvidencePair(index) {
+  const id = `exact-input-${index}`;
+  const startLine = 1 + (index - 1) * 45;
+  return [
+    {
+      role: "assistant",
+      content: "",
+      reasoning_content: "Read one bounded exact-input evidence range.",
+      tool_calls: [
+        {
+          id,
+          type: "function",
+          function: {
+            name: "read_file",
+            arguments: JSON.stringify({
+              path: "tmp/reliability-evidence-pass.md",
+              startLine,
+              lineLimit: 45,
+            }),
+          },
+        },
+      ],
+    },
+    {
+      role: "tool",
+      tool_call_id: id,
+      content: JSON.stringify({
+        ok: true,
+        toolName: "read_file",
+        path: "tmp/reliability-evidence-pass.md",
+        startLine,
+        lineLimit: 45,
+        lineCount: 180,
+        bytes: 24000,
+        sha256: "dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd",
+        contentTruncated: false,
+        content: `EXACT-INPUT-RANGE-${index}\n${`source evidence ${index} `.repeat(220)}`,
+      }),
+    },
+  ];
+}
+
+function readOnlyDiagnosticPair(index) {
+  const id = `diagnostic-${index}`;
+  const command = `python3 -c "print('diagnostic ${index}')"`;
+  return [
+    {
+      role: "assistant",
+      content: "",
+      reasoning_content: "Inspect one diagnostic without changing task outputs.",
+      tool_calls: [
+        {
+          id,
+          type: "function",
+          function: { name: "run_command", arguments: JSON.stringify({ command }) },
+        },
+      ],
+    },
+    {
+      role: "tool",
+      tool_call_id: id,
+      content: JSON.stringify({
+        ok: true,
+        toolName: "run_command",
+        args: { command },
+        exitCode: 0,
+        stdout: `DIAGNOSTIC-${index}\n${"read-only shell output ".repeat(80)}`,
+      }),
+    },
+  ];
+}
+
+const exactInputCoverageState = {
+  goal: [
+    "Read tmp/reliability-evidence-pass.md as the exact read-only input.",
+    "Rewrite agent-reliability-evidence-review.md.",
+    "Rebuild sources.json.",
+  ].join("\n"),
+  plan: "Use retained evidence and create the two outputs.",
+  meta: {
+    scs: {
+      taskContract: {
+        exactInputPaths: ["tmp/reliability-evidence-pass.md"],
+        exactOutputPaths: ["agent-reliability-evidence-review.md", "sources.json"],
+      },
+    },
+  },
+  messages: [
+    { role: "system", content: `SYSTEM-INPUT-COVERAGE\n${"policy ".repeat(5000)}` },
+    { role: "user", content: "Create a source-grounded reader-facing report." },
+    ...Array.from({ length: 4 }, (_, index) => exactInputEvidencePair(index + 1)).flat(),
+    ...Array.from({ length: 10 }, (_, index) => readOnlyDiagnosticPair(index + 1)).flat(),
+    ...Array.from({ length: 6 }, (_, index) => boundedOutputReadPair(index + 1, 9)).flat(),
+  ],
+};
+const exactInputCoverage = buildContextBudgetCompactionMessages(
+  exactInputCoverageState,
+  { ...config, provider: "deepseek", model: "deepseek-chat" },
+  { title: "", url: "" },
+  20,
+  { reason: "preserve all exact-input source ranges over diagnostics" }
+);
+const exactInputCoverageText = exactInputCoverage.map((message) => message.content || "").join("\n");
+for (let index = 1; index <= 4; index += 1) {
+  assert.ok(
+    exactInputCoverageText.includes(`EXACT-INPUT-RANGE-${index}`),
+    `compaction lost exact input evidence range ${index}`
+  );
+}
+assert.ok(
+  estimateMessageTokens(exactInputCoverage) <= 12288,
+  "exact-input evidence retention exceeded the bounded retry target"
+);
+
 const twiceCompactedState = {
   ...compactionState,
+  meta: {
+    scs: {
+      taskContract: {
+        exactInputPaths: ["reports/reliability.md"],
+        exactOutputPaths: ["agent-reliability-evidence-review.md", "sources.json"],
+      },
+    },
+  },
   messages: [
     ...deepSeekRuntimeMessages,
     ...Array.from({ length: 14 }, (_, index) => noisyFullReadPair(index + 1, 2)).flat(),
+    ...Array.from({ length: 8 }, (_, index) => readOnlyDiagnosticPair(index + 1)).flat(),
+    ...Array.from({ length: 6 }, (_, index) => boundedOutputReadPair(index + 1, 2)).flat(),
   ],
 };
 const twiceCompacted = buildContextBudgetCompactionMessages(
@@ -381,9 +565,11 @@ assert.equal(
 
 const thriceCompactedState = {
   ...compactionState,
+  meta: twiceCompactedState.meta,
   messages: [
     ...twiceCompacted,
     ...Array.from({ length: 14 }, (_, index) => noisyFullReadPair(index + 1, 3)).flat(),
+    ...Array.from({ length: 6 }, (_, index) => boundedOutputReadPair(index + 1, 3)).flat(),
   ],
 };
 const thriceCompacted = buildContextBudgetCompactionMessages(

package/scripts/smoke-deep-research.js

@@ -9,6 +9,7 @@ import { flushHousekeeping } from "../src/housekeeping.js";
 import { requestNextStep, toolChoiceForProvider } from "../src/model-client.js";
 import { providerStructuredOutputAttempts } from "../src/provider-contract.js";
 import {
+  hasExplicitDeepResearchSuppression,
   hasExplicitDeepResearchIntent,
   hasLocalResearchWorkspaceIntent,
   shouldStartWithDeepResearch,
@@ -107,6 +108,50 @@ async function main() {
     shouldStartWithDeepResearch("Write a deep web research report comparing three primary papers."),
     "standalone deep research no longer starts with the bounded research workflow"
   );
+  const retainedResearchGoal = [
+    "Continue the interrupted evidence-review task from its saved state.",
+    "Do not run deep_research again. Reuse the completed research artifact.",
+    "Rewrite agent-reliability-evidence-review.md from the retained evidence.",
+  ].join("\n");
+  assert(
+    hasExplicitDeepResearchSuppression(retainedResearchGoal),
+    "an explicit completed-research reuse instruction was not detected"
+  );
+  assert(
+    !shouldStartWithDeepResearch(retainedResearchGoal, inspectedLocalEvidenceMessages),
+    "an explicit prohibition still narrowed the next turn to deep_research"
+  );
+  const coordinatedSuppressionGoal = [
+    "Resume the saved evidence-review task.",
+    "Do not restart the task, run deep_research, or reopen broad discovery.",
+    "Use the retained completed evidence and rebuild sources.json.",
+  ].join("\n");
+  assert(
+    hasExplicitDeepResearchSuppression(coordinatedSuppressionGoal),
+    "a coordinated do-not clause did not suppress deep_research"
+  );
+  assert(
+    !shouldStartWithDeepResearch(localEvidenceGoal, [
+      { role: "user", content: coordinatedSuppressionGoal },
+      ...inspectedLocalEvidenceMessages.slice(1),
+    ]),
+    "a resumed retained-evidence repair was forced back into deep_research after inspection"
+  );
+  assert(
+    shouldStartWithDeepResearch(localEvidenceGoal, [
+      ...inspectedLocalEvidenceMessages,
+      { role: "user", content: "Run a fresh deep research pass now; the retained evidence is stale." },
+      {
+        role: "assistant",
+        tool_calls: [{ id: "fresh-report", function: { name: "read_file", arguments: '{"path":"agent-reliability-evidence-review.md"}' } }],
+      },
+      {
+        role: "assistant",
+        tool_calls: [{ id: "fresh-sources", function: { name: "read_file", arguments: '{"path":"sources.json"}' } }],
+      },
+    ]),
+    "an older completed-research context suppressed a newer explicit refresh request"
+  );
   assert(
     !hasExplicitDeepResearchIntent("Create a phone-friendly document from this folder.", [
       {

package/scripts/smoke-dynamic-step-budget.js

@@ -1364,6 +1364,33 @@ try {
       `a status wrapper changed the inner command's mutation identity: ${command}`
     );
   }
+  const readOnlyValidatorState = { meta: { goalContract: { revision: 1 } } };
+  const readOnlyValidatorResult = {
+    toolName: "run_command",
+    ok: true,
+    exitCode: 0,
+    args: {
+      command:
+        'python3 tmp/external_agent_reliability_quality.py . ; echo "EXIT=$?"',
+    },
+    stdout: "agent reliability research contract passed\nEXIT=1\n",
+    stderr: "agent reliability research quality failed\n",
+    commandPolicy: {
+      category: "toolchain",
+      writesWorkspace: true,
+      mayMutateProject: false,
+      substantiveTest: false,
+    },
+  };
+  recordProjectVerificationOutcome(readOnlyValidatorState, readOnlyValidatorResult, {
+    commandCwd: workspace,
+    taskProfile: "writing",
+  });
+  assert(
+    readOnlyValidatorState.meta.projectVerification?.mutationRevision === 0 &&
+      readOnlyValidatorResult.projectMutationRevision === 0,
+    "a semantically read-only validator fabricated project mutation progress"
+  );
   const shellMutationState = { meta: { goalContract: { revision: 1 } } };
   const shellMutationResult = {
     toolName: "run_command",
@@ -2479,6 +2506,13 @@ try {
     args: { command: "npm test && git pull --ff-only" },
     stdout: "1 test passed",
     stderr: "",
+    commandPolicy: {
+      category: "git-remote",
+      writesWorkspace: true,
+      mayMutateProject: false,
+      substantiveTest: true,
+      gitOnly: false,
+    },
   };
   recordProjectVerificationOutcome(testBeforePullState, testBeforePullResult, {
     commandCwd: workspace,
@@ -3067,6 +3101,21 @@ try {
     shouldResetStaticDiscoveryPhase({ ok: true, toolName: "write_file", args: { path: "report.md" } }),
     "successful output creation should reset static discovery convergence"
   );
+  assert(
+    !shouldResetStaticDiscoveryPhase({
+      ok: true,
+      toolName: "run_command",
+      args: { command: "python3 - <<'PY'\nprint('inspect only')\nPY" },
+      commandPolicy: {
+        writesWorkspace: true,
+        mayMutateProject: false,
+        substantiveTest: false,
+      },
+      exitCode: 0,
+      stdout: "inspect only",
+    }),
+    "a read-only diagnostic shell probe reset static discovery because of a conservative write heuristic"
+  );
   const uniqueDiscovery = {};
   recordStaticDiscoveryProgress(uniqueDiscovery, "read_file:/reference/A.md");
   recordStaticDiscoveryProgress(uniqueDiscovery, "read_file:/reference/A.md");
@@ -3095,6 +3144,32 @@ try {
     JSON.stringify(compactedDiscoveryState.meta.toolLoop.warned) === JSON.stringify(["run_command:keep"]),
     "context recovery did not clear only stale static-read warnings"
   );
+  const retainedDiscoveryState = {
+    meta: {
+      toolLoop: {
+        recent: [],
+        warned: ["file-read:/reference/A.md"],
+        staticCounts: { "file-read:/reference/A.md": 2 },
+        staticOrder: ["file-read:/reference/A.md"],
+        staticTotal: 1,
+        staticCallTotal: 2,
+      },
+    },
+  };
+  resetStaticDiscoveryAfterContextLoss(
+    retainedDiscoveryState,
+    "proactive-context-compaction",
+    { preserveStaticEvidence: true }
+  );
+  assert(
+    retainedDiscoveryState.meta.toolLoop.staticTotal === 1 &&
+      retainedDiscoveryState.meta.toolLoop.staticCounts["file-read:/reference/A.md"] === 2,
+    "lossless context compaction reopened already completed discovery"
+  );
+  assert(
+    retainedDiscoveryState.meta.toolLoop.lastContextRecovery?.preservedStaticEvidence === true,
+    "lossless context compaction did not record preserved discovery evidence"
+  );
   const exactReadSignature = staticToolCallSignature("read_file", { path: "/reference/A.md" }, {
     commandCwd: workspace,
   });
@@ -6065,6 +6140,35 @@ try {
     events: [],
   });
   assert(!staticOnlyDecision.approved, "budget gate treated static discovery alone as implementation progress");
+  const readOnlyShellDecision = decideStepBudgetExtension({
+    config: { scsActive: true, commandCwd: "/tmp/workspace" },
+    budget: createStepBudgetState(
+      { provider: "localllm", maxSteps: 12, dynamicSteps: "on", dynamicStepExtensionLimit: 2, scsActive: true },
+      { meta: {}, stepsCompleted: 0 }
+    ),
+    step: 11,
+    state: {
+      messages: Array.from({ length: 5 }, (_, index) =>
+        toolMessage({
+          toolName: "run_command",
+          ok: true,
+          args: { command: `python3 -c "print('inspect ${index}')"` },
+          commandPolicy: {
+            writesWorkspace: true,
+            mayMutateProject: false,
+            substantiveTest: false,
+          },
+          exitCode: 0,
+          stdout: `inspection ${index}`,
+        })
+      ),
+    },
+    events: [],
+  });
+  assert(
+    !readOnlyShellDecision.approved,
+    "budget gate extended a run containing only read-only diagnostic shell output"
+  );
 
   const mockAutoBudget = createStepBudgetState({ provider: "mock", maxSteps: 4, dynamicSteps: "auto" }, { meta: {}, stepsCompleted: 0 });
   assert(!mockAutoBudget.enabled, "mock provider should not auto-extend unless explicitly enabled");

package/scripts/smoke-progressive-tool-selection.js

@@ -1515,6 +1515,43 @@ sameNames(
   ["deep_research", "finish"],
   "local evidence research did not enter the bounded research engine after inspection"
 );
+const retainedEvidenceManifestRepair = selectProgressiveTools(allTools, {
+  config: { provider: "deepseek" },
+  goal:
+    "Investigate the reliability problem in this folder, write an evidence review and sources.json, then commit the intentional work.",
+  profile: "research",
+  messages: [
+    {
+      role: "user",
+      content: [
+        "Resume the saved evidence-review task.",
+        "Do not restart the task, run deep_research, or reopen broad discovery.",
+        "Use the retained completed evidence and rebuild sources.json.",
+      ].join("\n"),
+    },
+    {
+      role: "assistant",
+      tool_calls: [{ id: "retained-sources", function: { name: "read_file", arguments: '{"path":"sources.json"}' } }],
+    },
+    {
+      role: "assistant",
+      tool_calls: [{ id: "retained-evidence", function: { name: "read_file", arguments: '{"path":"tmp/reliability-evidence-pass.md"}' } }],
+    },
+  ],
+});
+assert(
+  names(retainedEvidenceManifestRepair).includes("write_file"),
+  "retained-evidence manifest repair omitted write_file after inspection"
+);
+assert(
+  names(retainedEvidenceManifestRepair).includes("read_file"),
+  "retained-evidence manifest repair omitted bounded source reads"
+);
+assert(
+  !(names(retainedEvidenceManifestRepair).length === 2 &&
+    names(retainedEvidenceManifestRepair)[0] === "deep_research"),
+  "explicit retained-evidence reuse was forced back into deep_research"
+);
 const localEvidenceAfterDeepResearchCompaction = selectProgressiveTools(allTools, {
   config: { provider: "deepseek" },
   goal:

package/scripts/smoke-run-stdin.js

@@ -4,7 +4,7 @@ import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
-import { machineRunPayload } from "../src/cli.js";
+import { machineRunPayload, runResultExitCode } from "../src/cli.js";
 import { showProjectSession } from "../src/project.js";
 
 const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
@@ -36,6 +36,12 @@ const stoppedPayload = machineRunPayload({
 if (stoppedPayload.ok !== false || stoppedPayload.failed !== true || stoppedPayload.stopped !== true) {
   throw new Error(`stopped machine run was reported as success: ${JSON.stringify(stoppedPayload)}`);
 }
+if (runResultExitCode({ stopped: true, reason: "tool_contract_violation" }) !== 1) {
+  throw new Error("a stopped non-JSON agent run still reports shell success");
+}
+if (runResultExitCode({ stopped: false, result: "done" }) !== 0) {
+  throw new Error("a successful agent run was assigned a failing shell exit status");
+}
 
 async function runMachine(label, commandArgs, stdin = "") {
   const command = [cliPath, ...commandArgs];

package/scripts/smoke-scs-evidence-visibility.js

@@ -264,6 +264,27 @@ assert(
   "excluding output filenames also removed a real required text term"
 );
 
+const wrappedManifestRepairContract = deriveScsTaskContract({
+  goal: [
+    "The only unresolved content work",
+    "is rebuilding the stale sources.json for the current report.",
+    "The verified claims are retained in",
+    "tmp/reliability-evidence-pass.md. Then write",
+    "sources.json immediately. Do not read any other file.",
+  ].join("\n"),
+  taskProfile: "research",
+});
+assert.deepEqual(
+  wrappedManifestRepairContract.exactOutputPaths,
+  ["sources.json"],
+  "an inflected, soft-wrapped output instruction did not classify its manifest as an exact output"
+);
+assert.deepEqual(
+  wrappedManifestRepairContract.exactInputPaths,
+  ["tmp/reliability-evidence-pass.md"],
+  "a mutable exact output leaked into exact inputs through a later negated read clause"
+);
+
 const wordDocumentContract = deriveScsTaskContract({
   goal: "Create an editable DOCX and a phone-friendly PDF, then verify both outputs.",
   taskProfile: "word",

package/src/agent-runner.js

@@ -995,7 +995,7 @@ function compactRetainedToolPayload(toolName, payload = {}, args = {}) {
     result.contentTruncatedByLines = payload.contentTruncatedByLines === true;
     if (payload.sha256) result.sha256 = compactSingleLine(payload.sha256, 96);
     const content = String(payload.content || payload.contentPreview || "");
-    if (content) result.content = compactMultiline(content, 4200);
+    if (content) result.content = compactMultiline(content, 3000);
     if (Array.isArray(payload.pathEvidence)) {
       result.pathEvidence = compactPathItems(payload.pathEvidence, 12, ["path", "source"]);
     }
@@ -1018,7 +1018,22 @@ function compactRetainedToolPayload(toolName, payload = {}, args = {}) {
   return redactValue(result);
 }
 
-function retainedToolRecordPriority(record = {}) {
+function retainedPathMatchesAny(sourcePath = "", candidatePaths = []) {
+  const normalize = (value = "") =>
+    String(value || "")
+      .replace(/\\/g, "/")
+      .replace(/^\.\//, "")
+      .replace(/\/{2,}/g, "/")
+      .replace(/\/$/, "");
+  const source = normalize(sourcePath);
+  if (!source) return false;
+  return candidatePaths.some((candidate) => {
+    const output = normalize(candidate);
+    return output && (source === output || source.endsWith(`/${output}`) || output.endsWith(`/${source}`));
+  });
+}
+
+function retainedToolRecordPriority(record = {}, outputPaths = [], inputPaths = []) {
   const name = String(record.name || "");
   const args = record.args || {};
   const payload = record.payload || {};
@@ -1032,11 +1047,14 @@ function retainedToolRecordPriority(record = {}) {
   } else if (name === "read_file") {
     const range = retainedReadRange(payload, args);
     priority = range.lineLimit > 0 ? 750 : 600;
+    const sourcePath = String(payload.path || args.path || "").trim();
+    if (retainedPathMatchesAny(sourcePath, inputPaths)) priority += 260;
+    if (retainedPathMatchesAny(sourcePath, outputPaths)) priority -= 220;
   } else if (["search_files", "list_files"].includes(name)) priority = 400;
   return priority + Math.min(0.999, Math.max(0, Number(record.ordinal) || 0) / 100000);
 }
 
-function retainedToolStateMessages(messages = [], limit = 12) {
+function retainedToolStateMessages(messages = [], limit = 12, outputPaths = [], inputPaths = []) {
   const callsById = new Map();
   const recordsByKey = new Map();
   let ordinal = 0;
@@ -1086,7 +1104,8 @@ function retainedToolStateMessages(messages = [], limit = 12) {
   const selected = [...records]
     .sort(
       (left, right) =>
-        retainedToolRecordPriority(right) - retainedToolRecordPriority(left) ||
+        retainedToolRecordPriority(right, outputPaths, inputPaths) -
+          retainedToolRecordPriority(left, outputPaths, inputPaths) ||
         right.ordinal - left.ordinal
     )
     .slice(0, Math.max(1, Number(limit) || 12))
@@ -1118,8 +1137,8 @@ function retainedToolStateMessages(messages = [], limit = 12) {
   });
 }
 
-function retainedToolStateTextMessages(messages = [], limit = 12) {
-  const nativeMessages = retainedToolStateMessages(messages, limit);
+function retainedToolStateTextMessages(messages = [], limit = 12, outputPaths = [], inputPaths = []) {
+  const nativeMessages = retainedToolStateMessages(messages, limit, outputPaths, inputPaths);
   const retained = [];
   for (let index = 0; index < nativeMessages.length; index += 2) {
     const assistantMessage = nativeMessages[index];
@@ -1139,13 +1158,17 @@ function retainedToolStateTextMessages(messages = [], limit = 12) {
   return retained;
 }
 
-function retainedToolPairPriority(pair = [], order = 0) {
+function retainedToolPairPriority(pair = [], order = 0, outputPaths = [], inputPaths = []) {
   const assistantCall = pair[0]?.tool_calls?.[0];
   const retained = pair.length === 1 ? parseRetainedToolEvidenceMessage(pair[0]) : null;
   const name = String(retained?.name || assistantCall?.function?.name || "");
   const args = retained?.args || safeParseToolContent(assistantCall?.function?.arguments) || {};
   const payload = retained?.payload || safeParseToolContent(pair[1]?.content) || {};
-  return retainedToolRecordPriority({ name, args, payload, ordinal: order });
+  return retainedToolRecordPriority(
+    { name, args, payload, ordinal: order },
+    outputPaths,
+    inputPaths
+  );
 }
 
 function isRuntimeCompactionRequest(content = "") {
@@ -1327,9 +1350,11 @@ function buildCompactedRuntimeMessages(state, config, snapshot, step, options =
   // synthetic pairs, so preserve their bounded evidence as explicit runtime
   // context instead of fabricating assistant reasoning.
   const deepSeekCompaction = normalizeProviderId(config.provider, "") === "deepseek";
+  const exactOutputPaths = exactOutputPathsForState(state);
+  const exactInputPaths = exactInputPathsForState(state);
   const retainedToolMessages = deepSeekCompaction
-    ? retainedToolStateTextMessages(messages)
-    : retainedToolStateMessages(messages);
+    ? retainedToolStateTextMessages(messages, 12, exactOutputPaths, exactInputPaths)
+    : retainedToolStateMessages(messages, 12, exactOutputPaths, exactInputPaths);
   const snapshotSummary = {
     step,
     maxSteps: config.maxSteps,
@@ -1407,7 +1432,7 @@ function buildCompactedRuntimeMessages(state, config, snapshot, step, options =
   }));
   const boundedContent = compactTextForTokenBudget(
     compactedContent,
-    Math.max(1024, Math.floor(targetTokens * 0.52)),
+    Math.max(1024, Math.floor(targetTokens * (retainedToolMessages.length ? 0.28 : 0.52))),
     { headFraction: 0.58 }
   );
   const baseMessages = [
@@ -1423,7 +1448,12 @@ function buildCompactedRuntimeMessages(state, config, snapshot, step, options =
     retainedPairs.push({
       pair,
       order: retainedPairs.length,
-      priority: retainedToolPairPriority(pair, retainedPairs.length),
+      priority: retainedToolPairPriority(
+        pair,
+        retainedPairs.length,
+        exactOutputPaths,
+        exactInputPaths
+      ),
     });
   }
   const selectedPairs = [];
@@ -4338,7 +4368,12 @@ export function recordProjectVerificationOutcome(state = {}, toolResult = {}, co
     // authorize a new invocation of the same command. A recognized trailing
     // status probe reports evidence but does not change the inner command's
     // mutation capability.
-    const commandPolicy = classifyCommand(mutationCommand);
+    const commandPolicy = {
+      ...classifyCommand(mutationCommand),
+      ...(toolResult.commandPolicy && typeof toolResult.commandPolicy === "object"
+        ? toolResult.commandPolicy
+        : {}),
+    };
     const requiredCommands = effectiveRequiredProjectCommands(state, verification, config);
     const requiredCommand = requiredCommands.find(
       (candidate) => projectCommandsEquivalent(candidate, exitProbe.command || command, config)
@@ -5317,16 +5352,31 @@ function expectedRepeatedObservationCommand(command = "") {
   );
 }
 
+function runCommandResultHasDurableProgress(toolResult = {}) {
+  const policy = toolResult.commandPolicy || {};
+  const policyAllowsMutation =
+    policy.mayMutateProject === true ||
+    (policy.mayMutateProject === undefined && policy.writesWorkspace === true);
+  return Boolean(
+    policyAllowsMutation ||
+      policy.substantiveTest === true ||
+      (Array.isArray(toolResult.verifiedGeneratedOutputPaths) &&
+        toolResult.verifiedGeneratedOutputPaths.length > 0)
+  );
+}
+
 function isStaticDiscoveryToolResult(toolResult = {}) {
   if (isStaticDiscoveryToolCall(toolResult.toolName, toolResult.args || {})) return true;
   if (toolResult.toolName !== "run_command") return false;
-  if (toolResult.commandPolicy?.writesWorkspace !== false) return false;
+  if (runCommandResultHasDurableProgress(toolResult)) return false;
   return !expectedRepeatedObservationCommand(toolResult.args?.command);
 }
 
 function successfulToolStateProgress(toolResult = {}) {
   if (!toolResult || toolResult.done || toolResult.ok === false || toolResult.blocked || toolResult.skipped) return false;
-  if (toolResult.toolName === "run_command") return toolResult.commandPolicy?.writesWorkspace === true;
+  if (toolResult.toolName === "run_command") {
+    return runCommandResultHasDurableProgress(toolResult);
+  }
   if (["write_file", "apply_patch"].includes(String(toolResult.toolName || ""))) {
     return successfulProjectMutationPaths(toolResult).length > 0;
   }
@@ -5347,7 +5397,7 @@ function noProgressOutcomeFingerprint(toolResult = {}) {
     toolResult?.toolName !== "run_command" ||
     toolResult?.ok === false ||
     toolResult?.blocked ||
-    toolResult?.commandPolicy?.writesWorkspace === true ||
+    successfulToolStateProgress(toolResult) ||
     expectedRepeatedObservationCommand(toolResult?.args?.command)
   ) {
     return "";
@@ -6161,6 +6211,16 @@ function commandWritesOnlyPrivateVerificationEvidence(command = "") {
 }
 
 function commandCanMutateProjectContent(command = "", commandPolicy = {}) {
+  // The classifier may conservatively mark an interpreter or compound shell
+  // command as workspace-writing while still proving that this exact command
+  // cannot mutate project content. Preserve that stronger semantic result so
+  // validators and inspection probes do not fabricate mutation progress. Git
+  // sequences remain structurally inspected because an aggregate Git policy
+  // can be conservative even when one segment changes the worktree.
+  const category = String(commandPolicy.category || "");
+  const requiresGitMutationInspection =
+    ["git-workflow", "git-remote"].includes(category);
+  if (commandPolicy.mayMutateProject === false && !requiresGitMutationInspection) return false;
   if (commandPolicy.writesWorkspace !== true && commandPolicy.mayMutateProject !== true) return false;
   const sequence = parseTopLevelShellSequence(String(command || ""));
   if (
@@ -6174,7 +6234,6 @@ function commandCanMutateProjectContent(command = "", commandPolicy = {}) {
     );
   }
   if (commandWritesOnlyPrivateVerificationEvidence(command)) return false;
-  const category = String(commandPolicy.category || "");
   if (!["git-workflow", "git-remote"].includes(category)) return true;
   if (/\bgit\s+clone\b/i.test(String(command || ""))) return true;
   // An aggregate Git category can still contain a non-Git build/generator
@@ -6682,6 +6741,18 @@ function exactOutputPathsForState(state = {}) {
   ])].slice(0, 32);
 }
 
+function exactInputPathsForState(state = {}) {
+  const scsInputPaths = Array.isArray(state.meta?.scs?.taskContract?.exactInputPaths)
+    ? state.meta.scs.taskContract.exactInputPaths.filter(Boolean)
+    : [];
+  const outputPaths = new Set(
+    exactOutputPathsForState(state).map((item) => String(item).replace(/\\/g, "/").replace(/^\.\//, ""))
+  );
+  return [...new Set(scsInputPaths)]
+    .filter((item) => !outputPaths.has(String(item).replace(/\\/g, "/").replace(/^\.\//, "")))
+    .slice(0, 32);
+}
+
 async function hashExactOutputFile(absolutePath) {
   return await new Promise((resolve, reject) => {
     const digest = crypto.createHash("sha256");
@@ -7296,7 +7367,11 @@ export function recordStaticDiscoveryProgress(toolLoop = {}, signature = "") {
   };
 }
 
-export function resetStaticDiscoveryAfterContextLoss(state = {}, reason = "context-compaction") {
+export function resetStaticDiscoveryAfterContextLoss(
+  state = {},
+  reason = "context-compaction",
+  options = {}
+) {
   state.meta = state.meta || {};
   const toolLoop = state.meta.toolLoop && typeof state.meta.toolLoop === "object"
     ? state.meta.toolLoop
@@ -7305,6 +7380,16 @@ export function resetStaticDiscoveryAfterContextLoss(state = {}, reason = "conte
   const priorCounts = toolLoop.staticCounts && typeof toolLoop.staticCounts === "object"
     ? toolLoop.staticCounts
     : {};
+  if (options.preserveStaticEvidence === true) {
+    toolLoop.lastContextRecovery = {
+      reason: String(reason || "context-compaction"),
+      at: new Date().toISOString(),
+      priorStaticTotal: Number(priorOrder.length),
+      preservedStaticEvidence: true,
+    };
+    state.meta.toolLoop = toolLoop;
+    return toolLoop.lastContextRecovery;
+  }
   if (priorOrder.length || Object.keys(priorCounts).length) {
     const history = Array.isArray(toolLoop.staticHistory) ? toolLoop.staticHistory : [];
     history.push({
@@ -11025,7 +11110,9 @@ export async function runAgent(config) {
         const tokensAfter = estimateMessageTokens(compactMessages);
         if (charsAfter < contextDecision.charsBefore) {
           state.messages = compactMessages;
-          resetStaticDiscoveryAfterContextLoss(state, "proactive-context-compaction");
+          resetStaticDiscoveryAfterContextLoss(state, "proactive-context-compaction", {
+            preserveStaticEvidence: true,
+          });
           state.meta.contextBudget = recordContextCompaction(contextBudget, {
             step,
             charsBefore: contextDecision.charsBefore,
@@ -11141,7 +11228,9 @@ export async function runAgent(config) {
           };
           state.messages = compactMessages;
           requestMessages = compactMessages;
-          resetStaticDiscoveryAfterContextLoss(state, "local-context-budget-retry");
+          resetStaticDiscoveryAfterContextLoss(state, "local-context-budget-retry", {
+            preserveStaticEvidence: true,
+          });
           state.meta.localContextBudgetRetries = {
             ...contextRetriedSteps,
             [retryKey]: true,
@@ -11189,7 +11278,9 @@ export async function runAgent(config) {
           };
           state.messages = compactMessages;
           requestMessages = compactMessages;
-          resetStaticDiscoveryAfterContextLoss(state, "model-timeout-retry");
+          resetStaticDiscoveryAfterContextLoss(state, "model-timeout-retry", {
+            preserveStaticEvidence: true,
+          });
           state.meta.modelTimeoutRetries = {
             ...retriedSteps,
             [retryKey]: true,

package/src/cli.js

@@ -383,6 +383,10 @@ export function machineRunPayload(run, fallbackSessionId = "", metadata = {}) {
   };
 }
 
+export function runResultExitCode(run = {}) {
+  return run?.stopped === true || run?.failed === true ? 1 : 0;
+}
+
 function printMachineRunResult(run, fallbackSessionId = "", metadata = {}) {
   const payload = machineRunPayload(run, fallbackSessionId, metadata);
   console.log(JSON.stringify(payload));
@@ -2507,6 +2511,7 @@ export async function main(argv = process.argv.slice(2)) {
         ...(jsonFlag ? { onConsole: () => {} } : {}),
       });
       const run = await runAgent(config);
+      if (runResultExitCode(run) !== 0) process.exitCode = 1;
       if (jsonFlag) {
         printMachineRunResult(run, runArgs.sessionId, {
           provider: config.provider,
@@ -2604,6 +2609,7 @@ export async function main(argv = process.argv.slice(2)) {
       config.expectedRuntimeRevision = preparedRuntime.expectedRuntimeRevision;
       if (preparedRuntime.runtimePatch) config.runtimePatch = preparedRuntime.runtimePatch;
       const run = await runAgent(config);
+      if (runResultExitCode(run) !== 0) process.exitCode = 1;
       if (jsonFlag) {
         printMachineRunResult(run, sessionId, {
           provider: config.provider,
@@ -2765,5 +2771,6 @@ export async function main(argv = process.argv.slice(2)) {
     config.expectedRuntimeRevision = preparedRuntime.expectedRuntimeRevision;
     if (preparedRuntime.runtimePatch) config.runtimePatch = preparedRuntime.runtimePatch;
   }
-  await runAgent(config);
+  const run = await runAgent(config);
+  if (runResultExitCode(run) !== 0) process.exitCode = 1;
 }

package/src/research-routing.js

@@ -95,12 +95,30 @@ export function hasLocalResearchWorkspaceIntent(goal = "", messages = []) {
   );
 }
 
+export function hasExplicitDeepResearchSuppression(goal = "", messages = []) {
+  const current = currentIntentMessages(messages);
+  const latestUserIntent = [...current]
+    .reverse()
+    .find((message) => message?.role === "user" && !isRuntimeUserMessage(messageText(message.content)));
+  const text = `${scopedChatopsEvidenceGoal(goal)}\n${scopedChatopsEvidenceGoal(
+    messageText(latestUserIntent?.content)
+  )}`;
+  return (
+    /\b(?:do not|don't|must not|never)\s+(?:run|rerun|re-run|repeat|restart|invoke|call|start)\s+(?:the\s+)?(?:deep[_ -]?research|research workflow)\b/i.test(text) ||
+    /\b(?:do not|don't|must not|never)\b[^.!?\n]{0,140}\b(?:run|rerun|re-run|repeat|restart|invoke|call|start)\s+(?:the\s+)?(?:deep[_ -]?research|research workflow)\b/i.test(text) ||
+    /\b(?:reuse|use|continue from|recover from)\b.{0,140}\b(?:completed|existing|retained|saved)\b.{0,180}\b(?:deep[_ -]?research|research (?:result|artifact|evidence|pass))\b/i.test(text) ||
+    /(?:不要|无需|不必|禁止).{0,20}(?:重新|再次|重复)?(?:运行|调用|启动)?(?:深度研究|深入研究|deep[_ -]?research)/iu.test(text) ||
+    /(?:ディープリサーチ|深い調査).{0,20}(?:再実行しない|繰り返さない|呼び出さない)/u.test(text)
+  );
+}
+
 export function toolWasRequested(messages = [], toolName = "") {
   return requestedToolCount(messages, toolName) > 0;
 }
 
 export function shouldStartWithDeepResearch(goal = "", messages = []) {
   if (!hasExplicitDeepResearchIntent(goal, messages)) return false;
+  if (hasExplicitDeepResearchSuppression(goal, messages)) return false;
   const current = currentIntentMessages(messages);
   if (toolWasRequested(current, "deep_research")) return false;
   if (hasLocalResearchWorkspaceIntent(goal, messages) && !localWorkspaceInspectionReady(current)) return false;

package/src/scs-evidence.js

@@ -373,9 +373,9 @@ function inferExactOutputPaths(goal = "") {
     "gi"
   );
   const directOutputAction =
-    /\b(save|saved|write|written|output|create|store|update|modify|edit)\b|保存|写入|寫入|输出|輸出|创建|建立|更新|修改|编辑|編輯/i;
+    /\b(?:sav(?:e|es|ing)|writ(?:e|es|ing)|rewrit(?:e|es|ing)|output(?:s|ting)?|creat(?:e|es|ing)|rebuild(?:s|ing)?|replac(?:e|es|ing)|regenerat(?:e|es|ing)|generat(?:e|es|ing)|stor(?:e|es|ing)|updat(?:e|es|ing)|modif(?:y|ies|ying)|edit(?:s|ing)?)\b|保存|写入|寫入|重写|重寫|输出|輸出|创建|建立|重建|替换|替換|重新生成|生成|更新|修改|编辑|編輯/i;
   const directOutputActionGlobal =
-    /\b(save|saved|write|written|output|create|store|update|modify|edit)\b|保存|写入|寫入|输出|輸出|创建|建立|更新|修改|编辑|編輯/gi;
+    /\b(?:sav(?:e|es|ing)|writ(?:e|es|ing)|rewrit(?:e|es|ing)|output(?:s|ting)?|creat(?:e|es|ing)|rebuild(?:s|ing)?|replac(?:e|es|ing)|regenerat(?:e|es|ing)|generat(?:e|es|ing)|stor(?:e|es|ing)|updat(?:e|es|ing)|modif(?:y|ies|ying)|edit(?:s|ing)?)\b|保存|写入|寫入|重写|重寫|输出|輸出|创建|建立|重建|替换|替換|重新生成|生成|更新|修改|编辑|編輯/gi;
   const outputListHeader =
     /^(?:#+\s*)?(?:(?:required|final|expected|declared|target|pilot|deliverable)\s+)*(?:create|created files?|files? to create|outputs?|output structure|required outputs?|artifacts?|deliverables?|generated files?|writer requirements|renderer requirements|生成文件|输出结构|輸出結構|输出文件|輸出文件|创建文件|建立文件)(?:\s+(?:outputs?|artifacts?|deliverables?))?\s*[：:]?\s*$/i;
   const nonOutputToolLine =
@@ -410,8 +410,15 @@ function inferExactOutputPaths(goal = "") {
     }
     return matches[0]?.index ?? -1;
   };
-  for (const rawLine of lines) {
-    const line = String(rawLine || "").trim();
+  for (let lineIndex = 0; lineIndex < lines.length; lineIndex += 1) {
+    const rawLine = lines[lineIndex];
+    const currentLine = String(rawLine || "").trim();
+    const previousLine = String(lines[lineIndex - 1] || "").trim();
+    const wrappedOutputInstruction =
+      previousLine &&
+      !/[.!?。！？;；]$/.test(previousLine) &&
+      directOutputAction.test(previousLine);
+    const line = wrappedOutputInstruction ? `${previousLine} ${currentLine}`.trim() : currentLine;
     if (!line) {
       if (inOutputList) inOutputList = false;
       continue;
@@ -468,16 +475,23 @@ function inferExactInputPaths(goal = "") {
     "gi"
   );
   const inputAction =
-    /\b(use|using|read|load|fill|upload|attach|import|select|choose|reference|input|from|fix|repair|patch|correct)\b|使用|读取|讀取|加载|載入|填写|填入|上传|上傳|附加|导入|導入|选择|選擇|选取|選取|参考|參考|素材|图片|圖片|照片|提示词|提示詞|修复|修正|更正|从|從/i;
+    /\b(?:use|using|read|load|fill|upload|attach|import|select|choose|reference|input|from|retain(?:ed|ing)?|fix|repair|patch|correct)\b|使用|读取|讀取|加载|載入|填写|填入|上传|上傳|附加|导入|導入|选择|選擇|选取|選取|参考|參考|素材|图片|圖片|照片|提示词|提示詞|保留|修复|修正|更正|从|從/i;
   const directOutputAction =
-    /\b(save|saved|write|written|output|create|store|update|modify|edit)\b|保存|写入|寫入|输出|輸出|创建|建立|更新|修改|编辑|編輯/i;
+    /\b(?:sav(?:e|es|ing)|writ(?:e|es|ing)|rewrit(?:e|es|ing)|output(?:s|ting)?|creat(?:e|es|ing)|rebuild(?:s|ing)?|replac(?:e|es|ing)|regenerat(?:e|es|ing)|generat(?:e|es|ing)|stor(?:e|es|ing)|updat(?:e|es|ing)|modif(?:y|ies|ying)|edit(?:s|ing)?)\b|保存|写入|寫入|重写|重寫|输出|輸出|创建|建立|重建|替换|替換|重新生成|生成|更新|修改|编辑|編輯/i;
   const pushPath = (raw = "") => {
     const cleaned = String(raw || "").trim();
     if (!cleaned || /[{}]/.test(cleaned)) return;
     paths.push(cleaned);
   };
-  for (const rawLine of lines) {
-    const fullLine = String(rawLine || "").trim();
+  for (let lineIndex = 0; lineIndex < lines.length; lineIndex += 1) {
+    const rawLine = lines[lineIndex];
+    const currentLine = String(rawLine || "").trim();
+    const previousLine = String(lines[lineIndex - 1] || "").trim();
+    const wrappedInputInstruction =
+      previousLine &&
+      !/[.!?。！？;；]$/.test(previousLine) &&
+      inputAction.test(previousLine);
+    const fullLine = wrappedInputInstruction ? `${previousLine} ${currentLine}`.trim() : currentLine;
     const outputIndex = fullLine.search(directOutputAction);
     const line = outputIndex > 0 ? fullLine.slice(0, outputIndex).trim() : fullLine;
     if (!line || !inputAction.test(line)) continue;

package/src/step-budget-controller.js

@@ -208,7 +208,25 @@ export function staticToolCallSignature(toolName, args = {}, context = {}) {
 
 function isStaticDiscoveryResult(result = {}) {
   if (!result || result.ok === false || result.blocked || result.done) return false;
-  return isStaticDiscoveryToolCall(result.toolName, result.args || {});
+  if (isStaticDiscoveryToolCall(result.toolName, result.args || {})) return true;
+  if (result.toolName !== "run_command") return false;
+  if (/\b(?:watch|poll|status|queue|sleep)\b|tail\s+-f|tmux\s+capture-pane/i.test(String(result.args?.command || ""))) {
+    return false;
+  }
+  return !runCommandHasConcreteProgress(result);
+}
+
+function runCommandHasConcreteProgress(result = {}) {
+  const policy = result.commandPolicy || {};
+  const policyAllowsMutation =
+    policy.mayMutateProject === true ||
+    (policy.mayMutateProject === undefined && policy.writesWorkspace === true);
+  return Boolean(
+    policyAllowsMutation ||
+      policy.substantiveTest === true ||
+      (Array.isArray(result.verifiedGeneratedOutputPaths) &&
+        result.verifiedGeneratedOutputPaths.length > 0)
+  );
 }
 
 export function summarizeRepeatedStaticDiscovery(recentToolResults = [], context = {}) {
@@ -251,7 +269,7 @@ function hasConcreteProgress(recentToolResults = [], events = []) {
     if (result.ok === false || result.blocked || result.done) return false;
     if (isStaticDiscoveryToolCall(result.toolName, result.args || {})) return false;
     if (!PROGRESS_TOOL_NAMES.has(result.toolName)) return false;
-    if (result.toolName === "run_command") return Boolean(result.stdout || result.stderr || result.exitCode === 0);
+    if (result.toolName === "run_command") return runCommandHasConcreteProgress(result);
     return Boolean(
       result.path ||
         result.artifactPath ||