comisai 1.0.41 → 1.0.44

package/node_modules/@comis/daemon/dist/daemon.js

@@ -1,57 +1,95 @@
 // SPDX-License-Identifier: Apache-2.0
-// @allow-throw: daemon bootstrap composition-root failures (secrets bootstrap, decryption, etc.); hard-fail at startup is the correct contract per AGENTS.md §6.2 (bootstrap() returns Result but daemon.ts is the entry point that catches it and exits).
+// @allow-throw: daemon bootstrap composition-root failures (secrets bootstrap, decryption, etc.); hard-fail at startup is the correct contract (bootstrap() returns Result but daemon.ts is the entry point that catches it and exits).
 /**
- * Daemon Entry Point: thin orchestrator calling setupXxx() factories in sequence.
+ * Daemon Entry Point: composition root for the entire daemon process.
  *
- * Helpers live in `./stages/` (5 modules + 1 barrel); Handle interfaces and
- * SessionStoreBridge live in `./daemon-types.ts`. This file is the
- * composition root: 5 stage* orchestrators + main() + 4 small helpers
- * (DEFAULT_CONFIG_PATHS / applyInspectDefaultsForLogging /
- * hardenDataDirPermissions / runPreflightDoctor).
+ * Structure: (1) imports; (2) DEFAULT_CONFIG_PATHS + applyInspectDefaultsForLogging;
+ * (3) hardenDataDirPermissions; (4) runPreflightDoctor; (5) process.env scrub helpers;
+ * (6) agents-stage helpers; (7) channels-stage helpers (buildChannelManagerDeps,
+ * buildGraphCoordinatorDeps, wirePostChannelsLifecycle); (8) gateway-stage helpers
+ * (resolveGatewayTokens, createHotAdd/Remove, buildRpcDispatchDeps,
+ * replayContinuationsIfAny); (9) shutdown-stage helpers; (10) bootFoundation /
+ * bootAgents / bootChannels / bootGateway / bootShutdown; (11) main(); (12) direct-run guard.
+ *
+ * The 4-handle chain (Foundation → Agents → Channels → Gateway) is collapsed into ONE
+ * BootContext (`./daemon-types.ts`): each boot* helper takes `boot: BootContext` and
+ * mutates it via Object.assign; main() chains the 5 helpers. The 6 true forward-ref
+ * slots (channelPluginsRef, bgNotifyRef, cronWakeCallbackRef, gatewaySendRef,
+ * shutdownRef, channelAdaptersRef) persist on BootContext. Larger one-shot helpers are
+ * top-level functions here; trivial ones are inlined at their single call site. Some
+ * helpers live in wiring/main-helpers.ts (image/video bundles, durability, etc.).
  *
  * @module
  */
-import { bootstrap, loadEnvFile, createApprovalGate, parseFormattedSessionKey, envSubset, createInjectionRateLimiter, checkApprovalsConfig, safePath, resolveConfigSecretRefs, BackgroundTasksConfigSchema, } from "@comis/core";
+import { bootstrap, loadEnvFile, createApprovalGate, createAuditAggregator, createConfigGitManager, parseFormattedSessionKey, envSubset, createInjectionRateLimiter, checkApprovalsConfig, formatSessionKey, safePath, resolveConfigSecretRefs, validateMemoryWrite, themeForName, BackgroundTasksConfigSchema, writeMasterKeyIfAbsent, preReadStorageMode, systemNowMs, } from "@comis/core";
 // Runtime adapter factories — constructed at the composition root and
 // threaded through wiring helpers that retarget Date.now / process.env /
 // setTimeout / setInterval. Sanctioned construction site.
 import { createSystemClock, createSystemEnv, createSystemTimers } from "@comis/infra";
-import { setupSecrets as _setupSecretsImpl, createNamedGraphStore, createContextStore, createObservabilityStore } from "@comis/memory";
+import { createNamedGraphStore, createObservabilityStore, selectSecretStore, } from "@comis/memory";
 import { createGatewayServer } from "@comis/gateway";
-import { setupLogging, setupObservability, setupHealth, setupMemory, setupAgents, setupSchedulers, setupChannels, setupMedia, setupCrossSession, setupTools, setupMonitoring, setupHeartbeat, setupTaskExtraction, setupShutdown, setupGateway, setupRpcBridge, setupDeliveryQueue, setupDeliveryMirror, setupNotifications, setupBackgroundTasks, setupBackgroundCompletionRunner, } from "./wiring/index.js";
-import { createActiveRunRegistry, createBackgroundSessionResolver, createGeminiCacheManager, validateProviderOverrides, } from "@comis/agent";
+import { setupLogging, setupObservability, rehydrateSpendFromStore, setupHealth, setupMemory, setupAgents, setupSchedulers, setupChannels, createInteractiveCallbackWiring, setupMedia, setupCrossSession, setupTools, setupMonitoring, setupHeartbeat, setupShutdown, setupGateway, setupRpcBridge, setupDeliveryQueue, setupDeliveryMirror, buildDurableStores, buildDurableResume, createWorktreeRegistry, toLifecycleGitExec, setupWorktreeSweep, discoverWorktreeOrphans, setupNotifications, setupBackgroundTasks, setupBackgroundCompletionRunner, setupTerminalWake, setupMcp, selectMcpTokenStore, setupSkillBundles, buildSkillRegistriesForBundles, setupOutputRetention, setupBroker, acquireDataDirLock, releaseDataDirLock, } from "./wiring/index.js";
+import { createActiveRunRegistry, createBackgroundSessionResolver, clearSessionState, createGeminiCacheManager, createSessionTrackerRegistry, evaluateViableFloorForAgent, probeAllOllamaProviders, seedDefaultDagTemplates, validateProviderOverrides, wireGeminiCacheCleanup, wireMcpDisconnectCleanup, wireSessionStateCleanup, } from "@comis/agent";
+// resolveAgentMainProvider is the handler-side accessor that delegates to the
+// EXACT completion-path resolveAgentModel (I4 lockstep / RES-01). Imported
+// directly (not via the wiring barrel) to avoid widening the barrel surface.
+import { resolveAgentMainProvider } from "./wiring/setup-agents/setup-agents-tooling.js";
+import { seedBundledSkills, defaultSeedBundledSkillsDeps } from "./wiring/seed-bundled-skills.js";
 // createModelCatalog + resolveWorkspaceDir live in @comis/core.
 import { createModelCatalog, resolveWorkspaceDir } from "@comis/core";
-import { detectSandboxProvider } from "@comis/skills";
+import { createFileStateTracker, detectSandboxProvider } from "@comis/skills";
+import { reapNeverTaskedDrives as reapNeverTaskedDrivesInRegistry } from "@comis/skills/tools";
+import { constructCapabilityLayer } from "./wiring/setup-capability-endpoint-boot.js"; // Phase 211 ENDPOINT-01/03 + JAIL-03
+// The single process-singleton activity circuit breaker is constructed
+// here and threaded down through ChannelsDeps → buildAndStartChannelManager
+// into every per-turn coordinator. The daemon is the composition root that owns
+// the breaker's lifetime; the orchestrator owns its logic.
+import { createActivityCircuitBreaker } from "@comis/orchestrator";
 import { createGraphCoordinator, createNodeTypeRegistry } from "./graph/index.js";
+import { resolveGraphConcurrencyDefaults } from "./graph/graph-capability-defaults.js";
 import { createWakeCoalescer, createSystemEventQueue } from "@comis/scheduler";
 import { createTokenRegistry } from "./api/token-handlers.js";
-import { createLatencyRecorder } from "./observability/latency-recorder.js";
+import { buildObsMcpClientClosures } from "./wiring/obs-mcp-closures.js";
+import { createEmptyBootContext } from "./daemon-types.js";
 import { setupObsPersistence } from "./observability/obs-persistence-wiring.js";
+import { recordModelHealth } from "./observability/record-model-health.js";
+import { buildConfigPostureRecord, countChimericModels, countPricingGaps, isLoopbackHost } from "./observability/build-config-posture-record.js";
+import { setupDeliveryQueueLogging } from "./observability/delivery-queue-logger.js";
 import { createContextPipelineCollector } from "./observability/context-pipeline-collector.js";
-import { createLogLevelManager } from "./observability/log-infra.js";
+import { createLogLevelManager, expandTilde } from "./observability/log-infra.js";
 import { createTokenTracker } from "./observability/token-tracker.js";
 import { createTracingLogger } from "./observability/trace-logger.js";
 import { setupChannelHealthLogging } from "./observability/channel-health-logger.js";
-import { registerGracefulShutdown } from "./process/graceful-shutdown.js";
 import { createProcessMonitor } from "./process/process-monitor.js";
-import { startWatchdog } from "./health/watchdog.js";
+import { ok, err, suppressError } from "@comis/shared";
+import { exportTrajectoryBundle } from "@comis/observability";
 import { randomUUID } from "node:crypto";
-import { existsSync, chmodSync, statSync, mkdirSync } from "node:fs";
+import { existsSync, statSync } from "node:fs";
+import { writeFile as fsWriteFile, rm } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+import { resolve as pathResolve } from "node:path";
 import { createExecGit } from "./config/exec-git.js";
 import { saveLastKnownGood, buildRollbackSuggestion, handleRestoreFlag } from "./config/last-known-good.js";
-import { createRestartContinuationTracker } from "./wiring/restart-continuation.js";
+import { runConfigBootstrapAndEmitObserve } from "./config/bootstrap-observe.js";
+import { createRestartContinuationTracker, loadContinuations, buildMcpStatusLine, } from "./wiring/restart-continuation.js";
+import { setupSingleAgent, createLearnedSkillSurfaceRegistry } from "./wiring/setup-agents/index.js";
+import { buildDialecticWiring, dialecticWiringDepsFromBoot } from "./wiring/setup-dialectic.js";
+import { createConversationReset } from "./wiring/conversation-reset.js";
+import { setupSecretManager } from "./wiring/setup-secret-manager.js";
+import { restoreApprovalState, resolveGatewayTokens, setupChannelHealthMonitor, resolveModelHealthMultilingual, buildImageGenBundle, buildImageHandlerDeps, buildVideoGenBundle, buildVideoHandlerDeps, buildVideoStatusHandlerDeps, buildMediaVisionBundle, createBoundedAutonomyWiring } from "./wiring/main-helpers.js";
+import { hardenDataDirPermissions } from "./wiring/harden-data-dir.js";
+import { buildAudioResolverDeps } from "./wiring/setup-audio-provider.js";
+import { runPreflightDoctor } from "./wiring/preflight-doctor.js";
 import { createInboundMessageIdResolver } from "./wiring/inbound-message-id-resolver.js";
 import { logOperationModelDryRun } from "./wiring/startup-dry-run.js";
+import { emitStartupBanner } from "./wiring/emit-startup-banner.js";
+import { emitStartupInvariants } from "./wiring/setup-startup-invariants.js";
+import { checkStorageModeConsistency } from "./wiring/setup-storage-mismatch-warn.js";
+import { buildPlaceholdersFromBindings } from "./wiring/broker-placeholder-builder.js";
+import { warnOnProviderTimeoutRedirect } from "./wiring/provider-timeout-redirect.js";
 import os from "node:os";
 import { dirname as pathDirname } from "node:path";
 import { inspect } from "node:util";
-// Stage-helper imports.
-import { seedBundledSkillCreator, bootstrapSecretsAndEnv, wireConfigGitManager, } from "./stages/foundation-helpers.js";
-import { restoreApprovalState, setupMcpManager, wirePostAgentsCleanup, buildAuditBundle, buildDeferredCronWakeCallback, } from "./stages/agents-helpers.js";
-import { buildChannelManagerDeps, buildGraphCoordinatorDeps, setupChannelHealthMonitor, createCapabilityPortResolver, wirePostChannelsLifecycle, buildImageGenBundle, } from "./stages/channels-helpers.js";
-import { resolveGatewayTokens, createHotAdd, createHotRemove, buildRpcDispatchDeps, replayContinuationsIfAny, } from "./stages/gateway-helpers.js";
-import { wireHealthLogging, emitStartupBanner, } from "./stages/shutdown-helpers.js";
 export const DEFAULT_CONFIG_PATHS = [
     safePath(safePath(os.homedir(), ".comis"), "config.yaml"),
     safePath(safePath(os.homedir(), ".comis"), "config.local.yaml"),
@@ -85,96 +123,725 @@ export function applyInspectDefaultsForLogging(env) {
     inspect.defaultOptions.breakLength = Infinity;
     return { depthChanged, breakLengthChanged };
 }
+// Preflight native-dep doctor — extracted to wiring/preflight-doctor.ts to keep
+// this composition root ≤3000 lines (v2.25 audio wiring pushed it over). Imported
+// for the boot call site below AND re-exported so `runPreflightDoctor` stays on
+// daemon.ts's public surface (daemon.test.ts imports it from "./daemon.js").
+export { runPreflightDoctor };
 // ---------------------------------------------------------------------------
-// Startup permission hardening
+// Foundation helpers — scrub + store-wins env merge
 // ---------------------------------------------------------------------------
 /**
- * Scan ~/.comis/ and fix permissions on the data directory and known
- * sensitive files. Returns an array of corrections for deferred logging.
+ * Sensitive environment variable prefixes to remove from process.env after
+ * the SecretManager snapshot captures them. Prevents leakage through
+ * subprocess inheritance.
  */
-export function hardenDataDirPermissions(dataDir) {
-    const corrections = [];
-    // Ensure data dir exists with 0o700
-    try {
-        mkdirSync(dataDir, { recursive: true, mode: 0o700 });
+const SENSITIVE_PREFIXES = [
+    "ANTHROPIC_",
+    "OPENAI_",
+    "TELEGRAM_",
+    "DISCORD_",
+    "SLACK_",
+    "WHATSAPP_",
+    "GOOGLE_",
+    "GROQ_",
+    "MISTRAL_",
+    "DEEPGRAM_",
+    "ELEVENLABS_",
+    "SENDGRID_",
+    "STRIPE_",
+];
+/** Individual keys to scrub that don't match prefix patterns. */
+const SENSITIVE_EXACT_KEYS = new Set([
+    "SECRETS_MASTER_KEY",
+]);
+/**
+ * Stage-1 scrub: remove sensitive env vars from process.env (ALL storage modes).
+ * Preserves COMIS_* (filesystem-layout pointers, not credentials — kept for
+ * subprocess path resolution; per-spawn-site envSubset() excludes them from
+ * untrusted-child envs). Preserves PATH, HOME, NODE_ENV, etc.
+ */
+function scrubProcessEnv() {
+    for (const key of Object.keys(process.env)) {
+        if (SENSITIVE_EXACT_KEYS.has(key)) {
+            // eslint-disable-next-line no-restricted-syntax -- see scrubProcessEnv comment above
+            delete process.env[key];
+            continue;
+        }
+        for (const prefix of SENSITIVE_PREFIXES) {
+            if (key.startsWith(prefix)) {
+                // eslint-disable-next-line no-restricted-syntax -- see scrubProcessEnv comment above
+                delete process.env[key];
+                break;
+            }
+        }
     }
-    catch { /* may already exist */ }
-    // Fix data directory permissions
-    try {
-        const stat = statSync(dataDir);
-        const currentMode = stat.mode & 0o777;
-        if (currentMode !== 0o700) {
-            chmodSync(dataDir, 0o700);
-            corrections.push({ file: dataDir, oldMode: currentMode, newMode: 0o700 });
+}
+/** Build mergedEnv: store-wins, stage-1 scrub for ALL modes.
+ * Returns shadowed names for deferred WARN logging (logger not yet available). */
+function buildMergedEnv(secretStore, mode) {
+    const merged = {
+        ...process.env,
+    };
+    if (mode === "env") {
+        // Env mode: env IS the source. No store values to overlay.
+        scrubProcessEnv();
+        return { mergedEnv: merged, shadowedNames: [] };
+    }
+    // file / encrypted: store is authoritative.
+    const decryptResult = secretStore.decryptAll();
+    if (!decryptResult.ok) {
+        throw new Error(`Secret decryption failed: ${decryptResult.error.message}`);
+    }
+    const shadowedNames = [];
+    for (const [name, value] of decryptResult.value) {
+        if (merged[name] !== undefined && merged[name] !== value) {
+            // store wins; collect name for deferred WARN (logger not yet available).
+            shadowedNames.push(name);
         }
+        merged[name] = value;
     }
-    catch { /* best-effort */ }
-    // Fix known sensitive files
-    const sensitiveFiles = ["config.yaml", "config.local.yaml", ".env", "secrets.db"];
-    for (const filename of sensitiveFiles) {
-        try {
-            const filePath = `${dataDir}/${filename}`;
-            const stat = statSync(filePath);
-            const currentMode = stat.mode & 0o777;
-            if (currentMode !== 0o600) {
-                chmodSync(filePath, 0o600);
-                corrections.push({ file: filePath, oldMode: currentMode, newMode: 0o600 });
-            }
+    scrubProcessEnv();
+    return { mergedEnv: merged, shadowedNames };
+}
+// ---------------------------------------------------------------------------
+// Agents helpers
+// ---------------------------------------------------------------------------
+// Helpers consumed by `bootAgents`. `wirePostAgentsCleanup` (eventBus.on
+// subscriber wiring for session:expired → registry release + Gemini cache
+// cleanup + MCP disconnect cleanup; returns the per-session FileStateTracker
+// pool) is kept here as a top-level function (large body, single call site).
+// `restoreApprovalState` (file I/O against the approvals JSON snapshot left by
+// graceful shutdown) lives in `wiring/main-helpers.ts` to keep this file under
+// its architecture line cap. Three other helpers (setupMcpManager,
+// buildAuditBundle, buildDeferredCronWakeCallback) were inlined into bootAgents.
+// ---------------------------------------------------------------------------
+/**
+ * Wire post-setupAgents cleanup listeners: session:expired releases
+ * sessionTrackerRegistry, Gemini cache disposal, and MCP disconnect cleanup.
+ * Schedules an orphan-cache cleanup pass for any stale comis:* caches.
+ */
+function wirePostAgentsCleanup(deps) {
+    const { eventBus, geminiCacheManager, daemonLogger } = deps;
+    // Clean up all session-scoped state on session expiry
+    wireSessionStateCleanup(eventBus);
+    // Per-session FileStateTracker pool -- keeps the LLM's file read state alive
+    // across turns. Registered trackers are released on session:expired.
+    const sessionTrackerRegistry = createSessionTrackerRegistry(createFileStateTracker);
+    eventBus.on("session:expired", (payload) => {
+        sessionTrackerRegistry.release(formatSessionKey(payload.sessionKey));
+    });
+    // Dispose Gemini cache on session expiry (fire-and-forget)
+    wireGeminiCacheCleanup(eventBus, geminiCacheManager);
+    // Clean up orphaned comis:* caches from previous daemon runs
+    suppressError(geminiCacheManager.cleanupOrphaned().then((result) => {
+        if (result.ok && (result.value.deleted > 0 || result.value.skipped > 0)) {
+            daemonLogger.info({ deleted: result.value.deleted, skipped: result.value.skipped }, "Gemini cache: orphan cleanup complete");
         }
-        catch { /* file may not exist; best-effort */ }
+    }), "gemini-cache-orphan-cleanup");
+    // Clean up discovery state when MCP servers disconnect or remove tools
+    wireMcpDisconnectCleanup(eventBus);
+    return sessionTrackerRegistry;
+}
+/**
+ * Build the deps object passed to `setupChannels`. The tool-assembler /
+ * session-tracker / inbound-message-id-resolver indirection slots are
+ * gone — callers pass `assembleToolsForAgent` directly (setupTools is
+ * hoisted before setupChannels) and pass `sessionTracker` /
+ * `inboundMessageIdResolver` accessor closures that read local-`let` slots
+ * captured at message-arrival time.
+ */
+function buildChannelManagerDeps(deps) {
+    const { agents, assembleToolsForAgent, getInboundMessageIdResolver, getSessionTracker } = deps;
+    const { container, executors, defaultAgentId, sessionManager, sessionStore, logger, channelsLogger, linkRunner, ssrfFetcher, transcriber, ttsAdapter, audioConverter, mediaTempManager, mediaSemaphore, fileExtractor, workspaceDirs, defaultWorkspaceDir, memoryAdapter, memoryApi, entityStore, causalStore, consolidationStore, memoryLifecycleStore, outcomeStore, learnedSkillStore, embeddingQueue, activeRunRegistry, sessionResolver, rpcCall, continuationTracker, approvalGate, interactiveCallbackWiring, piSessionAdapters, costTrackers, deliveryQueue, recordOutboundMessage, executionTrackers, onSuspiciousContent, dataDir, clock, timers, activityBreaker, activityStream, activityRendererFactoryOverride, executionPlanPorts, oauthManagers, } = agents;
+    // LEARN-01: per-agent OAuth access-token resolver (auto-refreshing) so the
+    // background memory/learning cron jobs run on an OAuth main provider
+    // (openai-codex) instead of skipping for "no API key". Wraps the SAME
+    // OAuthTokenManager.getApiKey the interactive + media-bundle paths use.
+    const resolveCronAccessToken = async (agentId, provider) => {
+        const mgr = oauthManagers?.get(agentId);
+        if (!mgr)
+            return undefined;
+        const r = await mgr.getApiKey(provider, {
+            oauthProfiles: container.config.agents?.[agentId]?.oauthProfiles,
+        });
+        return r.ok ? r.value : undefined;
+    };
+    // Complete three-layer forget for channel /new + /reset (live 2026-06-11).
+    const channelConversationReset = createConversationReset({ lcdStore: agents.lcdStore, piSessionAdapters, tenantId: container.config.tenantId, logger });
+    // Build exportSessionBundle DI closure for the /export-trajectory slash
+    // command. Uses exportTrajectoryBundle from @comis/observability (same
+    // pipeline as `comis trace export`).
+    const exportSessionBundle = async (sessionId) => {
+        const sessionsDir = safePath(container.config.dataDir ?? dataDir, "sessions");
+        const sessionFile = safePath(sessionsDir, `${sessionId}.jsonl`);
+        const workspaceDir = defaultWorkspaceDir ?? safePath(container.config.dataDir ?? dataDir, "workspace");
+        const result = await exportTrajectoryBundle({
+            sessionId,
+            sessionKey: sessionId,
+            sessionFile,
+            workspaceDir,
+            traceId: sessionId, // best-effort; bundle exporter uses for naming only
+            agentId: "unknown", // best-effort; available in session file header
+        });
+        if (!result.ok)
+            throw new Error(`Bundle export failed: ${result.error.kind}`);
+        return { bundlePath: result.value.bundleDir };
+    };
+    return {
+        container, executors, defaultAgentId, sessionManager, sessionStore,
+        logger, channelsLogger, clock, timers,
+        resolveAccessToken: resolveCronAccessToken, // LEARN-01: OAuth-provider background jobs
+        // the orchestrator-facing redacted ActivityStream (setupObservability)
+        // injected into the inbound coordinatorFactory as its activityStreamPort.
+        // the process-singleton circuit breaker shared across every coordinator.
+        activityStream, activityBreaker,
+        // the DEFAULT agent's shared ExecutionPlanHolder reference
+        // (Pitfall 1 lock — same reference as PiExecutorDeps.executionPlanHolder +
+        // AcpServerDeps.executionPlanPort, NOT a parallel createExecutionPlanHolder).
+        // Multi-agent note: only the default agent's plan-state reaches chat in this
+        // wave; non-default-agent plan updates are filtered out per-turn in the
+        // coordinator by the (agentId, sessionKey) guard. A future per-agent
+        // plan-stream Map plumbing lifts that single-agent limitation cleanly.
+        executionPlanPort: executionPlanPorts.get(defaultAgentId),
+        // test-only renderer-injection seam. Default-undefined in production
+        // (the daemon override is never set); threaded into buildActivityRenderers so
+        // an integration test can inject a spy renderer.
+        activityRendererFactory: activityRendererFactoryOverride,
+        // signed approval buttons (Telegram/Discord/Slack/LINE) + the Email
+        // single-use approval link. The wiring is built once in the agents phase
+        // (always present at runtime; optional-typed on BootContext).
+        signCallbackData: interactiveCallbackWiring?.signCallbackData,
+        mintApprovalLink: interactiveCallbackWiring?.mintApprovalLink,
+        // thread the verifier. The InteractiveCallbackRouter is the server-side
+        // authority that intercepts inbound button callbacks (inbound-gate.ts) BEFORE
+        // slash parsing — without this hop the signed payload reaches the LLM as text.
+        interactiveCallbackRouter: interactiveCallbackWiring?.router,
+        linkRunner, ssrfFetcher, transcriber,
+        maxMediaBytes: container.config.integrations.media.infrastructure.maxRemoteFetchBytes,
+        assembleToolsForAgent,
+        ttsAdapter, audioConverter, mediaTempManager, mediaSemaphore,
+        fileExtractor, fileExtractionConfig: container.config.integrations.media.documentExtraction,
+        workspaceDirs, defaultWorkspaceDir, memoryAdapter,
+        // the entity-associative store (built in setup-memory on the shared db).
+        // Forwarded into registerCronEventListeners -> runMemoryReview (the write path that
+        // populates memory_entities / memory_entity_links after each successful store).
+        entityStore,
+        // the causal store (built in setup-memory on the shared db).
+        // Forwarded into registerCronEventListeners -> runMemoryReview (the write path that
+        // links cause->effect edges via linkCausal after each successful store). The SAME store
+        // also rides the setupAgents read path (the 5th causal recall lane).
+        causalStore,
+        // the consolidation store (built in setup-memory on the shared db).
+        // Orphaned in v2.31 Phase 225-05 (the runMemoryConsolidation job + the
+        // __MEMORY_CONSOLIDATION__ cron were deleted); the consolidationStore port + its
+        // memories table are retired in Phase 226. Still threaded (its writer is gone, no live consumer).
+        consolidationStore,
+        // memoryLifecycleStore + memoryApi ride the SAME cron-deps chain → the __MEMORY_LIFECYCLE__
+        // sentinel (KEYLESS: the DORMANT lifecycle sweep). (The __SOCIAL_MODELING__ sentinel + its
+        // relationshipStore were DELETED in Phase 226-04 with the rest of the social-modeling subsystem.
+        // The __MEMORY_TRIPLE_EXTRACTION__ + __USEFULNESS_JUDGE__ sentinels were deleted in Phase 226
+        // SIMPLIFY-03 — neither tripleStore nor usefulnessStore rides the cron chain anymore: tripleStore
+        // feeds ONLY the graphSpread recall lane via setupAgents (below), the FORGET-02 recordUsage write
+        // is in setup-learning.ts. The __MEMORY_REASONING__ / __USER_REPRESENTATION__ sentinels + the
+        // __ONLINE_TUNING__ bandit were deleted in Phase 225 / 224.)
+        // outcomeStore + learnedSkillStore ride the SAME chain → the __REFLECT__ sentinel (v2.31 Reflection): the daemon assembles the closed-graph reflection bundle from them + the trusted-origin LCD source inside registerCronEventListeners. (The embedder is NO LONGER threaded here — the reflection job groups by topicKey, no clustering embeddings; the dead procedural-synthesis embedding wiring was deleted in Phase 223 Plan 05.)
+        memoryLifecycleStore, outcomeStore, learnedSkillStore, memoryApi,
+        tenantId: container.config.tenantId,
+        embeddingQueue, queueConfig: container.config.queue,
+        onSuspiciousContent,
+        activeRunRegistry, sessionResolver, rpcCall,
+        onMessageReceived: (msg, channelType) => {
+            const chatType = typeof msg.metadata?.telegramChatType === "string"
+                ? msg.metadata.telegramChatType
+                : undefined;
+            continuationTracker.track({
+                agentId: defaultAgentId, channelType, channelId: msg.channelId,
+                userId: msg.senderId, chatType, tenantId: container.config.tenantId, timestamp: Date.now(),
+            });
+            getInboundMessageIdResolver()?.record(msg, channelType);
+        },
+        onMessageProcessed: (msg, channelType) => {
+            getSessionTracker()?.recordActivity(defaultAgentId, channelType, msg.channelId);
+        },
+        approvalGate: container.config.approvals?.enabled ? approvalGate : undefined,
+        piSessionAdapters, costTrackers, deliveryQueue,
+        // REACT-04 (206-04): the outbound → trajectory binding (same callback the
+        // delivery-queue drain receives) so the DIRECT ack path in createDeliveryService
+        // binds the primary inbound-reply id → trajectory (the 206-03 live-finding fix).
+        recordOutboundMessage,
+        destroyConversation: channelConversationReset.destroyConversationCompletely,
+        lcdStore: agents.lcdStore, contextBrowse: agents.contextBrowse, // review session source (DAG transcripts)
+        cronExecutionTrackers: executionTrackers,
+        exportSessionBundle,
+    };
+}
+/**
+ * Build the deps object passed to `createGraphCoordinator`. The optional
+ * pre-warm cache config (Anthropic graph executions) is inlined inside the
+ * preWarm field — it returns undefined if no Anthropic API key is resolvable.
+ */
+function buildGraphCoordinatorDeps(deps) {
+    const { agents, channels } = deps;
+    const { container, defaultAgentId, dataDir, agentLogger, activeRunRegistry, agentsConfig } = agents;
+    const a2aSec = container.config.security.agentToAgent;
+    // Pre-warm cache config: undefined if no Anthropic API key resolvable
+    // (lifted from buildGraphPreWarm helper).
+    const preWarm = (() => {
+        const agentCfg = agentsConfig[defaultAgentId];
+        const provider = agentCfg?.provider ?? "anthropic";
+        const resolvedModel = agentCfg?.model === "default" || !agentCfg?.model
+            ? "claude-sonnet-4-5-20250929"
+            : agentCfg.model;
+        const apiKey = container.secretManager.get("anthropic-api-key") ?? container.secretManager.get("ANTHROPIC_API_KEY") ?? "";
+        if (!apiKey)
+            return undefined;
+        return {
+            provider, modelId: resolvedModel, apiKey,
+            systemPrompt: agentCfg?.name
+                ? `You are ${agentCfg.name}. You are a helpful AI assistant.`
+                : "You are a helpful AI assistant.",
+            tools: [],
+        };
+    })();
+    // F3: capability-gated graph concurrency — small/nano → 2, frontier/mid → 4.
+    // Reads the default agent's model+provider — the same values the preWarm block uses,
+    // but declared here in the outer function scope (not inside the IIFE above).
+    // Explicit `graphMaxConcurrency` config always wins via the ?? chain below.
+    const agentCfg = agentsConfig[defaultAgentId];
+    const defaultModel = agentCfg?.model === "default" || !agentCfg?.model
+        ? "claude-sonnet-4-5-20250929"
+        : agentCfg.model;
+    const defaultProvider = agentCfg?.provider ?? "anthropic";
+    const capabilityOverride = (container.config.providers?.entries?.[defaultProvider]?.capabilities?.capabilityClass);
+    const graphDefaults = resolveGraphConcurrencyDefaults({ provider: defaultProvider, modelId: defaultModel }, capabilityOverride);
+    return {
+        subAgentRunner: channels.subAgentRunner, eventBus: container.eventBus,
+        sendToChannel: channels.sendToChannel, announceToParent: channels.announceToParent,
+        batcher: channels.announcementBatcher, tenantId: container.config.tenantId, defaultAgentId,
+        maxConcurrency: a2aSec.graphMaxConcurrency ?? graphDefaults.maxConcurrency,
+        maxResultLength: a2aSec.graphMaxResultLength, maxGlobalSubAgents: a2aSec.graphMaxGlobalSubAgents,
+        // BUDGET-02/03 (D3): operator default per-node token-budget inherit-share source.
+        subAgentTokenBudget: a2aSec.tokenBudget ?? null,
+        logger: agentLogger?.child?.({ submodule: "graph-coordinator" }),
+        dataDir: container.config.dataDir || dataDir,
+        nodeTypeRegistry: channels.nodeTypeRegistry, activeRunRegistry,
+        assembleToolsForAgent: async (agentId) => {
+            const tools = await channels.assembleToolsForAgent(agentId);
+            return tools.map((t) => ({
+                name: t.name, description: t.description, inputSchema: t.inputSchema,
+            }));
+        },
+        touchParentSession: channels.commandQueue
+            ? (sessionKey) => channels.commandQueue.touchLane(sessionKey)
+            : undefined,
+        ...(agents.resolveRootRunId ? { resolveRootRunId: agents.resolveRootRunId } : {}), // Phase 213 CR-01: graph nodes share one tree root (killByRootRun reach).
+        ...(deps.durableRunStore ? { durableRuns: deps.durableRunStore } : {}), // Phase 216 HIGH-3/DUR-01: node-boundary DAG checkpointing → the live durable store (off ⇒ no-op).
+        preWarm,
+    };
+}
+/**
+ * Wire post-setupChannels lifecycle hooks: populate the delivery-queue
+ * channelAdapters map, drain + start prune timer, mirror prune lifecycle,
+ * delivery-queue logging, and output retention housekeeper.
+ */
+async function wirePostChannelsLifecycle(deps) {
+    const { adaptersByType, channelAdaptersRef, drainAndStartDeliveryPrune, startAndResumeVideoPoller, startAndResumeDurable, startMirrorPrune, daemonLogger, container, defaultWorkspaceDir, outputRetentionConfig } = deps;
+    for (const [type, adapter] of adaptersByType)
+        channelAdaptersRef.set(type, adapter);
+    await drainAndStartDeliveryPrune();
+    // JOB-03 (189): the channel registry is now populated (channelAdaptersRef was
+    // just filled by reference) — start + resume the video poller so a pending
+    // render's finished clip announces to the recorded channel outside any turn,
+    // exactly like the delivery queue's drainAndStart above.
+    await startAndResumeVideoPoller?.();
+    // Phase 216: run the durable resume engine AFTER the video poller — i.e. after the
+    // channel registry is populated — so its reconcile (reconcileSend) + replay resolve
+    // a LIVE adapter (a crashed-mid-send row is otherwise mis-resolved). Boot-order.
+    await startAndResumeDurable?.();
+    // eventBus.on("system:shutdown", ...) subscribers deleted —
+    // shutdownDeliveryQueue, shutdownMirror, and outputRetentionHandle.shutdown
+    // are surfaced through BootContext / wirePostChannelsLifecycle return
+    // shape so the composition root invokes them directly via ShutdownDeps.
+    startMirrorPrune();
+    setupDeliveryQueueLogging({ eventBus: container.eventBus, logger: daemonLogger });
+    if (defaultWorkspaceDir) {
+        const outputRetentionHandle = setupOutputRetention({
+            config: outputRetentionConfig, workspaceDir: defaultWorkspaceDir, logger: daemonLogger,
+        });
+        return { outputRetentionHandle };
     }
-    return corrections;
+    daemonLogger.debug({ hint: "No defaultWorkspaceDir; output retention housekeeper skipped" }, "Output retention: skipped (no default workspace)");
+    return {};
 }
 /**
- * Probe better-sqlite3 before any subsystem init. A missing transitive
- * `bindings` folder (known failure mode from partial npm upgrades) makes
- * better-sqlite3 throw at first require, which otherwise surfaces as an
- * opaque mid-boot crash and a systemd restart loop. Here we catch it up
- * front and exit 78 (EX_CONFIG) with an actionable hint, so operators can
- * repair instead of chasing a cascading failure.
+ * Factory: hot-add agent closure. Returns the closure that captures
+ * destructured Maps + setupSingleAgent + shutdownRef + eventBus by reference
+ * (all consumers hold the same Map references).
  */
-export async function runPreflightDoctor(exitFn, opts = {}) {
-    const write = opts.stderrWrite ?? ((s) => { process.stderr.write(s); });
-    const load = opts.loadBetterSqlite3
-        ?? (async () => (await import("better-sqlite3")).default);
-    try {
-        const Database = await load();
-        const db = new Database(":memory:");
-        try {
-            const row = db.prepare("select 1 as ok").get();
-            if (!row)
-                throw new Error("better-sqlite3 returned no row from sentinel query");
+function createHotAdd(deps) {
+    const { channels, shutdownRef } = deps;
+    const { singleAgentDeps, executors, workspaceDirs, costTrackers, budgetGuards, stepCounters, piSessionAdapters, skillWatcherHandles, skillRegistries, toolCapabilityPorts, container, daemonLogger, } = channels;
+    return async (agentId, config, rawRerankEnabled) => {
+        const startMs = systemNowMs();
+        if (shutdownRef.value?.isShuttingDown) {
+            throw new Error("Cannot hot-add agent during shutdown");
         }
-        finally {
-            db.close();
+        // forward the RAW rerank signal from the agents.create RPC input
+        // so the hot-added agent's effective-rerank precedence matches the boot path.
+        const result = await setupSingleAgent(agentId, config, singleAgentDeps, rawRerankEnabled);
+        executors.set(agentId, result.executor);
+        workspaceDirs.set(agentId, result.workspaceDir);
+        costTrackers.set(agentId, result.costTracker);
+        budgetGuards.set(agentId, result.budgetGuard);
+        stepCounters.set(agentId, result.stepCounter);
+        piSessionAdapters.set(agentId, result.piSessionAdapter);
+        if (result.skillWatcherHandle) {
+            skillWatcherHandles.set(agentId, result.skillWatcherHandle);
         }
+        skillRegistries.set(agentId, result.skillRegistry);
+        toolCapabilityPorts.set(agentId, result.toolCapabilityPort);
+        container.eventBus.emit("agent:hot_added", { agentId, timestamp: systemNowMs() });
+        daemonLogger.info({ agentId, durationMs: systemNowMs() - startMs }, "Agent hot-added to running daemon");
+    };
+}
+/**
+ * Factory: hot-remove agent closure. Mirror of createHotAdd.
+ */
+function createHotRemove(deps) {
+    const { activeRunRegistry, daemonLogger, skillWatcherHandles, executors, workspaceDirs, costTrackers, budgetGuards, stepCounters, piSessionAdapters, skillRegistries, toolCapabilityPorts, container, } = deps.channels;
+    return async (agentId) => {
+        const startMs = systemNowMs();
+        // Warn if agent may have active executions.
+        // ActiveRunRegistry is keyed by sessionKey, not agentId. Since hot-remove is
+        // rare and the registry is small, a coarse size > 0 check is sufficient for v1.
+        if (activeRunRegistry.size > 0) {
+            daemonLogger.warn({ agentId, activeRuns: activeRunRegistry.size,
+                hint: "Agent removed while daemon has active executions; if this agent has an in-flight run it will complete but response delivery may fail",
+                errorKind: "internal" }, "Hot-removing agent with possible active executions");
+        }
+        // Stop skill watcher if present
+        const watcher = skillWatcherHandles.get(agentId);
+        if (watcher) {
+            await watcher.close();
+            skillWatcherHandles.delete(agentId);
+        }
+        // Remove from all Maps (workspace dir preserved on disk for data safety)
+        executors.delete(agentId);
+        workspaceDirs.delete(agentId);
+        costTrackers.delete(agentId);
+        budgetGuards.delete(agentId);
+        stepCounters.delete(agentId);
+        piSessionAdapters.delete(agentId);
+        skillRegistries.delete(agentId);
+        toolCapabilityPorts.delete(agentId);
+        container.eventBus.emit("agent:hot_removed", { agentId, timestamp: systemNowMs() });
+        daemonLogger.info({ agentId, durationMs: systemNowMs() - startMs }, "Agent hot-removed from running daemon");
+    };
+}
+/**
+ * Build the rpcDispatchDeps literal. Inlines the image-handler-deps,
+ * token-store-mutators, and context-engine-config helpers — each was a
+ * trivial one-call-site builder.
+ */
+function buildRpcDispatchDeps(deps) {
+    const { channels: c, gateway: g, startupStartMs, defaultConfigPaths } = deps;
+    // RES-01 keystone (I4 lockstep): the agent's main provider via the EXACT completion-path resolver, falling back to the configurable defaultAgentId (NOT literal "default"; WR-01 183-REVIEW). See resolveAgentMainProvider (setup-agents-tooling.ts) for the fallback + honest-sentinel semantics.
+    const resolveAgentMainProviderFor = (agentId) => resolveAgentMainProvider(c.container.config.agents, c.container.config.models, agentId, c.defaultAgentId);
+    // WR-04 (186-REVIEW): extracted to buildImageHandlerDeps (wiring/main-helpers.ts) to keep this composition root under its 3000-line cap. Undefined when image generation is disabled (no provider / rate limiter).
+    const imageHandlerDeps = buildImageHandlerDeps(c, resolveAgentMainProviderFor);
+    // Phase 188: video.generate handler deps (undefined when disabled). The spread
+    // into ApiDispatchDeps below wires the live handler (source guard pins it).
+    const videoHandlerDeps = buildVideoHandlerDeps(c, resolveAgentMainProviderFor);
+    // Phase 189 (JOB-04): video.status read-handler deps (undefined when disabled) —
+    // reads the SAME agent-scoped store the poller writes. Spread below (guard pins it).
+    const videoStatusHandlerDeps = buildVideoStatusHandlerDeps(c);
+    // Inlined buildTokenStoreMutators.
+    const addToTokenStore = (entry) => { g.runtimeTokens.push({ id: entry.id, secretBuf: Buffer.from(entry.secret, "utf-8"), scopes: entry.scopes }); };
+    const removeFromTokenStore = (id) => {
+        g.removedTokenIds.add(id);
+        const idx = g.runtimeTokens.findIndex((t) => t.id === id);
+        if (idx >= 0)
+            g.runtimeTokens.splice(idx, 1);
+    };
+    // Pass-through to the ONE mode-selected MCP OAuth token store the composition
+    // root built via selectMcpTokenStore (threaded onto the boot context). Both
+    // mcp-handlers (Fix 4 — pre-check no-token before manager.connect) and
+    // mcp-oauth-handlers (read/write tokens during login) consume this factory and
+    // receive the SAME instance setupMcp's manager wiring uses — no split-brain,
+    // no plaintext-disk fallback. Returns undefined in env mode (no writable MCP
+    // OAuth store); consumers guard on undefined.
+    const createTokenStore = () => c.mcpTokenStore;
+    // the single in-process recall-counter registry is stood up once in
+    // setup-memory (the composition site that holds the event bus) and threaded
+    // here on the boot context. The snapshot accessor feeds the
+    // memory.recall_stats handler (comis memory stats reads live counters). The
+    // gauge is daemon-lifetime — it resets on restart.
+    const recallCounters = c.recallCounters;
+    const dialecticWiring = buildDialecticWiring(dialecticWiringDepsFromBoot(c)); // the memory.ask seam + per-agent recall factory (setup-dialectic.ts owns the wiring; the cost gate returns {} when off). Spread into the dispatch deps below; the forward-presence belt locks the spread.
+    // L3 destroy for session.reset_conversation (live 2026-06-11: skipping it resurrected the forget).
+    const conversationReset = createConversationReset({ lcdStore: c.lcdStore, sessionStore: g.sessionStoreBridge, piSessionAdapters: c.piSessionAdapters, tenantId: c.container.config.tenantId, logger: c.logger });
+    return {
+        defaultAgentId: c.defaultAgentId, getAgentCronScheduler: c.getAgentCronScheduler,
+        cronSchedulers: c.cronSchedulers, executionTrackers: c.executionTrackers, wakeCoalescer: c.wakeCoalescer,
+        defaultWorkspaceDir: c.defaultWorkspaceDir, workspaceDirs: c.workspaceDirs,
+        memoryApi: c.memoryApi, memoryAdapter: c.memoryAdapter, embeddingQueue: c.embeddingQueue,
+        // DIST-05: thread the memory adapter as the MemoryPort for the
+        // session.reset_conversation --memory honest reset. SqliteMemoryAdapter
+        // implements MemoryPort (incl. deleteBySessionKey, Phase 172-03), so the
+        // SAME object satisfies SessionsApiDeps.memoryPort. consolidationStore (the
+        // unlink/purge surface) is already on the spread below.
+        memoryPort: c.memoryAdapter,
+        destroyRuntimeSession: (formattedSessionKey) => conversationReset.destroyRuntimeSession(c.defaultAgentId, formattedSessionKey),
+        // CR-02 (175-REVIEW): session.reset_conversation / session.delete drop
+        // the executor's session-scoped state (tool-schema snapshots, GBNF-02
+        // strip-retry once-gate, JIT-guide delivery, cache latches) through the
+        // agent's single authoritative cleanup path — the same function the
+        // session:expired listener uses (wireSessionStateCleanup above).
+        clearAgentSessionState: clearSessionState,
+        // context.* operator-browse RPC deps (Context DAG browser): the LCD
+        // ContextStorePort (context.tree reads getSummaries/getContextItems) + the
+        // ContextBrowsePort (context.conversations). Both R4 agent+tenant scoped.
+        lcdStore: c.lcdStore, contextBrowse: c.contextBrowse,
+        // memory-diagnostic deps: the scoped consolidation + entity stores
+        // (provenance + entity-graph reads) and the live recall counters
+        // for the 4 admin-gated memory.* diagnostic handlers. (usefulnessStore is NOT
+        // here — no diagnostic handler consumes it; its read path is the setupAgents
+        // injection at the setupAgents({…}) call below, mirroring entityStore.)
+        consolidationStore: c.consolidationStore, entityStore: c.entityStore, recallCounters, ...dialecticWiring, onSuspiciousContent: c.onSuspiciousContent,
+        recallTraceEnabled: c.container.config.diagnostics?.recallTrace?.enabled ?? false, // memory.recall_trace honest-empty gate
+        tenantId: c.container.config.tenantId, agents: c.agentsConfig, costTrackers: c.costTrackers, stepCounters: c.stepCounters,
+        agentDataDir: safePath(c.container.config.dataDir ?? safePath(os.homedir(), ".comis"), "agents"),
+        sessionStore: g.sessionStoreBridge, crossSessionSender: c.crossSessionSender, subAgentRunner: c.subAgentRunner,
+        ...(c.resolveRootRunId ? { resolveRootRunId: c.resolveRootRunId } : {}), // Phase 213 CR-01: session→rootRunId resolver so session.spawn propagates one tree root (ceiling/kill/budget key on it).
+        // Phase 213-06: the daemon-wide LeaseManager (autonomy-handlers gate lease.revoke/run.kill on it).
+        // Phase 216: DUR-03 durableRuns (revoke ALSO invalidates the persisted record) + ONCE-01/02 outwardLedger (the message.send/reply/react wrap). Absent ⇒ degrade (no revoke RPC / pass-through wrap).
+        ...(c.capEndpointHandle?.leaseManager ?? c.sharedLeaseManager ? { leaseManager: c.capEndpointHandle?.leaseManager ?? c.sharedLeaseManager } : {}),
+        ...(c.durableRunStore ? { durableRuns: c.durableRunStore } : {}),
+        ...(c.outwardLedger ? { outwardLedger: c.outwardLedger } : {}),
+        // Phase 217-05 (UNATT/BREAK/EVICT): the never-hang control plane the dispatch chokepoint reads — the denial breaker (recordDenial/recordAllow → trip→abort), the evicted-rootRunId set (isEvicted → demote mid-run), and the content-free escalate. Constructed at the cap layer; absent when no autonomy agent ⇒ pre-217 deny-without-escalate (byte-identical). Threading evictRegistry here ALSO flows it into createAutonomyHandlers via the `...deps` spread, activating the autonomy.evict handler (Plan 04 cross-wave point).
+        ...(c.capEndpointHandle ? { denialBreaker: c.capEndpointHandle.denialBreaker, evictRegistry: c.capEndpointHandle.evictRegistry, escalate: c.capEndpointHandle.escalate } : {}),
+        graphCoordinator: c.graphCoordinator, namedGraphStore: c.namedGraphStore, nodeTypeRegistry: c.nodeTypeRegistry,
+        securityConfig: c.container.config.security, adaptersByType: c.adaptersByType,
+        inboundMessageIdResolver: c.inboundMessageIdResolver, visionRegistry: c.visionRegistry, resolveAgentMainProvider: resolveAgentMainProviderFor, mainModelIdFor: c.mediaVisionBundle?.resolveMainModelId, mainProviderVision: c.mediaVisionBundle?.capability, trajectoryRegistry: c.trajectoryRegistry,
+        mediaConfig: c.container.config.integrations.media, ttsAdapter: c.ttsAdapter, linkRunner: c.linkRunner,
+        logger: c.logger, container: c.container, configPaths: c.configPaths, defaultConfigPaths,
+        // VERSION-SKEW: surface the daemon build version on gateway.status so
+        // `comis doctor` can flag a stale CLI talking to a newer daemon.
+        daemonVersion: c.daemonVersion,
+        configGitManager: c.configGitManager,
+        configWebhook: c.container.config.daemon.configWebhook,
+        secretStore: c.secretStore, mutableSecretManager: c.mutableHandle, envFilePath: c.envPath, logLevelManager: c.logLevelManager,
+        getAgentBrowserService: c.getAgentBrowserService,
+        resolveAttachment: c.resolveAttachment, transcriber: c.transcriber, fileExtractor: c.fileExtractor, voiceSelection: c.voiceSelection,
+        approvalGate: c.approvalGate, suspendedAgents: c.suspendedAgents,
+        hotAdd: g.hotAdd, hotRemove: g.hotRemove,
+        diagnosticCollector: c.diagnosticCollector, billingEstimator: c.billingEstimator,
+        channelActivityTracker: c.channelActivityTracker, deliveryTracer: c.deliveryTracer, budgetGuards: c.budgetGuards,
+        // WEBUI-02 (179-04): thread the LIVE spend snapshot the kill-switch enforces
+        // (locked A1 — getSnapshot(), NOT the lagging SQL) + the configured ceilings, so
+        // obs.spend.snapshot computes headroom = ceiling − spend. Absent ⇒ spend off
+        // (the handler degrades to an honest enabled:false, never a misleading $0).
+        spendSnapshot: c.spendAccumulator
+            ? () => ({
+                ...c.spendAccumulator.getSnapshot(),
+                ceilings: {
+                    perAgentUsd: c.container.config.observability.spend.perAgentUsd,
+                    perTenantUsd: c.container.config.observability.spend.perTenantUsd,
+                    daemonGlobalUsd: c.container.config.observability.spend.daemonGlobalUsd,
+                },
+            })
+            : undefined,
+        modelCatalog: c.modelCatalog, channelConfig: c.channelConfig,
+        tokenRegistry: g.tokenRegistry,
+        addToTokenStore, removeFromTokenStore,
+        createTokenStore,
+        memoryWriteValidator: validateMemoryWrite,
+        // MemoryApiDeps.eventBus accepts the full AppContainer["eventBus"] type;
+        // no down-cast to `{ emit }` is needed.
+        eventBus: c.container.eventBus,
+        mcpClientManager: c.mcpClientManager,
+        // 161-02: ObservabilityApiDeps.clock = the SAME boot ClockPort (one createSystemClock()
+        // at the composition root) so the obs.fleet.health assembler has a clock (asserts deps.clock!).
+        obsStore: c.obsStore, clock: c.clock, startupTimestamp: startupStartMs, sharedCostTracker: c.sharedCostTracker,
+        // obs.getCacheStats reads deps.tokenTracker for the in-memory hit-rate/effectiveness;
+        // without this it fell to the `!deps.tokenTracker` branch and returned a silent 0/0
+        // forever, even at an 85% live hit rate (live cache-management finding, 2026-06-12).
+        tokenTracker: c.tokenTracker,
+        contextPipelineCollector: c.contextPipelineCollector, execGit: c.execGit,
+        deliveryQueue: c.deliveryQueue, deliveryService: c.deliveryService,
+        boundedAutonomy: c.capEndpointHandle?.boundedAutonomy, leaseManager: c.capEndpointHandle?.leaseManager, // Phase 213 QUOTA-01/02 + 213-06 REVOKE-01/03: the outward-quota service the message handlers gate on, plus the SAME cap-endpoint handle's LeaseManager gating lease.revoke + run.kill registration — omitting leaseManager (while boundedAutonomy WAS threaded) left REVOKE unreachable live ("Unknown RPC method" with the lease layer ACTIVE — VPS finding)
+        channelPlugins: c.channelPlugins, healthMonitor: c.channelHealthMonitor,
+        embeddingCacheStats: c.embeddingCacheStats, embeddingCircuitBreakerState: c.embeddingCircuitBreakerState,
+        skillRegistries: c.skillRegistries, notificationService: c.notificationContext.notificationService,
+        imageHandlerDeps,
+        videoHandlerDeps,
+        videoStatusHandlerDeps,
+        oauthCredentialStore: c.oauthCredentialStore,
+        // Wire observability DI seams.
+        // ObservabilityApiDeps.dataDir: used by obs.trace.* handlers for session-index + bundle export.
+        // ObservabilityApiDeps.exportTrajectoryBundle: DI seam for obs.trace.export RPC (comis trace export <sessionId>).
+        dataDir: c.dataDir,
+        exportTrajectoryBundle,
+    };
+}
+/**
+ * Replay restart continuations from disk if any. Owns the block that
+ * loads persisted continuation records and re-injects synthetic restart
+ * messages through channelManager. Per-record synthetic message construction
+ * is inlined inside the per-record loop.
+ */
+async function replayContinuationsIfAny(deps) {
+    const { container, dataDir, daemonLogger, mcpClientManager, continuationTracker, channelManager } = deps.channels;
+    const continuationFilePath = safePath(container.config.dataDir || dataDir, "restart-continuations.json");
+    const continuations = loadContinuations(continuationFilePath, 5 * 60_000, daemonLogger);
+    if (continuations.length === 0 || !channelManager)
+        return;
+    daemonLogger.info({ count: continuations.length }, "Replaying restart continuations");
+    const mcpStatusLine = buildMcpStatusLine(mcpClientManager.getAllConnections());
+    if (mcpStatusLine) {
+        daemonLogger.warn({ mcpStatusLine, continuationCount: continuations.length,
+            hint: "One or more MCP servers failed to handshake after restart; surfacing status to agents via synthetic system message",
+            errorKind: "dependency" }, "MCP connection failures detected during restart continuation replay");
     }
-    catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        write(JSON.stringify({
-            level: 60,
-            time: new Date().toISOString(),
-            name: "comis-daemon",
-            submodule: "preflight",
-            errorKind: "dependency",
-            err: message,
-            hint: "Native module 'better-sqlite3' failed to load. Try: npm rebuild better-sqlite3 (or re-run install.sh). If this persists, reinstall comisai from a fresh tarball.",
-            msg: "Preflight check failed: better-sqlite3 unavailable",
-        }) + "\n");
-        exitFn(78);
+    const baseText = "[system: daemon restarted to apply a config change. The result of your previous tool call is in the conversation above — react to it naturally, confirm or surface any issue, then yield to the user.]";
+    for (const record of continuations) {
+        // Skip sessions that already received a message during this startup cycle
+        // (e.g., Telegram webhook delivered before continuation replay ran).
+        if (continuationTracker.isTracked(record)) {
+            daemonLogger.debug({ channelType: record.channelType, channelId: record.channelId }, "Skipping continuation replay: session already active this cycle");
+            continue;
+        }
+        // Inlined buildSyntheticRestartMessage: synthetic-restart message payload
+        // for a single continuation record. Rehydrates chat-type metadata so
+        // downstream resolveChatType / isGroupMessage classify correctly.
+        const metadata = {
+            isRestartContinuation: true,
+            mcpStatusLine: mcpStatusLine ?? null,
+        };
+        if (record.channelType === "telegram" && record.chatType) {
+            metadata.telegramChatType = record.chatType;
+        }
+        if (record.chatType === "group" || record.chatType === "supergroup") {
+            // Channel-agnostic flag mirrored by other adapters (e.g. WhatsApp).
+            metadata.isGroup = true;
+        }
+        const syntheticMsg = {
+            id: randomUUID(),
+            channelId: record.channelId,
+            channelType: record.channelType,
+            senderId: record.userId,
+            text: mcpStatusLine ? `${baseText}\n${mcpStatusLine}` : baseText,
+            timestamp: Date.now(),
+            attachments: [],
+            metadata,
+        };
+        channelManager.injectMessage(record.channelType, syntheticMsg).catch((injectErr) => {
+            daemonLogger.warn({ err: injectErr, channelType: record.channelType, channelId: record.channelId, hint: "Continuation replay failed; user can re-send to resume", errorKind: "internal" }, "Failed to replay continuation");
+        });
     }
 }
 // ---------------------------------------------------------------------------
+// Shutdown helpers
+// ---------------------------------------------------------------------------
+/**
+ * Wire eventBus health subscriptions to structured logger metrics.
+ * Reads metrics from the observability event bus, prunes prompt timeouts,
+ * computes stuck-sub-agent counters, force-kills sub-agents past threshold,
+ * and emits the canonical "Daemon health" DEBUG line. The DB-size metrics
+ * and stuck-sub-agent computation are inlined directly into the subscriber
+ * body (each was a single-call-site helper).
+ */
+function wireHealthLogging(deps) {
+    const { container, daemonLogger, db, maintenanceTick, subAgentRunner, promptTimeoutTimestamps, activeExecutions, getActiveConnectionCount, deadLetterQueue, providerHealth, deliveryQueue, } = deps;
+    container.eventBus.on("observability:metrics", async (metrics) => {
+        // Prune prompt timeout timestamps to 5-minute window
+        const fiveMinAgo = Date.now() - 5 * 60_000;
+        while (promptTimeoutTimestamps.length > 0 && promptTimeoutTimestamps[0] < fiveMinAgo) {
+            promptTimeoutTimestamps.shift();
+        }
+        // Inlined readDbSizeMetrics: best-effort DB file + WAL file sizes.
+        let memoryDbSizeBytes;
+        let memoryDbWalSizeBytes;
+        try {
+            const dbFilePath = db.name;
+            if (dbFilePath) {
+                memoryDbSizeBytes = statSync(dbFilePath).size;
+                try {
+                    memoryDbWalSizeBytes = statSync(dbFilePath + "-wal").size;
+                }
+                catch { /* WAL file may not exist */ }
+            }
+        }
+        catch { /* stat failure must not crash health check */ }
+        maintenanceTick();
+        // Inlined computeAndKillStuckSubAgents: count active sub-agent runs and
+        // force-kill any past the threshold-aware cutoff. Graph sub-agents get a
+        // longer threshold since they do multi-step analytical work.
+        const stuckKillThresholdMs = container.config.security.agentToAgent.subagentContext?.stuckKillThresholdMs ?? 180_000;
+        const graphStuckKillThresholdMs = container.config.security.agentToAgent.subagentContext?.graphStuckKillThresholdMs ?? 600_000;
+        const allRuns = subAgentRunner.listRuns();
+        const now = Date.now();
+        let activeSubAgentRuns = 0;
+        let stuckSubAgentRuns = 0;
+        let stuckKilledThisTick = 0;
+        for (const run of allRuns) {
+            if (run.status !== "running")
+                continue;
+            activeSubAgentRuns++;
+            const threshold = run.graphId ? graphStuckKillThresholdMs : stuckKillThresholdMs;
+            if (threshold > 0 && (now - run.startedAt) > threshold)
+                stuckSubAgentRuns++;
+            if (threshold <= 0)
+                continue;
+            if ((now - run.startedAt) <= threshold)
+                continue;
+            subAgentRunner.killRun(run.runId);
+            stuckKilledThisTick++;
+            daemonLogger.warn({
+                runId: run.runId, agentId: run.agentId, runtimeMs: now - run.startedAt,
+                thresholdMs: threshold, isGraphRun: !!run.graphId,
+                hint: run.graphId
+                    ? "Graph sub-agent exceeded graphStuckKillThresholdMs; force-killed by health handler. Adjust security.agentToAgent.subagentContext.graphStuckKillThresholdMs if needed."
+                    : "Sub-agent exceeded stuckKillThresholdMs; force-killed by health handler. Adjust security.agentToAgent.subagentContext.stuckKillThresholdMs if needed.",
+                errorKind: "timeout",
+            }, "Stuck sub-agent killed by health handler");
+        }
+        daemonLogger.debug({
+            rssBytes: metrics.rssBytes, heapUsedBytes: metrics.heapUsedBytes,
+            heapTotalBytes: metrics.heapTotalBytes, externalBytes: metrics.externalBytes,
+            eventLoopP99Ms: Math.round(metrics.eventLoopDelayMs.p99 * 100) / 100,
+            activeHandles: metrics.activeHandles, activeConnections: getActiveConnectionCount(),
+            activeExecutions: activeExecutions.size, uptimeSeconds: Math.round(metrics.uptimeSeconds),
+            activeSubAgentRuns, stuckSubAgentRuns, stuckKilledThisTick,
+            deadLetterQueueSize: deadLetterQueue?.size() ?? 0,
+            degradedProviders: [...providerHealth.getHealthSummary().entries()]
+                .filter(([, v]) => v.degraded).map(([k]) => k),
+            promptTimeoutsLast5m: promptTimeoutTimestamps.length,
+            ...(memoryDbSizeBytes !== undefined && { memoryDbSizeBytes }),
+            ...(memoryDbWalSizeBytes !== undefined && { memoryDbWalSizeBytes }),
+            pendingDeliveryCount: await deliveryQueue.pendingEntries().then(r => r.ok ? r.value.length : 0),
+        }, "Daemon health");
+    });
+}
+/**
+ * Emit startup banner + docker restart-policy warn + OAuth TLS preflight.
+ * Emits the canonical "Comis daemon started" INFO line (log line 5 in
+ * daemon-lifecycle.test.ts). The startup-banner-manifest sub-object is
+ * inlined directly into the log call.
+ */
+// emitStartupBanner → wiring/emit-startup-banner.ts (daemon.ts ≤3000 line cap).
+// ---------------------------------------------------------------------------
 // Stage 1: foundation
 // ---------------------------------------------------------------------------
 /**
- * stageFoundation — daemon-process foundation startup. Owns:
+ * bootFoundation — daemon-process foundation startup. Owns:
  *   - data directory + .env load + permission hardening
  *   - secret decryption + env merge + process.env scrub
  *   - bootstrap (core container) + config-secret-ref resolution
  *   - config git versioning
  *   - logging + observability + context-pipeline collector
- *   - health (process monitor + watchdog + device identity)
+ *   - health (process monitor)
  *   - memory + embedding + observability-persistence
  *   - context store + active-run registry + session resolver
  *   - canary fallback + injection rate limiter
@@ -182,196 +849,441 @@ export async function runPreflightDoctor(exitFn, opts = {}) {
  *   - background task system + deferred channel/notification refs
  *   - bundled skill-creator seeding (idempotent)
  *
- * Hard cap: ≤200 lines AST-measured. Per-line-source order preserved so
- * daemon-lifecycle.test.ts log-sequence assertions remain green.
+ * Mutates `boot` with all Group A foundation fields. Per-line-source order
+ * preserved so daemon-lifecycle.test.ts log-sequence assertions remain green.
  */
-async function stageFoundation(input) {
+async function bootFoundation(boot, input) {
     const { overrides, startupStartMs, instanceId } = input;
     const _bootstrap = overrides.bootstrap ?? bootstrap;
-    const _setupSecrets = overrides.setupSecrets ?? _setupSecretsImpl;
+    const _preReadStorageMode = overrides.preReadStorageMode ?? preReadStorageMode;
+    const _writeMasterKeyIfAbsent = overrides.writeMasterKeyIfAbsent ?? writeMasterKeyIfAbsent;
     const _createTracingLogger = overrides.createTracingLogger ?? createTracingLogger;
     const _createLogLevelManager = overrides.createLogLevelManager ?? createLogLevelManager;
     const _createTokenTracker = overrides.createTokenTracker ?? createTokenTracker;
-    const _createLatencyRecorder = overrides.createLatencyRecorder ?? createLatencyRecorder;
     const _createProcessMonitor = overrides.createProcessMonitor ?? createProcessMonitor;
-    const _startWatchdog = overrides.startWatchdog ?? startWatchdog;
-    // 0. Resolve data directory, then load secrets from <dataDir>/.env.
+    // 0. Resolve data directory + config paths, then load secrets from <dataDir>/.env.
     // eslint-disable-next-line no-restricted-syntax -- process.env access needed before SecretManager is initialized
     const dataDir = process.env["COMIS_DATA_DIR"] ?? safePath(os.homedir(), ".comis");
     const envPath = safePath(dataDir, ".env");
-    loadEnvFile(envPath);
-    // 0.5. Decrypt secrets, merge with env, scrub process.env.
-    const permissionCorrections = hardenDataDirPermissions(dataDir);
-    const { mergedEnv, secretStore, secretsCrypto, secretsDb } = bootstrapSecretsAndEnv({
-        setupSecrets: _setupSecrets,
-        dataDir,
-    });
-    // 0.6. Runtime adapter construction (composition root). overrides.timers is opt-in for test fake-timers; never set in production.
-    const clock = createSystemClock();
-    const env = createSystemEnv(mergedEnv);
-    const timers = overrides.timers ?? createSystemTimers();
-    // 1. Bootstrap core container
-    // eslint-disable-next-line no-restricted-syntax -- process.env access needed before SecretManager for config path resolution
+    // Resolve config paths up front so we can pre-read security.storage
+    // before writeMasterKeyIfAbsent. The full bootstrap (which validates the
+    // whole config + does ${VAR} substitution) runs later — it depends on
+    // mergedEnv, which depends on whether the encrypted store opened.
+    // eslint-disable-next-line no-restricted-syntax -- process.env access needed before SecretManager for config path resolution + VITEST guard
     const rawConfigPaths = process.env["COMIS_CONFIG_PATHS"];
-    const configPaths = (rawConfigPaths ? rawConfigPaths.split(":") : DEFAULT_CONFIG_PATHS)
-        .filter((p) => existsSync(p));
-    const bootResult = _bootstrap({ configPaths, env: mergedEnv });
-    if (!bootResult.ok) {
-        throw new Error(`Bootstrap failed: ${bootResult.error.message}`);
-    }
-    // Container via const+resolve-then-spread.
-    const initialContainer = bootResult.value;
-    const refResult = resolveConfigSecretRefs(initialContainer.config, { secretManager: initialContainer.secretManager });
-    if (!refResult.ok) {
-        throw new Error(`SecretRef resolution failed: ${refResult.error.message}`);
+    if (process.env["VITEST"] === "true" && !rawConfigPaths)
+        throw new Error("VITEST=true and COMIS_CONFIG_PATHS unset — refusing to read ~/.comis/config.yaml from a test process. Set COMIS_CONFIG_PATHS to a sandbox path in your test setup, or import test/support/vitest-process-listeners.ts.");
+    const requestedConfigPaths = rawConfigPaths ? rawConfigPaths.split(":") : DEFAULT_CONFIG_PATHS;
+    // P0 boot gate: ensure file/env first boot creates no key material.
+    //
+    // Step 1: Pre-read security.storage from YAML (layered, last-wins). Returns
+    // "encrypted"|"file"|"env". NEVER writes key material before this check.
+    const storageMode = _preReadStorageMode(requestedConfigPaths);
+    // Step 2: Write master key ONLY when storageMode is "encrypted".
+    // file/env modes create NO key material on first boot.
+    if (storageMode === "encrypted") {
+        _writeMasterKeyIfAbsent(dataDir);
+        // loadEnvFile below picks up the freshly-written key from the .env file,
+        // so selectSecretStore can read SECRETS_MASTER_KEY from process.env.
     }
-    const container = { ...initialContainer, config: refResult.value };
-    // 1.5. Config git versioning
-    const execGit = createExecGit();
-    const configDir = configPaths.length > 0 ? pathDirname(configPaths[0]) : "";
-    const configGitManager = wireConfigGitManager({ configDir, execGit });
-    // 2-3. Logging
-    const { logger, logLevelManager, daemonLogger, gatewayLogger, channelsLogger, agentLogger, schedulerLogger, skillsLogger, memoryLogger, daemonVersion, } = setupLogging({ container, instanceId, _createTracingLogger, _createLogLevelManager });
-    // Log permission corrections (deferred until logger is available)
-    if (permissionCorrections.length > 0) {
-        for (const c of permissionCorrections) {
-            daemonLogger.info({ file: c.file, oldMode: `0o${c.oldMode.toString(8)}`, newMode: `0o${c.newMode.toString(8)}`, hint: "Restrictive permissions applied", errorKind: "config" }, `Fixed permissions on ${c.file}: 0o${c.oldMode.toString(8)} -> 0o${c.newMode.toString(8)}`);
+    loadEnvFile(envPath);
+    // 0.5. Select secret store by mode, merge with env, scrub process.env.
+    const permissionCorrections = hardenDataDirPermissions(dataDir);
+    // singleton lock — must run before any store bootstrap.
+    acquireDataDirLock(dataDir);
+    // On boot failure (e.g. selectSecretStore error, bootstrap failure), release
+    // the lock. Under normal boot setupShutdown.onShutdown owns the release.
+    try {
+        // selectSecretStore is called BEFORE scrubProcessEnv so encrypted mode
+        // can still read SECRETS_MASTER_KEY from process.env (Pitfall 5 in RESEARCH).
+        //
+        // sensitiveNames: built here at the composition root (a sanctioned process.env
+        // access point per AGENTS.md §2.8). In file/encrypted modes the names are
+        // passed to the env adapter via selectSecretStore but ignored there.
+        // NOTE: sensitiveNames and env snapshot must be built AFTER loadEnvFile so ~/.comis/.env vars are included.
+        const sensitiveNames = new Set([
+            ...SENSITIVE_EXACT_KEYS,
+            ...Object.keys(process.env).filter(k => SENSITIVE_PREFIXES.some(p => k.startsWith(p))),
+        ]);
+        const storeResult = selectSecretStore({
+            mode: storageMode,
+            dataDir,
+            env: process.env,
+            sensitiveNames,
+        });
+        if (!storeResult.ok) {
+            throw new Error(`Failed to open secret store (mode: ${storageMode}): ${storeResult.error.message}`);
         }
-    }
-    // 3.5. Startup config warnings
-    const approvalsWarning = checkApprovalsConfig(container.config.approvals ?? { enabled: false, defaultMode: "auto", rules: [], defaultTimeoutMs: 30_000, waitTimeoutMs: 60_000 });
-    if (approvalsWarning) {
-        daemonLogger.warn({ hint: "Set approvals.enabled: true or remove unused rules", errorKind: "config" }, approvalsWarning);
-    }
-    // 3.6. Validate PROVIDER_OVERRIDES vs live pi-ai catalog (fire-and-forget).
-    validateProviderOverrides(agentLogger);
-    // 4. Observability
-    const { tokenTracker, latencyRecorder, sharedCostTracker, diagnosticCollector, billingEstimator, channelActivityTracker, deliveryTracer, } = setupObservability({ eventBus: container.eventBus, _createTokenTracker, _createLatencyRecorder, logger: logLevelManager.getLogger("observability"), dataDir });
-    const contextPipelineCollector = createContextPipelineCollector({
-        eventBus: container.eventBus,
-        logger: logLevelManager.getLogger("context-pipeline"),
-    });
-    // 5-6. Health / process
-    const { processMonitor, watchdogHandle, deviceIdentity } = setupHealth({
-        container, logger, daemonLogger, _createProcessMonitor, _startWatchdog,
-    });
-    // 6.5. Memory + embedding
-    const { disposeEmbedding, cachedPort, memoryAdapter, db, sessionStore, memoryApi, embeddingQueue, backgroundIndexingPromise, embeddingCacheStats, embeddingCircuitBreakerState, maintenanceTick, } = await setupMemory({ container, memoryLogger, clock });
-    // Observability persistence (dual-write to SQLite). obsStore +
-    // obsPersistence via const+IIFE.
-    const obsConfig = container.config.observability;
-    const obsBundle = obsConfig.persistence.enabled
-        ? (() => {
-            const store = createObservabilityStore(db);
-            const pruneResult = store.prune(obsConfig.persistence.retentionDays);
+        const selected = storeResult.value;
+        const secretStore = selected.secretStore;
+        let secretsCrypto;
+        let secretsDb;
+        if (selected.kind === "encrypted") {
+            secretsCrypto = selected.secretsCrypto;
+            secretsDb = selected.secretsDb;
+        }
+        // Build mergedEnv (store-wins) + stage-1 scrub.
+        const { mergedEnv, shadowedNames } = buildMergedEnv(secretStore, storageMode);
+        // 0.6. Runtime adapter construction (composition root). overrides.timers is opt-in for test fake-timers; never set in production.
+        const clock = createSystemClock();
+        const env = createSystemEnv(mergedEnv);
+        const timers = overrides.timers ?? createSystemTimers();
+        // test-only renderer-injection seam (mirrors overrides.timers): captured here
+        // and threaded onto BootContext so buildChannelManagerDeps can forward it into
+        // buildActivityRenderers. Never set in production; inert on the inbound path.
+        const activityRendererFactory = overrides.activityRendererFactory;
+        // ONE process-singleton ActivityCircuitBreaker, constructed at the
+        // composition root and shared across EVERY per-turn coordinator the inbound
+        // coordinatorFactory builds. Constructed once here (NOT inside a per-turn or
+        // per-agent loop) so a permission/error storm on one (agentId, channelKey) pair
+        // auto-quiesces that pair across turns. Threaded down via BootContext →
+        // buildChannelManagerDeps → ChannelsDeps → buildAndStartChannelManager.
+        const activityBreaker = createActivityCircuitBreaker(clock);
+        // Shared-map SecretManager: construct BEFORE bootstrap; same Map → AppContainer + mutableHandle.
+        const { secretManager: sharedSecretManager, mutableHandle } = setupSecretManager(mergedEnv);
+        const wrappedBootstrap = (opts) => _bootstrap({ ...opts, secretManager: sharedSecretManager });
+        // 1. Bootstrap core container. (security.storage pre-read in step 0 before encrypted-store bootstrap.)
+        const { configPaths, bootResult } = await runConfigBootstrapAndEmitObserve({ requestedConfigPaths, mergedEnv, bootstrap: wrappedBootstrap });
+        if (!bootResult.ok) {
+            throw new Error(`Bootstrap failed: ${bootResult.error.message}`);
+        }
+        // Container via const+resolve-then-spread.
+        const initialContainer = bootResult.value;
+        const refResult = resolveConfigSecretRefs(initialContainer.config, { secretManager: initialContainer.secretManager });
+        if (!refResult.ok) {
+            throw new Error(`SecretRef resolution failed: ${refResult.error.message}`);
+        }
+        const container = { ...initialContainer, config: refResult.value };
+        // Stage-2 scrub: remove config-referenced SecretRef names from process.env; runs after config parse.
+        for (const name of container.platformSecretNames) {
+            // eslint-disable-next-line no-restricted-syntax -- stage-2 scrub
+            delete process.env[name];
+        }
+        // 1.5. Config git versioning (inlined wireConfigGitManager).
+        const execGit = createExecGit();
+        const configDir = configPaths.length > 0 ? pathDirname(configPaths[0]) : "";
+        const configGitManager = configDir
+            ? createConfigGitManager({
+                configDir,
+                execGit,
+                writeFile: async (relativePath, content) => {
+                    try {
+                        const targetPath = safePath(configDir, relativePath);
+                        await fsWriteFile(targetPath, content, "utf-8");
+                        return ok(undefined);
+                    }
+                    catch (e) {
+                        return err(e instanceof Error ? e.message : String(e));
+                    }
+                },
+                removeDir: async (relativePath) => {
+                    try {
+                        const targetPath = safePath(configDir, relativePath);
+                        await rm(targetPath, { recursive: true, force: true });
+                        return ok(undefined);
+                    }
+                    catch (e) {
+                        return err(e instanceof Error ? e.message : String(e));
+                    }
+                },
+            })
+            : undefined;
+        // 2-3. Logging
+        const { logger, logLevelManager, daemonLogger, gatewayLogger, channelsLogger, agentLogger, schedulerLogger, skillsLogger, memoryLogger, daemonVersion, } = setupLogging({ container, instanceId, _createTracingLogger, _createLogLevelManager });
+        // Log permission corrections (deferred until logger is available)
+        if (permissionCorrections.length > 0) {
+            for (const c of permissionCorrections) {
+                daemonLogger.info({ file: c.file, oldMode: `0o${c.oldMode.toString(8)}`, newMode: `0o${c.newMode.toString(8)}`, hint: "Restrictive permissions applied", errorKind: "config" }, `Fixed permissions on ${c.file}: 0o${c.oldMode.toString(8)} -> 0o${c.newMode.toString(8)}`);
+            }
+        }
+        // Deferred store-wins WARNs: shadow notifications (collected pre-logger).
+        // Log name only — never value (residency invariant).
+        for (const name of shadowedNames) {
+            daemonLogger.warn({ submodule: "secrets-overlay", secretName: name }, `Secret '${name}' defined in both the active store and process.env — ` +
+                "store value is authoritative. The env var has been removed from process.env.");
+        }
+        // Assert pre-read storageMode === post-bootstrap security.storage (invariant).
+        // security.storage is a boot-critical, runtime-immutable switch that must be a literal
+        // value — ${VAR} substitution is not supported for this field, because preReadStorageMode
+        // (raw YAML scan, no variable expansion) gates key-material writes before
+        // bootstrap resolves the substitution. A mismatch means ${VAR} was used and the two
+        // values disagree — fail boot loudly rather than silently misrouting credential storage.
+        if (container.config.security.storage !== storageMode) {
+            throw new Error(`[CONFIG_ERROR] security.storage resolved to '${container.config.security.storage}' ` +
+                `after config substitution, but pre-read value was '${storageMode}'. ` +
+                "security.storage must be a literal value (encrypted|file|env); " +
+                "${VAR} references are not supported for this field.");
+        }
+        // P0 boot: file/env storage mode INFO log (logger now available).
+        // No WARN needed — the legacy opt-out path now fails at the boot gate above.
+        // If we reach here with storageMode !== "encrypted", it is a valid P0 mode.
+        if (storageMode !== "encrypted") {
+            daemonLogger.info({
+                storageMode,
+                hint: "Credential stores operating in non-encrypted mode. SECRETS_MASTER_KEY and secrets.db are not created.",
+            }, `security.storage: ${storageMode} — no key material created.`);
+        }
+        // 3.5. Startup config warnings
+        const approvalsWarning = checkApprovalsConfig(container.config.approvals ?? { enabled: false, defaultMode: "auto", rules: [], defaultTimeoutMs: 30_000, waitTimeoutMs: 60_000 });
+        if (approvalsWarning) {
+            daemonLogger.warn({ hint: "Set approvals.enabled: true or remove unused rules", errorKind: "config" }, approvalsWarning);
+        }
+        // 3.6. Validate PROVIDER_OVERRIDES vs live pi-ai catalog (fire-and-forget).
+        validateProviderOverrides(agentLogger);
+        // 4. Observability
+        const { tokenTracker, sharedCostTracker, diagnosticCollector, billingEstimator, channelActivityTracker, deliveryTracer, 
+        // the canonical redacted ActivityStream (the orchestrator-facing
+        // ActivityStreamPort) + its drain hook. `activityStream` is injected into
+        // ExecutionPipelineDeps + the ACP renderer hook; `disposeActivityStream` is
+        // threaded into setupShutdown. The activity-stream logger + homeDir
+        // are read here at the sanctioned composition root (no env reads in the
+        // substrate; injected logger).
+        activityStream, disposeActivityStream, spendAccumulator, otelHandle, // spendAccumulator: Phase 177 kill-switch (live-incremented, REHYDRATED below, threaded to bridges); otelHandle: Phase 178 OTLP/Prometheus exporter handle → setupShutdown.
+         } = await setupObservability({
+            eventBus: container.eventBus,
+            _createTokenTracker,
+            logger: logLevelManager.getLogger("observability"),
+            activityLogger: logLevelManager.getLogger("activity-stream"),
+            homeDir: mergedEnv["HOME"],
+            dataDir, clock, config: container.config, version: daemonVersion, // Phase 177 (clock+config): construct the spend accumulator here (ceilings from config.observability.spend). Phase 178/CR-01: daemonVersion → comis_build_info{version}.
+            // runtime reachability: resolve the DEFAULT agent's activity.theme →
+            // themeForName bundle and forward it so the process-wide ActivityStream's
+            // subagent marker follows the configured theme (the four themes are now
+            // selectable at runtime; the schema fully-defaults activity.theme, the
+            // `?? "default"` is belt-and-suspenders). Per-agent-per-turn theming via
+            // TurnActivityContext is a documented future refinement.
+            theme: themeForName(container.config.agents[container.config.routing.defaultAgentId]?.activity?.theme ?? "default"),
+        });
+        const contextPipelineCollector = createContextPipelineCollector({
+            eventBus: container.eventBus,
+            logger: logLevelManager.getLogger("context-pipeline"),
+        });
+        // The ActivityStream substrate is live and subscribed to the
+        // EventBus. The orchestrator-facing ActivityStreamPort +
+        // the per-channel coordinator-factory are now threaded into the INBOUND
+        // execution pipeline (ExecutionPipelineDeps.activityStreamPort /
+        // coordinatorFactory) — `activityStream` flows through buildChannelManagerDeps →
+        // ChannelsDeps → buildAndStartChannelManager, which assembles the
+        // coordinatorFactory over the live activityRenderers map and injects it onto
+        // createChannelManager. The substrate is drained on shutdown via
+        // disposeActivityStream. Per-renderer egress stays fail-closed until an
+        // operator opts in via activity.channels.<rendererKey> (§22.2 Day-0).
+        daemonLogger.debug({ component: "activity-stream", counters: activityStream.counters() }, "ActivityStream substrate constructed and subscribed to EventBus");
+        // 5. Health / process
+        const { processMonitor } = setupHealth({
+            container, logger, daemonLogger, _createProcessMonitor,
+        });
+        // WR-01: the shared per-agent learned-skill SURFACE registry — created BEFORE the memory
+        // wiring (which stands up the promote/demote loop) and threaded into BOTH it and setupAgents,
+        // so a promote/demote can re-refresh the agent that registered its surface cache.
+        const learnedSkillSurfaceRegistry = createLearnedSkillSurfaceRegistry();
+        // 6.5. Memory + embedding
+        const { disposeEmbedding, cachedPort, memoryAdapter, db, sessionStore, memoryApi, embeddingQueue, backgroundIndexingPromise, embeddingCacheStats, embeddingCircuitBreakerState, maintenanceTick, summarizerSpendBreaker, rerankerPort, rerankerModelPresent, disposeReranker, entityStore, lcdStore, provenanceStore, contextBrowse, temporalStore, causalStore, tripleStore, embeddingStore, usefulnessStore, outcomeStore, learnedSkillStore, recordOutboundMessage, destroyReactionWiring, memoryLifecycleStore, consolidationStore, recallCounters, } = await setupMemory({ container, memoryLogger, clock, timers, learnedSkillSurfaceRegistry });
+        // Observability persistence (dual-write to SQLite). obsStore +
+        // obsPersistence via const+IIFE.
+        const obsConfig = container.config.observability;
+        const obsBundle = obsConfig.persistence.enabled
+            ? (() => {
+                const store = createObservabilityStore(db);
+                const pruneResult = store.prune(obsConfig.persistence.retentionDays);
+                daemonLogger.info({
+                    retentionDays: obsConfig.persistence.retentionDays,
+                    pruned: pruneResult,
+                }, "Observability data pruned on startup");
+                const persistence = setupObsPersistence({
+                    eventBus: container.eventBus,
+                    obsStore: store,
+                    db,
+                    channelActivityTracker,
+                    startupTimestamp: startupStartMs,
+                    snapshotIntervalMs: obsConfig.persistence.snapshotIntervalMs,
+                    logger: daemonLogger,
+                    // AUDIT-01: the security-audit.jsonl lives under <dataDir>/logs and
+                    // rides the shared observability.logRotation policy (the 6th stream).
+                    dataDir: container.config.dataDir || dataDir,
+                    logRotation: {
+                        maxSizeBytes: obsConfig.logRotation.maxSizeBytes,
+                        maxFiles: obsConfig.logRotation.maxFiles,
+                    },
+                    auditConfig: { persist: obsConfig.audit.persist, sink: obsConfig.audit.sink },
+                    // PERSIST-01: the cache_break subscriber is opt-out-able via this flag (default on).
+                    persistence: { cacheBreaks: obsConfig.persistence.cacheBreaks },
+                });
+                return { obsStore: store, obsPersistence: persistence };
+            })()
+            : undefined;
+        const obsStore = obsBundle?.obsStore; // trajectory recorder is per-session (pi-executor.ts).
+        const obsPersistence = obsBundle?.obsPersistence;
+        // Phase 177: REHYDRATE the spend accumulator at the boot root, AFTER obsStore exists (the rolling-spend read lives there); NO-OPS when obsStore is undefined (persistence off → start at $0). 24h window.
+        if (spendAccumulator)
+            rehydrateSpendFromStore(spendAccumulator, obsStore, 24 * 60 * 60 * 1000);
+        // OUTCOME-07: prune the append-only outcome_events ledger at EVERY boot,
+        // UNCONDITIONALLY — deliberately OUTSIDE the obsConfig.persistence.enabled IIFE
+        // above, because this is anti-DoS housekeeping that must run regardless of obs
+        // persistence OR the learningOutcome enable flag (a ledger that grew while the
+        // signal was briefly enabled must still be bounded after it is turned off). The
+        // ledger is tenant/agent-agnostic, so retain the LONGEST horizon any agent asks
+        // for (default 30 from the Plan-01 schema) — never prune one agent's data early.
+        {
+            const learningOutcomeRetentionDays = Math.max(30, ...Object.values(container.config.agents ?? {}).map((a) => a?.learningOutcome?.retentionDays ?? 30));
+            const outcomePruneStart = systemNowMs();
+            const outcomePruned = outcomeStore.prune(learningOutcomeRetentionDays);
             daemonLogger.info({
-                retentionDays: obsConfig.persistence.retentionDays,
-                pruned: pruneResult,
-            }, "Observability data pruned on startup");
-            const persistence = setupObsPersistence({
+                retentionDays: learningOutcomeRetentionDays,
+                pruned: outcomePruned.changes,
+                durationMs: systemNowMs() - outcomePruneStart,
+            }, "Outcome events pruned on startup");
+        }
+        // I2: one-shot model_health boot snapshot — embedding/reranker load-level
+        // signals as a queryable obs_diagnostics row (no-ops when persistence off).
+        // EMB-01 adds the two advisory multilingual booleans (provider-aware resolution
+        // in resolveModelHealthMultilingual; advisory only — no recall gated, I4).
+        recordModelHealth(obsStore, {
+            embeddingAvailable: !!cachedPort, rerankerModelPresent, rerankerBuilt: rerankerPort !== undefined,
+            ...resolveModelHealthMultilingual(container.config),
+        }, clock);
+        // Create daemon-level runtime registries
+        const activeRunRegistry = createActiveRunRegistry();
+        const sessionResolver = createBackgroundSessionResolver({ activeRunRegistry });
+        const canaryFallbackSecret = (await import("node:crypto")).createHmac("sha256", container.config.tenantId)
+            .update("comis:canary-fallback")
+            .digest("hex");
+        const injectionRateLimiter = createInjectionRateLimiter({ clock, timers });
+        // Session mirroring (must precede setupAgents — agents receive a live deliveryMirror port)
+        const { deliveryMirror, startPrune: startMirrorPrune, shutdown: shutdownMirror } = await setupDeliveryMirror({
+            db, config: container.config, pluginRegistry: container.pluginRegistry, logger: daemonLogger,
+        });
+        // Gemini CachedContent lifecycle manager (per-agent enable gate lives in the injector)
+        const geminiCacheManager = createGeminiCacheManager({
+            getApiKey: () => container.secretManager.get("google-api-key") ?? container.secretManager.get("GOOGLE_API_KEY"),
+            ttlSeconds: 3600,
+            maxActiveCachesPerAgent: 20,
+            refreshThreshold: 0.5,
+            logger: daemonLogger,
+            clock,
+        });
+        // Deferred channel plugins ref (populated after setupChannels)
+        const channelPluginsRef = {};
+        // 6.5.1. Background task system (created before setupAgents)
+        const { backgroundTaskManager } = setupBackgroundTasks({
+            dataDir,
+            eventBus: container.eventBus,
+            logger: logLevelManager.getLogger("background-tasks"),
+            clock,
+            timers,
+        });
+        // Deferred notification ref + bgNotifyFn closure
+        const bgNotifyRef = {};
+        const bgNotifyFn = async (opts) => {
+            await bgNotifyRef.ref?.notifyUser({
+                agentId: opts.agentId,
+                message: opts.message,
+                priority: opts.priority,
+                origin: opts.origin,
+            });
+        };
+        // 6.5.2. Credential broker (constructed only when executor.broker is configured)
+        const brokerHandle = container.config.executor?.broker
+            ? await setupBroker({
+                dataDir,
                 eventBus: container.eventBus,
-                obsStore: store,
-                db,
-                channelActivityTracker,
-                startupTimestamp: startupStartMs,
-                snapshotIntervalMs: obsConfig.persistence.snapshotIntervalMs,
                 logger: daemonLogger,
-            });
-            return { obsStore: store, obsPersistence: persistence };
-        })()
-        : undefined;
-    const obsStore = obsBundle?.obsStore;
-    const obsPersistence = obsBundle?.obsPersistence;
-    // Create context store + daemon-level runtime registries
-    const contextStore = createContextStore(db);
-    const activeRunRegistry = createActiveRunRegistry();
-    const sessionResolver = createBackgroundSessionResolver({ activeRunRegistry });
-    const canaryFallbackSecret = (await import("node:crypto")).createHmac("sha256", container.config.tenantId)
-        .update("comis:canary-fallback")
-        .digest("hex");
-    const injectionRateLimiter = createInjectionRateLimiter({ clock, timers });
-    // Session mirroring (must precede setupAgents — agents receive a live deliveryMirror port)
-    const { deliveryMirror, startPrune: startMirrorPrune, shutdown: shutdownMirror } = await setupDeliveryMirror({
-        db, config: container.config, pluginRegistry: container.pluginRegistry, logger: daemonLogger,
-    });
-    // Gemini CachedContent lifecycle manager (per-agent enable gate lives in the injector)
-    const geminiCacheManager = createGeminiCacheManager({
-        getApiKey: () => container.secretManager.get("google-api-key") ?? container.secretManager.get("GOOGLE_API_KEY"),
-        ttlSeconds: 3600,
-        maxActiveCachesPerAgent: 20,
-        refreshThreshold: 0.5,
-        logger: daemonLogger,
-        clock,
-    });
-    // Deferred channel plugins ref (populated after setupChannels)
-    const channelPluginsRef = {};
-    // 6.5.1. Background task system (created before setupAgents)
-    const { backgroundTaskManager } = setupBackgroundTasks({
-        dataDir,
-        eventBus: container.eventBus,
-        logger: logLevelManager.getLogger("background-tasks"),
-        clock,
-        timers,
-    });
-    // Deferred notification ref + bgNotifyFn closure
-    const bgNotifyRef = {};
-    const bgNotifyFn = async (opts) => {
-        await bgNotifyRef.ref?.notifyUser({
-            agentId: opts.agentId,
-            message: opts.message,
-            priority: opts.priority,
-            origin: opts.origin,
+                clock,
+                timers,
+                secretManager: container.secretManager,
+                bindings: Object.values(container.config.executor.broker.bindings ?? {}),
+                port: container.config.executor.broker.port,
+                socketPath: container.config.executor.broker.socketPath ?? safePath(dataDir, "broker.sock"),
+            })
+            : undefined;
+        // 6.5.9. Seed ALL bundled skills into the user data dir (version-aware, AUTO-SCANNED).
+        // SKILLS-SEED-01: generalized from the former single skill-creator IIFE — every
+        // `bundled-skills/<name>/` (skill-creator, claude-code, codex, …) is seeded into
+        // `<dataDir>/skills/<name>`, so shipping a bundled skill is ZERO engine code. Idempotent:
+        // re-seeds only when missing or the bundled `version:` differs (see seed-bundled-skills.ts).
+        {
+            // Relative path resolves to packages/daemon/bundled-skills from this file in packages/daemon/src/.
+            const bundledSkillsRoot = pathResolve(fileURLToPath(import.meta.url), "../../bundled-skills");
+            seedBundledSkills(defaultSeedBundledSkillsDeps(bundledSkillsRoot, safePath(dataDir, "skills"), agentLogger));
+        }
+        // Mutate boot with all Group A foundation fields. The 2 forward-ref slots
+        // (channelPluginsRef, bgNotifyRef) were eagerly initialized by
+        // createEmptyBootContext(); here we wire the bgNotifyFn closure that reads
+        // bgNotifyRef.ref at call time (populated later by bootChannels).
+        boot.channelPluginsRef = channelPluginsRef;
+        boot.bgNotifyRef = bgNotifyRef;
+        Object.assign(boot, {
+            container, dataDir, configPaths, envPath,
+            clock, env, timers, activityBreaker, activityRendererFactoryOverride: activityRendererFactory,
+            secretStore, mutableHandle, secretsCrypto, secretsDb, permissionCorrections,
+            execGit, configGitManager,
+            logger, logLevelManager, daemonLogger, gatewayLogger, channelsLogger, agentLogger,
+            schedulerLogger, skillsLogger, memoryLogger, daemonVersion,
+            tokenTracker, sharedCostTracker,
+            diagnosticCollector, billingEstimator, channelActivityTracker, deliveryTracer,
+            activityStream, disposeActivityStream, spendAccumulator, otelHandle, // spendAccumulator: Phase 177 kill-switch → bridge; otelHandle: Phase 178 OTLP/Prometheus exporter → setupShutdown.
+            contextPipelineCollector,
+            processMonitor,
+            disposeEmbedding, cachedPort, memoryAdapter, db, sessionStore, memoryApi,
+            embeddingQueue, backgroundIndexingPromise, embeddingCacheStats,
+            embeddingCircuitBreakerState, summarizerSpendBreaker, rerankerPort, rerankerModelPresent, disposeReranker, entityStore, lcdStore, provenanceStore, contextBrowse, temporalStore, causalStore, tripleStore, embeddingStore, usefulnessStore, outcomeStore, learnedSkillStore, learnedSkillSurfaceRegistry, recordOutboundMessage, destroyReactionWiring, memoryLifecycleStore, consolidationStore, recallCounters, maintenanceTick,
+            obsStore, obsPersistence,
+            activeRunRegistry, sessionResolver, canaryFallbackSecret, injectionRateLimiter,
+            deliveryMirror, startMirrorPrune, shutdownMirror,
+            geminiCacheManager,
+            backgroundTaskManager, bgNotifyFn,
+            brokerHandle,
         });
-    };
-    // 6.5.9. Seed bundled skill-creator into user data dir (version-aware)
-    seedBundledSkillCreator({ dataDir, agentLogger });
-    return {
-        container, dataDir, configPaths, envPath,
-        clock, env, timers,
-        secretStore, secretsCrypto, secretsDb, permissionCorrections,
-        execGit, configGitManager,
-        logger, logLevelManager, daemonLogger, gatewayLogger, channelsLogger, agentLogger,
-        schedulerLogger, skillsLogger, memoryLogger, daemonVersion,
-        tokenTracker, latencyRecorder, sharedCostTracker,
-        diagnosticCollector, billingEstimator, channelActivityTracker, deliveryTracer,
-        contextPipelineCollector,
-        processMonitor, watchdogHandle, deviceIdentity,
-        disposeEmbedding, cachedPort, memoryAdapter, db, sessionStore, memoryApi,
-        embeddingQueue, backgroundIndexingPromise, embeddingCacheStats,
-        embeddingCircuitBreakerState, maintenanceTick,
-        obsStore, obsPersistence, contextStore,
-        activeRunRegistry, sessionResolver, canaryFallbackSecret, injectionRateLimiter,
-        deliveryMirror, startMirrorPrune, shutdownMirror,
-        geminiCacheManager,
-        channelPluginsRef, backgroundTaskManager, bgNotifyRef, bgNotifyFn,
-    };
+    }
+    catch (e) {
+        // Boot failed — release the lock. Under normal boot, setupShutdown.onShutdown
+        // owns the release; catch here handles bootstrap/selectSecretStore failures.
+        releaseDataDirLock(dataDir);
+        throw e;
+    }
 }
 // ---------------------------------------------------------------------------
 // Stage 2: agents
 // ---------------------------------------------------------------------------
 /**
- * stageAgents — agent-runtime startup. Owns:
+ * bootAgents — agent-runtime startup. Owns:
  *   - agents config map + default agent/workspace resolution
  *   - mcpClientManager (constructed BEFORE setupAgents per ordering constraint)
  *   - setupAgents (executors, costTrackers, skillRegistries, OAuth store, etc.)
  *   - subprocessEnv + execToolEnv (filtered envs for trusted/untrusted children)
  *   - systemEventQueue (cron-heartbeat routing) + setupSchedulers
  *   - sessionTrackerRegistry + Gemini-cache cleanup + MCP disconnect cleanup
- *   - setupTaskExtraction + auditAggregator + onSuspiciousContent
+ *   - auditAggregator + onSuspiciousContent
  *   - setupMedia + setupRpcBridge
- *   - approvalGate + restoreApprovalState (extracted helper)
+ *   - approvalGate + restoreApprovalState
  *   - setupDeliveryQueue (+ channelAdaptersRef placeholder)
  *
- * Hard cap: ≤200 lines AST-measured. Per-line-source order preserved so
- * daemon-lifecycle.test.ts log-sequence assertions remain green ("Agent
- * executor initialized", "Per-agent CronScheduler started").
+ * Mutates `boot` with all Group B agent fields. Per-line-source order
+ * preserved so daemon-lifecycle.test.ts log-sequence assertions remain green
+ * ("Agent executor initialized", "Per-agent CronScheduler started").
  *
  * mcpClientManager construction order is a production-correctness
  * constraint: it must be constructed BEFORE setupAgents — do not invert.
  */
-async function stageAgents(input) {
-    const { overrides, foundation } = input;
-    const { container, dataDir, clock, env, timers, daemonLogger, gatewayLogger, agentLogger, schedulerLogger, skillsLogger, memoryAdapter, db, sessionStore, cachedPort, embeddingQueue, contextStore, activeRunRegistry, canaryFallbackSecret, injectionRateLimiter, deliveryMirror, geminiCacheManager, channelPluginsRef, backgroundTaskManager, secretsCrypto, secretsDb, } = foundation;
+async function bootAgents(boot, input) {
+    const { overrides } = input;
+    // Alias `boot` as `foundation` for body-readability — Group A fields are
+    // already populated by bootFoundation, destructuring from boot is equivalent.
+    const foundation = boot;
+    const { container, dataDir, clock, env, timers, daemonLogger, gatewayLogger, agentLogger, schedulerLogger, skillsLogger, memoryAdapter, db, sessionStore, cachedPort, embeddingQueue, rerankerPort, // built in setup-memory; threaded into setupAgents -> createPiExecutor
+    rerankerModelPresent, // model-present probe result; threaded into setupAgents -> per-agent effective rerank precedence (same value as the build gate)
+    entityStore, // threaded into setupAgents -> createPiExecutor (recall read path) + the cron review (write path)
+    lcdStore, // Phase 128 LCD store; threaded into setupAgents -> createPiExecutor (contextStore) -> setupContextEngine -> the `dag` branch (context-engine.ts). Opt-in (version: "dag"); default pipeline. The agent receives the core ContextStorePort TYPE only (agent↛memory cut)
+    provenanceStore, // Phase 173 DIST-03 read side; threaded into setupAgents -> createPiExecutor -> prompt-assembly -> createMemoryRecall's post-fusion provenance down-weighting pass (was BUILT but never injected in Phase 172). The agent receives the core LcdProvenanceReadStore TYPE only (agent↛memory cut)
+    summarizerSpendBreaker, // R1 (132-05); daemon-owned per-tenant breaker; threaded into setupAgents -> createPiExecutor -> setupContextEngine so getSummarizerDeps gates the leaf seam per tenant (truncation-only degrade on open-breaker/over-cap)
+    spendAccumulator, temporalStore, // spendAccumulator = Phase 177 dollars kill-switch (threaded setupAgents -> createPiExecutor -> bridge); temporalStore -> createMemoryRecall (recall temporal-spread read; dormant until rag.lanes.temporal.enabled)
+    causalStore, // threaded into setupAgents -> createPiExecutor -> createMemoryRecall (the 5th causal read lane, dormant until rag.lanes.causal.enabled) AND the cron review -> runMemoryReview -> linkCausal (the write path) — one segregated port, both halves
+    tripleStore, // threaded into setupAgents -> createPiExecutor -> createMemoryRecall (the 6th graph-spread read lane, dormant until rag.lanes.graphSpread.enabled); the agent receives the port TYPE only (the agent↛memory cut)
+    embeddingStore, usefulnessStore, // the MMR re-rank's scoped embedding read + recall usefulness read -> setupAgents -> createPiExecutor -> prompt-assembly; the agent receives the port TYPEs only (the agent↛memory cut). (The directional relationshipStore + the LLM-free <channel_relationships> standing-block read were DELETED in Phase 226-04 with the rest of the social-modeling subsystem. The LLM-free <user_profile> read is now the kind:"profile" mentalModelStore.list path — FOLD-01, Phase 225 — NOT a separate userRepresentationStore. The buildScoringAlphas tuned-vector read was deleted in Phase 224 — recall scoring is the fixed config alphas.)
+    activeRunRegistry, canaryFallbackSecret, injectionRateLimiter, learnedSkillStore, learnedSkillSurfaceRegistry, // learnedSkillStore (v2.26 SURFACE-01/03) -> setupAgents -> getPromptSkillsXml; learnedSkillSurfaceRegistry (WR-01) -> setupAgents register + the promote/demote re-refresh
+    deliveryMirror, geminiCacheManager, channelPluginsRef, backgroundTaskManager, secretsCrypto, secretsDb, obsStore, // thread into setupAgents
+    secretStore, // interactive-callback signing-secret resolution
+     } = foundation;
     const _setupMedia = overrides.setupMedia ?? setupMedia;
     // 6.6. Agents
     const agentsConfig = container.config.agents;
@@ -385,19 +1297,124 @@ async function stageAgents(input) {
     const defaultAgentConfig = agentsConfig[defaultAgentId] ??
         agentsConfig.default ??
         {};
-    const defaultWorkspaceDir = resolveWorkspaceDir(defaultAgentConfig, defaultAgentId);
+    const defaultWorkspaceDir = resolveWorkspaceDir(defaultAgentConfig, defaultAgentId, container.config.dataDir || dataDir);
+    // Boot-path skill-bundle re-merge MUST run BEFORE setupMcp (sequencing
+    // gate). The orchestrator
+    // re-runs the bundle resolver across every installed skill's mcpServers
+    // block and persists the merged array via persistMcpServers — which
+    // mutates container.config.integrations.mcp.servers via its in-memory
+    // swap. setupMcp on the next line then connects from the POST-merge
+    // state. Reversing the order leaves setupMcp connecting to the pre-merge
+    // list (a new bundle entry persists on disk but stays disconnected).
+    //
+    // Pre-pass: build thin discovery-only skill registries inline (the real
+    // per-agent registries with eligibility + watcher are built later inside
+    // setupAgents). createSkillRegistry is idempotent so the two passes
+    // don't race; the discovery-only registries are discarded after the
+    // orchestrator returns.
+    const skillRegistriesForBundles = buildSkillRegistriesForBundles(container, skillsLogger);
+    await setupSkillBundles({
+        container,
+        skillRegistries: skillRegistriesForBundles,
+        persistDeps: {
+            container,
+            configPaths: foundation.configPaths,
+            defaultConfigPaths: DEFAULT_CONFIG_PATHS,
+            configGitManager: foundation.configGitManager,
+            logger: skillsLogger,
+        },
+        eventBus: container.eventBus,
+        logger: skillsLogger,
+    });
+    // Construct the ONE mode-selected MCP OAuth token store at the composition
+    // root. The SAME instance is threaded into BOTH consumers — setupMcp's manager
+    // wiring (below) AND the login/handler path (buildRpcDispatchDeps reads it off
+    // the boot context). This kills the encrypted-mode split-brain where the login
+    // path wrote a plaintext disk store while the manager read the mode-selected
+    // store. selectMcpTokenStore: encrypted → mcp_credentials (AES-256-GCM, no disk
+    // files); file → chokidar mcp-tokens/ store; env → undefined (no MCP OAuth).
+    const mcpTokenStore = selectMcpTokenStore({
+        storage: container.config.security.storage,
+        logger: skillsLogger,
+        dataDir: container.config.dataDir && container.config.dataDir.length > 0
+            ? container.config.dataDir
+            : dataDir,
+        secretsDb,
+        secretsCrypto,
+    });
     // Construct daemon-global MCP manager BEFORE setupAgents (ordering constraint
     // -- per-agent ToolCapabilityPort adapters close over mcpClientManager).
-    const mcpClientManager = await setupMcpManager({ container, skillsLogger, defaultWorkspaceDir });
+    // setupMcp consumes the injected mcpTokenStore; it no longer mode-selects.
+    const { mcpClientManager } = await setupMcp({
+        servers: container.config.integrations.mcp.servers,
+        logger: skillsLogger,
+        callToolTimeoutMs: container.config.integrations.mcp.callToolTimeoutMs,
+        defaultCwd: defaultWorkspaceDir,
+        eventBus: container.eventBus,
+        stdioDefaultConcurrency: container.config.integrations.mcp.stdioDefaultConcurrency,
+        httpDefaultConcurrency: container.config.integrations.mcp.httpDefaultConcurrency,
+        // Forward the global reliability config so daemon-wide overrides
+        // apply to startup-connected servers. keepaliveIntervalMs is the middle tier:
+        // per-server server.keepaliveIntervalMs ?? globalKeepaliveIntervalMs ??
+        // transport-aware default (resolveDefaultKeepaliveIntervalMs in ticker).
+        globalKeepaliveIntervalMs: container.config.integrations.mcp.keepaliveIntervalMs,
+        circuitBreakerThreshold: container.config.integrations.mcp.circuitBreakerThreshold,
+        circuitBreakerCooldownMs: container.config.integrations.mcp.circuitBreakerCooldownMs,
+        // The single mode-selected MCP OAuth token store (same instance threaded
+        // into the login/handler path via the boot context). Undefined in env mode.
+        mcpTokenStore,
+    });
+    // CWF-03: Ollama served-window probe — best-effort, fail-open.
+    // Must run before setupAgents so the result can be threaded into each executor.
+    // daemon.ts is the globals allowlist root; raw fetch is permitted here.
+    const servedWindowByProvider = await probeAllOllamaProviders({
+        providerEntries: container.config.providers?.entries ?? {},
+        fetchFn: (url, init) => fetch(url, init),
+        timeoutMs: 5_000,
+        // IMP-2a: also LOAD-warm each ollama model (fire-and-forget) so a cold model's first inference
+        // doesn't exceed the per-inference stall budget and abort the first user turn after a (re)start.
+        prewarm: true,
+        logger: agentLogger,
+    }).catch((err) => {
+        agentLogger.warn({
+            err,
+            errorKind: "dependency",
+            hint: "probeAllOllamaProviders threw an unhandled exception; all executor servedContextWindow values will be undefined. Check @comis/agent version compatibility.",
+        }, "Ollama served-window probe threw unexpectedly — starting with empty map (fail-open)");
+        return new Map();
+    });
+    // LAT-03: one-time redirect WARN for the config-echo-only providers.*.timeoutMs.
+    try {
+        warnOnProviderTimeoutRedirect({ providerEntries: container.config.providers?.entries ?? {}, logger: agentLogger });
+    }
+    catch { /* fail-open — a WARN helper must never block boot (I1) */ }
+    // KNOB-01/03 + FLOOR-01 (v2.21): daemon-owned boot-honesty collectors, populated
+    // per-agent in setup-agents beside the registry; read by the bootChannels floor
+    // loop + the bootShutdown posture count (ONE comparison feeds WARN + count).
+    const servedWindowComparisons = new Map();
+    const agentBootWindowInfo = new Map();
+    // Phase 213-08: the LATE-BOUND bounded-autonomy seam (built before the cap layer; see helper JSDoc).
+    const { boundedAutonomyBudgetHolder, resolveRootRunId, sharedLeaseManager } = createBoundedAutonomyWiring({ clock });
     const { sessionManager, executors, workspaceDirs, costTrackers, budgetGuards, stepCounters, getExecutor, piSessionAdapters, skillWatcherHandles, skillRegistries, lockCleanupTimer, singleAgentDeps, providerHealth, 
-    // Daemon-level OAuth credential store, threaded into ApiDispatchDeps
-    // below so agents.update can validate oauthProfiles patches via has().
+    // Daemon-level OAuth credential store from setupAgents — same port instance
+    // threaded into ApiDispatchDeps so agents.update can validate oauthProfiles
+    // patches via has(). setupAgents constructs its own store internally via
+    // selectOAuthCredentialStore. This is the OAuth *profile* store (provider
+    // tokens), distinct from the MCP OAuth token store (`mcpTokenStore` above,
+    // built via selectMcpTokenStore) — two separate credential families.
     oauthCredentialStore, 
     // Per-agent live ToolCapabilityPort adapters; daemon.ts threads
     // getCapabilityPortForAgent into setupTools and mutates this map on
-    // hot-add / hot-remove.
-    toolCapabilityPorts, } = await setupAgents({
-        container, memoryAdapter, sessionStore, agentLogger, outboundMediaEnabled: true,
+    // hot-add / hot-remove. trajectoryRegistry is drained by setupShutdown.
+    toolCapabilityPorts, trajectoryRegistry, 
+    // per-agent shared ExecutionPlanHolder reference map.
+    // Threaded through buildChannelManagerDeps so the chat plan-stream reads
+    // from the SAME object SEP publishes into (Pitfall 1).
+    executionPlanPorts, oauthManagers, authStorages, // oauthManagers (184): DEFAULT agent's → buildImageGenBundle (CDX-01); authStorages (FLAG-3): dialectic OAuth resolver
+     } = await setupAgents({
+        container, memoryAdapter, sessionStore, agentLogger, rerankerPort, rerankerModelPresent, entityStore, lcdStore, provenanceStore, temporalStore, causalStore, tripleStore, embeddingStore, usefulnessStore, pinnedStore: memoryAdapter, learnedSkillStore, learnedSkillSurfaceRegistry, summarizerSpendBreaker, spendAccumulator,
+        boundedAutonomyBudget: boundedAutonomyBudgetHolder, resolveRootRunId, // Phase 213-08: per-root budget holder + rootRunId resolver → each bridge
+        outboundMediaEnabled: true,
         autonomousMediaEnabled: !container.config.integrations.media.transcription.autoTranscribe
             || !container.config.integrations.media.vision.enabled
             || !container.config.integrations.media.documentExtraction.enabled,
@@ -405,16 +1422,13 @@ async function stageAgents(input) {
         canaryFallbackSecret, // Deterministic canary fallback
         injectionRateLimiter, // Per-user injection rate limiting
         embeddingQueue, // Conversation memory persistence in executor
-        // DAG context engine deps
-        contextStore,
-        db,
         embeddingPort: cachedPort, // Semantic search in discover_tools
         // Session mirroring -- mirror port + injection budget config
         deliveryMirror,
         deliveryMirrorConfig: container.config.deliveryMirror
             ? { maxEntriesPerInjection: container.config.deliveryMirror.maxEntriesPerInjection, maxCharsPerInjection: container.config.deliveryMirror.maxCharsPerInjection }
             : undefined,
-        geminiCacheManager, // Gemini cache lifecycle manager
+        geminiCacheManager, obsStore, // SystemPromptReport persistence
         // Resolve platform char limit via deferred channelPlugins ref
         getChannelMaxChars: (channelType) => {
             const plugin = channelPluginsRef.ref?.get(channelType);
@@ -430,6 +1444,8 @@ async function stageAgents(input) {
         // per-agent ToolCapabilityPort adapter construction.
         mcpClientManager,
         clock, env, timers,
+        servedWindowByProvider, // CWF-03: Ollama served context-window probe result
+        servedWindowComparisons, agentBootWindowInfo, // KNOB-01/03 + FLOOR-01 collectors
     });
     // Log operation model resolutions at startup (dry-run validation)
     logOperationModelDryRun({
@@ -445,42 +1461,55 @@ async function stageAgents(input) {
     const subprocessEnv = envSubset(container.secretManager, [...SUBPROCESS_SYSTEM, ...container.secretManager.keys()]);
     // Credential-free env for the exec tool (agent-issued shell commands).
     const execToolEnv = envSubset(container.secretManager, [...SUBPROCESS_SYSTEM]);
-    // Deferred wake callback ref -- populated by stageChannels once
-    // wakeCoalescer is constructed. Same shape as channelPluginsRef /
-    // bgNotifyRef (cross-stage deferred-ref pattern).
+    // Deferred wake callback ref -- populated by bootChannels once wakeCoalescer is
+    // constructed (the channelPluginsRef / bgNotifyRef cross-stage deferred-ref pattern).
     const cronWakeCallbackRef = {};
     // 6.6.4.9. System event queue (created early for cron-heartbeat routing)
     const systemEventQueue = createSystemEventQueue({ logger: schedulerLogger });
-    // 6.6.5. Schedulers
+    // 6.6.5. Schedulers — the onCronWake handler reads `cronWakeCallbackRef.ref` at
+    // INVOCATION time (deferred), so the live wakeCoalescer wired in bootChannels
+    // receives the wake; a cron firing in the handoff gap is DEBUG-logged (the silent
+    // miss is visible). Observability-only: NO buffer-then-drain (channelPluginsRef/
+    // bgNotifyRef precedent) — replaying timer-driven wakes could cause a wake storm.
     const { cronSchedulers, executionTrackers, browserServices, resetSchedulers, getAgentCronScheduler, getAgentBrowserService, } = await setupSchedulers({
         container, workspaceDirs, sessionStore, sessionManager,
         schedulerLogger, agentLogger, skillsLogger,
         subprocessEnv,
         systemEventQueue, // cron-heartbeat routing
-        onCronWake: buildDeferredCronWakeCallback(cronWakeCallbackRef, daemonLogger),
+        onCronWake: (reason) => {
+            const callback = cronWakeCallbackRef.ref;
+            if (callback) {
+                callback(reason);
+            }
+            else {
+                daemonLogger.debug({ reason, hint: "wakeCoalescer not yet constructed; cron wake dropped" }, "Cron wake dropped during stage handoff");
+            }
+        },
         clock, timers,
+        leaseManager: sharedLeaseManager, boundedAutonomyHolder: boundedAutonomyBudgetHolder, // Phase 213-08 (RATE-02): the cron-fire fresh-lease mint (shared LeaseManager + late-bound holder)
     });
     // Post-setupAgents cleanup wiring: session expiry, Gemini cache disposal,
     // orphan cleanup, MCP disconnect cleanup. Returns the sessionTrackerRegistry
-    // bound to the session:expired listener (helper keeps stageAgents ≤200L).
+    // bound to the session:expired listener.
     const sessionTrackerRegistry = wirePostAgentsCleanup({
         eventBus: container.eventBus,
         geminiCacheManager,
         daemonLogger,
     });
-    // 6.6.5.5. Task extraction (conversation -> extracted tasks pipeline)
-    const { extractFromConversation } = setupTaskExtraction({
-        container, workspaceDirs, schedulerLogger,
-    });
-    // Audit aggregator for deduplicating security events (extracted helper).
-    const { auditAggregator, onSuspiciousContent } = buildAuditBundle({
-        eventBus: container.eventBus,
-        skillsLogger,
-        clock,
-        timers,
-    });
+    // Audit aggregator for deduplicating security events. Inlined buildAuditBundle:
+    // auditAggregator + onSuspiciousContent pair used by bootAgents and
+    // threaded into setupMedia.
+    const auditAggregator = createAuditAggregator(container.eventBus, { clock, timers }, undefined, skillsLogger);
+    const onSuspiciousContent = (info) => {
+        auditAggregator.record({ source: "external_content", patterns: info.patterns });
+    };
     // 6.6.7. Media (moved up from 6.6.8 -- media infrastructure must be ready before channels)
-    const { ttsAdapter, visionRegistry, linkRunner, mediaTempManager, mediaSemaphore, audioConverter, transcriber, ssrfFetcher, fileExtractor, } = await _setupMedia({ container, skillsLogger, onSuspiciousContent });
+    // Phase 193 keyless-first audio steering: setup-media gates STT/TTS construction
+    // on this selector (resolveStt/resolveTts) BEFORE building any adapter — a
+    // Codex/OAuth-only main never builds the empty-bearer OpenAI adapter (no 401).
+    // Phase 194: buildAudioResolverDeps is async (runs the detectLocalSttEngine boot probe).
+    const audioSelector = await buildAudioResolverDeps(container, defaultAgentId, skillsLogger);
+    const { ttsAdapter, visionRegistry, visionRegistryHolder, linkRunner, mediaTempManager, mediaSemaphore, audioConverter, transcriber, ssrfFetcher, fileExtractor, voiceSelection, } = await _setupMedia({ container, skillsLogger, onSuspiciousContent, audioSelector });
     // 6.6.7.5. RPC bridge (deferred dispatch) -- moved before setupChannels so rpcCall
     // can be threaded into channel config command handling.
     const { rpcCall, wireDispatch } = setupRpcBridge({ gatewayLogger });
@@ -501,77 +1530,241 @@ async function stageAgents(input) {
         containerDataDir: container.config.dataDir,
         daemonLogger,
     });
+    // 6.6.8.6.3. Interactive-callback wiring: resolve
+    // the signing secret (store or in-memory fallback), bind the renderer signer,
+    // construct the InteractiveCallbackRouter over the SAME gate + secret, and build
+    // the Email single-use link minter + the gateway approval-token map/resolver.
+    // Built here (gate + secretStore + clock all available) and consumed by both
+    // bootChannels (signer + minter) and bootGateway (token map + resolveApproval).
+    const interactiveCallbackWiring = createInteractiveCallbackWiring({
+        secretStore,
+        approvalGate,
+        clock,
+        config: container.config,
+        logger: daemonLogger,
+    });
     // 6.6.7.8. Delivery queue: create adapter BEFORE setupChannels.
     // channelAdapters map is passed by reference -- populated after setupChannels.
     // drainAndStart() is called AFTER setupChannels (two-phase lifecycle).
     const channelAdaptersRef = new Map();
     const { deliveryQueue, drainAndStart: drainAndStartDeliveryPrune, shutdown: shutdownDeliveryQueue } = await setupDeliveryQueue({
         db, config: container.config, eventBus: container.eventBus, logger: daemonLogger, channelAdapters: channelAdaptersRef,
+        // REACT-02 (Verified Learning, Phase 199): capture agent-authored outbound (messageId → trajectory).
+        // `undefined` when learning-outcome is off for all agents (byte-identity: zero extra drain work).
+        recordOutboundMessage: foundation.recordOutboundMessage,
     });
-    return {
-        ...foundation,
+    Object.assign(boot, {
         defaultAgentId, defaultWorkspaceDir, agentsConfig,
+        boundedAutonomyBudgetHolder, resolveRootRunId, sharedLeaseManager, // Phase 213-08: ride the late-bind seam onto boot for bootChannels' cap layer
         sessionManager, executors, workspaceDirs, costTrackers, budgetGuards, stepCounters,
         getExecutor, piSessionAdapters, skillWatcherHandles, skillRegistries, lockCleanupTimer,
         singleAgentDeps, providerHealth, oauthCredentialStore, toolCapabilityPorts, mcpClientManager,
+        mcpTokenStore,
         continuationTracker, subprocessEnv, execToolEnv,
         systemEventQueue, cronSchedulers, executionTrackers, browserServices, resetSchedulers,
         getAgentCronScheduler, getAgentBrowserService,
-        sessionTrackerRegistry, extractFromConversation, auditAggregator, onSuspiciousContent,
-        ttsAdapter, visionRegistry, linkRunner, mediaTempManager, mediaSemaphore, audioConverter,
-        transcriber, ssrfFetcher, fileExtractor,
-        rpcCall, wireDispatch, approvalGate,
+        sessionTrackerRegistry, auditAggregator, onSuspiciousContent,
+        ttsAdapter, visionRegistry, visionRegistryHolder, linkRunner, mediaTempManager, mediaSemaphore, audioConverter,
+        transcriber, ssrfFetcher, fileExtractor, voiceSelection,
+        rpcCall, wireDispatch, approvalGate, interactiveCallbackWiring,
         channelAdaptersRef, deliveryQueue, drainAndStartDeliveryPrune, shutdownDeliveryQueue,
-        cronWakeCallbackRef,
-    };
+        cronWakeCallbackRef, trajectoryRegistry, executionPlanPorts, oauthManagers, authStorages, servedWindowComparisons, agentBootWindowInfo,
+    });
 }
 // ---------------------------------------------------------------------------
 // Stage 3: channels
 // ---------------------------------------------------------------------------
 /**
- * stageChannels — channel-runtime startup. Owns:
+ * bootChannels — channel-runtime startup. Owns:
+ *   - sandbox + image generation providers
+ *   - per-agent ToolCapabilityPort resolver (inlined factory)
+ *   - tools assembly + message preprocessing (setupTools HOISTED above
+ *     setupChannels — eliminates the tool-assembler indirection)
  *   - channel adapters + composite media resolution + delivery service
- *   - inbound message id resolver
+ *   - inbound message id resolver (local-let; lambda reads at call time)
  *   - notification system + background completion runner
+ *   - sessionTracker (local-let after notifications; lambda reads at call time)
  *   - channel health monitor
- *   - sandbox + image generation providers
- *   - per-agent ToolCapabilityPort resolver (factory helper)
- *   - tools assembly + message preprocessing
  *   - cross-session sender + sub-agent runner
  *   - node type registry + graph coordinator + named graph store
  *   - monitoring (heartbeat runner) + per-agent heartbeat + wake coalescer
  *   - cronWakeCallbackRef populated (cross-stage handoff)
  *   - agent management runtime state (suspended set, model catalog, channel cfg)
  *
- * Hard cap: ≤200 lines AST-measured. Per-line-source order preserved so
- * daemon-lifecycle.test.ts log-sequence assertions remain green.
+ * setupTools is constructed BEFORE setupChannels (every setupTools input
+ * was already foundation/agents-stage output or constructed inline before
+ * setupChannels). sandbox/imageGen providers remain before setupChannels
+ * (unchanged). This eliminates the tool-assembler indirection:
+ * `assembleToolsForAgent` is now passed directly into
+ * `buildChannelManagerDeps`. The remaining 2 eliminable refs
+ * (sessionTracker / inboundMessageIdResolver) are local `let` slots
+ * captured by accessor closures that read at message-arrival time.
+ *
+ * Mutates `boot` with all Group C channel fields. Per-line-source order
+ * preserved so daemon-lifecycle.test.ts log-sequence assertions remain green.
  */
-async function stageChannels(input) {
-    const { agents: handle } = input;
-    // Names consumed by stageChannels body itself; helper functions
+async function bootChannels(boot) {
+    // Alias `boot` as `handle` to preserve readability of the body destructure
+    // pattern — bootChannels reads many fields populated by bootAgents +
+    // bootFoundation. Both names refer to the same object; mutations to `handle`
+    // are mutations to `boot`.
+    const handle = boot;
+    // Names consumed by bootChannels body itself; helper functions
     // re-destructure from `handle` directly so closure deps are explicit.
-    const { container, sessionStore, db, daemonLogger, agentLogger, schedulerLogger, skillsLogger, logger, memoryAdapter, memoryApi, activeRunRegistry, sessionResolver, channelPluginsRef, backgroundTaskManager, bgNotifyRef, bgNotifyFn, defaultAgentId, defaultWorkspaceDir, executors, workspaceDirs, agentsConfig: agents, toolCapabilityPorts, mcpClientManager, linkRunner, systemEventQueue, rpcCall, approvalGate, deliveryQueue, cronWakeCallbackRef, singleAgentDeps, } = handle;
-    const sessionTrackerRef = {};
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- matches assembleToolsForAgent signature from setup-tools.ts
-    const toolAssemblerRef = {};
-    // `{ ref?: T }` indirection captured by onMessageReceived lambda;
-    // populated below once channelCapabilities is available.
-    const inboundMessageIdResolverRef = {};
-    // 6.6.8. Channels (lifted from main()'s setupChannels; deps via helper)
-    const { adaptersByType, channelManager, resolveAttachment, lifecycleReactors, channelPlugins, channelCapabilities, commandQueue, deliveryService } = await setupChannels(buildChannelManagerDeps({ agents: handle, toolAssemblerRef, inboundMessageIdResolverRef, sessionTrackerRef }));
+    const { container, sessionStore, db, daemonLogger, agentLogger, schedulerLogger, skillsLogger, logger, memoryAdapter, memoryApi, activeRunRegistry, sessionResolver, channelPluginsRef, backgroundTaskManager, bgNotifyRef, bgNotifyFn, defaultAgentId, defaultWorkspaceDir, executors, workspaceDirs, agentsConfig: agents, toolCapabilityPorts, mcpClientManager, linkRunner, systemEventQueue, rpcCall, approvalGate, deliveryQueue, cronWakeCallbackRef, singleAgentDeps, 
+    // Phase 131 (E1/E2): the concrete LCD ContextStorePort (createLcdStore),
+    // populated on the BootContext by bootFoundation's setupMemory Object.assign.
+    // Threaded into setupTools so assembleToolsForAgent wires the dag-mode ctx_*
+    // in-session expansion tools. The agent sees only the core port TYPE (the cut).
+    lcdStore, } = handle;
+    // The 3 eliminable local-scope refs (session-tracker, tool-assembler,
+    // inbound-message-id-resolver) are GONE.
+    //   - assembleToolsForAgent is now a direct value (setupTools hoisted below).
+    //   - sessionTracker / inboundMessageIdResolver use a `const {current?: T}`
+    //     container pattern: the binding is `const` (satisfies prefer-const)
+    //     and the `.current` field is mutated after setupChannels returns. The
+    //     accessor closures passed into buildChannelManagerDeps read
+    //     `container.current` at message-arrival time (lambdas captured by
+    //     setupChannels are not invoked during setupChannels itself).
+    const sessionTrackerSlot = {};
+    const inboundMessageIdResolverSlot = {};
+    // 6.6.8.4.1. Sandbox + image generation providers (HOISTED before setupTools
+    // because setupTools consumes both as direct inputs).
+    const sandboxProvider = detectSandboxProvider(skillsLogger);
+    if (sandboxProvider)
+        skillsLogger.info({ provider: sandboxProvider.name }, "Exec sandbox provider detected");
+    // Image-generation bundle (see buildImageGenBundle in wiring/main-helpers.ts). 184: oauthManager threads the DEFAULT agent's OAuth manager for the Codex image path (CDX-01).
+    const { imageGenConfig, imageGenProvider, imageGenRateLimiter, persistImage, imageGenCostLimiter } = await buildImageGenBundle({ container, defaultAgentId, skillsLogger, oauthManager: handle.oauthManagers.get(defaultAgentId), workspaceDirs, defaultWorkspaceDir });
+    // Video-generation bundle (Phase 188 baseline + 189 async + 190 live adapters —
+    // see buildVideoGenBundle in wiring/main-helpers.ts). 189: pass the shared
+    // memory.db handle (the VideoJobStore binds it), the EARLY channelAdaptersRef
+    // (WARNING-1 — the poller resolves a LIVE adapter from it after
+    // wirePostChannelsLifecycle populates it), and the daemon TimerPort (the poller's
+    // sweeper). 190 (CRED-01): oauthManager threads the DEFAULT agent's OAuth manager
+    // for the Grok-video key-or-OAuth path (mirrors the image call below + :2169).
+    // Destructure videoJobStore + videoPoller for the boot context + the handler deps.
+    const { videoGenConfig, videoGenProvider, videoGenRateLimiter, persistVideo, videoGenCostLimiter, videoJobStore, videoPoller } = buildVideoGenBundle({ container, defaultAgentId, skillsLogger, oauthManager: handle.oauthManagers.get(defaultAgentId), workspaceDirs, defaultWorkspaceDir, db, channelAdaptersRef: handle.channelAdaptersRef, timers: handle.timers, trajectoryRegistry: handle.trajectoryRegistry, eventBus: container.eventBus });
+    // VIS-01 (187): the provider-following vision bundle — same construction site, reusing the DEFAULT agent's OAuth manager (codex bearer) + the boot clock (the bridge's per-message timestamp). See buildMediaVisionBundle in wiring/main-helpers.ts.
+    const mediaVisionBundle = buildMediaVisionBundle({ container, defaultAgentId, skillsLogger, clock: handle.clock, oauthManager: handle.oauthManagers.get(defaultAgentId) });
+    // 6.6.8.5. Tools + message preprocessing — HOISTED above setupChannels.
+    // getCapabilityPortForAgent: resolve a ToolCapabilityPort, default-agent fallback, throw if neither.
+    const getCapabilityPortForAgent = (agentId) => {
+        const port = toolCapabilityPorts.get(agentId) ?? toolCapabilityPorts.get(defaultAgentId);
+        if (!port)
+            throw new Error(`No ToolCapabilityPort registered for agent '${agentId}' and no default agent ('${defaultAgentId}') fallback available -- the agent may have been removed or the daemon failed to initialize.`);
+        return port;
+    };
+    // 7.8.9. Phase 216: durable stores built EARLY (before the cap layer — the jail-leg chokepoint shares the SAME store for the HIGH-1 _outwardStepIndex allocation). See buildDurableStores.
+    const { durabilityCfg, durableRunStore: durableRunStoreEarly, outwardLedger: outwardLedgerEarly } = buildDurableStores({ agents, db });
+    // 7.9. Capability-lease layer + ACTIVATION (Phase 211 + 212 Gap 3) — constructed BEFORE setupTools so the KEPT handle threads capMint + the orchestrate capSocketPath into tool assembly; on `boot` for bootShutdown. Phase 213: cronJobCount binds the bounded-autonomy RATE-02 count to the per-agent CronScheduler. Phase 216: durableRuns threads into the jail-leg chokepoint for the HIGH-1 _outwardStepIndex allocation.
+    const { capEndpointHandle, namespacePreflightOk } = await constructCapabilityLayer({ agents, rpcCall, clock: boot.clock, timers: handle.timers, cronJobCount: (agentId) => { try {
+            return handle.getAgentCronScheduler(agentId).getJobs().length;
+        }
+        catch {
+            return 0;
+        } }, dataDir: container.config.dataDir || ".", daemonLogger, skillsLogger, workspaceDirs, defaultWorkspaceDir, webSearchKeys: container.secretManager, boundedAutonomyHolder: handle.boundedAutonomyBudgetHolder, leaseManager: handle.sharedLeaseManager, container, ...(durableRunStoreEarly ? { durableRuns: durableRunStoreEarly } : {}) }); // Phase 213-08: POPULATE the late-bound budget holder (read by the bridge at turn time) + share the SAME LeaseManager as the cron-fire mint; Phase 215 (AUDIT-01): pass the container so the SOCKET chokepoint emits the per-cap audit (audit:event + capability:audited) for jailed tool.invoke calls
+    Object.assign(boot, { capEndpointHandle, namespacePreflightOk });
+    // 7.9.1. Phase 216: the durable-resume engine built AFTER the cap layer (BoundedAutonomy reachable); its closures resolve at resumeAndStart() (AFTER channels — boot-order). See buildDurableResume.
+    // Plan 12 (DUR-02/LOW-2): late-bound holder for coordinator.resumeGraph — the coordinator is built later (after channels) but resumeRun only fires at resumeAndStart() (also after channels), so it is set by then. A DAG record routes here.
+    const graphResumeHolder = {};
+    const { durableResume, startAndResumeDurable, durableRunFacts } = buildDurableResume({
+        db, durabilityCfg, durableRunStore: durableRunStoreEarly, outwardLedger: outwardLedgerEarly,
+        boundedAutonomy: capEndpointHandle?.boundedAutonomy, sharedLeaseManager: handle.sharedLeaseManager,
+        channelAdaptersRef: handle.channelAdaptersRef, eventBus: container.eventBus, logger: daemonLogger, clock: handle.clock, timers: handle.timers,
+        // DUR-02/LOW-2: route a DAG record (spawn_tree objects w/ status) to coordinator.resumeGraph via the late-bound holder.
+        resumeGraph: (record) => graphResumeHolder.ref ? graphResumeHolder.ref(record) : Promise.resolve(err(new Error("resumeGraph holder unpopulated (coordinator not built)"))),
+    });
+    Object.assign(boot, { durableRunStore: durableResume.durableRunStore, outwardLedger: durableResume.outwardLedger, durableResumeShutdown: durableResume.shutdown });
+    const { assembleToolsForAgent, preprocessMessageText, shutdownBackgroundProcesses, terminalRegistries, getTerminalAttentionConfig, terminalDurability } = setupTools({
+        rpcCall, agents, defaultAgentId, workspaceDirs, defaultWorkspaceDir, capEndpointHandle, namespacePreflightOk, // Phase 211 JAIL-03 → PROFILE-05: degrade the orchestrate surface + lease mint when the host cannot build the jail (no silent unjailed fallback)
+        // Phase 216 (HIGH-1 / NEW-4): durable store + resolver → in-process outward send gets _outwardStepIndex (off ⇒ pass-through).
+        ...(durableResume.durableRunStore ? { durableRuns: durableResume.durableRunStore } : {}),
+        ...(handle.resolveRootRunId ? { resolveRootRunId: handle.resolveRootRunId } : {}),
+        // WR-04 (Phase 174-04): the per-provider operator capabilityClass override so ctx_expand's walk depth honors a pinned tier (same providers.entries source as the executor's ModelProfile). Undefined ⇒ provider-family heuristic.
+        getProviderCapabilityClass: (provider) => container.config.providers?.entries?.[provider ?? ""]?.capabilities?.capabilityClass,
+        dataDir: container.config.dataDir || ".",
+        secretManager: container.secretManager, platformSecretNames: container.platformSecretNames,
+        eventBus: container.eventBus, skillsLogger, linkRunner,
+        approvalGate: container.config.approvals?.enabled ? approvalGate : undefined,
+        subprocessEnv: handle.execToolEnv, onSuspiciousContent: handle.onSuspiciousContent,
+        // 124-09 (WR-01 closure): the daemon TimerPort drives the terminal-driver reaper sweep.
+        timers: handle.timers,
+        // Phase 131 (E1/E2): the concrete LCD store, so assembleToolsForAgent can wire the
+        // dag-mode ctx_* tools (gated on version === "dag" && a present store). The agent
+        // receives only the core ContextStorePort TYPE (the agent-to-store cut holds).
+        lcdStore,
+        mcpClientManager,
+        // Fresh accessor for per-server tool filtering — read live so
+        // config:mutated server edits surface on the next tool assembly.
+        getMcpServerEntries: () => container.config.integrations?.mcp?.servers ?? [],
+        sandboxProvider, imageGenProvider, videoGenProvider, backgroundTaskManager,
+        // JOB-04 (189): gate the video_status tool on the SAME condition video_generate
+        // uses (the async store + poller are wired exactly when videoGenProvider exists).
+        videoStatusEnabled: videoGenProvider,
+        sessionTrackerRegistry: handle.sessionTrackerRegistry, getCapabilityPortForAgent,
+        // broker activation seam. When executor.broker is configured,
+        // thread the broker handle into setupTools so assembleToolsForAgent wires
+        // the exec tool with broker-only network + proxy env + placeholder creds.
+        // When absent (no executor.broker config), brokerContext is undefined and
+        // the exec tool uses the default open-network path (no regression).
+        brokerContext: handle.brokerHandle
+            ? {
+                tcpPort: handle.brokerHandle.tcpPort,
+                socketPath: handle.brokerHandle.socketPath,
+                caPath: handle.brokerHandle.caPath,
+                sessionManager: handle.brokerHandle.sessionManager,
+                placeholders: buildPlaceholdersFromBindings(container.config.executor?.broker?.bindings ?? {}, daemonLogger),
+            }
+            : undefined,
+    });
+    // FLOOR-01 (v2.21): boot-time viable-floor WARN per agent — WARN-only (I1/D-02),
+    // awaited for determinism, fail-open per agent (a throw never aborts boot, T-176-15).
+    for (const [floorAgentId, bootInfo] of handle.agentBootWindowInfo ?? new Map()) {
+        try {
+            evaluateViableFloorForAgent({ info: bootInfo, tools: await assembleToolsForAgent(floorAgentId), logger: daemonLogger });
+        }
+        catch (err) {
+            daemonLogger.warn({ err, agentId: floorAgentId, errorKind: "internal", hint: "viable-floor boot check failed — boot continues (fail-open); turn-time guards still apply (dag: CWF-02 preflight; pipeline: 85% compaction trigger + reactive classification)" }, "viable-floor boot evaluation threw — skipped for agent");
+        }
+    }
+    // 6.6.8. Channels — pass assembleToolsForAgent DIRECTLY (no ref) and
+    // pass accessor closures for sessionTracker / inboundMessageIdResolver
+    // (const `{current?:T}` container pattern; populated after setupChannels
+    // returns by mutating the .current field).
+    const { adaptersByType, channelManager, resolveAttachment, lifecycleReactors, channelPlugins, commandQueue, deliveryService } = await setupChannels(buildChannelManagerDeps({
+        agents: handle,
+        assembleToolsForAgent,
+        getInboundMessageIdResolver: () => inboundMessageIdResolverSlot.current,
+        getSessionTracker: () => sessionTrackerSlot.current,
+    }));
     channelPluginsRef.ref = channelPlugins;
-    const inboundMessageIdResolver = (() => {
+    inboundMessageIdResolverSlot.current = (() => {
         const metaKeyByChannel = new Map();
-        for (const [type, cap] of channelCapabilities)
-            metaKeyByChannel.set(type, cap.replyToMetaKey);
+        for (const [type, plugin] of channelPlugins) {
+            const metaKey = plugin.capabilities.replyToMetaKey;
+            if (metaKey)
+                metaKeyByChannel.set(type, metaKey);
+        }
         return createInboundMessageIdResolver({ metaKeyByChannel });
     })();
-    inboundMessageIdResolverRef.ref = inboundMessageIdResolver;
-    await wirePostChannelsLifecycle({
+    // Local alias for the BootContext-bound publication below.
+    const inboundMessageIdResolver = inboundMessageIdResolverSlot.current;
+    // wirePostChannelsLifecycle now returns outputRetentionHandle so
+    // the composition root can route .shutdown() through ShutdownDeps. The
+    // eventBus.on("system:shutdown", ...) subscribers previously here are
+    // deleted; shutdownDeliveryQueue + shutdownMirror remain reachable via
+    // boot (they were always part of the agents/foundation groups).
+    const { outputRetentionHandle } = await wirePostChannelsLifecycle({
         adaptersByType,
         channelAdaptersRef: handle.channelAdaptersRef,
         drainAndStartDeliveryPrune: handle.drainAndStartDeliveryPrune,
         shutdownDeliveryQueue: handle.shutdownDeliveryQueue,
+        // JOB-03 (189): start + resume the background video poller after the channel
+        // registry is populated (the local videoPoller from buildVideoGenBundle above;
+        // undefined when video is disabled → the optional call no-ops).
+        ...(videoPoller ? { startAndResumeVideoPoller: () => videoPoller.startAndResume() } : {}),
+        // Phase 216: run the durable resume engine after channels (boot-order — reconcile/replay need LIVE adapters); inert no-op when durability is off.
+        startAndResumeDurable,
         startMirrorPrune: handle.startMirrorPrune,
         shutdownMirror: handle.shutdownMirror,
         daemonLogger, container, defaultWorkspaceDir,
@@ -585,7 +1778,7 @@ async function stageChannels(input) {
         activeAdapterTypes: new Set(adaptersByType.keys()),
         logger: daemonLogger, tenantId: container.config.tenantId,
     });
-    sessionTrackerRef.ref = notificationContext.sessionTracker;
+    sessionTrackerSlot.current = notificationContext.sessionTracker;
     bgNotifyRef.ref = notificationContext.notificationService;
     const bgConfigForRunner = BackgroundTasksConfigSchema.parse(agents[defaultAgentId]?.backgroundTasks ?? {});
     const bgCompletionRunnerContext = setupBackgroundCompletionRunner({
@@ -593,40 +1786,110 @@ async function stageChannels(input) {
         taskManager: backgroundTaskManager, fallbackNotifyFn: bgNotifyFn,
         maxBackgroundHops: bgConfigForRunner.maxBackgroundHops, logger: daemonLogger,
     });
-    container.eventBus.on("system:shutdown", () => { void bgCompletionRunnerContext.runner.shutdown(); });
+    // eventBus.on("system:shutdown", () =>
+    //   bgCompletionRunnerContext.runner.shutdown()) deleted — runner.shutdown
+    // is threaded directly into setupShutdown via
+    // ShutdownDeps.bgCompletionRunnerShutdown.
+    // Thread the terminal registries to bootGateway's webhook route for the unattended honest-fail backstop (WEBHOOK-CLAUDE-AGENT-DRIVE-RELIABILITY).
+    Object.assign(boot, { terminalRegistries });
+    // 6.6.8.0.2. Terminal-driver wake-FSM (v2.11 / 124-09 — THE KEYSTONE). One-per-daemon:
+    // subscribes the re-published terminal:input_needed (the Task-1 fd3 hook) → dedupe/active-
+    // check/hop-limit → wakes ONE turn that runs the safe-only auto-answer + loop-guard against
+    // the SAME per-agent terminalRegistries the tools drive; escalations route via bgNotifyFn
+    // (§4.7). Drained on shutdown via ShutdownDeps.terminalWakeShutdown.
+    const terminalWakeContext = setupTerminalWake({
+        eventBus: container.eventBus,
+        registries: terminalRegistries,
+        getTerminalAttentionConfig,
+        notify: bgNotifyFn,
+        dataDir: container.config.dataDir || ".",
+        // 165-07 DUR-02 / LIVE-01 / ENDURE-01: the durable wake deps — the journal store
+        // (persist-on-set + resume-on-re-attach), the liveness backstop (timers + heartbeatMs +
+        // checkLiveness via the worker status round-trip, whose lastActivity stamp IS the I9 reaper
+        // unify — LO-03), and the spend ceiling (maxCostUsd). timers = the reaper's TimerPort.
+        ...terminalDurability,
+        timers: handle.timers,
+        logger: daemonLogger,
+    });
     // 6.6.8.0.3. Recover background tasks NOW (after the runner is subscribed)
     backgroundTaskManager.recoverOnStartup();
     // Channel health monitor (start + stop produced by helper).
     const { monitor: channelHealthMonitor, stop: stopChannelHealthMonitor } = setupChannelHealthMonitor({ adaptersByType, daemonLogger, container });
-    container.eventBus.on("system:shutdown", () => { stopChannelHealthMonitor?.(); });
+    // eventBus.on("system:shutdown", () => stopChannelHealthMonitor?.())
+    // deleted — stopChannelHealthMonitor is threaded directly into setupShutdown
+    // via ShutdownDeps.stopChannelHealthMonitor.
     setupChannelHealthLogging({ eventBus: container.eventBus, logger: daemonLogger });
-    // 6.6.8.4.1. Sandbox + image generation providers (helper)
-    const sandboxProvider = detectSandboxProvider(skillsLogger);
-    if (sandboxProvider)
-        skillsLogger.info({ provider: sandboxProvider.name }, "Exec sandbox provider detected");
-    const { imageGenProvider, imageGenRateLimiter, imageGenConfig } = buildImageGenBundle({ container, skillsLogger });
-    // 6.6.8.5. Tools + message preprocessing
-    const getCapabilityPortForAgent = createCapabilityPortResolver(toolCapabilityPorts, defaultAgentId);
-    const { assembleToolsForAgent, preprocessMessageText } = setupTools({
-        rpcCall, agents, defaultAgentId, workspaceDirs, defaultWorkspaceDir,
-        dataDir: container.config.dataDir || ".",
-        secretManager: container.secretManager, platformSecretNames: container.platformSecretNames,
-        eventBus: container.eventBus, skillsLogger, linkRunner,
-        approvalGate: container.config.approvals?.enabled ? approvalGate : undefined,
-        subprocessEnv: handle.execToolEnv, onSuspiciousContent: handle.onSuspiciousContent,
-        mcpClientManager, sandboxProvider, imageGenProvider, backgroundTaskManager,
-        sessionTrackerRegistry: handle.sessionTrackerRegistry, getCapabilityPortForAgent,
-    });
-    toolAssemblerRef.ref = assembleToolsForAgent;
     // 6.6.9. Cross-session sender + sub-agent runner
+    // proxyTypingCleanup returned from setupCrossSession — replaces
+    // the eventBus.on("system:shutdown", ...) subscriber inside
+    // registerProxyTypingListeners that silently no-op'd in production.
     const gatewaySendRef = {};
-    const { crossSessionSender, subAgentRunner, sendToChannel, announceToParent, deadLetterQueue, announcementBatcher } = setupCrossSession({
+    // WT-01/WT-02: the git-worktree seam for `spawn --worktree`. ONE registry shared
+    // by executeSubAgent (which creates + auto-cleans worktrees in-line) and the boot
+    // orphan-sweep (which reclaims worktrees orphaned by a crashed run). The lifecycle
+    // GitExec is the SAME real execFile-backed `execGit` config-git uses, adapted to
+    // the lifecycle's `{ stdout, exitCode }` shape (toLifecycleGitExec). The boot
+    // sweep is started in wirePostChannelsLifecycle (after channels) + cancelled on
+    // shutdown — modeled on the durable-resume two-phase boot hook.
+    const worktreeRegistry = createWorktreeRegistry();
+    const worktreeGitExec = toLifecycleGitExec(handle.execGit);
+    const { crossSessionSender, subAgentRunner, sendToChannel, announceToParent, deadLetterQueue, announcementBatcher, proxyTypingCleanup } = setupCrossSession({
         sessionStore, container, assembleToolsForAgent, getExecutor: handle.getExecutor, adaptersByType,
         logger: agentLogger, memoryAdapter, gatewaySend: gatewaySendRef,
         activeRunRegistry, sessionResolver, deliveryQueue, deliveryService,
         fileLock: singleAgentDeps.fileLock,
         clock: handle.clock, timers: handle.timers,
+        // WT-01/WT-02: thread the worktree seam + the shared registry.
+        worktreeGitExec, worktreeRegistry,
+        ...(capEndpointHandle ? { checkSpawnCeiling: (rootRunId, depth, fanout) => capEndpointHandle.boundedAutonomy.tryAcquireSpawn(rootRunId, depth, fanout), releaseSpawnCeiling: (rootRunId) => capEndpointHandle.boundedAutonomy.releaseSpawn(rootRunId) } : {}), // Phase 213 CEIL-01/CR-02: tree-wide spawn ceiling + symmetric release (paired 1:1, no per-root leak)
+        // Phase 216 DUR-01/HB-01: durable store + thresholds + facts → the runner writes a per-root checkpoint + heartbeat (off ⇒ inert).
+        ...(durableResume.durableRunStore ? { durableRuns: durableResume.durableRunStore } : {}),
+        ...(durabilityCfg.enabled ? { durability: { keepAliveMs: durabilityCfg.keepAliveMs, staleHeartbeatMs: durabilityCfg.staleHeartbeatMs } } : {}),
+        ...(durableRunFacts ? { durableRunFacts } : {}),
+        // Phase 216 HIGH-2 (ONCE-01..04): the SAME ledger (Plan 07) + rootRunId resolver → announce() + the DLQ drain route through the exactly-once ledger (off ⇒ pass-through). Makes Plan 10 LIVE.
+        ...(durableResume.outwardLedger ? { outwardLedger: durableResume.outwardLedger } : {}),
+        ...(handle.resolveRootRunId ? { resolveRootRunId: handle.resolveRootRunId } : {}),
+    });
+    // WT-02: the worktree orphan-sweep. Boot recovery (discover prior-crash
+    // worktrees from `git worktree list` → seed the registry → one conservative
+    // sweep) THEN a periodic interval (.unref()'d, cancelled on shutdown). Modeled
+    // on the durable-resume two-phase boot hook. The sweep is git/fs-only (no
+    // channels), so it runs here once setupCrossSession has built the shared
+    // registry. `exists` is the real fs check (existsSync); the boot discovery is
+    // scoped to the agent workspace dirs so the operator's OWN worktrees are never
+    // touched. Best-effort at boot — a failure WARN-logs and the periodic pass retries.
+    const worktreeSweep = setupWorktreeSweep({
+        execGit: handle.execGit,
+        registry: worktreeRegistry,
+        exists: (dir) => existsSync(dir),
+        timers: handle.timers,
+        clock: handle.clock,
+        logger: daemonLogger,
     });
+    void (async () => {
+        try {
+            await discoverWorktreeOrphans({
+                execGit: handle.execGit,
+                registry: worktreeRegistry,
+                workspaceDirs: [...workspaceDirs.values()],
+                logger: daemonLogger,
+            });
+            await worktreeSweep.sweepNow();
+        }
+        catch (sweepErr) {
+            daemonLogger.warn({
+                err: sweepErr,
+                hint: "worktree boot sweep failed; the periodic sweep retries — no worktree was removed this pass",
+                errorKind: "internal",
+            }, "Worktree boot sweep failed");
+        }
+        finally {
+            worktreeSweep.startPeriodicSweep();
+        }
+    })();
+    // The sweep interval is .unref()'d so it never blocks event-loop exit at
+    // shutdown (mirrors the per-agent lock-cleanup timer in setup-agents-registry,
+    // which likewise relies on .unref() rather than a formal teardown handle).
     const promptTimeoutTimestamps = [];
     container.eventBus.on("execution:prompt_timeout", () => { promptTimeoutTimestamps.push(Date.now()); });
     // 6.6.9.0-2. Node type registry + graph coordinator + named graph store
@@ -634,9 +1897,15 @@ async function stageChannels(input) {
     const graphCoordinator = createGraphCoordinator(buildGraphCoordinatorDeps({
         agents: handle,
         channels: { subAgentRunner, sendToChannel, announceToParent, announcementBatcher, commandQueue, assembleToolsForAgent, nodeTypeRegistry },
+        // Phase 216 HIGH-3/DUR-01: thread the live durable store so the coordinator checkpoints node state (Plan 11). Makes DAG durability LIVE.
+        ...(durableResume.durableRunStore ? { durableRunStore: durableResume.durableRunStore } : {}),
     }));
     subAgentRunner.setGraphCoordinator(graphCoordinator);
+    // Phase 216 DUR-02/LOW-2: populate the late-bound holder so resumeRun (fires at resumeAndStart, after channels) routes a DAG record to coordinator.resumeGraph (incomplete-node re-entry).
+    graphResumeHolder.ref = (record) => graphCoordinator.resumeGraph(record);
     const namedGraphStore = createNamedGraphStore(db);
+    // O2 (WR-02): seed the four canonical small-model DAG templates into the named-graph store. Idempotent (INSERT-OR-IGNORE in the seeder), so operator-customized templates survive restarts and re-running on every boot is safe.
+    seedDefaultDagTemplates(namedGraphStore);
     // 6.7. Monitoring + per-agent heartbeat + wake coalescer
     const { heartbeatRunner, duplicateDetector } = setupMonitoring({ container, schedulerLogger, logger, adaptersByType });
     const { perAgentRunner } = setupHeartbeat({
@@ -647,51 +1916,54 @@ async function stageChannels(input) {
         runOnce: () => (heartbeatRunner ? heartbeatRunner.runOnce() : Promise.resolve()),
         logger: schedulerLogger,
     });
-    // Cross-stage: populate cronWakeCallbackRef now that wakeCoalescer is
-    // constructed. The setupSchedulers `onCronWake` lambda (wired in
-    // stageAgents) reads `.ref` at call time.
+    // Cross-stage: populate cronWakeCallbackRef now that wakeCoalescer exists. The setupSchedulers `onCronWake` lambda (wired in bootAgents) reads `.ref` at call time.
     cronWakeCallbackRef.ref = (reason) => wakeCoalescer.requestHeartbeatNow(reason);
     // 6.7.0.2. Agent management runtime state
     const suspendedAgents = new Set();
     const modelCatalog = createModelCatalog();
     modelCatalog.loadStatic();
     const channelConfig = Object.fromEntries(Object.entries(container.config.channels ?? {}).filter(([k, v]) => k !== "healthCheck" && typeof v === "object" && v !== null && "enabled" in v).map(([k, v]) => [k, { enabled: !!v.enabled }]));
-    return {
-        ...handle,
+    Object.assign(boot, {
         adaptersByType, channelManager, resolveAttachment, lifecycleReactors, channelPlugins,
-        channelCapabilities, commandQueue, deliveryService,
+        commandQueue, deliveryService,
         inboundMessageIdResolver, channelHealthMonitor, stopChannelHealthMonitor,
-        notificationContext, bgCompletionRunnerContext,
+        notificationContext, bgCompletionRunnerContext, terminalWakeContext,
         crossSessionSender, subAgentRunner, sendToChannel, announceToParent,
         deadLetterQueue, announcementBatcher, gatewaySendRef,
-        sandboxProvider, imageGenProvider, imageGenRateLimiter, imageGenConfig,
+        sandboxProvider, imageGenProvider, imageGenRateLimiter, imageGenConfig, persistImage, imageGenCostLimiter, mediaVisionBundle,
+        videoGenProvider, videoGenRateLimiter, videoGenConfig, persistVideo, videoGenCostLimiter, videoJobStore, videoPoller,
         assembleToolsForAgent, preprocessMessageText, getCapabilityPortForAgent,
         heartbeatRunner, duplicateDetector, perAgentRunner, wakeCoalescer,
         nodeTypeRegistry, graphCoordinator, namedGraphStore,
         suspendedAgents, modelCatalog, channelConfig, promptTimeoutTimestamps,
-    };
+        // Teardown handles surfaced for ShutdownDeps wiring.
+        shutdownBackgroundProcesses, proxyTypingCleanup,
+        outputRetentionHandle,
+    });
 }
 // ---------------------------------------------------------------------------
 // Stage 4: gateway
 // ---------------------------------------------------------------------------
 /**
- * stageGateway -- gateway-runtime startup. Owns:
+ * bootGateway -- gateway-runtime startup. Owns:
  *   token registry + session store bridge + shutdown ref + hot-add/hot-remove
  *   closures + RPC dispatch deps assembly + gateway server + deferred gateway
  *   attachment wiring + gatewaySendRef.ref population + restart continuation
  *   replay.
- * Inputs: ChannelsHandle (yields foundation + agents + channels) + overrides.
- *
- * Hard cap ≤200 lines AST-measured. Five helpers extracted to fit
- * (resolveGatewayTokens, createHotAdd, createHotRemove,
- * buildRpcDispatchDeps, replayContinuationsIfAny).
  *
- * Log-sequence: "Gateway server started" emits inside setupGateway here in
- * source order; daemon-lifecycle.test.ts assertions remain unchanged.
+ * Reads Group A/B/C fields populated by bootFoundation/bootAgents/bootChannels;
+ * mutates `boot` with Group D gateway fields. Per-source-order:
+ * "Gateway server started" emits inside setupGateway here in source order;
+ * daemon-lifecycle.test.ts assertions remain unchanged.
  */
-async function stageGateway(input) {
-    const { overrides, channels, startupStartMs, instanceId } = input;
-    const { container, configPaths, sessionStore, daemonLogger, gatewayLogger, cachedPort, memoryApi, memoryAdapter, embeddingQueue, defaultAgentId, defaultWorkspaceDir, agentsConfig: agents, costTrackers, workspaceDirs, piSessionAdapters, getExecutor, rpcCall, wireDispatch, assembleToolsForAgent, preprocessMessageText, suspendedAgents, gatewaySendRef, } = channels;
+async function bootGateway(boot, input) {
+    const { overrides, startupStartMs, instanceId } = input;
+    // Alias `boot` as `channels` for body-readability — Group A/B/C fields are
+    // already populated by bootFoundation/bootAgents/bootChannels.
+    const channels = boot;
+    const { container, configPaths, sessionStore, daemonLogger, gatewayLogger, cachedPort, memoryApi, memoryAdapter, embeddingQueue, defaultAgentId, defaultWorkspaceDir, agentsConfig: agents, costTrackers, workspaceDirs, piSessionAdapters, getExecutor, rpcCall, wireDispatch, assembleToolsForAgent, preprocessMessageText, suspendedAgents, gatewaySendRef, interactiveCallbackWiring, obsStore, // 154-03: backs the obs_explain assembler closure (diagnostics rollup)
+    dataDir: bootDataDir, // 154-03: absolute fallback data dir (always abs; ~/.comis or $COMIS_DATA_DIR)
+     } = channels;
     const _createGatewayServer = overrides.createGatewayServer ?? createGatewayServer;
     // Token registry for token management handlers
     const gwTokens = (container.config.gateway?.tokens ?? []).map((t) => ({
@@ -720,7 +1992,7 @@ async function stageGateway(input) {
             sessionStore.save(parsed, messages, metadata);
         },
     };
-    // Mutable shutdown ref for hot-add guard. Populated by stageShutdown --
+    // Mutable shutdown ref for hot-add guard. Populated by bootShutdown --
     // closures read .value at RPC call time, not definition time.
     const shutdownRef = {};
     // Hot-add / hot-remove closures (factory pattern; deps captured by closure)
@@ -736,16 +2008,36 @@ async function stageGateway(input) {
     wireDispatch(rpcDispatchDeps);
     // 7. Gateway server
     const gwConfig = container.config.gateway;
+    // 154-03 / 161-02: the trust-flag-FREE obs.explain + obs.fleet.health MCP-client
+    // closures, extracted to wiring/obs-mcp-closures.ts (daemon.ts ≤3000 line cap).
+    // SECURITY (never-inject-admin; allowlist-only authorization) + the durableRuns
+    // NET-NEW-thread rationale (boot.durableRunStore — the live store the RPC path wires
+    // at :893) live in that helper. dataDir MUST be the absolute boot dir (else
+    // makeRealReader → PathTraversalError); clock is the load-bearing boot ClockPort.
+    const { obsExplainForMcpClient, obsFleetHealthForMcpClient } = buildObsMcpClientClosures({
+        dataDir: container.config.dataDir || bootDataDir,
+        obsStore,
+        clock: boot.clock,
+        durableRuns: boot.durableRunStore,
+    });
     const { gatewayHandle, activeExecutions, getActiveConnectionCount, wsConnections } = await setupGateway({
         container, gwConfig, webhooksConfig: container.config.webhooks, agents, defaultAgentId,
         configPaths, defaultConfigPaths: DEFAULT_CONFIG_PATHS, gatewayLogger,
         embeddingQueue, memoryAdapter, memoryApi, cachedPort, sessionStore, getExecutor,
+        // Deterministic honest-fail backstop (WEBHOOK-CLAUDE-AGENT-DRIVE-RELIABILITY): reap a webhook turn's LIVE never-tasked drives so it records an honest failure, not a silent success.
+        reapNeverTaskedDrives: (agentId, owner) => { const r = channels.terminalRegistries?.get(agentId); return r ? reapNeverTaskedDrivesInRegistry(r, owner) : Promise.resolve({ reaped: [] }); },
         assembleToolsForAgent, preprocessMessageText, rpcCall,
         costTrackers, workspaceDirs,
         _createGatewayServer, piSessionAdapters,
+        // Complete three-layer forget for gateway slash /new + /reset (live 2026-06-11).
+        destroyConversation: createConversationReset({ lcdStore: channels.lcdStore, sessionStore: sessionStoreBridge, piSessionAdapters, tenantId: container.config.tenantId, logger: gatewayLogger }).destroyConversationCompletely,
         resolvedTokens: resolvedGatewayTokens,
+        daemonVersion: boot.daemonVersion,
         suspendedAgents,
         instanceId, startupStartMs,
+        interactiveCallbackWiring,
+        obsExplainForMcpClient,
+        obsFleetHealthForMcpClient,
     });
     // 7.0.1. Wire deferred gateway attachment deps (wsConnections / mediaDir /
     // onGatewayAttachment) into the mutable rpcDispatchDeps reference; handler
@@ -812,35 +2104,47 @@ async function stageGateway(input) {
     // 7.5. Restart continuation replay (helper enforces source order:
     // load -> mcp-status -> per-record inject).
     await replayContinuationsIfAny({ channels });
-    return {
-        ...channels,
+    Object.assign(boot, {
         tokenRegistry, runtimeTokens, removedTokenIds, resolvedGatewayTokens,
         sessionStoreBridge, shutdownRef, hotAdd, hotRemove, rpcDispatchDeps,
         gatewayHandle, activeExecutions, getActiveConnectionCount, wsConnections,
-    };
+    });
 }
 // ---------------------------------------------------------------------------
 // Stage 5: shutdown
 // ---------------------------------------------------------------------------
 /**
- * stageShutdown -- final stage. Constructs the shutdown handle, populates
+ * bootShutdown -- final stage. Constructs the shutdown handle, populates
  * gateway.shutdownRef.value (cross-stage deferred-ref pattern), wires the
  * health-metrics event-bus subscription, emits the startup banner, snapshots
  * last-known-good config, and returns the DaemonInstance to main()'s callers.
  *
- * Hard cap: ≤200 lines AST-measured.
+ * Reads Group A-D fields populated by the prior 4 boot* helpers; returns
+ * `DaemonInstance` (unlike the other boot* helpers which return void) so
+ * main()'s contract is preserved.
  */
-async function stageShutdown(input) {
-    const { overrides, gateway, startupStartMs, instanceId } = input;
-    const { container, dataDir, configPaths, logger, logLevelManager, daemonLogger, daemonVersion, tokenTracker, latencyRecorder, processMonitor, watchdogHandle, deviceIdentity, diagnosticCollector, billingEstimator, channelActivityTracker, deliveryTracer, contextPipelineCollector, backgroundIndexingPromise, db, disposeEmbedding, cachedPort, maintenanceTick, obsPersistence, injectionRateLimiter, geminiCacheManager, backgroundTaskManager, secretStore, executors: _execs, cronSchedulers, resetSchedulers, browserServices, skillWatcherHandles, lockCleanupTimer, continuationTracker, mediaTempManager, ttsAdapter, visionRegistry, rpcCall, approvalGate, auditAggregator, agentsConfig: agents, providerHealth, subAgentRunner, channelManager, channelAdaptersRef, deliveryQueue, adaptersByType, lifecycleReactors, channelHealthMonitor, deadLetterQueue, heartbeatRunner, perAgentRunner, wakeCoalescer, graphCoordinator, suspendedAgents: _suspended, promptTimeoutTimestamps, sessionStoreBridge, shutdownRef, gatewayHandle, activeExecutions, getActiveConnectionCount, } = gateway;
+async function bootShutdown(boot, input) {
+    const { overrides, startupStartMs, instanceId } = input;
+    // Alias `boot` as `gateway` for body-readability — all 4 prior boot* helpers
+    // have populated Group A-D fields.
+    const gateway = boot;
+    const { container, dataDir, configPaths, capEndpointHandle, namespacePreflightOk, logger, logLevelManager, daemonLogger, daemonVersion, tokenTracker, processMonitor, diagnosticCollector, billingEstimator, channelActivityTracker, deliveryTracer, contextPipelineCollector, backgroundIndexingPromise, db, disposeEmbedding, disposeReranker, cachedPort, maintenanceTick, obsPersistence, disposeActivityStream, otelHandle, injectionRateLimiter, destroyReactionWiring, geminiCacheManager, backgroundTaskManager, secretStore, executors: _execs, cronSchedulers, resetSchedulers, browserServices, skillWatcherHandles, lockCleanupTimer, continuationTracker, mediaTempManager, ttsAdapter, visionRegistry, rpcCall, approvalGate, auditAggregator, agentsConfig: agents, providerHealth, subAgentRunner, channelManager, channelAdaptersRef, deliveryQueue, adaptersByType, lifecycleReactors, channelHealthMonitor, deadLetterQueue, heartbeatRunner, perAgentRunner, wakeCoalescer, graphCoordinator, suspendedAgents: _suspended, promptTimeoutTimestamps, sessionStoreBridge, shutdownRef, gatewayHandle, activeExecutions, getActiveConnectionCount, trajectoryRegistry, 
+    // 9 new teardown handles surfaced through BootContext.
+    shutdownBackgroundProcesses, proxyTypingCleanup, outputRetentionHandle, shutdownDeliveryQueue, shutdownMirror, bgCompletionRunnerContext, terminalWakeContext, stopChannelHealthMonitor, mcpClientManager, 
+    // Phase 189: the background video poller (undefined when video disabled) —
+    // its shutdown is threaded into setupShutdown below.
+    videoPoller, } = gateway;
     void _execs;
     void _suspended;
     // Override-derived locals -- only consumed by setupShutdown below.
     const exitFn = overrides.exit ?? ((code) => process.exit(code));
-    const _registerGracefulShutdown = overrides.registerGracefulShutdown ?? registerGracefulShutdown;
-    // 8. Graceful shutdown
+    // Declared here (before setupShutdown) so the thunk captures the ref;
+    // assigned after emitStartupInvariants. Ref-object pattern mirrors
+    // shutdownRef.value — setupShutdown reads .fn at teardown time.
+    const _healthAggRef = { fn: undefined };
+    // 8. Graceful shutdown: signal-handler registration + teardown ordering (setupShutdown).
     const { shutdownHandle } = setupShutdown({
-        logger, daemonLogger, processMonitor, container, exitFn, _registerGracefulShutdown,
+        logger, daemonLogger, processMonitor, container, exitFn,
         tokenTracker, startupTimestamp: startupStartMs,
         activeExecutions, graphCoordinator, subAgentRunner, cronSchedulers, resetSchedulers,
         browserServices, channelManager, heartbeatRunner, perAgentRunner, wakeCoalescer, gatewayHandle,
@@ -848,19 +2152,47 @@ async function stageShutdown(input) {
         diagnosticCollector, channelActivityTracker, deliveryTracer, contextPipelineCollector,
         backgroundIndexingPromise, db,
         disposeEmbedding, // coordinated L1 -> L2 -> provider dispose chain
+        disposeReranker, // release the reranker native context (ranking ctx -> model -> llama)
         approvalGate,
         secretStore, // close secrets.db on shutdown
         auditAggregator, // clear pending dedup timers
         injectionRateLimiter, // clear rate limiter timers on shutdown
+        destroyReactionWiring, // WR-01: clear reaction/session map + reaction limiter timers on shutdown
         lockCleanupTimer, // clear periodic lock cleanup timer
         dataDir: container.config.dataDir || dataDir,
+        lockDataDir: dataDir, // D14 lock release — must match acquireDataDirLock's boot path
         continuationTracker,
         lifecycleReactors, // destroy lifecycle reactors on shutdown
         obsPersistence, // drain write buffers before db.close
+        disposeActivityStream, otelShutdown: otelHandle ? () => otelHandle.shutdown() : undefined, // drain ActivityStream; Phase 178 flush+close OTLP/Prometheus exporter (stops /metrics listener)
         geminiCacheManager, // Dispose all Gemini caches on shutdown
+        trajectoryRegistry, // Drain session-scoped trajectory recorders
+        // 9 new teardown fields (8 production subscribers + setup-tools
+        // split into background-processes + mcp-client-manager).
+        // Each was previously a silent no-op subscriber.
+        shutdownBackgroundProcesses,
+        mcpClientManagerDisconnectAll: () => mcpClientManager.disconnectAll(),
+        bgCompletionRunnerShutdown: () => bgCompletionRunnerContext.runner.shutdown(),
+        // 124-09: drain the terminal wake-FSM (unsubscribe + await in-flight woken turns).
+        terminalWakeShutdown: terminalWakeContext ? () => terminalWakeContext.shutdown() : undefined,
+        proxyTypingCleanup,
+        shutdownDeliveryQueue,
+        // Phase 189: SIGTERM clears the poller's sweeper interval + stops in-flight
+        // per-job loops (no-op when video is disabled / poller undefined).
+        ...(videoPoller ? { shutdownVideoPoller: () => videoPoller.shutdown() } : {}),
+        // Phase 216: cancel the durable-resume watchdog interval on shutdown (inert no-op when off).
+        ...(boot.durableResumeShutdown ? { durableResumeShutdown: boot.durableResumeShutdown } : {}),
+        shutdownDeliveryMirror: shutdownMirror,
+        outputRetentionShutdown: outputRetentionHandle ? () => outputRetentionHandle.shutdown() : undefined,
+        stopChannelHealthMonitor: stopChannelHealthMonitor ?? undefined,
+        // Thunk reads _healthAggRef.fn at teardown time — populated by emitStartupInvariants.
+        unsubscribeHealthAggregator: () => _healthAggRef.fn?.(),
+        // Credential broker teardown (no-op when executor.broker is absent)
+        brokerStop: boot.brokerHandle ? () => boot.brokerHandle.stop() : undefined,
+        capEndpointStop: capEndpointHandle ? () => capEndpointHandle.endpoint.stopSocket() : undefined, // Phase 211/212: stops+unlinks cap.sock
     });
     // Wire shutdown ref for hot-add guard. Cross-stage deferred-ref populate:
-    // stageGateway declared the empty ref + captured it in hot-add closure;
+    // bootGateway declared the empty ref + captured it in hot-add closure;
     // here we point .value at the live shutdown handle so the closure reads
     // .isShuttingDown at call time.
     shutdownRef.value = shutdownHandle;
@@ -875,19 +2207,91 @@ async function stageShutdown(input) {
         container, daemonLogger, daemonVersion, agents, adaptersByType, configPaths,
         db, secretStore, cachedPort, ttsAdapter, visionRegistry,
         startupStartMs, instanceId,
+        namespacePreflightOk, // Phase 211: the real probe result → emitAutonomyBootLog.
+    });
+    // 9.1. Boot invariant record + duplicate-wiring WARN.
+    // Emitted AFTER the startup banner so the INFO record follows the human-readable
+    // "Comis daemon started" line in log streams, and BEFORE saveLastKnownGood /
+    // DaemonInstance return so WARNs fire before the daemon accepts traffic.
+    // depSlotConsistency is passed explicitly — the daemon composition root is the
+    // only site that knows which adapter slots were used (channelRegistry
+    // only; adaptersList was removed from setup-channels-runtime.ts).
+    // Derive logsDir from daemon.logging.filePath for the startup sweep.
+    const _loggingFilePath = container.config.daemon?.logging?.filePath;
+    const _logsDir = _loggingFilePath
+        ? pathDirname(expandTilde(_loggingFilePath))
+        : undefined;
+    _healthAggRef.fn = emitStartupInvariants({
+        logger: daemonLogger,
+        adaptersByType,
+        rawHandlerCounts: channelManager?.getRawHandlerCounts() ?? new Map(),
+        channelPlugins: gateway.channelPlugins ?? new Map(),
+        pluginRegistry: container.pluginRegistry ?? { count: () => 0 },
+        mcpClientManager: mcpClientManager ?? { getTools: () => [] },
+        agentsConfig: agents,
+        depSlotConsistency: { adaptersList: false, channelRegistry: true },
+        logRotationPolicy: container.config.observability?.logRotation,
+        logsDir: _logsDir,
+        alertBudgetPolicy: container.config.observability?.alertBudget,
+        eventBus: container.eventBus,
     });
-    // Snapshot current config as last-known-good after successful startup
+    const posture = checkStorageModeConsistency({ logger: daemonLogger, activeMode: boot.container.config.security.storage, dataDir: boot.dataDir, secretsDb: boot.secretsDb });
+    // 9.2. I3 — config-posture SNAPSHOT (one-shot boot record, NOT an event).
+    // Records the three log-file-only posture FINDINGS — TLS-off, stranded-secret
+    // COUNTS, canary-fallback — as a single config_posture obs_diagnostics row so
+    // the fleet lens can query a daemon's posture without grepping daemon.log.
+    // TLS-off is CONFIG-DERIVED here, not read from the gateway's own TLS decision:
+    // `gateway.{tls,allowInsecureHttp}` is the INPUT the gateway acts on, but the
+    // gateway's resolved `tls ? https : http` branch (hono-server.ts) is internal
+    // and NOT exposed on GatewayServerHandle, and threading it back out is the deep
+    // cross-package plumbing this phase's KISS constraint forbids. This recompute
+    // matches the listener's posture today; it only diverges if the gateway gains a
+    // TLS path that bypasses config (an injected cert / env override) — a future
+    // change should thread the gateway's resolved boolean here (WR-02).
+    // canaryFallbackActive is a daemon-global presence proxy: CANARY_SECRET is
+    // folded into `boot.env`/mergedEnv store-wins (buildMergedEnv), so this env read
+    // already honors an encrypted/file secret-store entry — the same source the
+    // per-agent path resolves (setup-agents-runtime.ts). True ⇒ no secret set ⇒
+    // every agent uses the deterministic fallback. KISS — no deep per-agent plumbing.
+    // OBS-7 (openclaw-usecases 2026-06-25): TLS-off is a posture concern only on a
+    // NON-loopback bind. A loopback gateway has no off-host exposure, so flagging it
+    // made `fleet` headline `config_posture` (TLS-off) on a clean dev/loopback box —
+    // noise. The gate matches the gateway-exposure security check (only 0.0.0.0-without-
+    // TLS is critical). `gateway.host` defaults to 127.0.0.1, so a default daemon stays
+    // benign; an operator-set 0.0.0.0/routable host WITHOUT TLS still flags.
+    const tlsOff = boot.container.config.gateway.tls === undefined &&
+        boot.container.config.gateway.allowInsecureHttp !== true &&
+        !isLoopbackHost(boot.container.config.gateway.host);
+    const allowInsecureHttp = boot.container.config.gateway.allowInsecureHttp === true;
+    const canaryFallbackActive = !boot.env.get("CANARY_SECRET");
+    // KNOB-03: derived from the SAME boot comparisons the KNOB-01 WARN used (no second comparison).
+    const servedBelowConfiguredCount = [...(boot.servedWindowComparisons?.values() ?? [])].filter((c) => c.belowConfigured).length;
+    // RELAX-SURFACE (Track-M): surface the relaxed no-downgrade sandbox default at boot.
+    // The typed field defaults to true (schema-security.ts); === false is the relaxation.
+    const sandboxNoDowngradeDisabled = container.config.security.agentToAgent.sandboxNoDowngrade === false;
+    buildConfigPostureRecord(boot.obsStore, { tlsOff, allowInsecureHttp, strandedFindings: posture.findings, canaryFallbackActive, servedBelowConfiguredCount, chimericModelCount: countChimericModels(container.config.agents), pricingGapCount: countPricingGaps(container.config.agents), sandboxNoDowngradeDisabled }, boot.clock);
+    // Snapshot current config as last-known-good after successful startup.
+    // Honor diagnostics.configAudit.enabled.
+    // `!== false` semantics preserve the schema's default-true contract;
+    // operators who omit the knob or explicitly set true see the audit
+    // line; only `enabled: false` skips the JSONL append.
     if (configPaths.length > 0) {
         const activeConfigPath = configPaths[configPaths.length - 1];
-        const lkg = saveLastKnownGood(activeConfigPath);
+        const auditEnabled = container.config.diagnostics?.configAudit?.enabled !== false;
+        const lkg = saveLastKnownGood(activeConfigPath, auditEnabled);
         if (lkg.saved) {
             daemonLogger.debug({ lkgPath: lkg.path }, "Last-known-good config snapshot saved");
         }
     }
     return {
-        container, logger, logLevelManager, tokenTracker, latencyRecorder,
-        processMonitor, shutdownHandle, watchdogHandle, cronSchedulers, resetSchedulers,
+        container, logger, logLevelManager, tokenTracker,
+        processMonitor, shutdownHandle, cronSchedulers, resetSchedulers,
         browserServices, heartbeatRunner, gatewayHandle, adapterRegistry: adaptersByType,
+        // Expose the orchestrator ChannelManager so integration tests can drive a
+        // real inbound turn through the daemon's REAL pipeline deps
+        // (channelManager.injectMessage). Undefined when no channels are configured
+        // at boot — see DaemonInstance.channelManager doc.
+        channelManager,
         // Expose the delivery-queue-side adapter map and the queue port itself so
         // integration tests can register adapters that the recurring drainer sees
         // and assert on queue depth.
@@ -897,7 +2301,7 @@ async function stageShutdown(input) {
         // synthetic tasks and call complete()/fail() to drive the completion
         // runner pipeline without requiring a live LLM call.
         backgroundTaskManager,
-        rpcCall, deviceIdentity, diagnosticCollector, billingEstimator,
+        rpcCall, diagnosticCollector, billingEstimator,
         channelActivityTracker, deliveryTracer, approvalGate, channelHealthMonitor, sessionStoreBridge,
     };
 }
@@ -917,26 +2321,37 @@ export async function main(overrides = {}) {
     // instead of cascading into a systemd restart loop.
     const exitFn = overrides.exit ?? ((code) => process.exit(code));
     await (overrides.preflightDoctor ?? ((fn) => runPreflightDoctor(fn)))(exitFn);
+    // The 4-handle chain collapsed into a single BootContext that the 5
+    // boot* helpers populate in sequence. main() owns the single `boot`
+    // variable; helpers mutate it via Object.assign.
+    const boot = createEmptyBootContext();
     // Stage 1: foundation. Owns data-dir + secrets + bootstrap + logging +
     // observability + memory + obs-persistence + context store + session
     // mirroring + Gemini cache + background tasks + deferred refs.
-    const foundation = await stageFoundation({ overrides, startupStartMs, instanceId });
-    // Stage 2: agents. Owns agent executors + mcpClientManager + schedulers +
-    // media + RPC bridge + approval gate (with restore) + delivery queue.
-    const agents = await stageAgents({ overrides, foundation });
-    // Stage 3: channels. Owns channel adapters + notifications + bg completion
-    // runner + sandbox/image-gen + tools + cross-session + graph + monitoring +
-    // heartbeat + wake coalescer + agent runtime state.
-    const channels = await stageChannels({ agents });
-    // Stage 4: gateway. Owns token registry + session store bridge + shutdown
-    // ref slot + hot-add/hot-remove closures + RPC dispatch deps assembly +
-    // gateway server + restart continuation replay.
-    const gateway = await stageGateway({ overrides, channels, startupStartMs, instanceId });
-    // Stage 5: shutdown. Constructs shutdown handle, populates
-    // gateway.shutdownRef.value (cross-stage deferred-ref), wires health
-    // logging, emits the startup banner ("Comis daemon started"), and returns
-    // the DaemonInstance.
-    return await stageShutdown({ overrides, gateway, startupStartMs, instanceId });
+    await bootFoundation(boot, { overrides, startupStartMs, instanceId });
+    // Stages 2-5: wrapped so a failure in any post-foundation stage releases the
+    // singleton lock. Under normal boot, setupShutdown.onShutdown owns
+    // the release; this catch handles partial-boot failures before that fires.
+    try {
+        // Stage 2: agents. Owns agent executors + mcpClientManager + schedulers +
+        // media + RPC bridge + approval gate (with restore) + delivery queue.
+        await bootAgents(boot, { overrides });
+        // Stage 3: channels. Owns sandbox/image-gen + tools (HOISTED) + channel
+        // adapters + notifications + bg completion runner + cross-session + graph
+        // + monitoring + heartbeat + wake coalescer + agent runtime state.
+        await bootChannels(boot);
+        // Stage 4: gateway. Owns token registry + session store bridge + shutdown
+        // ref slot + hot-add/hot-remove closures + RPC dispatch deps assembly +
+        // gateway server + restart continuation replay.
+        await bootGateway(boot, { overrides, startupStartMs, instanceId });
+        // Stage 5: shutdown. Constructs shutdown handle, wires health logging,
+        // emits the startup banner ("Comis daemon started"), returns DaemonInstance.
+        return await bootShutdown(boot, { overrides, startupStartMs, instanceId });
+    }
+    catch (e) {
+        releaseDataDirLock(boot.dataDir);
+        throw e;
+    }
 }
 // Only run when invoked directly (not imported).
 // Under pm2, process.argv[1] is ProcessContainerFork.js — detect via pm_id env var.