@pellux/goodvibes-agent 0.1.117 → 1.0.1

package/src/input/handler.ts

@@ -1,12 +1,8 @@
 import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
 import { dirname } from 'node:path';
 import { InputTokenizer } from '@pellux/goodvibes-sdk/platform/core';
-import { createOAuthLocalListener } from '@pellux/goodvibes-sdk/platform/config';
 import { clearModalStackForHandler, cleanupMarkerRegistryForHandler, executeBlockActionForHandler, expandPromptForHandler, findMarkerAtPosForHandler, getImageAttachmentsForHandler, handleBlockCopyForHandler, handleBlockRerunForHandler, handleBlockSaveForHandler, handleBlockToggleForHandler, handleBookmarkForHandler, handleCopyForHandler, handleCtrlCForHandler, handleEscapeForHandler, hydrateOnboardingWizardFromRuntimeForHandler, modalOpenedForHandler, openOnboardingWizardForHandler, registerPasteForHandler } from './handler-interactions.ts';
-import { clearOnboardingModelPickerCancelStateForHandler, clearOnboardingPendingModelPickerTargetForHandler, completeOpenAiSubscriptionFromListenerForHandler, getOnboardingConfigValueForHandler, getOnboardingRuntimePostureForHandler, handleModelPickerCommitForHandler, handleOnboardingActionForHandler, handleOpenAiSubscriptionFinishForHandler, handleOpenAiSubscriptionStartForHandler, openModelPickerWithTargetForHandler, openProviderModelPickerWithTargetForHandler, refreshOnboardingHydrationForHandler, restartOnboardingExternalServicesIfNeededForHandler, restoreOnboardingModelPickerCancelStateForHandler, syncRuntimeFromOnboardingRequestForHandler, verifyOnboardingRuntimePostureForHandler, type OnboardingRuntimePosture } from './handler-onboarding.ts';
-import { beginOpenAICodexLogin, exchangeOpenAICodexCode } from '@pellux/goodvibes-sdk/platform/config';
-import { openExternalUrl } from '@pellux/goodvibes-sdk/platform/utils';
-import { buildProviderAccountSnapshot } from '@/runtime/index.ts';
+import { clearOnboardingModelPickerCancelStateForHandler, clearOnboardingPendingModelPickerTargetForHandler, getOnboardingConfigValueForHandler, getOnboardingRuntimePostureForHandler, handleModelPickerCommitForHandler, handleOnboardingActionForHandler, handleOpenAiSubscriptionFinishForHandler, handleOpenAiSubscriptionStartForHandler, openModelPickerWithTargetForHandler, openProviderModelPickerWithTargetForHandler, refreshOnboardingHydrationForHandler, restartOnboardingExternalServicesIfNeededForHandler, restoreOnboardingModelPickerCancelStateForHandler, syncRuntimeFromOnboardingRequestForHandler, verifyOnboardingRuntimePostureForHandler, type OnboardingRuntimePosture } from './handler-onboarding.ts';
 import { SelectionManager } from './selection.ts';
 import type { InfiniteBuffer } from '../core/history.ts';
 import type { CommandRegistry, CommandContext } from './command-registry.ts';
@@ -163,14 +159,13 @@ export class InputHandler {
   public onboardingModelPickerCancelSnapshot: OnboardingWizardSnapshot | null = null;
   public onboardingHydrationSerial = 0;
   public onboardingApplyPending = false;
-  public onboardingOpenAiListenerSerial = 0;
 
   /**
    * Modal navigation stack. Each element is the name of an open modal.
    * Used to support back-navigation via Escape.
    */
   public modalStack: string[] = [];
-  public modalReturnFocus: 'prompt' | 'panel' | 'indicator' = 'prompt';
+  public modalReturnFocus: 'prompt' | 'indicator' = 'prompt';
   public sessionPickerModal: SessionPickerModal;
   public profilePickerModal: ProfilePickerModal;
   /** True when the help overlay is visible. */
@@ -308,7 +303,8 @@ export class InputHandler {
         ensureInputCursorVisible: (contentWidth?: number) => this.ensureInputCursorVisible(contentWidth),
         registerPaste: (content: string) => this.registerPaste(content),
         executeBlockAction: (id: string) => this.executeBlockAction(id),
-        cyclePanelTab: (direction: 'next' | 'prev') => this.cyclePanelTab(direction),
+        cycleAgentWorkspaceCategory: (direction: 'next' | 'prev') => this.cycleAgentWorkspaceCategory(direction),
+        dismissAgentWorkspace: () => this.dismissAgentWorkspace(),
         onPanelInputConsumed: (activePanel: Panel | null, key: string) => this.handlePanelIntegrationAction(activePanel, key),
         getWrappedPromptInfo: (contentWidth: number) => this.getWrappedPromptInfo(contentWidth),
         moveCursorVertical: (direction: -1 | 1) => this.moveCursorVertical(direction),
@@ -412,15 +408,33 @@ export class InputHandler {
     this.panelFocused = false;
     this.indicatorFocused = false;
     this.modalOpened('agentWorkspace');
-    this.agentWorkspace.open(context, (command) => this.dispatchAgentWorkspaceCommand(command, context), categoryId);
+    this.agentWorkspace.open(
+      context,
+      (command) => this.dispatchAgentWorkspaceCommand(command, context),
+      categoryId,
+      (prompt) => this.dispatchAgentWorkspacePrompt(prompt, context),
+    );
     this.requestRender();
   }
 
-  private dispatchAgentWorkspaceCommand(command: string, context: CommandContext): void {
+  private closeAgentWorkspaceModal(): void {
     this.agentWorkspace.close();
     for (let index = this.modalStack.length - 1; index >= 0; index -= 1) {
       if (this.modalStack[index] === 'agentWorkspace') this.modalStack.splice(index, 1);
     }
+  }
+
+  public dismissAgentWorkspace(): boolean {
+    if (!this.agentWorkspace.active) return false;
+    this.closeAgentWorkspaceModal();
+    this.panelFocused = false;
+    this.indicatorFocused = false;
+    this.requestRender();
+    return true;
+  }
+
+  private dispatchAgentWorkspaceCommand(command: string, context: CommandContext): void {
+    this.closeAgentWorkspaceModal();
     const { name, args } = parseSlashCommand(command);
     if (!name) return;
     void context.executeCommand?.(name, [...args]).catch((error: unknown) => {
@@ -429,11 +443,16 @@ export class InputHandler {
     });
     this.requestRender();
   }
+
+  private dispatchAgentWorkspacePrompt(prompt: string, context: CommandContext): void {
+    this.closeAgentWorkspaceModal();
+    context.submitInput?.(prompt);
+    this.requestRender();
+  }
   public handleModelPickerCommit(): boolean { return handleModelPickerCommitForHandler(this); }
   public async handleOnboardingAction(action: OnboardingWizardAction): Promise<void> { await handleOnboardingActionForHandler(this, action); }
   public async refreshOnboardingHydration(options: { readonly preserveValues?: boolean; readonly targetStepId?: string } = {}): Promise<void> { await refreshOnboardingHydrationForHandler(this, options); }
   public async handleOpenAiSubscriptionStart(): Promise<void> { await handleOpenAiSubscriptionStartForHandler(this); }
-  public async completeOpenAiSubscriptionFromListener(listener: Awaited<ReturnType<typeof createOAuthLocalListener>>, verifier: string, serial: number): Promise<void> { await completeOpenAiSubscriptionFromListenerForHandler(this, listener, verifier, serial); }
   public async handleOpenAiSubscriptionFinish(): Promise<void> { await handleOpenAiSubscriptionFinishForHandler(this); }
   public syncRuntimeFromOnboardingRequest(request: ReturnType<OnboardingWizardController['buildApplyRequest']>): void { syncRuntimeFromOnboardingRequestForHandler(this, request); }
   public getOnboardingConfigValue(request: OnboardingApplyRequest, key: string): unknown { return getOnboardingConfigValueForHandler(this, request, key); }
@@ -693,13 +712,24 @@ export class InputHandler {
    * Word-wrap a single line to fit within maxW columns.
    * Breaks at spaces; words wider than maxW are force-broken.
    */
-  public cyclePanelTab(direction: 'next' | 'prev'): void {
-    const pm = this.uiServices.shell.panelManager;
-    if (pm.isVisible()) {
-      if (direction === 'next') pm.nextWorkspaceTab();
-      else pm.prevWorkspaceTab();
-      this.requestRender();
+  public cycleAgentWorkspaceCategory(direction: 'next' | 'prev'): void {
+    const context = this.commandContext;
+    if (!this.agentWorkspace.active) {
+      if (!context) return;
+      this.panelFocused = false;
+      this.indicatorFocused = false;
+      this.modalOpened('agentWorkspace');
+      this.agentWorkspace.open(
+        context,
+        (command) => this.dispatchAgentWorkspaceCommand(command, context),
+        undefined,
+        (prompt) => this.dispatchAgentWorkspacePrompt(prompt, context),
+      );
     }
+    this.agentWorkspace.cycleCategory(direction);
+    this.panelFocused = false;
+    this.indicatorFocused = false;
+    this.requestRender();
   }
 
   public handlePanelIntegrationAction(activePanel: Panel | null, key: string): void {

package/src/input/input-history.ts

@@ -284,13 +284,12 @@ export class InputHistory {
 
   private normalizeStoredEntry(entry: unknown): StoredInputHistoryEntry | null {
     if (typeof entry === 'string') return entry;
-    if (!entry || typeof entry !== 'object') return null;
-    const record = entry as Record<string, unknown>;
-    if (typeof record.text !== 'string') return null;
-    const text = record.text.trim();
+    if (!entry || typeof entry !== 'object' || Array.isArray(entry)) return null;
+    if (!('text' in entry) || typeof entry.text !== 'string') return null;
+    const text = entry.text.trim();
     if (!text) return null;
-    if (typeof record.recallText === 'string' && record.recallText.trim() && record.recallText.trim() !== text) {
-      return { text, recallText: record.recallText.trim() };
+    if ('recallText' in entry && typeof entry.recallText === 'string' && entry.recallText.trim() && entry.recallText.trim() !== text) {
+      return { text, recallText: entry.recallText.trim() };
     }
     return text;
   }

package/src/input/keybindings.ts

@@ -60,10 +60,10 @@ export const ACTION_DESCRIPTIONS: Record<KeyAction, string> = {
   'clear-cancel':          'Clear input / cancel generation / exit (double)',
   'screen-clear':          'Repaint the screen',
   'panel-picker':          'Open the Agent operator workspace',
-  'panel-close':            'Dismiss deferred panel focus',
-  'panel-close-all':         'Dismiss deferred workspace focus',
-  'panel-tab-next':        'Reserved for future Agent workspace tabs',
-  'panel-tab-prev':        'Reserved for future Agent workspace tabs',
+  'panel-close':            'Dismiss Agent workspace',
+  'panel-close-all':         'Dismiss Agent workspace focus',
+  'panel-tab-next':        'Cycle Agent workspace category forward',
+  'panel-tab-prev':        'Cycle Agent workspace category backward',
   'history-search':        'Reverse input history search',
   'search':                'Toggle conversation search',
   'block-copy':            'Copy nearest block to clipboard',
@@ -80,6 +80,19 @@ export const ACTION_DESCRIPTIONS: Record<KeyAction, string> = {
   'replay-panel':          'Reserved replay workspace shortcut',
 };
 
+function isKeyAction(action: string): action is KeyAction {
+  return Object.hasOwn(ACTION_DESCRIPTIONS, action);
+}
+
+function isKeyCombo(value: unknown): value is KeyCombo {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return false;
+  if (!('key' in value) || typeof value.key !== 'string' || value.key.length === 0) return false;
+  if ('ctrl' in value && value.ctrl !== undefined && typeof value.ctrl !== 'boolean') return false;
+  if ('shift' in value && value.shift !== undefined && typeof value.shift !== 'boolean') return false;
+  if ('alt' in value && value.alt !== undefined && typeof value.alt !== 'boolean') return false;
+  return true;
+}
+
 /** Default key bindings for all actions. */
 export const DEFAULT_KEYBINDINGS: Record<KeyAction, KeyCombo[]> = {
   'copy-selection':        [{ key: 'c', ctrl: true, shift: true }],
@@ -218,11 +231,7 @@ export class KeybindingsManager {
   }
 
   private validateCombos(combos: unknown[]): combos is KeyCombo[] {
-    return combos.every((c) => {
-      if (typeof c !== 'object' || c === null) return false;
-      const combo = c as Record<string, unknown>;
-      return typeof combo['key'] === 'string' && combo['key'].length > 0;
-    });
+    return combos.every(isKeyCombo);
   }
 
   /**
@@ -233,9 +242,10 @@ export class KeybindingsManager {
    *                Expects: { logicalName: string; ctrl?: boolean; shift?: boolean; alt?: boolean }
    */
   matches(
-    action: KeyAction,
+    action: string,
     token: { logicalName?: string; ctrl?: boolean; shift?: boolean; alt?: boolean },
   ): boolean {
+    if (!isKeyAction(action)) return false;
     const combos = this.bindings[action];
     if (!combos) return false;
     return combos.some((combo) => this.comboMatches(combo, token));
@@ -267,7 +277,8 @@ export class KeybindingsManager {
    * getComboLabel — Return a human-readable label for the first combo of an action.
    * Example: { key: 'f', ctrl: true } → "Ctrl+F"
    */
-  getComboLabel(action: KeyAction): string {
+  getComboLabel(action: string): string {
+    if (!isKeyAction(action)) return '(unbound)';
     const combos = this.bindings[action];
     if (!combos?.length) return '(unbound)';
     return this.formatCombo(combos[0]);

package/src/input/onboarding/onboarding-wizard-apply.ts

@@ -22,6 +22,18 @@ export function buildOnboardingApplyRequest(controller: OnboardingWizardControll
       });
     };
     const readText = (fieldId: string): string => controller.getStringFieldValue(fieldId, '').trim();
+    const readList = (fieldId: string): readonly string[] => readText(fieldId).split(',').map((entry) => entry.trim()).filter(Boolean);
+    const maybeCreateLocalNote = (): void => {
+      const title = readText('agent-local-state.note-title');
+      const body = readText('agent-local-state.note-body');
+      if (!title && !body) return;
+      operations.push({
+        kind: 'create-local-note',
+        title,
+        body,
+        tags: readList('agent-local-state.note-tags'),
+      });
+    };
     const maybeCreateLocalPersona = (): void => {
       const name = readText('agent-local-state.persona-name');
       const description = readText('agent-local-state.persona-description');
@@ -93,6 +105,7 @@ export function buildOnboardingApplyRequest(controller: OnboardingWizardControll
         });
       }
     }
+    maybeCreateLocalNote();
     maybeCreateLocalPersona();
     maybeCreateLocalSkill();
     maybeCreateLocalRoutine();

package/src/input/onboarding/onboarding-wizard-constants.ts

@@ -6,6 +6,7 @@ export const STEP_ORDER: readonly OnboardingWizardStepId[] = [
   'default-model',
   'agent-communication',
   'agent-tools',
+  'agent-research',
   'agent-knowledge',
   'agent-local-state',
   'agent-automation',

package/src/input/onboarding/onboarding-wizard-operator-steps.ts

@@ -22,7 +22,7 @@ function discoverySample(discovery: AgentBehaviorDiscoverySnapshot | undefined):
     ...discovery.skills.names,
     ...discovery.routines.names,
   ].slice(0, 4);
-  if (names.length === 0) return 'Use /personas discover, /agent-skills discover, and /routines discover after setup to rescan.';
+  if (names.length === 0) return 'Open the Memory & Skills workspace after setup to rescan and import local behavior files.';
   const remaining = discoveryCount(discovery) > names.length ? `, +${discoveryCount(discovery) - names.length} more` : '';
   return `Import candidates: ${names.join(', ')}${remaining}.`;
 }
@@ -41,11 +41,12 @@ export function buildCommunicationStep(): OnboardingWizardStepDefinition {
     ],
     fields: [
       {
-        kind: 'status',
+        kind: 'action',
         id: 'agent-communication.companion',
+        action: 'open-agent-workspace:channels',
         label: 'Companion pairing',
-        hint: 'Use /pair from the Agent workspace to pair companion clients through the connected GoodVibes host.',
-        defaultValue: 'Pair when ready',
+        hint: 'Open the Channels workspace to pair companion clients and review channel readiness and delivery safety.',
+        defaultValue: 'Open Channels',
       },
       {
         kind: 'status',
@@ -86,11 +87,12 @@ export function buildToolsStep(): OnboardingWizardStepDefinition {
     ],
     fields: [
       {
-        kind: 'status',
+        kind: 'action',
         id: 'agent-tools.mcp',
+        action: 'open-agent-workspace:tools',
         label: 'MCP connections and tools',
-        hint: 'Use /mcp servers and the Agent workspace Tools area to inspect connected MCP servers, roles, and tool readiness.',
-        defaultValue: 'Inspectable',
+        hint: 'Open the Tools & MCP workspace to inspect connected MCP servers, roles, trust, and tool readiness.',
+        defaultValue: 'Open Tools',
       },
       {
         kind: 'status',
@@ -122,26 +124,27 @@ export function buildAgentKnowledgeStep(): OnboardingWizardStepDefinition {
     id: 'agent-knowledge',
     title: 'Agent Knowledge',
     shortLabel: 'Knowledge',
-    description: 'Agent Knowledge is isolated to the GoodVibes Agent product segment. It never falls back to default Knowledge/Wiki or any non-Agent product segment.',
+    description: 'Agent Knowledge is isolated to the GoodVibes Agent product segment. It never falls back to default knowledge or any non-Agent product segment.',
     summaryTitle: 'Knowledge isolation',
     summaryLines: [
-      'Route segment: /api/goodvibes-agent/knowledge/*',
-      'Default wiki fallback: disabled',
-      'Non-Agent route fallback: disabled',
+      'Route segment /api/goodvibes-agent/knowledge/*',
+      'Default knowledge fallback disabled',
+      'Non-Agent route fallback disabled',
     ],
     fields: [
       {
-        kind: 'status',
+        kind: 'action',
         id: 'agent-knowledge.route',
+        action: 'open-agent-workspace:knowledge',
         label: 'Isolated Agent Knowledge route',
-        hint: 'Ask, search, status, and ingest use /api/goodvibes-agent/knowledge/* only.',
-        defaultValue: 'Isolated',
+        hint: 'Open the Knowledge workspace for isolated Agent ask, search, status, ingest, and review actions.',
+        defaultValue: 'Open Knowledge',
       },
       {
         kind: 'status',
-        id: 'agent-knowledge.no-default-wiki',
-        label: 'Default Knowledge/Wiki fallback',
-        hint: 'Agent setup and Agent ask/search must not query the default wiki when Agent Knowledge has no answer.',
+        id: 'agent-knowledge.no-default-knowledge',
+        label: 'Default knowledge fallback',
+        hint: 'Agent setup and Agent ask/search must not query the default knowledge when Agent Knowledge has no answer.',
         defaultValue: 'Blocked',
       },
       {
@@ -155,6 +158,52 @@ export function buildAgentKnowledgeStep(): OnboardingWizardStepDefinition {
   };
 }
 
+export function buildResearchStep(): OnboardingWizardStepDefinition {
+  return {
+    id: 'agent-research',
+    title: 'Research and source triage',
+    shortLabel: 'Research',
+    description: 'Prepare read-only web research and source triage. Research runs in the main Agent conversation; durable source storage uses explicit Agent Knowledge ingest.',
+    summaryTitle: 'Research posture',
+    summaryLines: [
+      'Web research: read-only main-conversation requests',
+      'URL inspection: user-directed and visible',
+      'Durable sources: explicit Agent Knowledge ingest only',
+    ],
+    fields: [
+      {
+        kind: 'action',
+        id: 'agent-research.workspace',
+        action: 'open-agent-workspace:research',
+        label: 'Research workspace',
+        hint: 'Open the Research workspace to submit web research, inspect URLs, and decide what belongs in Agent Knowledge.',
+        defaultValue: 'Open Research',
+      },
+      {
+        kind: 'status',
+        id: 'agent-research.read-only',
+        label: 'Read-only web use',
+        hint: 'Search and URL inspection are normal Agent conversation turns. They should not send messages, mutate connected-host state, or perform browser side effects.',
+        defaultValue: 'Serial',
+      },
+      {
+        kind: 'status',
+        id: 'agent-research.knowledge-boundary',
+        label: 'Source-to-knowledge boundary',
+        hint: 'Reviewed sources become durable only through confirmed Agent Knowledge ingest actions. Default knowledge and non-Agent segments are not fallback stores.',
+        defaultValue: 'Explicit ingest',
+      },
+      {
+        kind: 'status',
+        id: 'agent-research.context-references',
+        label: 'Inline URL context',
+        hint: 'Use @https://... in the composer to reference a URL for one turn without ingesting it into Agent Knowledge.',
+        defaultValue: 'Available',
+      },
+    ],
+  };
+}
+
 export function buildLocalStateStep(discovery?: AgentBehaviorDiscoverySnapshot): OnboardingWizardStepDefinition {
   const discoveredCount = discoveryCount(discovery);
   return {
@@ -163,54 +212,91 @@ export function buildLocalStateStep(discovery?: AgentBehaviorDiscoverySnapshot):
     shortLabel: 'Behavior',
     description: discoveredCount > 0
       ? 'Review importable Agent-local behavior files, then create an isolated profile from them or import individual records.'
-      : 'Review the Agent-local behavior model. Memory, personas, skills, routines, and Agent profiles stay local until a stable shared registry exists.',
-    summaryTitle: 'Local Agent state',
+      : 'Review the Agent-local behavior model. Memory, notes, personas, skills, routines, and Agent profiles stay local until a stable shared registry exists.',
+    summaryTitle: 'Agent-local state',
     summaryLines: [
-      'Memory/personas/skills/routines: local Agent registries',
-      `Discovered behavior files: ${discoverySummary(discovery)}`,
-      'Secrets: rejected or stored by secret reference',
-      'Profiles: isolated Agent homes',
+      'Memory/notes/personas/skills/routines use Agent-local registries',
+      `Discovered behavior files ${discoverySummary(discovery)}`,
+      'Secrets are rejected or stored by secret reference',
+      'Profiles use isolated Agent homes',
     ],
     fields: [
       {
-        kind: 'status',
+        kind: 'action',
         id: 'agent-local-state.memory',
+        action: 'open-agent-workspace:memory',
         label: 'Local memory',
-        hint: 'Use /memory to create, review, stale, search, and delete Agent-local memory records.',
-        defaultValue: 'Local registry',
+        hint: 'Open the Memory & Skills workspace to create, review, stale, search, and delete Agent-local memory records.',
+        defaultValue: 'Open Memory',
       },
       {
-        kind: 'status',
+        kind: 'action',
+        id: 'agent-local-state.notes',
+        action: 'open-agent-workspace:notes',
+        label: 'Scratchpad notes',
+        hint: 'Open the Notes workspace to capture source triage, temporary decisions, and operator handoff without writing memory or Agent Knowledge.',
+        defaultValue: 'Open Notes',
+      },
+      {
+        kind: 'text',
+        id: 'agent-local-state.note-title',
+        label: 'Initial note title',
+        hint: 'Optional scratchpad note created during setup. Notes are temporary working context, not durable memory or Agent Knowledge.',
+        placeholder: 'First things to remember',
+        defaultValue: '',
+      },
+      {
+        kind: 'text',
+        id: 'agent-local-state.note-body',
+        label: 'Initial note body',
+        hint: 'Capture temporary setup context, source-triage notes, or user preferences that should be reviewed before promotion.',
+        placeholder: 'Review calendar connection later; user prefers concise daily planning; do not store secrets here.',
+        defaultValue: '',
+        multiline: true,
+      },
+      {
+        kind: 'text',
+        id: 'agent-local-state.note-tags',
+        label: 'Initial note tags',
+        hint: 'Optional comma-separated tags for the setup note.',
+        placeholder: 'setup, preference',
+        defaultValue: '',
+      },
+      {
+        kind: 'action',
         id: 'agent-local-state.personas',
+        action: 'open-agent-workspace:personas',
         label: 'Personas',
         hint: discovery?.personas.count && discovery.personas.count > 0
-          ? `${discovery.personas.count} persona file(s) are available. Use the Profiles workspace to create a profile from discovered behavior, or preview individual files with /personas discover.`
-          : 'Use /personas to create and activate serial operating modes for the main conversation.',
-        defaultValue: discovery?.personas.count && discovery.personas.count > 0 ? `${discovery.personas.count} discovered` : 'Local registry',
+          ? `${discovery.personas.count} persona file(s) are available. Open the Personas workspace to review, import, activate, or create a profile from discovered behavior.`
+          : 'Open the Personas workspace to create and activate serial operating modes for the main conversation.',
+        defaultValue: discovery?.personas.count && discovery.personas.count > 0 ? `${discovery.personas.count} discovered` : 'Open Personas',
       },
       {
-        kind: 'status',
+        kind: 'action',
         id: 'agent-local-state.skills',
+        action: 'open-agent-workspace:skills',
         label: 'Skills',
         hint: discovery?.skills.count && discovery.skills.count > 0
-          ? `${discovery.skills.count} skill file(s) are available. Use the Profiles workspace to create a profile from discovered behavior, or preview individual files with /agent-skills discover.`
-          : 'Use /agent-skills and /skills local to manage reusable Agent procedures.',
-        defaultValue: discovery?.skills.count && discovery.skills.count > 0 ? `${discovery.skills.count} discovered` : 'Local registry',
+          ? `${discovery.skills.count} skill file(s) are available. Open the Skills workspace to review, import, bundle, enable reusable procedures, or create a profile from discovered behavior.`
+          : 'Open the Skills workspace to manage reusable Agent procedures.',
+        defaultValue: discovery?.skills.count && discovery.skills.count > 0 ? `${discovery.skills.count} discovered` : 'Open Skills',
       },
       {
-        kind: 'status',
+        kind: 'action',
         id: 'agent-local-state.routines',
+        action: 'open-agent-workspace:routines',
         label: 'Routines',
         hint: discovery?.routines.count && discovery.routines.count > 0
-          ? `${discovery.routines.count} routine file(s) are available. Use the Profiles workspace to create a profile from discovered behavior, or preview individual files with /routines discover. ${discoverySample(discovery)}`
-          : 'Use /routines for reusable local procedures. Starting a routine prints steps in the main conversation and does not launch local workers.',
-        defaultValue: discovery?.routines.count && discovery.routines.count > 0 ? `${discovery.routines.count} discovered` : 'Local registry',
+          ? `${discovery.routines.count} routine file(s) are available. Open the Routines workspace to review, import, start, promote reviewed routines, or create a profile from discovered behavior. ${discoverySample(discovery)}`
+          : 'Open the Routines workspace for reusable local procedures. Starting a routine prints steps in the main conversation; schedule promotion remains explicit.',
+        defaultValue: discovery?.routines.count && discovery.routines.count > 0 ? `${discovery.routines.count} discovered` : 'Open Routines',
       },
       {
         kind: 'text',
         id: 'agent-local-state.persona-name',
         label: 'Initial persona name',
-        hint: 'Optional: create and activate a serial Agent persona during setup. Leave persona fields blank to skip.',
+        hint: 'Optional serial Agent persona created and activated during setup. Leave persona fields blank to skip.',
         placeholder: 'Household Operator',
         defaultValue: '',
         spacerBeforeRows: 1,
@@ -236,7 +322,7 @@ export function buildLocalStateStep(discovery?: AgentBehaviorDiscoverySnapshot):
         kind: 'text',
         id: 'agent-local-state.skill-name',
         label: 'Initial skill name',
-        hint: 'Optional: create and enable a reusable local procedure during setup.',
+        hint: 'Optional reusable local procedure created and enabled during setup.',
         placeholder: 'Daily Briefing',
         defaultValue: '',
         spacerBeforeRows: 1,
@@ -262,7 +348,7 @@ export function buildLocalStateStep(discovery?: AgentBehaviorDiscoverySnapshot):
         kind: 'text',
         id: 'agent-local-state.routine-name',
         label: 'Initial routine name',
-        hint: 'Optional: create and enable a local routine. Routines print steps in the main conversation and do not launch hidden jobs.',
+        hint: 'Optional local routine created and enabled during setup. Routines print steps in the main conversation and do not launch hidden jobs.',
         placeholder: 'Evening Reset',
         defaultValue: '',
         spacerBeforeRows: 1,
@@ -302,18 +388,20 @@ export function buildAutomationStep(): OnboardingWizardStepDefinition {
     ],
     fields: [
       {
-        kind: 'status',
+        kind: 'action',
         id: 'agent-automation.local-routines',
+        action: 'open-agent-workspace:routines',
         label: 'Local routine library',
-        hint: 'Use /routines or the Agent workspace to create, review, enable, and start local routines without spawning hidden jobs.',
-        defaultValue: 'Local registry',
+        hint: 'Open the Routines workspace to create, review, enable, and start local routines without hidden jobs.',
+        defaultValue: 'Open Routines',
       },
       {
-        kind: 'status',
+        kind: 'action',
         id: 'agent-automation.schedule-observability',
+        action: 'open-agent-workspace:automation',
         label: 'Schedule observability',
-        hint: 'Use /schedule list, /schedule reconcile, and automation views to inspect externally owned jobs and runs.',
-        defaultValue: 'Read first',
+        hint: 'Open the Automation workspace to inspect schedules, receipts, reconciliation, externally owned jobs, and runs.',
+        defaultValue: 'Open Automation',
       },
       {
         kind: 'status',
@@ -347,11 +435,12 @@ export function buildVoiceMediaStep(): OnboardingWizardStepDefinition {
     ],
     fields: [
       {
-        kind: 'status',
+        kind: 'action',
         id: 'agent-voice-media.voice',
+        action: 'open-agent-workspace:voice-media',
         label: 'Voice interaction',
-        hint: 'Use the voice/media workspace and TTS settings to configure spoken responses for the Agent conversation.',
-        defaultValue: 'Optional',
+        hint: 'Open the Voice & Media workspace and TTS settings to configure spoken responses for the Agent conversation.',
+        defaultValue: 'Open Voice',
       },
       {
         kind: 'status',
@@ -381,7 +470,7 @@ export function buildDelegationPolicyStep(): OnboardingWizardStepDefinition {
     summaryLines: [
       'Normal chat: main Agent conversation',
       'Build/fix/review: explicit GoodVibes TUI delegation',
-      'WRFC: only when explicitly requested for build/fix/review',
+      'Delegated review: only when explicitly requested for build/fix/review',
     ],
     fields: [
       {
@@ -392,17 +481,18 @@ export function buildDelegationPolicyStep(): OnboardingWizardStepDefinition {
         defaultValue: 'Serial',
       },
       {
-        kind: 'status',
+        kind: 'action',
         id: 'agent-delegation.build-work',
+        action: 'open-agent-workspace:delegate',
         label: 'Build/fix/review work',
-        hint: 'Use /delegate with the full original task. GoodVibes TUI owns coding execution and WRFC chains.',
-        defaultValue: 'Explicit delegation',
+        hint: 'Open the Delegation workspace for explicit build/fix/review handoff. GoodVibes TUI owns coding execution and delegated review chains.',
+        defaultValue: 'Open Delegation',
       },
       {
         kind: 'status',
-        id: 'agent-delegation.wrfc',
-        label: 'WRFC policy',
-        hint: 'Agent never uses WRFC by default; request it only for explicit build, fix, review, or implementation work.',
+        id: 'agent-delegation.review',
+        label: 'Review policy',
+        hint: 'Agent never requests delegated review by default; request it only for explicit build, fix, review, or implementation work.',
         defaultValue: 'Explicit only',
       },
     ],