@pellux/goodvibes-agent 0.1.116 → 1.0.0

package/src/runtime/onboarding/snapshot.ts

@@ -35,15 +35,7 @@ function buildConfigSnapshot(
       llmProvider: config.get('tools.llmProvider'),
       llmModel: config.get('tools.llmModel'),
     },
-    danger: config.getCategory('danger'),
-    controlPlane: config.getCategory('controlPlane'),
-    httpListener: config.getCategory('httpListener'),
-    web: config.getCategory('web'),
-    network: config.getCategory('network'),
     surfaces: config.getCategory('surfaces'),
-    service: config.getCategory('service'),
-    featureFlags: config.getCategory('featureFlags'),
-    batch: config.getCategory('batch'),
   };
 }
 
@@ -99,7 +91,7 @@ async function buildServicesSnapshot(
       },
       issues: [
         {
-          area: 'services',
+          area: 'host',
           message: error instanceof Error ? error.message : String(error),
         },
       ],
@@ -146,7 +138,7 @@ async function buildServicesSnapshot(
           hasAppToken: false,
         } satisfies OnboardingServiceState,
         issue: {
-          area: 'services',
+          area: 'host',
           message: `${name}: ${error instanceof Error ? error.message : String(error)}`,
         } satisfies OnboardingSnapshotCollectionIssue,
       };
@@ -389,13 +381,6 @@ export async function collectOnboardingSnapshot(
     auth: {
       snapshot: authSnapshotResult.value,
     },
-    bindSettings: {
-      daemonEnabled: Boolean(config.danger.daemon),
-      httpListenerEnabled: Boolean(config.danger.httpListener),
-      controlPlane: config.controlPlane,
-      httpListener: config.httpListener,
-      web: config.web,
-    },
     surfaces: {
       configuredEnabledKinds: buildConfiguredSurfaceKinds(config.surfaces),
       records: sortSurfaceRecords(surfaceResult.value),

package/src/runtime/onboarding/types.ts

@@ -40,15 +40,7 @@ export interface OnboardingConfigSnapshot {
   readonly permissions: GoodVibesConfig['permissions'];
   readonly helper: GoodVibesConfig['helper'];
   readonly tools: Pick<GoodVibesConfig['tools'], 'llmEnabled' | 'llmProvider' | 'llmModel'>;
-  readonly danger: GoodVibesConfig['danger'];
-  readonly controlPlane: GoodVibesConfig['controlPlane'];
-  readonly httpListener: GoodVibesConfig['httpListener'];
-  readonly web: GoodVibesConfig['web'];
-  readonly network: GoodVibesConfig['network'];
   readonly surfaces: GoodVibesConfig['surfaces'];
-  readonly service: GoodVibesConfig['service'];
-  readonly featureFlags: GoodVibesConfig['featureFlags'];
-  readonly batch: GoodVibesConfig['batch'];
 }
 
 export interface OnboardingProviderRoutingSnapshot {
@@ -102,14 +94,6 @@ export interface OnboardingAuthSnapshot {
   readonly snapshot: LocalAuthSnapshot;
 }
 
-export interface OnboardingBindSettingsSnapshot {
-  readonly daemonEnabled: boolean;
-  readonly httpListenerEnabled: boolean;
-  readonly controlPlane: GoodVibesConfig['controlPlane'];
-  readonly httpListener: GoodVibesConfig['httpListener'];
-  readonly web: GoodVibesConfig['web'];
-}
-
 export interface OnboardingSurfaceRecord {
   readonly id: string;
   readonly kind: string;
@@ -162,7 +146,7 @@ export interface OnboardingAcknowledgementSnapshot {
 }
 
 export type OnboardingSnapshotCollectionIssueArea =
-  | 'services'
+  | 'host'
   | 'subscriptions-active'
   | 'subscriptions-pending'
   | 'auth'
@@ -187,7 +171,6 @@ export interface OnboardingSnapshotState {
   readonly subscriptions: OnboardingSubscriptionsSnapshot;
   readonly secrets: OnboardingSecretsSnapshot;
   readonly auth: OnboardingAuthSnapshot;
-  readonly bindSettings: OnboardingBindSettingsSnapshot;
   readonly surfaces: OnboardingSurfacesSnapshot;
   readonly providerAccounts: OnboardingProviderAccountsSnapshot | null;
   readonly localBehaviorDiscovery: AgentBehaviorDiscoverySnapshot;
@@ -271,6 +254,37 @@ export type OnboardingApplyOperation =
       readonly kind: 'create-agent-profile';
       readonly name: string;
       readonly templateId?: string;
+    }
+  | {
+      readonly kind: 'select-agent-profile';
+      readonly name: string;
+    }
+  | {
+      readonly kind: 'create-local-note';
+      readonly title: string;
+      readonly body: string;
+      readonly tags?: readonly string[];
+    }
+  | {
+      readonly kind: 'create-local-persona';
+      readonly name: string;
+      readonly description: string;
+      readonly body: string;
+      readonly activate?: boolean;
+    }
+  | {
+      readonly kind: 'create-local-skill';
+      readonly name: string;
+      readonly description: string;
+      readonly procedure: string;
+      readonly enabled?: boolean;
+    }
+  | {
+      readonly kind: 'create-local-routine';
+      readonly name: string;
+      readonly description: string;
+      readonly steps: string;
+      readonly enabled?: boolean;
     };
 
 export interface OnboardingApplyRequest {
@@ -383,7 +397,7 @@ export interface OnboardingSnapshotDependencies {
 
 export interface OnboardingApplyDependencies {
   readonly clock?: () => number;
-  readonly config: Pick<ConfigManager, 'get' | 'getRaw' | 'load' | 'setDynamic'>;
+  readonly config: Pick<ConfigManager, 'get' | 'getCategory' | 'getRaw' | 'load' | 'mergeCategory' | 'setDynamic'>;
   readonly secrets?: Pick<SecretsManager, 'delete' | 'get' | 'inspect' | 'set'>;
   readonly auth?: Pick<UserAuthManager, 'inspect'>;
   readonly shellPaths: OnboardingShellPaths;
@@ -392,7 +406,7 @@ export interface OnboardingApplyDependencies {
 
 export interface OnboardingVerificationDependencies {
   readonly clock?: () => number;
-  readonly config: Pick<ConfigManager, 'get'>;
+  readonly config: Pick<ConfigManager, 'get' | 'getCategory'>;
   readonly secrets?: Pick<SecretsManager, 'get'>;
   readonly auth?: Pick<UserAuthManager, 'inspect'>;
   readonly shellPaths: OnboardingShellPaths;

package/src/runtime/onboarding/verify.ts

@@ -1,7 +1,12 @@
 import { existsSync } from 'node:fs';
 import { join } from 'node:path';
 import { isSecretRefInput } from '@pellux/goodvibes-sdk/platform/config';
-import { resolveAgentRuntimeProfileHome } from '../../agent/runtime-profile.ts';
+import { AgentNoteRegistry } from '../../agent/note-registry.ts';
+import { AgentPersonaRegistry } from '../../agent/persona-registry.ts';
+import { AgentRoutineRegistry } from '../../agent/routine-registry.ts';
+import { readAgentRuntimeProfileSelection, resolveAgentRuntimeProfileHome } from '../../agent/runtime-profile.ts';
+import { AgentSkillRegistry } from '../../agent/skill-registry.ts';
+import { isFeatureFlagConfigKey, readFeatureFlagConfigValue } from '../surface-feature-flags.ts';
 import { readOnboardingRuntimeState } from './state.ts';
 import type {
   OnboardingApplyOperation,
@@ -31,7 +36,7 @@ function isDeepEqual(left: unknown, right: unknown): boolean {
     const rightEntries = Object.entries(right);
     if (leftEntries.length !== rightEntries.length) return false;
 
-    return leftEntries.every(([key, value]) => isDeepEqual(value, (right as Record<string, unknown>)[key]));
+    return leftEntries.every(([key, value]) => isDeepEqual(value, Reflect.get(right, key)));
   }
 
   return false;
@@ -46,7 +51,9 @@ function verifyConfigOperation(
   deps: OnboardingVerificationDependencies,
   operation: Extract<OnboardingApplyOperation, { kind: 'set-config' }>,
 ): OnboardingVerificationItem {
-  const actual = deps.config.get(operation.key as never);
+  const actual = isFeatureFlagConfigKey(operation.key)
+    ? readFeatureFlagConfigValue(deps.config, operation.key)
+    : deps.config.get(operation.key);
   const ok = isDeepEqual(actual, operation.value);
 
   return {
@@ -144,6 +151,95 @@ function verifyCreateAgentProfileOperation(
   };
 }
 
+function verifySelectAgentProfileOperation(
+  deps: OnboardingVerificationDependencies,
+  operation: Extract<OnboardingApplyOperation, { kind: 'select-agent-profile' }>,
+): OnboardingVerificationItem {
+  const resolution = resolveAgentRuntimeProfileHome(deps.shellPaths.homeDirectory, operation.name);
+  const selection = readAgentRuntimeProfileSelection(deps.shellPaths.homeDirectory);
+  const ok = selection?.id === resolution.id && selection.exists;
+  return {
+    id: `selected-agent-profile:${resolution.id}`,
+    status: ok ? 'pass' : 'fail',
+    message: ok
+      ? `${resolution.id} Agent profile is selected for later plain goodvibes-agent runs.`
+      : `${resolution.id} Agent profile is not selected for later plain goodvibes-agent runs.`,
+    target: resolution.id,
+  };
+}
+
+function verifyCreateLocalPersonaOperation(
+  deps: OnboardingVerificationDependencies,
+  operation: Extract<OnboardingApplyOperation, { kind: 'create-local-persona' }>,
+): OnboardingVerificationItem {
+  const registry = AgentPersonaRegistry.fromShellPaths(deps.shellPaths);
+  const persona = registry.get(operation.name);
+  const activeOk = operation.activate === false || registry.snapshot().activePersonaId === persona?.id;
+  const ok = persona !== null && activeOk;
+  const target = persona?.id ?? operation.name.trim();
+  return {
+    id: `local-persona:${target}`,
+    status: ok ? 'pass' : 'fail',
+    message: ok
+      ? `${target} Agent-local persona exists${operation.activate === false ? '' : ' and is active'}.`
+      : `${target} Agent-local persona was not created${operation.activate === false ? '' : ' or activated'}.`,
+    target,
+  };
+}
+
+function verifyCreateLocalSkillOperation(
+  deps: OnboardingVerificationDependencies,
+  operation: Extract<OnboardingApplyOperation, { kind: 'create-local-skill' }>,
+): OnboardingVerificationItem {
+  const skill = AgentSkillRegistry.fromShellPaths(deps.shellPaths).get(operation.name);
+  const enabledOk = operation.enabled === false || skill?.enabled === true;
+  const ok = skill !== null && enabledOk;
+  const target = skill?.id ?? operation.name.trim();
+  return {
+    id: `local-skill:${target}`,
+    status: ok ? 'pass' : 'fail',
+    message: ok
+      ? `${target} Agent-local skill exists${operation.enabled === false ? '' : ' and is enabled'}.`
+      : `${target} Agent-local skill was not created${operation.enabled === false ? '' : ' or enabled'}.`,
+    target,
+  };
+}
+
+function verifyCreateLocalRoutineOperation(
+  deps: OnboardingVerificationDependencies,
+  operation: Extract<OnboardingApplyOperation, { kind: 'create-local-routine' }>,
+): OnboardingVerificationItem {
+  const routine = AgentRoutineRegistry.fromShellPaths(deps.shellPaths).get(operation.name);
+  const enabledOk = operation.enabled === false || routine?.enabled === true;
+  const ok = routine !== null && enabledOk;
+  const target = routine?.id ?? operation.name.trim();
+  return {
+    id: `local-routine:${target}`,
+    status: ok ? 'pass' : 'fail',
+    message: ok
+      ? `${target} Agent-local routine exists${operation.enabled === false ? '' : ' and is enabled'}.`
+      : `${target} Agent-local routine was not created${operation.enabled === false ? '' : ' or enabled'}.`,
+    target,
+  };
+}
+
+function verifyCreateLocalNoteOperation(
+  deps: OnboardingVerificationDependencies,
+  operation: Extract<OnboardingApplyOperation, { kind: 'create-local-note' }>,
+): OnboardingVerificationItem {
+  const note = AgentNoteRegistry.fromShellPaths(deps.shellPaths).get(operation.title);
+  const ok = note !== null && note.body.trim() === operation.body.trim();
+  const target = note?.id ?? operation.title.trim();
+  return {
+    id: `local-note:${target}`,
+    status: ok ? 'pass' : 'fail',
+    message: ok
+      ? `${target} Agent-local note exists.`
+      : `${target} Agent-local note was not created.`,
+    target,
+  };
+}
+
 async function verifyOperation(
   deps: OnboardingVerificationDependencies,
   operation: OnboardingApplyOperation,
@@ -152,7 +248,12 @@ async function verifyOperation(
   if (operation.kind === 'set-secret') return verifySecretOperation(deps, operation);
   if (operation.kind === 'ensure-auth-user') return verifyAuthOperation(deps, operation);
   if (operation.kind === 'acknowledge') return verifyAcknowledgementOperation(deps, operation);
-  return verifyCreateAgentProfileOperation(deps, operation);
+  if (operation.kind === 'create-agent-profile') return verifyCreateAgentProfileOperation(deps, operation);
+  if (operation.kind === 'select-agent-profile') return verifySelectAgentProfileOperation(deps, operation);
+  if (operation.kind === 'create-local-note') return verifyCreateLocalNoteOperation(deps, operation);
+  if (operation.kind === 'create-local-persona') return verifyCreateLocalPersonaOperation(deps, operation);
+  if (operation.kind === 'create-local-skill') return verifyCreateLocalSkillOperation(deps, operation);
+  return verifyCreateLocalRoutineOperation(deps, operation);
 }
 
 export async function verifyOnboardingRequest(

package/src/runtime/operator-token-cleanup.ts

@@ -4,10 +4,10 @@
  * Shared helper that enumerates the legacy workspace-scoped `operator-tokens.json`
  * locations earlier GoodVibes builds may have written. Used by the in-process
  * bootstrap path so stale-token pruning has a single source of truth for where
- * to look. GoodVibes Agent itself does not own daemon startup.
+ * to look. GoodVibes Agent itself does not own connected-host startup.
  *
  * Adding a new legacy location: append to `workspaceOperatorTokenCandidates` and
- * the new path will be inspected on the next daemon boot.
+ * the new path will be inspected on the next connected-host boot.
  */
 
 import { join } from 'node:path';
@@ -16,7 +16,7 @@ import { join } from 'node:path';
  * Return the list of absolute operator-tokens.json paths the TUI may have written
  * at legacy (pre-0.21.28) workspace-scoped locations under `workingDirectory`.
  *
- * The canonical, current-SDK location is `<daemonHomeDir>/operator-tokens.json`;
+ * The canonical, current-SDK location is `<connectedHostTokenDir>/operator-tokens.json`;
  * this helper is strictly for legacy-cleanup candidates.
  */
 export function workspaceOperatorTokenCandidates(workingDirectory: string): readonly string[] {

package/src/runtime/services.ts

@@ -1,5 +1,7 @@
 import { join } from 'node:path';
 import { ConfigManager } from '@pellux/goodvibes-sdk/platform/config';
+import { shell as runtimeShell } from '@pellux/goodvibes-sdk/platform/runtime';
+import type { shell as RuntimeShell } from '@pellux/goodvibes-sdk/platform/runtime';
 import { SecretsManager } from '../config/secrets.ts';
 import { ServiceRegistry } from '@pellux/goodvibes-sdk/platform/config';
 import { SubscriptionManager } from '@pellux/goodvibes-sdk/platform/config';
@@ -11,6 +13,8 @@ import { WatcherRegistry } from '@pellux/goodvibes-sdk/platform/watchers';
 import { ArtifactStore } from '@pellux/goodvibes-sdk/platform/artifacts';
 import {
   GOODVIBES_AGENT_KNOWLEDGE_DB_FILE,
+  HOME_GRAPH_KNOWLEDGE_DB_FILE,
+  HOME_GRAPH_KNOWLEDGE_EXTENSION,
   KnowledgeService,
   KnowledgeSemanticService,
   KnowledgeStore,
@@ -19,6 +23,7 @@ import {
   createWebKnowledgeGapRepairer,
   projectPlanningProjectIdFromPath,
 } from '@pellux/goodvibes-sdk/platform/knowledge';
+import * as KnowledgePlatform 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';
@@ -73,11 +78,10 @@ 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 type { FeatureFlagManager, RuntimeFoundationClientsOptions } from '@/runtime/index.ts';
 import { createFeatureFlagManager } from '@/runtime/index.ts';
 import { PolicyRuntimeState } from '@/runtime/index.ts';
 import {
@@ -86,6 +90,19 @@ import {
 } from '@pellux/goodvibes-sdk/platform/tools';
 import { WorkPlanStore } from '../work-plans/work-plan-store.ts';
 
+type WorktreeRegistry = RuntimeShell.WorktreeRegistry;
+type SdkRuntimeServices = RuntimeFoundationClientsOptions['runtimeServices'];
+type SdkCompanionGraphService = NonNullable<SdkRuntimeServices>['homeGraphService'];
+type KnowledgeServiceConstructor = new (
+  store: KnowledgeStore,
+  artifactStore: ArtifactStore,
+  options?: unknown,
+) => SdkCompanionGraphService;
+
+const companionGraphServiceConstructor = KnowledgePlatform[
+  ['Home', 'GraphService'].join('') as keyof typeof KnowledgePlatform
+] as unknown as KnowledgeServiceConstructor;
+
 function buildFallbackModelDefinition(provider: string, modelId: string): ModelDefinition {
   const providerLower = provider.toLowerCase();
   const isReasoningProvider = providerLower.includes('openai')
@@ -101,7 +118,7 @@ function buildFallbackModelDefinition(provider: string, modelId: string): ModelD
     description: 'Configured model available before the model catalog cache has loaded.',
     capabilities: {
       toolCalling: true,
-      codeEditing: true,
+      codeEditing: false,
       reasoning: isReasoningProvider,
       multimodal: isReasoningProvider,
     },
@@ -113,6 +130,54 @@ function buildFallbackModelDefinition(provider: string, modelId: string): ModelD
   };
 }
 
+class DisabledAgentWorktreeRegistry extends runtimeShell.WorktreeRegistry {
+  public override async list(): Promise<Awaited<ReturnType<WorktreeRegistry['list']>>> {
+    return [] as Awaited<ReturnType<WorktreeRegistry['list']>>;
+  }
+
+  public override attach(_path: string, _target: { sessionId?: string; taskId?: string }): void {
+    throw new Error('GoodVibes Agent does not own local worktree attachment. Delegate build, fix, and review work to GoodVibes TUI.');
+  }
+
+  public override setState(_path: string, _state: Parameters<WorktreeRegistry['setState']>[1]): void {
+    throw new Error('GoodVibes Agent does not own local worktree state. Delegate build, fix, and review work to GoodVibes TUI.');
+  }
+
+  public override async cleanup(_path: string): Promise<void> {
+    throw new Error('GoodVibes Agent does not own local worktree cleanup. Delegate build, fix, and review work to GoodVibes TUI.');
+  }
+}
+
+function createDisabledAgentWorktreeRegistry(workingDirectory: string): WorktreeRegistry {
+  return new DisabledAgentWorktreeRegistry(workingDirectory, {
+    surfaceRoot: GOODVIBES_AGENT_SURFACE_ROOT,
+  });
+}
+
+type AgentWrfcWorktreeFactory = NonNullable<ConstructorParameters<typeof WrfcController>[2]['createWorktree']>;
+type AgentWrfcWorktreeOps = ReturnType<AgentWrfcWorktreeFactory>;
+
+function agentWrfcWorktreeError(operation: string): Error {
+  return new Error(`GoodVibes Agent does not own local review worktree ${operation}. Delegate build, fix, and review work to GoodVibes TUI.`);
+}
+
+function createDisabledAgentWrfcWorktreeOps(): AgentWrfcWorktreeOps {
+  return {
+    async merge(_agentId: string): Promise<boolean> {
+      throw agentWrfcWorktreeError('merge');
+    },
+    async cleanup(_agentId: string): Promise<void> {
+      throw agentWrfcWorktreeError('cleanup');
+    },
+    async commitWorkingTree(_message: string): Promise<string | null> {
+      throw agentWrfcWorktreeError('commit');
+    },
+    async currentHead(): Promise<string | null> {
+      return null;
+    },
+  };
+}
+
 function ensureConfiguredModelIsRoutable(providerRegistry: ProviderRegistry, configManager: ConfigManager): void {
   const configuredModel = String(configManager.get('provider.model') ?? '').trim();
   if (!configuredModel.includes(':')) return;
@@ -254,7 +319,7 @@ export interface RuntimeServicesOptions {
   readonly homeDirectory: string;
 }
 
-export interface RuntimeServices {
+export interface RuntimeServices extends SdkRuntimeServices {
   readonly workingDirectory: string;
   readonly homeDirectory: string;
   readonly shellPaths: ShellPathService;
@@ -276,9 +341,10 @@ export interface RuntimeServices {
   readonly automationManager: AutomationManager;
   readonly gatewayMethods: GatewayMethodCatalog;
   readonly artifactStore: ArtifactStore;
-  /** Compatibility alias that intentionally points at the isolated Agent Knowledge service, not default Knowledge/Wiki. */
+  /** Compatibility alias that intentionally points at the isolated Agent Knowledge service, not default knowledge. */
   readonly knowledgeService: KnowledgeService;
   readonly agentKnowledgeService: KnowledgeService;
+  readonly homeGraphService: SdkCompanionGraphService;
   readonly projectPlanningService: ProjectPlanningService;
   readonly projectPlanningProjectId: string;
   readonly workPlanStore: WorkPlanStore;
@@ -345,7 +411,7 @@ export interface RuntimeServices {
    * Agent memory is home/profile-owned and intentionally does not move on workspace swap.
    * 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.
+   * the old path until the externally owned GoodVibes host restarts with the new --working-dir.
    */
   rerootStores(newWorkingDir: string): Promise<void>;
 }
@@ -443,12 +509,13 @@ export function createRuntimeServices(options: RuntimeServicesOptions): RuntimeS
     configManager,
   });
   agentManager.setRuntimeBus(options.runtimeBus);
-  const wrfcController = new WrfcController(options.runtimeBus, agentMessageBus, {
+  const wrfcController = Reflect.construct(WrfcController, [options.runtimeBus, agentMessageBus, {
     agentManager,
     configManager,
     projectRoot: workingDirectory,
-  });
-  agentManager.setWrfcController(wrfcController);
+    surfaceRoot: GOODVIBES_AGENT_SURFACE_ROOT,
+    createWorktree: createDisabledAgentWrfcWorktreeOps,
+  }]) as WrfcController;
   const hookDispatcher = new HookDispatcher({ toolLLM, projectRoot: workingDirectory }, hookActivityTracker);
   configManager.attachHookDispatcher(hookDispatcher);
   const hookWorkbench = createHookWorkbench({
@@ -496,7 +563,7 @@ export function createRuntimeServices(options: RuntimeServicesOptions): RuntimeS
     deliveryManager,
     spawnTask: (input) => {
       throw new Error([
-        'GoodVibes Agent does not spawn local automation agents.',
+        'GoodVibes Agent does not create local automation jobs and 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(' '));
@@ -506,6 +573,10 @@ export function createRuntimeServices(options: RuntimeServicesOptions): RuntimeS
     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,
@@ -514,12 +585,20 @@ export function createRuntimeServices(options: RuntimeServicesOptions): RuntimeS
     llm: knowledgeSemanticLlm,
     maxLlmSourcesPerReindex: 3,
   });
+  const homeGraphSemanticService = new KnowledgeSemanticService(homeGraphKnowledgeStore, {
+    llm: knowledgeSemanticLlm,
+    maxLlmSourcesPerReindex: 3,
+    objectProfiles: HOME_GRAPH_KNOWLEDGE_EXTENSION.objectProfiles,
+  });
   const agentKnowledgeService = new KnowledgeService(agentKnowledgeStore, artifactStore, undefined, {
     memoryRegistry,
     runtimeBus: options.runtimeBus,
     semanticService: agentKnowledgeSemanticService,
   });
   agentKnowledgeService.attachRuntimeBus(options.runtimeBus);
+  const homeGraphService = new companionGraphServiceConstructor(homeGraphKnowledgeStore, artifactStore, {
+    semanticService: homeGraphSemanticService,
+  });
   const projectPlanningProjectId = projectPlanningProjectIdFromPath(workingDirectory);
   const projectPlanningService = new ProjectPlanningService(agentKnowledgeStore, {
     defaultProjectId: projectPlanningProjectId,
@@ -544,6 +623,10 @@ export function createRuntimeServices(options: RuntimeServicesOptions): RuntimeS
     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, agentKnowledgeService);
@@ -578,7 +661,7 @@ export function createRuntimeServices(options: RuntimeServicesOptions): RuntimeS
   mcpRegistry.setSandboxRuntime(configManager, sandboxSessionRegistry);
   const tokenAuditor = new ApiTokenAuditor({ managed: false });
   const componentHealthMonitor = new ComponentHealthMonitor();
-  const worktreeRegistry = new WorktreeRegistry(workingDirectory);
+  const worktreeRegistry = createDisabledAgentWorktreeRegistry(workingDirectory);
   const webhookNotifier = new WebhookNotifier();
   const replayEngine = new DeterministicReplayEngine(workingDirectory);
   const providerOptimizer = new ProviderOptimizer(providerRegistry, providerCapabilityRegistry, false);
@@ -672,6 +755,7 @@ export function createRuntimeServices(options: RuntimeServicesOptions): RuntimeS
     artifactStore,
     knowledgeService: agentKnowledgeService,
     agentKnowledgeService,
+    homeGraphService,
     projectPlanningService,
     projectPlanningProjectId,
     workPlanStore,

package/src/runtime/store/selectors/index.ts

@@ -53,7 +53,7 @@ export function selectOverlays(state: RuntimeState): OverlayDomainState {
   return state.overlays;
 }
 
-/** Select the full panels domain slice. Casts from Record<string,unknown> to PanelDomainState. */
+/** Select the full panels domain slice. */
 export function selectPanels(state: RuntimeState): PanelDomainState {
   return state.panels as unknown as PanelDomainState;
 }
@@ -274,7 +274,7 @@ export function selectPermissionMode(state: RuntimeState): PermissionMode {
  */
 export function selectActivePanels(state: RuntimeState): PanelState[] {
   const result: PanelState[] = [];
-  const panelDomain = state.panels as unknown as PanelDomainState;
+  const panelDomain = selectPanels(state);
   for (const panel of panelDomain.panels.values()) {
     if (panel.open) {
       result.push(panel);
@@ -287,7 +287,7 @@ export function selectActivePanels(state: RuntimeState): PanelState[] {
  * Returns the panel currently holding focus.
  */
 export function selectFocusedPanel(state: RuntimeState): PanelState | undefined {
-  const panelDomain = state.panels as unknown as PanelDomainState;
+  const panelDomain = selectPanels(state);
   return panelDomain.panels.get(panelDomain.focusedPanelId);
 }
 

package/src/runtime/store/state.ts

@@ -76,10 +76,7 @@ export interface RuntimeState {
   model: ModelDomainState;
   conversation: ConversationDomainState;
   overlays: OverlayDomainState;
-  /**
-   * TUI panel state. Typed as Record<string,unknown> for SDK RuntimeState
-   * compatibility. Use selectPanels() which casts to PanelDomainState.
-   */
+  /** TUI panel state, exposed through the SDK-compatible runtime store shape. */
   panels: Record<string, unknown>;
   permissions: PermissionDomainState;
   tasks: TaskDomainState;

package/src/runtime/surface-feature-flags.ts

@@ -1,4 +1,4 @@
-import type { ConfigKey, ConfigManager, PersistedFlagState } from '../config/index.ts';
+import type { ConfigManager, PersistedFlagState } from '../config/index.ts';
 import { surfaceFeatureGateId } from '@/runtime/index.ts';
 
 export const CONTROL_PLANE_FEATURE_FLAG = 'control-plane-gateway';
@@ -14,6 +14,42 @@ const CORE_CHANNEL_FEATURE_FLAGS = [
 
 export type FeatureFlagConfigKey = 'featureFlags' | `featureFlags.${string}`;
 
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+
+export function isFeatureFlagConfigKey(key: string): key is FeatureFlagConfigKey {
+  return key === 'featureFlags' || key.startsWith('featureFlags.');
+}
+
+function isPersistedFlagState(value: unknown): value is PersistedFlagState {
+  return value === 'enabled' || value === 'disabled';
+}
+
+export function readFeatureFlagConfigValue(config: Pick<ConfigManager, 'getCategory'>, key: FeatureFlagConfigKey): unknown {
+  const flags = config.getCategory('featureFlags');
+  if (key === 'featureFlags') return flags;
+  return flags[key.slice('featureFlags.'.length)];
+}
+
+export function mergeFeatureFlagConfigValue(config: Pick<ConfigManager, 'mergeCategory'>, key: FeatureFlagConfigKey, value: unknown): void {
+  if (key === 'featureFlags') {
+    if (!isRecord(value)) throw new Error('featureFlags expects an object value.');
+    const patch: Partial<Record<string, PersistedFlagState>> = {};
+    for (const [flagId, state] of Object.entries(value)) {
+      if (!isPersistedFlagState(state)) throw new Error(`featureFlags.${flagId} expects enabled or disabled.`);
+      patch[flagId] = state;
+    }
+    config.mergeCategory('featureFlags', patch);
+    return;
+  }
+
+  if (!isPersistedFlagState(value)) throw new Error(`${key} expects enabled or disabled.`);
+  config.mergeCategory('featureFlags', {
+    [key.slice('featureFlags.'.length)]: value,
+  });
+}
+
 export function getSurfaceFeatureFlag(surfaceId: string): string | null {
   return surfaceFeatureGateId(surfaceId);
 }
@@ -47,7 +83,7 @@ export function getServerSurfaceFeatureFlags(options: {
 }
 
 export function isFeatureFlagEnabled(config: Pick<ConfigManager, 'getCategory'>, flagId: string): boolean {
-  const flags = (config.getCategory('featureFlags') as Record<string, PersistedFlagState | undefined>) ?? {};
+  const flags = config.getCategory('featureFlags');
   return flags[flagId] === 'enabled';
 }
 
@@ -58,8 +94,7 @@ export function getMissingSurfaceFeatureFlags(config: Pick<ConfigManager, 'getCa
   return required.filter((flagId) => !isFeatureFlagEnabled(config, flagId));
 }
 
-export function enableFeatureFlags(config: Pick<ConfigManager, 'setDynamic'>, flagIds: readonly string[]): void {
-  for (const flagId of flagIds) {
-    config.setDynamic(`featureFlags.${flagId}` as ConfigKey, 'enabled');
-  }
+export function enableFeatureFlags(config: Pick<ConfigManager, 'mergeCategory'>, flagIds: readonly string[]): void {
+  const patch = Object.fromEntries(flagIds.map((flagId) => [flagId, 'enabled'] as const));
+  config.mergeCategory('featureFlags', patch);
 }

package/src/runtime/ui-read-models.ts

@@ -53,10 +53,9 @@ export function createUiReadModels(
   runtimeServices: RuntimeServices,
   options: UiReadModelOptions = {},
 ): UiReadModels {
-  const sdkRuntimeServices = runtimeServices as unknown as Parameters<typeof createCoreReadModels>[0];
   return {
-    ...createCoreReadModels(sdkRuntimeServices),
-    ...createOperationsReadModels(sdkRuntimeServices, options),
-    ...createObservabilityReadModels(sdkRuntimeServices, options),
+    ...createCoreReadModels(runtimeServices),
+    ...createOperationsReadModels(runtimeServices, options),
+    ...createObservabilityReadModels(runtimeServices, options),
   };
 }