@lazyingart/agintiflow 0.20.263 → 0.20.264

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lazyingart/agintiflow",
-  "version": "0.20.263",
+  "version": "0.20.264",
   "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-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";
@@ -264,7 +265,7 @@ try {
         }],
       },
       failedTestDiagnostic: {
-        packetVersion: 13,
+        packetVersion: 15,
         mutationRevision: 0,
         failureSignature: "python-entrypoint-order",
         focuses: [{
@@ -645,6 +646,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 +799,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(
@@ -5078,6 +5212,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 +5913,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 } } },
@@ -6472,8 +6692,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 +7551,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 = {