chainlesschain 0.166.21 → 0.166.24

package/src/commands/serve.js

@@ -7,8 +7,37 @@ import { logger } from "../lib/logger.js";
 import { createAgentRuntimeFactory } from "../runtime/runtime-factory.js";
 import { captureAgentSkillOutcomeIndex } from "../lib/evolution/agent-evolution-runtime-composition-brand.js";
 import { captureSkillVectorAuthority } from "../lib/skill-vector-authority.js";
+import { captureSkillRetrievalRevocationReader } from "../lib/evolution/skill-retrieval-revocation-authority.js";
+import { isEvolutionWorkbenchCliHost } from "../lib/evolution/evolution-workbench-cli-host.js";
+import { isGovernedKnowledgeReviewHost } from "../lib/evolution/governed-knowledge-review-host.js";
 import path from "node:path";
 
+export function captureServeGovernanceHosts({
+  evolutionWorkbenchHost = null,
+  governedKnowledgeReviewHost = null,
+} = {}) {
+  if (
+    evolutionWorkbenchHost !== null &&
+    !isEvolutionWorkbenchCliHost(evolutionWorkbenchHost)
+  ) {
+    throw new TypeError(
+      "serve evolutionWorkbenchHost must be a branded Workbench host",
+    );
+  }
+  if (
+    governedKnowledgeReviewHost !== null &&
+    !isGovernedKnowledgeReviewHost(governedKnowledgeReviewHost)
+  ) {
+    throw new TypeError(
+      "serve governedKnowledgeReviewHost must be a branded review host",
+    );
+  }
+  return Object.freeze({
+    evolutionWorkbenchHost,
+    governedKnowledgeReviewHost,
+  });
+}
+
 export function registerServeCommand(program, dependencies = {}) {
   const evolutionCompositionFactory =
     dependencies.evolutionCompositionFactory ?? null;
@@ -20,6 +49,13 @@ export function registerServeCommand(program, dependencies = {}) {
     dependencies.skillVectorAuthority == null
       ? null
       : captureSkillVectorAuthority(dependencies.skillVectorAuthority);
+  const skillRetrievalRevocationReader =
+    dependencies.skillRetrievalRevocationReader == null
+      ? null
+      : captureSkillRetrievalRevocationReader(
+          dependencies.skillRetrievalRevocationReader,
+        );
+  const governanceHosts = captureServeGovernanceHosts(dependencies);
   const serve = program
     .command("serve")
     .description("Start WebSocket server for remote CLI access")
@@ -141,6 +177,8 @@ export function registerServeCommand(program, dependencies = {}) {
               evolutionCompositionFactory,
               skillOutcomeIndex,
               skillVectorAuthority,
+              skillRetrievalRevocationReader,
+              ...governanceHosts,
               maxQueuedRequests,
             });
             const info = await host.start();
@@ -173,6 +211,8 @@ export function registerServeCommand(program, dependencies = {}) {
               evolutionCompositionFactory,
               skillOutcomeIndex,
               skillVectorAuthority,
+              skillRetrievalRevocationReader,
+              ...governanceHosts,
               maxQueuedRequests,
             });
           } finally {
@@ -187,6 +227,7 @@ export function registerServeCommand(program, dependencies = {}) {
               : { evolutionCompositionFactory },
           skillOutcomeIndex,
           skillVectorAuthority,
+          skillRetrievalRevocationReader,
         }).createServerRuntime({
           port: parseInt(opts.port, 10),
           host: opts.host,

package/src/commands/skill.js

@@ -131,6 +131,7 @@ export function routeSkillSearch(skills, query, options = {}) {
     tags: options.tag ? [options.tag] : [],
     target: { os: options.os || process.platform },
     outcomeMetrics: options.outcomeMetrics ?? null,
+    revocationReader: options.revocationReader ?? null,
     vectorScores: options.vectorScores ?? null,
     topK: limit,
   });
@@ -575,6 +576,8 @@ export function registerSkillCommand(program, dependencies = {}) {
           {
             ...options,
             outcomeMetrics: outcomeAuthority.metrics,
+            revocationReader:
+              dependencies.skillRetrievalRevocationReader ?? null,
           },
           skillVectorAuthority,
         );

package/src/data/changelog.json

@@ -1,6 +1,45 @@
 {
   "source": "CHANGELOG.md",
   "releases": [
+    {
+      "productVersion": null,
+      "cliVersion": "0.166.24",
+      "cliVersions": ["0.166.23", "0.166.24"],
+      "date": "2026-09-06",
+      "title": "",
+      "sections": [
+        {
+          "heading": "Fixed - cc CLI 0.166.24: durable long-running IDE tasks",
+          "body": "> `chainlesschain` **0.166.23 -> 0.166.24** (release candidate,\n> 2026-09-06).\n\n- **Long-running interactive turns**: remove the implicit 50-model-call ceiling\n  from interactive streamed Agent sessions. Explicit `--max-turns`, environment,\n  cost, and session budgets remain authoritative, while unattended runs retain\n  the conservative default ceiling.\n- **Bounded large-file traversal**: page reads by exact byte and line cursors,\n  including oversized Unicode and escaped single lines, and return an explicit\n  continuation cursor without claiming unread ranges.\n- **No redundant file reinjection**: cache a bounded set of unchanged read\n  pages per Agent loop, invalidate entries when the file version changes, and\n  reference an already-visible page instead of injecting the same content into\n  the model again.\n- **Compaction-safe progress**: retain the newest file-read cursor through both\n  micro-compaction and full context compression so a long task resumes from the\n  correct page rather than restarting a large file.\n- **Regression coverage**: exercise an 80-page task using more than 50 model\n  calls with repeated shadow and canonical compactions, proving completion with\n  every page read exactly once.\n- **Release-runtime compatibility**: invoke the isolated evolution evaluator\n  with the permission-system flag supported by the Node 22.12 release baseline,\n  preventing the publish gate from failing before child-package publication.\n- **Release boundary**: no child npm package version changes are required. This\n  exact commit must pass every configured Linux, Windows, and macOS job in\n  `CLI CI` and `CLI Strict Sandbox` before the immutable npm tag is created."
+        }
+      ]
+    },
+    {
+      "productVersion": null,
+      "cliVersion": "0.166.23",
+      "cliVersions": ["0.1.5", "0.3.12", "0.166.22", "0.166.23"],
+      "date": "2026-09-06",
+      "title": "",
+      "sections": [
+        {
+          "heading": "Added - cc CLI 0.166.23: durable governed evolution and Workbench controls",
+          "body": "> `chainlesschain` **0.166.22 -> 0.166.23**,\n> `@chainlesschain/core-db` **0.1.4 -> 0.1.5**, and\n> `@chainlesschain/session-core` **0.3.11 -> 0.3.12** (release candidates,\n> 2026-09-06; not yet published).\n\n- **Public-install dependency closure**: ship Session Core's missing\n  `./evolvable-artifact` export and structured evolution memory updates, plus\n  Core DB's unprefixed named-parameter normalization. Publish these two child\n  packages before the exactly pinned CLI; the other 11 audited related package\n  payloads match their existing public releases and do not need a version bump.\n- **Governed knowledge rollback**: persist real Skill rollback, candidate\n  rejection, revocation admission fences, and targeted Wiki tombstones;\n  authenticate multi-hop Wiki provenance and recover interrupted settlement\n  without duplicate effects or reactivation of revoked sources.\n- **Durable Wiki and model boundaries**: authenticate pruning checkpoints and\n  retrieval projections, recover maintenance effects, and enforce bounded,\n  redacted durable projections at the model ingress boundary.\n- **Trusted Workbench assembly**: provide authenticated current-state\n  projections, durable review/rollback adapters, file-backed resources, and\n  one-use-bound control ports for signed CLI/App Server deployment modules.\n  Review batch completion uses the v2 receipt contract supported by the updated\n  JetBrains source; installed IDE extensions do not update automatically.\n- **Atomic watchdog reservations**: serialize first acquisition and expired\n  takeover across processes, publish only fully written records, and preserve\n  prior reservations when staging fails.\n- **Windows sandbox identity publication**: flush and close the helper's\n  identity record before a non-overwriting atomic move exposes it to the\n  broker. Late helper errors cannot overwrite an already-published identity;\n  post-spawn failures retain their original cause and remain fail-closed.\n- **Release and deployment boundary**: require the exact candidate SHA to pass\n  both complete three-platform CLI gates, including independent Core DB and\n  Session Core tests. Workbench remains unavailable without a real trusted\n  deployment, identity, and policy configuration; this release does not enable\n  unattended promotion or claim that the entire evolution roadmap is complete."
+        }
+      ]
+    },
+    {
+      "productVersion": null,
+      "cliVersion": "0.166.22",
+      "cliVersions": ["0.166.21", "0.166.22"],
+      "date": "2026-09-05",
+      "title": "",
+      "sections": [
+        {
+          "heading": "Fixed - cc CLI 0.166.22: keep IDE Agent streams alive during slow commands",
+          "body": "> `chainlesschain` **0.166.21 -> 0.166.22** (release candidate,\n> 2026-09-05).\n\n- **Responsive persistent IDE streams**: execute foreground shell commands\n  asynchronously for `stream-json` hosts, so a slow networked command such as\n  `git push` no longer blocks the Agent protocol pump or session-lease\n  heartbeat.\n- **Safe late heartbeat recovery**: let the exact live local lease owner renew\n  after an event-loop stall. A revocation or successor still changes the\n  durable authority tuple and fences the old host before any guarded write.\n- **Regression coverage**: verify event-loop responsiveness, late renewal, and\n  the IDE stream's non-blocking shell option while retaining the existing\n  takeover, revocation, and delegated-writer fences.\n- **Release inventory coherence**: align the Skill-writer inventory with the\n  current candidate-only sync and inactive marketplace-plugin staging paths,\n  removing stale evidence for legacy active hot-loading.\n- **Release boundary**: publication requires this exact release commit to pass\n  every configured Linux, Windows, and macOS job in `CLI CI` and\n  `CLI Strict Sandbox`; no Session Core, Agent SDK/Protocol, Personal Data Hub,\n  or other npm workspace version changes are required for this CLI-only fix."
+        }
+      ]
+    },
     {
       "productVersion": null,
       "cliVersion": "0.166.21",

package/src/gateways/ws/ws-agent-handler.js

@@ -274,6 +274,7 @@ export class WSAgentHandler {
       );
     }
     this._compactionLlmQuery = compactionLlmQuery || null;
+    this._customCompactionChatFn = typeof compactionChatFn === "function";
     this._compactionSettlementBlock = null;
     this._compactionChatFn =
       compactionChatFn ||
@@ -836,7 +837,11 @@ export class WSAgentHandler {
     return null;
   }
 
-  async _compactCanonicalHistoryBeforeClaim(requestId, signal = null) {
+  async _compactCanonicalHistoryBeforeClaim(
+    requestId,
+    signal = null,
+    evolutionComposition = null,
+  ) {
     const { session } = this;
     if (
       session.autoCompact === false ||
@@ -873,6 +878,14 @@ export class WSAgentHandler {
           preserveCompletedExchange: true,
           llmQuery: this._compactionLlmQuery,
           chatFn: this._compactionChatFn,
+          ...(evolutionComposition === null
+            ? {}
+            : {
+                evolutionIngress: evolutionComposition.evolutionIngress,
+                chatFn: this._customCompactionChatFn
+                  ? this._compactionChatFn
+                  : undefined,
+              }),
           chatOptions: {
             cwd: session.projectRoot,
             sessionId: session.id,
@@ -1395,9 +1408,13 @@ export class WSAgentHandler {
           strictUsageTelemetry =
             this._resolveCanonicalUsageProtocol() === "call-ledger";
           if (strictUsageTelemetry) this._assertUsageLedgerWritable();
+          if (this._evolutionCompositionFactory !== null) {
+            evolutionComposition = await this._prepareEvolutionTurn(requestId);
+          }
           const compacted = await this._compactCanonicalHistoryBeforeClaim(
             requestId,
             turnSignal,
+            evolutionComposition,
           );
           if (!compacted) return;
         }
@@ -1429,7 +1446,10 @@ export class WSAgentHandler {
           return;
         }
       }
-      if (this._evolutionCompositionFactory !== null) {
+      if (
+        this._evolutionCompositionFactory !== null &&
+        evolutionComposition === null
+      ) {
         evolutionComposition = await this._prepareEvolutionTurn(requestId);
       }
       if (evolutionComposition !== null) {
@@ -1489,6 +1509,11 @@ export class WSAgentHandler {
       const approvalGate = await this._ensureApprovalGate();
       approvalGate?.beginTurn?.(requestId || `turn-${Date.now()}`);
       const loopOptions = {
+        ...(evolutionComposition === null
+          ? {}
+          : {
+              evolutionIngress: evolutionComposition.evolutionIngress,
+            }),
         provider: session.provider,
         model: activeModel,
         baseUrl: session.baseUrl || "http://localhost:11434",
@@ -2228,11 +2253,15 @@ export class WSAgentHandler {
         const expectedMessages = [...session.messages];
         let result = null;
         let commandError = null;
+        let compactionEvolution = null;
         let compactionUsageCall = null;
         let compactionUsageSettled = false;
         try {
           this.assertSessionBudgetAdmission("WebSocket compaction");
           this._sessionHostLease?.assert?.();
+          compactionEvolution = await this._prepareEvolutionTurn(
+            `compact:${requestId || randomUUID()}`,
+          );
           result = await this._compactContextMemory(
             session.messages,
             {
@@ -2246,6 +2275,14 @@ export class WSAgentHandler {
               preserveCompletedExchange: true,
               llmQuery: this._compactionLlmQuery,
               chatFn: this._compactionChatFn,
+              ...(compactionEvolution === null
+                ? {}
+                : {
+                    evolutionIngress: compactionEvolution.evolutionIngress,
+                    chatFn: this._customCompactionChatFn
+                      ? this._compactionChatFn
+                      : undefined,
+                  }),
               chatOptions: {
                 cwd: session.projectRoot,
                 sessionId: session.id,
@@ -2428,6 +2465,26 @@ export class WSAgentHandler {
           // never retried by this command.
           this._emitCompactionUsage(requestId, usageEvent);
         }
+        if (
+          compactionEvolution !== null &&
+          result !== null &&
+          commandError === null
+        ) {
+          try {
+            await compactionEvolution.evolutionIngress.complete();
+          } catch {
+            commandError = this._latchCompactionSettlement({
+              code: "CC_AGENT_EVOLUTION_INGRESS_FAILED",
+              reason: "compaction_evolution_completion_failed",
+              commitState: "evolution-unconfirmed",
+            });
+            this.interaction.emit("compaction-degraded", {
+              requestId,
+              ...commandError,
+              summaryMode: "none",
+            });
+          }
+        }
         this.interaction.emit("command-response", {
           requestId,
           command: cmd,

package/src/gateways/ws/ws-server.js

@@ -392,6 +392,8 @@ export class ChainlessChainWSServer extends EventEmitter {
           options.remoteMembershipCoordinator === null
             ? null
             : () => this._requireRemoteMembershipCoordinator(),
+        refreshCoordinatorOnEnumeration:
+          options.remoteMembershipCoordinator != null,
         membershipAuthority:
           options.remoteMembershipAuthority === null
             ? null

package/src/harness/golden-transcript.js

@@ -18,6 +18,7 @@ const VOLATILE_KEYS = new Set([
   "updatedAt",
   "duration",
   "durationMs",
+  "fileVersion",
   "permission_decision_id",
   "tool_use_id",
   "turn_id",

package/src/harness/prompt-compressor.js

@@ -10,13 +10,21 @@
  */
 
 import { createHash } from "node:crypto";
+import {
+  collectFileReadProgress,
+  FILE_READ_PROGRESS_PREFIX,
+  fileReadProgressBody,
+} from "../lib/read-file-page.js";
 import { feature, featureVariant } from "../lib/feature-flags.js";
 import { isAbortError } from "../lib/abort-utils.js";
 import {
   CONTEXT_WINDOWS,
   getContextWindow,
 } from "../lib/model-context-window.js";
-export { CONTEXT_WINDOWS, getContextWindow } from "../lib/model-context-window.js";
+export {
+  CONTEXT_WINDOWS,
+  getContextWindow,
+} from "../lib/model-context-window.js";
 import {
   DURABLE_SYSTEM_MESSAGE_KINDS,
   getDurableSystemMessageProvenance,
@@ -107,7 +115,14 @@ function buildBoundedHistory(messages, maxChars) {
 }
 
 function summaryPrompt(messages, maxChars) {
-  const schema = `{${STRUCTURED_HANDOFF_FIELDS.map((field) => `"${field}"`).join(",")}}`;
+  const schema = JSON.stringify(
+    Object.fromEntries(
+      STRUCTURED_HANDOFF_FIELDS.map((field) => [
+        field,
+        field === "objective" ? "" : [],
+      ]),
+    ),
+  );
   const instructions = [
     "Create a durable conversation handoff from the history below.",
     `Return exactly one strict JSON object with all keys in this order: ${schema}.`,
@@ -356,6 +371,7 @@ export class PromptCompressor {
       ? messages.filter((m) => !isPinned(m))
       : messages;
 
+    const readProgress = collectFileReadProgress(messages);
     const originalTokens = estimateMessagesTokens(messages);
     let result = [...working];
     const applied = [];
@@ -397,7 +413,10 @@ export class PromptCompressor {
     }
 
     if (result.length > this.maxMessages) {
-      result = this._truncate(result);
+      result = this._truncate(
+        result,
+        this.maxMessages - (readProgress.length ? 1 : 0),
+      );
       applied.push("truncate");
     }
 
@@ -417,6 +436,32 @@ export class PromptCompressor {
       result = sanitizeToolPairs(result);
     }
 
+    // The LLM summary may omit paging state. Preserve bounded cursors from the
+    // actual read results even when old tool pairs are removed completely.
+    if (applied.length && readProgress.length) {
+      result = result.filter(
+        (message) => fileReadProgressBody(message) === null,
+      );
+      const insertion = result.findIndex(
+        (message) => message.role !== "system",
+      );
+      result.splice(
+        insertion < 0 ? result.length : insertion,
+        0,
+        markDurableSystemMessage(
+          {
+            role: "system",
+            content:
+              FILE_READ_PROGRESS_PREFIX +
+              JSON.stringify(readProgress) +
+              "\nHistorical read positions, not retained file contents. Continue with nextRead when relevant; if the file changed or an earlier section is needed, read that specific section.",
+          },
+          DURABLE_SYSTEM_MESSAGE_KINDS.COMPACT_SUMMARY,
+        ),
+      );
+      applied.push("file-read-progress");
+    }
+
     const compressedTokens = estimateMessagesTokens(result);
     const stats = {
       strategy: applied.join("+") || "none",
@@ -493,7 +538,7 @@ export class PromptCompressor {
     return result;
   }
 
-  _truncate(messages) {
+  _truncate(messages, maxMessages = this.maxMessages) {
     const system = messages.filter(
       (m) => m.role === "system" && !isCompactionArtifact(m),
     );
@@ -502,7 +547,7 @@ export class PromptCompressor {
       (m) => (m.role !== "system" || isCompactionArtifact(m)) && m !== last,
     );
 
-    let slots = this.maxMessages - system.length;
+    let slots = maxMessages - system.length;
     if (last) slots -= 1;
 
     const recent = rest.slice(-Math.max(slots, 1));
@@ -627,6 +672,7 @@ export class PromptCompressor {
       // A durable-ledger write failure is authoritative too. Falling back here
       // would let the host continue after losing the model-call boundary.
       if (error?.runtimeLedgerPersistence === true) throw error;
+      if (error?.code === "CC_AGENT_EVOLUTION_INGRESS_FAILED") throw error;
       // A workflow-bound query may already have reached the provider. An
       // extractive fallback would make the outer durable effect look completed
       // and authorize a replay of that physically unknown request.

package/src/harness/provider-backed-compaction.js

@@ -3,6 +3,7 @@ import {
   PromptCompressor,
   sanitizeToolPairs,
 } from "./prompt-compressor.js";
+import { captureAgentEvolutionIngress } from "../lib/evolution/agent-evolution-ingress.js";
 
 const DEFAULT_MAX_OUTPUT_TOKENS = 2048;
 const MIN_MAX_OUTPUT_TOKENS = 256;
@@ -121,11 +122,35 @@ export function compactionTokenUsage(stats) {
  * contract instead of falling back to positional truncation.
  */
 export async function compactConversationWithProvider(messages, options = {}) {
+  const configuredIngress =
+    options.evolutionIngress ?? options.chatOptions?.evolutionIngress ?? null;
+  const evolutionIngress =
+    configuredIngress === null
+      ? null
+      : captureAgentEvolutionIngress(configuredIngress);
   const originalMessages = Array.isArray(messages) ? [...messages] : [];
   const provider = options.provider || null;
   const model = options.model || null;
   const maxOutputTokens = boundedMaxOutputTokens(options.maxOutputTokens);
-  const chatFn = options.chatFn;
+  let chatFn = options.chatFn;
+  if (evolutionIngress !== null) {
+    const { chatWithTools } = await import("../runtime/agent-core.js");
+    if (
+      (chatFn != null && chatFn !== chatWithTools) ||
+      options.llmQuery != null ||
+      options.compressor != null ||
+      (options.evolutionIngress != null &&
+        options.chatOptions?.evolutionIngress != null &&
+        options.evolutionIngress !== options.chatOptions.evolutionIngress)
+    ) {
+      const error = new TypeError(
+        "Evolution compaction requires the canonical model transport and compressor",
+      );
+      error.code = "CC_AGENT_EVOLUTION_INGRESS_FAILED";
+      throw error;
+    }
+    chatFn = chatWithTools;
+  }
   const invokeProviderCall = async (call) => {
     const callId = safeUsageCallId(await options.onProviderCallStart?.());
     try {
@@ -145,12 +170,14 @@ export async function compactConversationWithProvider(messages, options = {}) {
           return invokeProviderCall(async () => {
             const response = await chatFn([{ role: "user", content: prompt }], {
               ...(options.chatOptions || {}),
+              ...(evolutionIngress === null ? {} : { evolutionIngress }),
               provider,
               model,
               baseUrl: options.baseUrl,
               apiKey: options.apiKey,
               signal: options.signal,
               contextEngine: null,
+              contextMemorySkipPlanning: true,
               enabledToolNames: [],
               extraToolDefinitions: [],
               hostManagedToolPolicy: null,

package/src/harness/remote-session-registry.js

@@ -268,6 +268,8 @@ export class RemoteSessionRegistry {
     // explicitly require this authority and trigger its lazy construction.
     this._membershipAuthority = options.membershipAuthority ?? null;
     this._membershipCoordinator = options.membershipCoordinator ?? null;
+    this._refreshCoordinatorOnEnumeration =
+      options.refreshCoordinatorOnEnumeration === true;
     this.sessions = new Map();
     this.tokens = new Map();
     this._transportBindings = new Map();
@@ -1175,11 +1177,21 @@ export class RemoteSessionRegistry {
   }
 
   findHosted(agentSessionId, hostClientId) {
-    if (this._membershipCoordinator) {
+    const hasDurableSession = [...this.sessions.values()].some((session) =>
+      Boolean(session.hostPrincipalId),
+    );
+    if (
+      this._membershipCoordinator &&
+      (this._refreshCoordinatorOnEnumeration ||
+        this._coordinatorHydrated ||
+        hasDurableSession)
+    ) {
       // Enumeration cannot rely on the one-time startup hydration: another
       // server may have created, closed, or re-enabled a durable session since
-      // this process started. Refresh the coordinator index before matching
-      // local transport attachments.
+      // this process started. Explicit coordinator deployments and processes
+      // already serving durable sessions refresh before matching local
+      // transport attachments. A lazy default coordinator must stay unopened
+      // for purely in-memory sessions.
       this._hydrateCoordinatorSessions(this._resolveMembershipCoordinator());
     }
     const matches = [];

package/src/index.js

@@ -13,6 +13,7 @@ import {
   startDefaultEventRuntimeHost,
   stopDefaultEventRuntimeHost,
 } from "./lib/event-runtime-host.js";
+import { loadEvolutionDeploymentCommandDependencies } from "./lib/evolution/evolution-deployment-loader.js";
 
 // The manifest entry is the canonical registration point for learning.  Keep
 // these names visible here for tooling that audits the CLI's command surface:
@@ -25,14 +26,22 @@ const __dirname = dirname(fileURLToPath(import.meta.url));
 const commandModules = [];
 
 for (const entry of manifest.commands) {
+  let deploymentStarted = false;
   try {
     const modulePath = join(__dirname, entry.module.replace("./", ""));
     const moduleUrl = pathToFileURL(modulePath).href;
     const mod = await import(moduleUrl);
-    commandModules.push({ entry, mod });
+    deploymentStarted = true;
+    const deploymentDependencies =
+      await loadEvolutionDeploymentCommandDependencies(entry.name);
+    commandModules.push({ entry, mod, deploymentDependencies });
   } catch (err) {
     // Store error for later reporting
-    commandModules.push({ entry, error: err });
+    commandModules.push({
+      entry,
+      error: err,
+      deploymentError: deploymentStarted,
+    });
   }
 }
 
@@ -79,9 +88,16 @@ export function createProgram(options = {}) {
   });
 
   // Register all preloaded commands
-  for (const { entry, mod, error } of commandModules) {
+  for (const {
+    entry,
+    mod,
+    error,
+    deploymentError,
+    deploymentDependencies,
+  } of commandModules) {
     if (shouldFilter && !allowedCommands.has(entry.name)) continue;
     if (error) {
+      if (deploymentError) throw error;
       if (process.env.DEBUG) {
         console.warn(
           chalk.yellow(
@@ -99,8 +115,18 @@ export function createProgram(options = {}) {
           `Register function '${entry.register}' not found in ${entry.module}`,
         );
       }
-      registerFn(program, options.commandDependencies?.[entry.name]);
+      registerFn(
+        program,
+        options.commandDependencies?.[entry.name] ??
+          deploymentDependencies ??
+          undefined,
+      );
     } catch (err) {
+      if (
+        options.commandDependencies?.[entry.name] != null ||
+        deploymentDependencies != null
+      )
+        throw err;
       if (process.env.DEBUG) {
         console.warn(
           chalk.yellow(

package/src/lazy-dispatch.js

@@ -682,6 +682,12 @@ async function defaultLoadFullProgram() {
   return createProgramAsync();
 }
 
+async function defaultLoadCommandDependencies(commandName) {
+  const { loadEvolutionDeploymentCommandDependencies } =
+    await import("./lib/evolution/evolution-deployment-loader.js");
+  return loadEvolutionDeploymentCommandDependencies(commandName);
+}
+
 /**
  * Load/register may fall back to the compatibility program. parseAsync is
  * intentionally outside that catch: once an action begins, any failure must
@@ -692,6 +698,7 @@ export async function dispatchManifestEntry(
   entry,
   {
     loadCommandModule = defaultLoadCommandModule,
+    loadCommandDependencies = defaultLoadCommandDependencies,
     createBaseProgram = defaultCreateBaseProgram,
     loadFullProgram = defaultLoadFullProgram,
     stderr = process.stderr,
@@ -699,6 +706,7 @@ export async function dispatchManifestEntry(
   } = {},
 ) {
   let program;
+  let allowCompatibilityFallback = true;
   try {
     program = await createBaseProgram();
     const mod = await loadCommandModule(entry);
@@ -708,8 +716,14 @@ export async function dispatchManifestEntry(
         `Register function '${entry.register}' not found in ${entry.module}`,
       );
     }
-    registerFn(program);
+    // Governed deployment loading may reconcile durable state. Do not hide a
+    // failed trust check or retry that assembly through the eager program.
+    allowCompatibilityFallback = false;
+    const dependencies = await loadCommandDependencies(entry.name);
+    allowCompatibilityFallback = dependencies == null;
+    registerFn(program, dependencies ?? undefined);
   } catch (error) {
+    if (!allowCompatibilityFallback) throw error;
     if (env.DEBUG || env.CC_DEBUG) {
       stderr.write(
         `Lazy command registration failed; loading compatibility program: ${error.message}\n`,