@lazyingart/agintiflow 0.20.271 → 0.20.273

package/package.json

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

@@ -5306,8 +5306,19 @@ try {
       postMutationVerificationRuntime.testVerificationCommand === postMutationVerifier,
     "a material failed-test repair did not advance directly to its exact retained verifier"
   );
+  const generatedDeckValidatorPath = path.join(
+    tempRoot,
+    "acceptance",
+    "presentation_deck_contract.py"
+  );
+  await fs.mkdir(path.dirname(generatedDeckValidatorPath), { recursive: true });
+  await fs.writeFile(
+    generatedDeckValidatorPath,
+    "raise SystemExit('acceptance fixture')\n",
+    "utf8"
+  );
   const generatedDeckValidator =
-    "python3 /tmp/presentation_deck_contract.py --root .";
+    `python3 ${generatedDeckValidatorPath} --root .`;
   await fs.writeFile(
     path.join(workspace, "build_deck.py"),
     "print('build canonical deck')\n",
@@ -5485,6 +5496,100 @@ try {
       runtime: postProducerRuntime,
     })}`
   );
+  const failedAfterProducerState = structuredClone(staleGeneratedDeckState);
+  failedAfterProducerState.meta.goalContract.taskGoal = failedAfterProducerState.goal;
+  failedAfterProducerState.meta.projectVerification.mutationHistory.splice(1, 0, {
+    revision: 8,
+    toolName: "apply_patch",
+    paths: ["TASK.md"],
+  });
+  failedAfterProducerState.meta.projectVerification.testRuns.push({
+    command: generatedDeckValidator,
+    at: "2026-08-27T19:05:00.000Z",
+    mutationRevision: 10,
+    privateMutationRevision: 0,
+    passed: false,
+    failureEvidenceVersion: 2,
+    failureSignature: "fresh-generated-deck-visible-text",
+    failureSummary: "acceptance failed: deck omits source-grounded phrase: single reader",
+  });
+  await fs.writeFile(
+    path.join(workspace, "TASK.md"),
+    "Treat source_brief.md, measurements.csv, prompt.txt, and TASK.md as immutable.\n",
+    "utf8"
+  );
+  const failedAfterProducerPacket = await buildFailedTestRecoveryPacket(
+    {
+      provider: "deepseek",
+      taskProfile: "slides",
+      commandCwd: workspace,
+      goal: failedAfterProducerState.goal,
+    },
+    failedAfterProducerState
+  );
+  assert(
+    JSON.stringify(failedAfterProducerPacket.repairPaths) ===
+      JSON.stringify(["build_deck.py"]),
+    "a fresh generated-artifact failure dropped its latest mutable producer or retained an explicitly immutable input"
+  );
+  failedAfterProducerState.meta.failedTestRecoveryPacket = {
+    packetVersion: 15,
+    content: failedAfterProducerPacket.content,
+    paths: failedAfterProducerPacket.paths,
+    repairPaths: failedAfterProducerPacket.repairPaths,
+    mutationRevision: 10,
+    failureSignature: "fresh-generated-deck-visible-text",
+    generatedAt: "2026-08-27T19:05:01.000Z",
+  };
+  const failedAfterProducerRuntime = nextStepRuntimeConfig(
+    {
+      provider: "deepseek",
+      taskProfile: "slides",
+      commandCwd: workspace,
+      goal: failedAfterProducerState.goal,
+    },
+    failedAfterProducerState
+  );
+  assert(
+    JSON.stringify(failedAfterProducerRuntime.testFailureRepairContextPaths) ===
+      JSON.stringify(["build_deck.py"]),
+    "failed-test recovery forced immutable evidence reads instead of grounding the canonical producer"
+  );
+  assert(
+    JSON.stringify(failedAfterProducerRuntime.testFailureDiagnosticReadPaths) ===
+      JSON.stringify([generatedDeckValidatorPath]) &&
+      failedAfterProducerRuntime.readOnlyRoots.includes(
+        path.dirname(generatedDeckValidatorPath)
+      ),
+    "an exact external validator from the retained failed command was not exposed through a narrow read-only root"
+  );
+  const consumedExternalValidatorState = structuredClone(failedAfterProducerState);
+  consumedExternalValidatorState.meta.toolLoop =
+    consumedExternalValidatorState.meta.toolLoop || { recent: [] };
+  consumedExternalValidatorState.meta.toolLoop.recent = [
+    ...(consumedExternalValidatorState.meta.toolLoop.recent || []),
+    {
+      toolName: "read_file",
+      path: generatedDeckValidatorPath,
+      ok: true,
+      blocked: false,
+      goalRevision: 13,
+      at: "2026-08-27T19:05:02.000Z",
+    },
+  ];
+  const consumedExternalValidatorRuntime = nextStepRuntimeConfig(
+    {
+      provider: "deepseek",
+      taskProfile: "slides",
+      commandCwd: workspace,
+      goal: consumedExternalValidatorState.goal,
+    },
+    consumedExternalValidatorState
+  );
+  assert(
+    consumedExternalValidatorRuntime.testFailureDiagnosticReadPaths.length === 0,
+    "an exact external validator remained exposed after its bounded read completed"
+  );
   const immutableOnlyRepairState = {
     goal: "Treat service_ctl.py as immutable read-only source evidence and finish from existing results.",
     meta: {

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

@@ -1804,6 +1804,28 @@ sameNames(
   "an unchanged failed-test rerun did not close discovery until a real mutation"
 );
 
+const externalValidatorPath = "/tmp/aginti-acceptance/deck_contract.py";
+const externalDiagnosticFailedTestRepairTools = selectProgressiveTools(allTools, {
+  config: {
+    provider: "deepseek",
+    testFailureRepairActive: true,
+    testFailureRepairMutationRequired: true,
+    testFailureDiagnosticReadPaths: [externalValidatorPath],
+  },
+  goal: "Repair the canonical producer from the exact external acceptance contract.",
+  profile: "slides",
+});
+sameNames(
+  externalDiagnosticFailedTestRepairTools,
+  ["read_file", "apply_patch", "finish"],
+  "a retained external validator was not exposed as one bounded read during mutation-only recovery"
+);
+assertStrict.deepEqual(
+  externalDiagnosticFailedTestRepairTools[0].function.parameters.properties.path.enum,
+  [externalValidatorPath],
+  "the external validator read was not schema-constrained to its exact path"
+);
+
 const failedTestPatchContextTools = selectProgressiveTools(allTools, {
   config: {
     provider: "localllm",

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

@@ -70,6 +70,24 @@ const wrappedImmutableSourceContract = deriveScsTaskContract({
   taskProfile: "slides",
 });
 
+const actionWrappedImmutableSourceContract = deriveScsTaskContract({
+  goal: [
+    "Continue the exact task. Do not",
+    "modify source_brief.md, measurements.csv, prompt.txt, or TASK.md.",
+    "Repair build_deck.py and rebuild output/deck.pptx.",
+  ].join("\n"),
+  taskProfile: "slides",
+});
+
+const pathWrappedImmutableSourceContract = deriveScsTaskContract({
+  goal: [
+    "Continue the exact task. Do not modify",
+    "source_brief.md, measurements.csv, prompt.txt, or TASK.md.",
+    "Repair build_deck.py and rebuild output/deck.pptx.",
+  ].join("\n"),
+  taskProfile: "slides",
+});
+
 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.",
@@ -173,6 +191,16 @@ assert(
   ),
   "an immutable source path leaked into exact output requirements"
 );
+for (const contract of [
+  actionWrappedImmutableSourceContract,
+  pathWrappedImmutableSourceContract,
+]) {
+  assert.deepEqual(
+    contract.excludedOutputPaths.sort(),
+    ["TASK.md", "measurements.csv", "prompt.txt", "source_brief.md"].sort(),
+    "a negative action or its governed path list lost protection across a line wrap"
+  );
+}
 assert(
   recoveryInstructionContract.excludedOutputPaths.includes("resume-after-git-baseline-recovery-dev-prompt.txt") &&
     !recoveryInstructionContract.exactOutputPaths.includes("resume-after-git-baseline-recovery-dev-prompt.txt"),

package/src/agent-runner.js

@@ -4085,6 +4085,7 @@ async function applyContinuationPrompt(state, config, observers) {
       packetVersion: FAILED_TEST_RECOVERY_PACKET_VERSION,
       content: retainedTestEvidence.content,
       paths: retainedTestEvidence.paths,
+      repairPaths: retainedTestEvidence.repairPaths,
       mutationRevision: Number(currentFailure?.mutationRevision || 0),
       failureSignature: String(currentFailure?.failureSignature || ""),
       command: String(currentFailure?.command || ""),
@@ -6624,6 +6625,109 @@ function safeRecoveryEvidencePath(value = "") {
   return PLAIN_TEXT_FILE_EXTENSIONS.has(path.extname(candidate).toLowerCase()) ? candidate : "";
 }
 
+function failedTestMutationRepairPaths(
+  config = {},
+  state = {},
+  testRun = {},
+  excludedPaths = []
+) {
+  const verification = state.meta?.projectVerification || {};
+  const history = Array.isArray(verification.mutationHistory)
+    ? verification.mutationHistory
+    : verification.lastMutation
+      ? [verification.lastMutation]
+      : [];
+  const maximumRevision = Math.max(
+    0,
+    Number(testRun?.mutationRevision ?? verification.mutationRevision ?? 0)
+  );
+  const taskGoal = String(
+    state.meta?.goalContract?.taskGoal || state.goal || config.goal || ""
+  ).trim();
+  const activeTaskHash = taskGoal ? hashForLog(taskGoal) : "";
+  const repairPaths = [];
+  for (const mutation of [...history].reverse()) {
+    if (
+      Number(mutation?.revision || 0) > maximumRevision ||
+      !["apply_patch", "write_file"].includes(String(mutation?.toolName || "")) ||
+      (activeTaskHash && mutation?.taskHash && mutation.taskHash !== activeTaskHash)
+    ) {
+      continue;
+    }
+    for (const candidate of Array.isArray(mutation?.paths) ? mutation.paths : []) {
+      const safePath = safeRecoveryEvidencePath(candidate);
+      if (
+        !safePath ||
+        pathLooksLikeTestSource(safePath) ||
+        isPrivateVerificationEvidencePath(safePath) ||
+        filterExplicitlyExcludedOutputPaths([safePath], excludedPaths).length === 0 ||
+        repairPaths.includes(safePath)
+      ) {
+        continue;
+      }
+      repairPaths.push(safePath);
+      if (repairPaths.length >= 6) return repairPaths;
+    }
+  }
+  return repairPaths;
+}
+
+function failedTestCanonicalRepairPaths(state = {}) {
+  const packet = state.meta?.failedTestRecoveryPacket || {};
+  const preferred = Array.isArray(packet.repairPaths) && packet.repairPaths.length
+    ? packet.repairPaths
+    : packet.paths;
+  return (Array.isArray(preferred) ? preferred : [])
+    .map(safeRecoveryEvidencePath)
+    .filter(Boolean)
+    .filter((item, index, items) => items.indexOf(item) === index);
+}
+
+export function failedTestExternalDiagnosticReadPaths(
+  config = {},
+  state = {},
+  testRun = null
+) {
+  const failure = testRun || currentFailedProjectTest(state)?.test;
+  const command = String(failure?.command || "").trim();
+  if (!command) return [];
+  const commandCwd = path.resolve(
+    config.commandCwd || state.commandCwd || process.cwd()
+  );
+  const candidates = [];
+  for (const token of tokenizeShellWords(command)) {
+    const rawPath = String(token || "").replace(/[;,]+$/g, "").trim();
+    if (!rawPath || !path.isAbsolute(rawPath)) continue;
+    let realPath = "";
+    try {
+      realPath = fsSync.realpathSync(rawPath);
+      const stat = fsSync.statSync(realPath);
+      if (!stat.isFile() || stat.size > 1_000_000) continue;
+    } catch {
+      continue;
+    }
+    const relative = path.relative(commandCwd, realPath);
+    if (!relative.startsWith("..") && !path.isAbsolute(relative)) continue;
+    const normalized = realPath.replace(/\\/g, "/");
+    if (
+      !PLAIN_TEXT_FILE_EXTENSIONS.has(path.extname(normalized).toLowerCase()) ||
+      /(?:secret|credential|password|private[-_]?key|access[-_]?token)/i.test(normalized) ||
+      !(
+        pathLooksLikeTestSource(normalized) ||
+        /(?:^|\/)(?:acceptance|verification)(?:\/|$)|(?:contract|validator)/i.test(
+          normalized
+        )
+      ) ||
+      candidates.includes(realPath)
+    ) {
+      continue;
+    }
+    candidates.push(realPath);
+    if (candidates.length >= 3) break;
+  }
+  return candidates;
+}
+
 function recoveryEvidenceDependencies(sourcePath = "", content = "") {
   const dependencies = [];
   const append = (candidate) => {
@@ -6984,8 +7088,17 @@ export async function buildFailedTestRecoveryPacket(config = {}, state = {}) {
   ]
     .map(safeRecoveryEvidencePath)
     .filter(Boolean);
+  const mutationRepairPaths = failedTestMutationRepairPaths(
+    config,
+    state,
+    testRun,
+    taskContract.excludedOutputPaths || []
+  );
   const mutationEvidencePaths = new Set(
-    (Array.isArray(verification.lastMutation?.paths) ? verification.lastMutation.paths : [])
+    [
+      ...mutationRepairPaths,
+      ...(Array.isArray(verification.lastMutation?.paths) ? verification.lastMutation.paths : []),
+    ]
       .map(safeRecoveryEvidencePath)
       .filter(Boolean)
   );
@@ -7476,8 +7589,33 @@ export async function buildFailedTestRecoveryPacket(config = {}, state = {}) {
     at: new Date().toISOString(),
     focuses: diagnosticFocuses,
   };
+  const evidencePaths = [...seen].filter((item) =>
+    excerpts.some((excerpt) => excerpt.startsWith(`### ${item}\n`))
+  );
+  const diagnosticRepairPaths = diagnosticFocuses
+    .map((focus) => safeRecoveryEvidencePath(focus?.path))
+    .filter(Boolean);
+  const preferredRepairPaths = [
+    ...diagnosticRepairPaths,
+    ...mutationRepairPaths,
+  ]
+    .filter((item, index, items) => items.indexOf(item) === index)
+    .filter((item) => evidencePaths.includes(item));
+  const fallbackRepairPaths = evidencePaths
+    .filter((item) => !pathLooksLikeTestSource(item))
+    .filter(
+      (item) =>
+        filterExplicitlyExcludedOutputPaths(
+          [item],
+          taskContract.excludedOutputPaths || []
+        ).length > 0
+    );
   return {
-    paths: [...seen].filter((item) => excerpts.some((excerpt) => excerpt.startsWith(`### ${item}\n`))),
+    paths: evidencePaths,
+    repairPaths: (preferredRepairPaths.length
+      ? preferredRepairPaths
+      : fallbackRepairPaths
+    ).slice(0, 6),
     content: [
       `Bounded failed-test evidence packet v${FAILED_TEST_RECOVERY_PACKET_VERSION}. These are exact current workspace excerpts selected from the discovered test and its local dependencies. Use them to calculate the producing transformation; do not restart broad discovery.`,
       testRun.command ? `Verification command: ${testRun.command}` : "",
@@ -11359,6 +11497,39 @@ export function nextStepRuntimeConfig(config = {}, state = {}) {
       .slice(0, 8);
     const toolLoop = state.meta?.toolLoop || {};
     const stagnationEpoch = Math.max(0, Number(toolLoop.stagnationEpoch || 0));
+    const externalDiagnosticPaths = failedTestExternalDiagnosticReadPaths(
+      runtimeConfig,
+      state,
+      retainedFailedTest
+    );
+    const consumedExternalDiagnosticPaths = new Set(
+      (Array.isArray(toolLoop.recent) ? toolLoop.recent : [])
+        .filter(
+          (entry) =>
+            entry?.ok === true &&
+            entry?.blocked !== true &&
+            String(entry?.toolName || "") === "read_file" &&
+            Number(entry?.goalRevision || 0) === groundingGoalRevision
+        )
+        .map((entry) => {
+          const rawPath = String(entry?.path || "").trim();
+          return rawPath ? path.resolve(commandCwd, rawPath) : "";
+        })
+        .filter(Boolean)
+    );
+    runtimeConfig.testFailureDiagnosticReadPaths = externalDiagnosticPaths.filter(
+      (candidate) => !consumedExternalDiagnosticPaths.has(candidate)
+    );
+    if (runtimeConfig.testFailureDiagnosticReadPaths.length) {
+      runtimeConfig.readOnlyRoots = [
+        ...(Array.isArray(runtimeConfig.readOnlyRoots)
+          ? runtimeConfig.readOnlyRoots
+          : []),
+        ...runtimeConfig.testFailureDiagnosticReadPaths.map((candidate) =>
+          path.dirname(candidate)
+        ),
+      ].filter((item, index, items) => items.indexOf(item) === index);
+    }
     const currentRecoveryPacket = Boolean(
       state.meta?.failedTestRecoveryPacket &&
         Number(state.meta.failedTestRecoveryPacket.packetVersion || 0) ===
@@ -11676,9 +11847,7 @@ export function nextStepRuntimeConfig(config = {}, state = {}) {
         );
       });
     const recoveryPacketPaths = currentRecoveryPacket
-      ? (Array.isArray(state.meta?.failedTestRecoveryPacket?.paths)
-          ? state.meta.failedTestRecoveryPacket.paths
-          : [])
+      ? failedTestCanonicalRepairPaths(state)
           .map(safeRecoveryEvidencePath)
           .filter(Boolean)
           .filter((item, index, items) => items.indexOf(item) === index)
@@ -13420,9 +13589,7 @@ function requiredDeclarationIdentitiesForPatch(state = {}, targetPath = "") {
 }
 
 function requiredSymbolRepairPath(state = {}, owner = "") {
-  const sourcePaths = (state.meta?.failedTestRecoveryPacket?.paths || [])
-    .map((item) => safeRecoveryEvidencePath(item))
-    .filter(Boolean)
+  const sourcePaths = failedTestCanonicalRepairPaths(state)
     .filter((item) => !/(?:^|\/)tests?(?:\/|$)/i.test(item));
   const ownerBasename = String(owner || "")
     .split(".")
@@ -16542,7 +16709,7 @@ async function recordToolContractViolation({
   const completedRequestedPaths = requestedCalls
     .map((call) => call.path)
     .filter((item) => item && completedArtifacts.has(item));
-  const repairPaths = (state.meta?.failedTestRecoveryPacket?.paths || [])
+  const repairPaths = failedTestCanonicalRepairPaths(state)
     .map((item) => String(item || "").replace(/\\/g, "/"))
     .filter((item) => item && !/(?:^|\/)tests?(?:\/|$)/i.test(item))
     .slice(0, 6);
@@ -17423,9 +17590,7 @@ export function recoverUnavailableVerificationRerunAsCanonicalRead(
     ...(Array.isArray(config.testFailureRepairPatchTargets)
       ? config.testFailureRepairPatchTargets.map((target) => target?.path)
       : []),
-    ...(Array.isArray(state.meta?.failedTestRecoveryPacket?.paths)
-      ? state.meta.failedTestRecoveryPacket.paths
-      : []),
+    ...failedTestCanonicalRepairPaths(state),
   ]
     .map(safeRecoveryEvidencePath)
     .filter(Boolean)
@@ -19210,6 +19375,7 @@ async function runAgentOnceUnlocked(config) {
               packetVersion: FAILED_TEST_RECOVERY_PACKET_VERSION,
               content: recoveryEvidence.content,
               paths: recoveryEvidence.paths,
+              repairPaths: recoveryEvidence.repairPaths,
               mutationRevision: Number(currentFailure.mutationRevision || 0),
               failureSignature: String(currentFailure.failureSignature || ""),
               command: String(currentFailure.command || ""),
@@ -20488,6 +20654,7 @@ async function runAgentOnceUnlocked(config) {
             packetVersion: FAILED_TEST_RECOVERY_PACKET_VERSION,
             content: recoveryEvidence.content,
             paths: recoveryEvidence.paths,
+            repairPaths: recoveryEvidence.repairPaths,
             mutationRevision: Number(currentFailure.mutationRevision || 0),
             failureSignature: String(currentFailure.failureSignature || ""),
             command: String(currentFailure.command || ""),

package/src/progressive-tool-selection.js

@@ -733,6 +733,8 @@ function constrainReadFilePaths(tool, paths, phase) {
           ? "Exact canonical project file selected from current task evidence for the required fresh correction."
         : phase === "failed-test-evidence-refresh"
           ? "Exact unread workspace-relative path retained by the current failed-test evidence packet."
+          : phase === "failed-test-diagnostic-read"
+            ? "Exact read-only acceptance or validator source named by the retained failed verification command."
           : "Exact workspace-relative path discovered by inspect_project.",
   };
   return {
@@ -746,6 +748,8 @@ function constrainReadFilePaths(tool, paths, phase) {
             ? "Read one exact canonical project file before the required fresh source correction. Tests, Git actions, and finish remain unavailable until a material patch advances the project mutation revision."
           : phase === "failed-test-evidence-refresh"
             ? "Read one exact unread source or acceptance-test file from the current failed-test evidence packet. Each packet path is exposed at most once before mutation-only recovery resumes."
+            : phase === "failed-test-diagnostic-read"
+              ? "Read one exact existing external acceptance or validator file from the retained failed command. This path is read-only and no neighboring external files are exposed."
           : phase === "read-instructions"
           ? "Read one exact project instruction file discovered by inspect_project before repository mutation or validation commands are enabled."
           : phase === "read-tests"
@@ -2017,24 +2021,36 @@ export function selectProgressiveTools(
           .filter((item, index, items) => items.indexOf(item) === index)
           .slice(0, 1)
       : [];
-    const boundedRepairReadPaths = repairContextPaths.length
-      ? repairContextPaths
-      : optionalRepairRereadPaths;
+    const diagnosticReadPaths = Array.isArray(config.testFailureDiagnosticReadPaths)
+      ? config.testFailureDiagnosticReadPaths
+          .map((item) => String(item || "").replace(/\\/g, "/").trim())
+          .filter(Boolean)
+          .filter((item, index, items) => items.indexOf(item) === index)
+          .slice(0, 3)
+      : [];
+    const boundedRepairReadPaths = [
+      ...diagnosticReadPaths,
+      ...(repairContextPaths.length ? repairContextPaths : optionalRepairRereadPaths),
+    ]
+      .filter((item, index, items) => items.indexOf(item) === index)
+      .slice(0, 8);
     const constrainedRepairRead = boundedRepairReadPaths.length
       ? constrainReadFilePaths(
           available.get("read_file"),
           boundedRepairReadPaths,
-          repairContextPaths.length
-            ? "failed-test-evidence-refresh"
-            : "deepseek-failed-test-source-reread"
+          diagnosticReadPaths.length
+            ? "failed-test-diagnostic-read"
+            : repairContextPaths.length
+              ? "failed-test-evidence-refresh"
+              : "deepseek-failed-test-source-reread"
         )
       : available.get("read_file");
     const toolNames = config.testFailureRepairMutationRequired === true
       ? [
-          ...(config.testFailureRepairNeedsPatchContext === true
-            ? ["read_file", ...(repairContextPaths.length ? [] : ["search_files"])]
-            : optionalRepairRereadPaths.length
-              ? ["read_file"]
+          ...(boundedRepairReadPaths.length
+            ? ["read_file"]
+            : config.testFailureRepairNeedsPatchContext === true
+              ? ["read_file", "search_files"]
               : []),
           "apply_patch",
           ...(constrainedInstructionCreate ? ["write_file"] : []),

package/src/scs-evidence.js

@@ -542,12 +542,26 @@ export function filterExplicitlyExcludedOutputPaths(paths = [], exclusions = [])
 }
 
 export function inferExplicitlyExcludedOutputPaths(goal = "") {
+  const extensionPattern = "md|txt|json|jsonl|ndjson|ya?ml|html|css|js|ts|tsx|jsx|py|sh|csv|tex|svg|png|jpe?g|webp|mp4|mov|pdf|docx";
   // Preserve coordinated path lists that wrap after a comma. Prompt and task
   // files commonly format "do not modify a, b,\nc, or d" across lines; splitting
   // that text first drops the governing negative action from the continuation.
-  const source = String(goal || "").replace(/([,，、])\s*\r?\n\s*/gu, "$1 ");
+  const negativePrefix = "(?:do\\s+not|don't|dont|must\\s+not|should\\s+not|never)";
+  const negativeAction = "(?:run|rerun|re-run|execut(?:e|ed|ing)|creat(?:e|ed|ing)|recreat(?:e|ed|ing)|writ(?:e|ten|ing)|generat(?:e|ed|ing)|sav(?:e|ed|ing)|output|touch|modif(?:y|ied|ying)|edit(?:ed|ing)?|stage|commit)";
+  const wrappedNegativeAction = new RegExp(
+    `(\\b${negativePrefix}\\b)\\s*\\r?\\n\\s*(?=${negativeAction}\\b)`,
+    "giu"
+  );
+  const wrappedNegativePath = new RegExp(
+    `(\\b${negativePrefix}\\b[^.!?。！？;；\\n]{0,180}\\b${negativeAction}\\b)\\s*\\r?\\n\\s*` +
+      `(?=\\S{1,260}\\.(?:${extensionPattern})\\b)`,
+    "giu"
+  );
+  const source = String(goal || "")
+    .replace(/([,，、])\s*\r?\n\s*/gu, "$1 ")
+    .replace(wrappedNegativeAction, "$1 ")
+    .replace(wrappedNegativePath, "$1 ");
   if (!source.trim()) return [];
-  const extensionPattern = "md|txt|json|jsonl|ndjson|ya?ml|html|css|js|ts|tsx|jsx|py|sh|csv|tex|svg|png|jpe?g|webp|mp4|mov|pdf|docx";
   const pathPattern = new RegExp(
     '((?:~|\\.{1,2}|/|[A-Za-z0-9_\\-\\u4e00-\\u9fff])[\\w./~\\-\\u4e00-\\u9fff]{0,260}\\.(?:' +
       extensionPattern +