@lazyingart/agintiflow 0.20.243 → 0.20.245

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lazyingart/agintiflow",
-  "version": "0.20.243",
+  "version": "0.20.245",
   "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",
@@ -67,6 +67,7 @@
     "scripts/smoke-supervision-ledger.js",
     "scripts/smoke-integration-production-mount.js",
     "scripts/smoke-integration-production-runtime-bundle.js",
+    "scripts/smoke-integration-retained-idempotency-store.js",
     "scripts/smoke-integration-storage-authority.js",
     "scripts/smoke-integration-retained-durable-common.js",
     "scripts/smoke-integration-retained-file-lock.js",
@@ -205,6 +206,7 @@
     "smoke:supervision-ledger": "node scripts/smoke-supervision-ledger.js",
     "smoke:integration-production-mount": "node scripts/smoke-integration-production-mount.js",
     "smoke:integration-production-runtime-bundle": "node scripts/smoke-integration-production-runtime-bundle.js",
+    "smoke:integration-retained-idempotency-store": "node scripts/smoke-integration-retained-idempotency-store.js",
     "smoke:integration-storage-authority": "node scripts/smoke-integration-storage-authority.js",
     "smoke:integration-retained-durable-common": "node scripts/smoke-integration-retained-durable-common.js",
     "smoke:integration-retained-file-lock": "node scripts/smoke-integration-retained-file-lock.js",
@@ -221,7 +223,7 @@
     "storage:migrate": "node bin/aginti-cli.js storage migrate",
     "publish:env": "node scripts/npm-publish-from-env.js publish --access public",
     "publish:env:whoami": "node scripts/npm-publish-from-env.js whoami",
-    "test": "npm run check && npm run smoke:integration-production-mount && npm run smoke:integration-production-runtime-bundle && npm run smoke:integration-storage-authority && npm run smoke:integration-retained-durable-common && npm run smoke:integration-retained-file-lock && npm run smoke:integration-retained-event-ledger && npm run smoke:integration-retained-event-ledger-bundle && npm run smoke:integration-retained-repository-kernel && npm run smoke:integration-retained-session-state-store && npm run smoke:integration-retained-native-session-repository-state && npm run smoke:integration-retained-native-execution-evidence && npm run smoke:integration-retained-runtime-repository-surface && npm run smoke:integration-retained-runtime-repository-phase-b && npm run smoke:integration-runtime-repository-contract && npm run smoke:integration-runtime-authority && npm run smoke:localllm-provider && npm run smoke:localllm-model-tiers && npm run smoke:localllm-code-routing && npm run smoke:local-failure-recovery && npm run smoke:localllm-auto-max && npm run smoke:local-resource-policy && npm run smoke:context-budget-recovery && npm run smoke:session-runtime && npm run smoke:runtime-core && npm run smoke:progressive-tools && npm run smoke:truthful-completion && npm run smoke:document-artifact-quality && npm run smoke:writing-specialist-routing && npm run eval:local-first-agent && npm run eval:provider-attribution && npm run smoke:runtime-compat && npm run smoke:autoupdate && npm run smoke:web-api && npm run smoke:math-rendering && npm run smoke:web-ui && npm run smoke:web-autostart && npm run smoke:webapp-command && npm run smoke:web-port-fallback && npm run smoke:docker-command && npm run smoke:coding-tools && npm run smoke:dynamic-step-budget && npm run smoke:execution-policy && npm run smoke:aaps-adapter && npm run smoke:auxiliary-tools && npm run smoke:perception-research && npm run smoke:deep-research && npm run smoke:public-research && npm run smoke:safe-chat && npm run smoke:auth && npm run smoke:agentlink && npm run smoke:canvas-artifacts && npm run smoke:capabilities && npm run smoke:mcp && npm run smoke:model-roles && npm run smoke:platform && npm run smoke:permission-modes && npm run smoke:skills && npm run smoke:skillmesh && npm run smoke:supervision-ledger && npm run smoke:tmux-tools && npm run smoke:long-jobs && npm run smoke:run-stdin && npm run smoke:cli-chat && npm run smoke:inbox",
+    "test": "npm run check && npm run smoke:integration-production-mount && npm run smoke:integration-production-runtime-bundle && npm run smoke:integration-retained-idempotency-store && npm run smoke:integration-storage-authority && npm run smoke:integration-retained-durable-common && npm run smoke:integration-retained-file-lock && npm run smoke:integration-retained-event-ledger && npm run smoke:integration-retained-event-ledger-bundle && npm run smoke:integration-retained-repository-kernel && npm run smoke:integration-retained-session-state-store && npm run smoke:integration-retained-native-session-repository-state && npm run smoke:integration-retained-native-execution-evidence && npm run smoke:integration-retained-runtime-repository-surface && npm run smoke:integration-retained-runtime-repository-phase-b && npm run smoke:integration-runtime-repository-contract && npm run smoke:integration-runtime-authority && npm run smoke:localllm-provider && npm run smoke:localllm-model-tiers && npm run smoke:localllm-code-routing && npm run smoke:local-failure-recovery && npm run smoke:localllm-auto-max && npm run smoke:local-resource-policy && npm run smoke:context-budget-recovery && npm run smoke:session-runtime && npm run smoke:runtime-core && npm run smoke:progressive-tools && npm run smoke:truthful-completion && npm run smoke:document-artifact-quality && npm run smoke:writing-specialist-routing && npm run eval:local-first-agent && npm run eval:provider-attribution && npm run smoke:runtime-compat && npm run smoke:autoupdate && npm run smoke:web-api && npm run smoke:math-rendering && npm run smoke:web-ui && npm run smoke:web-autostart && npm run smoke:webapp-command && npm run smoke:web-port-fallback && npm run smoke:docker-command && npm run smoke:coding-tools && npm run smoke:dynamic-step-budget && npm run smoke:execution-policy && npm run smoke:aaps-adapter && npm run smoke:auxiliary-tools && npm run smoke:perception-research && npm run smoke:deep-research && npm run smoke:public-research && npm run smoke:safe-chat && npm run smoke:auth && npm run smoke:agentlink && npm run smoke:canvas-artifacts && npm run smoke:capabilities && npm run smoke:mcp && npm run smoke:model-roles && npm run smoke:platform && npm run smoke:permission-modes && npm run smoke:skills && npm run smoke:skillmesh && npm run smoke:supervision-ledger && npm run smoke:tmux-tools && npm run smoke:long-jobs && npm run smoke:run-stdin && npm run smoke:cli-chat && npm run smoke:inbox",
     "pack:dry-run": "npm pack --dry-run",
     "smoke:capabilities": "node scripts/smoke-capabilities.js"
   },

package/scripts/smoke-context-budget-recovery.js

@@ -125,57 +125,155 @@ const sentPlan = capturedPayload.messages.map((message) => message.content || ""
 assert.ok(sentPlan.includes(HEAD), "plan request lost the exact task head");
 assert.ok(sentPlan.includes(TAIL), "plan request lost the latest task tail");
 
+const compactionState = {
+  goal: hugeGoal,
+  plan: "Use the existing routine and verify its artifact.",
+  messages: [
+    { role: "system", content: "SYSTEM-HEAD\n" + "policy ".repeat(10000) + "\nSYSTEM-TAIL" },
+    { role: "user", content: "first request" },
+    {
+      role: "user",
+      content:
+        "The runtime proactively compacted a long agent history before the provider context became inefficient or unstable. OLD-COMPACTION-MUST-NOT-RECUR",
+    },
+    {
+      role: "assistant",
+      content: "",
+      tool_calls: [
+        {
+          id: "deep-research-complete",
+          type: "function",
+          function: {
+            name: "deep_research",
+            arguments: '{"query":"reliability evidence","outputPath":"reports/reliability.md"}',
+          },
+        },
+      ],
+    },
+    {
+      role: "tool",
+      tool_call_id: "deep-research-complete",
+      content: JSON.stringify({
+        ok: true,
+        toolName: "deep_research",
+        version: 14,
+        researchId: "reliability-evidence-v14",
+        status: "completed",
+        stage: "completed",
+        reportPath: "reports/reliability.md",
+        artifactPath: ".aginti/deep-research-reliability.json",
+        queryCount: 10,
+        sourceCount: 16,
+        answer: "RESEARCH-COMPACTION-SUMMARY",
+        coverage: { requiredFirstPartyVerified: true },
+        audit: { citationCoverage: 1 },
+      }),
+    },
+    {
+      role: "assistant",
+      content: "",
+      tool_calls: [
+        {
+          id: "evidence-chunk-one",
+          type: "function",
+          function: {
+            name: "read_file",
+            arguments: '{"path":"reports/reliability.md","startLine":1,"lineLimit":50}',
+          },
+        },
+      ],
+    },
+    {
+      role: "tool",
+      tool_call_id: "evidence-chunk-one",
+      content: JSON.stringify({
+        ok: true,
+        toolName: "read_file",
+        path: "reports/reliability.md",
+        startLine: 1,
+        lineLimit: 50,
+        lineCount: 100,
+        bytes: 8000,
+        sha256: "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+        contentTruncated: false,
+        content: `EVIDENCE-CHUNK-ONE measured retry findings\n${"retry evidence ".repeat(220)}`,
+      }),
+    },
+    {
+      role: "assistant",
+      content: "",
+      tool_calls: [
+        {
+          id: "evidence-chunk-two",
+          type: "function",
+          function: {
+            name: "read_file",
+            arguments: '{"path":"reports/reliability.md","startLine":51,"lineLimit":50}',
+          },
+        },
+      ],
+    },
+    {
+      role: "tool",
+      tool_call_id: "evidence-chunk-two",
+      content: JSON.stringify({
+        ok: true,
+        toolName: "read_file",
+        path: "reports/reliability.md",
+        startLine: 51,
+        lineLimit: 50,
+        lineCount: 100,
+        bytes: 8000,
+        sha256: "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+        contentTruncated: false,
+        content: `EVIDENCE-CHUNK-TWO limitations and recommendations\n${"limitation evidence ".repeat(180)}`,
+      }),
+    },
+    {
+      role: "tool",
+      content: JSON.stringify({
+        ok: true,
+        toolName: "read_file",
+        path: "/evidence/Musia/SKILL.md",
+        bytes: 2048,
+        sha256: "1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef",
+        contentTruncated: false,
+        content: [
+          "---",
+          "name: musia-music-production",
+          "description: Create and review songs through the established Musia production workflow.",
+          "---",
+          "# Musia Music Production",
+          "Use the existing CLI and preserve the reviewed song artifacts.",
+        ].join("\n"),
+        commandEvidence: [{ command: "node bin/musia.js doctor --json" }],
+        pathEvidence: [{ path: "bin/musia.js" }],
+      }),
+    },
+    {
+      role: "tool",
+      content: JSON.stringify({
+        ok: true,
+        toolName: "list_files",
+        path: "/evidence/LALACHAN/scripts",
+        entries: [{ path: "scripts/xyq_cdp_browser.py" }, { path: "scripts/wait_downloaded_mp4.sh" }],
+      }),
+    },
+    { role: "user", content: "latest interruption: send the finished PDF to this exact chat" },
+  ],
+};
 const runtimeMessages = buildContextBudgetCompactionMessages(
-  {
-    goal: hugeGoal,
-    plan: "Use the existing routine and verify its artifact.",
-    messages: [
-      { role: "system", content: "SYSTEM-HEAD\n" + "policy ".repeat(10000) + "\nSYSTEM-TAIL" },
-      { role: "user", content: "first request" },
-      {
-        role: "user",
-        content:
-          "The runtime proactively compacted a long agent history before the provider context became inefficient or unstable. OLD-COMPACTION-MUST-NOT-RECUR",
-      },
-      {
-        role: "tool",
-        content: JSON.stringify({
-          ok: true,
-          toolName: "read_file",
-          path: "/evidence/Musia/SKILL.md",
-          bytes: 2048,
-          sha256: "1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef",
-          contentTruncated: false,
-          content: [
-            "---",
-            "name: musia-music-production",
-            "description: Create and review songs through the established Musia production workflow.",
-            "---",
-            "# Musia Music Production",
-            "Use the existing CLI and preserve the reviewed song artifacts.",
-          ].join("\n"),
-          commandEvidence: [{ command: "node bin/musia.js doctor --json" }],
-          pathEvidence: [{ path: "bin/musia.js" }],
-        }),
-      },
-      {
-        role: "tool",
-        content: JSON.stringify({
-          ok: true,
-          toolName: "list_files",
-          path: "/evidence/LALACHAN/scripts",
-          entries: [{ path: "scripts/xyq_cdp_browser.py" }, { path: "scripts/wait_downloaded_mp4.sh" }],
-        }),
-      },
-      { role: "user", content: "latest interruption: send the finished PDF to this exact chat" },
-    ],
-  },
+  compactionState,
   config,
   { title: "", url: "" },
   3,
   { reason: "test context recovery" }
 );
 const runtimeText = runtimeMessages.map((message) => message.content || "").join("\n");
+const retainedNativeDeepResearch = runtimeMessages.find((message) =>
+  Array.isArray(message.tool_calls) &&
+  message.tool_calls.some((call) => call?.function?.name === "deep_research")
+);
 assert.ok(
   estimateMessageTokens(runtimeMessages) <= 12288,
   "runtime compaction exceeded the bounded LocalLLM retry target"
@@ -193,8 +291,35 @@ assert.ok(runtimeText.includes("sha256=1234567890abcdef"));
 assert.ok(runtimeText.includes("content=complete"));
 assert.ok(runtimeText.includes("node bin/musia.js doctor --json"));
 assert.ok(runtimeText.includes("scripts/xyq_cdp_browser.py"));
+assert.ok(retainedNativeDeepResearch, "native compaction lost the completed deep_research call");
+assert.ok(runtimeText.includes("reliability-evidence-v14"));
+assert.ok(runtimeText.includes('"version":14'));
+assert.ok(runtimeText.includes("RESEARCH-COMPACTION-SUMMARY"));
+assert.ok(runtimeText.includes("EVIDENCE-CHUNK-ONE"));
+assert.ok(runtimeText.includes("EVIDENCE-CHUNK-TWO"));
+assert.ok(runtimeText.includes("range=lines 1-50"));
+assert.ok(runtimeText.includes("range=lines 51-100"));
 assert.ok(!runtimeText.includes("OLD-COMPACTION-MUST-NOT-RECUR"));
 assert.match(runtimeText, /Do not reread a listed source solely because compaction occurred/);
 assert.match(runtimeText, /never restart a full-file read loop after compaction/);
 
+const deepSeekRuntimeMessages = buildContextBudgetCompactionMessages(
+  compactionState,
+  { ...config, provider: "deepseek", model: "deepseek-chat" },
+  { title: "", url: "" },
+  3,
+  { reason: "test DeepSeek context recovery" }
+);
+const deepSeekRuntimeText = deepSeekRuntimeMessages.map((message) => message.content || "").join("\n");
+assert.ok(deepSeekRuntimeText.includes("Tool: deep_research"));
+assert.ok(deepSeekRuntimeText.includes("reliability-evidence-v14"));
+assert.ok(deepSeekRuntimeText.includes('"version":14'));
+assert.ok(deepSeekRuntimeText.includes("RESEARCH-COMPACTION-SUMMARY"));
+assert.ok(deepSeekRuntimeText.includes("EVIDENCE-CHUNK-ONE"));
+assert.ok(deepSeekRuntimeText.includes("EVIDENCE-CHUNK-TWO"));
+assert.ok(
+  estimateMessageTokens(deepSeekRuntimeMessages) <= 12288,
+  "DeepSeek runtime compaction exceeded the bounded retry target"
+);
+
 console.log("context budget recovery smoke passed");

package/scripts/smoke-integration-production-mount.js

@@ -1105,7 +1105,7 @@ async function main() {
         assert.equal(summary.runtimeBundle.firstBlocker?.component, "idempotencyStore");
         assert.equal(
           summary.runtimeBundle.firstBlocker?.code,
-          "INTEGRATION_DESCRIPTOR_BOUND_IDEMPOTENCY_UNAVAILABLE"
+          "INTEGRATION_IDEMPOTENCY_TRUSTED_RECOVERY_RECEIPT_AUTHORITY_UNAVAILABLE"
         );
       } else {
         assert.equal(summary.runtimeBundle.firstBlocker?.component, "storageAuthority");

package/scripts/smoke-integration-production-runtime-bundle.js

@@ -12,6 +12,9 @@ import {
   openIntegrationProductionRuntimeBundle,
   preflightIntegrationProductionRuntimeBundle,
 } from "../src/integration-production-runtime-bundle.js";
+import {
+  INTEGRATION_RETAINED_IDEMPOTENCY_SNAPSHOT_FILE,
+} from "../src/integration-retained-idempotency-store.js";
 import { contractDigest } from "../src/integration-policy.js";
 
 const UID = process.getuid();
@@ -73,6 +76,7 @@ async function provisionRuntimeRoot(stateRoot, { omitEventLock = false } = {}) {
   await ensureLockFile(paths.repositoryLock);
   await ensureLockFile(paths.sessionLock);
   if (!omitEventLock) await ensureLockFile(paths.eventLedgerLock);
+  await ensureLockFile(paths.idempotencyLock);
   return paths;
 }
 
@@ -215,6 +219,9 @@ async function run() {
     path.join(os.tmpdir(), "aginti-production-runtime-lock-replacement-")
   );
   const failedRoot = await fs.mkdtemp(path.join(os.tmpdir(), "aginti-production-runtime-failed-"));
+  const idempotencyCorruptionRoot = await fs.mkdtemp(
+    path.join(os.tmpdir(), "aginti-production-runtime-idempotency-corrupt-")
+  );
   try {
     const paths = await provisionRuntimeRoot(stateRoot);
     assert.equal(paths.repository, path.join(stateRoot, "runtime-authority", "repository"));
@@ -230,7 +237,7 @@ async function run() {
     assert.equal(check.firstBlocker.component, "idempotencyStore");
     assert.equal(
       check.firstBlocker.code,
-      "INTEGRATION_DESCRIPTOR_BOUND_IDEMPOTENCY_UNAVAILABLE"
+      "INTEGRATION_IDEMPOTENCY_TRUSTED_RECOVERY_RECEIPT_AUTHORITY_UNAVAILABLE"
     );
     assert.equal(check.components.storageAuthority.descriptorBound, true);
     assert.equal(check.components.repository.descriptorBound, true);
@@ -240,7 +247,14 @@ async function run() {
     assert.equal(check.components.eventLedger.runtimeAppendView, true);
     assert.equal(check.components.eventLedger.sessionReadView, true);
     assert.equal(check.components.idempotencyStore.namespaceDescriptorBound, true);
+    assert.equal(check.components.idempotencyStore.descriptorBound, true);
     assert.equal(check.components.idempotencyStore.transactionalStore, false);
+    assert.equal(check.components.idempotencyStore.recoveryAuthorityBound, false);
+    assert.equal(check.components.idempotencyStore.trustedRecoveryReceiptAuthorityBound, false);
+    assert.equal(check.components.idempotencyStore.publicMutationResponseByteEnvelopeCovered, true);
+    assert.equal(check.components.idempotencyStore.boundedTransactionalSubstrate, true);
+    assert.equal(check.components.idempotencyStore.integrationApiCompatibleWhenRecoveryBound, false);
+    assert.notEqual(check.components.idempotencyStore.proofDigest, "0".repeat(64));
     assert.equal(check.components.nativeExecutor.lexicalProofPresent, true);
     assert.equal(check.components.nativeExecutor.retainedSessionStateBound, false);
     assert.equal(check.components.nativeExecutor.artifactEvents, false);
@@ -266,7 +280,7 @@ async function run() {
     assert.equal(bundle.attestation.capabilityEnabled, false);
     assert.equal(bundle.attestation.httpServingEnabled, false);
     assert.equal(bundle.attestation.runtimeActivated, false);
-    assert.equal(bundle.attestation.idempotencyProofDigest, "0".repeat(64));
+    assert.notEqual(bundle.attestation.idempotencyProofDigest, "0".repeat(64));
     assert.equal(bundle.attestation.blockers[0].component, "idempotencyStore");
     assert.equal(bundle.attestation.limitations, INTEGRATION_PRODUCTION_RUNTIME_BUNDLE_LIMITATIONS);
     assert.equal("start" in bundle, false);
@@ -366,6 +380,28 @@ async function run() {
     assert.equal((await recoveredFromFactoryFailure.health()).healthy, true);
     await recoveredFromFactoryFailure.close();
 
+    const corruptIdempotencyPaths = await provisionRuntimeRoot(idempotencyCorruptionRoot);
+    await fs.writeFile(
+      path.join(
+        corruptIdempotencyPaths.idempotency,
+        INTEGRATION_RETAINED_IDEMPOTENCY_SNAPSHOT_FILE
+      ),
+      "{}\n",
+      { mode: 0o600 }
+    );
+    await expectCode(
+      () => openIntegrationProductionRuntimeBundle({
+        stateRoot: idempotencyCorruptionRoot,
+      }),
+      "IDEMPOTENCY_STORE_CORRUPT"
+    );
+    const corruptIdempotencyCheck = await checkIntegrationProductionRuntimeBundle({
+      stateRoot: idempotencyCorruptionRoot,
+    });
+    assert.equal(corruptIdempotencyCheck.healthy, false);
+    assert.equal(corruptIdempotencyCheck.firstBlocker.component, "idempotencyStore");
+    assert.equal(corruptIdempotencyCheck.firstBlocker.code, "IDEMPOTENCY_STORE_CORRUPT");
+
     const [cliSource, serverSource, bundleSource] = await Promise.all([
       fs.readFile(new URL("../src/integration-cli.js", import.meta.url), "utf8"),
       fs.readFile(new URL("../src/integration-server.js", import.meta.url), "utf8"),
@@ -384,6 +420,7 @@ async function run() {
     await fs.rm(lockModeRoot, { recursive: true, force: true });
     await fs.rm(lockReplacementRoot, { recursive: true, force: true });
     await fs.rm(failedRoot, { recursive: true, force: true });
+    await fs.rm(idempotencyCorruptionRoot, { recursive: true, force: true });
   }
 
   process.stdout.write("integration production runtime bundle smoke: ok\n");