@lazyingart/agintiflow 0.20.273 → 0.20.275

package/package.json

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

@@ -6483,6 +6483,12 @@ try {
     }),
     "a direct clean-worktree assertion was not classified when the traceback omitted the Git helper call"
   );
+  assert(
+    failedTestRequiresCleanRepositoryState({
+      failureSummary: "acceptance failed: repository is not clean",
+    }),
+    "a concise authoritative acceptance failure did not activate repository-state repair"
+  );
   assert(
     !failedTestRequiresCleanRepositoryState({
       failureSummary: "The generated prose says the repository worktree is not clean.",
@@ -9789,6 +9795,20 @@ try {
     !shouldReviewToolResult(malformedReadOnlyCheck, { meta: {} }),
     "SCS should let the normal agent loop repair simple shell quoting mistakes"
   );
+  const prospectivePatchSyntaxCorrection = {
+    toolName: "apply_patch",
+    ok: false,
+    blocked: false,
+    recoverable: true,
+    stopRun: false,
+    category: "python-syntax-regression",
+    error: "Exact Python patch failed prospective syntax validation.",
+    diagnosticHint: "SyntaxError: unterminated string literal",
+  };
+  assert(
+    !shouldReviewToolResult(prospectivePatchSyntaxCorrection, { meta: {} }),
+    "SCS replanned instead of letting the agent correct a deterministic prospective patch rejection"
+  );
   const boundedSearchRecovery = {
     toolName: "run_command",
     ok: false,

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

@@ -1826,6 +1826,28 @@ assertStrict.deepEqual(
   "the external validator read was not schema-constrained to its exact path"
 );
 
+const canonicalRepairPathAliasTools = selectProgressiveTools(allTools, {
+  config: {
+    provider: "deepseek",
+    commandCwd: "/tmp/aginti-canonical-repair",
+    testFailureRepairActive: true,
+    testFailureRepairMutationRequired: true,
+    testFailureRepairOptionalRereadPaths: ["build_deck.py"],
+  },
+  goal: "Correct the canonical producer after a prospective patch rejection.",
+  profile: "slides",
+});
+sameNames(
+  canonicalRepairPathAliasTools,
+  ["read_file", "apply_patch", "finish"],
+  "a canonical repair reread did not preserve its bounded tool surface"
+);
+assertStrict.deepEqual(
+  canonicalRepairPathAliasTools[0].function.parameters.properties.path.enum,
+  ["build_deck.py", "/tmp/aginti-canonical-repair/build_deck.py"],
+  "the exact in-workspace absolute alias was not accepted for the canonical repair path"
+);
+
 const failedTestPatchContextTools = selectProgressiveTools(allTools, {
   config: {
     provider: "localllm",
@@ -1986,6 +2008,54 @@ assert(
   ),
   "repository-state repair did not explain the bounded Git workflow"
 );
+const conciseRepositoryStateRepairRuntime = nextStepRuntimeConfig(
+  { provider: "deepseek", taskProfile: "slides" },
+  {
+    meta: {
+      projectVerification: {
+        mutationRevision: 18,
+        testRuns: [{
+          command: "python acceptance.py --root .",
+          mutationRevision: 18,
+          passed: false,
+          failureEvidenceVersion: 2,
+          failureSignature: "concise-repository-state-gate",
+          failureSummary: "acceptance failed: repository is not clean",
+        }],
+      },
+      failedTestRecoveryPacket: {
+        packetVersion: 15,
+        mutationRevision: 18,
+        failureSignature: "concise-repository-state-gate",
+        content: "Retained canonical source evidence from the prior content failure.",
+      },
+      toolLoop: {
+        stagnationEpoch: 4,
+        recent: [],
+      },
+    },
+    messages: [],
+  }
+);
+assertStrict.equal(
+  conciseRepositoryStateRepairRuntime.testFailureRepositoryStateRepair,
+  true,
+  "a concise acceptance failure remained in canonical-source repair mode"
+);
+assertStrict.equal(
+  conciseRepositoryStateRepairRuntime.testFailureRepairMutationRequired,
+  false,
+  "stale retained source evidence overrode a clean-repository repair gate"
+);
+sameNames(
+  selectProgressiveTools(allTools, {
+    config: conciseRepositoryStateRepairRuntime,
+    goal: "Commit the accepted presentation and leave the repository clean.",
+    profile: "slides",
+  }),
+  ["run_command", "finish"],
+  "a concise clean-repository acceptance failure exposed content mutation tools"
+);
 const taskOwnedRepositoryState = {
   meta: {
     goalContract: { revision: 6 },

package/src/agent-runner.js

@@ -6306,6 +6306,9 @@ export function failedTestRequiresCleanRepositoryState(testRun = {}) {
   const directCleanStateAssertion =
     /(?:assertionerror|assert(?:ion)?(?:\s+failed)?)[^.!;]{0,200}(?:(?:project|repository)\s+)?(?:work\s*tree|worktree|repository)[^.!;]{0,80}(?:is\s+not\s+clean|must\s+be\s+clean|expected\s+(?:to\s+be\s+)?clean)\b/i.test(summary);
   if (directCleanStateAssertion) return true;
+  const authoritativeCleanStateFailure =
+    /(?:^|\b)(?:acceptance|validation|verification|contract|test|check)\s+failed\s*:[^.!;]{0,200}(?:(?:project|repository)\s+)?(?:work\s*tree|worktree|repository)[^.!;]{0,80}(?:is\s+not\s+clean|must\s+be\s+clean|expected\s+(?:to\s+be\s+)?clean)\b/i.test(summary);
+  if (authoritativeCleanStateFailure) return true;
   const invokesShortStatus =
     /git[a-z_]*\s*\([^)]*["']status["'][^)]*(?:["']--short["']|["']--porcelain(?:=[^"']+)?["'])[^)]*\)/i.test(summary) ||
     /\bgit\s+status\s+(?:--short|--porcelain(?:=\S+)?)\b/i.test(summary);

package/src/progressive-tool-selection.js

@@ -1,3 +1,4 @@
+import path from "node:path";
 import {
   hasLocalResearchWorkspaceIntent,
   shouldStartWithDeepResearch,
@@ -772,6 +773,25 @@ function constrainReadFilePaths(tool, paths, phase) {
   };
 }
 
+function exactWorkspacePathAliases(paths = [], commandCwd = "") {
+  const workspaceRoot = String(commandCwd || "").trim()
+    ? path.resolve(String(commandCwd))
+    : "";
+  const aliases = [];
+  for (const item of paths) {
+    const normalized = String(item || "").replace(/\\/g, "/").trim();
+    if (!normalized) continue;
+    aliases.push(normalized);
+    if (!workspaceRoot || path.isAbsolute(normalized)) continue;
+    const absolute = path.resolve(workspaceRoot, normalized);
+    const relative = path.relative(workspaceRoot, absolute);
+    if (relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative))) {
+      aliases.push(absolute.replace(/\\/g, "/"));
+    }
+  }
+  return aliases.filter((item, index, items) => items.indexOf(item) === index);
+}
+
 function escapeRegex(value = "") {
   return String(value).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
@@ -2028,11 +2048,13 @@ export function selectProgressiveTools(
           .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)
+    const boundedRepairReadPaths = exactWorkspacePathAliases(
+      [
+        ...diagnosticReadPaths,
+        ...(repairContextPaths.length ? repairContextPaths : optionalRepairRereadPaths),
+      ],
+      config.commandCwd
+    )
       .slice(0, 8);
     const constrainedRepairRead = boundedRepairReadPaths.length
       ? constrainReadFilePaths(

package/src/scs-controller.js

@@ -1156,10 +1156,28 @@ export function shouldRequestScsReplan(decision = {}) {
   return ["rethink_plan", "reject_phase", "finish_rejected"].includes(String(decision?.decision || ""));
 }
 
+export function isRecoverablePatchCorrectionResult(toolResult = {}) {
+  if (
+    String(toolResult?.toolName || "") !== "apply_patch" ||
+    toolResult?.ok !== false ||
+    toolResult?.recoverable !== true ||
+    toolResult?.blocked === true ||
+    toolResult?.stopRun === true
+  ) {
+    return false;
+  }
+  return new Set([
+    "ambiguous-declaration-token-patch",
+    "ambiguous-python-main-guard-patch",
+    "python-syntax-regression",
+  ]).has(String(toolResult?.category || ""));
+}
+
 export function shouldReviewToolResult(toolResult, state = {}) {
   if (!toolResult || toolResult.done) return false;
   if (toolResult.permissionAdvice?.autoRecover) return false;
   if (isRecoverableShellToolResult(toolResult)) return false;
+  if (isRecoverablePatchCorrectionResult(toolResult)) return false;
   if (toolResult.ok === false || toolResult.blocked || toolResult.error || toolResult.reason) return true;
   if (isSuspiciousBroadBrowserToolResult(toolResult)) return true;
   // A later successful call is progress, even when another call using the same