@lazyingart/agintiflow 0.20.317 → 0.20.319

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lazyingart/agintiflow",
-  "version": "0.20.317",
+  "version": "0.20.319",
   "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,65 @@ 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 pipedUnittestCommand =
     "python3 -m unittest discover -s tests -p 'test_wechat_document_reader.py' -v 2>&1 | tail -14; echo \"EXIT=${PIPESTATUS[0]}\"";
   assert(
@@ -6183,6 +6242,84 @@ try {
       sandboxMode: "host",
     }
   );
+  const liveScopedOutsideStatusTestLogCommand = {
+    toolName: "run_command",
+    ok: true,
+    exitCode: 0,
+    args: {
+      command:
+        `cd ${JSON.stringify(workspace)} && ` +
+        `TASK=${scopedRelativeTaskRoot} && ` +
+        `{ date -u +"RUN_AT=%FT%TZ"; PYTHONPATH=src python -m pytest tests/test_wechat_document_reader.py -q; } ` +
+        `> "$TASK/document-reader-test.log" 2>&1; rc=$?; echo "PYTEST_EXIT=$rc"; ` +
+        `cat "$TASK/document-reader-test.log"`,
+    },
+    projectMutationPaths: [],
+    stdout: "PYTEST_EXIT=0\n....... [100%]\n7 passed in 0.04s\n",
+    stderr: "",
+  };
+  recordProjectVerificationOutcome(
+    scopedTaskState,
+    liveScopedOutsideStatusTestLogCommand,
+    {
+      commandCwd: workspace,
+      taskProfile: "qa",
+      allowShellTool: true,
+      sandboxMode: "host",
+    }
+  );
+  const conditionalTestCommand =
+    `cd ${JSON.stringify(workspace)} && ` +
+    `if PYTHONPATH=src python -c "import pytest" 2>/dev/null; then ` +
+    `PYTHONPATH=src python -m pytest tests/test_wechat_document_reader.py -q; else ` +
+    `PYTHONPATH=src python -m unittest tests.test_wechat_document_reader -v; fi`;
+  const conditionalTestState = { meta: { goalContract: { revision: 1 } } };
+  const conditionalTestResult = {
+    toolName: "run_command",
+    ok: true,
+    exitCode: 0,
+    args: { command: conditionalTestCommand },
+    projectMutationPaths: [],
+    stdout: "....... [100%]\n7 passed in 0.04s\n",
+    stderr: "",
+    commandPolicy: classifyCommand(conditionalTestCommand),
+  };
+  recordProjectVerificationOutcome(
+    conditionalTestState,
+    conditionalTestResult,
+    {
+      commandCwd: workspace,
+      taskProfile: "qa",
+      allowShellTool: true,
+      sandboxMode: "host",
+    }
+  );
+  const mutatingConditionalTestCommand = conditionalTestCommand.replace(
+    "tests.test_wechat_document_reader -v; fi",
+    "tests.test_wechat_document_reader -v; touch src/agent-runner.js; fi"
+  );
+  const mutatingConditionalTestState = { meta: { goalContract: { revision: 1 } } };
+  const mutatingConditionalTestResult = {
+    toolName: "run_command",
+    ok: true,
+    exitCode: 0,
+    args: { command: mutatingConditionalTestCommand },
+    projectMutationPaths: [],
+    stdout: "7 passed in 0.04s\n",
+    stderr: "",
+    commandPolicy: classifyCommand(mutatingConditionalTestCommand),
+  };
+  recordProjectVerificationOutcome(
+    mutatingConditionalTestState,
+    mutatingConditionalTestResult,
+    {
+      commandCwd: workspace,
+      taskProfile: "qa",
+      allowShellTool: true,
+      allowDestructive: true,
+      sandboxMode: "host",
+    }
+  );
   const unsafeScopedLogState = {
     goal: scopedTaskGoal,
     commandCwd: workspace,
@@ -6333,6 +6470,14 @@ try {
       liveScopedTeeTestLogCommand.scopedTaskArtifactWrite === true &&
       liveScopedTeeTestLogCommand.projectTest?.passed === true &&
       liveScopedTeeTestLogCommand.projectTest?.explicitExitStatus === 0 &&
+      liveScopedOutsideStatusTestLogCommand.scopedTaskArtifactWrite === true &&
+      liveScopedOutsideStatusTestLogCommand.projectTest?.passed === true &&
+      liveScopedOutsideStatusTestLogCommand.projectTest?.explicitExitStatus === 0 &&
+      conditionalTestState.meta.projectVerification?.mutationRevision === 0 &&
+      conditionalTestResult.boundedReadOnlyTestWrapper === true &&
+      conditionalTestResult.projectTest?.passed === true &&
+      mutatingConditionalTestState.meta.projectVerification?.mutationRevision === 1 &&
+      mutatingConditionalTestResult.projectTest === undefined &&
       unsafeScopedLogState.meta.projectVerification?.mutationRevision === 1 &&
       outsideScopedGroupTestLogCommand.scopedTaskArtifactWrite !== true &&
       sourceWriteAfterScopedLogState.meta.projectVerification?.mutationRevision === 1 &&
@@ -6358,6 +6503,23 @@ try {
         scopedTaskArtifactWrite: liveScopedTeeTestLogCommand.scopedTaskArtifactWrite,
         projectTest: liveScopedTeeTestLogCommand.projectTest,
       },
+      liveScopedOutsideStatusTestLogCommand: {
+        scopedTaskArtifactWrite:
+          liveScopedOutsideStatusTestLogCommand.scopedTaskArtifactWrite,
+        projectTest: liveScopedOutsideStatusTestLogCommand.projectTest,
+      },
+      conditionalTestResult: {
+        mutationRevision:
+          conditionalTestState.meta.projectVerification?.mutationRevision,
+        boundedReadOnlyTestWrapper:
+          conditionalTestResult.boundedReadOnlyTestWrapper,
+        projectTest: conditionalTestResult.projectTest,
+      },
+      mutatingConditionalTestResult: {
+        mutationRevision:
+          mutatingConditionalTestState.meta.projectVerification?.mutationRevision,
+        projectTest: mutatingConditionalTestResult.projectTest,
+      },
       outsideScopedGroupTestLogCommand: {
         mutationRevision:
           unsafeScopedLogState.meta.projectVerification?.mutationRevision,

package/src/agent-runner.js

@@ -5034,6 +5034,190 @@ function shellBraceGroups(value = "") {
   return groups;
 }
 
+function unquotedShellControlDelimiter(value = "", keyword = "", startIndex = 0) {
+  const text = String(value || "");
+  const expected = String(keyword || "").toLowerCase();
+  let quote = "";
+  let escaped = false;
+  for (let index = Math.max(0, Number(startIndex || 0)); index < text.length; index += 1) {
+    const char = text[index];
+    if (quote === "'") {
+      if (char === "'") quote = "";
+      continue;
+    }
+    if (escaped) {
+      escaped = false;
+      continue;
+    }
+    if (char === "\\") {
+      escaped = true;
+      continue;
+    }
+    if (quote === '"') {
+      if (char === '"') quote = "";
+      continue;
+    }
+    if (char === "'" || char === '"') {
+      quote = char;
+      continue;
+    }
+    if (char !== ";") continue;
+    const suffix = text.slice(index + 1).match(/^\s*([A-Za-z]+)\b/u);
+    if (String(suffix?.[1] || "").toLowerCase() === expected) return index;
+  }
+  return -1;
+}
+
+function boundedTestAvailabilityProbe(value = "") {
+  let command = normalizeProjectCommand(value);
+  if (!command || /(?:`|\$\()/u.test(command)) return false;
+  command = command
+    .replace(/(?:^|\s)(?:\d*>>?|&>>?)\s*(?:"\/dev\/null"|'\/dev\/null'|\/dev\/null)/gu, " ")
+    .trim()
+    .replace(/^(?:[A-Za-z_]\w*=(?:"[^"\n]*"|'[^'\n]*'|[^\s;&|]+)\s*)+/u, "")
+    .trim();
+  const tokens = tokenizeShellWords(command);
+  if (
+    ["command", "which"].includes(String(tokens[0] || "")) &&
+    (tokens[0] !== "command" || tokens[1] === "-v")
+  ) {
+    const target = tokens[0] === "command" ? tokens[2] : tokens[1];
+    return Boolean(target && /^[A-Za-z0-9_.+-]+$/u.test(target) && tokens.length <= 3);
+  }
+  const executable = String(tokens[0] || "").split(/[\\/]/u).at(-1) || "";
+  const codeIndex = tokens.indexOf("-c");
+  if (!/^python(?:\d+(?:\.\d+)*)?$/iu.test(executable) || codeIndex < 1) return false;
+  const code = String(tokens[codeIndex + 1] || "").trim();
+  if (!code || codeIndex + 2 !== tokens.length) return false;
+  return /^(?:import\s+[A-Za-z_]\w*(?:\.[A-Za-z_]\w*)*|from\s+[A-Za-z_]\w*(?:\.[A-Za-z_]\w*)*\s+import\s+[A-Za-z_]\w*)$/u.test(
+    code
+  );
+}
+
+function boundedTestCommandClassification(value = "") {
+  const command = normalizeProjectCommand(value);
+  const executableCommand = command
+    .replace(/^(?:[A-Za-z_]\w*=(?:"[^"\n]*"|'[^'\n]*'|[^\s;&|]+)\s*)+/u, "")
+    .trim();
+  return {
+    command,
+    executableCommand,
+    policy: classifyCommand(executableCommand),
+  };
+}
+
+function parseBoundedConditionalTestWrapper(value = "") {
+  let normalized = normalizeProjectCommand(value);
+  if (!normalized) return null;
+  normalized = normalized.replace(
+    /^cd\s+(?:"[^"\n]+"|'[^'\n]+'|[^\s;&|]+)\s*&&\s*/u,
+    ""
+  );
+  if (!/^if\s+/u.test(normalized)) return null;
+  const thenAt = unquotedShellControlDelimiter(normalized, "then", 3);
+  if (thenAt < 0) return null;
+  const thenMatch = normalized.slice(thenAt + 1).match(/^\s*then\b/u);
+  if (!thenMatch) return null;
+  const thenBodyStart = thenAt + 1 + thenMatch[0].length;
+  const elseAt = unquotedShellControlDelimiter(normalized, "else", thenBodyStart);
+  if (elseAt < 0) return null;
+  const elseMatch = normalized.slice(elseAt + 1).match(/^\s*else\b/u);
+  if (!elseMatch) return null;
+  const elseBodyStart = elseAt + 1 + elseMatch[0].length;
+  const fiAt = unquotedShellControlDelimiter(normalized, "fi", elseBodyStart);
+  if (fiAt < 0 || !/^\s*fi\s*$/u.test(normalized.slice(fiAt + 1))) return null;
+
+  const condition = normalized.slice(3, thenAt).trim();
+  const thenCommand = normalizeProjectCommand(
+    normalized.slice(thenBodyStart, elseAt).trim()
+  );
+  const elseCommand = normalizeProjectCommand(
+    normalized.slice(elseBodyStart, fiAt).trim()
+  );
+  if (!boundedTestAvailabilityProbe(condition)) return null;
+  const branches = [thenCommand, elseCommand];
+  const classifications = branches.map((candidate) =>
+    boundedTestCommandClassification(candidate)
+  );
+  const policies = classifications.map((candidate) => candidate.policy);
+  if (
+    branches.some((candidate) => {
+      const sequence = parseTopLevelShellSequence(candidate);
+      return (
+        !candidate ||
+        sequence.openQuote ||
+        sequence.trailingEscape ||
+        sequence.trailingSeparator ||
+        sequence.commands.length !== 1
+      );
+    }) ||
+    policies.some((policy) => policy.substantiveTest !== true)
+  ) {
+    return null;
+  }
+  return {
+    command: thenCommand,
+    alternateCommand: elseCommand,
+    wrappedCommand: normalizeProjectCommand(value),
+    statusSource: "process",
+    semanticallyReadOnly: policies.every(
+      (policy, index) =>
+        !commandCanMutateProjectContent(
+          classifications[index].executableCommand,
+          policy
+        )
+    ),
+  };
+}
+
+function capturedStatusEcho(value = "", statusVariable = "") {
+  const label =
+    "(?:(?:[A-Z][A-Z0-9_]{0,31}_)?(?:EXIT|STATUS|RESULT)(?:_CODE)?)";
+  const variable = String(statusVariable || "");
+  const statusOperand = variable
+    ? `\\$(?:\\{${variable.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&")}\\}|${variable.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&")})`
+    : "\\$\\?";
+  return String(value || "").trim().match(
+    new RegExp(
+      `^echo\\s+(?:-n\\s+)?["']?(?<label>${label})\\s*[:=]\\s*${statusOperand}["']?$`,
+      "iu"
+    )
+  );
+}
+
+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)
+  ) {
+    return true;
+  }
+  if (
+    ["cat", "grep", "head", "stat", "tail", "wc"].includes(
+      String(tokens[0] || "")
+    ) &&
+    !/(?:`|\$\(|[|<>])/u.test(command)
+  ) {
+    return true;
+  }
+  const policy = classifyCommand(command);
+  return (
+    policy.writesWorkspace !== true &&
+    policy.mayMutateProject !== true &&
+    policy.substantiveTest !== true
+  );
+}
+
 function parseCapturedTestExitStatusWrapper(value = "") {
   const normalized = normalizeProjectCommand(value);
   if (!normalized) return null;
@@ -5044,7 +5228,7 @@ function parseCapturedTestExitStatusWrapper(value = "") {
       sequence.openQuote ||
       sequence.trailingEscape ||
       (sequence.trailingSeparator && sequence.trailingSeparator !== ";") ||
-      sequence.commands.length < 3
+      sequence.commands.length < 1
     ) {
       continue;
     }
@@ -5071,7 +5255,7 @@ function parseCapturedTestExitStatusWrapper(value = "") {
         continue;
       }
       const testCommand = normalizeProjectCommand(sequence.commands[index - 1]);
-      if (classifyCommand(testCommand).substantiveTest !== true) continue;
+      if (boundedTestCommandClassification(testCommand).policy.substantiveTest !== true) continue;
       return {
         command: testCommand,
         wrappedCommand: normalized,
@@ -5080,10 +5264,159 @@ function parseCapturedTestExitStatusWrapper(value = "") {
         statusVariable,
       };
     }
+
+    for (let index = 0; index < sequence.commands.length - 1; index += 1) {
+      const testCommand = normalizeProjectCommand(sequence.commands[index]);
+      const directEcho = capturedStatusEcho(sequence.commands[index + 1]);
+      if (
+        !directEcho ||
+        boundedTestCommandClassification(testCommand).policy.substantiveTest !== true
+      ) {
+        continue;
+      }
+      if (
+        sequence.commands.slice(0, index).some(
+          (candidate) => !boundedReadOnlyTestPrefixCommand(candidate)
+        ) ||
+        sequence.commands.length !== index + 2
+      ) {
+        continue;
+      }
+      const outsideGroup = `${normalized.slice(0, group.start)} ${normalized.slice(group.end + 1)}`;
+      if (
+        /\b(?:echo|printf)\b[^;&|\n]{0,240}\b(?:EXIT|STATUS|RESULT)(?:_CODE)?\s*[:=]/iu.test(
+          outsideGroup
+        )
+      ) {
+        continue;
+      }
+      return {
+        command: testCommand,
+        wrappedCommand: normalized,
+        label: String(directEcho.groups?.label || "").toUpperCase(),
+        statusSource: "captured-group",
+      };
+    }
+
+    const bodyCommands = sequence.commands.map((candidate) =>
+      normalizeProjectCommand(candidate)
+    );
+    const testCommand = bodyCommands.at(-1) || "";
+    if (
+      boundedTestCommandClassification(testCommand).policy.substantiveTest !== true ||
+      bodyCommands.slice(0, -1).some(
+        (candidate) => !boundedReadOnlyTestPrefixCommand(candidate)
+      )
+    ) {
+      continue;
+    }
+    const suffix = normalized
+      .slice(group.end + 1)
+      .replace(
+        /^\s*(?:(?:\d*>>?|&>>?)\s*(?:"[^"\n]+"|'[^'\n]+'|&\d+|[^\s;&|]+)\s*)+/u,
+        ""
+      )
+      .replace(/^\s*;\s*/u, "");
+    const suffixSequence = parseTopLevelShellSequence(suffix);
+    if (
+      !suffix ||
+      suffixSequence.openQuote ||
+      suffixSequence.trailingEscape ||
+      suffixSequence.trailingSeparator ||
+      suffixSequence.commands.length < 2
+    ) {
+      continue;
+    }
+    const statusAssignment = String(suffixSequence.commands[0] || "")
+      .trim()
+      .match(/^([A-Za-z_]\w*)\s*=\s*\$\?$/u);
+    if (!statusAssignment) continue;
+    const statusEcho = capturedStatusEcho(
+      suffixSequence.commands[1],
+      statusAssignment[1]
+    );
+    if (!statusEcho) continue;
+    if (
+      suffixSequence.commands.slice(2).some((candidate) => {
+        if (
+          /\b(?:echo|printf)\b[^;&|\n]{0,240}\b(?:[A-Z][A-Z0-9_]{0,31}_)?(?:EXIT|STATUS|RESULT)(?:_CODE)?\s*[:=]/iu.test(
+            candidate
+          )
+        ) {
+          return true;
+        }
+        return !boundedReadOnlyTestPrefixCommand(candidate);
+      })
+    ) {
+      continue;
+    }
+    return {
+      command: testCommand,
+      wrappedCommand: normalized,
+      label: String(statusEcho.groups?.label || "").toUpperCase(),
+      statusSource: "captured-group",
+      statusVariable: statusAssignment[1],
+    };
   }
   return null;
 }
 
+function projectTestCommandWrapper(command = "") {
+  return (
+    parseCapturedTestExitStatusWrapper(command) ||
+    parseBoundedConditionalTestWrapper(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) ||
@@ -5161,6 +5494,7 @@ function isRetainedExactVerificationCommand(command = "", config = {}) {
 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;
   if (!text) return false;
   const classification = classifyCommand(text);
@@ -5278,9 +5612,16 @@ function explicitExitProbeStatus(command = "", result = {}) {
 
   let status = parseExplicitExitStatus(result.stdout || "");
   if (status === null && exitProbe.statusSource === "captured-group") {
+    const escapedLabel = String(exitProbe.label || "")
+      .replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
     const matches = [
       ...String(result.stdout || "").matchAll(
-        /(?:^|\n)\s*(?:EXIT|STATUS|RESULT)(?:_CODE)?\s*[:=]\s*(-?\d+)\s*(?=\n|$)/giu
+        escapedLabel
+          ? new RegExp(
+              `(?:^|\\n)\\s*${escapedLabel}\\s*[:=]\\s*(-?\\d+)\\s*(?=\\n|$)`,
+              "giu"
+            )
+          : /(?:^|\n)\s*(?:EXIT|STATUS|RESULT)(?:_CODE)?\s*[:=]\s*(-?\d+)\s*(?=\n|$)/giu
       ),
     ];
     if (matches.length) status = Number(matches.at(-1)[1]);
@@ -6853,6 +7194,7 @@ export function recordProjectVerificationOutcome(state = {}, toolResult = {}, co
 
   if (toolName === "run_command") {
     const command = normalizeProjectCommand(toolResult.args?.command || "");
+    const testCommandWrapper = projectTestCommandWrapper(command);
     const retainedExactVerification = isRetainedExactVerificationCommand(
       command,
       config
@@ -6962,14 +7304,20 @@ 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 &&
         !retainedExactVerification &&
+        testCommandWrapper?.semanticallyReadOnly !== true &&
         !disposableGeneratedCleanup &&
         !disposableGeneratedVerificationSideEffects &&
         !scopedTaskArtifactWrite &&
         !readOnlyArtifactValidation &&
+        !nonMutatingTestOutputPipeline &&
         (commandSucceeded || commandMutationPaths.length > 0) &&
         (
           commandCanMutateProjectContent(mutationCommand, commandPolicy) ||
@@ -6990,6 +7338,12 @@ export function recordProjectVerificationOutcome(state = {}, toolResult = {}, co
     if (readOnlyArtifactValidation) {
       toolResult.readOnlyArtifactValidation = true;
     }
+    if (nonMutatingTestOutputPipeline) {
+      toolResult.nonAuthoritativeTestOutputPipeline = true;
+    }
+    if (testCommandWrapper?.semanticallyReadOnly === true) {
+      toolResult.boundedReadOnlyTestWrapper = true;
+    }
     let requiredBatch = currentRequiredCommandBatch(verification, requiredCommands);
     const activeExecutionContract = state.meta?.activeExecutionContract;
     const activeTurnCommands =
@@ -13043,6 +13397,7 @@ function commandWritesOnlyEvidenceMatching(command = "", pathMatches = () => fal
       .trim();
     if (!withoutAssignments) return true;
     const commandTokens = tokenizeShellWords(withoutAssignments);
+    if (boundedReadOnlyTestPrefixCommand(withoutAssignments)) return true;
     const teeTargets = evidenceTargetsFromTee(commandTokens);
     if (teeTargets.length) {
       const safe = teeTargets.every(pathMatches);
@@ -22341,6 +22696,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}`
         : "",