@lazyingart/agintiflow 0.20.239 → 0.20.240

package/package.json

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

@@ -2302,6 +2302,112 @@ try {
     shellMutationState.meta.projectVerification?.mutationRevision === 1,
     "metadata-only Git chain with observational output invalidated current verification"
   );
+  assert(
+    classifyCommand("md5sum output/report.pdf").writesWorkspace === false &&
+      classifyCommand("md5sum -c .aginti/verification/source-hashes.txt").writesWorkspace === false &&
+      classifyCommand("diff .aginti/verification/run-1.txt .aginti/verification/run-2.txt").writesWorkspace === false,
+    "checksum or diff evidence probes were not classified as read-only"
+  );
+  const privateEvidenceState = {
+    meta: {
+      goalContract: { revision: 1 },
+      projectVerification: { requiredCommands: ["bash build.sh"] },
+    },
+  };
+  const privateEvidenceBuild = {
+    toolName: "run_command",
+    ok: true,
+    exitCode: 0,
+    args: { command: "bash build.sh" },
+    stdout: "build complete\n",
+    stderr: "",
+  };
+  recordProjectVerificationOutcome(privateEvidenceState, privateEvidenceBuild, {
+    commandCwd: workspace,
+    taskProfile: "writing",
+    allowShellTool: true,
+    sandboxMode: "host",
+  });
+  const privateEvidenceRevision =
+    privateEvidenceState.meta.projectVerification?.mutationRevision;
+  const privateEvidenceCommand = {
+    toolName: "run_command",
+    ok: true,
+    exitCode: 0,
+    args: {
+      command:
+        "md5sum output/report.pdf > .aginti/verification/hashes-final.txt && cat .aginti/verification/hashes-final.txt && diff .aginti/verification/hashes-run1.txt .aginti/verification/hashes-final.txt && md5sum -c .aginti/verification/source-hashes.txt && git status --porcelain",
+    },
+    stdout: "MATCH\n",
+    stderr: "",
+  };
+  recordProjectVerificationOutcome(privateEvidenceState, privateEvidenceCommand, {
+    commandCwd: workspace,
+    taskProfile: "writing",
+    allowShellTool: true,
+    sandboxMode: "host",
+  });
+  const privateEvidenceWrite = {
+    toolName: "write_file",
+    ok: true,
+    path: ".aginti/verification/visual-check.txt",
+    changes: [
+      {
+        path: ".aginti/verification/visual-check.txt",
+        created: true,
+        beforeHash: "",
+        afterHash: "private-evidence",
+      },
+    ],
+  };
+  recordProjectVerificationOutcome(privateEvidenceState, privateEvidenceWrite, {
+    commandCwd: workspace,
+    taskProfile: "writing",
+  });
+  const privateEvidenceContract = augmentScsTaskContractWithProjectVerification(
+    {
+      requiresExternalEvidence: false,
+      requiredEvidence: [],
+      requiredToolCalls: [],
+      requiredGitActions: [],
+      taskProfile: "writing",
+    },
+    privateEvidenceState,
+    { taskProfile: "writing" }
+  );
+  const privateEvidenceLedger = buildScsEvidenceLedger({
+    state: {
+      messages: [privateEvidenceBuild, privateEvidenceCommand, privateEvidenceWrite].map((result) =>
+        toolMessage(result)
+      ),
+    },
+  });
+  assert(
+    privateEvidenceRevision === 1 &&
+      privateEvidenceState.meta.projectVerification?.mutationRevision === 1 &&
+      privateEvidenceState.meta.projectVerification?.requiredCommandBatch?.complete === true &&
+      evaluateScsEvidence(privateEvidenceContract, privateEvidenceLedger).ok,
+    "ignored private verification evidence invalidated a successful canonical build"
+  );
+  const publicEvidenceMutation = {
+    toolName: "run_command",
+    ok: true,
+    exitCode: 0,
+    args: { command: "md5sum output/report.pdf > output/hashes-final.txt" },
+    stdout: "",
+    stderr: "",
+  };
+  recordProjectVerificationOutcome(privateEvidenceState, publicEvidenceMutation, {
+    commandCwd: workspace,
+    taskProfile: "writing",
+    allowShellTool: true,
+    sandboxMode: "host",
+  });
+  assert(
+    privateEvidenceState.meta.projectVerification?.mutationRevision === 2 &&
+      !privateEvidenceState.meta.projectVerification?.requiredCommandBatch,
+    "a non-private output write was incorrectly exempted from project mutation tracking"
+  );
   const gitCheckoutResult = {
     toolName: "run_command",
     ok: true,

package/src/agent-runner.js

@@ -5991,6 +5991,49 @@ const WORKTREE_CHANGING_GIT_ACTIONS = new Set([
   "switch",
 ]);
 
+function isPrivateVerificationEvidencePath(value = "") {
+  const normalized = String(value || "")
+    .trim()
+    .replace(/^["']|["']$/g, "")
+    .replace(/\\/g, "/")
+    .replace(/^\.\//, "");
+  return Boolean(
+    normalized === ".aginti/verification" ||
+      normalized.startsWith(".aginti/verification/") ||
+      normalized.includes("/.aginti/verification/")
+  );
+}
+
+function commandWritesOnlyPrivateVerificationEvidence(command = "") {
+  const normalized = String(command || "").trim();
+  if (!normalized) return false;
+  const tokens = tokenizeShellWords(normalized);
+  if (tokens[0] === "tee") {
+    let index = 1;
+    if (["-a", "--append"].includes(tokens[index])) index += 1;
+    if (tokens[index] === "--") index += 1;
+    const targets = tokens.slice(index);
+    return targets.length > 0 && targets.every(isPrivateVerificationEvidencePath);
+  }
+  if (tokens[0] === "mkdir") {
+    const targets = tokens.slice(1).filter((token) => token !== "-p" && token !== "--");
+    return targets.length > 0 && targets.every(isPrivateVerificationEvidencePath);
+  }
+
+  let strippedPrivateRedirect = false;
+  const withoutPrivateRedirects = normalized.replace(
+    /(^|\s)(?:\d*>>?|&>>?)\s*("[^"]+"|'[^']+'|[^\s;&|]+)/g,
+    (match, prefix, target) => {
+      if (!isPrivateVerificationEvidencePath(target)) return match;
+      strippedPrivateRedirect = true;
+      return prefix;
+    }
+  ).trim();
+  if (!strippedPrivateRedirect || !withoutPrivateRedirects) return false;
+  const underlyingPolicy = classifyCommand(withoutPrivateRedirects);
+  return underlyingPolicy.writesWorkspace !== true && underlyingPolicy.mayMutateProject !== true;
+}
+
 function commandCanMutateProjectContent(command = "", commandPolicy = {}) {
   if (commandPolicy.writesWorkspace !== true && commandPolicy.mayMutateProject !== true) return false;
   const sequence = parseTopLevelShellSequence(String(command || ""));
@@ -6004,6 +6047,7 @@ function commandCanMutateProjectContent(command = "", commandPolicy = {}) {
       commandCanMutateProjectContent(segment, classifyCommand(segment))
     );
   }
+  if (commandWritesOnlyPrivateVerificationEvidence(command)) return false;
   const category = String(commandPolicy.category || "");
   if (!["git-workflow", "git-remote"].includes(category)) return true;
   if (/\bgit\s+clone\b/i.test(String(command || ""))) return true;
@@ -6490,7 +6534,7 @@ function successfulProjectMutationPaths(toolResult = {}) {
       [
         toolResult.path,
         ...actualChanges.flatMap((change) => [change.path, change.fromPath]),
-      ].filter(Boolean)
+      ].filter((candidate) => candidate && !isPrivateVerificationEvidencePath(candidate))
     ),
   ];
 }

package/src/command-policy.js

@@ -108,17 +108,31 @@ function isReadOnlyUniqFilter(command = "") {
   );
 }
 
-function isReadOnlySha256Command(command = "") {
+function isReadOnlyDigestCommand(command = "") {
   const normalized = stripBenignRedirections(command);
   if (hasActiveShellExpansion(normalized)) return false;
   const tokens = tokenizeShellWords(normalized);
-  if (tokens[0] !== "sha256sum" || tokens.length < 2) return false;
-  const paths = tokens.slice(1).filter((token) => token !== "--");
+  if (!["md5sum", "sha256sum"].includes(tokens[0]) || tokens.length < 2) return false;
+  let index = 1;
+  if (["-c", "--check"].includes(tokens[index])) index += 1;
+  if (tokens[index] === "--") index += 1;
+  const paths = tokens.slice(index);
   return paths.length > 0 && paths.every((token) =>
     !token.startsWith("-") && READ_ONLY_FOR_LOOP_LITERAL_PATTERN.test(token)
   );
 }
 
+function isReadOnlyDiffCommand(command = "") {
+  const normalized = stripBenignRedirections(command);
+  if (hasActiveShellExpansion(normalized)) return false;
+  const tokens = tokenizeShellWords(normalized);
+  if (tokens[0] !== "diff" || tokens.length < 3) return false;
+  const operands = tokens.slice(1).filter((token) => token !== "--" && !token.startsWith("-"));
+  return operands.length === 2 && operands.every((token) =>
+    READ_ONLY_FOR_LOOP_LITERAL_PATTERN.test(token)
+  );
+}
+
 function isReadOnlyFindCommand(command = "") {
   const normalized = stripBenignRedirections(command);
   if (!/^find\s+/.test(normalized)) return false;
@@ -1511,7 +1525,8 @@ function classifySimpleCommand(normalized) {
     isReadOnlyPrintfCommand(commandForPatternMatching) ||
     isReadOnlyTrDeleteFilter(commandForPatternMatching) ||
     isReadOnlyUniqFilter(commandForPatternMatching) ||
-    isReadOnlySha256Command(commandForPatternMatching) ||
+    isReadOnlyDigestCommand(commandForPatternMatching) ||
+    isReadOnlyDiffCommand(commandForPatternMatching) ||
     isReadOnlyFindCommand(normalized) ||
     (!hasActiveShellExpansion(benignRedirectCommand) && isReadOnlyShellCondition(benignRedirectCommand))
   ) {