@pellux/goodvibes-tui 1.17.0 → 1.19.0

package/src/runtime/services.ts

@@ -4,33 +4,28 @@ import { ConfigManager, ServiceRegistry, SubscriptionManager, ToolLLM } from '@p
 import { SecretsManager } from '../config/secrets.ts';
 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, SharedSessionBroker } from '@pellux/goodvibes-sdk/platform/control-plane';
+import { ApprovalBroker, GatewayMethodCatalog, SessionLiveTurnControlsHolder, SharedSessionBroker } from '@pellux/goodvibes-sdk/platform/control-plane';
+import type { PowerManager } from '@pellux/goodvibes-sdk/platform/power';
+import { wireIdlePowerAndLiveTurn } from './idle-power-services.ts';
 import { StepUpService } from '@pellux/goodvibes-sdk/daemon';
-import { attachWsOnlyGatewayVerbHandlers, createArchivableFleetRegistry } from '@pellux/goodvibes-terminal-shell';
+import { PairingTokenManager } from '@pellux/goodvibes-sdk/platform/pairing';
+import { resolvePairingWebOrigin } from '../core/pairing-origin.ts';
+import { attachWsOnlyGatewayVerbHandlers } from '@pellux/goodvibes-terminal-shell';
 import { WatcherRegistry } from '@pellux/goodvibes-sdk/platform/watchers';
 import { ArtifactStore } from '@pellux/goodvibes-sdk/platform/artifacts';
-import {
-  HomeGraphService,
-  GOODVIBES_AGENT_KNOWLEDGE_DB_FILE,
-  HOME_GRAPH_KNOWLEDGE_EXTENSION,
-  KnowledgeService,
-  KnowledgeSemanticService,
-  KnowledgeStore,
-  ProjectPlanningService,
-  createProviderBackedKnowledgeSemanticLlm,
-  createWebKnowledgeGapRepairer,
-  projectPlanningProjectIdFromPath,
-} from '@pellux/goodvibes-sdk/platform/knowledge';
+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, createWorkflowServices, type WorkflowServices } from '@pellux/goodvibes-sdk/platform/tools';
-import { FileStateCache, FileUndoManager, MemoryEmbeddingProviderRegistry, MemoryRegistry, MemoryStore, ModeManager, ProjectIndex, resolveCanonicalMemoryDbPath, type CodeIndexStore, type CodeIndexReindexScheduler } from '@pellux/goodvibes-sdk/platform/state';
+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 { 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, type NotificationDispatcher } from './notification-dispatch.ts';
+import { createNotificationDispatcher, wireRuntimeNotificationBridge, wireMemoryPressureNotice, type NotificationDispatcher } 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';
@@ -44,6 +39,9 @@ import {
   type ShellPathService, type FeatureFlagManager, createFeatureFlagManager, PolicyRuntimeState,
 } from '@/runtime/index.ts';
 import { VoiceProviderRegistry, VoiceService, ensureBuiltinVoiceProviders } from '@pellux/goodvibes-sdk/platform/voice';
+import { CacheRegistry, PauseController, type MemoryGovernor } 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';
@@ -55,17 +53,18 @@ import { SessionManager, CrossSessionTaskRegistry, SessionChangeTracker } from '
 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 { BenchmarkStore, CacheHitTracker, computeUsageCostUsd, FavoritesStore, ModelLimitsService, ProviderCapabilityRegistry, ProviderOptimizer, ProviderRegistry } from '@pellux/goodvibes-sdk/platform/providers';
+import { BenchmarkStore, CacheHitTracker, FavoritesStore, ModelLimitsService, ProviderCapabilityRegistry, ProviderOptimizer, ProviderRegistry } from '@pellux/goodvibes-sdk/platform/providers';
 import { KeybindingsManager } from '../input/keybindings.ts';
 import { AdaptivePlanner, DeterministicReplayEngine, ExecutionPlanManager, SessionLineageTracker, SessionMemoryStore } from '@pellux/goodvibes-sdk/platform/core';
 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 { wireFleetNeedsInputPush } from './fleet-needs-input-push.ts';
 import { codeIndexDbPath, createCodeIndexServices, isCodeInjectionSettingEnabled } from './code-index-services.ts';
-import { WorkPlanStore } from '../work-plans/work-plan-store.ts';
+import type { WorkPlanStore } from '../work-plans/work-plan-store.ts';
 import { registerDaemonHandlers, type DaemonHandlerSurfaces } from '../daemon/handlers/index.ts';
 import type { HandlerContext, HandlerLogger } from '../daemon/handlers/context.ts';
 import { createDaemonCredentialStore } from '../daemon/handlers/credentials.ts';
@@ -79,8 +78,6 @@ import { registerRemoteSurface } from '../daemon/handlers/remote/index.ts';
 import { WorkspaceTrustManager } from './trust/workspace-trust.ts';
 import { ensureConfiguredModelIsRoutable } from './provider-fallback.ts';
 
-const REGULAR_KNOWLEDGE_DB_FILE = 'knowledge-wiki.sqlite';
-const HOME_GRAPH_KNOWLEDGE_DB_FILE = 'knowledge-home-graph.sqlite';
 export interface RuntimeServicesOptions {
   readonly runtimeBus: RuntimeEventBus;
   readonly runtimeStore: RuntimeStore;
@@ -90,6 +87,13 @@ export interface RuntimeServicesOptions {
   readonly getConversationTitle?: () => string | undefined;
   readonly workingDir: string;
   readonly homeDirectory: string;
+  /** 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'];
 }
 
 export interface RuntimeServices {
@@ -135,6 +139,7 @@ export interface RuntimeServices {
   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;
@@ -198,6 +203,15 @@ export interface RuntimeServices {
   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 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;
@@ -227,6 +241,19 @@ export function createRuntimeServices(options: RuntimeServicesOptions): RuntimeS
     bindFeatureSettingsBridge(configManager, featureFlags);
   }
   const runtimeDispatch = createDomainDispatch(options.runtimeStore);
+  // Memory governance seams built EARLY (mirrors the SDK's own createRuntimeServices)
+  // so the scheduler gates and the knowledge background jobs can consult the pause
+  // controller before the MemoryGovernor (constructed at the composition tail)
+  // drives it. The admission gate is late-bound: expensive entry points capture
+  // this closure now and the governor binds into it at the tail — until then
+  // everything is admitted (the daemon is still booting).
+  const cacheRegistry = new CacheRegistry();
+  const pauseController = new PauseController();
+  const MEMORY_BACKGROUND_JOB_IDS = ['knowledge-self-improvement', 'memory-consolidation', 'code-index-reindex'];
+  const admitExpensiveWorkRef: { current: ((label: string) => { allowed: boolean; reason?: string | undefined }) | null } = { current: null };
+  const admitExpensiveWork = (label: string): { allowed: boolean; reason?: string | undefined } =>
+    admitExpensiveWorkRef.current?.(label) ?? { allowed: true };
+  const isKnowledgeBackgroundPaused = (): boolean => pauseController.isPaused('knowledge-self-improvement');
   const gatewayMethods = new GatewayMethodCatalog();
   const panelManager = new PanelManager();
   // (the purge): MIGRATE-TO-MODAL surface + redirect registration moved to
@@ -249,6 +276,7 @@ export function createRuntimeServices(options: RuntimeServicesOptions): RuntimeS
   });
   // Step-up (WebAuthn) ceremony service, shared between the ceremony gateway verbs and the relay gate's verifier.
   const stepUpService = new StepUpService({ secrets: secretsManager });
+  const pairingTokens = new PairingTokenManager(shellPaths.resolveUserPath('control-plane', 'pairing-tokens.json'));
   const subscriptionManager = new SubscriptionManager(shellPaths.resolveUserPath('tui', 'subscriptions.json'));
   const serviceRegistry = new ServiceRegistry(shellPaths.resolveProjectPath('tui', 'services.json'), {
     secretsManager,
@@ -414,61 +442,15 @@ export function createRuntimeServices(options: RuntimeServicesOptions): RuntimeS
       return record.id;
     },
   });
-  const knowledgeStore = new KnowledgeStore({
-    configManager,
-    dbFileName: REGULAR_KNOWLEDGE_DB_FILE,
-  });
-  const agentKnowledgeStore = new KnowledgeStore({
-    configManager,
-    dbFileName: GOODVIBES_AGENT_KNOWLEDGE_DB_FILE,
-  });
-  const homeGraphKnowledgeStore = new KnowledgeStore({
-    configManager,
-    dbFileName: HOME_GRAPH_KNOWLEDGE_DB_FILE,
-  });
-  const knowledgeSemanticLlm = createProviderBackedKnowledgeSemanticLlm(providerRegistry, {
-    timeoutMs: 20_000,
-    maxConcurrent: 1,
-  });
-  const knowledgeSemanticService = new KnowledgeSemanticService(knowledgeStore, {
-    llm: knowledgeSemanticLlm,
-    maxLlmSourcesPerReindex: 3,
-  });
-  const homeGraphSemanticService = new KnowledgeSemanticService(homeGraphKnowledgeStore, {
-    llm: knowledgeSemanticLlm,
-    maxLlmSourcesPerReindex: 3,
-    objectProfiles: HOME_GRAPH_KNOWLEDGE_EXTENSION.objectProfiles,
-  });
-  const agentKnowledgeSemanticService = new KnowledgeSemanticService(agentKnowledgeStore, {
-    llm: knowledgeSemanticLlm,
-    maxLlmSourcesPerReindex: 3,
-  });
-  const knowledgeService = new KnowledgeService(knowledgeStore, artifactStore, undefined, {
-    memoryRegistry,
-    runtimeBus: options.runtimeBus,
-    semanticService: knowledgeSemanticService,
-  });
-  knowledgeService.attachRuntimeBus(options.runtimeBus);
-  const agentKnowledgeService = new KnowledgeService(agentKnowledgeStore, artifactStore, undefined, {
-    memoryRegistry,
-    runtimeBus: options.runtimeBus,
-    semanticService: agentKnowledgeSemanticService,
-  });
-  agentKnowledgeService.attachRuntimeBus(options.runtimeBus);
-  const homeGraphService = new HomeGraphService(homeGraphKnowledgeStore, artifactStore, {
-    semanticService: homeGraphSemanticService,
-  });
-  const projectPlanningProjectId = projectPlanningProjectIdFromPath(workingDirectory);
-  const projectPlanningService = new ProjectPlanningService(knowledgeStore, {
-    defaultProjectId: projectPlanningProjectId,
-  });
-  const workPlanStore = new WorkPlanStore({
-    homeDirectory,
-    projectId: projectPlanningProjectId,
-    projectRoot: workingDirectory,
-  });
+  // Knowledge/wiki + home-graph stack (governor backpressure wired in) — see knowledge-services.ts.
+  const {
+    knowledgeStore, agentKnowledgeStore, homeGraphKnowledgeStore,
+    knowledgeSemanticService, homeGraphSemanticService, agentKnowledgeSemanticService,
+    knowledgeService, agentKnowledgeService, homeGraphService,
+    projectPlanningService, projectPlanningProjectId, workPlanStore,
+  } = createKnowledgeServices({ configManager, providerRegistry, artifactStore, memoryRegistry, runtimeBus: options.runtimeBus, workingDirectory, homeDirectory, isBackgroundPaused: isKnowledgeBackgroundPaused, admitExpensiveWork });
   const voiceProviders = new VoiceProviderRegistry();
-  ensureBuiltinVoiceProviders(voiceProviders);
+  ensureBuiltinVoiceProviders(voiceProviders, { readConfig: (key) => configManager.get(key as Parameters<typeof configManager.get>[0]) });
   const voiceService = new VoiceService(voiceProviders);
   const webSearchProviders = new WebSearchProviderRegistry({
     env: process.env,
@@ -478,18 +460,9 @@ export function createRuntimeServices(options: RuntimeServicesOptions): RuntimeS
     serviceRegistry,
     featureFlags,
   });
-  knowledgeSemanticService.setGapRepairer(createWebKnowledgeGapRepairer({
-    searchService: webSearchService,
-    ingestService: knowledgeService,
-  }));
-  agentKnowledgeSemanticService.setGapRepairer(createWebKnowledgeGapRepairer({
-    searchService: webSearchService,
-    ingestService: agentKnowledgeService,
-  }));
-  homeGraphSemanticService.setGapRepairer(createWebKnowledgeGapRepairer({
-    searchService: webSearchService,
-    ingestService: homeGraphService,
-  }));
+  for (const [semantic, ingest] of [[knowledgeSemanticService, knowledgeService], [agentKnowledgeSemanticService, agentKnowledgeService], [homeGraphSemanticService, homeGraphService]] as const) {
+    semantic.setGapRepairer(createWebKnowledgeGapRepairer({ searchService: webSearchService, ingestService: ingest }));
+  }
   const mediaProviders = new MediaProviderRegistry();
   ensureBuiltinMediaProviders(mediaProviders, artifactStore, providerRegistry);
   const multimodalService = new MultimodalService(artifactStore, mediaProviders, voiceService, knowledgeService);
@@ -587,40 +560,55 @@ export function createRuntimeServices(options: RuntimeServicesOptions): RuntimeS
   // Repo source-tree code index, sharing memoryEmbeddingRegistry
   // with MemoryStore above. Auto-build is config-gated (default off) — see
   // code-index-services.ts's header doc.
-  const { codeIndexStore, codeIndexReindexScheduler } = createCodeIndexServices({ workingDirectory, configManager, memoryEmbeddingRegistry });
+  const { codeIndexStore, codeIndexReindexScheduler } = createCodeIndexServices({ workingDirectory, configManager, memoryEmbeddingRegistry, isReindexPaused: () => pauseController.isPaused('code-index-reindex'), admitExpensiveWork });
   // Store snapshots + durable remembered-approval rules + the live credential
   // chain, mirroring the SDK composition — see durability-services.ts.
   const { storeSnapshotScheduler, userPermissionRuleStore } = createDurabilityServices({
-    configManager, secretsManager, providerRegistry, memoryDbPath, codeIndexDbPath: codeIndexDbPath(workingDirectory),
+    configManager, secretsManager, providerRegistry, memoryDbPath, codeIndexDbPath: codeIndexDbPath(workingDirectory), workingDirectory, surfaceRoot: 'tui', homeDirectory, shellPaths, // + retention-sweep roots & live config watch (mirrors the SDK)
   });
   const codeInjectionOrchestratorDeps = { codeIndex: codeIndexStore, isCodeInjectionSettingEnabled: () => isCodeInjectionSettingEnabled(configManager), codeIndexReindexScheduler }; // Code-injection seam (agent here; main via orchestrator-core-services.ts)
-  // Shared, archive-aware fleet registry — see gateway-verbs.ts's factory doc.
-  const processRegistry = createArchivableFleetRegistry({
-    agentManager,
-    wrfcController,
+  const { processRegistry } = createFleetServices({ // Shared archive-aware fleet registry (+ daemon observed rows) — see fleet-services.ts
+    agentManager, wrfcController,
     orchestrationEngine, // Folds workstream/phase/work-item nodes into the fleet
     codeIndexService: codeIndexStore, // Folds a single 'code-index' node into the fleet
-    processManager,
-    watcherRegistry,
-    workflow,
-    approvalBroker,
-    sessionBroker,
+    processManager, watcherRegistry, workflow, approvalBroker, sessionBroker,
     messageBus: agentMessageBus, // Backs steer()/`steerable` (the Fleet steer composer builds on top)
     automationManager, // Folds /schedule AutomationJobs into the fleet as 'schedule' nodes
     runtimeBus: options.runtimeBus,
-    // Honest-unpriced through the ONE pricing resolver (manual -> registration -> provider-served
-    // -> catalog -> unknown); unknown/subscription yields null, never $0. Mirrors the SDK composition.
-    priceUsage: (model, usage) => (model ? computeUsageCostUsd(providerRegistry.resolveModelPricing(model), usage) : null),
+    observeExternalAgents: options.observeExternalAgents, providerRegistry, // observeExternalAgents is daemon-side only
   });
-  const modeManager = new ModeManager();
-  const fileUndoManager = new FileUndoManager();
+  const modeManager = new ModeManager(); const fileUndoManager = new FileUndoManager();
   const workspaceCheckpointManager = createWorkspaceCheckpointing({ workspaceRoot: workingDirectory, 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
+  // admitted (mirrors the SDK's own createRuntimeServices idle gate).
+  const { memoryConsolidationScheduler, powerManager, sessionLiveTurnControls } = wireIdlePowerAndLiveTurn({ configManager, memoryRegistry, runtimeBus: options.runtimeBus, isIdle: () => sessionBroker.countBusySessions() === 0 && !pauseController.isPaused('memory-consolidation') && admitExpensiveWork('memory consolidation').allowed, snapshotTick: () => storeSnapshotScheduler.tick(), heartbeat: async () => { await automationManager.triggerHeartbeat({ source: 'wake-catchup' }); }, powerSeam: options.powerSeam });
+
+  // Construct + start the MemoryGovernor (default ON — a safety feature) with
+  // the standard KNOWN cache adapters (knowledge stores + shared session
+  // broker), then late-bind the admission gate the expensive entry points
+  // captured earlier. Mirrors the SDK's own createRuntimeServices composition tail.
+  const { memoryGovernor } = wireMemoryGovernance({
+    configManager,
+    runtimeBus: options.runtimeBus,
+    cacheRegistry,
+    pauseController,
+    jobIds: MEMORY_BACKGROUND_JOB_IDS,
+    receiptPath: shellPaths.resolveProjectPath('tui', 'memory', 'tripwire-receipt.json'),
+    knowledgeStores: [knowledgeStore, agentKnowledgeStore, homeGraphKnowledgeStore],
+    sessionBroker,
+    // Graceful tripwire shutdown flushes in-flight state via ASYNC store
+    // snapshots so the governor's 10s shutdown ceiling stays enforceable.
+    onTripwireShutdown: async () => { await storeSnapshotScheduler.snapshotAllAsync('tripwire'); },
+  });
+  admitExpensiveWorkRef.current = (label) => memoryGovernor.admitExpensiveWork(label);
+
+  // 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 });
 
-  // Shared terminal-shell wrapper over the SDK's registerGatewayVerbGroups (see gateway-verbs.ts): 501s the ws-only
-  // family without it. principals.*/channels.profiles.*/ci.* register unconditionally; checkin.* only with
-  // channelDeliveryRouter/providerRegistry/automationManager/sessionLister ALL present; fleet needs-input push gated by
-  // runtimeBus/sessionPresence (fleet-needs-input-push.ts). conversationRewindPort serves conversation-scope rewind live.
-  attachWsOnlyGatewayVerbHandlers(gatewayMethods, { processRegistry, workspaceCheckpointManager, conversationRewindPort: createSessionConversationRewindPort(), sessionBroker, secretsManager, stepUpService, approvalBroker, requestApproval: (input) => approvalBroker.requestApproval(input), watcherRegistry, userPermissionRuleStore, shellPaths, configManager, runtimeStore: options.runtimeStore, channelDeliveryRouter, providerRegistry, automationManager, sessionLister: sessionBroker, sessionIntake: sessionBroker, workingDirectory, memoryRegistry, ...wireFleetNeedsInputPush({ registry: processRegistry, runtimeBus: options.runtimeBus, sessionBroker }) });
+  // 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.
+  attachWsOnlyGatewayVerbHandlers(gatewayMethods, { processRegistry, workspaceCheckpointManager, conversationRewindPort: createSessionConversationRewindPort(), sessionBroker, secretsManager, stepUpService, approvalBroker, requestApproval: (input) => approvalBroker.requestApproval(input), watcherRegistry, userPermissionRuleStore, shellPaths, configManager, runtimeStore: options.runtimeStore, channelDeliveryRouter, providerRegistry, automationManager, sessionLister: sessionBroker, sessionIntake: sessionBroker, workingDirectory, memoryRegistry, pairingTokens, sessionLiveTurnControls, powerManager, memoryGovernor, voiceSetup, relayAvailable: () => configManager.get('relay.enabled') === true, pairingWebOrigin: () => resolvePairingWebOrigin(configManager).origin, ...wireFleetNeedsInputPush({ registry: processRegistry, runtimeBus: options.runtimeBus, sessionBroker }) });
   const integrationHelpers = new IntegrationHelperService({
     workingDirectory,
     homeDirectory,
@@ -683,6 +671,9 @@ export function createRuntimeServices(options: RuntimeServicesOptions): RuntimeS
   // panel feed (panel_only and burst-collapsed decisions land there).
   const notificationDispatcher = createNotificationDispatcher(configManager);
   wireRuntimeNotificationBridge(options.runtimeBus, notificationDispatcher);
+  // OPS_MEMORY_PRESSURE is lifted into the notice feed on its own targeted
+  // bridge (the high-churn 'ops' domain stays out of the wholesale allowlist).
+  wireMemoryPressureNotice(options.runtimeBus, notificationDispatcher);
 
   return {
     workingDirectory,
@@ -723,6 +714,7 @@ export function createRuntimeServices(options: RuntimeServicesOptions): RuntimeS
     serviceRegistry,
     secretsManager,
     stepUpService,
+    pairingTokens,
     subscriptionManager,
     localUserAuthManager,
     profileManager,
@@ -782,6 +774,12 @@ export function createRuntimeServices(options: RuntimeServicesOptions): RuntimeS
     codeIndexStore,
     codeIndexReindexScheduler,
     storeSnapshotScheduler,
+    memoryConsolidationScheduler,
+    powerManager,
+    memoryGovernor,
+    cacheRegistry,
+    pauseController,
+    sessionLiveTurnControls,
     processRegistry,
     modeManager,
     fileUndoManager,

package/src/runtime/ui-services.ts

@@ -59,6 +59,8 @@ export interface UiPlatformServices {
   readonly surfaceRegistry: RuntimeServices['surfaceRegistry'];
   readonly subscriptionManager: RuntimeServices['subscriptionManager'];
   readonly secretsManager: SecretsManager;
+  /** Per-device pairing tokens — backs the pairing modal QR and the settings device surface. */
+  readonly pairingTokens: RuntimeServices['pairingTokens'];
   readonly tokenAuditor: RuntimeServices['tokenAuditor'];
   readonly replayEngine: RuntimeServices['replayEngine'];
   readonly webhookNotifier: RuntimeServices['webhookNotifier'];
@@ -188,6 +190,7 @@ export function createUiRuntimeServices(
       surfaceRegistry: runtimeServices.surfaceRegistry,
       subscriptionManager: runtimeServices.subscriptionManager,
       secretsManager: runtimeServices.secretsManager,
+      pairingTokens: runtimeServices.pairingTokens,
       tokenAuditor: runtimeServices.tokenAuditor,
       replayEngine: runtimeServices.replayEngine,
       webhookNotifier: runtimeServices.webhookNotifier,

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

@@ -0,0 +1,104 @@
+// ---------------------------------------------------------------------------
+// voice-setup-services.ts — managed local-voice provisioning composition (TUI wiring)
+//
+// Backs the daemon's voice.local.status / voice.local.install verbs. Extracted
+// into its own module rather than built inline in services.ts, which sits at
+// the architecture check's 800-line cap (scripts/check-architecture.ts) — new
+// service construction gets its own module and a single wiring call there.
+//
+// Mirrors the SDK's own createRuntimeServices voiceSetup: a single-flight
+// one-act install that provisions the piper engine + a default voice (and
+// whisper STT where a bundle is published) and pre-configures the voice.local.*
+// keys with ownership awareness (values THIS installer previously wrote update
+// to the new managed paths; genuinely user-set values still win; a user-cleared
+// installer value stays cleared). status() is a no-network read.
+// ---------------------------------------------------------------------------
+
+import {
+  createVoiceInstallProgressTracker,
+  localVoiceRuntimeStatus,
+  preconfigureLocalVoiceKeys,
+  provisionLocalVoiceRuntime,
+  readVoiceInstallStamp,
+  writeVoiceInstallStamp,
+  type VoiceProviderRegistry,
+} from '@pellux/goodvibes-sdk/platform/voice';
+import { singleFlight } from '@pellux/goodvibes-sdk/platform/utils';
+import type { ConfigManager } from '@pellux/goodvibes-sdk/platform/config';
+import type { ShellPathService } from '@/runtime/index.ts';
+import type { VoiceLocalInstallResult } from '../core/voice-provision-status.ts';
+
+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 };
+}
+
+/** The narrow provisioning slice the voice.local.* gateway verbs consume. */
+export interface VoiceSetupService {
+  status(): unknown;
+  install(): Promise<VoiceLocalInstallResult>;
+}
+
+/** Compose the managed-voice single-flight install + no-network status read. */
+export function wireVoiceSetup(deps: VoiceSetupServicesDeps): { voiceSetup: VoiceSetupService } {
+  const { configManager, voiceProviders } = deps;
+  const managedVoiceRoot = deps.shellPaths.resolveUserPath('voice');
+  // Live install progress: the install verb is plain request/response, so during
+  // a multi-hundred-MB provision a surface would otherwise only see busy→receipt.
+  // The tracker folds the provisioner's onProgress stream into a poll-able
+  // snapshot that status() carries as `installInProgress` WHILE (and only while)
+  // an install runs — surfaces poll status during install (mirrors the SDK).
+  const progress = createVoiceInstallProgressTracker();
+  // Single-flight: concurrent installs join the in-progress promise instead of
+  // starting parallel multi-hundred-MB downloads.
+  const runVoiceInstall = singleFlight(async () => {
+    progress.begin();
+    try {
+    const provision = await provisionLocalVoiceRuntime({ managedRoot: managedVoiceRoot, onProgress: (p) => progress.onProgress(p) });
+    let configured: { set: { key: string; value: string }[]; skipped: { key: string; reason: string }[] } = { set: [], skipped: [] };
+    if (provision.tts.state === 'provisioned' && provision.tts.binaryPath && provision.tts.modelPath) {
+      const stamp = readVoiceInstallStamp(managedVoiceRoot);
+      const receipt = preconfigureLocalVoiceKeys({
+        getConfig: (k) => String(configManager.get(k as Parameters<typeof configManager.get>[0]) ?? ''),
+        setConfig: (k, v) => configManager.setDynamic(k as Parameters<typeof configManager.setDynamic>[0], v),
+        ttsEngine: provision.tts.engine,
+        ttsBinary: provision.tts.binaryPath,
+        ttsModelPath: provision.tts.modelPath,
+        ...(provision.stt.state === 'provisioned' && provision.stt.binaryPath && provision.stt.modelPath
+          ? { sttEngine: provision.stt.engine, sttBinary: provision.stt.binaryPath, sttModelPath: provision.stt.modelPath }
+          : {}),
+        priorInstallWrites: stamp?.configWrites,
+      });
+      configured = { set: [...receipt.set], skipped: [...receipt.skipped] };
+      if (stamp) {
+        writeVoiceInstallStamp(managedVoiceRoot, { ...stamp, configWrites: { ...stamp.configWrites, ...receipt.installWrites } });
+      }
+      // A successful (re-)install clears any tripped local-engine breaker.
+      voiceProviders.get('local')?.resetEngineFailureState?.();
+    }
+    return { provisioned: provision.tts.state === 'provisioned', platform: provision.platform, tts: provision.tts, stt: provision.stt, components: provision.components, configured };
+    } finally {
+      progress.end();
+    }
+  });
+  const voiceSetup: VoiceSetupService = {
+    status: () => {
+      const base = localVoiceRuntimeStatus({ managedRoot: managedVoiceRoot });
+      const snapshot = progress.snapshot();
+      // Carry live per-component progress ONLY while an install is active.
+      return snapshot ? { ...base, installInProgress: snapshot } : base;
+    },
+    install: async () => {
+      // Critical-tier admission: refuse honestly instead of piling onto pressure.
+      const admission = deps.admitExpensiveWork('voice runtime install');
+      if (!admission.allowed) {
+        throw new Error(admission.reason ?? 'voice runtime install refused: daemon is under critical memory pressure.');
+      }
+      return runVoiceInstall();
+    },
+  };
+  return { voiceSetup };
+}