@lazyingart/agintiflow 0.20.244 → 0.20.246

package/package.json

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

@@ -164,10 +164,71 @@ const compactionState = {
         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({
@@ -233,6 +294,11 @@ 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/);
@@ -248,9 +314,92 @@ const deepSeekRuntimeText = deepSeekRuntimeMessages.map((message) => message.con
 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"
 );
 
+function noisyFullReadPair(index, generation) {
+  const id = `validator-${generation}-${index}`;
+  const file = `tmp/validator-${generation}-${index}.py`;
+  return [
+    {
+      role: "assistant",
+      content: "",
+      reasoning_content: "Inspect the latest validator.",
+      tool_calls: [
+        {
+          id,
+          type: "function",
+          function: { name: "read_file", arguments: JSON.stringify({ path: file }) },
+        },
+      ],
+    },
+    {
+      role: "tool",
+      tool_call_id: id,
+      content: JSON.stringify({
+        ok: true,
+        toolName: "read_file",
+        path: file,
+        bytes: 4096,
+        lineCount: 120,
+        sha256: `${generation}${String(index).padStart(2, "0")}`.repeat(24).slice(0, 64),
+        contentTruncated: false,
+        content: `VALIDATOR-${generation}-${index}\n${"broad validator content ".repeat(150)}`,
+      }),
+    },
+  ];
+}
+
+const twiceCompactedState = {
+  ...compactionState,
+  messages: [
+    ...deepSeekRuntimeMessages,
+    ...Array.from({ length: 14 }, (_, index) => noisyFullReadPair(index + 1, 2)).flat(),
+  ],
+};
+const twiceCompacted = buildContextBudgetCompactionMessages(
+  twiceCompactedState,
+  { ...config, provider: "deepseek", model: "deepseek-chat" },
+  { title: "", url: "" },
+  8,
+  { reason: "second DeepSeek compaction" }
+);
+const twiceCompactedText = twiceCompacted.map((message) => message.content || "").join("\n");
+assert.ok(twiceCompactedText.includes("reliability-evidence-v14"));
+assert.ok(twiceCompactedText.includes("EVIDENCE-CHUNK-ONE"));
+assert.ok(twiceCompactedText.includes("EVIDENCE-CHUNK-TWO"));
+assert.equal(
+  (twiceCompactedText.match(/Tool: deep_research/g) || []).length,
+  1,
+  "second DeepSeek compaction duplicated the completed research record"
+);
+
+const thriceCompactedState = {
+  ...compactionState,
+  messages: [
+    ...twiceCompacted,
+    ...Array.from({ length: 14 }, (_, index) => noisyFullReadPair(index + 1, 3)).flat(),
+  ],
+};
+const thriceCompacted = buildContextBudgetCompactionMessages(
+  thriceCompactedState,
+  { ...config, provider: "deepseek", model: "deepseek-chat" },
+  { title: "", url: "" },
+  12,
+  { reason: "third DeepSeek compaction" }
+);
+const thriceCompactedText = thriceCompacted.map((message) => message.content || "").join("\n");
+assert.ok(thriceCompactedText.includes("reliability-evidence-v14"));
+assert.ok(thriceCompactedText.includes("EVIDENCE-CHUNK-ONE"));
+assert.ok(thriceCompactedText.includes("EVIDENCE-CHUNK-TWO"));
+assert.ok(
+  estimateMessageTokens(thriceCompacted) <= 12288,
+  "cumulative DeepSeek 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");