@lazyingart/agintiflow 0.20.324 → 0.20.325

package/package.json

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

@@ -80,6 +80,7 @@ import {
   recordAlreadyCommittedRepositoryRepair,
   recordDurableEvidenceCategories,
   recordProjectVerificationOutcome,
+  recordFailedCommandAttempt,
   repositoryStateInspectionCommand,
   recordExactOutputProgress,
   recordStaticDiscoveryProgress,
@@ -94,6 +95,7 @@ import {
   forbiddenCurrentTestRerunBlock,
   unchangedFailedTestRerunBlock,
   repeatedNoProgressToolBlock,
+  runCommandResultHasDurableProgress,
   redundantCadValidationAliasPatchBlock,
   regressiveInversePatchBlock,
   repeatedSuccessfulMutationBlock,
@@ -11159,6 +11161,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/src/agent-runner.js

@@ -10956,11 +10956,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 +10972,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 +11212,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) {
@@ -19847,6 +19920,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) {

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}`,
   };
 }