@lazyingart/agintiflow 0.20.314 → 0.20.316

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lazyingart/agintiflow",
-  "version": "0.20.314",
+  "version": "0.20.316",
   "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-coding-tools.js

@@ -1431,7 +1431,7 @@ try {
     "host workspace chmod sequence should remain categorized as permission-change"
   );
   const androidReadonlyProbePolicy = evaluateCommandPolicy(
-    'test -x /usr/bin/gradle && echo "GRADLE_OK" ; test -x /usr/bin/java && /usr/bin/java -version 2>&1 | head -1; adb devices; emulator -list-avds; find android-app -type f | sort',
+    'test -x /usr/bin/gradle && echo "GRADLE_OK" ; test -x /usr/bin/java && /usr/bin/java -version 2>&1 | head -1; adb devices; emulator -list-avds; find android-app -maxdepth 16 -type f | sort',
     hostWorkspacePolicy
   );
   assert(androidReadonlyProbePolicy.allowed, "Android host read-only probes should not require full-host destructive access");

package/scripts/smoke-dynamic-step-budget.js

@@ -4556,6 +4556,36 @@ try {
       failedSpacedExitProbeResult.projectTest?.explicitExitStatus === 1,
     "a spaced nonzero test-status wrapper was recorded as successful generic evidence"
   );
+  const pipedUnittestCommand =
+    "python3 -m unittest discover -s tests -p 'test_wechat_document_reader.py' -v 2>&1 | tail -14; echo \"EXIT=${PIPESTATUS[0]}\"";
+  assert(
+    parseNonMutatingExitStatusWrapper(pipedUnittestCommand)?.command ===
+      "python3 -m unittest discover -s tests -p 'test_wechat_document_reader.py' -v 2>&1" &&
+      isSubstantiveTestCommand(pipedUnittestCommand),
+    "the exact bounded PIPESTATUS unittest wrapper lost its test identity"
+  );
+  for (const [status, expectedPassed] of [[0, true], [1, false]]) {
+    const state = { meta: { goalContract: { revision: 1 } } };
+    const result = {
+      toolName: "run_command",
+      ok: true,
+      exitCode: 0,
+      args: { command: pipedUnittestCommand },
+      stdout: `Ran 7 tests in 0.01s\n${status === 0 ? "OK" : "FAILED (failures=1)"}\nEXIT=${status}\n`,
+      stderr: "",
+      commandPolicy: classifyCommand(pipedUnittestCommand),
+    };
+    recordProjectVerificationOutcome(state, result, {
+      commandCwd: workspace,
+      taskProfile: "qa",
+    });
+    assert(
+      result.projectTest?.passed === expectedPassed &&
+        result.projectTest?.explicitExitStatus === status &&
+        state.meta.projectVerification?.mutationRevision === 0,
+      `a PIPESTATUS unittest wrapper was not recorded at the correct status/revision: ${status}`
+    );
+  }
   for (const [command, output, expectedRevision] of [
     ['npm test; printf "EXIT_CODE=%d\\n" "$?"', "EXIT_CODE=0\n", 0],
     ['git push; echo "EXIT=$?"', "EXIT=0\n", 0],
@@ -4579,6 +4609,50 @@ try {
       `a status wrapper changed the inner command's mutation identity: ${command}`
     );
   }
+  const boundedFindCommand =
+    `cd ${workspace} && echo "=== CANDIDATES ===" && ` +
+    "find . -maxdepth 4 \\( -name '*.py' -o -name '*.md' \\) -not -path './output/*' 2>/dev/null | sort; echo DONE";
+  const boundedFindPolicy = evaluateCommandPolicy(boundedFindCommand, {
+    commandCwd: workspace,
+    allowShellTool: true,
+    allowDestructive: false,
+    sandboxMode: "host",
+  });
+  assert(
+    boundedFindPolicy.allowed === true &&
+      boundedFindPolicy.category === "read-only" &&
+      boundedFindPolicy.writesWorkspace === false,
+    "the exact bounded read-only find sequence was classified as a project mutation"
+  );
+  const boundedFindState = { meta: { goalContract: { revision: 1 } } };
+  const boundedFindResult = {
+    toolName: "run_command",
+    ok: true,
+    exitCode: 0,
+    args: { command: boundedFindCommand },
+    stdout: "./tests/test_wechat_document_reader.py\nDONE\n",
+    stderr: "",
+    commandPolicy: boundedFindPolicy,
+  };
+  recordProjectVerificationOutcome(boundedFindState, boundedFindResult, {
+    commandCwd: workspace,
+    taskProfile: "qa",
+  });
+  assert(
+    boundedFindState.meta.projectVerification?.mutationRevision === 0,
+    "a successful bounded read-only find fabricated a source revision"
+  );
+  for (const command of [
+    "find . -maxdepth 4 -name '*.py' -delete",
+    "find . -maxdepth 4 -name '*.py' -exec touch {} \\;",
+  ]) {
+    const classification = classifyCommand(command);
+    assert(
+      classification.writesWorkspace === true &&
+        ["destructive", "general-shell"].includes(classification.category),
+      `a write-capable find form was accepted as read-only: ${command}`
+    );
+  }
   const readOnlyValidatorState = { meta: { goalContract: { revision: 1 } } };
   const readOnlyValidatorResult = {
     toolName: "run_command",
@@ -6030,13 +6104,86 @@ try {
       sandboxMode: "host",
     }
   );
+  const scopedCompoundTestLogCommand = {
+    toolName: "run_command",
+    ok: true,
+    exitCode: 0,
+    args: {
+      command: [
+        `cd ${JSON.stringify(workspace)}`,
+        `LOG=${JSON.stringify(path.join(scopedTaskRoot, "document-reader-test.log"))}`,
+        'echo "RUN_MARKER=now" > "$LOG"',
+        'python3 -m unittest discover -s tests -p \'test_reader.py\' -v >> "$LOG" 2>&1',
+        'echo "EXIT=0" >> "$LOG"',
+        'cat "$LOG"',
+      ].join(" && "),
+    },
+    projectMutationPaths: [],
+    stdout: "Ran 7 tests\nOK\nEXIT=0\n",
+    stderr: "",
+  };
+  recordProjectVerificationOutcome(
+    scopedTaskState,
+    scopedCompoundTestLogCommand,
+    {
+      commandCwd: workspace,
+      taskProfile: "auto",
+      allowShellTool: true,
+      sandboxMode: "host",
+    }
+  );
+  const nullRedirectValidationCommand = {
+    toolName: "run_command",
+    ok: true,
+    exitCode: 0,
+    args: {
+      command: [
+        `cd ${JSON.stringify(workspace)}`,
+        `python3 -m json.tool ${JSON.stringify(
+          path.join(scopedTaskRoot, "agent-result.json")
+        )} > /dev/null`,
+        'echo "JSON_VALID"',
+        `grep -c '^## [0-9]' ${JSON.stringify(
+          path.join(scopedTaskRoot, "source-intake-audit.md")
+        )}`,
+      ].join(" && "),
+    },
+    projectMutationPaths: [],
+    stdout: "JSON_VALID\n5\n",
+    stderr: "",
+  };
+  recordProjectVerificationOutcome(
+    scopedTaskState,
+    nullRedirectValidationCommand,
+    {
+      commandCwd: workspace,
+      taskProfile: "auto",
+      allowShellTool: true,
+      sandboxMode: "host",
+    }
+  );
   assert(
     requestedOutputRevision === 1 &&
       scopedTaskState.meta.projectVerification?.mutationRevision === 1 &&
       readOnlyArtifactValidation.readOnlyArtifactValidation === true &&
       scopedManifestCommand.scopedTaskArtifactWrite === true &&
-      pythonScopedManifestCommand.scopedTaskArtifactWrite === true,
-    "task-scoped delivery bookkeeping invalidated requested artifact evidence"
+      pythonScopedManifestCommand.scopedTaskArtifactWrite === true &&
+      scopedCompoundTestLogCommand.scopedTaskArtifactWrite === true &&
+      nullRedirectValidationCommand.readOnlyArtifactValidation === true,
+    `task-scoped delivery bookkeeping invalidated requested artifact evidence: ${JSON.stringify({
+      requestedOutputRevision,
+      mutationRevision:
+        scopedTaskState.meta.projectVerification?.mutationRevision,
+      readOnlyArtifactValidation:
+        readOnlyArtifactValidation.readOnlyArtifactValidation,
+      scopedManifestCommand: scopedManifestCommand.scopedTaskArtifactWrite,
+      pythonScopedManifestCommand:
+        pythonScopedManifestCommand.scopedTaskArtifactWrite,
+      scopedCompoundTestLogCommand:
+        scopedCompoundTestLogCommand.scopedTaskArtifactWrite,
+      nullRedirectValidationCommand:
+        nullRedirectValidationCommand.readOnlyArtifactValidation,
+    })}`
   );
   const mutatingInlinePython = {
     toolName: "run_command",

package/src/agent-runner.js

@@ -5143,12 +5143,20 @@ function testRunRepresentsInvalidInvocation(testRun = {}) {
 function explicitExitProbeStatus(command = "", result = {}) {
   const normalizedCommand = normalizeProjectCommand(command);
   const exitProbe = parseNonMutatingExitStatusWrapper(normalizedCommand);
-  if (!exitProbe) return { present: false, status: null, command: normalizedCommand };
+  if (!exitProbe) {
+    return {
+      present: false,
+      status: null,
+      command: normalizedCommand,
+      wrappedCommand: normalizedCommand,
+    };
+  }
 
   return {
     present: true,
     status: parseExplicitExitStatus(result.stdout || ""),
     command: exitProbe.command,
+    wrappedCommand: exitProbe.wrappedCommand || exitProbe.command,
   };
 }
 
@@ -6717,7 +6725,10 @@ export function recordProjectVerificationOutcome(state = {}, toolResult = {}, co
     );
     const exitProbe = explicitExitProbeStatus(command, toolResult);
     const mutationCommand = normalizeProjectCommand(
-      normalizeCommandForPolicy(exitProbe.command || command, config)
+      normalizeCommandForPolicy(
+        exitProbe.wrappedCommand || exitProbe.command || command,
+        config
+      )
     );
     // The result proves the command already executed. Classify its semantic
     // mutation capability independently of whether the current policy would
@@ -12762,31 +12773,85 @@ function safePatchContextEvidencePath(value = "", state = {}, config = {}) {
 function commandWritesOnlyEvidenceMatching(command = "", pathMatches = () => false) {
   const normalized = String(command || "").trim();
   if (!normalized) return false;
+  const assignments = new Map();
+  for (const match of normalized.matchAll(
+    /(?:^|[\s;&|])([A-Za-z_]\w*)\s*=\s*("[^"\n]+"|'[^'\n]+'|[^\s;&|]+)/g
+  )) {
+    assignments.set(
+      match[1],
+      String(match[2] || "").replace(/^["']|["']$/g, "")
+    );
+  }
+  const resolveTarget = (value = "") => {
+    const target = String(value || "")
+      .trim()
+      .replace(/^["']|["']$/g, "");
+    const variable = target.match(/^\$(?:\{([A-Za-z_]\w*)\}|([A-Za-z_]\w*))$/);
+    return variable
+      ? String(assignments.get(variable[1] || variable[2]) || "")
+      : target;
+  };
   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);
+    const targets = tokens.slice(index).map(resolveTarget);
     return targets.length > 0 && targets.every(pathMatches);
   }
   if (tokens[0] === "mkdir") {
-    const targets = tokens.slice(1).filter((token) => token !== "-p" && token !== "--");
+    const targets = tokens
+      .slice(1)
+      .filter((token) => token !== "-p" && token !== "--")
+      .map(resolveTarget);
     return targets.length > 0 && targets.every(pathMatches);
   }
 
   let strippedEvidenceRedirect = false;
+  let rejectedRedirect = false;
   const withoutEvidenceRedirects = normalized.replace(
     /(^|\s)(?:\d*>>?|&>>?)\s*("[^"]+"|'[^']+'|[^\s;&|]+)/g,
     (match, prefix, target) => {
-      if (!pathMatches(target)) return match;
+      const resolvedTarget = resolveTarget(target);
+      if (/^(?:&\d+|\/dev\/null)$/u.test(resolvedTarget)) return prefix;
+      if (!resolvedTarget || !pathMatches(resolvedTarget)) {
+        rejectedRedirect = true;
+        return match;
+      }
       strippedEvidenceRedirect = true;
       return prefix;
     }
   ).trim();
-  if (!strippedEvidenceRedirect || !withoutEvidenceRedirects) return false;
-  const underlyingPolicy = classifyCommand(withoutEvidenceRedirects);
-  return underlyingPolicy.writesWorkspace !== true && underlyingPolicy.mayMutateProject !== true;
+  if (rejectedRedirect || !strippedEvidenceRedirect || !withoutEvidenceRedirects) {
+    return false;
+  }
+  const sequence = parseTopLevelShellSequence(withoutEvidenceRedirects);
+  if (sequence.openQuote || sequence.trailingEscape || sequence.trailingSeparator) {
+    return false;
+  }
+  return sequence.commands.every((segment) => {
+    const withoutAssignments = String(segment || "")
+      .trim()
+      .replace(
+        /^(?:[A-Za-z_]\w*=(?:"[^"\n]*"|'[^'\n]*'|[^\s;&|]+)\s*)+/u,
+        ""
+      )
+      .trim();
+    if (!withoutAssignments) return true;
+    const commandTokens = tokenizeShellWords(withoutAssignments);
+    if (
+      ["cat", "cd", "head", "ls", "stat", "tail", "wc"].includes(
+        String(commandTokens[0] || "")
+      )
+    ) {
+      return true;
+    }
+    const underlyingPolicy = classifyCommand(withoutAssignments);
+    return (
+      underlyingPolicy.writesWorkspace !== true &&
+      underlyingPolicy.mayMutateProject !== true
+    );
+  });
 }
 
 function commandWritesOnlyPrivateVerificationEvidence(command = "") {
@@ -12833,15 +12898,20 @@ function commandIsBoundedReadOnlyArtifactValidation(command = "") {
   const normalized = String(command || "").trim();
   if (!normalized) return false;
   if (
-    !/\bassert\b|\bjson\.(?:load|loads)\s*\(|\bJSON\.parse\s*\(|\bjq\b|\bsha256sum\b|\bmd5sum\b|\b(?:valid|pass|verified?)\b/i.test(
+    !/\bassert\b|\bjson\.(?:load|loads|tool)\b|\bJSON\.parse\s*\(|\bjq\b|\bsha256sum\b|\bmd5sum\b|\b(?:valid|pass|verified?)\b/i.test(
       normalized
     )
   ) {
     return false;
   }
+  const withoutNullRedirects = normalized.replace(
+    /(^|\s)(?:\d*>>?|&>>?)\s*(?:"\/dev\/null"|'\/dev\/null'|\/dev\/null)/g,
+    "$1"
+  );
   // Heredoc input (`<<`) is compatible with read-only validation. Any output
-  // redirection or known mutator keeps conservative project revision tracking.
-  if (/(^|[^<])>{1,2}(?!=)/m.test(normalized)) return false;
+  // redirection outside /dev/null or known mutator keeps conservative project
+  // revision tracking.
+  if (/(^|[^<])>{1,2}(?!=)/m.test(withoutNullRedirects)) return false;
   if (
     /\b(?:cp|install|mkdir|mv|rm|rmdir|tee|touch|truncate)\b|\bsed\s+-i\b|\bperl\s+-pi\b/i.test(
       normalized

package/src/command-policy.js

@@ -17,7 +17,6 @@ const READ_ONLY_PATTERNS = [
   /^command\s+-v\s+[-\w.]+$/,
   /^uname(?:\s+-a)?$/,
   /^ls(?:\s+(?:"[^"\n]*"|'[^'\n]*'|[-\w./~*]+))*$/,
-  /^find(?:\s+[./~\w-]+)*(?:\s+-maxdepth\s+\d+)?(?:\s+-type\s+[fd])?$/,
   /^rg(?:\s+.+)?$/,
   /^grep(?:\s+.+)?$/,
   /^pgrep(?:\s+.+)?$/,
@@ -143,8 +142,71 @@ function isReadOnlyFindCommand(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);
-  if (/[|<>;&`$]/.test(unquoted)) return false;
-  return /^find\s+(?:[-./~\w]+|\/workspace)(?:\s+[-\w]+(?:\s+(?:"[^"\n]*"|'[^'\n]*'|[^\s|<>;&`$]+))?)*$/.test(normalized);
+  if (/[|<>;&`$]/.test(unquoted) || hasActiveShellExpansion(normalized)) return false;
+
+  const tokens = tokenizeShellWords(normalized);
+  if (tokens[0] !== "find" || tokens.length < 4) return false;
+  let index = 1;
+  let roots = 0;
+  while (index < tokens.length && !tokens[index].startsWith("-") && !["(", ")", "!"].includes(tokens[index])) {
+    const root = tokens[index];
+    if (!/^(?:\.{1,2}|\/workspace(?:\/[-\w./~*]+)?|~?(?:\/)?[-\w./*]+)$/.test(root)) return false;
+    roots += 1;
+    index += 1;
+  }
+  if (!roots) return false;
+
+  let maxDepth = null;
+  let parenthesisDepth = 0;
+  const patternPredicates = new Set([
+    "-name",
+    "-iname",
+    "-path",
+    "-ipath",
+    "-wholename",
+    "-iwholename",
+  ]);
+  const operators = new Set(["!", "-not", "-o", "-or", "-a", "-and", "-true", "-false", "-empty", "-print", "-print0", "-quit"]);
+  while (index < tokens.length) {
+    const token = tokens[index];
+    if (token === "(") {
+      parenthesisDepth += 1;
+      index += 1;
+      continue;
+    }
+    if (token === ")") {
+      parenthesisDepth -= 1;
+      if (parenthesisDepth < 0) return false;
+      index += 1;
+      continue;
+    }
+    if (operators.has(token)) {
+      index += 1;
+      continue;
+    }
+    const argument = tokens[index + 1];
+    if (!argument || /[\u0000-\u001f\u007f]/u.test(argument)) return false;
+    if (token === "-maxdepth" || token === "-mindepth") {
+      if (!/^\d+$/.test(argument)) return false;
+      const depth = Number(argument);
+      if (!Number.isSafeInteger(depth) || depth > 64) return false;
+      if (token === "-maxdepth") maxDepth = depth;
+      index += 2;
+      continue;
+    }
+    if (token === "-type") {
+      if (!/^[bcdpflsD]$/.test(argument)) return false;
+      index += 2;
+      continue;
+    }
+    if (patternPredicates.has(token)) {
+      if (argument.length > 1024) return false;
+      index += 2;
+      continue;
+    }
+    return false;
+  }
+  return parenthesisDepth === 0 && maxDepth !== null;
 }
 
 function isUnboundedRecursiveGrep(command = "") {

package/src/scs-evidence.js

@@ -2227,10 +2227,51 @@ function normalizeProjectCommand(value = "") {
   return canonicalizeShellCommand(value);
 }
 
+function pipelineStatusCommand(value = "", pipelineIndex = 0) {
+  const sequence = parseTopLevelShellSequence(value);
+  if (
+    sequence.openQuote ||
+    sequence.trailingEscape ||
+    sequence.trailingSeparator ||
+    sequence.commands.length < 2 ||
+    sequence.separators.at(-1) !== "|"
+  ) {
+    return "";
+  }
+
+  let pipelineStart = sequence.commands.length - 1;
+  while (pipelineStart > 0 && sequence.separators[pipelineStart - 1] === "|") {
+    pipelineStart -= 1;
+  }
+  const commandIndex = pipelineStart + Number(pipelineIndex || 0);
+  if (commandIndex < pipelineStart || commandIndex >= sequence.commands.length) return "";
+  return normalizeProjectCommand(sequence.commands[commandIndex]);
+}
+
 export function parseNonMutatingExitStatusWrapper(value = "") {
   const normalized = normalizeProjectCommand(value);
   if (!normalized) return null;
   const label = "(?:EXIT|STATUS|RESULT)(?:_CODE)?";
+  const pipelinePattern = new RegExp(
+    `^(?<pipelineCommand>[\\s\\S]+);\\s*echo\\s+(?:"(?<doubleLabel>${label})\\s*[:=]\\s*\\$\\{PIPESTATUS\\[0\\]\\}"|(?<bareLabel>${label})\\s*[:=]\\s*\\$\\{PIPESTATUS\\[0\\]\\})$`,
+    "i"
+  );
+  const pipelineMatch = normalized.match(pipelinePattern);
+  if (pipelineMatch?.groups?.pipelineCommand) {
+    const wrappedCommand = normalizeProjectCommand(pipelineMatch.groups.pipelineCommand);
+    const command = pipelineStatusCommand(wrappedCommand, 0);
+    if (command) {
+      return {
+        command,
+        wrappedCommand,
+        label: String(
+          pipelineMatch.groups.doubleLabel || pipelineMatch.groups.bareLabel || ""
+        ).toUpperCase(),
+        statusSource: "pipeline",
+        pipelineIndex: 0,
+      };
+    }
+  }
   const patterns = [
     new RegExp(
       `^(?<command>[\\s\\S]+);\\s*echo\\s+(?:\"(?<doubleLabel>${label})\\s*[:=]\\s*\\$\\?\"|'(?<singleLabel>${label})\\s*[:=]\\s*\\$\\?'|(?<bareLabel>${label})\\s*[:=]\\s*\\$\\?)$`,