@lazyingart/agintiflow 0.20.322 → 0.20.324

package/package.json

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

@@ -11030,6 +11030,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,
@@ -11089,6 +11145,20 @@ try {
     })?.category === "repeated-no-progress-call",
     "a third identical failed shell command was not blocked"
   );
+  const repeatedChangingFailureState = structuredClone(repeatedFailureState);
+  repeatedChangingFailureState.meta.toolLoop.recent[0].outcomeFingerprint =
+    "failure-with-first-dynamic-log";
+  repeatedChangingFailureState.meta.toolLoop.recent[1].outcomeFingerprint =
+    "failure-with-second-dynamic-log";
+  assert(
+    repeatedNoProgressToolBlock(
+      repeatedChangingFailureState,
+      "run_command",
+      repeatedProbeArgs,
+      { commandCwd: workspace }
+    )?.category === "repeated-no-progress-call",
+    "dynamic failure output allowed an unchanged failing command to loop"
+  );
   const newlyAuthoritativeVerificationState = structuredClone(repeatedFailureState);
   newlyAuthoritativeVerificationState.meta.projectVerification = {
     mutationRevision: 6,

package/src/agent-runner.js

@@ -11017,13 +11017,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)
   );
@@ -11094,6 +11164,26 @@ export function repeatedNoProgressToolBlock(state, toolName, args = {}, config =
       Boolean(entry?.outcomeFingerprint)
   );
   if (matches.length < 2) return null;
+  const repeatedFailures = matches.slice(-2).every((entry) => entry?.ok === false);
+  if (repeatedFailures) {
+    return {
+      reason:
+        "The same command 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 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.",
+        ],
+      },
+    };
+  }
   const recentFingerprints = matches.slice(-2).map((entry) => entry.outcomeFingerprint);
   if (new Set(recentFingerprints).size !== 1) return null;
   return {
@@ -19731,6 +19821,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 &&
@@ -21408,6 +21503,8 @@ async function executeTool(browserState, toolCall, snapshot, config, store, obse
             blocked: true,
             reason: normalized.reason,
             toolName: "send_to_canvas",
+            args: safeArgs,
+            category: "canvas",
           };
         }
 
@@ -21430,6 +21527,8 @@ async function executeTool(browserState, toolCall, snapshot, config, store, obse
             blocked: true,
             reason: persisted.reason,
             toolName: "send_to_canvas",
+            args: safeArgs,
+            category: "canvas",
           };
         }