@pellux/goodvibes-tui 1.25.0 → 1.27.0

package/src/runtime/services.ts

@@ -1,14 +1,10 @@
 import { join } from 'node:path';
 import { FocusTracker } from '../core/focus-tracker.ts';
-import { ConfigManager, ServiceRegistry, SubscriptionManager, ToolLLM } from '@pellux/goodvibes-sdk/platform/config';
-import { SecretsManager } from '../config/secrets.ts';
+import { ServiceRegistry, SubscriptionManager, ToolLLM } from '@pellux/goodvibes-sdk/platform/config';
 import { AutomationDeliveryManager, AutomationManager } from '@pellux/goodvibes-sdk/platform/automation';
-import { ChannelDeliveryRouter, ChannelPolicyManager, type ChannelPluginRegistry, type RouteBindingManager, type SurfaceRegistry } from '@pellux/goodvibes-sdk/platform/channels';
-import { ApprovalBroker, GatewayMethodCatalog, SessionLiveTurnControlsHolder, SharedSessionBroker } from '@pellux/goodvibes-sdk/platform/control-plane';
-import type { PowerManager } from '@pellux/goodvibes-sdk/platform/power';
+import { ChannelDeliveryRouter, ChannelPolicyManager } from '@pellux/goodvibes-sdk/platform/channels';
+import { ApprovalBroker, GatewayMethodCatalog, SharedSessionBroker } from '@pellux/goodvibes-sdk/platform/control-plane';
 import { wireIdlePowerAndLiveTurn } from './idle-power-services.ts';
-import { StepUpService } from '@pellux/goodvibes-sdk/daemon';
-import { PairingTokenManager } from '@pellux/goodvibes-sdk/platform/pairing';
 import { resolvePairingWebOrigin } from '../core/pairing-origin.ts';
 import { attachWsOnlyGatewayVerbHandlers } from '@pellux/goodvibes-terminal-shell';
 import { composeMailDeps } from './mail-composition.ts';
@@ -17,46 +13,35 @@ import { createDisposalScope, registerSurfaceRuntimePollers } from './disposal-w
 import { WatcherRegistry } from '@pellux/goodvibes-sdk/platform/watchers';
 import { ArtifactStore } from '@pellux/goodvibes-sdk/platform/artifacts';
 import { createWebKnowledgeGapRepairer } from '@pellux/goodvibes-sdk/platform/knowledge';
-import type { HomeGraphService, KnowledgeService, ProjectPlanningService } from '@pellux/goodvibes-sdk/platform/knowledge';
 import { createKnowledgeServices } from './knowledge-services.ts';
 import { MediaProviderRegistry, ensureBuiltinMediaProviders } from '@pellux/goodvibes-sdk/platform/media';
 import { MultimodalService } from '@pellux/goodvibes-sdk/platform/multimodal';
-import { AgentMessageBus, AgentOrchestrator, ArchetypeLoader, WrfcController } from '@pellux/goodvibes-sdk/platform/agents';
-import { AgentManager, ContextAccountingHolder, OverflowHandler, ProcessManager, cancelAllAgentRuns, createWorkflowServices, type WorkflowServices } from '@pellux/goodvibes-sdk/platform/tools';
-import { FileStateCache, FileUndoManager, MemoryConsolidationScheduler, MemoryEmbeddingProviderRegistry, MemoryRegistry, MemoryStore, ModeManager, ProjectIndex, resolveCanonicalMemoryDbPath, type CodeIndexStore, type CodeIndexReindexScheduler } from '@pellux/goodvibes-sdk/platform/state';
-import type { StoreSnapshotScheduler } from '@pellux/goodvibes-sdk/platform/state/store-snapshots';
-import type { UserPermissionRuleStore } from '@pellux/goodvibes-sdk/platform/permissions';
+import { OverflowHandler, ProcessManager, cancelAllAgentRuns, createWorkflowServices } from '@pellux/goodvibes-sdk/platform/tools';
+import { FileStateCache, FileUndoManager, MemoryEmbeddingProviderRegistry, MemoryRegistry, MemoryStore, ModeManager, ProjectIndex, resolveCanonicalMemoryDbPath } from '@pellux/goodvibes-sdk/platform/state';
 import { buildExecPromptAnswerHandler } from '@pellux/goodvibes-sdk/platform/runtime/permissions/exec-prompt-wiring';
 import { buildLocalhostFetchApproval } from '@pellux/goodvibes-sdk/platform/runtime/permissions/localhost-fetch-approval';
-import { createNotificationDispatcher, wireRuntimeNotificationBridge, wireMemoryPressureNotice, type NotificationDispatcher } from './notification-dispatch.ts';
+import { createNotificationDispatcher, wireRuntimeNotificationBridge, wireMemoryPressureNotice } from './notification-dispatch.ts';
 import { createDurabilityServices } from './durability-services.ts';
 import { MemorySpineClient, createLocalMemoryAccess } from '@pellux/goodvibes-sdk/platform/runtime/memory-spine';
-import { WorkspaceCheckpointManager } from '@pellux/goodvibes-sdk/platform/workspace';
 import { createWorkspaceCheckpointing } from './workspace-checkpointing.ts';
 import { createSessionConversationRewindPort } from './conversation-rewind-port.ts';
 import { createDomainDispatch } from './store/index.ts';
-import type { DomainDispatch, RuntimeStore } from './store/index.ts';
-import {
-  type RuntimeEventBus, DistributedRuntimeManager, RemoteRunnerRegistry, RemoteSupervisor, IntegrationHelperService,
-  IdempotencyStore, ComponentHealthMonitor, WorktreeRegistry, SandboxSessionRegistry, createShellPathService,
-  type ShellPathService, type FeatureFlagManager, createFeatureFlagManager, PolicyRuntimeState, type SessionSurface,
-} from '@/runtime/index.ts';
+import { DistributedRuntimeManager, IntegrationHelperService, IdempotencyStore, ComponentHealthMonitor, WorktreeRegistry, createShellPathService, createFeatureFlagManager, PolicyRuntimeState } from '@/runtime/index.ts';
 import { createSessionStorageServices } from './session-storage-services.ts';
 import { VoiceProviderRegistry, VoiceService, ensureBuiltinVoiceProviders } from '@pellux/goodvibes-sdk/platform/voice';
-import { CacheRegistry, PauseController, type MemoryGovernor } from '@pellux/goodvibes-sdk/platform/runtime/memory';
+import { CacheRegistry, PauseController } from '@pellux/goodvibes-sdk/platform/runtime/memory';
 import { wireMemoryGovernance } from './memory-governance-services.ts';
 import { wireVoiceSetup } from './voice-setup-services.ts';
 import { WebSearchProviderRegistry, WebSearchService } from '@pellux/goodvibes-sdk/platform/web-search';
 import { PanelManager } from '../panels/panel-manager.ts';
 import { HookActivityTracker } from '@pellux/goodvibes-sdk/platform/hooks';
-import { HookDispatcher, createHookWorkbench, type HookWorkbench } from '@pellux/goodvibes-sdk/platform/hooks';
+import { HookDispatcher, createHookWorkbench } from '@pellux/goodvibes-sdk/platform/hooks';
 import { PluginManager } from '@pellux/goodvibes-sdk/platform/plugins';
 import { BookmarkManager } from '@pellux/goodvibes-sdk/platform/bookmarks';
 import { ProfileManager } from '@pellux/goodvibes-sdk/platform/profiles';
-import { SessionManager, CrossSessionTaskRegistry, SessionChangeTracker } from '@pellux/goodvibes-sdk/platform/sessions';
+import { CrossSessionTaskRegistry, SessionChangeTracker } from '@pellux/goodvibes-sdk/platform/sessions';
 import { ApiTokenAuditor, UserAuthManager } from '@pellux/goodvibes-sdk/platform/security';
 import { WebhookNotifier } from '@pellux/goodvibes-sdk/platform/integrations';
-import { McpRegistry } from '@pellux/goodvibes-sdk/platform/mcp';
 import { createRemoteExecutionServices } from './remote-execution-composition.ts';
 import { createAgentGraph } from './agent-graph-composition.ts';
 import { BenchmarkStore, CacheHitTracker, FavoritesStore, ModelLimitsService, ProviderCapabilityRegistry, ProviderOptimizer, ProviderRegistry } from '@pellux/goodvibes-sdk/platform/providers';
@@ -65,192 +50,20 @@ import { AdaptivePlanner, DeterministicReplayEngine, ExecutionPlanManager, Sessi
 import { deriveFeatureStates, bindFeatureSettingsBridge } from '@pellux/goodvibes-sdk/platform/runtime/state';
 import { createChannelComposition } from './channel-composition.ts';
 import { applyProviderOptimizerConfigMode, bindProviderOptimizerFeatureFlag } from './provider-optimizer-wiring.ts';
-import { type ArchivableProcessRegistry } from '@pellux/goodvibes-sdk/platform/runtime/fleet';
 import { createFleetServices } from './fleet-services.ts';
-import { createWorkstreamServices, type OrchestrationEngine, type WorkstreamCommandService } from './workstream-services.ts';
+import { createWorkstreamServices } from './workstream-services.ts';
 import { wireFleetNeedsInputPush } from './fleet-needs-input-push.ts';
 import { codeIndexDbPath, createCodeIndexServices, createStoreRerooter, isCodeInjectionSettingEnabled } from './code-index-services.ts';
-import type { WorkPlanStore } from '../work-plans/work-plan-store.ts';
-import type { DaemonHandlerSurfaces } from '../daemon/handlers/index.ts';
 import { createDaemonHandlerComposition } from './daemon-handler-composition.ts';
-import { createClusterServices, startClusterServices, type ClusterGroupComposition } from './cluster-group-composition.ts';
-import type { ClusterCoordinator } from '@pellux/goodvibes-sdk/platform/cluster';
+import { createDevicePostureServices } from './device-posture-composition.ts';
+// Re-exported so the shell's bootstrap reaches the install through the same
+// module it already imports the runtime graph from.
+export { installDevicePosture } from './device-posture-composition.ts';
+import { createClusterServices, startClusterServices } from './cluster-group-composition.ts';
 import { WorkspaceTrustManager } from './trust/workspace-trust.ts';
 import { ensureConfiguredModelIsRoutable } from './provider-fallback.ts';
-
-export interface RuntimeServicesOptions {
-  readonly runtimeBus: RuntimeEventBus;
-  readonly runtimeStore: RuntimeStore;
-  readonly configManager: ConfigManager;
-  readonly localUserAuthManager?: UserAuthManager;
-  readonly featureFlags?: FeatureFlagManager;
-  readonly getConversationTitle?: () => string | undefined;
-  readonly workingDir: string;
-  readonly homeDirectory: string;
-  /** Daemon state root (`--daemon-home`); absent ⇒ `<homeDirectory>/.goodvibes/daemon`.
-   * Threaded into SecretsManager so the override MOVES the credential store —
-   * without it an "isolated" daemon read the real home's secrets. One name for
-   * one thing; resolveGoodVibesHomeOwnership is the single reader. */
-  readonly daemonHomeDirectory?: string | undefined;
-  /** Opt-in (daemon-side only): fold host-observed external coding-agent sessions
-   * into the fleet as 'observed-external' rows. Interactive leaves it off and reads
-   * the daemon snapshot. Mirrors the SDK's own createRuntimeServices option. */
-  readonly observeExternalAgents?: boolean | undefined;
-  /** Host power seam opt-in. Fork mirrors the SDK: non-spawning unavailable-seam
-   * default (idle-power-services.ts); daemon + embedded runtime pass createHostPowerSeam(). */
-  readonly powerSeam?: Parameters<typeof wireIdlePowerAndLiveTurn>[0]['powerSeam'];
-  /** Live session id, read per crash-residue sweep so the running session is exempt — see durability-services.ts. */
-  readonly currentSessionId?: (() => string | null) | undefined;
-}
-
-export interface RuntimeServices {
-  readonly workingDirectory: string;
-  readonly homeDirectory: string;
-  /** The declare-once session-storage handle every session reader and writer threads through — see session-storage-services.ts. */
-  readonly surface: SessionSurface;
-  readonly shellPaths: ShellPathService;
-  readonly configManager: ConfigManager;
-  readonly featureFlags: FeatureFlagManager;
-  readonly runtimeBus: RuntimeEventBus;
-  readonly runtimeStore: RuntimeStore;
-  readonly runtimeDispatch: DomainDispatch;
-  readonly panelManager: PanelManager;
-  readonly keybindingsManager: KeybindingsManager;
-  readonly routeBindings: RouteBindingManager;
-  readonly surfaceRegistry: SurfaceRegistry;
-  readonly channelPlugins: ChannelPluginRegistry;
-  readonly channelDeliveryRouter: ChannelDeliveryRouter;
-  readonly watcherRegistry: WatcherRegistry;
-  readonly approvalBroker: ApprovalBroker;
-  /** Loopback-fetch approval that rides the approval broker; shared by the tool registry and orchestrator so every surface asks the same way. */
-  readonly localhostFetchApproval: ReturnType<typeof buildLocalhostFetchApproval>;
-  /** Terminal prompt-answer handler that rides the approval broker; shared by the tool registry and orchestrator so an interactive command's prompt gets an ask/card on every surface. */
-  readonly execPromptAnswerHandler: ReturnType<typeof buildExecPromptAnswerHandler>;
-  /** Routes curated runtime-domain events into the panel_only notification feed (the panel's live producer). */
-  readonly notificationDispatcher: NotificationDispatcher;
-  /** Durable user-origin permission rules (remembered approvals); permissions.rules.* surface. Mirrors the SDK composition. */
-  readonly userPermissionRuleStore: UserPermissionRuleStore;
-  readonly sessionBroker: SharedSessionBroker;
-  readonly deliveryManager: AutomationDeliveryManager;
-  readonly automationManager: AutomationManager;
-  readonly gatewayMethods: GatewayMethodCatalog;
-  readonly artifactStore: ArtifactStore;
-  readonly knowledgeService: KnowledgeService;
-  readonly agentKnowledgeService: KnowledgeService;
-  readonly homeGraphService: HomeGraphService;
-  readonly projectPlanningService: ProjectPlanningService;
-  readonly projectPlanningProjectId: string;
-  readonly workPlanStore: WorkPlanStore;
-  readonly memoryStore: MemoryStore;
-  readonly memoryRegistry: MemoryRegistry;
-  /** Host-vs-client memory access: local until bootstrap.ts activates it for an adopted 'external' daemon (mirrors sessionSpine). */
-  readonly memorySpine: MemorySpineClient;
-  readonly serviceRegistry: ServiceRegistry;
-  readonly secretsManager: SecretsManager;
-  readonly stepUpService: StepUpService;
-  readonly pairingTokens: PairingTokenManager; // backs pairing.tokens.* verbs + the settings device surface (mirrors the SDK composition)
-  readonly subscriptionManager: SubscriptionManager;
-  readonly localUserAuthManager: UserAuthManager;
-  readonly profileManager: ProfileManager;
-  readonly bookmarkManager: BookmarkManager;
-  readonly sessionManager: SessionManager;
-  readonly sessionOrchestration: CrossSessionTaskRegistry;
-  readonly hookDispatcher: HookDispatcher;
-  readonly hookActivityTracker: HookActivityTracker;
-  readonly hookWorkbench: HookWorkbench;
-  readonly pluginManager: PluginManager;
-  readonly workflow: WorkflowServices;
-  readonly voiceProviders: VoiceProviderRegistry;
-  readonly voiceService: VoiceService;
-  readonly webSearchProviders: WebSearchProviderRegistry;
-  readonly webSearchService: WebSearchService;
-  readonly mediaProviders: MediaProviderRegistry;
-  readonly multimodalService: MultimodalService;
-  readonly memoryEmbeddingRegistry: MemoryEmbeddingProviderRegistry;
-  readonly channelPolicy: ChannelPolicyManager;
-  readonly mcpRegistry: McpRegistry;
-  readonly tokenAuditor: ApiTokenAuditor;
-  readonly componentHealthMonitor: ComponentHealthMonitor;
-  readonly worktreeRegistry: WorktreeRegistry;
-  readonly sandboxSessionRegistry: SandboxSessionRegistry;
-  readonly webhookNotifier: WebhookNotifier;
-  /** Terminal focus tracker — fed by input/handler-feed.ts, read by the alert notifiers in core/. */
-  readonly focusTracker: FocusTracker;
-  readonly replayEngine: DeterministicReplayEngine;
-  readonly providerOptimizer: ProviderOptimizer;
-  readonly providerCapabilityRegistry: ProviderCapabilityRegistry;
-  readonly cacheHitTracker: CacheHitTracker;
-  readonly favoritesStore: FavoritesStore;
-  readonly benchmarkStore: BenchmarkStore;
-  readonly modelLimitsService: ModelLimitsService;
-  readonly providerRegistry: ProviderRegistry;
-  readonly toolLLM: ToolLLM;
-  readonly distributedRuntime: DistributedRuntimeManager;
-  readonly daemonHandlers: DaemonHandlerSurfaces;
-  /** Elects the one node on this network that consumes inbound messages; hand it to the DaemonServer so its consumers share this leadership instead of holding a second election. */
-  readonly clusterCoordinator: ClusterCoordinator;
-  /** LAN group membership: identity, keys, roster, and the `cluster` verbs. */
-  readonly clusterGroup: ClusterGroupComposition;
-  /** Start the group layer and then the election, in that order. Idempotent. */
-  readonly startCluster: () => Promise<void>;
-  readonly remoteRunnerRegistry: RemoteRunnerRegistry;
-  readonly remoteSupervisor: RemoteSupervisor;
-  readonly sessionMemoryStore: SessionMemoryStore;
-  readonly sessionLineageTracker: SessionLineageTracker;
-  readonly sessionChangeTracker: SessionChangeTracker;
-  readonly planManager: ExecutionPlanManager;
-  readonly adaptivePlanner: AdaptivePlanner;
-  readonly idempotencyStore: IdempotencyStore;
-  readonly overflowHandler: OverflowHandler;
-  readonly policyRuntimeState: PolicyRuntimeState;
-  readonly archetypeLoader: ArchetypeLoader;
-  readonly agentManager: AgentManager;
-  readonly agentMessageBus: AgentMessageBus;
-  readonly agentOrchestrator: AgentOrchestrator;
-  readonly contextAccountingHolder: ContextAccountingHolder; // bound at bootstrap.ts; see context-accounting-source.ts
-  readonly wrfcController: WrfcController;
-  readonly processManager: ProcessManager;
-  /** The phase/work-item orchestration engine — see runtime/workstream-services.ts. */
-  readonly orchestrationEngine: OrchestrationEngine;
-  readonly workstreamCommands: WorkstreamCommandService;
-  /** The repo source-tree code index — see runtime/code-index-services.ts. */
-  readonly codeIndexStore: CodeIndexStore;
-  readonly codeIndexReindexScheduler: CodeIndexReindexScheduler; // tool-site reindex
-  /** Daily snapshots of every SQLite store this runtime writes, with bounded retention; unref'd timers (mirrors the SDK composition — hosts that tear down a runtime stop() it themselves). */
-  readonly storeSnapshotScheduler: StoreSnapshotScheduler;
-  readonly appendOnlyRetentionScheduler: ReturnType<typeof createDurabilityServices>['appendOnlyRetentionScheduler']; // periodic append-only sweep; unref'd timers, stop() on teardown
-  /** Stops the recurring crash-residue sweep; idempotent, unref'd timer (hosts that tear a runtime down call it). */
-  readonly stopDurabilityHousekeeping: () => void;
-  readonly memoryConsolidationScheduler: MemoryConsolidationScheduler;
-  readonly powerManager: PowerManager;
-  /** The daemon's memory governor (default ON). Backs ops.memory.get and defends the daemon's footprint by tier. */
-  readonly memoryGovernor: MemoryGovernor;
-  /** Registry of every retained cache the governor can shrink (knowledge stores + shared session broker). */
-  readonly cacheRegistry: CacheRegistry;
-  /** Controller the governor uses to pause/resume the deferrable background jobs under pressure. */
-  readonly pauseController: PauseController;
-  readonly sessionLiveTurnControls: SessionLiveTurnControlsHolder;
-  /** Unified live process registry (agents, WRFC chains, workflows, watchers, background processes) backing the Fleet panel; archive-aware — finished subtrees can be moved to the session archive view. */
-  readonly processRegistry: ArchivableProcessRegistry;
-  readonly modeManager: ModeManager;
-  readonly fileUndoManager: FileUndoManager;
-  readonly workspaceCheckpointManager: WorkspaceCheckpointManager;
-  /** Per-workspace trust gate — restricts write/execute/delegate tools until the workspace is trusted. */
-  readonly workspaceTrustManager: WorkspaceTrustManager;
-  readonly integrationHelpers: IntegrationHelperService;
-  /** Re-root path-bound stores (MemoryStore, ProjectIndex) to a new working directory, called by WorkspaceSwapManager after verification; stores needing a process restart just warn-log and keep serving the old path until the daemon restarts with the new --working-dir. */
-  rerootStores(newWorkingDir: string): Promise<void>;
-  /**
-   * Cancel the agent runs this graph is hosting, returning how many.
-   *
-   * Required by the SDK's RuntimePollerOwners: by dispose() time the fleet
-   * registry, orchestration engine, process registry and bus these runs report
-   * through are already down, so a run still described as "running" is orphaned
-   * rather than preserved.
-   */
-  cancelHostedAgentRuns(): number;
-  dispose(): void; // Stop every poller this graph started; best-effort, total, idempotent. This surface owns its graph — see disposal-wiring.ts.
-}
+import type { RuntimeServicesOptions, RuntimeServices } from './runtime-services-types.ts';
+export type { RuntimeServicesOptions, RuntimeServices } from './runtime-services-types.ts';
 
 export function createRuntimeServices(options: RuntimeServicesOptions): RuntimeServices {
   const disposalScope = createDisposalScope('RuntimeServices'); const workingDirectory = options.workingDir; // disposal seam: see ./disposal-wiring.ts
@@ -350,8 +163,24 @@ export function createRuntimeServices(options: RuntimeServicesOptions): RuntimeS
     join(surface.sessionsDir, 'task-graph.json'),
   );
   const hookActivityTracker = new HookActivityTracker();
+  // featureFlags is REQUIRED here in practice, even though the SDK types it
+  // optional. isFeatureGateEnabled(null, ...) is permissive by design — a
+  // narrow embed with no manager wired gets the capability rather than a
+  // silent off — so omitting it did not disable the watcher framework when
+  // watchers.enabled is turned off; it made the setting configure nothing.
+  // Threading it preserves current effective behaviour rather than changing
+  // it: watchers.enabled defaults true, the watcher-framework flag's own
+  // defaultState is 'enabled', and the flag declares no notOperable record —
+  // so with nothing configured the gate reads exactly as before, and the
+  // difference is only that turning it OFF now turns it off. This composes
+  // with bootstrap-core.ts's own `if (configManager.get('watchers.enabled'))`
+  // check around the built-in polling watcher registration: that check reads
+  // the same key, so the two never disagree, and this fix only reaches the
+  // watcher registry's OTHER entry points (registerWatcher/startWatcher/etc.)
+  // that bootstrap-core.ts's narrower check does not cover.
   const watcherRegistry = new WatcherRegistry({
     storePath: shellPaths.resolveProjectPath('tui', 'watchers.json'),
+    featureFlags,
   });
   watcherRegistry.attachRuntime({
     runtimeStore: options.runtimeStore,
@@ -414,6 +243,15 @@ export function createRuntimeServices(options: RuntimeServicesOptions): RuntimeS
   // modal): bootstrap.ts activates the wire transport when a compatible
   // external daemon is adopted, same signal as the session spine.
   const memorySpine = new MemorySpineClient({ local: createLocalMemoryAccess(memoryRegistry) });
+  // featureFlags is REQUIRED here in practice, even though the SDK types it
+  // optional. isFeatureGateEnabled(null, ...) is permissive by design, so
+  // omitting it did not disable delivery tracking when
+  // integrations.deliveryTracking is turned off — it made the setting
+  // configure nothing: deliverText/deliverJobRun kept running either way.
+  // Threading it preserves current effective behaviour rather than changing
+  // it: the config default is true, the delivery-engine flag's own
+  // defaultState is 'enabled', and the flag declares no notOperable record —
+  // so with nothing configured the gate reads exactly as before.
   const deliveryManager = new AutomationDeliveryManager({
     configManager,
     // This manager builds the delivery router the daemon actually replies
@@ -427,7 +265,20 @@ export function createRuntimeServices(options: RuntimeServicesOptions): RuntimeS
     runtimeStore: options.runtimeStore,
     routeBindings,
     artifactStore,
+    featureFlags,
   });
+  // Same shape as deliveryManager above: automation.enabled defaults true,
+  // the automation-domain flag's own defaultState is 'enabled', so threading
+  // featureFlags here does not change what a default install does — it only
+  // makes turning automation.enabled off actually turn AutomationManager's own
+  // create/update/run/list surface off. This composes with bootstrap.ts's own
+  // `if (configManager.get('automation.enabled'))` gate around scheduling
+  // automationManager.start(): that check reads the same key, and
+  // AutomationManager.start() re-checks the same gate internally (it no-ops
+  // and stops rather than starting when disabled), so the two can never
+  // disagree — this fix only reaches the manager's OTHER entry points
+  // (createJob/updateJob/runNow/etc.) that the bootstrap.ts gate does not
+  // cover, the same way watchers.enabled and the watcher registry above do.
   const automationManager = new AutomationManager({
     configManager,
     defaultSurfaceKind: 'tui',
@@ -439,6 +290,7 @@ export function createRuntimeServices(options: RuntimeServicesOptions): RuntimeS
     // Same live registry: a bare model id on an automation job resolves through
     // the shared resolver instead of a format-only rejection.
     providerRegistry,
+    featureFlags,
     spawnTask: (input) => {
       const record = agentManager.spawn({
         mode: 'spawn',
@@ -500,6 +352,16 @@ export function createRuntimeServices(options: RuntimeServicesOptions): RuntimeS
     approvalBridge: approvalBroker,
     automationBridge: automationManager,
   });
+  // The paired-phone feature for this host, on the SAME runtime phones pair onto
+  // and the SAME approval broker every other confirmation rides. Every `device.*`
+  // setting is read live through this; see device-posture-composition.ts.
+  const { devicePosture } = createDevicePostureServices({
+    configManager,
+    distributedRuntime,
+    approvals: approvalBroker,
+    stateDirectory: shellPaths.resolveProjectPath('tui', 'devices'),
+    gatewayMethods,
+  });
 
   // Which machines on this network are "us", and which of them reads the
   // shared inbox. Both inert until startCluster() — no socket, no key material
@@ -525,7 +387,18 @@ export function createRuntimeServices(options: RuntimeServicesOptions): RuntimeS
     = createRemoteExecutionServices({
       agentManager, workingDirectory, hookDispatcher, configManager, runtimeBus: options.runtimeBus,
     });
-  const tokenAuditor = new ApiTokenAuditor({ managed: false });
+  // featureFlags is REQUIRED here in practice, even though the SDK types it
+  // optional. isFeatureGateEnabled(null, ...) is permissive by design, so
+  // omitting it did not disable managed blocking when
+  // security.tokenAudit.enabled is turned off. Threading it preserves current
+  // effective behaviour rather than changing it: managed is hardcoded false
+  // here (advisory reporting only; excess-scope/overdue tokens are reported,
+  // never blocked, regardless of this flag — see isBlocked()'s
+  // `this._config.managed && this._managedBlockingEnabled()` guard), the
+  // config default for security.tokenAudit.enabled is true, and the
+  // token-scope-rotation-audit flag's own defaultState is 'enabled' — so with
+  // nothing configured the gate reads exactly as before either way.
+  const tokenAuditor = new ApiTokenAuditor({ managed: false, featureFlags });
   const componentHealthMonitor = new ComponentHealthMonitor();
   const worktreeRegistry = new WorktreeRegistry(workingDirectory);
   const webhookNotifier = new WebhookNotifier();
@@ -577,7 +450,15 @@ export function createRuntimeServices(options: RuntimeServicesOptions): RuntimeS
     runtimeBus: options.runtimeBus,
     observeExternalAgents: options.observeExternalAgents, providerRegistry, // observeExternalAgents is daemon-side only
   });
-  const modeManager = new ModeManager(); const fileUndoManager = new FileUndoManager();
+  // featureFlags is REQUIRED here in practice, even though the SDK types it
+  // optional. isFeatureGateEnabled(null, ...) is permissive by design, so
+  // omitting it did not disable the HITL UX mode system when
+  // behavior.hitlMode is set to 'off' — setHITLMode/setDomainVerbosity kept
+  // accepting writes either way. Threading it preserves current effective
+  // behaviour rather than changing it: behavior.hitlMode defaults to
+  // 'balanced' (not 'off'), and the hitl-ux-modes flag's own defaultState is
+  // 'enabled' — so with nothing configured the gate reads exactly as before.
+  const modeManager = new ModeManager({ featureFlags }); const fileUndoManager = new FileUndoManager();
   const workspaceCheckpointManager = createWorkspaceCheckpointing({ workspaceRoot: workingDirectory, surface, runtimeBus: options.runtimeBus, configManager });
   // memory-consolidation honors governor backpressure: it ticks only when idle
   // AND the 'memory-consolidation' job is not paused AND expensive work is
@@ -605,7 +486,11 @@ export function createRuntimeServices(options: RuntimeServicesOptions): RuntimeS
 
   // Managed local-voice provisioning (voice.local.status/install) — single-flight
   // one-act install + no-network status; see voice-setup-services.ts.
-  const { voiceSetup } = wireVoiceSetup({ configManager, shellPaths, voiceProviders, admitExpensiveWork });
+  const { voiceSetup, stopWakeHousekeeping } = wireVoiceSetup({ configManager, shellPaths, voiceProviders, admitExpensiveWork,
+    // Boot provisioning of the wake-word model + its recovery sweep, opted into
+    // by the real entrypoints only (same treatment as powerSeam) so a one-shot
+    // CLI command and a test composing this graph fetch nothing and start no timer.
+    provisionWakeModelsAtBoot: options.provisionWakeModelsAtBoot === true });
 
   // Terminal-shell wrapper over the SDK registerGatewayVerbGroups (gateway-verbs.ts); checkin.*/fleet-needs-input/pairing.* register only when their deps are present. memoryGovernor lights up ops.memory.get; voiceSetup lights up voice.local.status/install.
   // calendar.*/email.* are platform-served; these two let it register (mail-composition.ts).
@@ -743,6 +628,7 @@ export function createRuntimeServices(options: RuntimeServicesOptions): RuntimeS
     providerRegistry,
     toolLLM,
     distributedRuntime,
+    devicePosture,
     daemonHandlers,
     clusterCoordinator,
     clusterGroup,
@@ -768,7 +654,7 @@ export function createRuntimeServices(options: RuntimeServicesOptions): RuntimeS
     workstreamCommands,
     codeIndexStore,
     codeIndexReindexScheduler,
-    storeSnapshotScheduler, appendOnlyRetentionScheduler, stopDurabilityHousekeeping,
+    storeSnapshotScheduler, appendOnlyRetentionScheduler, stopDurabilityHousekeeping, stopWakeHousekeeping,
     memoryConsolidationScheduler,
     powerManager,
     memoryGovernor,

package/src/runtime/voice-setup-services.ts

@@ -23,30 +23,76 @@ import {
   createVoiceSetupService,
   type VoiceSetupService,
 } from '@pellux/goodvibes-sdk/platform/runtime/voice-setup';
-import type { VoiceProviderRegistry } from '@pellux/goodvibes-sdk/platform/voice';
+import {
+  startWakeBootProvisioning,
+  type VoiceProviderRegistry,
+} from '@pellux/goodvibes-sdk/platform/voice';
 import type { ConfigManager } from '@pellux/goodvibes-sdk/platform/config';
+import { logger } from '@pellux/goodvibes-sdk/platform/utils';
 import type { ShellPathService } from '@/runtime/index.ts';
 
 export type { VoiceSetupService };
 
+/**
+ * The recovery act this surface names when a boot provision degrades. The SDK
+ * would otherwise name the control-plane verb, which is correct everywhere and
+ * useless to someone sitting in a terminal.
+ */
+export const WAKE_RECOVERY_COMMAND = '/voice wake setup';
+
 export interface VoiceSetupServicesDeps {
   readonly configManager: ConfigManager;
   readonly shellPaths: Pick<ShellPathService, 'resolveUserPath'>;
   readonly voiceProviders: VoiceProviderRegistry;
   /** Critical-tier admission gate — a provision run allocates archive + model buffers. */
   readonly admitExpensiveWork: (label: string) => { allowed: boolean; reason?: string | undefined };
+  /**
+   * Opt into boot-time wake-model provisioning and the recovery sweeper.
+   *
+   * Off unless a real entrypoint asks for it, matching how this graph treats the
+   * host power seam: `daemon/cli.ts` and `runtime/bootstrap-core.ts` opt in, the
+   * one-shot CLI commands do not, and a test composing the graph gets neither a
+   * network fetch nor a repeating timer it did not ask for.
+   */
+  readonly provisionWakeModelsAtBoot?: boolean | undefined;
+  /** Injected in tests: the boot starter, so no sweeper and no fetch are real. */
+  readonly startBootProvisioning?: typeof startWakeBootProvisioning | undefined;
+}
+
+export interface VoiceSetupServices {
+  readonly voiceSetup: VoiceSetupService;
+  /**
+   * Stop the wake-word recovery sweeper and cancel a pending boot provision.
+   * A no-op when boot provisioning was not opted into. Registered on the
+   * disposal scope (disposal-wiring.ts) — an hourly timer nothing stops is a
+   * poller this surface leaked, which is exactly what that scope exists for.
+   */
+  readonly stopWakeHousekeeping: () => void;
 }
 
 /** Compose the managed-voice single-flight install + no-network status read. */
-export function wireVoiceSetup(deps: VoiceSetupServicesDeps): { voiceSetup: VoiceSetupService } {
+export function wireVoiceSetup(deps: VoiceSetupServicesDeps): VoiceSetupServices {
   const { configManager, voiceProviders } = deps;
+  const managedVoiceRoot = deps.shellPaths.resolveUserPath('voice');
   const voiceSetup = createVoiceSetupService({
-    managedVoiceRoot: deps.shellPaths.resolveUserPath('voice'),
+    managedVoiceRoot,
     getConfig: (key) => String(configManager.get(key as Parameters<typeof configManager.get>[0]) ?? ''),
     setConfig: (key, value) => configManager.setDynamic(key as Parameters<typeof configManager.setDynamic>[0], value),
     // A successful (re-)install clears any tripped local-engine breaker.
     resetLocalEngineFailureState: () => voiceProviders.get('local')?.resetEngineFailureState?.(),
     admitExpensiveWork: deps.admitExpensiveWork,
   });
-  return { voiceSetup };
+  if (deps.provisionWakeModelsAtBoot !== true) {
+    return { voiceSetup, stopWakeHousekeeping: () => {} };
+  }
+  // Sweep the wake tree, then fetch whatever the install could not. The SDK owns
+  // the policy — never throws, one plain message, reaps before it retries — and
+  // routes the attempt through the setup service's single flight so a boot
+  // attempt and a user typing /voice wake setup are one download.
+  const boot = (deps.startBootProvisioning ?? startWakeBootProvisioning)({
+    managedRoot: managedVoiceRoot,
+    ensureProvisioned: () => voiceSetup.wakeEnsureProvisioned({ recoveryHint: WAKE_RECOVERY_COMMAND }),
+    announce: (message) => { logger.info(message); },
+  });
+  return { voiceSetup, stopWakeHousekeeping: () => boot.stop() };
 }

package/src/shell/voice-capture-shell.ts

@@ -0,0 +1,69 @@
+/**
+ * voice-capture-shell.ts — the shell's side of microphone capture.
+ *
+ * Extracted from main() for the same reason the process-lifecycle wiring was:
+ * the entrypoint is a wiring file held under a source-line gate, and new shell
+ * composition gets its own module and a single call there.
+ *
+ * What this owns is only the shell-facing half — where a transcript lands (the
+ * composer draft, through the same public `prompt`/`cursorPos` fields the
+ * external-editor path writes), how a turn is submitted, which keybinding seam
+ * the Alt+V action hangs off, and the teardown registration that guarantees a
+ * live recorder subprocess dies with the process. Everything about audio itself
+ * lives in src/audio/voice-capture-wiring.ts, which must not (and does not)
+ * import shell-UI.
+ */
+
+import type { ConfigManager } from '@pellux/goodvibes-sdk/platform/config';
+import type { CommandContext } from '../input/command-registry.ts';
+import type { ShellPathService } from '@/runtime/index.ts';
+import type { VoiceCaptureIndicatorState } from '../core/voice-capture-status.ts';
+import { wireVoiceCapture } from '../audio/voice-capture-wiring.ts';
+
+export interface VoiceCaptureShellDeps {
+  readonly configManager: ConfigManager;
+  readonly shellPaths: Pick<ShellPathService, 'resolveUserPath'>;
+  readonly homeDirectory: string | (() => string);
+  /** Names retained wake clips so the SDK's sweeper reaps them when this session ends. */
+  readonly sessionId: string;
+  /** The Alt+V seam is hung here (commandContext.toggleVoiceInput). */
+  readonly commandContext: CommandContext;
+  /** The shell's teardown registry; the device release is appended to it. */
+  readonly unsubs: Array<() => void>;
+  /** The live composer buffer — InputHandler exposes public `prompt`/`cursorPos`. */
+  readonly buffer: { prompt: string; cursorPos: number };
+  readonly submitInput: (text: string) => void;
+  readonly notify: (message: string) => void;
+  readonly render: () => void;
+}
+
+/**
+ * Compose voice capture and hand back the footer-row reader.
+ *
+ * Opens no device: wake detection consults `voice.wake.*` and refuses without
+ * touching the capture opener when it is off, and push-to-talk opens one only on
+ * a keypress.
+ */
+export function installVoiceCapture(deps: VoiceCaptureShellDeps): () => VoiceCaptureIndicatorState | null {
+  const capture = wireVoiceCapture({
+    configManager: deps.configManager,
+    // The same managed root `/voice setup` uses; the wake tree is `<root>/wake`.
+    managedVoiceRoot: deps.shellPaths.resolveUserPath('voice'),
+    // Surface-scoped: the extracted onnxruntime assets belong to this surface's
+    // own directory, beside its other managed state.
+    assetDirectory: deps.shellPaths.resolveUserPath('tui', 'onnxruntime'),
+    homeDirectory: deps.homeDirectory,
+    sessionId: deps.sessionId,
+    writeDraft: (text) => {
+      deps.buffer.prompt = text;
+      deps.buffer.cursorPos = text.length;
+      deps.render();
+    },
+    submitTurn: (text) => deps.submitInput(text),
+    notify: deps.notify,
+    render: deps.render,
+  });
+  deps.commandContext.toggleVoiceInput = capture.toggleVoiceInput;
+  deps.unsubs.push(...capture.unsubs);
+  return capture.status;
+}