@lazyingart/agintiflow 0.20.324 → 0.20.326

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lazyingart/agintiflow",
-  "version": "0.20.324",
+  "version": "0.20.326",
   "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-document-artifact-quality.js

@@ -359,6 +359,17 @@ assert(
 
 const exactSourceRoot = await fs.mkdtemp(path.join(os.tmpdir(), "aginti-document-source-"));
 try {
+  await fs.writeFile(
+    path.join(exactSourceRoot, "AGENTS.md"),
+    "WeChat PYTHONPATH LazyEdit STEP WeCom CAD PCB OpenHI\n",
+    "utf8"
+  );
+  await fs.mkdir(path.join(exactSourceRoot, "references"));
+  await fs.writeFile(
+    path.join(exactSourceRoot, "references", "unrelated.md"),
+    "Repository-wide material that does not belong to this exact report.\n",
+    "utf8"
+  );
   await fs.writeFile(
     path.join(exactSourceRoot, "chat_history.md"),
     "Later correction: keep the publication blocked until login is restored.\n",
@@ -371,7 +382,13 @@ try {
   assert.deepEqual(
     exactSources.map((item) => item.path),
     ["chat_history.md"],
-    "an exact root-level source path was omitted from document validation"
+    "repository-wide context contaminated an exact document source contract"
+  );
+  const discoveredSources = await collectDocumentSourceDocuments(exactSourceRoot);
+  assert.deepEqual(
+    discoveredSources.map((item) => item.path).sort(),
+    ["AGENTS.md", "references/unrelated.md"],
+    "repository source discovery stopped working when no exact input was declared"
   );
 } finally {
   await fs.rm(exactSourceRoot, { recursive: true, force: true });

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

@@ -80,6 +80,7 @@ import {
   recordAlreadyCommittedRepositoryRepair,
   recordDurableEvidenceCategories,
   recordProjectVerificationOutcome,
+  recordFailedCommandAttempt,
   repositoryStateInspectionCommand,
   recordExactOutputProgress,
   recordStaticDiscoveryProgress,
@@ -94,6 +95,7 @@ import {
   forbiddenCurrentTestRerunBlock,
   unchangedFailedTestRerunBlock,
   repeatedNoProgressToolBlock,
+  runCommandResultHasDurableProgress,
   redundantCadValidationAliasPatchBlock,
   regressiveInversePatchBlock,
   repeatedSuccessfulMutationBlock,
@@ -8544,6 +8546,29 @@ try {
   const semanticGateDocumentState = structuredClone(
     currentGoalGeneratedDocumentState
   );
+  semanticGateDocumentState.messages = [
+    {
+      role: "assistant",
+      tool_calls: [{
+        id: "read-unrelated-root-policy",
+        type: "function",
+        function: {
+          name: "read_file",
+          arguments: JSON.stringify({ path: "AGENTS.md" }),
+        },
+      }],
+    },
+    {
+      role: "tool",
+      tool_call_id: "read-unrelated-root-policy",
+      content: JSON.stringify({
+        ok: true,
+        path: "AGENTS.md",
+        content: "WeChat PYTHONPATH LazyEdit STEP WeCom CAD PCB OpenHI",
+        contentTruncated: false,
+      }),
+    },
+  ];
   semanticGateDocumentState.meta.scs = {
     taskContract: { exactInputPaths: ["TASK.md"] },
   };
@@ -8581,7 +8606,8 @@ try {
       semanticGateValidatorInput?.exactOutputPaths?.includes(
         "daily_memo.pdf"
       ) &&
-      semanticGateValidatorInput?.exactInputPaths?.includes("TASK.md"),
+      JSON.stringify(semanticGateValidatorInput?.exactInputPaths) ===
+        JSON.stringify(["TASK.md"]),
     `current-goal artifact discovery bypassed source/status quality gates or reopened the missing-artifact loop: ${JSON.stringify({
       assessment: semanticGateAssessment,
       input: semanticGateValidatorInput,
@@ -11159,6 +11185,73 @@ try {
     )?.category === "repeated-no-progress-call",
     "dynamic failure output allowed an unchanged failing command to loop"
   );
+  assertStrict.equal(
+    runCommandResultHasDurableProgress({
+      toolName: "run_command",
+      ok: true,
+      commandPolicy: classifyCommand(
+        'find /aginti-env -type f -name "pdflatex" | xargs ls -la | grep -v "not found"'
+      ),
+    }),
+    false,
+    "a bounded find/xargs/grep probe fabricated durable workspace progress"
+  );
+  assertStrict.equal(
+    runCommandResultHasDurableProgress({
+      toolName: "run_command",
+      ok: true,
+      commandPolicy: {
+        category: "general-shell",
+        writesWorkspace: true,
+      },
+      projectMutationPaths: ["src/example.js"],
+    }),
+    true,
+    "an observed shell mutation did not count as durable workspace progress"
+  );
+  const compactedFailureLoop = {
+    stagnationEpoch: 4,
+    recent: [],
+  };
+  for (let attempt = 0; attempt < 2; attempt += 1) {
+    recordFailedCommandAttempt(compactedFailureLoop, {
+      signature: repeatedProbeState.meta.toolLoop.recent[0].signature,
+      toolName: "run_command",
+      ok: false,
+      blocked: false,
+      noProgressProbe: true,
+      outcomeFingerprint: `failure-${attempt}`,
+      stagnationEpoch: 4,
+      goalRevision: 1,
+      mutationRevision: 0,
+    });
+  }
+  const compactedRepeatedFailureState = {
+    meta: {
+      toolLoop: compactedFailureLoop,
+    },
+  };
+  assert(
+    repeatedNoProgressToolBlock(
+      compactedRepeatedFailureState,
+      "run_command",
+      repeatedProbeArgs,
+      { commandCwd: workspace }
+    )?.category === "repeated-no-progress-call",
+    "bounded failed-command history was lost after recent tool history rolled off"
+  );
+  const compactedFailureAfterMutation = structuredClone(compactedRepeatedFailureState);
+  compactedFailureAfterMutation.meta.toolLoop.stagnationEpoch = 5;
+  assertStrict.equal(
+    repeatedNoProgressToolBlock(
+      compactedFailureAfterMutation,
+      "run_command",
+      repeatedProbeArgs,
+      { commandCwd: workspace }
+    ),
+    null,
+    "a verified later state change did not release retained failed-command history"
+  );
   const newlyAuthoritativeVerificationState = structuredClone(repeatedFailureState);
   newlyAuthoritativeVerificationState.meta.projectVerification = {
     mutationRevision: 6,

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

@@ -240,6 +240,28 @@ const pageSafeReportContract = deriveScsTaskContract({
   taskProfile: "auto",
 });
 
+const hostCompiledReportContract = deriveScsTaskContract({
+  goal: [
+    "Create report.md and report.tex for the requested evidence-grounded report.",
+    "Do not invoke LaTeX, latexmk, pdflatex, make, package managers, or document compiler commands; the LabCanvas host compiler owns PDF compilation and validation.",
+    "The host will create output/report.pdf after the agent turn.",
+  ].join(" "),
+  taskProfile: "research",
+});
+
+const agentCompiledReportContract = deriveScsTaskContract({
+  goal: "Create report.tex, compile output/report.pdf, inspect it, and return the PDF.",
+  taskProfile: "research",
+});
+
+const fallbackHostCompilationContract = deriveScsTaskContract({
+  goal: [
+    "Create report.tex and compile output/report.pdf.",
+    "If compilation is unavailable in the sandbox, the LabCanvas host recovery stage owns PDF compilation.",
+  ].join(" "),
+  taskProfile: "research",
+});
+
 const forbiddenOutputContract = deriveScsTaskContract({
   goal: "Continue the task. verification_suite.py does not exist and must not be rerun or created. Preserve smoke_test.py and finish from current evidence.",
   taskProfile: "devops",
@@ -543,6 +565,29 @@ assert(
   !pageSafeReportContract.requiredEvidence.some((item) => item.category === "browser"),
   "the editorial phrase page-safe incorrectly required browser evidence"
 );
+assert.equal(
+  hostCompiledReportContract.hostManagedDocumentCompilation,
+  true,
+  "an explicit host-only compilation contract was not retained"
+);
+assert(
+  hostCompiledReportContract.requiredArtifactKinds.some((item) => item.id === "format:.tex") &&
+    !hostCompiledReportContract.requiredArtifactKinds.some((item) => item.id === "format:.pdf"),
+  "host-managed PDF compilation did not preserve editable source while deferring PDF production"
+);
+assert(
+  !hostCompiledReportContract.exactOutputPaths.some((item) => item.endsWith(".pdf")),
+  "a host-managed PDF path remained an agent-owned exact output"
+);
+assert(
+  agentCompiledReportContract.requiredArtifactKinds.some((item) => item.id === "format:.pdf") &&
+    agentCompiledReportContract.exactOutputPaths.some((item) => item.endsWith("output/report.pdf")),
+  "ordinary agent-owned PDF compilation was weakened by the host-managed exception"
+);
+assert(
+  fallbackHostCompilationContract.hostManagedDocumentCompilation === false,
+  "a conditional host recovery fallback was mistaken for an explicit host-only compilation contract"
+);
 
 const noEvidenceProgress = {
   role: "student",

package/src/agent-runner.js

@@ -147,6 +147,7 @@ import {
   finishResultClaimsBlocker,
   finishResultClaimsIncompleteWork,
   hasScsBlockerEvidence,
+  hostManagedDocumentCompilationRequested,
   buildTmuxGitIntent,
   inferAuthoritativeReadOnlyRoutine,
   inferGitActionsFromCommand,
@@ -1414,6 +1415,22 @@ export function successfulReadFileEvidencePaths(messages = []) {
     .map(({ path: sourcePath, complete }) => ({ path: sourcePath, complete }));
 }
 
+export function authoritativeDocumentInputPaths(state = {}, contract = {}) {
+  const normalize = (value = "") =>
+    String(value || "").replace(/\\/gu, "/").replace(/^\.\//u, "").trim();
+  const declared = [
+    ...(Array.isArray(contract?.exactInputPaths) ? contract.exactInputPaths : []),
+    ...exactInputPathsForState(state),
+  ]
+    .map(normalize)
+    .filter(Boolean);
+  if (declared.length > 0) return [...new Set(declared)].slice(0, 32);
+  return successfulReadFileEvidencePaths(state.messages || [])
+    .map((item) => normalize(item.path))
+    .filter(Boolean)
+    .slice(-32);
+}
+
 function writingRequestNeedsSourceGrounding(args = {}) {
   const context = [args.writingBrief, args.canon, args.constraints, args.priorDraft]
     .filter((value) => typeof value === "string")
@@ -3238,7 +3255,9 @@ async function createInitialState(config, sessionId) {
           isRetainedWorkspaceProfile(config)
             ? "For website/app/code/LaTeX/Python/C/shell tasks, create or edit real workspace files and run bounded checks when useful."
             : "For website/app/code/LaTeX/Python/C/shell tasks, create or edit real workspace files, run available build/compile/test commands, and surface artifacts through the canvas when useful.",
-          "For LaTeX/PDF tasks, check existing latexmk/pdflatex first and compile with the available host or Docker TeX toolchain before installing packages or rebuilding the sandbox.",
+          hostManagedDocumentCompilationRequested(config.goal)
+            ? "For this host-managed document task, create and verify the requested editable sources only. Do not invoke LaTeX, make, package managers, or document compilers; the host stage owns compilation and derived-PDF validation."
+            : "For LaTeX/PDF tasks, check existing latexmk/pdflatex first and compile with the available host or Docker TeX toolchain before installing packages or rebuilding the sandbox.",
           "For research or web-search tasks, use browser tools or safe shell network tools when the current policy allows; cite or save useful sources in workspace notes when the task needs traceability.",
           completionRequirementCoverageInstruction(),
           repositorySourcePrecedenceInstruction(),
@@ -10816,12 +10835,19 @@ export async function documentQualityCommitAssessment(
   const requestedArtifactKinds = Array.isArray(contract.requiredArtifactKinds)
     ? contract.requiredArtifactKinds
     : [];
+  const hostManagedCompilation = Boolean(
+    contract.hostManagedDocumentCompilation ||
+      hostManagedDocumentCompilationRequested(completionContractGoal(config, state))
+  );
   const documentRequested = Boolean(
-    exactOutputPaths.some((item) => /\.(?:docx|pdf)$/iu.test(String(item || ""))) ||
+    exactOutputPaths.some((item) =>
+      /\.docx$/iu.test(String(item || "")) ||
+      (!hostManagedCompilation && /\.pdf$/iu.test(String(item || "")))
+    ) ||
       requestedArtifactKinds.some((item) =>
-        [".docx", ".pdf"].includes(
-          String(item?.format || item?.extension || item || "").toLowerCase()
-        )
+        String(item?.format || item?.extension || item || "").toLowerCase() === ".docx" ||
+        (!hostManagedCompilation &&
+          String(item?.format || item?.extension || item || "").toLowerCase() === ".pdf")
       )
   );
   if (!documentRequested) return null;
@@ -10837,15 +10863,7 @@ export async function documentQualityCommitAssessment(
       candidateResult: "",
       goal: completionContractGoal(config, state),
       exactOutputPaths,
-      exactInputPaths: [
-        ...(Array.isArray(contract.exactInputPaths)
-          ? contract.exactInputPaths
-          : []),
-        ...exactInputPathsForState(state),
-        ...successfulReadFileEvidencePaths(state.messages || []).map(
-          (item) => item.path
-        ),
-      ],
+      exactInputPaths: authoritativeDocumentInputPaths(state, contract),
       requireVersioned: false,
     });
   } catch (error) {
@@ -10887,7 +10905,8 @@ export async function documentQualityCommitAssessment(
   );
   const documentArtifactProducerCommand = inferredLatexArtifactProducerCommand(
     state,
-    config
+    config,
+    contract
   );
   const repair = completionRepairMutationRequirement({
     contract,
@@ -10956,11 +10975,12 @@ function expectedRepeatedObservationCommand(command = "") {
   );
 }
 
-function runCommandResultHasDurableProgress(toolResult = {}) {
+export function runCommandResultHasDurableProgress(toolResult = {}) {
   const policy = toolResult.commandPolicy || {};
   const policyAllowsMutation =
-    policy.mayMutateProject === true ||
-    (policy.mayMutateProject === undefined && policy.writesWorkspace === true);
+    policy.semanticMayMutateProject !== false &&
+    (policy.mayMutateProject === true ||
+      (policy.mayMutateProject === undefined && policy.writesWorkspace === true));
   return Boolean(
     policyAllowsMutation ||
       policy.substantiveTest === true ||
@@ -10971,6 +10991,54 @@ function runCommandResultHasDurableProgress(toolResult = {}) {
   );
 }
 
+function failedCommandAttempt(toolLoop = {}, signature = "", stagnationEpoch = 0) {
+  return (Array.isArray(toolLoop.failedCommandAttempts)
+    ? toolLoop.failedCommandAttempts
+    : []
+  ).find(
+    (entry) =>
+      entry?.signature === signature &&
+      Number(entry?.stagnationEpoch || 0) === Number(stagnationEpoch || 0)
+  );
+}
+
+export function recordFailedCommandAttempt(toolLoop = {}, entry = {}) {
+  if (
+    entry?.toolName !== "run_command" ||
+    entry?.ok !== false ||
+    entry?.blocked === true ||
+    entry?.noProgressProbe !== true ||
+    !entry?.signature
+  ) {
+    return null;
+  }
+  toolLoop.failedCommandAttempts = Array.isArray(toolLoop.failedCommandAttempts)
+    ? toolLoop.failedCommandAttempts
+    : [];
+  const prior = failedCommandAttempt(
+    toolLoop,
+    entry.signature,
+    entry.stagnationEpoch
+  );
+  if (prior) {
+    prior.count = Math.max(0, Number(prior.count || 0)) + 1;
+    prior.lastOutcomeFingerprint = String(entry.outcomeFingerprint || "");
+    prior.lastAt = String(entry.at || new Date().toISOString());
+  } else {
+    toolLoop.failedCommandAttempts.push({
+      signature: entry.signature,
+      count: 1,
+      stagnationEpoch: Math.max(0, Number(entry.stagnationEpoch || 0)),
+      goalRevision: Math.max(0, Number(entry.goalRevision || 0)),
+      mutationRevision: Math.max(0, Number(entry.mutationRevision || 0)),
+      lastOutcomeFingerprint: String(entry.outcomeFingerprint || ""),
+      lastAt: String(entry.at || new Date().toISOString()),
+    });
+  }
+  toolLoop.failedCommandAttempts = toolLoop.failedCommandAttempts.slice(-40);
+  return prior || toolLoop.failedCommandAttempts.at(-1);
+}
+
 function isStaticDiscoveryToolResult(toolResult = {}) {
   if (isStaticDiscoveryToolCall(toolResult.toolName, toolResult.args || {})) return true;
   if (toolResult.toolName !== "run_command") return false;
@@ -11163,6 +11231,30 @@ export function repeatedNoProgressToolBlock(state, toolName, args = {}, config =
       Number(entry?.stagnationEpoch || 0) === stagnationEpoch &&
       Boolean(entry?.outcomeFingerprint)
   );
+  const retainedFailure = failedCommandAttempt(
+    toolLoop,
+    signature,
+    stagnationEpoch
+  );
+  if (Number(retainedFailure?.count || 0) >= 2) {
+    return {
+      reason:
+        "The same command already failed twice without an intervening verified workspace, artifact, browser, or task-state change.",
+      category: "repeated-no-progress-call",
+      permissionAdvice: {
+        category: "repeated-no-progress-call",
+        autoRecover: true,
+        summary: "This is a failed-command convergence guard, not a permission blocker.",
+        instruction:
+          "Do not rerun the command or a cosmetically equivalent form. Use the retained failure evidence, change the command or repair the implicated source, then run the smallest relevant validation.",
+        options: [
+          "Choose the correct compiler, interpreter, working directory, or command flags from the observed failure.",
+          "Apply one bounded source repair that addresses the failure, then rerun validation.",
+          "Finish with a concrete external blocker only when no enabled tool can make progress.",
+        ],
+      },
+    };
+  }
   if (matches.length < 2) return null;
   const repeatedFailures = matches.slice(-2).every((entry) => entry?.ok === false);
   if (repeatedFailures) {
@@ -16422,7 +16514,7 @@ export function nextStepRuntimeConfig(config = {}, state = {}) {
         (item) => String(item?.id || "").toLowerCase() === "format:.tex"
       )
   )
-    ? inferredLatexArtifactProducerCommand(state, config)
+    ? inferredLatexArtifactProducerCommand(state, config, groundingExecutionContract)
     : "";
   const retainedRepairPacket = state.meta?.failedTestRecoveryPacket;
   const repairedRetainedFailure = Boolean(
@@ -19847,6 +19939,7 @@ async function applyToolLoopGuard(state, toolResult, store, observers, config =
   };
   state.meta.toolLoop.recent.push(entry);
   state.meta.toolLoop.recent = state.meta.toolLoop.recent.slice(-20);
+  recordFailedCommandAttempt(state.meta.toolLoop, entry);
 
   const activeRefresh = activePatchContextRefresh(state);
   if (requiredPatchContextRefresh && !activeRefresh) {
@@ -22376,7 +22469,13 @@ export function completionRepairMutationRequirement({
   };
 }
 
-function inferredLatexArtifactProducerCommand(state = {}, config = {}) {
+function inferredLatexArtifactProducerCommand(state = {}, config = {}, contract = {}) {
+  if (
+    contract?.hostManagedDocumentCompilation === true ||
+    hostManagedDocumentCompilationRequested(completionContractGoal(config, state))
+  ) {
+    return "";
+  }
   const verification = state.meta?.projectVerification || {};
   const sourcePath = [...(verification.mutationHistory || [])]
     .reverse()
@@ -22465,13 +22564,21 @@ async function completionEvidenceDecision({ config, state, store, observers, ste
     ...currentGoalDocumentArtifactPathsForState(state, config),
   ];
   const documentContractText = `${completionContractGoal(config, state)}\n${candidateResult}`;
+  const hostManagedCompilation = Boolean(
+    assessment.contract?.hostManagedDocumentCompilation ||
+      hostManagedDocumentCompilationRequested(completionContractGoal(config, state))
+  );
   const documentDeliverableRequested =
     documentProfile === "word" ||
-    documentExactOutputPaths.some((item) => /\.(?:docx|pdf)$/iu.test(String(item || ""))) ||
+    documentExactOutputPaths.some((item) =>
+      /\.docx$/iu.test(String(item || "")) ||
+      (!hostManagedCompilation && /\.pdf$/iu.test(String(item || "")))
+    ) ||
     (["book", "latex", "paper", "writing"].includes(documentProfile) &&
-      /(?:\b(?:docx|pdf|word document)\b|可编辑.*(?:文档|文件)|(?:文档|文件).*可编辑)/iu.test(
+      (/(?:\b(?:docx|word document)\b|可编辑.*(?:文档|文件)|(?:文档|文件).*可编辑)/iu.test(
         documentContractText
-      ));
+      ) ||
+        (!hostManagedCompilation && /\bpdf\b/iu.test(documentContractText))));
   if (documentDeliverableRequested) {
     try {
       documentQuality = await validateWordDocumentArtifacts({
@@ -22479,11 +22586,7 @@ async function completionEvidenceDecision({ config, state, store, observers, ste
         candidateResult,
         goal: completionContractGoal(config, state),
         exactOutputPaths: documentExactOutputPaths,
-        exactInputPaths: [
-          ...(assessment.contract?.exactInputPaths || []),
-          ...exactInputPathsForState(state),
-          ...successfulReadFileEvidencePaths(state.messages || []).map((item) => item.path),
-        ],
+        exactInputPaths: authoritativeDocumentInputPaths(state, assessment.contract),
         requireVersioned: (assessment.contract?.requiredGitActions || []).includes("commit"),
       });
     } catch (error) {
@@ -22764,7 +22867,8 @@ async function completionEvidenceDecision({ config, state, store, observers, ste
     : "";
   const documentArtifactProducerCommand = inferredLatexArtifactProducerCommand(
     state,
-    config
+    config,
+    assessment.contract
   );
   const freshMutationRequirement = completionRepairMutationRequirement({
     contract: assessment.contract,

package/src/command-policy.js

@@ -137,6 +137,25 @@ function isReadOnlyDiffCommand(command = "") {
   );
 }
 
+function isReadOnlyXargsListFilter(command = "") {
+  const normalized = stripBenignRedirections(command);
+  if (hasActiveShellExpansion(normalized)) return false;
+  const tokens = tokenizeShellWords(normalized);
+  if (!tokens.length || tokens[0] !== "xargs") return false;
+  let index = 1;
+  while (
+    ["-0", "--null", "-r", "--no-run-if-empty"].includes(tokens[index])
+  ) {
+    index += 1;
+  }
+  if (tokens[index] !== "ls") return false;
+  return tokens.slice(index + 1).every((token) =>
+    /^(?:-[A-Za-z0-9]+|--(?:all|almost-all|directory|inode|long|numeric-uid-gid|reverse|size|human-readable))$/.test(
+      token
+    )
+  );
+}
+
 function isReadOnlyFindCommand(command = "") {
   const normalized = stripBenignRedirections(command);
   if (!/^find\s+/.test(normalized)) return false;
@@ -209,6 +228,16 @@ function isReadOnlyFindCommand(command = "") {
   return parenthesisDepth === 0 && maxDepth !== null;
 }
 
+function isNonMutatingFindCommand(command = "") {
+  const normalized = stripBenignRedirections(command);
+  if (!/^find\s+/.test(normalized)) return false;
+  if (/(^|\s)(-delete|-exec|-execdir|-ok|-okdir|-fprint|-fprintf|-fls)\b/.test(normalized)) {
+    return false;
+  }
+  const unquoted = stripQuotedSegments(normalized);
+  return !/[|<>;&`$]/.test(unquoted) && !hasActiveShellExpansion(normalized);
+}
+
 function isUnboundedRecursiveGrep(command = "") {
   const normalized = stripBenignRedirections(command);
   if (!/^grep\s+/.test(normalized)) return false;
@@ -1860,6 +1889,7 @@ function classifySimpleCommand(normalized) {
     isReadOnlyUniqFilter(commandForPatternMatching) ||
     isReadOnlyDigestCommand(commandForPatternMatching) ||
     isReadOnlyDiffCommand(commandForPatternMatching) ||
+    isReadOnlyXargsListFilter(commandForPatternMatching) ||
     isReadOnlyFindCommand(normalized) ||
     (!hasActiveShellExpansion(benignRedirectCommand) && isReadOnlyShellCondition(benignRedirectCommand))
   ) {
@@ -1921,6 +1951,17 @@ function classifySimpleCommand(normalized) {
     return { category: "env-setup", needsNetwork: false, writesWorkspace: true };
   }
 
+  if (isNonMutatingFindCommand(commandForPatternMatching)) {
+    return {
+      category: "general-shell",
+      needsNetwork: false,
+      writesWorkspace: true,
+      semanticMayMutateProject: false,
+      reason:
+        "Unbounded find inspection remains under trusted shell policy but cannot mutate project state.",
+    };
+  }
+
   return {
     category: "general-shell",
     needsNetwork: false,
@@ -2770,6 +2811,13 @@ function classifyPipelineSequence(normalized) {
     category: "general-shell",
     needsNetwork: classifications.some((classification) => classification.needsNetwork),
     writesWorkspace: classifications.some((classification) => classification.writesWorkspace),
+    ...(classifications.every(
+      (classification) =>
+        classification.category === "read-only" ||
+        classification.semanticMayMutateProject === false
+    )
+      ? { semanticMayMutateProject: false }
+      : {}),
     reason: `Shell pipeline includes a broad segment and requires trusted shell policy: ${normalized}`,
   };
 }

package/src/document-artifact-quality.js

@@ -821,6 +821,32 @@ export async function collectDocumentSourceDocuments(commandCwd, exactInputPaths
   const maxTotalBytes = 4 * 1024 * 1024;
   const maxFileBytes = 512 * 1024;
 
+  const knownPaths = new Set();
+  for (const value of Array.isArray(exactInputPaths) ? exactInputPaths : []) {
+    if (documents.length >= maxFiles || totalBytes >= maxTotalBytes) break;
+    const absolutePath = path.resolve(commandCwd, String(value || ""));
+    if (!isInsideRoot(commandCwd, absolutePath)) continue;
+    const relativePath = portablePath(path.relative(commandCwd, absolutePath));
+    if (!relativePath || knownPaths.has(relativePath)) continue;
+    if (!DOCUMENT_EXTENSIONS.has(path.extname(absolutePath).toLowerCase())) continue;
+    try {
+      const stat = await fs.stat(absolutePath);
+      if (!stat.isFile() || stat.size <= 0 || stat.size > maxFileBytes) continue;
+      if (totalBytes + stat.size > maxTotalBytes) continue;
+      const text = await fs.readFile(absolutePath, "utf8");
+      documents.push({ path: relativePath, text });
+      knownPaths.add(relativePath);
+      totalBytes += stat.size;
+    } catch {
+      // Exact unreadable sources remain visible to the existing source/evidence gates.
+    }
+  }
+
+  // Declared task inputs are authoritative. Repository-wide discovery is a
+  // fallback for tasks that did not name a readable source, not extra context
+  // to blend into a scoped document review.
+  if (documents.length > 0) return documents;
+
   async function visit(directory, sourceRoot = false, depth = 0) {
     if (documents.length >= maxFiles || totalBytes >= maxTotalBytes || depth > 5) return;
     let entries;
@@ -857,26 +883,6 @@ export async function collectDocumentSourceDocuments(commandCwd, exactInputPaths
   }
 
   await visit(commandCwd, false, 0);
-  const knownPaths = new Set(documents.map((item) => item.path));
-  for (const value of Array.isArray(exactInputPaths) ? exactInputPaths : []) {
-    if (documents.length >= maxFiles || totalBytes >= maxTotalBytes) break;
-    const absolutePath = path.resolve(commandCwd, String(value || ""));
-    if (!isInsideRoot(commandCwd, absolutePath)) continue;
-    const relativePath = portablePath(path.relative(commandCwd, absolutePath));
-    if (!relativePath || knownPaths.has(relativePath)) continue;
-    if (!DOCUMENT_EXTENSIONS.has(path.extname(absolutePath).toLowerCase())) continue;
-    try {
-      const stat = await fs.stat(absolutePath);
-      if (!stat.isFile() || stat.size <= 0 || stat.size > maxFileBytes) continue;
-      if (totalBytes + stat.size > maxTotalBytes) continue;
-      const text = await fs.readFile(absolutePath, "utf8");
-      documents.push({ path: relativePath, text });
-      knownPaths.add(relativePath);
-      totalBytes += stat.size;
-    } catch {
-      // Exact unreadable sources remain visible to the existing source/evidence gates.
-    }
-  }
   return documents;
 }
 

package/src/scs-evidence.js

@@ -670,9 +670,40 @@ function artifactRequestHasOutputIntent(goal = "", taskProfile = "") {
   );
 }
 
+export function hostManagedDocumentCompilationRequested(goal = "") {
+  const source = String(goal || "").replace(/\s+/gu, " ").trim();
+  if (!source) return false;
+  if (
+    /\bdo\s+not\s+(?:invoke|run|use)\b[^.!?;。！？；]{0,180}\b(?:document\s+compiler|latexmk|pdflatex|xelatex|lualatex|latex|pandoc|make)\b[^.!?;。！？；]{0,180}\b(?:labcanvas\s+)?host\b/iu.test(
+      source
+    ) ||
+    /(?:不要|不得|无需|不需要)(?:调用|运行|使用).{0,80}(?:LaTeX|latexmk|pdflatex|xelatex|文档编译器).{0,100}(?:由|交给)(?:\s*LabCanvas)?(?:主机|宿主)(?:编译|构建|渲染|验证)/u.test(
+      source
+    )
+  ) {
+    return true;
+  }
+
+  const ownershipPattern =
+    /\b(?:the\s+)?(?:labcanvas\s+)?host(?:\s+(?:compiler|recovery|stage)){0,2}\s+(?:alone\s+)?(?:owns|handles?|performs?|will\s+(?:build|compile|handle|perform|render|validate))\b[^.!?;。！？；]{0,120}\b(?:compil(?:ation|e)|document|latex|pdf|render|validation)\b/giu;
+  for (const match of source.matchAll(ownershipPattern)) {
+    const prefix = source.slice(Math.max(0, Number(match.index || 0) - 180), Number(match.index || 0));
+    if (
+      /\b(?:if|when)\b[^.!?;。！？；]{0,140}\b(?:cannot|can't|fails?|failure|unavailable|unsupported)\b/iu.test(
+        prefix
+      )
+    ) {
+      continue;
+    }
+    return true;
+  }
+  return false;
+}
+
 export function inferRequestedArtifactRequirements(goal = "", taskProfile = "") {
   const source = stripForbiddenLanguage(String(goal || ""));
   if (!artifactRequestHasOutputIntent(source, taskProfile)) return [];
+  const hostManagedCompilation = hostManagedDocumentCompilationRequested(goal);
 
   const requirements = [];
   const add = (requirement) => {
@@ -681,6 +712,7 @@ export function inferRequestedArtifactRequirements(goal = "", taskProfile = "")
   };
 
   for (const format of REQUESTED_ARTIFACT_FORMATS) {
+    if (hostManagedCompilation && format.extension === ".pdf") continue;
     if (!requestedArtifactFormatHasOutputIntent(source, format)) continue;
     add({
       id: `format:${format.extension}`,
@@ -702,6 +734,7 @@ export function inferRequestedArtifactRequirements(goal = "", taskProfile = "")
   }
 
   if (
+    !hostManagedCompilation &&
     /\bprintable\b/i.test(source) &&
     /\b(?:answer|deck|document|handout|material|practice|sheet|slides?|worksheet)\b/i.test(source)
   ) {
@@ -2170,9 +2203,16 @@ export function deriveScsTaskContract({ goal = "", taskProfile = "", acceptanceC
     inferExactOutputPaths(positiveEvidenceGoal),
     excludedOutputPaths
   );
+  const hostManagedDocumentCompilation = hostManagedDocumentCompilationRequested(
+    evidenceGoal
+  );
   const exactOutputPaths = filterExplicitlyExcludedOutputPaths(
     applyScopedArtifactRoot(inferredOutputPaths, artifactRoot),
     excludedOutputPaths
+  ).filter(
+    (item) =>
+      !hostManagedDocumentCompilation ||
+      path.extname(String(item || "")).toLocaleLowerCase("en-US") !== ".pdf"
   );
   const exactInputPaths = filterExplicitlyExcludedOutputPaths(
     inferExactInputPaths(positiveEvidenceGoal),
@@ -2198,6 +2238,7 @@ export function deriveScsTaskContract({ goal = "", taskProfile = "", acceptanceC
     forbiddenActions: inferForbiddenActions(evidenceGoal),
     exactOutputPaths,
     requiredArtifactKinds,
+    hostManagedDocumentCompilation,
     scopedArtifactDeliverable,
     scopedArtifactOperation,
     excludedOutputPaths,