@lazyingart/agintiflow 0.20.242 → 0.20.243

package/docs/deep-research-engine.md

@@ -10,6 +10,15 @@ Simple questions should stay on the fast path. A deep-research run spends more
 queries and model calls only when breadth, verification, and traceability add
 real value.
 
+For a request that combines local workspace evidence with web research, the
+outer agent first receives normal inspection tools. After it has read two
+relevant files, or read one file plus inspected/searched the project, the next
+research turn is constrained to `deep_research` and `finish`. This keeps local
+notes authoritative without letting an agent silently replace a requested
+multi-source review with ad hoc browsing. Tool history is scoped to the newest
+genuine user request, so a completed research call from an older task does not
+suppress a later correction or refresh.
+
 ## Architecture
 
 The implementation follows the strongest production patterns without making
@@ -205,7 +214,10 @@ To resume a partial or completed same-query run, pass the returned
 `refresh=true` is explicit. A transient run that retrieved zero allowed sources
 is marked failed, preserves its attempts, and retries retrieval on resume
 instead of caching an empty report as success. Checkpoint schema changes
-invalidate old cached runs automatically.
+invalidate old cached runs automatically. The public tool result also carries
+the research schema version; the outer session reuses a completed result only
+when that version matches the installed engine. Versionless or older retained
+results are refreshed instead of being presented as current evidence.
 
 `outputPath` is optional and must name a Markdown file inside the active
 workspace. Repository internals such as `.git`, dependency trees such as

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lazyingart/agintiflow",
-  "version": "0.20.242",
+  "version": "0.20.243",
   "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",
@@ -66,6 +66,7 @@
     "scripts/supervision-ledger.js",
     "scripts/smoke-supervision-ledger.js",
     "scripts/smoke-integration-production-mount.js",
+    "scripts/smoke-integration-production-runtime-bundle.js",
     "scripts/smoke-integration-storage-authority.js",
     "scripts/smoke-integration-retained-durable-common.js",
     "scripts/smoke-integration-retained-file-lock.js",
@@ -203,6 +204,7 @@
     "supervision:ledger": "node scripts/supervision-ledger.js",
     "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-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",
@@ -219,7 +221,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-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-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-deep-research.js

@@ -3,7 +3,7 @@ import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 
-import { auditResearchSynthesis, deepResearch } from "../src/deep-research.js";
+import { auditResearchSynthesis, deepResearch, RESEARCH_VERSION } from "../src/deep-research.js";
 import { checkToolUse } from "../src/guardrails.js";
 import { flushHousekeeping } from "../src/housekeeping.js";
 import { requestNextStep, toolChoiceForProvider } from "../src/model-client.js";
@@ -59,6 +59,50 @@ async function main() {
     !shouldStartWithDeepResearch(localEvidenceGoal),
     "local-source research incorrectly forced deep_research before workspace inspection"
   );
+  const inspectedLocalEvidenceMessages = [
+    { role: "user", content: localEvidenceGoal },
+    {
+      role: "assistant",
+      tool_calls: [{ id: "inspect-notes", function: { name: "read_file", arguments: '{"path":"PROJECT_NOTES.md"}' } }],
+    },
+    {
+      role: "assistant",
+      tool_calls: [{ id: "inspect-sources", function: { name: "read_file", arguments: '{"path":"sources.json"}' } }],
+    },
+  ];
+  assert(
+    shouldStartWithDeepResearch(localEvidenceGoal, inspectedLocalEvidenceMessages),
+    "local-source research did not enter bounded deep research after workspace inspection"
+  );
+  assert(
+    !shouldStartWithDeepResearch(localEvidenceGoal, [
+      ...inspectedLocalEvidenceMessages,
+      {
+        role: "assistant",
+        tool_calls: [{ id: "current-research", function: { name: "deep_research", arguments: "{}" } }],
+      },
+    ]),
+    "the current request repeated deep research after already requesting it"
+  );
+  assert(
+    shouldStartWithDeepResearch(localEvidenceGoal, [
+      ...inspectedLocalEvidenceMessages,
+      {
+        role: "assistant",
+        tool_calls: [{ id: "old-research", function: { name: "deep_research", arguments: "{}" } }],
+      },
+      { role: "user", content: "Refresh this evidence review because the current report quality is not acceptable." },
+      {
+        role: "assistant",
+        tool_calls: [{ id: "refresh-report", function: { name: "read_file", arguments: '{"path":"agent-reliability-evidence-review.md"}' } }],
+      },
+      {
+        role: "assistant",
+        tool_calls: [{ id: "refresh-sources", function: { name: "read_file", arguments: '{"path":"sources.json"}' } }],
+      },
+    ]),
+    "a completed research call from an older user intent suppressed a fresh bounded research pass"
+  );
   assert(
     shouldStartWithDeepResearch("Write a deep web research report comparing three primary papers."),
     "standalone deep research no longer starts with the bounded research workflow"
@@ -509,6 +553,7 @@ async function main() {
     },
     store
   );
+  assert(research.version === RESEARCH_VERSION, "deep research did not expose its result-schema version");
   assert(research.ok && research.sourceCount === 2, `deep research failed: ${research.error || "unknown"}`);
   assert(
     researchSearchProviders.length === 2 && researchSearchProviders.every((provider) => provider === "multi"),

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

@@ -4,6 +4,7 @@ import os from "node:os";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { runAgent } from "../src/agent-runner.js";
+import { RESEARCH_VERSION } from "../src/deep-research.js";
 import { resolveRuntimeConfig } from "../src/config.js";
 import { classifyCommand, evaluateCommandPolicy } from "../src/command-policy.js";
 import {
@@ -4338,6 +4339,7 @@ try {
     {
       ok: true,
       toolName: "deep_research",
+      version: RESEARCH_VERSION,
       researchId: "research-one",
       status: "completed",
       reportPath: path.join(workspace, "report.md"),
@@ -4354,6 +4356,16 @@ try {
     reusedResearch?.duplicateSuppressed && reusedResearch.reportPath === path.join(workspace, "report.md"),
     "same-goal deep research did not reuse an already completed exact report"
   );
+  completedResearchState.meta.completedDeepResearch[0].result.version = RESEARCH_VERSION - 1;
+  assert(
+    completedDeepResearchReuse(
+      completedResearchState,
+      { query: "A model-expanded query", outputPath: "report.md", refresh: true },
+      { commandCwd: workspace }
+    ) === null,
+    "a stale deep-research engine result was reused after the report contract changed"
+  );
+  completedResearchState.meta.completedDeepResearch[0].result.version = RESEARCH_VERSION;
   completedResearchState.meta.goalContract = { revision: 2, currentHash: "goal-two" };
   assert(
     completedDeepResearchReuse(

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

@@ -547,6 +547,7 @@ async function verifyPackagedBinAndScriptClosure() {
     "scripts/eval-provider-attribution.js",
     "scripts/smoke-context-budget-recovery.js",
     "scripts/smoke-integration-production-mount.js",
+    "scripts/smoke-integration-production-runtime-bundle.js",
   ]) {
     assert.equal(packageJson.files.includes(requiredFile), true);
   }
@@ -1087,6 +1088,38 @@ async function main() {
       "INTEGRATION_CREDENTIAL_SOURCE_FORBIDDEN"
     );
 
+    let cliCheckOutput = "";
+    await withCanonicalCredentialFixture(async () => {
+      const summary = await integrationCliMain(["check", "--config", configPath], {
+        env: { CREDENTIALS_DIRECTORY: INTEGRATION_SYSTEMD_CREDENTIALS_DIRECTORY },
+        stdout: { write(chunk) { cliCheckOutput += String(chunk); } },
+      });
+      assert.equal(summary.status, "checked-disabled");
+      assert.equal(summary.capability?.enabled, false);
+      assert.equal(summary.implementationReady, false);
+      assert.equal(typeof summary.runtimeBundle?.healthy, "boolean");
+      assert.equal(summary.runtimeBundle?.implementationReady, false);
+      assert.equal(summary.runtimeBundle?.capabilityEnabled, false);
+      assert.equal(summary.runtimeBundle?.httpServingEnabled, false);
+      if (summary.runtimeBundle.healthy) {
+        assert.equal(summary.runtimeBundle.firstBlocker?.component, "idempotencyStore");
+        assert.equal(
+          summary.runtimeBundle.firstBlocker?.code,
+          "INTEGRATION_DESCRIPTOR_BOUND_IDEMPOTENCY_UNAVAILABLE"
+        );
+      } else {
+        assert.equal(summary.runtimeBundle.firstBlocker?.component, "storageAuthority");
+        assert.match(
+          summary.runtimeBundle.firstBlocker?.code || "",
+          /^INTEGRATION_STORAGE_/u
+        );
+      }
+      assert.deepEqual(
+        JSON.parse(cliCheckOutput.trim()),
+        JSON.parse(JSON.stringify(summary))
+      );
+    });
+
     const cliServePort = await unusedLoopbackPort();
     const cliServeConfigPath = path.join(tempRoot, "integration-serve.json");
     await fs.writeFile(

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

@@ -0,0 +1,398 @@
+#!/usr/bin/env node
+import assert from "node:assert/strict";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import {
+  INTEGRATION_PRODUCTION_RUNTIME_BUNDLE_HEALTH_VERSION,
+  INTEGRATION_PRODUCTION_RUNTIME_BUNDLE_LIMITATIONS,
+  INTEGRATION_PRODUCTION_RUNTIME_BUNDLE_VERSION,
+  checkIntegrationProductionRuntimeBundle,
+  integrationProductionRuntimeBundlePaths,
+  openIntegrationProductionRuntimeBundle,
+  preflightIntegrationProductionRuntimeBundle,
+} from "../src/integration-production-runtime-bundle.js";
+import { contractDigest } from "../src/integration-policy.js";
+
+const UID = process.getuid();
+const GID = process.getgid();
+
+async function expectCode(action, expectedCode) {
+  let captured = null;
+  try {
+    await action();
+  } catch (error) {
+    captured = error;
+  }
+  assert(captured, `Expected ${expectedCode}`);
+  assert.equal(captured.publicCode || captured.code, expectedCode, captured.stack || captured.message);
+}
+
+async function expectNoUnhandledRejections(action) {
+  const unhandled = [];
+  const onUnhandled = (reason) => unhandled.push(reason);
+  process.on("unhandledRejection", onUnhandled);
+  try {
+    await action();
+    await new Promise((resolve) => setImmediate(resolve));
+  } finally {
+    process.removeListener("unhandledRejection", onUnhandled);
+  }
+  assert.deepEqual(unhandled, []);
+}
+
+async function ensureOwnerDirectory(directoryPath) {
+  await fs.mkdir(directoryPath, { recursive: true, mode: 0o700 });
+  await fs.chmod(directoryPath, 0o700);
+  await fs.chown(directoryPath, UID, GID);
+}
+
+async function ensureLockFile(filePath) {
+  try {
+    await fs.writeFile(filePath, "", { flag: "wx", mode: 0o600 });
+  } catch (error) {
+    if (error?.code !== "EEXIST") throw error;
+  }
+  await fs.chmod(filePath, 0o600);
+  await fs.chown(filePath, UID, GID);
+}
+
+async function provisionRuntimeRoot(stateRoot, { omitEventLock = false } = {}) {
+  const paths = integrationProductionRuntimeBundlePaths(stateRoot);
+  for (const directoryPath of [
+    paths.stateRoot,
+    path.dirname(paths.repository),
+    paths.repository,
+    paths.sessions,
+    paths.workspace,
+    paths.eventLedger,
+    paths.idempotency,
+  ]) {
+    await ensureOwnerDirectory(directoryPath);
+  }
+  await ensureLockFile(paths.repositoryLock);
+  await ensureLockFile(paths.sessionLock);
+  if (!omitEventLock) await ensureLockFile(paths.eventLedgerLock);
+  return paths;
+}
+
+async function inventory(stateRoot) {
+  const names = await fs.readdir(stateRoot, { recursive: true });
+  return names.map((name) => String(name)).sort();
+}
+
+function assertEvidenceDigest(evidence) {
+  const { digest, ...unsigned } = evidence;
+  assert.equal(digest, contractDigest(unsigned));
+}
+
+async function run() {
+  const missingRoot = path.join(
+    os.tmpdir(),
+    `aginti-production-runtime-bundle-missing-${process.pid}-${Date.now()}`
+  );
+  const missing = await checkIntegrationProductionRuntimeBundle({ stateRoot: missingRoot });
+  assert.equal(missing.schemaVersion, INTEGRATION_PRODUCTION_RUNTIME_BUNDLE_HEALTH_VERSION);
+  assert.equal(missing.healthy, false);
+  assert.equal(missing.implementationReady, false);
+  assert.equal(missing.capabilityEnabled, false);
+  assert.equal(missing.httpServingEnabled, false);
+  assert.equal(missing.firstBlocker.component, "storageAuthority");
+  assert.equal(missing.firstBlocker.code, "INTEGRATION_STORAGE_UNAVAILABLE");
+  assert.equal(missing.blockers[1].component, "idempotencyStore");
+  assertEvidenceDigest(missing);
+
+  let proxyTrapCalls = 0;
+  const proxiedInput = new Proxy(Object.freeze({ stateRoot: missingRoot }), {
+    get() {
+      proxyTrapCalls += 1;
+      throw new Error("bundle input get trap must not run");
+    },
+    ownKeys() {
+      proxyTrapCalls += 1;
+      throw new Error("bundle input ownKeys trap must not run");
+    },
+  });
+  await expectCode(
+    () => openIntegrationProductionRuntimeBundle(proxiedInput),
+    "INTEGRATION_RUNTIME_BUNDLE_INVALID"
+  );
+  assert.equal(proxyTrapCalls, 0);
+  const revocable = Proxy.revocable(Object.freeze({ stateRoot: missingRoot }), {});
+  revocable.revoke();
+  await expectCode(
+    () => openIntegrationProductionRuntimeBundle(revocable.proxy),
+    "INTEGRATION_RUNTIME_BUNDLE_INVALID"
+  );
+
+  let accessorCalls = 0;
+  const accessorInput = {};
+  Object.defineProperty(accessorInput, "stateRoot", {
+    configurable: true,
+    enumerable: true,
+    get() {
+      accessorCalls += 1;
+      return missingRoot;
+    },
+  });
+  await expectCode(
+    () => openIntegrationProductionRuntimeBundle(accessorInput),
+    "INTEGRATION_RUNTIME_BUNDLE_INVALID"
+  );
+  assert.equal(accessorCalls, 0);
+  await expectCode(
+    () => openIntegrationProductionRuntimeBundle(Object.create({ stateRoot: missingRoot })),
+    "INTEGRATION_RUNTIME_BUNDLE_INVALID"
+  );
+  await expectNoUnhandledRejections(async () => {
+    const rejectedInput = Promise.reject(new Error("already rejected bundle input"));
+    await expectCode(
+      () => openIntegrationProductionRuntimeBundle(rejectedInput),
+      "INTEGRATION_RUNTIME_BUNDLE_INVALID"
+    );
+    const rejectedStateRoot = Promise.reject(new Error("already rejected stateRoot"));
+    await expectCode(
+      () => openIntegrationProductionRuntimeBundle({ stateRoot: rejectedStateRoot }),
+      "INTEGRATION_RUNTIME_BUNDLE_INVALID"
+    );
+    const rejectedOpenExtra = Promise.reject(new Error("already rejected open extra"));
+    await expectCode(
+      () => openIntegrationProductionRuntimeBundle({ stateRoot: missingRoot }, rejectedOpenExtra),
+      "INTEGRATION_RUNTIME_BUNDLE_INVALID"
+    );
+    const rejectedPreflightExtra = Promise.reject(new Error("already rejected preflight extra"));
+    await expectCode(
+      () => preflightIntegrationProductionRuntimeBundle({ stateRoot: missingRoot }, rejectedPreflightExtra),
+      "INTEGRATION_RUNTIME_BUNDLE_INVALID"
+    );
+    const rejectedCheckExtra = Promise.reject(new Error("already rejected check extra"));
+    await expectCode(
+      () => checkIntegrationProductionRuntimeBundle({ stateRoot: missingRoot }, rejectedCheckExtra),
+      "INTEGRATION_RUNTIME_BUNDLE_INVALID"
+    );
+    const rejectedPathsExtra = Promise.reject(new Error("already rejected paths extra"));
+    await expectCode(
+      () => integrationProductionRuntimeBundlePaths(missingRoot, rejectedPathsExtra),
+      "INTEGRATION_RUNTIME_BUNDLE_INVALID"
+    );
+  });
+
+  const nonDirectoryRoot = await fs.mkdtemp(
+    path.join(os.tmpdir(), "aginti-production-runtime-nondirectory-")
+  );
+  try {
+    const nonDirectory = path.join(nonDirectoryRoot, "not-a-directory");
+    await fs.writeFile(nonDirectory, "blocked", { mode: 0o600 });
+    const unavailable = await checkIntegrationProductionRuntimeBundle({
+      stateRoot: path.join(nonDirectory, "child"),
+    });
+    assert.equal(unavailable.healthy, false);
+    assert.equal(unavailable.firstBlocker.component, "storageAuthority");
+    assert.equal(unavailable.firstBlocker.code, "INTEGRATION_STORAGE_UNAVAILABLE");
+    if (UID !== 0) {
+      const deniedParent = path.join(nonDirectoryRoot, "denied");
+      await fs.mkdir(deniedParent, { mode: 0o700 });
+      await fs.chmod(deniedParent, 0o000);
+      try {
+        const denied = await checkIntegrationProductionRuntimeBundle({
+          stateRoot: path.join(deniedParent, "child"),
+        });
+        assert.equal(denied.healthy, false);
+        assert.equal(denied.firstBlocker.component, "storageAuthority");
+        assert.equal(denied.firstBlocker.code, "INTEGRATION_STORAGE_UNAVAILABLE");
+      } finally {
+        await fs.chmod(deniedParent, 0o700);
+      }
+    }
+  } finally {
+    await fs.rm(nonDirectoryRoot, { recursive: true, force: true });
+  }
+
+  const stateRoot = await fs.mkdtemp(path.join(os.tmpdir(), "aginti-production-runtime-bundle-"));
+  const poisonRoot = await fs.mkdtemp(path.join(os.tmpdir(), "aginti-production-runtime-poison-"));
+  const lockModeRoot = await fs.mkdtemp(path.join(os.tmpdir(), "aginti-production-runtime-lock-mode-"));
+  const lockReplacementRoot = await fs.mkdtemp(
+    path.join(os.tmpdir(), "aginti-production-runtime-lock-replacement-")
+  );
+  const failedRoot = await fs.mkdtemp(path.join(os.tmpdir(), "aginti-production-runtime-failed-"));
+  try {
+    const paths = await provisionRuntimeRoot(stateRoot);
+    assert.equal(paths.repository, path.join(stateRoot, "runtime-authority", "repository"));
+    assert.equal(paths.sessions, path.join(stateRoot, "runtime-authority", "sessions"));
+    assert.equal(paths.workspace, path.join(stateRoot, "runtime-authority", "workspace"));
+    assert.equal(paths.eventLedger, path.join(stateRoot, "event-ledger"));
+    assert.equal(paths.idempotency, path.join(stateRoot, "idempotency-store"));
+
+    const beforePreflight = await inventory(stateRoot);
+    const check = await checkIntegrationProductionRuntimeBundle({ stateRoot });
+    assert.equal(check.healthy, true);
+    assert.equal(check.implementationReady, false);
+    assert.equal(check.firstBlocker.component, "idempotencyStore");
+    assert.equal(
+      check.firstBlocker.code,
+      "INTEGRATION_DESCRIPTOR_BOUND_IDEMPOTENCY_UNAVAILABLE"
+    );
+    assert.equal(check.components.storageAuthority.descriptorBound, true);
+    assert.equal(check.components.repository.descriptorBound, true);
+    assert.equal(check.components.repository.runtimeFenceAcquired, false);
+    assert.equal(check.components.sessionState.descriptorBound, true);
+    assert.equal(check.components.sessionState.nativeWriteFenceBound, false);
+    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.transactionalStore, false);
+    assert.equal(check.components.nativeExecutor.lexicalProofPresent, true);
+    assert.equal(check.components.nativeExecutor.retainedSessionStateBound, false);
+    assert.equal(check.components.nativeExecutor.artifactEvents, false);
+    assert.equal(check.components.sandbox.capabilityEnabled, false);
+    assert.equal(check.components.runtimeAuthority.composed, false);
+    assert.equal(check.components.sessionService.composed, false);
+    assertEvidenceDigest(check);
+    assert.deepEqual(await inventory(stateRoot), beforePreflight);
+
+    const directPreflight = await preflightIntegrationProductionRuntimeBundle({ stateRoot });
+    assert.equal(directPreflight.probe, "preflight");
+    assert.equal(directPreflight.healthy, true);
+    assert.equal(directPreflight.implementationReady, false);
+    assert.deepEqual(await inventory(stateRoot), beforePreflight);
+
+    const bundle = await openIntegrationProductionRuntimeBundle({ stateRoot });
+    assert.equal(Object.getPrototypeOf(bundle), null);
+    assert.equal(Object.isFrozen(bundle), true);
+    assert.equal(bundle.schemaVersion, INTEGRATION_PRODUCTION_RUNTIME_BUNDLE_VERSION);
+    assert.equal(bundle.attestation.descriptorBound, true);
+    assert.equal(bundle.attestation.storageLifecycleOwned, true);
+    assert.equal(bundle.attestation.implementationReady, false);
+    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.equal(bundle.attestation.blockers[0].component, "idempotencyStore");
+    assert.equal(bundle.attestation.limitations, INTEGRATION_PRODUCTION_RUNTIME_BUNDLE_LIMITATIONS);
+    assert.equal("start" in bundle, false);
+    assert.equal("serve" in bundle, false);
+    assert.equal("runtimeAuthority" in bundle, false);
+    assert.equal("sessionService" in bundle, false);
+    assert.throws(() => Object.defineProperty(bundle, "start", { value() {} }), TypeError);
+    await expectCode(() => bundle.health({}), "INTEGRATION_RUNTIME_BUNDLE_INVALID");
+    await expectCode(() => bundle.preflight({}), "INTEGRATION_RUNTIME_BUNDLE_INVALID");
+    await expectCode(() => bundle.close({}), "INTEGRATION_RUNTIME_BUNDLE_INVALID");
+    await expectCode(() => bundle.isClosed({}), "INTEGRATION_RUNTIME_BUNDLE_INVALID");
+    await expectNoUnhandledRejections(async () => {
+      const rejectedHealthExtra = Promise.reject(new Error("already rejected health extra"));
+      await expectCode(() => bundle.health(rejectedHealthExtra), "INTEGRATION_RUNTIME_BUNDLE_INVALID");
+      const rejectedPreflightExtra = Promise.reject(new Error("already rejected preflight extra"));
+      await expectCode(
+        () => bundle.preflight(rejectedPreflightExtra),
+        "INTEGRATION_RUNTIME_BUNDLE_INVALID"
+      );
+      const rejectedCloseExtra = Promise.reject(new Error("already rejected close extra"));
+      await expectCode(() => bundle.close(rejectedCloseExtra), "INTEGRATION_RUNTIME_BUNDLE_INVALID");
+      const rejectedClosedExtra = Promise.reject(new Error("already rejected isClosed extra"));
+      await expectCode(
+        () => bundle.isClosed(rejectedClosedExtra),
+        "INTEGRATION_RUNTIME_BUNDLE_INVALID"
+      );
+    });
+
+    const healthy = await bundle.health();
+    assert.equal(healthy.probe, "health");
+    assert.equal(healthy.status, "healthy-disabled");
+    assert.equal(healthy.healthy, true);
+    assert.equal(healthy.implementationReady, false);
+    assertEvidenceDigest(healthy);
+
+    const concurrentHealth = await Promise.all([
+      bundle.health(),
+      bundle.preflight(),
+      bundle.health(),
+    ]);
+    assert.deepEqual(
+      concurrentHealth.map((item) => item.healthy),
+      [true, true, true]
+    );
+
+    const racingProbe = bundle.health();
+    const racingClose = bundle.close();
+    await expectCode(() => racingProbe, "INTEGRATION_RUNTIME_BUNDLE_CLOSED");
+    assert.deepEqual(await racingClose, { closed: true, poisoned: false });
+    assert.equal(bundle.isClosed(), true);
+    assert.deepEqual(await bundle.close(), { closed: true, poisoned: false });
+    await expectCode(() => bundle.health(), "INTEGRATION_RUNTIME_BUNDLE_CLOSED");
+    await expectCode(() => bundle.preflight(), "INTEGRATION_RUNTIME_BUNDLE_CLOSED");
+
+    await provisionRuntimeRoot(poisonRoot);
+    const poisonedBundle = await openIntegrationProductionRuntimeBundle({ stateRoot: poisonRoot });
+    await fs.chmod(poisonRoot, 0o755);
+    await expectCode(() => poisonedBundle.health(), "INTEGRATION_STORAGE_POISONED");
+    await fs.chmod(poisonRoot, 0o700);
+    await expectCode(() => poisonedBundle.health(), "INTEGRATION_RUNTIME_BUNDLE_POISONED");
+    assert.deepEqual(await poisonedBundle.close(), { closed: true, poisoned: true });
+
+    const lockModePaths = await provisionRuntimeRoot(lockModeRoot);
+    const lockModeBundle = await openIntegrationProductionRuntimeBundle({ stateRoot: lockModeRoot });
+    await fs.chmod(lockModePaths.repositoryLock, 0o640);
+    await expectCode(() => lockModeBundle.health(), "INTEGRATION_STORAGE_LOCK_POISONED");
+    await fs.chmod(lockModePaths.repositoryLock, 0o600);
+    await expectCode(() => lockModeBundle.health(), "INTEGRATION_RUNTIME_BUNDLE_POISONED");
+    assert.deepEqual(await lockModeBundle.close(), { closed: true, poisoned: true });
+
+    const replacementPaths = await provisionRuntimeRoot(lockReplacementRoot);
+    const replacementBundle = await openIntegrationProductionRuntimeBundle({
+      stateRoot: lockReplacementRoot,
+    });
+    const displacedSessionLock = `${replacementPaths.sessionLock}.displaced`;
+    await fs.rename(replacementPaths.sessionLock, displacedSessionLock);
+    await ensureLockFile(replacementPaths.sessionLock);
+    await expectCode(
+      () => replacementBundle.health(),
+      "INTEGRATION_STORAGE_LOCK_POISONED"
+    );
+    await expectCode(
+      () => replacementBundle.preflight(),
+      "INTEGRATION_RUNTIME_BUNDLE_POISONED"
+    );
+    assert.deepEqual(await replacementBundle.close(), { closed: true, poisoned: true });
+
+    const failedPaths = await provisionRuntimeRoot(failedRoot, { omitEventLock: true });
+    await expectCode(
+      () => openIntegrationProductionRuntimeBundle({ stateRoot: failedRoot }),
+      "INTEGRATION_STORAGE_UNAVAILABLE"
+    );
+    await ensureLockFile(failedPaths.eventLedgerLock);
+    const recoveredFromFactoryFailure = await openIntegrationProductionRuntimeBundle({
+      stateRoot: failedRoot,
+    });
+    assert.equal((await recoveredFromFactoryFailure.health()).healthy, true);
+    await recoveredFromFactoryFailure.close();
+
+    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"),
+      fs.readFile(new URL("../src/integration-production-runtime-bundle.js", import.meta.url), "utf8"),
+    ]);
+    assert.match(cliSource, /checkIntegrationProductionRuntimeBundle/u);
+    assert.doesNotMatch(serverSource, /integration-production-runtime-bundle/u);
+    assert.doesNotMatch(
+      bundleSource,
+      /acquireRetainedIntegrationRuntimeRepositoryFence|createAgintiIntegrationRuntimeAuthority|createNativeIntegrationSessionService|createFileIntegrationIdempotencyStore/u
+    );
+  } finally {
+    await fs.chmod(poisonRoot, 0o700).catch(() => {});
+    await fs.rm(stateRoot, { recursive: true, force: true });
+    await fs.rm(poisonRoot, { recursive: true, force: true });
+    await fs.rm(lockModeRoot, { recursive: true, force: true });
+    await fs.rm(lockReplacementRoot, { recursive: true, force: true });
+    await fs.rm(failedRoot, { recursive: true, force: true });
+  }
+
+  process.stdout.write("integration production runtime bundle smoke: ok\n");
+}
+
+run().catch((error) => {
+  process.stderr.write(
+    `integration production runtime bundle smoke: failed (${String(error?.publicCode || error?.code || error?.name || "ERROR")})\n`
+  );
+  process.stderr.write(`${String(error?.stack || error?.message || error)}\n`);
+  process.exitCode = 1;
+});

package/scripts/smoke-integration-retained-event-ledger-bundle.js

@@ -482,15 +482,20 @@ async function runCore() {
   const authorities = [];
   let consumerMocks = [];
   try {
-    const [serverSource, runtimeSource, sessionSource] = await Promise.all([
+    const [serverSource, runtimeSource, sessionSource, productionBundleSource] = await Promise.all([
       fs.readFile(new URL("../src/integration-server.js", import.meta.url), "utf8"),
       fs.readFile(new URL("../src/integration-runtime-authority.js", import.meta.url), "utf8"),
       fs.readFile(new URL("../src/integration-session-service.js", import.meta.url), "utf8"),
+      fs.readFile(new URL("../src/integration-production-runtime-bundle.js", import.meta.url), "utf8"),
     ]);
     assert.match(serverSource, /export const INTEGRATION_MOUNT_CAPABILITY_ENABLED = false;/u);
     assert.equal(serverSource.includes("createRetainedIntegrationEventLedgerBundle"), false);
     assert.equal(runtimeSource.includes("createRetainedIntegrationEventLedgerBundle"), false);
     assert.equal(sessionSource.includes("createRetainedIntegrationEventLedgerBundle"), false);
+    assert.equal(productionBundleSource.includes("createRetainedIntegrationEventLedgerBundle"), true);
+    assert.match(productionBundleSource, /capabilityEnabled:\s*false/u);
+    assert.match(productionBundleSource, /httpServingEnabled:\s*false/u);
+    assert.match(productionBundleSource, /runtimeActivationIncluded:\s*false/u);
 
     const main = await openFixture(path.join(smokeRoot, "main"), "retained-ledger-bundle-main");
     authorities.push(main.authority);

package/scripts/smoke-integration-retained-native-session-repository-state.js

@@ -791,6 +791,7 @@ async function runStaticBoundaryChecks(surface) {
   assert.match(config, /capability:\s*Object\.freeze\(\{ enabled: false \}\)/u);
   const sourceDirectory = fileURLToPath(new URL("../src/", import.meta.url));
   for (const consumerName of [
+    "integration-production-runtime-bundle.js",
     "integration-native-executor.js",
     "integration-runtime-authority.js",
     "integration-native-runtime-roots.js",
@@ -800,6 +801,18 @@ async function runStaticBoundaryChecks(surface) {
     "session-store.js",
   ]) {
     const consumer = await fs.readFile(path.join(sourceDirectory, consumerName), "utf8");
+    if (consumerName === "integration-production-runtime-bundle.js") {
+      assert.match(consumer, /capabilityEnabled:\s*false/u);
+      assert.match(consumer, /runtimeActivationIncluded:\s*false/u);
+      assert.match(consumer, /repositoryFenceAcquisitionIncluded:\s*false/u);
+      assert.match(consumer, /descriptorBoundIdempotencyStore:\s*false/u);
+      assert.doesNotMatch(
+        consumer,
+        /acquireRetainedIntegrationRuntimeRepositoryFence|createAgintiIntegrationRuntimeAuthority|createIntegrationServer|createNativeIntegrationSessionService/u,
+        `${consumerName} may compose the repository-state surface only before runtime activation.`
+      );
+      continue;
+    }
     assert.doesNotMatch(
       consumer,
       /integration-retained-native-session-repository-state|(?:create|assert)RetainedIntegrationNativeSessionRepositoryState/u,