@pellux/goodvibes-agent 0.1.114 → 0.1.117

package/src/runtime/onboarding/apply.ts

@@ -5,8 +5,14 @@ import { CONFIG_SCHEMA, DEFAULT_CONFIG } from '../../config/index.ts';
 import {
   createAgentRuntimeProfile,
   getAgentRuntimeProfileTemplate,
+  getAgentRuntimeProfileSelectionPath,
+  readAgentRuntimeProfileSelection,
   resolveAgentRuntimeProfileHome,
+  setAgentRuntimeProfileSelection,
 } from '../../agent/runtime-profile.ts';
+import { AgentPersonaRegistry, assertNoSecretLikeText } from '../../agent/persona-registry.ts';
+import { AgentRoutineRegistry } from '../../agent/routine-registry.ts';
+import { AgentSkillRegistry } from '../../agent/skill-registry.ts';
 import type { FeatureFlagConfigKey } from '../surface-feature-flags.ts';
 import {
   getOnboardingRuntimeStatePath,
@@ -222,6 +228,65 @@ function validateCreateAgentProfileOperation(
   if (templateId) getAgentRuntimeProfileTemplate(templateId, deps.shellPaths.homeDirectory);
 }
 
+function validateSelectAgentProfileOperation(
+  deps: OnboardingApplyDependencies,
+  operation: Extract<OnboardingApplyOperation, { kind: 'select-agent-profile' }>,
+): void {
+  const name = operation.name.trim();
+  if (name.length === 0) throw new Error('Agent profile name is required.');
+  const resolution = resolveAgentRuntimeProfileHome(deps.shellPaths.homeDirectory, name);
+  if (!existsSync(resolution.homeDirectory)) {
+    throw new Error(`Agent profile does not exist: ${resolution.id}`);
+  }
+}
+
+function validateCreateLocalPersonaOperation(
+  deps: OnboardingApplyDependencies,
+  operation: Extract<OnboardingApplyOperation, { kind: 'create-local-persona' }>,
+): void {
+  const name = operation.name.trim();
+  const description = operation.description.trim();
+  const body = operation.body.trim();
+  if (!name) throw new Error('Persona name is required.');
+  if (!description) throw new Error('Persona description is required.');
+  if (!body) throw new Error('Persona body is required.');
+  assertNoSecretLikeText([name, description, body]);
+  const duplicate = AgentPersonaRegistry.fromShellPaths(deps.shellPaths).get(name);
+  if (duplicate) throw new Error(`Persona already exists: ${duplicate.id}`);
+}
+
+function validateCreateLocalSkillOperation(
+  deps: OnboardingApplyDependencies,
+  operation: Extract<OnboardingApplyOperation, { kind: 'create-local-skill' }>,
+): void {
+  const registry = AgentSkillRegistry.fromShellPaths(deps.shellPaths);
+  const name = operation.name.trim();
+  const description = operation.description.trim();
+  const procedure = operation.procedure.trim();
+  if (!name) throw new Error('Skill name is required.');
+  if (!description) throw new Error('Skill description is required.');
+  if (!procedure) throw new Error('Skill procedure is required.');
+  assertNoSecretLikeText([name, description, procedure]);
+  const duplicate = registry.get(name);
+  if (duplicate) throw new Error(`Skill already exists: ${duplicate.id}`);
+}
+
+function validateCreateLocalRoutineOperation(
+  deps: OnboardingApplyDependencies,
+  operation: Extract<OnboardingApplyOperation, { kind: 'create-local-routine' }>,
+): void {
+  const registry = AgentRoutineRegistry.fromShellPaths(deps.shellPaths);
+  const name = operation.name.trim();
+  const description = operation.description.trim();
+  const steps = operation.steps.trim();
+  if (!name) throw new Error('Routine name is required.');
+  if (!description) throw new Error('Routine description is required.');
+  if (!steps) throw new Error('Routine steps are required.');
+  assertNoSecretLikeText([name, description, steps]);
+  const duplicate = registry.get(name);
+  if (duplicate) throw new Error(`Routine already exists: ${duplicate.id}`);
+}
+
 function applyConfigOperation(
   deps: OnboardingApplyDependencies,
   operation: Extract<OnboardingApplyOperation, { kind: 'set-config' }>,
@@ -322,6 +387,26 @@ async function buildRollbackAction(
     };
   }
 
+  if (operation.kind === 'select-agent-profile') {
+    const path = getAgentRuntimeProfileSelectionPath(deps.shellPaths.homeDirectory);
+    return snapshotFileRollback(path);
+  }
+
+  if (operation.kind === 'create-local-persona') {
+    const registry = AgentPersonaRegistry.fromShellPaths(deps.shellPaths);
+    return snapshotFileRollback(registry.snapshot().path);
+  }
+
+  if (operation.kind === 'create-local-skill') {
+    const registry = AgentSkillRegistry.fromShellPaths(deps.shellPaths);
+    return snapshotFileRollback(registry.snapshot().path);
+  }
+
+  if (operation.kind === 'create-local-routine') {
+    const registry = AgentRoutineRegistry.fromShellPaths(deps.shellPaths);
+    return snapshotFileRollback(registry.snapshot().path);
+  }
+
   const neverOperation: never = operation;
   throw new Error(`Unsupported onboarding operation: ${JSON.stringify(neverOperation)}`);
 }
@@ -364,6 +449,73 @@ function applyCreateAgentProfileOperation(
   };
 }
 
+function applySelectAgentProfileOperation(
+  deps: OnboardingApplyDependencies,
+  operation: Extract<OnboardingApplyOperation, { kind: 'select-agent-profile' }>,
+): OnboardingAppliedOperation {
+  validateSelectAgentProfileOperation(deps, operation);
+  const selection = setAgentRuntimeProfileSelection(deps.shellPaths.homeDirectory, operation.name);
+  return {
+    kind: operation.kind,
+    summary: `Selected Agent profile ${selection.id} for future launches.`,
+  };
+}
+
+function applyCreateLocalPersonaOperation(
+  deps: OnboardingApplyDependencies,
+  operation: Extract<OnboardingApplyOperation, { kind: 'create-local-persona' }>,
+): OnboardingAppliedOperation {
+  const registry = AgentPersonaRegistry.fromShellPaths(deps.shellPaths);
+  const persona = registry.create({
+    name: operation.name,
+    description: operation.description,
+    body: operation.body,
+    source: 'user',
+    provenance: 'onboarding',
+  });
+  if (operation.activate !== false) registry.setActive(persona.id);
+  return {
+    kind: operation.kind,
+    summary: `Created local Agent persona ${persona.id}.`,
+  };
+}
+
+function applyCreateLocalSkillOperation(
+  deps: OnboardingApplyDependencies,
+  operation: Extract<OnboardingApplyOperation, { kind: 'create-local-skill' }>,
+): OnboardingAppliedOperation {
+  const skill = AgentSkillRegistry.fromShellPaths(deps.shellPaths).create({
+    name: operation.name,
+    description: operation.description,
+    procedure: operation.procedure,
+    enabled: operation.enabled !== false,
+    source: 'user',
+    provenance: 'onboarding',
+  });
+  return {
+    kind: operation.kind,
+    summary: `Created local Agent skill ${skill.id}.`,
+  };
+}
+
+function applyCreateLocalRoutineOperation(
+  deps: OnboardingApplyDependencies,
+  operation: Extract<OnboardingApplyOperation, { kind: 'create-local-routine' }>,
+): OnboardingAppliedOperation {
+  const routine = AgentRoutineRegistry.fromShellPaths(deps.shellPaths).create({
+    name: operation.name,
+    description: operation.description,
+    steps: operation.steps,
+    enabled: operation.enabled !== false,
+    source: 'user',
+    provenance: 'onboarding',
+  });
+  return {
+    kind: operation.kind,
+    summary: `Created local Agent routine ${routine.id}.`,
+  };
+}
+
 function orderApplyOperations(
   operations: readonly OnboardingApplyOperation[],
 ): readonly OnboardingApplyOperation[] {
@@ -376,6 +528,12 @@ function orderApplyOperations(
     operation.kind === 'set-config' && operation.key !== 'storage.secretPolicy'
   ));
   const agentProfileOperations = operations.filter((operation) => operation.kind === 'create-agent-profile');
+  const agentProfileSelectionOperations = operations.filter((operation) => operation.kind === 'select-agent-profile');
+  const localBehaviorOperations = operations.filter((operation) => (
+    operation.kind === 'create-local-persona'
+    || operation.kind === 'create-local-skill'
+    || operation.kind === 'create-local-routine'
+  ));
   const finalOperations = operations.filter((operation) => (
     operation.kind === 'acknowledge'
   ));
@@ -386,6 +544,8 @@ function orderApplyOperations(
     ...secretOperations,
     ...configOperations,
     ...agentProfileOperations,
+    ...agentProfileSelectionOperations,
+    ...localBehaviorOperations,
     ...finalOperations,
   ];
 }
@@ -427,6 +587,31 @@ function prevalidateApplyRequest(
         continue;
       }
 
+      if (operation.kind === 'select-agent-profile') {
+        const createdEarlier = orderedOperations.some((candidate) => (
+          candidate.kind === 'create-agent-profile'
+          && resolveAgentRuntimeProfileHome(deps.shellPaths.homeDirectory, candidate.name).id
+            === resolveAgentRuntimeProfileHome(deps.shellPaths.homeDirectory, operation.name).id
+        ));
+        if (!createdEarlier) validateSelectAgentProfileOperation(deps, operation);
+        continue;
+      }
+
+      if (operation.kind === 'create-local-persona') {
+        validateCreateLocalPersonaOperation(deps, operation);
+        continue;
+      }
+
+      if (operation.kind === 'create-local-skill') {
+        validateCreateLocalSkillOperation(deps, operation);
+        continue;
+      }
+
+      if (operation.kind === 'create-local-routine') {
+        validateCreateLocalRoutineOperation(deps, operation);
+        continue;
+      }
+
       const neverOperation: never = operation;
       throw new Error(`Unsupported onboarding operation: ${JSON.stringify(neverOperation)}`);
     } catch (error) {
@@ -446,6 +631,10 @@ function getVerificationFailureKind(itemId: string): OnboardingApplyOperation['k
   if (itemId.startsWith('auth:')) return 'ensure-auth-user';
   if (itemId.startsWith('acknowledge:')) return 'acknowledge';
   if (itemId.startsWith('agent-profile:')) return 'create-agent-profile';
+  if (itemId.startsWith('selected-agent-profile:')) return 'select-agent-profile';
+  if (itemId.startsWith('local-persona:')) return 'create-local-persona';
+  if (itemId.startsWith('local-skill:')) return 'create-local-skill';
+  if (itemId.startsWith('local-routine:')) return 'create-local-routine';
   return 'set-config';
 }
 
@@ -502,6 +691,30 @@ export async function applyOnboardingRequest(
           continue;
         }
 
+        if (operation.kind === 'select-agent-profile') {
+          applied.push(applySelectAgentProfileOperation(deps, operation));
+          rollbacks.push(rollback);
+          continue;
+        }
+
+        if (operation.kind === 'create-local-persona') {
+          applied.push(applyCreateLocalPersonaOperation(deps, operation));
+          rollbacks.push(rollback);
+          continue;
+        }
+
+        if (operation.kind === 'create-local-skill') {
+          applied.push(applyCreateLocalSkillOperation(deps, operation));
+          rollbacks.push(rollback);
+          continue;
+        }
+
+        if (operation.kind === 'create-local-routine') {
+          applied.push(applyCreateLocalRoutineOperation(deps, operation));
+          rollbacks.push(rollback);
+          continue;
+        }
+
         const neverOperation: never = operation;
         throw new Error(`Unsupported onboarding operation: ${JSON.stringify(neverOperation)}`);
       } catch (error) {

package/src/runtime/onboarding/derivation.ts

@@ -211,7 +211,8 @@ function hasExternalIntegrations(snapshot: OnboardingSnapshotState): boolean {
 function hasLocalBehaviorCustomization(snapshot: OnboardingSnapshotState): boolean {
   return hasCustomizedWorkspaceDefaults(snapshot)
     || countPermissionToolOverrides(snapshot) > 0
-    || snapshot.runtimeDefaults.secretStoragePolicy !== DEFAULT_CONFIG.storage.secretPolicy;
+    || snapshot.runtimeDefaults.secretStoragePolicy !== DEFAULT_CONFIG.storage.secretPolicy
+    || countDiscoveredLocalBehavior(snapshot) > 0;
 }
 
 function hasCommunicationChannelSignals(snapshot: OnboardingSnapshotState): boolean {
@@ -223,7 +224,7 @@ function hasAutomationReviewSignals(snapshot: OnboardingSnapshotState): boolean
 }
 
 function describeOperatorTerminal(): string {
-  return 'Use GoodVibes Agent as the terminal operator while connecting to existing GoodVibes services. Agent setup does not create new entrypoints.';
+  return 'Use GoodVibes Agent as the terminal operator while connecting to an existing GoodVibes host. Agent setup does not create new entrypoints.';
 }
 
 function describeProviderAccess(snapshot: OnboardingSnapshotState): string {
@@ -240,6 +241,18 @@ function describeAgentKnowledge(): string {
 }
 
 function describeLocalBehavior(snapshot: OnboardingSnapshotState): string {
+  const discoveredCount = countDiscoveredLocalBehavior(snapshot);
+  if (discoveredCount > 0) {
+    const discovery = snapshot.localBehaviorDiscovery;
+    const samples = [
+      ...discovery.personas.names,
+      ...discovery.skills.names,
+      ...discovery.routines.names,
+    ].slice(0, 4);
+    const sampleText = samples.length > 0 ? ` Found: ${samples.join(', ')}.` : '';
+    return `Import ${discoveredCount} discovered Agent persona/skill/routine file(s) from local Agent folders before creating blank behavior.${sampleText}`;
+  }
+
   if (!hasLocalBehaviorCustomization(snapshot)) {
     return 'Configure local memory, routines, skills, personas, permissions, and secret handling before the Agent starts doing useful work.';
   }
@@ -247,6 +260,12 @@ function describeLocalBehavior(snapshot: OnboardingSnapshotState): string {
   return 'Review existing local behavior, permission, display, or secret-handling choices before applying Agent setup.';
 }
 
+function countDiscoveredLocalBehavior(snapshot: OnboardingSnapshotState): number {
+  return snapshot.localBehaviorDiscovery.personas.count
+    + snapshot.localBehaviorDiscovery.skills.count
+    + snapshot.localBehaviorDiscovery.routines.count;
+}
+
 function describeCommunicationChannels(snapshot: OnboardingSnapshotState): string {
   const integrationCount = new Set<string>([
     ...getExternalIntegrationServiceIds(snapshot),
@@ -439,23 +458,23 @@ export function deriveReopenEditAcknowledgementState(
         snapshot,
         'auth',
         'bootstrap-credential',
-        'A connected-service bootstrap credential signal is still visible to Agent.',
+        'A connected-host bootstrap credential signal is still visible to Agent.',
       )
     : authSessionCount > 0
       ? buildRequiredAcknowledgement(
           snapshot,
           'auth',
           'active-sessions',
-          `${authSessionCount} connected-service auth session signal(s) are currently visible.`,
+          `${authSessionCount} connected-host auth session signal(s) are currently visible.`,
         )
       : authUserCount > 0
         ? buildRequiredAcknowledgement(
             snapshot,
             'auth',
             'auth-state',
-            `${authUserCount} connected-service auth user signal(s) are already visible.`,
+            `${authUserCount} connected-host auth user signal(s) are already visible.`,
           )
-        : buildNotNeededAcknowledgement(snapshot, 'auth', 'No connected-service auth signal needs confirmation.');
+        : buildNotNeededAcknowledgement(snapshot, 'auth', 'No connected-host auth signal needs confirmation.');
 
   return {
     providers,

package/src/runtime/onboarding/snapshot.ts

@@ -1,6 +1,7 @@
 import type { SecretStorageReview } from '../../config/secrets.ts';
 import { getProviderIdFromModel } from '../../config/provider-model.ts';
 import type { LocalAuthSnapshot } from '@pellux/goodvibes-sdk/platform/security';
+import { summarizeAgentBehaviorDiscovery } from '../../agent/behavior-discovery-summary.ts';
 import { readOnboardingRuntimeState } from './state.ts';
 import type {
   OnboardingAcknowledgementSnapshot,
@@ -98,7 +99,7 @@ async function buildServicesSnapshot(
       },
       issues: [
         {
-          area: 'services',
+          area: 'host',
           message: error instanceof Error ? error.message : String(error),
         },
       ],
@@ -145,7 +146,7 @@ async function buildServicesSnapshot(
           hasAppToken: false,
         } satisfies OnboardingServiceState,
         issue: {
-          area: 'services',
+          area: 'host',
           message: `${name}: ${error instanceof Error ? error.message : String(error)}`,
         } satisfies OnboardingSnapshotCollectionIssue,
       };
@@ -400,6 +401,7 @@ export async function collectOnboardingSnapshot(
       records: sortSurfaceRecords(surfaceResult.value),
     },
     providerAccounts: providerAccountsResult.value,
+    localBehaviorDiscovery: summarizeAgentBehaviorDiscovery(deps.shellPaths),
     collectionIssues,
   };
 }

package/src/runtime/onboarding/types.ts

@@ -8,6 +8,7 @@ import type {
   ServiceInspectionQuery,
   SubscriptionAccessQuery,
 } from '../ui-service-queries.ts';
+import type { AgentBehaviorDiscoverySnapshot } from '../../agent/behavior-discovery-summary.ts';
 
 export type OnboardingMode = 'new' | 'edit' | 'reopen';
 
@@ -161,7 +162,7 @@ export interface OnboardingAcknowledgementSnapshot {
 }
 
 export type OnboardingSnapshotCollectionIssueArea =
-  | 'services'
+  | 'host'
   | 'subscriptions-active'
   | 'subscriptions-pending'
   | 'auth'
@@ -189,6 +190,7 @@ export interface OnboardingSnapshotState {
   readonly bindSettings: OnboardingBindSettingsSnapshot;
   readonly surfaces: OnboardingSurfacesSnapshot;
   readonly providerAccounts: OnboardingProviderAccountsSnapshot | null;
+  readonly localBehaviorDiscovery: AgentBehaviorDiscoverySnapshot;
   readonly collectionIssues: readonly OnboardingSnapshotCollectionIssue[];
 }
 
@@ -269,6 +271,31 @@ 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-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 {

package/src/runtime/onboarding/verify.ts

@@ -1,7 +1,10 @@
 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 { 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 { readOnboardingRuntimeState } from './state.ts';
 import type {
   OnboardingApplyOperation,
@@ -144,6 +147,78 @@ 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 future launches.`
+      : `${resolution.id} Agent profile is not selected for future launches.`,
+    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} local Agent persona exists${operation.activate === false ? '' : ' and is active'}.`
+      : `${target} local Agent 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} local Agent skill exists${operation.enabled === false ? '' : ' and is enabled'}.`
+      : `${target} local Agent 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} local Agent routine exists${operation.enabled === false ? '' : ' and is enabled'}.`
+      : `${target} local Agent routine was not created${operation.enabled === false ? '' : ' or enabled'}.`,
+    target,
+  };
+}
+
 async function verifyOperation(
   deps: OnboardingVerificationDependencies,
   operation: OnboardingApplyOperation,
@@ -152,7 +227,11 @@ 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-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';

package/src/runtime/services.ts

@@ -23,7 +23,7 @@ import { MediaProviderRegistry, ensureBuiltinMediaProviders } from '@pellux/good
 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 type { 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';
@@ -73,7 +73,7 @@ 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 type { 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';
@@ -101,7 +101,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 +113,24 @@ function buildFallbackModelDefinition(provider: string, modelId: string): ModelD
   };
 }
 
+function createDisabledAgentWorktreeRegistry(): WorktreeRegistry {
+  const registry: Pick<WorktreeRegistry, 'list' | 'attach' | 'setState' | 'cleanup'> = {
+    async list() {
+      return [];
+    },
+    attach(_path, _target) {
+      throw new Error('GoodVibes Agent does not own local worktree attachment. Delegate build, fix, and review work to GoodVibes TUI.');
+    },
+    setState(_path, _state) {
+      throw new Error('GoodVibes Agent does not own local worktree state. Delegate build, fix, and review work to GoodVibes TUI.');
+    },
+    async cleanup(_path) {
+      throw new Error('GoodVibes Agent does not own local worktree cleanup. Delegate build, fix, and review work to GoodVibes TUI.');
+    },
+  };
+  return registry as unknown as WorktreeRegistry;
+}
+
 function ensureConfiguredModelIsRoutable(providerRegistry: ProviderRegistry, configManager: ConfigManager): void {
   const configuredModel = String(configManager.get('provider.model') ?? '').trim();
   if (!configuredModel.includes(':')) return;
@@ -335,7 +353,7 @@ export interface RuntimeServices {
   readonly agentManager: AgentManager;
   readonly agentMessageBus: AgentMessageBus;
   readonly agentOrchestrator: AgentOrchestrator;
-  readonly wrfcController: WrfcController;
+  readonly wrfcController: Pick<WrfcController, 'listChains'>;
   readonly processManager: ProcessManager;
   readonly modeManager: ModeManager;
   readonly fileUndoManager: FileUndoManager;
@@ -345,7 +363,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 +461,9 @@ export function createRuntimeServices(options: RuntimeServicesOptions): RuntimeS
     configManager,
   });
   agentManager.setRuntimeBus(options.runtimeBus);
-  const wrfcController = new WrfcController(options.runtimeBus, agentMessageBus, {
-    agentManager,
-    configManager,
-    projectRoot: workingDirectory,
-  });
-  agentManager.setWrfcController(wrfcController);
+  const wrfcController: Pick<WrfcController, 'listChains'> = {
+    listChains: () => [],
+  };
   const hookDispatcher = new HookDispatcher({ toolLLM, projectRoot: workingDirectory }, hookActivityTracker);
   configManager.attachHookDispatcher(hookDispatcher);
   const hookWorkbench = createHookWorkbench({
@@ -578,7 +593,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();
   const webhookNotifier = new WebhookNotifier();
   const replayEngine = new DeterministicReplayEngine(workingDirectory);
   const providerOptimizer = new ProviderOptimizer(providerRegistry, providerCapabilityRegistry, false);