@lazyingart/agintiflow 0.20.263 → 0.20.265

package/package.json

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

@@ -8,6 +8,7 @@ import {
   genericArtifactFilenameBlock,
   modelTimeoutExhaustionRoute,
   modelTimeoutRetryRoute,
+  normalizeNoMatchQueryResult,
   applyModelTimeoutRetryRoute,
   recoverFocusedTextRewriteWithWritingSpecialist,
   repairModelMessageHistory,
@@ -956,6 +957,33 @@ try {
   );
   assert(readonlyVersionPipelinePolicy.allowed, "read-only version probe pipelines should not require package-install-policy=allow");
   assert(readonlyVersionPipelinePolicy.category === "read-only", "read-only version probe pipelines should be classified as read-only");
+  const pgrepNoMatchPolicy = evaluateCommandPolicy(
+    "pgrep -af gateway_service",
+    dockerWorkspaceNoInstallsPolicy
+  );
+  assert(
+    pgrepNoMatchPolicy.allowed &&
+      pgrepNoMatchPolicy.category === "read-only" &&
+      pgrepNoMatchPolicy.noMatchExitIsSuccess === true,
+    "pgrep should be a read-only query whose no-match exit is meaningful evidence"
+  );
+  const pgrepNoMatchResult = normalizeNoMatchQueryResult(
+    { ok: false, exitCode: 1, stdout: "", stderr: "" },
+    pgrepNoMatchPolicy
+  );
+  assert(
+    pgrepNoMatchResult.ok === true &&
+      pgrepNoMatchResult.noMatch === true &&
+      pgrepNoMatchResult.semanticOutcome === "no-match",
+    "pgrep exit 1 with no diagnostics should normalize to successful no-match evidence"
+  );
+  assert(
+    normalizeNoMatchQueryResult(
+      { ok: false, exitCode: 2, stdout: "", stderr: "invalid option" },
+      pgrepNoMatchPolicy
+    ).ok === false,
+    "an actual pgrep error was incorrectly normalized as no-match evidence"
+  );
   const readonlyDiffSlicePolicy = evaluateCommandPolicy(
     "git diff -- src/agent-runner.js | sed -n '1,240p'",
     dockerWorkspaceNoInstallsPolicy
@@ -1000,6 +1028,16 @@ try {
   );
   assert(pythonUnittestPolicy.allowed, "stdlib python unittest should be allowed without package installs");
   assert(pythonUnittestPolicy.category === "test", "stdlib python unittest should be classified as test");
+  const pythonNoBytecodeAcceptancePolicy = evaluateCommandPolicy(
+    "PYTHONDONTWRITEBYTECODE=1 python3 /tmp/devops_sensor_gateway_contract.py",
+    dockerWorkspaceNoInstallsPolicy
+  );
+  assert(
+    pythonNoBytecodeAcceptancePolicy.allowed &&
+      pythonNoBytecodeAcceptancePolicy.category === "test" &&
+      pythonNoBytecodeAcceptancePolicy.substantiveTest === true,
+    "a no-bytecode Python acceptance command should retain substantive test classification"
+  );
   const pythonDemoPolicy = evaluateCommandPolicy("python3 demo.py 2>&1", dockerWorkspaceNoInstallsPolicy);
   assert(pythonDemoPolicy.allowed, "workspace-local python demo script should be allowed without package installs");
   assert(pythonDemoPolicy.category === "toolchain", "workspace-local python demo script should be classified as toolchain");

package/scripts/smoke-deep-research.js

@@ -215,6 +215,40 @@ async function main() {
     )) === JSON.stringify({ type: "function", function: { name: "apply_patch" } }),
     "DeepSeek failed-test repair did not force its sole bounded mutation tool"
   );
+  assert(
+    JSON.stringify(toolChoiceForProvider(
+      {
+        provider: "deepseek",
+        testFailureRepairActive: true,
+        testFailureRepairMutationRequired: true,
+        testFailureRepairOptionalRereadPaths: ["service.py"],
+      },
+      [{ role: "user", content: "Apply the coherent repair from retained evidence." }],
+      [
+        { type: "function", function: { name: "read_file" } },
+        { type: "function", function: { name: "apply_patch" } },
+        { type: "function", function: { name: "finish" } },
+      ]
+    )) === JSON.stringify({ type: "function", function: { name: "apply_patch" } }),
+    "DeepSeek bounded reread fallback displaced the required repair mutation"
+  );
+  assert(
+    JSON.stringify(toolChoiceForProvider(
+      {
+        provider: "deepseek",
+        testFailureRepairActive: true,
+        testFailureRepairMutationRequired: true,
+        testFailureRepairNeedsPatchContext: true,
+      },
+      [{ role: "user", content: "Continue from the retained failing test evidence." }],
+      [
+        { type: "function", function: { name: "read_file" } },
+        { type: "function", function: { name: "apply_patch" } },
+        { type: "function", function: { name: "finish" } },
+      ]
+    )) === JSON.stringify({ type: "function", function: { name: "read_file" } }),
+    "DeepSeek failed-test repair did not force its bounded context refresh first"
+  );
   assert(
     toolChoiceForProvider(
       { provider: "deepseek" },
@@ -292,6 +326,61 @@ async function main() {
     !Object.hasOwn(deepSeekActionPayload || {}, "reasoning_effort"),
     "DeepSeek action-only recovery sent a conflicting reasoning effort"
   );
+  let deepSeekRepairReadPayload = null;
+  await requestNextStep(
+    {
+      chat: {
+        completions: {
+          create: async (payload) => {
+            deepSeekRepairReadPayload = payload;
+            return {
+              choices: [{
+                message: {
+                  role: "assistant",
+                  content: "",
+                  tool_calls: [{
+                    id: "deepseek-repair-read",
+                    type: "function",
+                    function: {
+                      name: "read_file",
+                      arguments: JSON.stringify({ path: "service.py" }),
+                    },
+                  }],
+                },
+              }],
+            };
+          },
+        },
+      },
+    },
+    {
+      provider: "deepseek",
+      model: "deepseek-v4-pro",
+      reasoning: "xhigh",
+      goal: "Repair service.py from the exact failed test evidence.",
+      taskProfile: "code",
+      allowFileTools: true,
+      allowShellTool: false,
+      allowWebSearch: false,
+      allowMcpTools: false,
+      allowWrapperTools: false,
+      allowAuxiliaryTools: false,
+      testFailureRepairActive: true,
+      testFailureRepairMutationRequired: true,
+      testFailureRepairNeedsPatchContext: true,
+      testFailureRepairPatchTargets: ["service.py"],
+      testFailureRepairContextPaths: ["service.py"],
+    },
+    [{ role: "user", content: "Continue from the retained failing test evidence." }]
+  );
+  assert(
+    deepSeekRepairReadPayload?.tool_choice?.function?.name === "read_file",
+    "DeepSeek failed-test repair request did not force the bounded context read"
+  );
+  assert(
+    deepSeekRepairReadPayload?.thinking?.type === "disabled",
+    "DeepSeek failed-test context refresh spent another unbounded reasoning pass"
+  );
 
   assert(!isPublicWebUrl("http://127.0.0.1/private"), "public URL guard accepted loopback");
   assert(!isPublicWebUrl("http://10.0.0.1/private"), "public URL guard accepted RFC1918 address");

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

@@ -2,6 +2,7 @@
 import crypto from "node:crypto";
 import { spawnSync } from "node:child_process";
 import fs from "node:fs/promises";
+import net from "node:net";
 import os from "node:os";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
@@ -59,6 +60,7 @@ import {
   completionExternalBlockerCanClose,
   pythonTopLevelDefinitionDuplicates,
   recordCanonicalGeneratedOutputProgress,
+  recordAlreadyCommittedRepositoryRepair,
   recordProjectVerificationOutcome,
   recordExactOutputProgress,
   recordStaticDiscoveryProgress,
@@ -264,7 +266,7 @@ try {
         }],
       },
       failedTestDiagnostic: {
-        packetVersion: 13,
+        packetVersion: 15,
         mutationRevision: 0,
         failureSignature: "python-entrypoint-order",
         focuses: [{
@@ -645,6 +647,137 @@ try {
     )) === null,
     "the exact cwd-independent agent-created test harness repair was blocked"
   );
+  const foreignListener = net.createServer((socket) => socket.end());
+  await new Promise((resolve, reject) => {
+    foreignListener.once("error", reject);
+    foreignListener.listen(0, "127.0.0.1", resolve);
+  });
+  try {
+    const collisionPort = Number(foreignListener.address()?.port || 0);
+    assert(collisionPort >= 1024, "failed to allocate the foreign-listener smoke port");
+    await fs.writeFile(
+      path.join(baselineWorkspace, "service_ctl.py"),
+      [
+        "from pathlib import Path",
+        "",
+        'GATEWAY = Path(__file__).resolve().parent / "gateway_service.py"',
+        "raise SystemExit(0)",
+        "",
+      ].join("\n"),
+      "utf8"
+    );
+    await fs.writeFile(
+      path.join(baselineWorkspace, "gateway_service.py"),
+      "print('sensor gateway fixture')\n",
+      "utf8"
+    );
+    const portCollisionSource = [
+      "import subprocess",
+      "import sys",
+      "import unittest",
+      "from pathlib import Path",
+      "",
+      'SERVICE_CTL = (Path(__file__).resolve().parent / "../service_ctl.py").resolve()',
+      "",
+      "class TestLifecycle(unittest.TestCase):",
+      "    def test_start(self):",
+      `        first = subprocess.run([sys.executable, SERVICE_CTL, "start", "--port", "${collisionPort}"], capture_output=True)`,
+      `        second = subprocess.run([sys.executable, SERVICE_CTL, "status", "--port", "${collisionPort}"], capture_output=True)`,
+      "        self.assertEqual(first.returncode, 0)",
+      "        self.assertEqual(second.returncode, 0)",
+      "",
+    ].join("\n");
+    await fs.writeFile(harnessTestPath, portCollisionSource, "utf8");
+    const portCollisionState = {
+      meta: {
+        projectVerification: {
+          mutationRevision: 5,
+          discoveredTests: ["tests/test_service_lifecycle.py"],
+          testRuns: [{
+            command: "python3 -m unittest discover -s tests -v",
+            mutationRevision: 5,
+            passed: false,
+            failureEvidenceVersion: 2,
+            failureSignature: "agent-created-test-foreign-port-collision",
+            failureSummary:
+              "test_start AssertionError: 1 != 0 while starting the task service",
+          }],
+        },
+      },
+    };
+    const portCollisionPacket = await buildFailedTestRecoveryPacket(
+      { commandCwd: baselineWorkspace },
+      portCollisionState
+    );
+    const portCollisionFocus = portCollisionState.meta.failedTestDiagnostic.focuses.find(
+      (focus) => focus.kind === "python-agent-test-foreign-port-collision"
+    );
+    assert(
+      portCollisionPacket.content.includes("Foreign listener collision") &&
+        portCollisionPacket.paths.includes("gateway_service.py") &&
+        portCollisionFocus?.path === "tests/test_service_lifecycle.py" &&
+        portCollisionFocus?.ports?.[0] === collisionPort &&
+        portCollisionFocus?.portOccurrences === 2 &&
+        portCollisionFocus?.listenerEvidence?.[0]?.ownership === "outside-task-workspace" &&
+        portCollisionFocus?.testNames?.join(",") === "test_start" &&
+        portCollisionFocus?.assertionCount === 2,
+      "a foreign hard-coded port or its exact executable dependency was not retained for repair"
+    );
+    const dynamicPortSource = [
+      "import socket",
+      "import subprocess",
+      "import sys",
+      "import unittest",
+      "from pathlib import Path",
+      "",
+      'SERVICE_CTL = (Path(__file__).resolve().parent / "../service_ctl.py").resolve()',
+      "",
+      "def free_port():",
+      "    with socket.socket() as probe:",
+      '        probe.bind(("127.0.0.1", 0))',
+      "        return probe.getsockname()[1]",
+      "",
+      "class TestLifecycle(unittest.TestCase):",
+      "    def test_start(self):",
+      "        port = free_port()",
+      "        first = subprocess.run([sys.executable, SERVICE_CTL, \"start\", \"--port\", str(port)], capture_output=True)",
+      "        second = subprocess.run([sys.executable, SERVICE_CTL, \"status\", \"--port\", str(port)], capture_output=True)",
+      "        self.assertEqual(first.returncode, 0)",
+      "        self.assertEqual(second.returncode, 0)",
+      "",
+    ].join("\n");
+    assert(
+      (await failedTestRepairPatchBlock(
+        portCollisionState,
+        "apply_patch",
+        {
+          path: "tests/test_service_lifecycle.py",
+          search: portCollisionSource,
+          replace: dynamicPortSource.replace(
+            "        self.assertEqual(second.returncode, 0)",
+            "        self.assertTrue(True)"
+          ),
+        },
+        { commandCwd: baselineWorkspace }
+      ))?.category === "failed-test-regression",
+      "foreign-port isolation was allowed to change the assertion-method contract"
+    );
+    assert(
+      (await failedTestRepairPatchBlock(
+        portCollisionState,
+        "apply_patch",
+        {
+          path: "tests/test_service_lifecycle.py",
+          search: portCollisionSource,
+          replace: dynamicPortSource,
+        },
+        { commandCwd: baselineWorkspace }
+      )) === null,
+      "a complete dynamic-port rewrite of the Git-new test was blocked"
+    );
+  } finally {
+    await new Promise((resolve) => foreignListener.close(resolve));
+  }
   for (const args of [
     ["add", "service_ctl.py", "tests/test_service_lifecycle.py"],
     ["commit", "-m", "tracked harness boundary"],
@@ -667,9 +800,11 @@ try {
   );
   assert(
     !trackedHarnessState.meta.failedTestDiagnostic.focuses.some(
-      (focus) => focus.kind === "python-agent-test-harness-path"
+      (focus) =>
+        focus.kind === "python-agent-test-harness-path" ||
+        focus.kind === "python-agent-test-foreign-port-collision"
     ),
-    "the agent-created test exception was incorrectly applied to a tracked authoritative test"
+    "an agent-created test exception was incorrectly applied to a tracked authoritative test"
   );
   await fs.mkdir(path.join(workspace, "tests"), { recursive: true });
   await fs.writeFile(
@@ -1961,6 +2096,36 @@ try {
     }
   );
   assert(coveredTestQuality.ok === true, coveredTestQuality.reason);
+  const coveredBeforeAcceptanceQuality = await validateMutatedPythonSourceQuality(
+    { commandCwd: pythonQualityWorkspace },
+    {
+      meta: {
+        projectVerification: {
+          mutationRevision: 3,
+          privateMutationRevision: 0,
+          mutationHistory: [{ revision: 3, paths: ["tests/test_service_launch.py"] }],
+          testRuns: [
+            {
+              command: "PYTHONDONTWRITEBYTECODE=1 python3 -m unittest discover -s tests -v",
+              mutationRevision: 3,
+              privateMutationRevision: 0,
+              passed: true,
+            },
+            {
+              command: "python3 /tmp/project_acceptance.py",
+              mutationRevision: 3,
+              privateMutationRevision: 0,
+              passed: true,
+            },
+          ],
+        },
+      },
+    }
+  );
+  assert(
+    coveredBeforeAcceptanceQuality.ok === true,
+    "a later passing acceptance verifier erased current unit-suite coverage for a changed test"
+  );
   assert(normalizeDynamicStepsMode("off") === "off", "dynamic mode off did not normalize");
   for (const command of [
     "npm run build",
@@ -5078,6 +5243,69 @@ try {
       leadingContinuationUpdate?.refreshExecutionContract,
     "a leading bare continuation clause followed by concrete details became a new task"
   );
+  const activeTaskContinuationState = structuredClone(concreteContinuationState);
+  const retainedActiveTaskVerification = activeTaskContinuationState.meta.projectVerification;
+  const activeTaskContinuationUpdate = applyContinuationContractTransition(
+    activeTaskContinuationState,
+    `Continue the exact active DevOps task from the current workspace. Diagnose the retained failures from exact evidence, rerun validation, and commit the coherent repair. ${"Preserve the existing task lineage while applying this correction. ".repeat(12)}`,
+    { at: "2026-08-24T09:59:30.000Z" }
+  );
+  assert(
+    activeTaskContinuationUpdate?.preserveTaskBoundary &&
+      activeTaskContinuationUpdate?.refreshExecutionContract,
+    "an explicit exact active-task continuation opened a new task boundary"
+  );
+  assert(
+    activeTaskContinuationState.meta.projectVerification === retainedActiveTaskVerification,
+    "an exact active-task continuation discarded durable verification evidence"
+  );
+  const postMutationVerifier = "python3 -m unittest discover -s tests -v";
+  const postMutationVerificationState = {
+    goal: "Repair and verify the current service controller.",
+    meta: {
+      goalContract: {
+        revision: 12,
+        currentRequest: "Repair and verify the current service controller.",
+      },
+      activeExecutionContract: {
+        revision: 12,
+        startedMutationRevision: 7,
+        materialMutationRevision: 8,
+        requiresFileMutation: true,
+        requiresSourceGrounding: true,
+      },
+      projectVerification: {
+        mutationRevision: 8,
+        testRuns: [{
+          command: postMutationVerifier,
+          mutationRevision: 7,
+          passed: false,
+          failureEvidenceVersion: 2,
+          failureSignature: "pre-repair-failure",
+        }],
+      },
+      failedTestRecoveryPacket: {
+        packetVersion: 15,
+        mutationRevision: 7,
+        failureSignature: "pre-repair-failure",
+        content: "Bounded failed-test evidence packet v15.",
+      },
+    },
+  };
+  const postMutationVerificationRuntime = nextStepRuntimeConfig(
+    {
+      provider: "deepseek",
+      taskProfile: "devops",
+      commandCwd: workspace,
+      goal: postMutationVerificationState.goal,
+    },
+    postMutationVerificationState
+  );
+  assert(
+    postMutationVerificationRuntime.testVerificationPending === true &&
+      postMutationVerificationRuntime.testVerificationCommand === postMutationVerifier,
+    "a material failed-test repair did not advance directly to its exact retained verifier"
+  );
   const concreteGoalUpdate = applyContinuationContractTransition(
     concreteContinuationState,
     concreteContinuation,
@@ -5716,6 +5944,29 @@ try {
     ) === null,
     "the repeated-read guard blocked an exact source refresh required after a stale patch"
   );
+  assert(
+    repeatedStaticToolBlock(
+      {
+        meta: {
+          toolLoop: {
+            staticCounts: {
+              [staticToolCallSignature("read_file", { path: "service_ctl.py" }, {
+                commandCwd: workspace,
+              })]: 1,
+            },
+            staticTotal: 1,
+          },
+        },
+      },
+      "read_file",
+      { path: "service_ctl.py" },
+      {
+        commandCwd: workspace,
+        testFailureRepairContextPaths: ["service_ctl.py"],
+      }
+    ) === null,
+    "the repeated-read guard blocked an exact bounded failed-test context refresh"
+  );
   assert(
     repeatedStaticToolBlock(
       { meta: { toolLoop: { staticCounts: { [exactReadSignature]: 1 }, staticTotal: 1 } } },
@@ -5916,6 +6167,124 @@ try {
     ) === null,
     "a clean-worktree verification gate could not rerun after a Git-state repair"
   );
+  const successfulRepositoryRepairState = structuredClone(repositoryCleanGateFailure);
+  successfulRepositoryRepairState.goal = "Repair and verify the service lifecycle.";
+  successfulRepositoryRepairState.meta.goalContract = { revision: 4 };
+  successfulRepositoryRepairState.meta.activeExecutionContract = {
+    revision: 4,
+    materialMutationRevision: 6,
+  };
+  const successfulRepositoryCommit = {
+    toolName: "run_command",
+    ok: true,
+    exitCode: 0,
+    args: {
+      command:
+        "git add -- 'gateway_service.py' && git commit -m 'Repair service lifecycle'",
+    },
+    stdout:
+      "[main abcdef1] Repair service lifecycle\n 1 file changed, 1 insertion(+), 1 deletion(-)\n",
+    stderr: "",
+  };
+  recordProjectVerificationOutcome(
+    successfulRepositoryRepairState,
+    successfulRepositoryCommit,
+    { commandCwd: workspace, taskProfile: "devops" }
+  );
+  const successfulRepositoryRepairMarker = recordAlreadyCommittedRepositoryRepair(
+    successfulRepositoryRepairState,
+    successfulRepositoryCommit
+  );
+  const postCommitRepositoryRuntime = nextStepRuntimeConfig(
+    { provider: "deepseek", taskProfile: "devops", commandCwd: workspace },
+    successfulRepositoryRepairState
+  );
+  assert(
+    successfulRepositoryRepairMarker?.source === "successful-commit" &&
+      postCommitRepositoryRuntime.testFailureRepositoryStateRepair !== true &&
+      postCommitRepositoryRuntime.testVerificationPending === true &&
+      postCommitRepositoryRuntime.testVerificationCommand === failedValidationCommand,
+    "a successful bounded repair commit did not advance directly to the exact failed verifier"
+  );
+  const cleanStatusRepositoryRepairState = structuredClone(repositoryCleanGateFailure);
+  cleanStatusRepositoryRepairState.goal = "Resume the committed service repair.";
+  cleanStatusRepositoryRepairState.meta.goalContract = { revision: 5 };
+  cleanStatusRepositoryRepairState.meta.activeExecutionContract = {
+    revision: 5,
+    startedMutationRevision: 6,
+    materialMutationRevision: 6,
+    requiresFileMutation: true,
+    requiresSourceGrounding: true,
+  };
+  cleanStatusRepositoryRepairState.meta.durableGitEvidence = [{
+    action: "commit",
+    goalRevision: 5,
+    mutationRevision: 5,
+  }];
+  const cleanStatusAfterCommit = {
+    toolName: "run_command",
+    ok: true,
+    exitCode: 0,
+    args: { command: "git status --short" },
+    stdout: "",
+    stderr: "",
+  };
+  recordProjectVerificationOutcome(
+    cleanStatusRepositoryRepairState,
+    cleanStatusAfterCommit,
+    { commandCwd: workspace, taskProfile: "devops" }
+  );
+  const cleanStatusRepositoryRepairMarker = recordAlreadyCommittedRepositoryRepair(
+    cleanStatusRepositoryRepairState,
+    cleanStatusAfterCommit
+  );
+  const cleanStatusRepositoryRuntime = nextStepRuntimeConfig(
+    { provider: "deepseek", taskProfile: "devops", commandCwd: workspace },
+    cleanStatusRepositoryRepairState
+  );
+  assert(
+    cleanStatusRepositoryRepairMarker?.source === "clean-status-after-commit" &&
+      cleanStatusRepositoryRuntime.completionFreshMutationRequired !== true &&
+      cleanStatusRepositoryRuntime.testVerificationPending === true &&
+      cleanStatusRepositoryRuntime.testVerificationCommand === failedValidationCommand &&
+      buildKnownConstrainedPhasePlan(
+        { provider: "deepseek", taskProfile: "devops", commandCwd: workspace },
+        cleanStatusRepositoryRepairState,
+        cleanStatusRepositoryRuntime
+      )?.mode === "exact-verification",
+    "current commit plus an exact clean Git status did not recover an interrupted repository repair"
+  );
+  const repeatedDirtyRepositoryResult = {
+    toolName: "run_command",
+    ok: false,
+    exitCode: 1,
+    args: { command: failedValidationCommand },
+    stdout: "",
+    stderr:
+      "AssertionError: repository worktree is not clean after a new unrelated mutation",
+  };
+  recordProjectVerificationOutcome(
+    successfulRepositoryRepairState,
+    repeatedDirtyRepositoryResult,
+    {
+      provider: "deepseek",
+      taskProfile: "devops",
+      commandCwd: workspace,
+      testVerificationPending: true,
+      testVerificationCommand: failedValidationCommand,
+    }
+  );
+  const repeatedDirtyRepositoryRuntime = nextStepRuntimeConfig(
+    { provider: "deepseek", taskProfile: "devops", commandCwd: workspace },
+    successfulRepositoryRepairState
+  );
+  assert(
+    repeatedDirtyRepositoryResult.repositoryStateRepairConsumed === true &&
+      !successfulRepositoryRepairState.meta.repositoryStateRepair &&
+      repeatedDirtyRepositoryRuntime.testFailureRepositoryStateRepair === true &&
+      repeatedDirtyRepositoryRuntime.testVerificationPending !== true,
+    "a consumed repository-repair marker caused an unchanged clean-worktree verifier loop"
+  );
   const oversizedRepositoryState = {
     ...repositoryCleanGateFailure,
     goal: "Complete the current repository task and preserve its established acceptance contract.",
@@ -6379,6 +6748,32 @@ try {
     projectTestVerificationFinishBlock(repairedValidationState) === null,
     "a passing rerun at the current real mutation revision did not reopen completion"
   );
+  const presentationWrappedValidationState = {
+    meta: {
+      projectVerification: {
+        mutationRevision: 7,
+        privateMutationRevision: 0,
+        testRuns: [
+          {
+            command: "python3 -m unittest discover -s tests -v 2>&1",
+            mutationRevision: 2,
+            privateMutationRevision: 0,
+            passed: false,
+          },
+          {
+            command: "PYTHONDONTWRITEBYTECODE=1 python3 -m unittest discover -s tests -v",
+            mutationRevision: 7,
+            privateMutationRevision: 0,
+            passed: true,
+          },
+        ],
+      },
+    },
+  };
+  assert(
+    projectTestVerificationFinishBlock(presentationWrappedValidationState) === null,
+    "presentation-only test wrappers left a superseded failure unresolved"
+  );
   const tracebackEvidence = compactFailedTestEvidence(
     {
       stderr: [
@@ -6472,8 +6867,8 @@ try {
     "a same-task refresh could not rebuild a missing failed-test evidence packet"
   );
   missingRecoveryPacketState.meta.failedTestRecoveryPacket = {
-    packetVersion: 13,
-    content: "Bounded failed-test evidence packet v13.",
+    packetVersion: 15,
+    content: "Bounded failed-test evidence packet v15.",
     mutationRevision: 6,
     failureSignature: "same-failure",
   };
@@ -7331,7 +7726,7 @@ try {
         ],
       },
       failedTestDiagnostic: {
-        packetVersion: 13,
+        packetVersion: 15,
         mutationRevision: 0,
         failureSignature: "partial-derived-order",
         focuses: [

package/scripts/smoke-local-failure-recovery.js

@@ -539,12 +539,12 @@ const focusedRecoveryState = {
       }],
     },
     failedTestRecoveryPacket: {
-      packetVersion: 13,
+      packetVersion: 15,
       mutationRevision: 4,
       failureSignature: "missing-service-seams",
       paths: ["tests/test_service_ctl.py", "service_ctl.py"],
       content: [
-        "Bounded failed-test evidence packet v13.",
+        "Bounded failed-test evidence packet v15.",
         'with mock.patch.object(service_ctl, "launch_service") as launch:',
         'with mock.patch.object(service_ctl, "wait_until_healthy", return_value=True):',
         "### service_ctl.py",
@@ -588,7 +588,7 @@ assert.match(
   focusedRecoveryText,
   /Required acceptance seams: service_ctl\.launch_service, service_ctl\.wait_until_healthy/
 );
-assert.match(focusedRecoveryText, /Bounded failed-test evidence packet v13/);
+assert.match(focusedRecoveryText, /Bounded failed-test evidence packet v15/);
 assert.match(focusedRecoveryText, /requires one coherent source mutation before verification/i);
 
 const durablePatchArgs = {