chainlesschain 0.163.4 → 0.163.6

package/src/commands/scheduler-daemon.js

@@ -0,0 +1,450 @@
+import { randomUUID } from "node:crypto";
+import chalk from "chalk";
+import { logger } from "../lib/logger.js";
+import {
+  DEFAULT_SERVICE_INTERVAL_MS,
+  MAX_SERVICE_INTERVAL_MS,
+  MIN_SERVICE_INTERVAL_MS,
+  createSchedulerService,
+} from "../lib/scheduler-kernel/service.js";
+
+export const SCHEDULER_DAEMON_DOMAINS = Object.freeze(["agenda", "cowork"]);
+
+function schedulerDaemonError(code, message, details = undefined) {
+  const error = new Error(message);
+  error.code = code;
+  if (details !== undefined) error.details = details;
+  return error;
+}
+
+function positiveInteger(value, field) {
+  const normalized = Number(value);
+  if (!Number.isSafeInteger(normalized) || normalized < 1) {
+    throw schedulerDaemonError(
+      "SCHEDULER_DAEMON_INVALID_POLICY",
+      `${field} must be a positive integer`,
+    );
+  }
+  return normalized;
+}
+
+function nonnegativeInteger(value, field) {
+  const normalized = Number(value);
+  if (!Number.isSafeInteger(normalized) || normalized < 0) {
+    throw schedulerDaemonError(
+      "SCHEDULER_DAEMON_INVALID_POLICY",
+      `${field} must be a non-negative integer`,
+    );
+  }
+  return normalized;
+}
+
+export function parseSchedulerCapabilities(value) {
+  if (typeof value !== "string") {
+    throw schedulerDaemonError(
+      "SCHEDULER_DAEMON_INVALID_POLICY",
+      "Scheduler capabilities must be a comma-separated string",
+    );
+  }
+  const capabilities = [
+    ...new Set(
+      value
+        .split(",")
+        .map((entry) => entry.trim())
+        .filter(Boolean),
+    ),
+  ].sort();
+  if (capabilities.length === 0 || capabilities.includes("*")) {
+    throw schedulerDaemonError(
+      "SCHEDULER_DAEMON_INVALID_POLICY",
+      "Scheduler policy requires one or more exact capabilities",
+    );
+  }
+  return capabilities;
+}
+
+async function withSchedulerStore(dependencies, operation) {
+  const openStore =
+    dependencies.openSchedulerStore ||
+    (await import("../lib/scheduler-kernel/store.js")).openSchedulerStore;
+  const store = openStore();
+  try {
+    return operation(store);
+  } finally {
+    store.close();
+  }
+}
+
+export async function getSchedulerAuthorityPolicy(
+  principalType,
+  principalId,
+  dependencies = {},
+) {
+  return withSchedulerStore(dependencies, (store) => {
+    const policy = store.getAuthorityPolicy({
+      type: principalType,
+      id: principalId,
+    });
+    if (!policy) {
+      throw schedulerDaemonError(
+        "SCHEDULER_AUTHORITY_POLICY_NOT_FOUND",
+        `Scheduler authority policy does not exist: ${principalType}:${principalId}`,
+      );
+    }
+    return policy;
+  });
+}
+
+export async function setSchedulerAuthorityPolicy(
+  principalType,
+  principalId,
+  options,
+  dependencies = {},
+) {
+  const windowSeconds = positiveInteger(options.windowSeconds, "windowSeconds");
+  const windowMs = windowSeconds * 1_000;
+  if (!Number.isSafeInteger(windowMs)) {
+    throw schedulerDaemonError(
+      "SCHEDULER_DAEMON_INVALID_POLICY",
+      "windowSeconds is too large",
+    );
+  }
+  return withSchedulerStore(dependencies, (store) =>
+    store.setAuthorityPolicy(
+      { type: principalType, id: principalId },
+      {
+        capabilities: parseSchedulerCapabilities(options.capabilities),
+        windowMs,
+        maxRuns: positiveInteger(options.maxRuns, "maxRuns"),
+        maxUnits: positiveInteger(options.maxUnits, "maxUnits"),
+        enabled: options.disable !== true,
+        expectedRevision: nonnegativeInteger(
+          options.expectedRevision,
+          "expectedRevision",
+        ),
+      },
+    ),
+  );
+}
+
+export function parseSchedulerDomains(
+  value = SCHEDULER_DAEMON_DOMAINS.join(","),
+) {
+  if (typeof value !== "string") {
+    throw schedulerDaemonError(
+      "SCHEDULER_DAEMON_INVALID_DOMAINS",
+      "Scheduler domains must be a comma-separated string",
+    );
+  }
+  const requested = [
+    ...new Set(
+      value
+        .split(",")
+        .map((entry) => entry.trim().toLowerCase())
+        .filter(Boolean),
+    ),
+  ];
+  const unknown = requested.filter(
+    (entry) => !SCHEDULER_DAEMON_DOMAINS.includes(entry),
+  );
+  if (requested.length === 0 || unknown.length > 0) {
+    throw schedulerDaemonError(
+      "SCHEDULER_DAEMON_INVALID_DOMAINS",
+      `Scheduler domains must be selected from: ${SCHEDULER_DAEMON_DOMAINS.join(", ")}`,
+      { unknown },
+    );
+  }
+  return SCHEDULER_DAEMON_DOMAINS.filter((entry) => requested.includes(entry));
+}
+
+export function parseSchedulerIntervalMs(
+  value = DEFAULT_SERVICE_INTERVAL_MS / 1000,
+) {
+  const seconds = Number(value);
+  const intervalMs = Math.round(seconds * 1000);
+  if (
+    !Number.isFinite(seconds) ||
+    seconds <= 0 ||
+    !Number.isSafeInteger(intervalMs) ||
+    intervalMs < MIN_SERVICE_INTERVAL_MS ||
+    intervalMs > MAX_SERVICE_INTERVAL_MS
+  ) {
+    throw schedulerDaemonError(
+      "SCHEDULER_DAEMON_INVALID_INTERVAL",
+      `Scheduler interval must be between ${MIN_SERVICE_INTERVAL_MS / 1000} and ${MAX_SERVICE_INTERVAL_MS / 1000} seconds`,
+    );
+  }
+  return intervalMs;
+}
+
+async function loadSchedulerRuntime() {
+  const [
+    { AgentScheduleStore },
+    { runAgendaRun },
+    { CoworkCronSchedulerBridge },
+    { openSchedulerStore },
+    { runCoworkTask },
+  ] = await Promise.all([
+    import("../lib/agent-schedule-store.js"),
+    import("./agenda.js"),
+    import("../lib/scheduler-kernel/cowork-cron-adapter.js"),
+    import("../lib/scheduler-kernel/store.js"),
+    import("../lib/cowork-task-runner.js"),
+  ]);
+  return {
+    AgentScheduleStore,
+    CoworkCronSchedulerBridge,
+    openSchedulerStore,
+    runAgendaRun,
+    runCoworkTask,
+  };
+}
+
+function parseAgendaSummary(lines) {
+  for (let index = lines.length - 1; index >= 0; index -= 1) {
+    try {
+      return JSON.parse(lines[index]);
+    } catch {
+      // Keep looking for the machine-readable summary.
+    }
+  }
+  return { due: 0, retired: [], actions: [] };
+}
+
+export async function createDefaultSchedulerService({
+  cwd = process.cwd(),
+  domains = SCHEDULER_DAEMON_DOMAINS,
+  onEvent,
+  runtime,
+  createService = createSchedulerService,
+} = {}) {
+  const selected = Array.isArray(domains)
+    ? parseSchedulerDomains(domains.join(","))
+    : parseSchedulerDomains(domains);
+  const loaded = runtime || (await loadSchedulerRuntime());
+  const schedulerStore = loaded.openSchedulerStore();
+  const drivers = [];
+  try {
+    if (selected.includes("agenda")) {
+      const agendaStore = new loaded.AgentScheduleStore();
+      const ownerId = `scheduler-service:agenda:${process.pid}:${randomUUID()}`;
+      drivers.push({
+        name: "agenda",
+        async run({ signal }) {
+          const lines = [];
+          const code = await loaded.runAgendaRun(
+            { json: true, signal },
+            {
+              store: agendaStore,
+              schedulerStore,
+              schedulerOwnerId: ownerId,
+              log: (line) => lines.push(String(line)),
+            },
+          );
+          const summary = parseAgendaSummary(lines);
+          if (code !== 0) {
+            throw schedulerDaemonError(
+              "SCHEDULER_DAEMON_AGENDA_FAILED",
+              "Agenda scheduler tick completed with one or more failed actions",
+              summary,
+            );
+          }
+          return summary;
+        },
+      });
+    }
+
+    if (selected.includes("cowork")) {
+      const bridge = new loaded.CoworkCronSchedulerBridge({
+        cwd,
+        schedulerStore,
+        runTask: loaded.runCoworkTask,
+        ownerId: `scheduler-service:cowork:${process.pid}:${randomUUID()}`,
+      });
+      drivers.push({
+        name: "cowork",
+        run: ({ signal }) => bridge.runDue({ signal }),
+      });
+    }
+
+    return createService({
+      drivers,
+      onEvent,
+      dispose: () => schedulerStore.close(),
+    });
+  } catch (error) {
+    schedulerStore.close();
+    throw error;
+  }
+}
+
+function humanEvent(event, log) {
+  if (event.type === "scheduler-service-started") {
+    log(
+      chalk.green(
+        `Scheduler service running (${event.drivers.join(", ")}); press Ctrl-C to stop.`,
+      ),
+    );
+  } else if (event.type === "scheduler-driver-failed") {
+    log(
+      chalk.red(
+        `${event.driver} scheduler failed (${event.error.code}): ${event.error.message}`,
+      ),
+    );
+  } else if (event.type === "scheduler-service-stopped") {
+    log(chalk.gray(`Scheduler service stopped after ${event.ticks} tick(s).`));
+  }
+}
+
+export async function runSchedulerDaemon(options = {}, dependencies = {}) {
+  const domains = parseSchedulerDomains(options.domains);
+  const intervalMs = parseSchedulerIntervalMs(options.interval);
+  const log = dependencies.log || ((line) => logger.log(line));
+  const processRef = dependencies.processRef || process;
+  const controller = new AbortController();
+  const externalSignal = options.signal || dependencies.signal;
+  const abort = () => controller.abort(externalSignal?.reason);
+  if (externalSignal?.aborted) abort();
+  else externalSignal?.addEventListener?.("abort", abort, { once: true });
+  const onProcessSignal = () => controller.abort();
+  processRef.once?.("SIGINT", onProcessSignal);
+  processRef.once?.("SIGTERM", onProcessSignal);
+
+  const emit =
+    dependencies.onEvent ||
+    ((event) => {
+      if (options.json) log(JSON.stringify(event));
+      else humanEvent(event, log);
+    });
+  const createDefault =
+    dependencies.createDefaultService || createDefaultSchedulerService;
+  let service;
+  try {
+    service = await createDefault({
+      cwd: options.cwd || process.cwd(),
+      domains,
+      onEvent: emit,
+      ...(dependencies.runtime === undefined
+        ? {}
+        : { runtime: dependencies.runtime }),
+      ...(dependencies.createService === undefined
+        ? {}
+        : { createService: dependencies.createService }),
+    });
+    const result = await service.run({
+      intervalMs,
+      once: options.once === true,
+      signal: controller.signal,
+      ...(dependencies.maxTicks === undefined
+        ? {}
+        : { maxTicks: dependencies.maxTicks }),
+    });
+    if (options.once === true) {
+      if (options.json) {
+        log(JSON.stringify({ type: "scheduler-run-summary", ...result }));
+      } else {
+        log(
+          result.status === "degraded"
+            ? chalk.yellow("Scheduler tick completed with failures.")
+            : chalk.green("Scheduler tick completed."),
+        );
+      }
+    }
+    return result.status === "degraded" ? 1 : 0;
+  } finally {
+    externalSignal?.removeEventListener?.("abort", abort);
+    processRef.removeListener?.("SIGINT", onProcessSignal);
+    processRef.removeListener?.("SIGTERM", onProcessSignal);
+    await service?.close();
+  }
+}
+
+export function registerSchedulerDaemonCommands(daemon) {
+  const scheduler = daemon
+    .command("scheduler")
+    .description("Run durable unattended scheduler domains in one process");
+
+  scheduler
+    .command("run", { isDefault: true })
+    .description("Run Agenda and Cowork scheduler domains")
+    .option("--once", "Run one tick and exit")
+    .option(
+      "--interval <seconds>",
+      "Polling interval in seconds",
+      String(DEFAULT_SERVICE_INTERVAL_MS / 1000),
+    )
+    .option(
+      "--domains <list>",
+      "Comma-separated domains (agenda,cowork)",
+      SCHEDULER_DAEMON_DOMAINS.join(","),
+    )
+    .option("--json", "Emit newline-delimited scheduler events")
+    .action(async (options) => {
+      try {
+        process.exitCode = await runSchedulerDaemon(options);
+      } catch (error) {
+        logger.error(chalk.red(error.message));
+        process.exitCode = 1;
+      }
+    });
+
+  const policy = scheduler
+    .command("policy")
+    .description("Inspect or update scheduler permission and budget policies");
+
+  policy
+    .command("get")
+    .description("Read one scheduler authority policy")
+    .argument("<principal-type>", "Authority principal type")
+    .argument("<principal-id>", "Authority principal id")
+    .action(async (principalType, principalId) => {
+      try {
+        logger.log(
+          JSON.stringify(
+            await getSchedulerAuthorityPolicy(principalType, principalId),
+            null,
+            2,
+          ),
+        );
+      } catch (error) {
+        logger.error(chalk.red(error.message));
+        process.exitCode = 1;
+      }
+    });
+
+  policy
+    .command("set")
+    .description("CAS-update exact capabilities and a bounded usage budget")
+    .argument("<principal-type>", "Authority principal type")
+    .argument("<principal-id>", "Authority principal id")
+    .requiredOption(
+      "--capabilities <list>",
+      "Comma-separated exact capabilities",
+    )
+    .requiredOption("--window-seconds <n>", "Budget window in seconds")
+    .requiredOption("--max-runs <n>", "Maximum runs in the window")
+    .requiredOption("--max-units <n>", "Maximum units in the window")
+    .requiredOption(
+      "--expected-revision <n>",
+      "Current policy revision for compare-and-swap",
+    )
+    .option("--disable", "Disable unattended execution for this principal")
+    .action(async (principalType, principalId, options) => {
+      try {
+        logger.log(
+          JSON.stringify(
+            await setSchedulerAuthorityPolicy(
+              principalType,
+              principalId,
+              options,
+            ),
+            null,
+            2,
+          ),
+        );
+      } catch (error) {
+        logger.error(chalk.red(error.message));
+        process.exitCode = 1;
+      }
+    });
+}

package/src/data/changelog.json

@@ -1,6 +1,32 @@
 {
   "source": "CHANGELOG.md",
   "releases": [
+    {
+      "productVersion": null,
+      "cliVersion": "0.163.6",
+      "cliVersions": ["0.163.5", "0.163.6"],
+      "date": "2026-08-12",
+      "title": "",
+      "sections": [
+        {
+          "heading": "Added — cc CLI 0.163.6: unified scheduler authority and automation control",
+          "body": "> `chainlesschain` **0.163.5 → 0.163.6** (candidate; not yet published,\n> 2026-08-12).\n> CLI-only candidate; `@chainlesschain/personal-data-hub` remains **0.4.57**\n> and `@chainlesschain/agent-sdk` remains **0.1.7**.\n\n- **Complete scheduler adapter migration**: Agenda monitors, Loop iterations,\n  Automation cron flows, Routine GitHub polling, channel automation events,\n  and the standalone daemon now execute through the shared scheduler service\n  with durable claims, definition snapshots, recovery fences, and bounded\n  retry/dead-letter behavior.\n- **Timezone and missed-run consistency**: Agenda and Cowork cron definitions\n  persist canonical IANA timezones, handle DST gaps and repeated civil times,\n  and collapse downtime to one latest due occurrence without replay storms.\n- **Shared scheduler permission and budget authority**: Agenda, Routine,\n  Cowork, Automation, and Loop bind exact capability policies to durable\n  revisions and use one transactional reservation/settlement path. Missing,\n  stale, disabled, exhausted, or inconsistent policy state fails closed;\n  retries reuse the original reservation instead of charging twice.\n- **Layered Automation enforcement**: the shared scheduler authority composes\n  with Automation's creator identity, connector permissions, live revocation,\n  and per-flow run/action budgets. Domain evidence and the scheduler policy\n  revision remain independently validated.\n- **Governed management surfaces**: scheduler policy inspection/update commands\n  require exact capabilities and revision CAS, while the Automation Center\n  exposes governed flow and Routine controls without bypassing backend\n  permission or budget checks.\n- **Known residuals**: durable outcome-unknown adjudication, complete mixed-\n  version migration/rollback, scheduler disk-fault closure, and the three-OS\n  long-soak matrix remain open. Signed native distribution and representative\n  alias-removal telemetry also remain outside this release.\n- **Release status**: final tag, source SHA, workflow run IDs, package digest,\n  provenance, and registry readback are intentionally omitted until the exact\n  `0.163.6` release commit passes the complete `CLI CI` and `CLI Strict Sandbox`\n  Linux, Windows, and macOS matrices, followed by the dedicated npm release and\n  independent public readback workflows."
+        }
+      ]
+    },
+    {
+      "productVersion": null,
+      "cliVersion": "0.163.5",
+      "cliVersions": ["0.163.4", "0.163.5"],
+      "date": "2026-08-11",
+      "title": "",
+      "sections": [
+        {
+          "heading": "Added — cc CLI 0.163.5: durable scheduler runtime and recovery",
+          "body": "> `chainlesschain` **0.163.4 → 0.163.5** (published from exact SHA\n> `095087c1e859a8451ce01ed58c59af3fede756fd`, 2026-08-11).\n> CLI-only release; `@chainlesschain/personal-data-hub` remains **0.4.57**\n> and `@chainlesschain/agent-sdk` remains **0.1.7**.\n\n- **Unified scheduler runtime**: the versioned scheduler store now has a shared\n  runtime with adapter registration, snapshot-bound authorization, durable\n  owner/fence claims, lease renewal, bounded retry, dead-letter settlement,\n  history, and adapter-kind isolation.\n- **Routine scheduling migration**: manual triggers and `routine run` cron/once\n  executions use canonical logical occurrences, revision-CAS job snapshots,\n  deterministic run evidence, dual-driver fencing, and crash recovery that\n  settles terminal evidence without replaying the agent.\n- **Agenda wakeup/cron migration**: production Agenda wakeup and cron entries\n  preserve their full permission/worktree/turn/token/cost/time run policy while\n  executing through the shared kernel. New and legacy drivers coordinate with\n  durable leases; known failures retry, while start-only outcomes fail closed.\n- **Cowork Cron migration**: production `cowork cron run` uses definition-only\n  snapshots, workspace-scoped recovery claims, cross-version JSONL delivery\n  fences, terminal-evidence recovery, and automatic one-second polling for\n  six-field cron expressions.\n- **Durable compaction recovery**: micro-compaction strips transient runtime\n  markers before persistence, records checkpoint state durably, restores it in\n  REPL/agent flows, and preserves trace propagation across Process Broker\n  execution boundaries.\n- **Honest execution boundary**: durable terminal evidence prevents duplicate\n  automatic replay after a scheduler process crash. Start-only evidence or a\n  post-side-effect persistence failure remains outcome-unknown and requires\n  explicit handling; this release does not claim global exactly-once behavior.\n- **Known residuals**: Agenda monitor, Automation, Loop, Routine GitHub,\n  standalone scheduler daemon/liveness, shared permission/budget resolution,\n  IANA timezone/DST/missed-run semantics, migration/rollback, disk-fault and\n  long-soak closure remain outside this release. Signed native distribution and\n  representative alias-removal telemetry also remain open.\n- **Published release evidence**: immutable tag `v-npm-0-163-5` resolves to\n  exact source commit `095087c1e859a8451ce01ed58c59af3fede756fd`. Its Linux,\n  Windows, and macOS `CLI CI` (`31509337185`) and `CLI Strict Sandbox`\n  (`31509336854`) matrices passed; the dedicated npm release (`31509336832`)\n  completed its exact-SHA gate, immutable package, Trusted Publishing and\n  signed provenance, and the independent public readback (`31514940240`)\n  succeeded. npm reports `latest=0.163.5`; the public tarball SHA-1 is\n  `5dc6677dee6d1d73b708e6a50e3808007a314894`."
+        }
+      ]
+    },
     {
       "productVersion": null,
       "cliVersion": "0.163.4",
@@ -10,7 +36,7 @@
       "sections": [
         {
           "heading": "Added — cc CLI 0.163.4: immutable MCP capsules and durable scheduler storage",
-          "body": "> `chainlesschain` **0.163.3 → 0.163.4** (candidate; not yet published,\n> 2026-08-11).\n> CLI-only candidate; `@chainlesschain/personal-data-hub` remains **0.4.57**\n> and `@chainlesschain/agent-sdk` remains **0.1.7**.\n\n- **Immutable MCP capsule build inputs**: the capsule builder now executes in a\n  bounded worker against an in-memory WASM virtual filesystem populated from\n  verified bytes. Package sources and native builder assets are canonicalized,\n  identity-bound, and no longer reopened from mutable host paths during the\n  build.\n- **Platform-bound live capsule evidence**: materialized stdio MCP capsules are\n  exercised through the production Process Broker and child contract on Linux,\n  Windows, and macOS. Framed reports, exact asset identity, deferred host-path\n  resolution, and shared CJS/ESM trace context prevent warning or path-alias\n  drift from weakening the evidence chain.\n- **Bounded failure behavior**: worker memory, output, timeout, and cleanup are\n  bounded; partial or malformed child evidence, post-verification replacement,\n  unapproved effects, and unsupported strict boundaries fail closed.\n- **Command lifecycle evidence and alias decision**: report v2 binds exact\n  coverage, approval, scope, and repository evidence and summarizes command\n  telemetry without silently accepting zero-data input. All 25 deprecated\n  aliases remain retained until representative opt-in telemetry exists and the\n  documented `0.164.0` removal floor is reached.\n- **Scheduler kernel storage foundation**: a versioned SQLite store adds strict\n  schema verification, expected-revision CAS, logical-occurrence deduplication,\n  durable claims, and two-handle race coverage. This is the first P2-4 storage\n  milestone, not completion of the scheduling kernel or orchestration runtime.\n- **Delivery and recovery hardening**: production delivery adapters, durable\n  provider-backed compaction, MCP recovery admission, session ownership fences,\n  and exact Windows write checks close additional internal consistency gaps.\n- **Native release readback hardening**: release evidence now verifies public\n  bytes, checksums, manifests, signatures, and provenance contracts more\n  strictly. Signed native distribution is still blocked until real signed\n  artifacts and public package-manager readback are available.\n- **Known residuals**: full P2-4 scheduling orchestration, signed native\n  distribution, representative alias telemetry, and the remaining documented\n  long-soak/host-boundary follow-ups are not claimed by this release.\n- **Release status**: final tag, exact source SHA, workflow run IDs, package\n  digest, provenance, and public registry readback are intentionally omitted\n  until the exact `0.163.4` release commit passes the Linux, Windows, and macOS\n  `CLI CI` and `CLI Strict Sandbox` gates and the npm release/readback workflows\n  complete successfully."
+          "body": "> `chainlesschain` **0.163.3 → 0.163.4** (published from exact SHA\n> `27ed0ac2005e16ce5ddff53990e85b1d13ea0b1d`, 2026-08-11).\n> CLI-only release; `@chainlesschain/personal-data-hub` remains **0.4.57**\n> and `@chainlesschain/agent-sdk` remains **0.1.7**.\n\n- **Immutable MCP capsule build inputs**: the capsule builder now executes in a\n  bounded worker against an in-memory WASM virtual filesystem populated from\n  verified bytes. Package sources and native builder assets are canonicalized,\n  identity-bound, and no longer reopened from mutable host paths during the\n  build.\n- **Platform-bound live capsule evidence**: materialized stdio MCP capsules are\n  exercised through the production Process Broker and child contract on Linux,\n  Windows, and macOS. Framed reports, exact asset identity, deferred host-path\n  resolution, and shared CJS/ESM trace context prevent warning or path-alias\n  drift from weakening the evidence chain.\n- **Bounded failure behavior**: worker memory, output, timeout, and cleanup are\n  bounded; partial or malformed child evidence, post-verification replacement,\n  unapproved effects, and unsupported strict boundaries fail closed.\n- **Command lifecycle evidence and alias decision**: report v2 binds exact\n  coverage, approval, scope, and repository evidence and summarizes command\n  telemetry without silently accepting zero-data input. All 25 deprecated\n  aliases remain retained until representative opt-in telemetry exists and the\n  documented `0.164.0` removal floor is reached.\n- **Scheduler kernel storage foundation**: a versioned SQLite store adds strict\n  schema verification, expected-revision CAS, logical-occurrence deduplication,\n  durable claims, and two-handle race coverage. This is the first P2-4 storage\n  milestone, not completion of the scheduling kernel or orchestration runtime.\n- **Delivery and recovery hardening**: production delivery adapters, durable\n  provider-backed compaction, MCP recovery admission, session ownership fences,\n  and exact Windows write checks close additional internal consistency gaps.\n- **Native release readback hardening**: release evidence now verifies public\n  bytes, checksums, manifests, signatures, and provenance contracts more\n  strictly. Signed native distribution is still blocked until real signed\n  artifacts and public package-manager readback are available.\n- **Known residuals**: full P2-4 scheduling orchestration, signed native\n  distribution, representative alias telemetry, and the remaining documented\n  long-soak/host-boundary follow-ups are not claimed by this release.\n- **Published release evidence**: immutable tag `v-npm-0-163-4` resolves to\n  exact source commit `27ed0ac2005e16ce5ddff53990e85b1d13ea0b1d`. `CLI CI`\n  (`31421782916`), `CLI Strict Sandbox` (`31421782072`), the npm release\n  (`31424056034`), and independent public readback (`31425519966`) succeeded."
         }
       ]
     },