@pellux/goodvibes-agent 0.1.116 → 1.0.0

package/src/runtime/index.ts

@@ -97,7 +97,6 @@ export const restoreRuntimeModel = bootstrap.restoreRuntimeModel;
 export const restoreSavedModel = bootstrap.restoreRuntimeModel;
 export const synchronizeConfiguredServices = bootstrap.synchronizeConfiguredServices;
 export const syncConfiguredServices = bootstrap.synchronizeConfiguredServices;
-export const registerBootstrapRuntimeEvents = bootstrap.registerBootstrapRuntimeEvents;
 export const registerHostRuntimeEvents = bootstrap.registerHostRuntimeEvents;
 function agentExternalHostStatus(
   config: Bootstrap.HostServicesConfig,
@@ -113,7 +112,7 @@ function agentExternalHostStatus(
     port,
     baseUrl: `http://${host}:${port}`,
     reason: service === 'daemon'
-      ? 'GoodVibes Agent connects to GoodVibes services owned outside this product and does not start or restart them.'
+      ? 'GoodVibes Agent connects to a GoodVibes host owned outside this product and does not start or restart it.'
       : 'GoodVibes Agent does not own listener lifecycle.',
   };
 }
@@ -245,7 +244,6 @@ export type RemoteRuntimeEvents = Transport.RemoteRuntimeEvents;
 export type SerializedRuntimeEnvelope = Transport.SerializedRuntimeEnvelope;
 
 // Operations compatibility aliases.
-export const AcpTaskAdapter = operations.AcpTaskAdapter;
 export const OpsControlPlane = operations.OpsControlPlane;
 export const OpsIllegalActionError = operations.OpsIllegalActionError;
 export const OpsTargetNotFoundError = operations.OpsTargetNotFoundError;
@@ -436,10 +434,10 @@ export const uninstallEcosystemCatalogEntry = shell.uninstallEcosystemCatalogEnt
 export const updateInstalledEcosystemEntry = shell.updateInstalledEcosystemEntry;
 export const upsertEcosystemCatalogEntry = shell.upsertEcosystemCatalogEntry;
 export const summarizeWorktreeOwnership = shell.summarizeWorktreeOwnership;
-export const WorktreeRegistry = shell.WorktreeRegistry;
 export const listPersistedWorktreeMeta = shell.listPersistedWorktreeMeta;
 export const getPersistedWorktreeMeta = shell.getPersistedWorktreeMeta;
 export const reviewWorktreeAttachments = shell.reviewWorktreeAttachments;
+export const WorktreeRegistry = shell.WorktreeRegistry;
 
 export type MutableRuntimeState = Shell.MutableRuntimeState;
 export type ProviderAccountRecord = Shell.ProviderAccountRecord;
@@ -458,7 +456,6 @@ export type WorktreeRegistry = Shell.WorktreeRegistry;
 export type WorktreeStatusRecord = Shell.WorktreeStatusRecord;
 export type ManagedWorktreeMeta = Shell.ManagedWorktreeMeta;
 export type ShellAgentManagerService = Shell.ShellAgentManagerService;
-export type ShellAcpManagerService = Shell.ShellAcpManagerService;
 export type ShellAutomationManagerService = Shell.ShellAutomationManagerService;
 export type ShellAutomationManagerRuntimeService = Shell.ShellAutomationManagerRuntimeService;
 export type ShellModeManagerService = Shell.ShellModeManagerService;

package/src/runtime/onboarding/apply-file-helpers.ts

@@ -0,0 +1,66 @@
+import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from 'node:fs';
+import { dirname } from 'node:path';
+
+export type RollbackAction = () => Promise<void> | void;
+
+export function isPlainObject(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+export function readJsonObject(path: string): Record<string, unknown> {
+  if (!existsSync(path)) return {};
+  const parsed = JSON.parse(readFileSync(path, 'utf-8')) as unknown;
+  if (!isPlainObject(parsed)) throw new Error(`Expected an object JSON payload at ${path}.`);
+  return parsed;
+}
+
+export function writeJsonObject(path: string, payload: Record<string, unknown>): void {
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, `${JSON.stringify(payload, null, 2)}\n`, 'utf-8');
+}
+
+export function setNestedValue(root: Record<string, unknown>, key: string, value: unknown): Record<string, unknown> {
+  const parts = key.split('.');
+  const next = structuredClone(root);
+  let cursor: Record<string, unknown> = next;
+
+  for (let index = 0; index < parts.length - 1; index += 1) {
+    const part = parts[index]!;
+    let existing = cursor[part];
+    if (!isPlainObject(existing)) {
+      existing = {};
+      cursor[part] = existing;
+    }
+    cursor = existing as Record<string, unknown>;
+  }
+
+  cursor[parts[parts.length - 1]!] = structuredClone(value);
+  return next;
+}
+
+export function restoreFile(path: string, previous: string | null, reload?: () => void): void {
+  if (previous === null) {
+    if (existsSync(path)) unlinkSync(path);
+  } else {
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, previous, 'utf-8');
+  }
+  reload?.();
+}
+
+export function snapshotFileRollback(path: string, reload?: () => void): RollbackAction {
+  const previous = existsSync(path) ? readFileSync(path, 'utf-8') : null;
+  return () => restoreFile(path, previous, reload);
+}
+
+export async function runRollbacks(rollbacks: readonly RollbackAction[]): Promise<readonly string[]> {
+  const errors: string[] = [];
+  for (const rollback of [...rollbacks].reverse()) {
+    try {
+      await rollback();
+    } catch (error) {
+      errors.push(error instanceof Error ? error.message : String(error));
+    }
+  }
+  return errors;
+}

package/src/runtime/onboarding/apply.ts

@@ -1,13 +1,24 @@
-import { existsSync, mkdirSync, readFileSync, rmSync, unlinkSync, writeFileSync } from 'node:fs';
-import { dirname } from 'node:path';
+import { existsSync, readFileSync, rmSync } from 'node:fs';
 import { isSecretRefInput } from '@pellux/goodvibes-sdk/platform/config';
 import { CONFIG_SCHEMA, DEFAULT_CONFIG } from '../../config/index.ts';
 import {
   createAgentRuntimeProfile,
   getAgentRuntimeProfileTemplate,
+  getAgentRuntimeProfileSelectionPath,
+  readAgentRuntimeProfileSelection,
   resolveAgentRuntimeProfileHome,
+  setAgentRuntimeProfileSelection,
 } from '../../agent/runtime-profile.ts';
-import type { FeatureFlagConfigKey } from '../surface-feature-flags.ts';
+import { AgentNoteRegistry } from '../../agent/note-registry.ts';
+import { AgentPersonaRegistry, assertNoSecretLikeText } from '../../agent/persona-registry.ts';
+import { AgentRoutineRegistry } from '../../agent/routine-registry.ts';
+import { AgentSkillRegistry } from '../../agent/skill-registry.ts';
+import {
+  isFeatureFlagConfigKey,
+  mergeFeatureFlagConfigValue,
+  readFeatureFlagConfigValue,
+  type FeatureFlagConfigKey,
+} from '../surface-feature-flags.ts';
 import {
   getOnboardingRuntimeStatePath,
   readOnboardingRuntimeState,
@@ -23,72 +34,12 @@ import type {
   OnboardingApplyRequest,
   OnboardingApplyResult,
 } from './types.ts';
+import { isPlainObject, readJsonObject, restoreFile, runRollbacks, setNestedValue, snapshotFileRollback, writeJsonObject, type RollbackAction } from './apply-file-helpers.ts';
 
 function getNow(deps: Pick<OnboardingApplyDependencies, 'clock'>): number {
   return deps.clock?.() ?? Date.now();
 }
 
-function isPlainObject(value: unknown): value is Record<string, unknown> {
-  return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-
-function readJsonObject(path: string): Record<string, unknown> {
-  if (!existsSync(path)) return {};
-  const parsed = JSON.parse(readFileSync(path, 'utf-8')) as unknown;
-  if (!isPlainObject(parsed)) throw new Error(`Expected an object JSON payload at ${path}.`);
-  return parsed;
-}
-
-function writeJsonObject(path: string, payload: Record<string, unknown>): void {
-  mkdirSync(dirname(path), { recursive: true });
-  writeFileSync(path, `${JSON.stringify(payload, null, 2)}\n`, 'utf-8');
-}
-
-function setNestedValue(root: Record<string, unknown>, key: string, value: unknown): Record<string, unknown> {
-  const parts = key.split('.');
-  const next = structuredClone(root);
-  let cursor: Record<string, unknown> = next;
-
-  for (let index = 0; index < parts.length - 1; index += 1) {
-    const part = parts[index]!;
-    const existing = cursor[part];
-    if (!isPlainObject(existing)) cursor[part] = {};
-    cursor = cursor[part] as Record<string, unknown>;
-  }
-
-  cursor[parts[parts.length - 1]!] = structuredClone(value);
-  return next;
-}
-
-type RollbackAction = () => Promise<void> | void;
-
-function restoreFile(path: string, previous: string | null, reload?: () => void): void {
-  if (previous === null) {
-    if (existsSync(path)) unlinkSync(path);
-  } else {
-    mkdirSync(dirname(path), { recursive: true });
-    writeFileSync(path, previous, 'utf-8');
-  }
-  reload?.();
-}
-
-function snapshotFileRollback(path: string, reload?: () => void): RollbackAction {
-  const previous = existsSync(path) ? readFileSync(path, 'utf-8') : null;
-  return () => restoreFile(path, previous, reload);
-}
-
-async function runRollbacks(rollbacks: readonly RollbackAction[]): Promise<readonly string[]> {
-  const errors: string[] = [];
-  for (const rollback of [...rollbacks].reverse()) {
-    try {
-      await rollback();
-    } catch (error) {
-      errors.push(error instanceof Error ? error.message : String(error));
-    }
-  }
-  return errors;
-}
-
 function isGoodVibesSecretReferenceValue(value: string): boolean {
   const normalized = value.trim();
   return normalized.startsWith('goodvibes://secrets/') && isSecretRefInput(normalized);
@@ -99,10 +50,6 @@ function isMalformedGoodVibesSecretReferenceValue(value: string): boolean {
   return normalized.startsWith('goodvibes://') && !isGoodVibesSecretReferenceValue(normalized);
 }
 
-function isFeatureFlagConfigKey(key: string): key is FeatureFlagConfigKey {
-  return key === 'featureFlags' || key.startsWith('featureFlags.');
-}
-
 function validateFeatureFlagConfigValue(operation: Extract<OnboardingApplyOperation, { kind: 'set-config' }>): boolean {
   if (!isFeatureFlagConfigKey(operation.key)) return false;
 
@@ -137,7 +84,7 @@ function validateConfigValue(operation: Extract<OnboardingApplyOperation, { kind
     const defaultValue = operation.key.split('.').reduce<unknown>((cursor, part) => (
       isPlainObject(cursor) ? cursor[part] : undefined
     ), DEFAULT_CONFIG);
-    if (defaultValue === undefined) throw new Error(`Unknown config key: ${operation.key}`);
+    if (defaultValue === undefined) throw new Error(`Unknown config key ${operation.key}`);
     if (typeof defaultValue === 'boolean' && typeof operation.value !== 'boolean') {
       throw new Error(`Config key ${operation.key} expects a boolean value.`);
     }
@@ -164,11 +111,11 @@ function validateConfigValue(operation: Extract<OnboardingApplyOperation, { kind
   }
 
   if (schema.type === 'enum' && schema.enumValues && stringValue !== null && !schema.enumValues.includes(stringValue)) {
-    throw new Error(`Invalid value for ${operation.key}: ${String(operation.value)}.`);
+    throw new Error(`Invalid value for ${operation.key} ${String(operation.value)}.`);
   }
 
   if (schema.validate && !schema.validate(operation.value)) {
-    throw new Error(`Invalid value for ${operation.key}: ${String(operation.value)}.`);
+    throw new Error(`Invalid value for ${operation.key} ${String(operation.value)}.`);
   }
 }
 
@@ -222,6 +169,80 @@ 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 validateCreateLocalNoteOperation(
+  deps: OnboardingApplyDependencies,
+  operation: Extract<OnboardingApplyOperation, { kind: 'create-local-note' }>,
+): void {
+  const registry = AgentNoteRegistry.fromShellPaths(deps.shellPaths);
+  const title = operation.title.trim();
+  const body = operation.body.trim();
+  const tags = operation.tags ?? [];
+  if (!title) throw new Error('Note title is required.');
+  if (!body) throw new Error('Note body is required.');
+  assertNoSecretLikeText([title, body, ...tags]);
+  const duplicate = registry.get(title);
+  if (duplicate) throw new Error(`Note already exists: ${duplicate.id}`);
+}
+
 function applyConfigOperation(
   deps: OnboardingApplyDependencies,
   operation: Extract<OnboardingApplyOperation, { kind: 'set-config' }>,
@@ -241,7 +262,11 @@ function applyConfigOperation(
     };
   }
 
-  deps.config.setDynamic(operation.key as never, operation.value);
+  if (isFeatureFlagConfigKey(operation.key)) {
+    mergeFeatureFlagConfigValue(deps.config, operation.key, operation.value);
+  } else {
+    deps.config.setDynamic(operation.key, operation.value);
+  }
   return {
     kind: operation.kind,
     summary: `Updated ${operation.key} in global onboarding settings.`,
@@ -294,9 +319,15 @@ async function buildRollbackAction(
       );
     }
 
-    const previous = deps.config.get(operation.key as never);
+    const previous = isFeatureFlagConfigKey(operation.key)
+      ? readFeatureFlagConfigValue(deps.config, operation.key)
+      : deps.config.get(operation.key);
     return () => {
-      deps.config.setDynamic(operation.key as never, previous);
+      if (isFeatureFlagConfigKey(operation.key)) {
+        mergeFeatureFlagConfigValue(deps.config, operation.key, previous ?? 'disabled');
+      } else {
+        deps.config.setDynamic(operation.key, previous);
+      }
     };
   }
 
@@ -322,6 +353,31 @@ async function buildRollbackAction(
     };
   }
 
+  if (operation.kind === 'select-agent-profile') {
+    const path = getAgentRuntimeProfileSelectionPath(deps.shellPaths.homeDirectory);
+    return snapshotFileRollback(path);
+  }
+
+  if (operation.kind === 'create-local-note') {
+    const registry = AgentNoteRegistry.fromShellPaths(deps.shellPaths);
+    return snapshotFileRollback(registry.snapshot().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 +420,90 @@ 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 later plain goodvibes-agent runs.`,
+  };
+}
+
+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 Agent-local 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 Agent-local 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 Agent-local routine ${routine.id}.`,
+  };
+}
+
+function applyCreateLocalNoteOperation(
+  deps: OnboardingApplyDependencies,
+  operation: Extract<OnboardingApplyOperation, { kind: 'create-local-note' }>,
+): OnboardingAppliedOperation {
+  const note = AgentNoteRegistry.fromShellPaths(deps.shellPaths).create({
+    title: operation.title,
+    body: operation.body,
+    tags: operation.tags ?? [],
+    source: 'user',
+    provenance: 'onboarding',
+  });
+  return {
+    kind: operation.kind,
+    summary: `Created Agent-local note ${note.id}.`,
+  };
+}
+
 function orderApplyOperations(
   operations: readonly OnboardingApplyOperation[],
 ): readonly OnboardingApplyOperation[] {
@@ -376,6 +516,13 @@ 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-note'
+    || 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 +533,8 @@ function orderApplyOperations(
     ...secretOperations,
     ...configOperations,
     ...agentProfileOperations,
+    ...agentProfileSelectionOperations,
+    ...localBehaviorOperations,
     ...finalOperations,
   ];
 }
@@ -427,6 +576,36 @@ 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-note') {
+        validateCreateLocalNoteOperation(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 +625,11 @@ 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-note:')) return 'create-local-note';
+  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 +686,36 @@ 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-note') {
+          applied.push(applyCreateLocalNoteOperation(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

@@ -83,7 +83,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;
@@ -224,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 {
@@ -250,7 +250,7 @@ function describeLocalBehavior(snapshot: OnboardingSnapshotState): string {
       ...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}`;
+    return `Import ${discoveredCount} discovered Agent persona/skill/routine file(s) from Agent-local folders before creating blank behavior.${sampleText}`;
   }
 
   if (!hasLocalBehaviorCustomization(snapshot)) {
@@ -288,7 +288,7 @@ function describeAutomationReview(snapshot: OnboardingSnapshotState): string {
 }
 
 function describeTuiDelegation(): string {
-  return 'Delegate explicit build, fix, implementation, and review work to GoodVibes TUI; WRFC is requested only when the user explicitly asks for it.';
+  return 'Delegate explicit build, fix, implementation, and review work to GoodVibes TUI; delegated review is requested only when the user explicitly asks for it.';
 }
 
 function getAcknowledgementAccepted(
@@ -391,10 +391,7 @@ export function deriveStep1CapabilityFlags(
   };
 }
 
-export function deriveStep1_5NetworkMode(
-  bindSettings: Pick<OnboardingSnapshotState, 'bindSettings'>['bindSettings'],
-): OnboardingNetworkMode {
-  void bindSettings;
+export function deriveStep1_5NetworkMode(): OnboardingNetworkMode {
   return 'local-network-default';
 }
 
@@ -458,23 +455,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,
@@ -488,7 +485,7 @@ export function deriveOnboardingStepState(
 ): OnboardingStepDerivationState {
   return {
     step1Capabilities: deriveStep1Capabilities(snapshot),
-    step1_5NetworkMode: deriveStep1_5NetworkMode(snapshot.bindSettings),
+    step1_5NetworkMode: deriveStep1_5NetworkMode(),
     reopenEditAcknowledgements: deriveReopenEditAcknowledgementState(snapshot),
   };
 }