@lazyingart/agintiflow 0.20.247 → 0.20.249

package/docs/supervision-campaign-ledger.md

@@ -330,3 +330,52 @@ event sequence, a project handoff with exact status and verification commands,
 and no lingering job tmux session. No source patch or npm release was needed;
 this run validates the published package's general long-job, resume, context,
 deduplication, and cleanup contracts without task-specific routing.
+
+### Host-managed response roles and permission integrity
+
+`permission-resilient-synthesis-030` traced a real LabCanvas career-report
+failure to the integration boundary rather than weakening AgInTiFlow's
+permission guard. LabCanvas invoked the host-managed report under the role
+`career_research`, while its response-only classifier recognized only the older
+`career_daily` alias. The model was consequently offered file tools in a safe,
+read-only run; when it tried to save its already synthesized report,
+AgInTiFlow correctly persisted a `permission_required` pause.
+
+LabCanvas now classifies the full `career-research-*` and
+`daily-organizer-*` role families as host-managed response turns. Those turns
+use AgInTi's `chatops` profile with shell, file, and auxiliary tools disabled;
+the host owns persistence, compilation, quality validation, and delivery.
+General worker roles retain their existing writable Docker contract, and safe
+mode still blocks genuine unapproved writes.
+
+A fresh installed `0.20.248` DeepSeek run completed the imperfect synthesis
+prompt in one model turn. Independent event inspection found zero tool calls,
+zero permission events, one normal `session.finished`, a complete 1,893-byte
+answer, and no task artifact mutation. This was an AgenticApp integration fix;
+no AgInTiFlow runtime or npm release change was required.
+
+### Reader-facing report quality and local editorial routing
+
+`research-pdf-quality-034` exercised a normal scheduled-research packet through
+the AgInTi-backed LabCanvas worker. DeepSeek revised an existing local report
+into a 17,557-byte Chinese scientific review with nine traceable sources,
+source-level methods/results/limitations, cross-source synthesis and tensions,
+explicit evidence boundaries, actionable experiments, and references. The
+first host compile exposed a nearly empty final page, and the prior agent repair
+claimed success without changing the source.
+
+LabCanvas now treats the PDF as a different deliverable from the concise chat
+brief. It audits every configured content dimension, keeps orchestration
+provenance out of the reader document, extracts text per page, renders private
+page previews, rejects orphan pages, retries one conservative compact layout,
+rebuilds stale sibling PDFs, and can deterministically adopt a corrected
+host-built PDF during stored-result repair. The accepted four-page PDF has
+embedded CJK fonts, page body counts `1584, 1988, 1416, 2058`, and no visual or
+layout issues. Stored replay covered every task item with no model rerun or
+external write.
+
+The scenario also exposed two general AgInTi routing false positives. Explicit
+local report paths and existing-document revision language now count as local
+workspace intent, so surrounding research policy does not force a new deep
+research route. The phrase `page-safe` no longer creates a browser-evidence
+requirement. Focused routing/evidence smokes and the full npm suite pass.

package/package.json

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

@@ -415,11 +415,126 @@ function boundedOutputReadPair(index, generation) {
   ];
 }
 
+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"],
       },
     },
@@ -427,6 +542,7 @@ const twiceCompactedState = {
   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(),
   ],
 };

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:
@@ -1610,6 +1647,22 @@ assert(
   "surrounding policy prose incorrectly forced a scoped artifact task into deep research"
 );
 
+const scopedExistingReportEditPrompt = `Generic research worker policy.
+AGINTI_EVIDENCE_SCOPE_JSON: {"mode":"task","request":"Revise the exact existing research report at output/wechat_worker/task/report.md. Preserve the evidence, write the revised Markdown under this task's artifact directory, and use page-safe tables. The host owns PDF compilation."}
+Surrounding routine text mentions literature review, evidence review, research report, and web sources.`;
+const scopedExistingReportEditTools = selectProgressiveTools(allTools, {
+  config: { provider: "deepseek", progressiveTools: true },
+  goal: scopedExistingReportEditPrompt,
+  profile: "auto",
+  messages: [{ role: "user", content: scopedExistingReportEditPrompt }],
+});
+assert(names(scopedExistingReportEditTools).includes("read_file"), "scoped existing-report edit omitted read_file");
+assert(names(scopedExistingReportEditTools).includes("write_file"), "scoped existing-report edit omitted write_file");
+assert(
+  !(names(scopedExistingReportEditTools).length === 2 && names(scopedExistingReportEditTools)[0] === "deep_research"),
+  "scoped existing-report edit was incorrectly forced into deep_research"
+);
+
 const scopedDeepResearchPrompt = `Generic workspace policy.
 AGINTI_EVIDENCE_SCOPE_JSON: {"mode":"task","request":"Write a deep research evidence review comparing three primary papers."}`;
 const scopedDeepResearchTools = selectProgressiveTools(allTools, {

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

@@ -36,6 +36,26 @@ function fakeStudentClient(json) {
   };
 }
 
+const pageSafeReportContract = deriveScsTaskContract({
+  goal: [
+    "AGINTI_EVIDENCE_SCOPE_JSON: {\"mode\":\"task\",\"request\":\"Revise the exact existing research report at output/wechat_worker/task/report.md, write a complete Markdown report, and use page-safe tables. The host owns PDF compilation.\"}",
+    "Surrounding browser and research policy text is not part of the exact request.",
+  ].join("\n"),
+  taskProfile: "auto",
+});
+assert(
+  pageSafeReportContract.requiredEvidence.some((item) => item.category === "file"),
+  "a scoped existing-report edit did not require file evidence"
+);
+assert(
+  pageSafeReportContract.requiredEvidence.some((item) => item.category === "artifact"),
+  "a scoped existing-report edit did not require artifact evidence"
+);
+assert(
+  !pageSafeReportContract.requiredEvidence.some((item) => item.category === "browser"),
+  "the editorial phrase page-safe incorrectly required browser evidence"
+);
+
 const noEvidenceProgress = {
   role: "student",
   decision: "reject_phase",
@@ -264,6 +284,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

@@ -1018,7 +1018,7 @@ function compactRetainedToolPayload(toolName, payload = {}, args = {}) {
   return redactValue(result);
 }
 
-function retainedPathMatchesOutput(sourcePath = "", outputPaths = []) {
+function retainedPathMatchesAny(sourcePath = "", candidatePaths = []) {
   const normalize = (value = "") =>
     String(value || "")
       .replace(/\\/g, "/")
@@ -1027,13 +1027,13 @@ function retainedPathMatchesOutput(sourcePath = "", outputPaths = []) {
       .replace(/\/$/, "");
   const source = normalize(sourcePath);
   if (!source) return false;
-  return outputPaths.some((candidate) => {
+  return candidatePaths.some((candidate) => {
     const output = normalize(candidate);
     return output && (source === output || source.endsWith(`/${output}`) || output.endsWith(`/${source}`));
   });
 }
 
-function retainedToolRecordPriority(record = {}, outputPaths = []) {
+function retainedToolRecordPriority(record = {}, outputPaths = [], inputPaths = []) {
   const name = String(record.name || "");
   const args = record.args || {};
   const payload = record.payload || {};
@@ -1048,12 +1048,13 @@ function retainedToolRecordPriority(record = {}, outputPaths = []) {
     const range = retainedReadRange(payload, args);
     priority = range.lineLimit > 0 ? 750 : 600;
     const sourcePath = String(payload.path || args.path || "").trim();
-    if (retainedPathMatchesOutput(sourcePath, outputPaths)) priority -= 220;
+    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, outputPaths = []) {
+function retainedToolStateMessages(messages = [], limit = 12, outputPaths = [], inputPaths = []) {
   const callsById = new Map();
   const recordsByKey = new Map();
   let ordinal = 0;
@@ -1103,7 +1104,8 @@ function retainedToolStateMessages(messages = [], limit = 12, outputPaths = [])
   const selected = [...records]
     .sort(
       (left, right) =>
-        retainedToolRecordPriority(right, outputPaths) - retainedToolRecordPriority(left, outputPaths) ||
+        retainedToolRecordPriority(right, outputPaths, inputPaths) -
+          retainedToolRecordPriority(left, outputPaths, inputPaths) ||
         right.ordinal - left.ordinal
     )
     .slice(0, Math.max(1, Number(limit) || 12))
@@ -1135,8 +1137,8 @@ function retainedToolStateMessages(messages = [], limit = 12, outputPaths = [])
   });
 }
 
-function retainedToolStateTextMessages(messages = [], limit = 12, outputPaths = []) {
-  const nativeMessages = retainedToolStateMessages(messages, limit, outputPaths);
+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];
@@ -1156,13 +1158,17 @@ function retainedToolStateTextMessages(messages = [], limit = 12, outputPaths =
   return retained;
 }
 
-function retainedToolPairPriority(pair = [], order = 0, outputPaths = []) {
+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 }, outputPaths);
+  return retainedToolRecordPriority(
+    { name, args, payload, ordinal: order },
+    outputPaths,
+    inputPaths
+  );
 }
 
 function isRuntimeCompactionRequest(content = "") {
@@ -1345,9 +1351,10 @@ function buildCompactedRuntimeMessages(state, config, snapshot, step, options =
   // 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, 12, exactOutputPaths)
-    : retainedToolStateMessages(messages, 12, exactOutputPaths);
+    ? retainedToolStateTextMessages(messages, 12, exactOutputPaths, exactInputPaths)
+    : retainedToolStateMessages(messages, 12, exactOutputPaths, exactInputPaths);
   const snapshotSummary = {
     step,
     maxSteps: config.maxSteps,
@@ -1425,7 +1432,7 @@ function buildCompactedRuntimeMessages(state, config, snapshot, step, options =
   }));
   const boundedContent = compactTextForTokenBudget(
     compactedContent,
-    Math.max(1024, Math.floor(targetTokens * (retainedToolMessages.length ? 0.4 : 0.52))),
+    Math.max(1024, Math.floor(targetTokens * (retainedToolMessages.length ? 0.28 : 0.52))),
     { headFraction: 0.58 }
   );
   const baseMessages = [
@@ -1441,7 +1448,12 @@ function buildCompactedRuntimeMessages(state, config, snapshot, step, options =
     retainedPairs.push({
       pair,
       order: retainedPairs.length,
-      priority: retainedToolPairPriority(pair, retainedPairs.length, exactOutputPaths),
+      priority: retainedToolPairPriority(
+        pair,
+        retainedPairs.length,
+        exactOutputPaths,
+        exactInputPaths
+      ),
     });
   }
   const selectedPairs = [];
@@ -4356,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)
@@ -5335,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;
   }
@@ -5365,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 "";
@@ -6179,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 (
@@ -6192,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
@@ -6700,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");
@@ -7314,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
@@ -7323,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({
@@ -11043,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,
@@ -11159,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,
@@ -11207,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

@@ -89,18 +89,38 @@ export function hasLocalResearchWorkspaceIntent(goal = "", messages = []) {
   const text = `${scopedChatopsEvidenceGoal(goal)}\n${recent}`;
   return (
     /\b(?:this|current|existing|project|workspace|local)\s+(?:folder|directory|repo(?:sitory)?|files?|notes?|sources?|artifacts?)\b/i.test(text) ||
+    /(?:^|[\s`'"(])(?:~\/|\.{1,2}\/|\/)?(?:[^\s`'"()\/]+\/)+[^\s`'"()\/]+\.(?:bib|csv|docx?|json|md|pdf|tex|txt|ya?ml)\b/i.test(text) ||
+    /\b(?:edit|revise|rewrite|proofread|correct|polish|read|inspect|update)\b[^.\n;]{0,160}\b(?:exact|existing|current|saved|local)\b[^.\n;]{0,80}\b(?:document|file|manuscript|markdown|notes?|report|source)\b/i.test(text) ||
     /\b(?:task|project|source|research|evidence|notes?|manifest|readme)[-_A-Za-z0-9]*\.(?:md|json|ya?ml|txt|csv|bib|tex)\b/i.test(text) ||
     /\b(?:inspect|read|reconcile|correct|rewrite|update)\b.{0,120}\b(?:workspace|folder|directory|repo(?:sitory)?|local files?|project notes?|existing notes?)\b/i.test(text) ||
     /\b(?:git\s+)?commit\b/i.test(text)
   );
 }
 
+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|write|rewrite|output|create|rebuild|replace|regenerate|generate|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|write|rewrite|output|create|rebuild|replace|regenerate|generate|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|write|rewrite|output|create|rebuild|replace|regenerate|generate|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;
@@ -779,7 +793,17 @@ function inferRequirementCategories(goal = "", taskProfile = "", acceptanceCrite
   if (textHas(mandatoryEvidenceText, /\b(artifact|canvas|pdf|image|video|screenshot|cover|plot|chart|figure|docx|archive|copy to|export|generated|generate|draft)\b/) || /输出|产物|图片|视频|截图|封面|生成/.test(mandatoryEvidenceText)) {
     categories.add("artifact");
   }
-  if (textHas(mandatoryEvidenceText, /\b(browser|chrome|chromium|cdp|devtools|playwright|selenium|web[- ]?ui|website|page|tab|composer|click|type|upload|attach|submit|form)\b/) || /浏览器|网页|页面|上传|提交|附件|资产库/.test(mandatoryEvidenceText)) {
+  if (
+    textHas(
+      mandatoryEvidenceText,
+      /\b(browser|chrome|chromium|cdp|devtools|playwright|selenium|web[- ]?(?:ui|page)|website|tab|composer|click|type|upload|attach|submit|form)\b/
+    ) ||
+    textHas(
+      mandatoryEvidenceText,
+      /\b(?:browse|navigate|open|refresh|visit)\b[^.\n;]{0,60}\b(?:page|site)\b|\b(?:page|site)\b[^.\n;]{0,60}\b(?:click|open|submit|upload)\b/
+    ) ||
+    /浏览器|网页|页面|上传|提交|附件|资产库/.test(mandatoryEvidenceText)
+  ) {
     categories.add("browser");
   }
   if (textHas(mandatoryEvidenceText, /\b(screenshot|visible|visual|see|inspect image|open image|read_image|thumbnail)\b/) || /截图|可见|缩略图/.test(mandatoryEvidenceText)) {

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 ||