@lazyingart/agintiflow 0.20.323 → 0.20.325

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lazyingart/agintiflow",
-  "version": "0.20.323",
+  "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,
@@ -11030,6 +11032,62 @@ try {
     })?.category === "repeated-no-progress-call",
     "a third identical unchanged shell probe was not blocked"
   );
+  const missingCanvasPath = path.join(workspace, "report.pdf");
+  const repeatedCanvasState = {
+    meta: {
+      toolLoop: {
+        stagnationEpoch: 4,
+        recent: [
+          {
+            toolName: "send_to_canvas",
+            ok: false,
+            blocked: true,
+            stagnationEpoch: 4,
+            error: `Canvas path does not exist or is not a file: ${missingCanvasPath}`,
+          },
+          {
+            toolName: "send_to_canvas",
+            ok: false,
+            blocked: true,
+            stagnationEpoch: 4,
+            error: `Canvas path does not exist or is not a file: ${missingCanvasPath}`,
+          },
+        ],
+      },
+    },
+  };
+  assert(
+    repeatedNoProgressToolBlock(
+      repeatedCanvasState,
+      "send_to_canvas",
+      {
+        path: missingCanvasPath,
+        title: "Changed title",
+        note: "A cosmetically different note",
+      },
+      { commandCwd: workspace }
+    )?.category === "repeated-no-progress-call",
+    "changed canvas metadata allowed the same missing artifact target to loop"
+  );
+  assert(
+    repeatedNoProgressToolBlock(
+      repeatedCanvasState,
+      "send_to_canvas",
+      { path: path.join(workspace, "different.pdf"), title: "Different artifact" },
+      { commandCwd: workspace }
+    ) === null,
+    "a different canvas artifact was blocked by unrelated missing-path history"
+  );
+  await fs.writeFile(missingCanvasPath, "%PDF-1.4\n", "utf8");
+  assert(
+    repeatedNoProgressToolBlock(
+      repeatedCanvasState,
+      "send_to_canvas",
+      { path: missingCanvasPath, title: "Now available" },
+      { commandCwd: workspace }
+    ) === null,
+    "a canvas artifact created after prior failures remained blocked"
+  );
   assert(
     repeatedNoProgressToolBlock(repeatedProbeState, "run_command", repeatedProbeArgs, {
       commandCwd: workspace,
@@ -11103,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;
@@ -11017,13 +11066,83 @@ function noProgressOutcomeFingerprint(toolResult = {}) {
   }));
 }
 
+function canvasNoProgressTarget(args = {}, config = {}) {
+  const rawPath = String(args?.path || "").trim();
+  if (rawPath) {
+    const normalized = comparableOutputPath(
+      rawPath,
+      config.commandCwd || process.cwd()
+    );
+    return `path:${normalized}`;
+  }
+  const content = String(args?.content || "");
+  if (content) return `content:${hashForLog(content)}`;
+  return "";
+}
+
+function canvasNoProgressTargetFromEntry(entry = {}, config = {}) {
+  if (entry?.semanticSignature) return String(entry.semanticSignature);
+  const error = String(entry?.error || "");
+  const match = error.match(/Canvas path does not exist or is not a file:\s*(.+)$/i);
+  if (!match?.[1]) return "";
+  return `path:${comparableOutputPath(
+    match[1].trim(),
+    config.commandCwd || process.cwd()
+  )}`;
+}
+
+function canvasTargetExists(args = {}, config = {}) {
+  const rawPath = String(args?.path || "").trim();
+  if (!rawPath) return false;
+  const candidates = path.isAbsolute(rawPath)
+    ? [rawPath]
+    : [path.resolve(config.commandCwd || process.cwd(), rawPath)];
+  return candidates.some((candidate) => {
+    try {
+      return fsSync.statSync(candidate).isFile();
+    } catch {
+      return false;
+    }
+  });
+}
+
 export function repeatedNoProgressToolBlock(state, toolName, args = {}, config = {}) {
-  if (toolName !== "run_command" || expectedRepeatedObservationCommand(args.command)) return null;
   const toolLoop = state.meta?.toolLoop || {};
+  const stagnationEpoch = Math.max(0, Number(toolLoop.stagnationEpoch || 0));
+  if (toolName === "send_to_canvas") {
+    if (canvasTargetExists(args, config)) return null;
+    const target = canvasNoProgressTarget(args, config);
+    if (!target) return null;
+    const matches = (Array.isArray(toolLoop.recent) ? toolLoop.recent : []).filter(
+      (entry) =>
+        entry?.toolName === "send_to_canvas" &&
+        entry?.ok === false &&
+        Number(entry?.stagnationEpoch || 0) === stagnationEpoch &&
+        canvasNoProgressTargetFromEntry(entry, config) === target
+    );
+    if (matches.length < 2) return null;
+    return {
+      reason:
+        "The same canvas artifact target already failed twice without an intervening file, artifact, browser, or task-state change.",
+      category: "repeated-no-progress-call",
+      permissionAdvice: {
+        category: "repeated-no-progress-call",
+        autoRecover: true,
+        summary: "This is a missing-artifact convergence guard, not a permission blocker.",
+        instruction:
+          "Do not retry the same missing path with a different title or note. Create or repair the exact artifact with an offered tool, return its durable source path for host processing, or finish with the concrete missing-artifact blocker.",
+        options: [
+          "Create the exact file before sending it to canvas.",
+          "Return a complete editable source so the host can compile the derived artifact.",
+          "Finish with the exact missing path when no enabled tool can create it.",
+        ],
+      },
+    };
+  }
+  if (toolName !== "run_command" || expectedRepeatedObservationCommand(args.command)) return null;
   const signature = staticToolCallSignature(toolName, args || {}, {
     commandCwd: config.commandCwd,
   });
-  const stagnationEpoch = Math.max(0, Number(toolLoop.stagnationEpoch || 0));
   const requestedCommand = projectTestCommandKey(
     normalizeLeadingWorkspaceCd(args.command, config)
   );
@@ -11093,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) {
@@ -19751,6 +19894,11 @@ async function applyToolLoopGuard(state, toolResult, store, observers, config =
     staticDiscovery: isStaticDiscoveryToolResult(toolResult),
     successfulMutation: successfulToolStateProgress(toolResult),
     noProgressProbe: Boolean(outcomeFingerprint),
+    semanticSignature:
+      toolResult.toolName === "send_to_canvas"
+        ? canvasNoProgressTarget(toolResult.args || {}, config) ||
+          canvasNoProgressTargetFromEntry(toolResult, config)
+        : "",
     generatedArtifactProducerAttempt: Boolean(
       toolResult.toolName === "run_command" &&
         config.generatedArtifactProducerPending === true &&
@@ -19772,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) {
@@ -21428,6 +21577,8 @@ async function executeTool(browserState, toolCall, snapshot, config, store, obse
             blocked: true,
             reason: normalized.reason,
             toolName: "send_to_canvas",
+            args: safeArgs,
+            category: "canvas",
           };
         }
 
@@ -21450,6 +21601,8 @@ async function executeTool(browserState, toolCall, snapshot, config, store, obse
             blocked: true,
             reason: persisted.reason,
             toolName: "send_to_canvas",
+            args: safeArgs,
+            category: "canvas",
           };
         }
 

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