@lazyingart/agintiflow 0.20.270 → 0.20.272

package/package.json

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

@@ -5485,6 +5485,65 @@ 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"
+  );
   const immutableOnlyRepairState = {
     goal: "Treat service_ctl.py as immutable read-only source evidence and finish from existing results.",
     meta: {
@@ -6265,6 +6324,22 @@ try {
     })?.category === "repeated-no-progress-call",
     "a third identical unchanged shell probe was not blocked"
   );
+  assert(
+    repeatedNoProgressToolBlock(repeatedProbeState, "run_command", repeatedProbeArgs, {
+      commandCwd: workspace,
+      generatedArtifactProducerPending: true,
+      generatedArtifactProducerCommand: repeatedProbeArgs.command,
+    }) === null,
+    "the exact authoritative generated-artifact producer remained blocked by stale no-progress history"
+  );
+  assert(
+    repeatedNoProgressToolBlock(repeatedProbeState, "run_command", repeatedProbeArgs, {
+      commandCwd: workspace,
+      generatedArtifactProducerPending: true,
+      generatedArtifactProducerCommand: "python3 build_deck.py",
+    })?.category === "repeated-no-progress-call",
+    "a mismatched generated-artifact producer disabled the ordinary no-progress guard"
+  );
   const repeatedFailureState = {
     meta: {
       toolLoop: {

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

@@ -1685,7 +1685,10 @@ assert(
   "a pending exact verifier did not activate the constrained project-command phase"
 );
 const exactVerifierTools = selectProgressiveTools(allTools, {
-  config: exactVerifierRuntime,
+  config: {
+    ...exactVerifierRuntime,
+    convergenceSuppressedToolNames: ["run_command"],
+  },
   goal: `Run ${exactVerifier}.`,
   profile: "security",
 });
@@ -1754,6 +1757,7 @@ const generatedArtifactProducerTools = selectProgressiveTools(allTools, {
     testFailureRepairMutationRequired: true,
     generatedArtifactProducerPending: true,
     generatedArtifactProducerCommand: "python3 build_deck.py",
+    convergenceSuppressedToolNames: ["run_command"],
   },
   goal: "Rebuild the generated presentation before rerunning its validator.",
   profile: "slides",
@@ -1768,6 +1772,22 @@ assertStrict.deepEqual(
   ["python3 build_deck.py"],
   "the generated-artifact producer command was not schema-constrained"
 );
+const disabledGeneratedArtifactProducerTools = selectProgressiveTools(allTools, {
+  config: {
+    provider: "localllm",
+    allowShellTool: false,
+    generatedArtifactProducerPending: true,
+    generatedArtifactProducerCommand: "python3 build_deck.py",
+    convergenceSuppressedToolNames: ["run_command"],
+  },
+  goal: "Rebuild the generated presentation.",
+  profile: "slides",
+});
+sameNames(
+  disabledGeneratedArtifactProducerTools,
+  ["finish"],
+  "an authoritative producer phase bypassed an explicit shell capability disable"
+);
 
 const mutationOnlyFailedTestRepairTools = selectProgressiveTools(allTools, {
   config: {
@@ -3523,6 +3543,7 @@ const pendingTestTools = selectProgressiveTools(allTools, {
     provider: "localllm",
     testVerificationPending: true,
     testVerificationCommand: "python -m unittest discover -s tests -v",
+    convergenceSuppressedToolNames: ["run_command"],
   },
   goal: "Verify the canonical mutation.",
   profile: "data",

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,64 @@ 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);
+}
+
 function recoveryEvidenceDependencies(sourcePath = "", content = "") {
   const dependencies = [];
   const append = (candidate) => {
@@ -6984,8 +7043,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 +7544,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}` : "",
@@ -7841,6 +7934,23 @@ function noProgressOutcomeFingerprint(toolResult = {}) {
 
 export function repeatedNoProgressToolBlock(state, toolName, args = {}, config = {}) {
   if (toolName !== "run_command" || expectedRepeatedObservationCommand(args.command)) return null;
+  const requestedCommand = projectTestCommandKey(
+    normalizeLeadingWorkspaceCd(args.command, config)
+  );
+  const pendingProducerCommand = projectTestCommandKey(
+    normalizeLeadingWorkspaceCd(config.generatedArtifactProducerCommand, config)
+  );
+  if (
+    config.generatedArtifactProducerPending === true &&
+    requestedCommand &&
+    requestedCommand === pendingProducerCommand
+  ) {
+    // A persisted session can contain no-progress history from a runtime that
+    // did not yet credit generated-artifact rebuilds as mutations. The current
+    // exact producer contract is authoritative and gets one executable route;
+    // unrelated repeated probes remain guarded below.
+    return null;
+  }
   const toolLoop = state.meta?.toolLoop || {};
   const signature = staticToolCallSignature(toolName, args || {}, {
     commandCwd: config.commandCwd,
@@ -11659,9 +11769,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)
@@ -13403,9 +13511,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(".")
@@ -16525,7 +16631,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);
@@ -17406,9 +17512,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)
@@ -19193,6 +19297,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 || ""),
@@ -20471,6 +20576,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

@@ -1938,7 +1938,10 @@ export function selectProgressiveTools(
   }
 
   if (config.generatedArtifactProducerPending === true) {
-    const available = new Map(enabled.map(({ name, tool }) => [name, tool]));
+    // An authoritative producer phase supersedes a stale convergence marker.
+    // Keep explicit capability disables effective by selecting from the real
+    // enabled baseline rather than from the convergence-pruned surface.
+    const available = new Map(baselineEnabled.map(({ name, tool }) => [name, tool]));
     const producerCommand = constrainRunCommand(
       available.get("run_command"),
       config.generatedArtifactProducerCommand,
@@ -1954,8 +1957,11 @@ export function selectProgressiveTools(
       typeof config.testFailureStalemateCommand === "string" &&
       config.testFailureStalemateCommand.trim()
     ) {
+      const mandatoryAvailable = new Map(
+        baselineEnabled.map(({ name, tool }) => [name, tool])
+      );
       const verificationCommand = constrainRunCommand(
-        available.get("run_command"),
+        mandatoryAvailable.get("run_command"),
         config.testFailureStalemateCommand,
         "Run this exact retained failing verifier once to refresh stale evidence after repeated semantic repair rejections. This is a bounded stalemate escape hatch, not permission to rerun arbitrary commands or loop unchanged tests."
       );
@@ -2053,7 +2059,7 @@ export function selectProgressiveTools(
   }
 
   if (config.requiredProjectCommandPending === true) {
-    const available = new Map(enabled.map(({ name, tool }) => [name, tool]));
+    const available = new Map(baselineEnabled.map(({ name, tool }) => [name, tool]));
     const requiredCommand = constrainRunCommand(
       available.get("run_command"),
       config.requiredProjectCommand,
@@ -2063,7 +2069,7 @@ export function selectProgressiveTools(
   }
 
   if (config.testVerificationPending === true) {
-    const available = new Map(enabled.map(({ name, tool }) => [name, tool]));
+    const available = new Map(baselineEnabled.map(({ name, tool }) => [name, tool]));
     const verificationCommand = constrainRunCommand(
       available.get("run_command"),
       config.testVerificationCommand,

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 +