@lazyingart/agintiflow 0.20.318 → 0.20.320

package/package.json

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

@@ -4556,6 +4556,105 @@ try {
       failedSpacedExitProbeResult.projectTest?.explicitExitStatus === 1,
     "a spaced nonzero test-status wrapper was recorded as successful generic evidence"
   );
+  const unsafePipedTestCommand =
+    "cd . && PYTHONPATH=src python -m pytest tests/test_wechat_document_reader.py -q 2>&1 | tail -5 && echo '---artifacts---' && ls -la output/task";
+  const unsafePipedTestState = { meta: { goalContract: { revision: 1 } } };
+  const unsafePipedTestResult = {
+    toolName: "run_command",
+    ok: true,
+    exitCode: 0,
+    args: { command: unsafePipedTestCommand },
+    stdout: "....... [100%]\n7 passed in 0.04s\n---artifacts---\n",
+    stderr: "",
+    projectMutationPaths: [],
+    commandPolicy: classifyCommand(unsafePipedTestCommand),
+  };
+  recordProjectVerificationOutcome(
+    unsafePipedTestState,
+    unsafePipedTestResult,
+    { commandCwd: workspace, taskProfile: "qa", allowShellTool: true, sandboxMode: "host" }
+  );
+  assert(
+    unsafePipedTestState.meta.projectVerification?.mutationRevision === 0 &&
+      unsafePipedTestResult.nonAuthoritativeTestOutputPipeline === true &&
+      unsafePipedTestResult.projectTest === undefined,
+    `an exit-status-hiding test pipeline fabricated source mutation or passing test evidence: ${JSON.stringify({
+      mutationRevision:
+        unsafePipedTestState.meta.projectVerification?.mutationRevision,
+      nonAuthoritativeTestOutputPipeline:
+        unsafePipedTestResult.nonAuthoritativeTestOutputPipeline,
+      projectTest: unsafePipedTestResult.projectTest,
+      policy: unsafePipedTestResult.commandPolicy,
+    })}`
+  );
+  const mutatingPipedTestCommand = `${unsafePipedTestCommand} && touch src/agent-runner.js`;
+  const mutatingPipedTestState = { meta: { goalContract: { revision: 1 } } };
+  const mutatingPipedTestResult = {
+    toolName: "run_command",
+    ok: true,
+    exitCode: 0,
+    args: { command: mutatingPipedTestCommand },
+    stdout: "7 passed in 0.04s\n",
+    stderr: "",
+    projectMutationPaths: [],
+    commandPolicy: classifyCommand(mutatingPipedTestCommand),
+  };
+  recordProjectVerificationOutcome(
+    mutatingPipedTestState,
+    mutatingPipedTestResult,
+    {
+      commandCwd: workspace,
+      taskProfile: "qa",
+      allowShellTool: true,
+      allowDestructive: true,
+      sandboxMode: "host",
+    }
+  );
+  assert(
+    mutatingPipedTestState.meta.projectVerification?.mutationRevision === 1 &&
+      mutatingPipedTestResult.nonAuthoritativeTestOutputPipeline !== true,
+    "a source mutation appended to an unsafe test pipeline escaped revision tracking"
+  );
+  const workspaceCdWrappedTestCommand =
+    `cd ${workspace} && PYTHONPATH=src python -m pytest tests/test_wechat_document_reader.py -v; echo "EXIT=$?"`;
+  assert(
+    isSubstantiveTestCommand(workspaceCdWrappedTestCommand, {
+      commandCwd: workspace,
+    }),
+    "a safe explicit-status test wrapper lost test identity behind a workspace cd"
+  );
+  const workspaceCdWrappedTestState = {
+    meta: { goalContract: { revision: 1 } },
+  };
+  const workspaceCdWrappedTestResult = {
+    toolName: "run_command",
+    ok: true,
+    exitCode: 0,
+    args: { command: workspaceCdWrappedTestCommand },
+    stdout: "7 passed in 0.06s\nEXIT=0\n",
+    stderr: "",
+    projectMutationPaths: [],
+    commandPolicy: classifyCommand(workspaceCdWrappedTestCommand),
+  };
+  recordProjectVerificationOutcome(
+    workspaceCdWrappedTestState,
+    workspaceCdWrappedTestResult,
+    {
+      commandCwd: workspace,
+      taskProfile: "qa",
+      allowShellTool: true,
+      sandboxMode: "host",
+    }
+  );
+  assert(
+    workspaceCdWrappedTestResult.projectTest?.passed === true &&
+      workspaceCdWrappedTestState.meta.projectVerification?.testRuns?.length === 1,
+    `a successful workspace-cd status wrapper did not produce one passing test run: ${JSON.stringify({
+      projectTest: workspaceCdWrappedTestResult.projectTest,
+      testRuns:
+        workspaceCdWrappedTestState.meta.projectVerification?.testRuns,
+    })}`
+  );
   const pipedUnittestCommand =
     "python3 -m unittest discover -s tests -p 'test_wechat_document_reader.py' -v 2>&1 | tail -14; echo \"EXIT=${PIPESTATUS[0]}\"";
   assert(

package/src/agent-runner.js

@@ -5189,6 +5189,13 @@ function boundedReadOnlyTestPrefixCommand(value = "") {
   const command = normalizeProjectCommand(value);
   if (!command) return false;
   const tokens = tokenizeShellWords(command);
+  if (
+    tokens[0] === "cd" &&
+    tokens.length === 2 &&
+    !/(?:`|\$\(|[|<>])/u.test(command)
+  ) {
+    return true;
+  }
   if (
     ["date", "echo", "printf"].includes(String(tokens[0] || "")) &&
     !/(?:`|\$\()/u.test(command)
@@ -5361,6 +5368,55 @@ function projectTestCommandWrapper(command = "") {
   );
 }
 
+function commandIsNonMutatingTestOutputPipeline(command = "") {
+  const normalized = normalizeProjectCommand(command);
+  if (!normalized || /\b(?:PIPESTATUS|pipefail)\b/u.test(normalized)) return false;
+  const sequence = parseTopLevelShellSequence(normalized);
+  if (
+    sequence.openQuote ||
+    sequence.trailingEscape ||
+    sequence.trailingSeparator ||
+    !sequence.commands.length
+  ) {
+    return false;
+  }
+  let sawTestPipeline = false;
+  for (let index = 0; index < sequence.commands.length;) {
+    if (sequence.separators[index] === "|") {
+      let pipelineEnd = index + 1;
+      while (sequence.separators[pipelineEnd] === "|") pipelineEnd += 1;
+      const test = boundedTestCommandClassification(sequence.commands[index]);
+      if (test.policy.substantiveTest !== true) return false;
+      const filtersAreReadOnly = sequence.commands
+        .slice(index + 1, pipelineEnd + 1)
+        .every((candidate) => {
+          const tokens = tokenizeShellWords(candidate);
+          if (
+            !["cat", "grep", "head", "sed", "sort", "tail", "tr", "uniq", "wc"].includes(
+              String(tokens[0] || "")
+            ) ||
+            /(?:`|\$\(|[<>])/u.test(candidate)
+          ) {
+            return false;
+          }
+          const policy = classifyCommand(candidate);
+          return policy.writesWorkspace !== true && policy.mayMutateProject !== true;
+        });
+      if (!filtersAreReadOnly) return false;
+      sawTestPipeline = true;
+      index = pipelineEnd + 1;
+      continue;
+    }
+    const candidate = String(sequence.commands[index] || "")
+      .trim()
+      .replace(/^(?:[A-Za-z_]\w*=(?:"[^"\n]*"|'[^'\n]*'|[^\s;&|]+)\s*)+/u, "")
+      .trim();
+    if (candidate && !boundedReadOnlyTestPrefixCommand(candidate)) return false;
+    index += 1;
+  }
+  return sawTestPipeline;
+}
+
 function projectExitStatusWrapper(command = "") {
   return (
     parseNonMutatingExitStatusWrapper(command) ||
@@ -5439,10 +5495,12 @@ export function isSubstantiveTestCommand(command = "", config = {}) {
   if (isRetainedExactVerificationCommand(command, config)) return true;
   const normalized = normalizeProjectCommand(normalizeCommandForPolicy(command, config));
   if (projectTestCommandWrapper(normalized)) return true;
-  const text = projectExitStatusWrapper(normalized)?.command || normalized;
+  const wrappedTestCommand =
+    projectExitStatusWrapper(normalized)?.command || normalized;
+  const text = normalizeLeadingWorkspaceCd(wrappedTestCommand, config);
   if (!text) return false;
-  const classification = classifyCommand(text);
-  if (classification.substantiveTest !== true) return false;
+  const classification = boundedTestCommandClassification(text);
+  if (classification.policy.substantiveTest !== true) return false;
   const sequence = parseTopLevelShellSequence(text);
   if (sequence.commands.length <= 1) return true;
   if (!sequence.separators.every((separator) => separator === "&&")) return false;
@@ -5450,9 +5508,17 @@ export function isSubstantiveTestCommand(command = "", config = {}) {
   let lastTestIndex = -1;
   let lastMutationIndex = -1;
   sequence.commands.forEach((segment, index) => {
-    const segmentPolicy = classifyCommand(segment);
+    const segmentClassification = boundedTestCommandClassification(segment);
+    const segmentPolicy = segmentClassification.policy;
     if (segmentPolicy.substantiveTest === true) lastTestIndex = index;
-    if (commandCanMutateProjectContent(segment, segmentPolicy)) lastMutationIndex = index;
+    if (
+      commandCanMutateProjectContent(
+        segmentClassification.executableCommand,
+        segmentPolicy
+      )
+    ) {
+      lastMutationIndex = index;
+    }
   });
   return lastTestIndex >= 0 && lastTestIndex >= lastMutationIndex;
 }
@@ -7248,6 +7314,10 @@ export function recordProjectVerificationOutcome(state = {}, toolResult = {}, co
       commandMutationPaths.length === 0 &&
         commandIsBoundedReadOnlyArtifactValidation(mutationCommand)
     );
+    const nonMutatingTestOutputPipeline = Boolean(
+      commandMutationPaths.length === 0 &&
+        commandIsNonMutatingTestOutputPipeline(mutationCommand)
+    );
     const projectContentMutation = Boolean(
       command &&
         toolResult.blocked !== true &&
@@ -7257,6 +7327,7 @@ export function recordProjectVerificationOutcome(state = {}, toolResult = {}, co
         !disposableGeneratedVerificationSideEffects &&
         !scopedTaskArtifactWrite &&
         !readOnlyArtifactValidation &&
+        !nonMutatingTestOutputPipeline &&
         (commandSucceeded || commandMutationPaths.length > 0) &&
         (
           commandCanMutateProjectContent(mutationCommand, commandPolicy) ||
@@ -7277,6 +7348,9 @@ export function recordProjectVerificationOutcome(state = {}, toolResult = {}, co
     if (readOnlyArtifactValidation) {
       toolResult.readOnlyArtifactValidation = true;
     }
+    if (nonMutatingTestOutputPipeline) {
+      toolResult.nonAuthoritativeTestOutputPipeline = true;
+    }
     if (testCommandWrapper?.semanticallyReadOnly === true) {
       toolResult.boundedReadOnlyTestWrapper = true;
     }
@@ -22632,6 +22706,9 @@ async function completionEvidenceDecision({ config, state, store, observers, ste
       detail.suggestedTestCommands.length
         ? `Use the established test command now: ${detail.suggestedTestCommands.join("; ")}.`
         : "",
+      detail.missingEvidence.includes("test")
+        ? "Run the focused test directly without piping it through tail, head, tee, grep, or another output filter that can replace the test exit status. If bounded output is essential, enable shell pipefail or capture the test's PIPESTATUS immediately and emit one EXIT=<status> marker. Keep artifact inspection in a separate later command."
+        : "",
       detail.failedProjectTestSummary
         ? `The latest current test run failed: ${detail.failedProjectTestSummary}`
         : "",