@lazyingart/agintiflow 0.20.258 → 0.20.260

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lazyingart/agintiflow",
-  "version": "0.20.258",
+  "version": "0.20.260",
   "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-dynamic-step-budget.js

@@ -2618,6 +2618,114 @@ try {
       JSON.stringify(["npm test"]),
     "console output lines were mistaken for required shell commands"
   );
+  const operatorGuideMarkdown = [
+    "# Service",
+    "",
+    "The controller must provide start, status, restart, and stop.",
+    "",
+    "## Operator Guidance",
+    "",
+    "### Start the service",
+    "",
+    "```bash",
+    "python3 service_ctl.py start --state-dir .runtime",
+    "```",
+    "",
+    "### Check service status",
+    "",
+    "```bash",
+    "python3 service_ctl.py status --state-dir .runtime",
+    "```",
+    "",
+    "## Running Tests",
+    "",
+    "Run the visible regression suite with:",
+    "",
+    "```bash",
+    "python3 -m unittest discover -s tests -v",
+    "```",
+  ].join("\n");
+  assert(
+    JSON.stringify(projectAcceptanceFromMarkdown(operatorGuideMarkdown, "README.md").requiredCommands) ===
+      JSON.stringify(["python3 -m unittest discover -s tests -v"]),
+    "ordinary operator examples became mandatory acceptance commands"
+  );
+  const refreshedAcceptanceState = {
+    commandCwd: workspace,
+    meta: {
+      projectVerification: {
+        requiredOutputs: ["stale-output.txt"],
+        requiredCommands: [
+          "python3 service_ctl.py start --state-dir .runtime",
+          "python3 service_ctl.py status --state-dir .runtime",
+        ],
+        acceptanceSource: "README.md",
+      },
+    },
+  };
+  recordProjectVerificationOutcome(
+    refreshedAcceptanceState,
+    {
+      ok: true,
+      toolName: "read_file",
+      path: "README.md",
+      content: operatorGuideMarkdown,
+    },
+    { commandCwd: workspace, taskProfile: "devops" }
+  );
+  assert(
+    JSON.stringify(refreshedAcceptanceState.meta.projectVerification.requiredCommands) ===
+      JSON.stringify(["python3 -m unittest discover -s tests -v"]) &&
+      refreshedAcceptanceState.meta.projectVerification.requiredOutputs.length === 0,
+    "rereading one authoritative source retained its stale acceptance requirements"
+  );
+  const resumedAcceptanceWorkspace = path.join(workspace, "resumed-acceptance");
+  await fs.mkdir(resumedAcceptanceWorkspace, { recursive: true });
+  await fs.writeFile(
+    path.join(resumedAcceptanceWorkspace, "README.md"),
+    operatorGuideMarkdown,
+    "utf8"
+  );
+  const resumedAcceptanceState = {
+    commandCwd: resumedAcceptanceWorkspace,
+    goal: "Repair the service and run its tests.",
+    meta: {
+      goalContract: { revision: 4, currentRequest: "Repair the service and run its tests." },
+      projectVerification: {
+        requiredCommands: [
+          "python3 service_ctl.py start --state-dir .runtime",
+          "python3 service_ctl.py status --state-dir .runtime",
+        ],
+        acceptanceSource: "README.md",
+      },
+    },
+  };
+  resetSameTaskExecutionContract(resumedAcceptanceState, 4);
+  assert(
+    JSON.stringify(resumedAcceptanceState.meta.projectVerification.requiredCommands) ===
+      JSON.stringify(["python3 -m unittest discover -s tests -v"]),
+    "same-task resume retained stale requirements from an older README parser"
+  );
+  recordProjectVerificationOutcome(
+    refreshedAcceptanceState,
+    {
+      ok: true,
+      toolName: "read_file",
+      path: "TASK.md",
+      content: requiredCommandMarkdown,
+    },
+    { commandCwd: workspace, taskProfile: "devops" }
+  );
+  assert(
+    JSON.stringify(refreshedAcceptanceState.meta.projectVerification.requiredCommands) ===
+      JSON.stringify([
+        "python3 -m unittest discover -s tests -v",
+        "npm run check",
+        "npm test",
+        "python scripts/verify.py --strict",
+      ]),
+    "source-scoped acceptance refresh discarded a distinct authoritative source"
+  );
   const operatorContinuedCommandMarkdown = [
     "# Task",
     "",

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

@@ -60,6 +60,14 @@ const coordinatedForbiddenOutputContract = deriveScsTaskContract({
   taskProfile: "devops",
 });
 
+const recoveryInstructionContract = deriveScsTaskContract({
+  goal: [
+    "Use the retained source and these two failures: the tests invoke ../service_ctl.py, while `python3 service_ctl.py start --state-dir .runtime` fails. Preserve the lifecycle assertions rather than replacing them, repair service_ctl.py, and remove the accidental untracked resume-after-git-baseline-recovery-dev-prompt.txt.",
+    "Then run `python3 -m unittest discover -s tests -v`, followed by `PYTHONDONTWRITEBYTECODE=1 python3 /tmp/devops_sensor_gateway_contract.py`. Do not use LocalLLM or change provider.",
+  ].join("\n"),
+  taskProfile: "devops",
+});
+
 const readOnlyReviewContract = deriveScsTaskContract({
   goal: [
     "Review focus: changed files only.",
@@ -136,6 +144,33 @@ assert.deepEqual(
   ["scratch.py", "temporary.py"],
   "a coordinated list did not retain each path governed by one exclusion"
 );
+assert(
+  recoveryInstructionContract.excludedOutputPaths.includes("resume-after-git-baseline-recovery-dev-prompt.txt") &&
+    !recoveryInstructionContract.exactOutputPaths.includes("resume-after-git-baseline-recovery-dev-prompt.txt"),
+  "an explicit deletion target became a required output"
+);
+assert.deepEqual(
+  recoveryInstructionContract.requiredTextTerms,
+  [],
+  "verification commands became required document prose"
+);
+assert.deepEqual(
+  recoveryInstructionContract.requiredExecutableTerms,
+  [],
+  "an environment assignment inside a verification command became required production source"
+);
+assert(
+  !recoveryInstructionContract.exactInputPaths.some((item) => item.includes("PYTHONDONTWRITEBYTECODE")),
+  "a quoted verification command became an input path"
+);
+assert.deepEqual(
+  recoveryInstructionContract.requiredProjectCommands,
+  [
+    "python3 -m unittest discover -s tests -v",
+    "PYTHONDONTWRITEBYTECODE=1 python3 /tmp/devops_sensor_gateway_contract.py",
+  ],
+  "a verification command introduced by 'followed by' was not retained"
+);
 assert.equal(
   readOnlyReviewContract.requiresWorkspaceMutation,
   false,

package/src/agent-runner.js

@@ -3769,6 +3769,67 @@ export function resetGoalScopedRuntimeState(state = {}) {
   return removed;
 }
 
+function refreshPersistedProjectAcceptance(state = {}) {
+  const verification = state.meta?.projectVerification;
+  if (!verification || typeof verification !== "object") return false;
+  const priorBySource =
+    verification.acceptanceBySource &&
+    typeof verification.acceptanceBySource === "object" &&
+    !Array.isArray(verification.acceptanceBySource)
+      ? verification.acceptanceBySource
+      : {};
+  const sources = [
+    ...Object.keys(priorBySource),
+    String(verification.acceptanceSource || "").trim(),
+  ].filter(Boolean);
+  if (!sources.length) return false;
+
+  const commandCwd = path.resolve(state.commandCwd || process.cwd());
+  const refreshed = {};
+  let inspected = 0;
+  for (const source of [...new Set(sources)].slice(-16)) {
+    const sourceKey = normalizedProjectAcceptancePath(source, commandCwd);
+    if (!sourceKey || !projectAcceptanceSourceIsAuthoritative(sourceKey, {
+      commandCwd,
+      authoritativePaths: [sourceKey],
+    })) {
+      continue;
+    }
+    const absolutePath = path.resolve(commandCwd, sourceKey);
+    if (absolutePath !== commandCwd && !absolutePath.startsWith(`${commandCwd}${path.sep}`)) continue;
+    inspected += 1;
+    if (!fsSync.existsSync(absolutePath)) continue;
+    try {
+      const acceptance = projectAcceptanceFromMarkdown(
+        fsSync.readFileSync(absolutePath, "utf8"),
+        sourceKey,
+        { commandCwd, authoritativePaths: [sourceKey] }
+      );
+      refreshed[sourceKey] = {
+        requiredOutputs: acceptance.requiredOutputs,
+        requiredCommands: acceptance.requiredCommands,
+        readAt: new Date().toISOString(),
+      };
+    } catch {
+      inspected -= 1;
+    }
+  }
+  if (!inspected) return false;
+  verification.acceptanceBySource = refreshed;
+  verification.requiredOutputs = [
+    ...new Set(
+      Object.values(refreshed).flatMap((item) => item.requiredOutputs || [])
+    ),
+  ].slice(0, 64);
+  verification.requiredCommands = [
+    ...new Set(
+      Object.values(refreshed).flatMap((item) => item.requiredCommands || [])
+    ),
+  ].slice(0, 24);
+  verification.acceptanceRefreshedAt = new Date().toISOString();
+  return true;
+}
+
 export function resetSameTaskExecutionContract(state = {}, revision = 0) {
   state.meta = state.meta || {};
   const keys = [
@@ -3786,6 +3847,7 @@ export function resetSameTaskExecutionContract(state = {}, revision = 0) {
     removed.push(key);
   }
   state.plan = "";
+  refreshPersistedProjectAcceptance(state);
   const activeRevision = Math.max(0, Number(revision || state.meta?.goalContract?.revision || 0));
   const currentRequest = String(state.meta?.goalContract?.currentRequest || state.goal || "").trim();
   const currentTurnContract = deriveScsTaskContract({
@@ -5281,20 +5343,59 @@ function canonicalRequiredFenceCommand(value = "") {
   );
 }
 
+function markdownFenceRequiresCommandExecution(content = "", fenceIndex = 0) {
+  const lines = String(content || "")
+    .slice(0, Math.max(0, Number(fenceIndex || 0)))
+    .split(/\r?\n/);
+  while (lines.length && !lines.at(-1).trim()) lines.pop();
+  if (!lines.length) return false;
+
+  const nearest = String(lines.at(-1) || "").trim();
+  const heading = nearest.match(/^#{1,6}\s+(.+?)\s*#*$/);
+  if (heading) {
+    return /\b(?:acceptance|tests?|validation|verification)\b|(?:验收|驗收|测试|測試|验证|驗證)|(?:受入|テスト|検証)/iu.test(
+      heading[1]
+    );
+  }
+
+  const paragraph = [];
+  while (lines.length && paragraph.length < 5) {
+    const line = String(lines.pop() || "").trim();
+    if (!line || /^#{1,6}\s+/.test(line) || /^```/.test(line)) break;
+    paragraph.unshift(line);
+  }
+  const cue = paragraph.join(" ").trim();
+  if (!cue) return false;
+
+  const execution = /\b(?:commands?|execute|invoke|launch|regenerate|run|tests?|validate|validation|verify|verification)\b/iu.test(
+    cue
+  );
+  const obligation = /\b(?:before\s+completion|must|required|shall|should)\b/iu.test(cue);
+  const directImperative = /^(?:please\s+)?(?:execute|invoke|launch|regenerate|run|validate|verify)\b/iu.test(cue);
+  const validationLead = /^(?:to\s+(?:check|test|validate|verify)\b|(?:required|mandatory)\s+(?:checks?|commands?|tests?|validation|verification)\b)/iu.test(
+    cue
+  );
+  const cjkExecution = /(?:运行|運行|执行|執行|验证|驗證|检查|檢查|测试|測試|验收|驗收|実行|検証|確認|テスト)/u.test(cue);
+  const cjkObligation = /(?:必须|必須|需要|应当|應當|完成前|完了前)/u.test(cue);
+  const cjkDirectImperative = /^(?:请|請)?(?:运行|運行|执行|執行|验证|驗證|检查|檢查|测试|測試|验收|驗收|実行|検証|確認|テスト)/u.test(
+    cue
+  );
+  return (
+    (execution && obligation) ||
+    directImperative ||
+    validationLead ||
+    (cjkExecution && cjkObligation) ||
+    cjkDirectImperative
+  );
+}
+
 function markdownRequiredCommands(content = "") {
   const text = String(content || "");
   const commands = [];
   for (const match of text.matchAll(/```([A-Za-z0-9_-]*)[ \t]*\n([\s\S]*?)```/gi)) {
     const language = String(match[1] || "").toLowerCase();
     if (language && !["bash", "sh", "shell", "console"].includes(language)) continue;
-    const before = text.slice(Math.max(0, Number(match.index || 0) - 420), Number(match.index || 0));
-    if (
-      !/(?:run|running|execute|command|verify|validation|regenerate)[^\n.]{0,180}(?:must|required|should|use|run|regenerate)|(?:必须|需要|应当|运行|执行|验证)[^。\n]{0,180}(?:命令|生成|输出|交付)/i.test(
-        before
-      )
-    ) {
-      continue;
-    }
+    if (!markdownFenceRequiresCommandExecution(text, match.index)) continue;
     const body = String(match[2] || "");
     const fenceCommandStart = commands.length;
     const context = [];
@@ -5342,11 +5443,9 @@ function normalizedProjectAcceptancePath(sourcePath = "", commandCwd = "") {
   return raw.replace(/\\/g, "/").replace(/^\.\//, "");
 }
 
-export function projectAcceptanceFromMarkdown(content = "", sourcePath = "", options = {}) {
+function projectAcceptanceSourceIsAuthoritative(sourcePath = "", options = {}) {
   const basename = path.basename(String(sourcePath || "")).toLowerCase();
-  if (!/^(?:readme|task|agents?|aginti)(?:\.[^.]+)?$/.test(basename)) {
-    return { requiredOutputs: [], requiredCommands: [] };
-  }
+  if (!/^(?:readme|task|agents?|aginti)(?:\.[^.]+)?$/.test(basename)) return false;
   const normalizedSource = normalizedProjectAcceptancePath(
     sourcePath,
     options.commandCwd
@@ -5356,10 +5455,11 @@ export function projectAcceptanceFromMarkdown(content = "", sourcePath = "", opt
       .map((item) => normalizedProjectAcceptancePath(item, options.commandCwd))
       .filter(Boolean)
   );
-  if (
-    normalizedSource.includes("/") &&
-    !authoritativePaths.has(normalizedSource)
-  ) {
+  return !normalizedSource.includes("/") || authoritativePaths.has(normalizedSource);
+}
+
+export function projectAcceptanceFromMarkdown(content = "", sourcePath = "", options = {}) {
+  if (!projectAcceptanceSourceIsAuthoritative(sourcePath, options)) {
     return { requiredOutputs: [], requiredCommands: [] };
   }
   return {
@@ -5739,29 +5839,72 @@ export function recordProjectVerificationOutcome(state = {}, toolResult = {}, co
       goal: completionContractGoal(config, state),
       taskProfile: config.taskProfile || state.meta?.taskProfile || "auto",
     });
+    const sourcePath = String(toolResult.path || toolResult.args?.path || "");
+    const acceptanceOptions = {
+      commandCwd: config.commandCwd || state.commandCwd || process.cwd(),
+      authoritativePaths: [
+        ...(Array.isArray(currentTaskContract.exactInputPaths)
+          ? currentTaskContract.exactInputPaths
+          : []),
+        ...(Array.isArray(currentTaskContract.exactOutputPaths)
+          ? currentTaskContract.exactOutputPaths
+          : []),
+      ],
+    };
     const acceptance = projectAcceptanceFromMarkdown(
       toolResult.content,
-      toolResult.path || toolResult.args?.path || "",
-      {
-        commandCwd: config.commandCwd || state.commandCwd || process.cwd(),
-        authoritativePaths: [
-          ...(Array.isArray(currentTaskContract.exactInputPaths)
-            ? currentTaskContract.exactInputPaths
-            : []),
-          ...(Array.isArray(currentTaskContract.exactOutputPaths)
-            ? currentTaskContract.exactOutputPaths
-            : []),
-        ],
-      }
+      sourcePath,
+      acceptanceOptions
     );
-    verification.requiredOutputs = [
-      ...new Set([...verification.requiredOutputs, ...acceptance.requiredOutputs]),
-    ].slice(0, 64);
-    verification.requiredCommands = [
-      ...new Set([...verification.requiredCommands, ...acceptance.requiredCommands]),
-    ].slice(0, 24);
-    if (acceptance.requiredOutputs.length || acceptance.requiredCommands.length) {
-      verification.acceptanceSource = String(toolResult.path || toolResult.args?.path || "");
+    if (projectAcceptanceSourceIsAuthoritative(sourcePath, acceptanceOptions)) {
+      const sourceKey = normalizedProjectAcceptancePath(
+        sourcePath,
+        acceptanceOptions.commandCwd
+      );
+      const acceptanceBySource =
+        verification.acceptanceBySource &&
+        typeof verification.acceptanceBySource === "object" &&
+        !Array.isArray(verification.acceptanceBySource)
+          ? { ...verification.acceptanceBySource }
+          : {};
+      const legacySourceKey = normalizedProjectAcceptancePath(
+        verification.acceptanceSource || "",
+        acceptanceOptions.commandCwd
+      );
+      if (
+        !Object.keys(acceptanceBySource).length &&
+        legacySourceKey &&
+        legacySourceKey !== sourceKey
+      ) {
+        acceptanceBySource[legacySourceKey] = {
+          requiredOutputs: [...verification.requiredOutputs],
+          requiredCommands: [...verification.requiredCommands],
+          readAt: verification.acceptanceReadAt || "",
+        };
+      }
+      acceptanceBySource[sourceKey] = {
+        requiredOutputs: acceptance.requiredOutputs,
+        requiredCommands: acceptance.requiredCommands,
+        readAt: now,
+      };
+      verification.acceptanceBySource = Object.fromEntries(
+        Object.entries(acceptanceBySource).slice(-16)
+      );
+      verification.requiredOutputs = [
+        ...new Set(
+          Object.values(verification.acceptanceBySource).flatMap((item) =>
+            Array.isArray(item?.requiredOutputs) ? item.requiredOutputs : []
+          )
+        ),
+      ].slice(0, 64);
+      verification.requiredCommands = [
+        ...new Set(
+          Object.values(verification.acceptanceBySource).flatMap((item) =>
+            Array.isArray(item?.requiredCommands) ? item.requiredCommands : []
+          )
+        ),
+      ].slice(0, 24);
+      verification.acceptanceSource = sourcePath;
       verification.acceptanceReadAt = now;
     }
   }

package/src/scs-evidence.js

@@ -326,6 +326,56 @@ function quotedTerms(text = "") {
   return terms;
 }
 
+function looksLikeShellCommandLiteral(value = "") {
+  const text = String(value || "").trim();
+  if (!text || /[\r\n]/.test(text)) return false;
+  const command = text.replace(/^(?:[A-Za-z_][A-Za-z0-9_]*=[^\s]+\s+)+/, "");
+  const tokens = tokenizeShellWords(command);
+  if (!tokens.length) return false;
+  const executable = path.basename(String(tokens[0] || "")).toLowerCase();
+  return new Set([
+    "aginti",
+    "bash",
+    "bun",
+    "cargo",
+    "cmake",
+    "curl",
+    "dotnet",
+    "ffmpeg",
+    "git",
+    "gh",
+    "go",
+    "java",
+    "javac",
+    "latexmk",
+    "make",
+    "node",
+    "npm",
+    "npx",
+    "perl",
+    "php",
+    "pnpm",
+    "pytest",
+    "python",
+    "python3",
+    "ruby",
+    "sh",
+    "wget",
+    "xelatex",
+    "yarn",
+    "zsh",
+  ]).has(executable);
+}
+
+function indexFallsInsideInlineCommand(source = "", index = 0) {
+  for (const match of String(source || "").matchAll(/`([^`\r\n]+)`/g)) {
+    const start = Number(match.index || 0);
+    const end = start + String(match[0] || "").length;
+    if (index >= start && index < end && looksLikeShellCommandLiteral(match[1])) return true;
+  }
+  return false;
+}
+
 function splitInlineTerms(text = "") {
   return String(text || "")
     .split(/[、,，;；]/)
@@ -515,6 +565,10 @@ export function inferExplicitlyExcludedOutputPaths(goal = "") {
     /(?:不要|不得|禁止|无需|不需要)[^。！？；\n]{0,140}(?:运行|执行|重跑|创建|建立|写入|生成|保存|输出|修改|编辑|提交|暂存)/u;
   const cjkNegativeActionAfter =
     /^(?:(?:不得|禁止|不要)(?:被)?(?:运行|执行|重跑|创建|建立|写入|生成|保存|输出|修改|编辑|提交|暂存)|(?:を)?(?:作成|生成|実行|再実行|保存|編集|変更|コミット)[^。！？；\n]{0,40}(?:しない|しなくてよい|してはいけない))/u;
+  const directRemovalBefore =
+    /\b(?:remove|delete|unlink|discard)\s+(?:(?:the|an?|this|that)\s+)?(?:(?:accidental|stale|temporary|untracked|generated|obsolete|old|private|empty)\s+)*(?:file\s+)?$/i;
+  const cjkDirectRemovalBefore =
+    /(?:删除|刪除|移除|清除)(?:(?:这个|這個|该|該|意外的|暂存的|暫存的|临时的|臨時的|未跟踪的|未追蹤的|旧的|舊的|私有的)\s*)*(?:文件)?\s*$/u;
   const excluded = [];
   for (const clause of source.split(/[;；\n]|(?<=[.!?。！？])\s+/u)) {
     pathPattern.lastIndex = 0;
@@ -545,7 +599,9 @@ export function inferExplicitlyExcludedOutputPaths(goal = "") {
         negativeActionAfter.test(after) ||
         keepAbsent.test(`${before}${after}`) ||
         cjkNegativeActionBefore.test(before) ||
-        cjkNegativeActionAfter.test(after)
+        cjkNegativeActionAfter.test(after) ||
+        directRemovalBefore.test(before) ||
+        cjkDirectRemovalBefore.test(before)
       );
       previousExcluded = directExclusion || coordinatedWithExcludedPrevious;
       if (previousExcluded) {
@@ -655,7 +711,13 @@ function inferRequiredTextTerms(goal = "") {
   }
   // A quoted filename in "save as `report.md`" is an output location, not
   // required prose inside that report. Path existence is validated separately.
-  return uniqueLimited(terms.filter((term) => !outputPathTerms.has(String(term).trim())), 24);
+  return uniqueLimited(
+    terms.filter((term) => {
+      const cleaned = String(term).trim();
+      return !outputPathTerms.has(cleaned) && !looksLikeShellCommandLiteral(cleaned);
+    }),
+    24
+  );
 }
 
 const EXECUTABLE_SOURCE_EXTENSIONS = new Set([
@@ -701,6 +763,7 @@ export function inferRequiredExecutableTerms(goal = "") {
   for (const match of source.matchAll(assignmentPattern)) {
     const index = Number(match.index || 0);
     if (executableRequirementIsNegated(source, index)) continue;
+    if (indexFallsInsideInlineCommand(source, index)) continue;
     const window = source.slice(Math.max(0, index - 180), Math.min(source.length, index + match[0].length + 220));
     const implementationRequirement =
       /\b(?:actual|canonical|executable|implementation|source|code|call|argument|keyword|parameter|repair|fix|correct|replace|add|set|pass|use|must|required)\b/iu.test(window) ||
@@ -1316,9 +1379,9 @@ function prefixRequestsInlineCommandExecution(prefix = "") {
   while (preamble.test(clause)) clause = clause.replace(preamble, "").trim();
   clause = clause.replace(/(?:[:：]|--?)\s*$/, "").trim();
   return (
-    /^(?:run|rerun|re-run|execute|invoke|launch|verify|validate|check|confirm)(?:\s+(?:(?:the|this|that)\s+)?(?:following\s+)?command(?:\s+named)?)?\s*$/i.test(
+    /^(?:followed\s+by|run|rerun|re-run|execute|invoke|launch|verify|validate|check|confirm)(?:\s+(?:(?:the|this|that)\s+)?(?:following\s+)?command(?:\s+named)?)?\s*$/i.test(
       clause
-    ) || /^(?:运行|運行|执行|執行|调用|調用|验证|驗證|检查|檢查|确认|確認)\s*$/.test(clause)
+    ) || /^(?:随后运行|隨後運行|接着运行|接著運行|运行|運行|执行|執行|调用|調用|验证|驗證|检查|檢查|确认|確認)\s*$/.test(clause)
   );
 }
 
@@ -1408,6 +1471,7 @@ function inferExplicitRequestedCommands(goal = "") {
 
 export function deriveScsTaskContract({ goal = "", taskProfile = "", acceptanceCriteria = [] } = {}) {
   const evidenceGoal = scopedChatopsEvidenceGoal(goal, taskProfile);
+  const positiveEvidenceGoal = stripForbiddenLanguage(evidenceGoal);
   const artifactRoot = scopedArtifactRoot(goal);
   const requirementCategories = inferRequirementCategories(evidenceGoal, taskProfile, acceptanceCriteria);
   const requiredToolCalls = inferRequiredToolCalls(evidenceGoal);
@@ -1431,7 +1495,7 @@ export function deriveScsTaskContract({ goal = "", taskProfile = "", acceptanceC
     excludedOutputPaths
   );
   const exactInputPaths = filterExplicitlyExcludedOutputPaths(
-    inferExactInputPaths(evidenceGoal),
+    inferExactInputPaths(positiveEvidenceGoal),
     excludedOutputPaths
   ).filter((item) => !inferredOutputPaths.includes(item) && !exactOutputPaths.includes(item));
   const declaredSourceRoots = inferDeclaredSourceRoots(evidenceGoal);
@@ -1455,8 +1519,8 @@ export function deriveScsTaskContract({ goal = "", taskProfile = "", acceptanceC
     requiresWorkspaceMutation: goalRequestsWorkspaceMutation(evidenceGoal, taskProfile),
     requiresFileMutation: goalRequestsFileMutation(evidenceGoal, taskProfile),
     requiresSourceGrounding: requiresSourceGrounding(evidenceGoal),
-    requiredTextTerms: inferRequiredTextTerms(evidenceGoal),
-    requiredExecutableTerms: inferRequiredExecutableTerms(evidenceGoal),
+    requiredTextTerms: inferRequiredTextTerms(positiveEvidenceGoal),
+    requiredExecutableTerms: inferRequiredExecutableTerms(positiveEvidenceGoal),
     forbiddenTextTerms: inferForbiddenTextTerms(evidenceGoal),
     successCriteria: unique(acceptanceCriteria).slice(0, 10),
   };