@pellux/goodvibes-agent 0.1.0

package/src/runtime/services.ts

@@ -0,0 +1,670 @@
+import { join } from 'node:path';
+import { ConfigManager } from '@pellux/goodvibes-sdk/platform/config';
+import { SecretsManager } from '../config/secrets.ts';
+import { ServiceRegistry } from '@pellux/goodvibes-sdk/platform/config';
+import { SubscriptionManager } from '@pellux/goodvibes-sdk/platform/config';
+import { AutomationDeliveryManager, AutomationManager, AutomationRouteStore } from '@pellux/goodvibes-sdk/platform/automation';
+import { ChannelPluginRegistry, ChannelPolicyManager, RouteBindingManager, SurfaceRegistry } from '@pellux/goodvibes-sdk/platform/channels';
+import { ChannelDeliveryRouter } from '@pellux/goodvibes-sdk/platform/channels';
+import { ApprovalBroker, GatewayMethodCatalog, SharedSessionBroker } from '@pellux/goodvibes-sdk/platform/control-plane';
+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 { MediaProviderRegistry, ensureBuiltinMediaProviders } from '@pellux/goodvibes-sdk/platform/media';
+import { MultimodalService } from '@pellux/goodvibes-sdk/platform/multimodal';
+import { AgentManager } from '@pellux/goodvibes-sdk/platform/tools';
+import { AgentMessageBus } from '@pellux/goodvibes-sdk/platform/agents';
+import { WrfcController } from '@pellux/goodvibes-sdk/platform/agents';
+import { AgentOrchestrator } from '@pellux/goodvibes-sdk/platform/agents';
+import { ArchetypeLoader } from '@pellux/goodvibes-sdk/platform/agents';
+import { ProcessManager } from '@pellux/goodvibes-sdk/platform/tools';
+import { ModeManager } from '@pellux/goodvibes-sdk/platform/state';
+import { FileUndoManager } from '@pellux/goodvibes-sdk/platform/state';
+import { MemoryRegistry } from '@pellux/goodvibes-sdk/platform/state';
+import { MemoryStore } from '@pellux/goodvibes-sdk/platform/state';
+import type { RuntimeEventBus } from '@/runtime/index.ts';
+import { createDomainDispatch } from './store/index.ts';
+import type { DomainDispatch, RuntimeStore } from './store/index.ts';
+import { DistributedRuntimeManager } from '@/runtime/index.ts';
+import { RemoteRunnerRegistry, RemoteSupervisor } from '@/runtime/index.ts';
+import { IntegrationHelperService } from '@/runtime/index.ts';
+import { VoiceProviderRegistry, VoiceService, ensureBuiltinVoiceProviders } from '@pellux/goodvibes-sdk/platform/voice';
+import { WebSearchProviderRegistry, WebSearchService } from '@pellux/goodvibes-sdk/platform/web-search';
+import { MemoryEmbeddingProviderRegistry } from '@pellux/goodvibes-sdk/platform/state';
+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 { 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 } from '@pellux/goodvibes-sdk/platform/sessions';
+import { CrossSessionTaskRegistry } from '@pellux/goodvibes-sdk/platform/sessions';
+import { ApiTokenAuditor } from '@pellux/goodvibes-sdk/platform/security';
+import { UserAuthManager } from '@pellux/goodvibes-sdk/platform/security';
+import { WebhookNotifier } from '@pellux/goodvibes-sdk/platform/integrations';
+import { McpRegistry } from '@pellux/goodvibes-sdk/platform/mcp';
+import { DeterministicReplayEngine } from '@pellux/goodvibes-sdk/platform/core';
+import { ProviderOptimizer } from '@pellux/goodvibes-sdk/platform/providers';
+import { ProviderRegistry } from '@pellux/goodvibes-sdk/platform/providers';
+import type { ModelDefinition } from '@pellux/goodvibes-sdk/platform/providers';
+import { ProviderCapabilityRegistry } from '@pellux/goodvibes-sdk/platform/providers';
+import { CacheHitTracker } from '@pellux/goodvibes-sdk/platform/providers';
+import { FavoritesStore } from '@pellux/goodvibes-sdk/platform/providers';
+import { BenchmarkStore } from '@pellux/goodvibes-sdk/platform/providers';
+import { ModelLimitsService } from '@pellux/goodvibes-sdk/platform/providers';
+import { KeybindingsManager } from '../input/keybindings.ts';
+import { SessionMemoryStore } from '@pellux/goodvibes-sdk/platform/core';
+import { SessionLineageTracker } from '@pellux/goodvibes-sdk/platform/core';
+import { SessionChangeTracker } from '@pellux/goodvibes-sdk/platform/sessions';
+import { ExecutionPlanManager } from '@pellux/goodvibes-sdk/platform/core';
+import { AdaptivePlanner } from '@pellux/goodvibes-sdk/platform/core';
+import { FileStateCache } from '@pellux/goodvibes-sdk/platform/state';
+import { ProjectIndex } from '@pellux/goodvibes-sdk/platform/state';
+import { IdempotencyStore } from '@/runtime/index.ts';
+import { OverflowHandler } from '@pellux/goodvibes-sdk/platform/tools';
+import { ToolLLM } from '@pellux/goodvibes-sdk/platform/config';
+import { ComponentHealthMonitor } from '@/runtime/index.ts';
+import { WorktreeRegistry } from '@/runtime/index.ts';
+import { SandboxSessionRegistry } from '@/runtime/index.ts';
+import { createShellPathService, type ShellPathService } from '@/runtime/index.ts';
+import { GOODVIBES_AGENT_SURFACE_ROOT } from '../config/surface.ts';
+import type { FeatureFlagManager } from '@/runtime/index.ts';
+import { createFeatureFlagManager } from '@/runtime/index.ts';
+import { PolicyRuntimeState } from '@/runtime/index.ts';
+import {
+  createWorkflowServices,
+  type WorkflowServices,
+} from '@pellux/goodvibes-sdk/platform/tools';
+import { WorkPlanStore } from '../work-plans/work-plan-store.ts';
+
+const REGULAR_KNOWLEDGE_DB_FILE = 'knowledge-wiki.sqlite';
+const HOME_GRAPH_KNOWLEDGE_DB_FILE = 'knowledge-home-graph.sqlite';
+
+function buildFallbackModelDefinition(provider: string, modelId: string): ModelDefinition {
+  const providerLower = provider.toLowerCase();
+  const isReasoningProvider = providerLower.includes('openai')
+    || providerLower.includes('anthropic')
+    || providerLower.includes('gemini')
+    || providerLower.includes('google');
+
+  return {
+    id: modelId,
+    provider,
+    registryKey: `${provider}:${modelId}`,
+    displayName: modelId,
+    description: 'Configured model available before the model catalog cache has loaded.',
+    capabilities: {
+      toolCalling: true,
+      codeEditing: true,
+      reasoning: isReasoningProvider,
+      multimodal: isReasoningProvider,
+    },
+    contextWindow: isReasoningProvider ? 128_000 : 32_000,
+    contextWindowProvenance: 'fallback',
+    selectable: true,
+    tier: 'standard',
+    ...(isReasoningProvider ? { reasoningEffort: ['instant', 'low', 'medium', 'high'] } : {}),
+  };
+}
+
+function ensureConfiguredModelIsRoutable(providerRegistry: ProviderRegistry, configManager: ConfigManager): void {
+  const configuredModel = String(configManager.get('provider.model') ?? '').trim();
+  if (!configuredModel.includes(':')) return;
+  if (providerRegistry.listModels().some((model) => model.registryKey === configuredModel)) return;
+
+  const [providerId, ...modelParts] = configuredModel.split(':');
+  const modelId = modelParts.join(':').trim();
+  if (!providerId || !modelId) return;
+
+  const provider = providerRegistry.tryGet(providerId);
+  if (!provider) return;
+
+  providerRegistry.registerRuntimeProvider({
+    provider,
+    replace: true,
+    models: [buildFallbackModelDefinition(providerId, modelId)],
+  });
+}
+
+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;
+}
+
+export interface RuntimeServices {
+  readonly workingDirectory: string;
+  readonly homeDirectory: string;
+  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;
+  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;
+  readonly serviceRegistry: ServiceRegistry;
+  readonly secretsManager: SecretsManager;
+  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;
+  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 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 wrfcController: WrfcController;
+  readonly processManager: ProcessManager;
+  readonly modeManager: ModeManager;
+  readonly fileUndoManager: FileUndoManager;
+  readonly integrationHelpers: IntegrationHelperService;
+  /**
+   * Re-root path-bound stores (MemoryStore, ProjectIndex) to a new working directory.
+   * Called by WorkspaceSwapManager after the new directory has been verified.
+   * Stores that require a process restart emit a warn-level log; they continue serving
+   * the old path until the daemon restarts with the new --working-dir.
+   */
+  rerootStores(newWorkingDir: string): Promise<void>;
+}
+
+export function createRuntimeServices(options: RuntimeServicesOptions): RuntimeServices {
+  const workingDirectory = options.workingDir;
+  const homeDirectory = options.homeDirectory;
+  const shellPaths = createShellPathService({
+    workingDirectory,
+    homeDirectory,
+  });
+  const configManager = options.configManager;
+  const featureFlags = options.featureFlags ?? createFeatureFlagManager();
+  const runtimeDispatch = createDomainDispatch(options.runtimeStore);
+  const gatewayMethods = new GatewayMethodCatalog();
+  const panelManager = new PanelManager();
+  const keybindingsManager = new KeybindingsManager({
+    configPath: shellPaths.resolveUserPath(GOODVIBES_AGENT_SURFACE_ROOT, 'keybindings.json'),
+  });
+  const routeBindings = new RouteBindingManager({
+    store: new AutomationRouteStore({ configManager }),
+    runtimeStore: options.runtimeStore,
+    runtimeBus: options.runtimeBus,
+  });
+  const surfaceRegistry = new SurfaceRegistry(configManager, options.runtimeStore);
+  const channelPlugins = new ChannelPluginRegistry();
+  surfaceRegistry.attachPluginRegistry(channelPlugins);
+  const secretsManager = new SecretsManager({
+    projectRoot: workingDirectory,
+    globalHome: homeDirectory,
+    configManager,
+  });
+  const subscriptionManager = new SubscriptionManager(
+    shellPaths.resolveUserPath(GOODVIBES_AGENT_SURFACE_ROOT, 'subscriptions.json'),
+  );
+  const serviceRegistry = new ServiceRegistry(shellPaths.resolveProjectPath(GOODVIBES_AGENT_SURFACE_ROOT, 'services.json'), {
+    secretsManager,
+    subscriptionManager,
+  });
+  const providerCapabilityRegistry = new ProviderCapabilityRegistry();
+  const cacheHitTracker = new CacheHitTracker();
+  const favoritesStore = new FavoritesStore({ dir: shellPaths.resolveUserPath(GOODVIBES_AGENT_SURFACE_ROOT) });
+  const benchmarkStore = new BenchmarkStore({ dir: shellPaths.resolveUserPath(GOODVIBES_AGENT_SURFACE_ROOT) });
+  const modelLimitsService = new ModelLimitsService({
+    cachePath: shellPaths.resolveUserPath(GOODVIBES_AGENT_SURFACE_ROOT, 'model-limits.json'),
+  });
+  const providerRegistry = new ProviderRegistry({
+    configManager,
+    subscriptionManager,
+    secretsManager,
+    serviceRegistry,
+    capabilityRegistry: providerCapabilityRegistry,
+    cacheHitTracker,
+    favoritesStore,
+    benchmarkStore,
+    modelLimitsService,
+    featureFlags,
+    runtimeBus: options.runtimeBus,
+  });
+  ensureConfiguredModelIsRoutable(providerRegistry, configManager);
+  providerRegistry.initCustomProviders();
+  const toolLLM = new ToolLLM({
+    configManager,
+    providerRegistry,
+  });
+  const localUserAuthManager = options.localUserAuthManager ?? new UserAuthManager({
+    bootstrapFilePath: shellPaths.resolveUserPath(GOODVIBES_AGENT_SURFACE_ROOT, 'auth-users.json'),
+    bootstrapCredentialPath: shellPaths.resolveUserPath(GOODVIBES_AGENT_SURFACE_ROOT, 'auth-bootstrap.txt'),
+  });
+  const profileManager = new ProfileManager(shellPaths.resolveUserPath(GOODVIBES_AGENT_SURFACE_ROOT, 'profiles'));
+  const bookmarkManager = new BookmarkManager(shellPaths.resolveUserPath(GOODVIBES_AGENT_SURFACE_ROOT, 'bookmarks'));
+  const sessionManager = new SessionManager(workingDirectory, { surfaceRoot: GOODVIBES_AGENT_SURFACE_ROOT });
+  const sessionOrchestration = new CrossSessionTaskRegistry(
+    shellPaths.resolveProjectPath(GOODVIBES_AGENT_SURFACE_ROOT, 'sessions', 'task-graph.json'),
+  );
+  const hookActivityTracker = new HookActivityTracker();
+  const watcherRegistry = new WatcherRegistry({
+    storePath: shellPaths.resolveProjectPath(GOODVIBES_AGENT_SURFACE_ROOT, 'watchers.json'),
+  });
+  watcherRegistry.attachRuntime({
+    runtimeStore: options.runtimeStore,
+    runtimeBus: options.runtimeBus,
+  });
+  const agentMessageBus = new AgentMessageBus();
+  agentMessageBus.setRuntimeBus(options.runtimeBus);
+  const archetypeLoader = new ArchetypeLoader(join(workingDirectory, '.goodvibes', 'agents'));
+  const agentOrchestrator = new AgentOrchestrator({
+    messageBus: agentMessageBus,
+  });
+  agentOrchestrator.setRuntimeBus(options.runtimeBus);
+  const agentManager = new AgentManager({
+    archetypeLoader,
+    messageBus: agentMessageBus,
+    executor: agentOrchestrator,
+    configManager,
+  });
+  agentManager.setRuntimeBus(options.runtimeBus);
+  const wrfcController = new WrfcController(options.runtimeBus, agentMessageBus, {
+    agentManager,
+    configManager,
+    projectRoot: workingDirectory,
+  });
+  agentManager.setWrfcController(wrfcController);
+  const hookDispatcher = new HookDispatcher({ toolLLM, projectRoot: workingDirectory }, hookActivityTracker);
+  configManager.attachHookDispatcher(hookDispatcher);
+  const hookWorkbench = createHookWorkbench({
+    hookDispatcher,
+    configManager,
+  });
+  const approvalBroker = new ApprovalBroker({
+    storePath: shellPaths.resolveProjectPath(GOODVIBES_AGENT_SURFACE_ROOT, 'control-plane', 'approvals.json'),
+  });
+  const sessionBroker = new SharedSessionBroker({
+    storePath: shellPaths.resolveProjectPath(GOODVIBES_AGENT_SURFACE_ROOT, 'control-plane', 'sessions.json'),
+    routeBindings,
+    agentStatusProvider: agentManager,
+    messageSender: agentMessageBus,
+  });
+  sessionBroker.setContinuationRunner(async ({ task, input }) => {
+    throw new Error([
+      'GoodVibes Agent does not own shared-session task execution.',
+      `Received task for session ${input.sessionId}: ${task}`,
+      'Delegate explicit build/fix/review work to GoodVibes TUI through the public shared-session/build-delegation contract.',
+    ].join(' '));
+  });
+  const artifactStore = new ArtifactStore({ configManager });
+  const memoryEmbeddingRegistry = new MemoryEmbeddingProviderRegistry({ configManager });
+  const memoryDbPath = join(workingDirectory, '.goodvibes', GOODVIBES_AGENT_SURFACE_ROOT, 'memory.sqlite');
+  const memoryStore = new MemoryStore(memoryDbPath, {
+    embeddingRegistry: memoryEmbeddingRegistry,
+  });
+  const memoryRegistry = new MemoryRegistry(memoryStore);
+  const deliveryManager = new AutomationDeliveryManager({
+    configManager,
+    serviceRegistry,
+    runtimeBus: options.runtimeBus,
+    runtimeStore: options.runtimeStore,
+    routeBindings,
+    artifactStore,
+  });
+  const automationManager = new AutomationManager({
+    configManager,
+    defaultSurfaceKind: 'service',
+    routeBindings,
+    sessionBroker,
+    runtimeStore: options.runtimeStore,
+    runtimeBus: options.runtimeBus,
+    deliveryManager,
+    spawnTask: (input) => {
+      throw new Error([
+        'GoodVibes Agent does not spawn local automation agents.',
+        `Received automation prompt: ${input.prompt}`,
+        'Use read-only automation observability here; explicit build/fix/review execution belongs to GoodVibes TUI delegation.',
+      ].join(' '));
+    },
+  });
+  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,
+  });
+  const voiceProviders = new VoiceProviderRegistry();
+  ensureBuiltinVoiceProviders(voiceProviders);
+  const voiceService = new VoiceService(voiceProviders);
+  const webSearchProviders = new WebSearchProviderRegistry({
+    env: process.env,
+    serviceRegistry,
+  });
+  const webSearchService = new WebSearchService(webSearchProviders, {
+    serviceRegistry,
+    featureFlags,
+  });
+  knowledgeSemanticService.setGapRepairer(createWebKnowledgeGapRepairer({
+    searchService: webSearchService,
+    ingestService: knowledgeService,
+  }));
+  agentKnowledgeSemanticService.setGapRepairer(createWebKnowledgeGapRepairer({
+    searchService: webSearchService,
+    ingestService: agentKnowledgeService,
+  }));
+  homeGraphSemanticService.setGapRepairer(createWebKnowledgeGapRepairer({
+    searchService: webSearchService,
+    ingestService: homeGraphService,
+  }));
+  const mediaProviders = new MediaProviderRegistry();
+  ensureBuiltinMediaProviders(mediaProviders, artifactStore, providerRegistry);
+  const multimodalService = new MultimodalService(artifactStore, mediaProviders, voiceService, knowledgeService);
+  const pluginManager = new PluginManager({
+    pathOptions: {
+      cwd: shellPaths.workingDirectory,
+      homeDir: shellPaths.homeDirectory,
+    },
+    stateFilePath: shellPaths.resolveUserPath(GOODVIBES_AGENT_SURFACE_ROOT, 'plugins.json'),
+  });
+  const workflow = createWorkflowServices();
+  hookDispatcher.setTriggerManager(workflow.triggerManager);
+  const channelPolicy = new ChannelPolicyManager({
+    storePath: shellPaths.resolveProjectPath(GOODVIBES_AGENT_SURFACE_ROOT, 'channels', 'policies.json'),
+  });
+  const distributedRuntime = new DistributedRuntimeManager(
+    shellPaths.resolveProjectPath(GOODVIBES_AGENT_SURFACE_ROOT, 'remote', 'distributed-runtime.json'),
+  );
+  distributedRuntime.attachRuntime({
+    sessionBridge: sessionBroker,
+    approvalBridge: approvalBroker,
+    automationBridge: automationManager,
+  });
+  const remoteRunnerRegistry = new RemoteRunnerRegistry(agentManager);
+  const remoteSupervisor = new RemoteSupervisor(remoteRunnerRegistry);
+  const sandboxSessionRegistry = new SandboxSessionRegistry(workingDirectory);
+  const mcpRegistry = new McpRegistry({
+    hookDispatcher,
+    sandboxSessions: sandboxSessionRegistry,
+  });
+  mcpRegistry.setRuntimeBus(options.runtimeBus);
+  mcpRegistry.setSandboxRuntime(configManager, sandboxSessionRegistry);
+  const tokenAuditor = new ApiTokenAuditor({ managed: false });
+  const componentHealthMonitor = new ComponentHealthMonitor();
+  const worktreeRegistry = new WorktreeRegistry(workingDirectory);
+  const webhookNotifier = new WebhookNotifier();
+  const replayEngine = new DeterministicReplayEngine(workingDirectory);
+  const providerOptimizer = new ProviderOptimizer(providerRegistry, providerCapabilityRegistry, false);
+  const sessionMemoryStore = new SessionMemoryStore();
+  const sessionLineageTracker = new SessionLineageTracker();
+  const sessionChangeTracker = new SessionChangeTracker();
+  const planManager = new ExecutionPlanManager(workingDirectory);
+  const adaptivePlanner = new AdaptivePlanner();
+  const idempotencyStore = new IdempotencyStore();
+  const overflowHandler = new OverflowHandler({ baseDir: workingDirectory });
+  const policyRuntimeState = new PolicyRuntimeState();
+  const fileCache = new FileStateCache();
+  const projectIndex = new ProjectIndex(workingDirectory);
+  const channelDeliveryRouter = new ChannelDeliveryRouter({
+    configManager,
+    secretsManager,
+    serviceRegistry,
+    artifactStore,
+  });
+  const processManager = new ProcessManager();
+  const modeManager = new ModeManager();
+  const fileUndoManager = new FileUndoManager();
+  const integrationHelpers = new IntegrationHelperService({
+    workingDirectory,
+    homeDirectory,
+    runtimeStore: options.runtimeStore,
+    runtimeBus: options.runtimeBus,
+    configManager,
+    getConversationTitle: options.getConversationTitle,
+    automationManager,
+    approvalBroker,
+    sessionBroker,
+    distributedRuntime,
+    remoteRunnerRegistry,
+    remoteSupervisor,
+    panelManager,
+    localUserAuthManager,
+    providerRegistry,
+    serviceRegistry,
+    subscriptionManager,
+    secretsManager,
+  });
+  agentOrchestrator.setDependencies({
+    surfaceRoot: GOODVIBES_AGENT_SURFACE_ROOT,
+    fileCache,
+    projectIndex,
+    workingDirectory,
+    fileUndoManager,
+    modeManager,
+    processManager,
+    agentMessageBus,
+    webSearchService,
+    channelRegistry: channelPlugins,
+    remoteRunnerRegistry,
+    knowledgeService,
+    memoryRegistry,
+    archetypeLoader,
+    configManager,
+    providerRegistry,
+    providerOptimizer,
+    toolLLM,
+    serviceRegistry,
+    sessionOrchestration,
+    featureFlags,
+    overflowHandler,
+    sandboxSessionRegistry,
+    workflowServices: workflow,
+  });
+
+  return {
+    workingDirectory,
+    homeDirectory,
+    shellPaths,
+    configManager,
+    featureFlags,
+    runtimeBus: options.runtimeBus,
+    runtimeStore: options.runtimeStore,
+    runtimeDispatch,
+    panelManager,
+    keybindingsManager,
+    routeBindings,
+    surfaceRegistry,
+    channelPlugins,
+    channelDeliveryRouter,
+    watcherRegistry,
+    approvalBroker,
+    sessionBroker,
+    deliveryManager,
+    automationManager,
+    gatewayMethods,
+    artifactStore,
+    knowledgeService,
+    agentKnowledgeService,
+    homeGraphService,
+    projectPlanningService,
+    projectPlanningProjectId,
+    workPlanStore,
+    memoryStore,
+    memoryRegistry,
+    serviceRegistry,
+    secretsManager,
+    subscriptionManager,
+    localUserAuthManager,
+    profileManager,
+    bookmarkManager,
+    sessionManager,
+    sessionOrchestration,
+    hookDispatcher,
+    hookActivityTracker,
+    hookWorkbench,
+    pluginManager,
+    workflow,
+    voiceProviders,
+    voiceService,
+    webSearchProviders,
+    webSearchService,
+    mediaProviders,
+    multimodalService,
+    memoryEmbeddingRegistry,
+    channelPolicy,
+    mcpRegistry,
+    tokenAuditor,
+    componentHealthMonitor,
+    worktreeRegistry,
+    sandboxSessionRegistry,
+    webhookNotifier,
+    replayEngine,
+    providerOptimizer,
+    providerCapabilityRegistry,
+    cacheHitTracker,
+    favoritesStore,
+    benchmarkStore,
+    modelLimitsService,
+    providerRegistry,
+    toolLLM,
+    distributedRuntime,
+    remoteRunnerRegistry,
+    remoteSupervisor,
+    sessionMemoryStore,
+    sessionLineageTracker,
+    sessionChangeTracker,
+    planManager,
+    adaptivePlanner,
+    idempotencyStore,
+    overflowHandler,
+    policyRuntimeState,
+    archetypeLoader,
+    agentManager,
+    agentMessageBus,
+    agentOrchestrator,
+    wrfcController,
+    processManager,
+    modeManager,
+    fileUndoManager,
+    integrationHelpers,
+    async rerootStores(newWorkingDir: string): Promise<void> {
+      const newMemoryDbPath = join(newWorkingDir, '.goodvibes', GOODVIBES_AGENT_SURFACE_ROOT, 'memory.sqlite');
+      await memoryStore.reroot(newMemoryDbPath);
+      await projectIndex.reroot(newWorkingDir);
+    },
+  };
+}

package/src/runtime/store/domains/domain-read-matrix.ts

@@ -0,0 +1,15 @@
+export const DOMAINS = [
+  'panels',
+  'ui-perf',
+] as const;
+
+export type DomainName = (typeof DOMAINS)[number];
+
+export const DOMAIN_READ_MATRIX: ReadonlyArray<{
+  readonly reader: DomainName;
+  readonly reads: readonly DomainName[];
+}> = [];
+
+export function getAllowedReadsFor(reader: DomainName): ReadonlySet<DomainName> {
+  return new Set<DomainName>([reader]);
+}