@pellux/goodvibes-agent 0.1.116 → 0.1.117

package/src/runtime/bootstrap-shell.ts

@@ -62,6 +62,43 @@ export interface BootstrapShellOptions {
   readonly completeModelSelectionSideEffect?: () => void;
 }
 
+type PlanningAnswerSubmit = (answer: string) => void;
+
+export interface PlanningAnswerSubmitBridgeOptions {
+  readonly getSubmitInput: () => PlanningAnswerSubmit | undefined;
+  readonly addSystemMessage: (message: string) => void;
+  readonly requestRender: () => void;
+  readonly defer?: (callback: () => void) => void;
+}
+
+export function submitPlanningAnswerWithShellFallback(
+  answer: string,
+  options: PlanningAnswerSubmitBridgeOptions,
+): void {
+  const submit = options.getSubmitInput();
+  if (submit) {
+    submit(answer);
+    return;
+  }
+
+  const defer = options.defer ?? ((callback) => {
+    setTimeout(callback, 0);
+  });
+  defer(() => {
+    const deferredSubmit = options.getSubmitInput();
+    if (deferredSubmit) {
+      deferredSubmit(answer);
+      return;
+    }
+
+    options.addSystemMessage([
+      '[Planning] Could not submit the selected answer because the prompt bridge is not ready.',
+      `Paste this answer into the prompt to continue planning: ${answer}`,
+    ].join('\n'));
+    options.requestRender();
+  });
+}
+
 export function createBootstrapShell(options: BootstrapShellOptions): BootstrapShellState {
   const {
     configManager,
@@ -113,10 +150,11 @@ export function createBootstrapShell(options: BootstrapShellOptions): BootstrapS
     resumeSession,
     requestRender,
     submitPlanningAnswer: (answer) => {
-      if (!commandContextRef?.submitInput) {
-        throw new Error('Planning answer submission is not wired yet.');
-      }
-      commandContextRef.submitInput(answer);
+      submitPlanningAnswerWithShellFallback(answer, {
+        getSubmitInput: () => commandContextRef?.submitInput,
+        addSystemMessage: (message) => conversation.addSystemMessage(message),
+        requestRender,
+      });
     },
     dismissPlanning: () => {
       services.panelManager.close('project-planning');

package/src/runtime/bootstrap.ts

@@ -10,7 +10,6 @@
  *   - lifecycle.ts: save/shutdown helpers
  */
 import { Orchestrator, type OrchestratorUserInputOptions } from '../core/orchestrator.ts';
-import { AcpManager } from '@pellux/goodvibes-sdk/platform/acp';
 import { getTierPromptSupplement, getTierForContextWindow } from '@pellux/goodvibes-sdk/platform/providers';
 import { logger } from '@pellux/goodvibes-sdk/platform/utils';
 import type { PermissionRequestHandler } from '@pellux/goodvibes-sdk/platform/permissions';
@@ -23,7 +22,6 @@ import type { RuntimeContext, BootstrapOptions } from './context.ts';
 import { shutdownRuntime, fireSessionStart, saveSession } from '@/runtime/index.ts';
 import { createTaskManager } from '@/runtime/index.ts';
 import { OpsControlPlane } from '@/runtime/index.ts';
-import { AcpTaskAdapter } from '@/runtime/index.ts';
 import type { SystemMessageRouter } from '../core/system-message-router.ts';
 import { emitSessionReady, emitSessionStarted } from '@/runtime/index.ts';
 import {
@@ -47,8 +45,8 @@ import { buildReviewedMemoryPrompt } from '../agent/memory-prompt.ts';
 
 const GOODVIBES_AGENT_OPERATOR_POLICY = [
   '## GoodVibes Agent Operator Policy',
-  '- Default to serial, proactive assistant work in the main conversation. Answer, inspect, summarize, remember useful non-secret facts, configure local Agent state, use read-only connected-service/operator routes, and take safe non-destructive actions without spawning local agents or WRFC.',
-  '- GoodVibes Agent connects to GoodVibes services owned outside this package. Do not start, stop, restart, install, expose, or mutate connected-service network/listener posture from Agent.',
+  '- Default to serial, proactive assistant work in the main conversation. Answer, inspect, summarize, remember useful non-secret facts, configure local Agent state, use read-only connected-host/operator routes, and take safe non-destructive actions without spawning local agents or WRFC.',
+  '- GoodVibes Agent connects to a GoodVibes host owned outside this package. Do not start, stop, restart, install, expose, or mutate connected-host network/listener posture from Agent.',
   '- Use the `agent_local_registry` tool when a durable memory, reusable persona, skill, skill bundle, or routine would improve future work. Keep those records local, non-secret, source/provenance tagged, and reviewable. Review memory with a confidence score when it should shape future turns. Starting a routine means applying its steps in this same serial conversation, not creating a background job.',
   '- WRFC is never the default Agent reasoning path. Do not create local WRFC chains for planning, research, operations, knowledge, memory, configuration, approvals, automation observability, or ordinary assistant work.',
   '- GoodVibes Agent is not the coding TUI. Do not use the `agent` tool to spawn local Engineer, Reviewer, Tester, Verifier, or batch-spawn roots from Agent.',
@@ -130,7 +128,7 @@ export type BootstrapContext = RuntimeContext & {
  *   3. Tool registry + agent wiring
  *   4. Runtime bus subscriptions (WRFC, subagent, hook bridge)
  *   5. Providers, webhooks, PermissionManager, HookDispatcher
- *   6. Orchestrator + AcpManager
+ *   6. Orchestrator and Agent-local task read models
  *   7. MCP auto-connect + workspace/panel manager
  *   8. Command registry + plugin init + CommandContext
  *   9. Input handler wiring
@@ -183,7 +181,7 @@ export async function bootstrapRuntime(
     pluginManager,
   } = services;
 
-  // ── Phase 6: Orchestrator + AcpManager ───────────────────────────────────
+  // ── Phase 6: Orchestrator and Agent-local task read models ───────────────
 
   // Mutable function refs so main.ts can patch these after constructing the scroll/viewport state.
   // The orchestrator closes over these refs, so patching them in main.ts takes immediate effect.
@@ -243,17 +241,6 @@ export async function bootstrapRuntime(
   });
   conversation.setSessionLineageTracker(services.sessionLineageTracker);
 
-  const acpManager = new AcpManager({
-    requestPermission: (request) => permissionPromptRef.requestPermission(request),
-    runtimeBus,
-    hookDispatcher: services.hookDispatcher,
-  });
-  const acpTaskAdapter = new AcpTaskAdapter(store);
-  const ACP_TASK_SYNC_INTERVAL_MS = 1_000;
-  const acpTaskSyncInterval = setInterval(() => {
-    acpTaskAdapter.sync(acpManager);
-  }, ACP_TASK_SYNC_INTERVAL_MS);
-  bootstrapUnsubs.push(() => clearInterval(acpTaskSyncInterval));
   const opsTaskManager = createTaskManager(store, runtimeBus, userSessionId);
   const opsControlPlane = services.featureFlags.isEnabled('operator-control-plane')
     ? new OpsControlPlane(opsTaskManager, runtimeBus, store, userSessionId)
@@ -334,7 +321,7 @@ export async function bootstrapRuntime(
       port,
       baseUrl: formatHostServiceBaseUrl(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 them.'
         : 'GoodVibes Agent does not own listener lifecycle.',
     };
   };
@@ -375,7 +362,7 @@ export async function bootstrapRuntime(
         daemonStatus: createExternalAgentServiceStatus('daemon'),
         httpListenerStatus: createExternalAgentServiceStatus('httpListener'),
       };
-      systemMessageRouter.high('[Startup] GoodVibes Agent does not start or restart connected GoodVibes services. Start them from GoodVibes TUI or the owning host, then refresh status.');
+      systemMessageRouter.high('[Startup] GoodVibes Agent does not start or restart the connected GoodVibes host. Start it from GoodVibes TUI or the owning host, then refresh status.');
       requestRender();
       return inspectExternalServices();
     },
@@ -452,8 +439,8 @@ export async function bootstrapRuntime(
   });
   bootstrapUnsubs.push(() => mcpAutoReload.stop());
   if (configManager.get('automation.enabled')) {
-    logger.warn('Local automation startup is disabled in GoodVibes Agent; use connected-service observability instead.');
-    systemMessageRouter.low('[Startup] Local automation runners are disabled in GoodVibes Agent; use read-only automation observability or explicit connected-service actions.');
+    logger.warn('Local automation startup is disabled in GoodVibes Agent; use connected-host observability instead.');
+    systemMessageRouter.low('[Startup] Local automation runners are disabled in GoodVibes Agent; use read-only automation observability or explicit connected-host actions.');
   }
 
   // ── Phase 12: Session:start lifecycle hook ─────────────────────────────
@@ -554,12 +541,6 @@ export async function bootstrapRuntime(
     },
   };
 
-  // ── Phase 12b: Operator intervention wiring (feature-gated) ──────────────
-  // Keep service-owned control-plane state internal. GoodVibes Agent does not
-  // expose the local ops-control panel; operator control is surfaced
-  // through Agent-owned status, approvals, automation, and delegation flows.
-  ctx.commandContext.ops.acpManager = acpManager;
-
   // Wire exit from options if provided; otherwise main.ts binds the shell bridge.
   if (options?.exit) {
     ctx.commandContext.exit = options.exit;

package/src/runtime/connected-host-auth.ts

@@ -0,0 +1,42 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+type JsonRecord = Record<string, unknown>;
+
+export interface ConnectedHostOperatorToken {
+  readonly path: string;
+  readonly present: boolean;
+  readonly token: string | null;
+  readonly error?: string;
+}
+
+function isRecord(value: unknown): value is JsonRecord {
+  return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+
+export function connectedHostOperatorTokenPath(homeDirectory: string): string {
+  return join(homeDirectory, '.goodvibes', 'daemon', 'operator-tokens.json');
+}
+
+export function readConnectedHostOperatorToken(homeDirectory: string): ConnectedHostOperatorToken {
+  const path = connectedHostOperatorTokenPath(homeDirectory);
+  if (!existsSync(path)) return { path, present: false, token: null };
+  try {
+    const parsed = JSON.parse(readFileSync(path, 'utf-8')) as unknown;
+    const token = isRecord(parsed) && typeof parsed.token === 'string' && parsed.token.trim().length > 0
+      ? parsed.token
+      : null;
+    return { path, present: true, token };
+  } catch (error) {
+    return { path, present: true, token: null, error: error instanceof Error ? error.message : String(error) };
+  }
+}
+
+export function connectedHostTokenRequiredMessage(path: string): string {
+  return [
+    'Connected-host operator token is required.',
+    `  token path: ${path}`,
+    '  Agent does not create or rotate connected-host auth tokens.',
+    '  Start or repair the owning GoodVibes host, then rerun this command.',
+  ].join('\n');
+}

package/src/runtime/diagnostics/panels/panel-resources.ts

@@ -1,7 +1,7 @@
 /**
  * Panel resource diagnostics panel data provider.
  *
- * Polls the shared TUI-owned ComponentHealthMonitor and produces PanelResourceSnapshot
+ * Polls the shared shell ComponentHealthMonitor and produces PanelResourceSnapshot
  * values for the diagnostics panel to render.
  */
 import type { ComponentHealthMonitor } from '../../perf/panel-health-monitor.ts';

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 them.'
       : '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,7 +434,6 @@ 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;
@@ -458,7 +455,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.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

@@ -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 {
@@ -458,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

@@ -99,7 +99,7 @@ async function buildServicesSnapshot(
       },
       issues: [
         {
-          area: 'services',
+          area: 'host',
           message: error instanceof Error ? error.message : String(error),
         },
       ],
@@ -146,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,
       };

package/src/runtime/onboarding/types.ts

@@ -162,7 +162,7 @@ export interface OnboardingAcknowledgementSnapshot {
 }
 
 export type OnboardingSnapshotCollectionIssueArea =
-  | 'services'
+  | 'host'
   | 'subscriptions-active'
   | 'subscriptions-pending'
   | 'auth'
@@ -271,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 {