@pellux/goodvibes-agent 1.2.0 → 1.4.1

package/src/renderer/agent-workspace.ts

@@ -5,6 +5,8 @@ import type {
   AgentWorkspaceLocalEditor,
   AgentWorkspaceRuntimeSnapshot,
 } from '../input/agent-workspace.ts';
+import type { AgentWorkspaceEditorKind } from '../input/agent-workspace-types.ts';
+import type { AgentWorkspaceSetupChecklistItem } from '../input/agent-workspace-setup.ts';
 import type { Line } from '../types/grid.ts';
 import { wrapText } from '../utils/terminal-width.ts';
 import { GLYPHS } from './ui-primitives.ts';
@@ -18,11 +20,36 @@ import {
 } from './fullscreen-workspace.ts';
 import { actionResultColor, type AgentWorkspaceContextLine as ContextLine } from './agent-workspace-style.ts';
 import { compactText, reviewerReadinessContextLines, snapshotLines } from './agent-workspace-context-lines.ts';
+import { ONBOARDING_COMPLETE_SYNTHETIC_ACTION, ONBOARDING_CRITICAL_STEP_IDS } from '../input/agent-workspace-onboarding-finish.ts';
+
+function onboardingCategoryReadiness(
+  category: AgentWorkspaceCategory,
+  checklist: readonly AgentWorkspaceSetupChecklistItem[],
+): 'ready' | 'attention' | 'optional' {
+  const CATEGORY_CHECKLIST_MAP: Record<string, readonly string[]> = {
+    'setup': ['provider-model', 'connected-host-auth', 'runtime'],
+    'account-model': ['provider-model', 'subscriptions'],
+    'assistant-behavior': [],
+    'tools-permissions': [],
+    'onboarding-display': [],
+    'onboarding-channels': ['channels'],
+    'onboarding-voice-media': ['voice-media'],
+    'onboarding-context': ['agent-knowledge', 'persona', 'skills', 'routines', 'memory', 'notes', 'profile'],
+    'onboarding-automation': [],
+  };
+  const itemIds = CATEGORY_CHECKLIST_MAP[category.id];
+  if (!itemIds || itemIds.length === 0) return 'optional';
+  const mapped = itemIds.map((id) => checklist.find((item) => item.id === id));
+  if (mapped.every((item) => item?.status === 'ready')) return 'ready';
+  if (mapped.some((item) => item?.status === 'blocked' || item?.status === 'recommended')) return 'attention';
+  return 'optional';
+}
 
 function buildLeftRows(workspace: AgentWorkspace, height: number): WorkspaceRow[] {
   const rows: WorkspaceRow[] = [];
   let selectedRenderedIndex = 0;
   let lastGroup = '';
+  const checklist = workspace.runtimeSnapshot?.setupChecklist ?? [];
 
   workspace.categories.forEach((category, index) => {
     if (category.group !== lastGroup) {
@@ -32,11 +59,24 @@ function buildLeftRows(workspace: AgentWorkspace, height: number): WorkspaceRow[
     const selected = index === workspace.selectedCategoryIndex;
     if (selected) selectedRenderedIndex = rows.length;
     const marker = selected ? GLYPHS.navigation.selected : ' ';
+    let readinessGlyph = '';
+    let readinessFg: string | undefined;
+    if (isOnboardingCategory(category)) {
+      const readiness = onboardingCategoryReadiness(category, checklist);
+      if (readiness === 'ready') {
+        readinessGlyph = GLYPHS.status.success;
+        readinessFg = PALETTE.good;
+      } else if (readiness === 'attention') {
+        readinessGlyph = '!';
+        readinessFg = PALETTE.warn;
+      }
+    }
+    const readinessMark = readinessGlyph ? `${readinessGlyph} ` : '  ';
     rows.push({
-      text: `  ${marker} ${category.label}`,
+      text: `  ${marker} ${readinessMark}${category.label}`,
       selected: selected && workspace.focusPane === 'categories',
       kind: 'item',
-      fg: selected ? PALETTE.text : PALETTE.muted,
+      fg: selected ? PALETTE.text : readinessFg ?? PALETTE.muted,
       bold: selected,
     });
   });
@@ -68,13 +108,321 @@ function actionCommand(action: AgentWorkspaceAction): string {
   return action.command ?? '(guidance)';
 }
 
-function actionMetaLine(action: AgentWorkspaceAction): ContextLine {
+function isOnboardingCategory(category: AgentWorkspaceCategory): boolean {
+  return category.group === 'ONBOARDING';
+}
+
+interface OnboardingActionColumns {
+  readonly setting: string;
+  readonly defaultValue: string;
+  readonly currentValue: string;
+}
+
+function editorPurposeLabel(editorKind: AgentWorkspaceEditorKind): string {
+  switch (editorKind) {
+    case 'mcp-server': return 'Edit MCP server';
+    case 'mcp-tools-server': return 'Edit MCP tools server';
+    case 'mcp-repair': return 'Repair MCP connection';
+    case 'secret-link': return 'Link secret reference';
+    case 'secret-set': return 'Store secret';
+    case 'secret-test': return 'Test secret reference';
+    case 'secret-delete': return 'Delete secret';
+    case 'subscription-login-start': return 'Sign in to provider';
+    case 'subscription-login-finish': return 'Finish provider sign-in';
+    case 'subscription-logout': return 'Sign out of provider';
+    case 'subscription-inspect': return 'Inspect subscription';
+    case 'provider-add': return 'Add custom provider';
+    case 'provider-remove': return 'Remove custom provider';
+    case 'provider-use': return 'Choose provider';
+    case 'provider-inspect': return 'Inspect provider';
+    case 'provider-routes': return 'Edit provider routes';
+    case 'provider-account-repair': return 'Repair provider account';
+    case 'memory': return 'Edit memory';
+    case 'memory-search': return 'Search memory';
+    case 'memory-get': return 'Get memory record';
+    case 'memory-explain': return 'Explain memory';
+    case 'memory-promote': return 'Promote memory';
+    case 'memory-link': return 'Link memory';
+    case 'memory-export': return 'Export memory';
+    case 'memory-import': return 'Import memory';
+    case 'memory-handoff-export': return 'Export memory handoff';
+    case 'memory-handoff-inspect': return 'Inspect memory handoff';
+    case 'memory-handoff-import': return 'Import memory handoff';
+    case 'memory-vector-rebuild': return 'Rebuild memory vectors';
+    case 'note': return 'Edit note';
+    case 'persona': return 'Edit persona';
+    case 'persona-search': return 'Search personas';
+    case 'persona-show': return 'Show persona';
+    case 'persona-discovery-import': return 'Import persona files';
+    case 'skill': return 'Edit skill';
+    case 'skill-search': return 'Search skills';
+    case 'skill-show': return 'Show skill';
+    case 'skill-discovery-import': return 'Import skill files';
+    case 'routine': return 'Edit routine';
+    case 'routine-search': return 'Search routines';
+    case 'routine-show': return 'Show routine';
+    case 'routine-discovery-import': return 'Import routine files';
+    case 'profile': return 'Edit profile';
+    case 'profile-from-discovered': return 'Create profile from files';
+    case 'profile-show': return 'Show profile';
+    case 'profile-default': return 'Set default profile';
+    case 'profile-default-clear': return 'Clear default profile';
+    case 'profile-delete': return 'Delete profile';
+    case 'profile-template-export': return 'Export profile template';
+    case 'profile-template-import': return 'Import profile template';
+    case 'profile-template-show': return 'Show profile template';
+    case 'profile-template-from-discovered': return 'Create template from files';
+    case 'knowledge-url': return 'Ingest URL';
+    case 'knowledge-urls': return 'Ingest URLs';
+    case 'knowledge-file': return 'Ingest file';
+    case 'knowledge-bookmarks': return 'Import bookmarks';
+    case 'knowledge-browser-history': return 'Import browser history';
+    case 'knowledge-connector-ingest': return 'Run connector ingest';
+    case 'knowledge-connector-show': return 'Show connector';
+    case 'knowledge-connector-doctor': return 'Check connector health';
+    case 'knowledge-reindex': return 'Reindex knowledge';
+    case 'knowledge-search': return 'Search knowledge';
+    case 'knowledge-ask': return 'Ask knowledge';
+    case 'knowledge-get': return 'Get knowledge record';
+    case 'knowledge-map': return 'Map knowledge';
+    case 'knowledge-review-issue': return 'Review knowledge issue';
+    case 'knowledge-consolidate': return 'Consolidate knowledge';
+    case 'knowledge-packet': return 'Build knowledge packet';
+    case 'knowledge-explain': return 'Explain knowledge';
+    case 'delegate-task': return 'Delegate build task';
+    case 'document-browse': return 'Browse documents';
+    case 'document-show': return 'Show document';
+    case 'document-create': return 'Create document';
+    case 'document-update': return 'Revise document';
+    case 'document-review': return 'Review document';
+    case 'document-comment': return 'Add comment';
+    case 'document-resolve-comment': return 'Resolve comment';
+    case 'document-suggest': return 'Propose suggestion';
+    case 'document-accept-suggestion': return 'Accept suggestion';
+    case 'document-reject-suggestion': return 'Reject suggestion';
+    case 'document-insert-artifact': return 'Insert artifact';
+    case 'document-attach-artifact': return 'Attach artifact';
+    case 'document-export': return 'Export document';
+    case 'document-reviewer-readiness': return 'Review readiness preflight';
+    case 'document-review-packet-wizard': return 'Run packet wizard';
+    case 'document-review-packet-preset': return 'Save packet preset';
+    case 'document-review-packet-preset-refresh': return 'Refresh packet preset';
+    case 'document-review-packet-share': return 'Share review packet';
+    case 'model-compare': return 'Compare models';
+    case 'model-compare-review': return 'Review comparison';
+    case 'model-compare-handoff-diff': return 'Diff reviewer handoffs';
+    case 'model-compare-judge': return 'Judge comparison';
+    case 'model-compare-apply': return 'Apply comparison winner';
+    case 'model-compare-route-decision': return 'Record route decision';
+    case 'model-compare-export': return 'Export comparison';
+    case 'model-compare-analytics': return 'View comparison analytics';
+    case 'local-model-benchmark': return 'Run local benchmark';
+    case 'auth-show': return 'Show auth status';
+    case 'auth-repair': return 'Repair auth';
+    case 'auth-bundle-export': return 'Export auth bundle';
+    case 'auth-bundle-inspect': return 'Inspect auth bundle';
+    case 'trust-bundle-export': return 'Export trust bundle';
+    case 'trust-bundle-inspect': return 'Inspect trust bundle';
+    case 'support-bundle-export': return 'Export support bundle';
+    case 'support-bundle-inspect': return 'Inspect support bundle';
+    case 'support-bundle-import': return 'Import support bundle';
+    case 'subscription-bundle-export': return 'Export subscription bundle';
+    case 'subscription-bundle-inspect': return 'Inspect subscription bundle';
+    case 'voice-enable': return 'Enable voice';
+    case 'voice-disable': return 'Disable voice';
+    case 'voice-bundle-export': return 'Export voice bundle';
+    case 'voice-bundle-inspect': return 'Inspect voice bundle';
+    case 'tts-prompt': return 'Test TTS prompt';
+    case 'image-input': return 'Attach image';
+    case 'artifact-browser': return 'Browse artifacts';
+    case 'artifact-show': return 'Show artifact';
+    case 'artifact-export-file': return 'Export artifact to file';
+    case 'artifact-export-package': return 'Export artifact package';
+    case 'artifact-promote-knowledge': return 'Promote artifact to knowledge';
+    case 'media-generate': return 'Generate media';
+    case 'conversation-export': return 'Export conversation';
+    case 'conversation-events': return 'Show conversation events';
+    case 'conversation-groups': return 'Show conversation groups';
+    case 'conversation-find': return 'Find conversation';
+    case 'effort-level': return 'Set effort level';
+    case 'channel-show': return 'Show channel';
+    case 'channel-doctor': return 'Check channel health';
+    case 'channel-setup': return 'Set up channel';
+    case 'channel-send': return 'Send to channel';
+    case 'session-save': return 'Save session';
+    case 'session-load': return 'Load session';
+    case 'session-rename': return 'Rename session';
+    case 'session-resume': return 'Resume session';
+    case 'session-info': return 'Inspect session';
+    case 'session-export-saved': return 'Export saved session';
+    case 'session-search': return 'Search sessions';
+    case 'session-delete': return 'Delete session';
+    case 'session-fork': return 'Fork session';
+    case 'session-graph': return 'Inspect session graph';
+    case 'task-list-filter': return 'Filter task list';
+    case 'task-show': return 'Show task';
+    case 'task-output': return 'View task output';
+    case 'plan-seed': return 'Seed plan';
+    case 'plan-show': return 'Show plan';
+    case 'plan-approve': return 'Approve plan';
+    case 'plan-override': return 'Override plan';
+    case 'plan-clear': return 'Clear plan';
+    case 'health-repair': return 'Repair health issue';
+    case 'approval-review': return 'Review approval';
+    case 'approval-approve': return 'Approve request';
+    case 'approval-deny': return 'Deny request';
+    case 'approval-cancel': return 'Cancel approval';
+    case 'automation-job-run': return 'Run automation job';
+    case 'automation-job-pause': return 'Pause automation job';
+    case 'automation-job-resume': return 'Resume automation job';
+    case 'automation-run-cancel': return 'Cancel automation run';
+    case 'automation-run-retry': return 'Retry automation run';
+    case 'schedule-run': return 'Run schedule';
+    case 'schedule-edit': return 'Edit schedule';
+    case 'routine-receipt': return 'View routine receipt';
+    case 'schedule-receipt': return 'View schedule receipt';
+    case 'mode-preset': return 'Set mode preset';
+    case 'mode-domain': return 'Set mode domain';
+    case 'setting-set': return 'Set setting';
+    case 'model-pin': return 'Pin model';
+    case 'model-unpin': return 'Unpin model';
+    case 'workplan-add': return 'Add work item';
+    case 'workplan-show': return 'Show work plan';
+    case 'workplan-status': return 'Check work plan status';
+    case 'workplan-delete': return 'Delete work item';
+    case 'workplan-clear-completed': return 'Clear completed items';
+    case 'routine-schedule': return 'Schedule routine';
+    case 'reminder-schedule': return 'Schedule reminder';
+    case 'skill-bundle': return 'Edit skill bundle';
+    case 'skill-bundle-search': return 'Search skill bundles';
+    case 'skill-bundle-show': return 'Show skill bundle';
+    case 'skill-bundle-update': return 'Update skill bundle';
+    case 'skill-bundle-enable': return 'Enable skill bundle';
+    case 'skill-bundle-disable': return 'Disable skill bundle';
+    case 'skill-bundle-review': return 'Review skill bundle';
+    case 'skill-bundle-stale': return 'Mark bundle stale';
+    case 'skill-bundle-delete': return 'Delete skill bundle';
+    case 'learned-behavior': return 'Review learned behavior';
+    case 'web-research': return 'Run web research';
+    case 'web-fetch': return 'Fetch from web';
+    case 'research-run': return 'Run research';
+    case 'research-source': return 'Manage research source';
+    case 'research-report': return 'Show research report';
+    case 'notify-webhook': return 'Add notification webhook';
+    case 'notify-webhook-remove': return 'Remove notification webhook';
+    case 'notify-webhook-clear': return 'Clear notification webhooks';
+    case 'notify-webhook-test': return 'Test notification webhook';
+    case 'notify-send': return 'Send notification';
+    default: return `Edit ${editorKind}`;
+  }
+}
+
+function localOperationLabel(localOperation: string): string {
+  switch (localOperation) {
+    case 'routine-start': return 'Start routine';
+    case 'persona-activate':
+    case 'persona-use': return 'Activate persona';
+    case 'persona-clear': return 'Deactivate persona';
+    case 'persona-edit': return 'Edit persona';
+    case 'persona-review': return 'Review persona';
+    case 'persona-delete': return 'Delete persona';
+    case 'memory-edit': return 'Edit memory';
+    case 'memory-review': return 'Review memory';
+    case 'memory-stale': return 'Mark memory stale';
+    case 'memory-delete': return 'Delete memory';
+    case 'note-edit': return 'Edit note';
+    case 'note-review': return 'Review note';
+    case 'note-stale': return 'Mark note stale';
+    case 'note-delete': return 'Delete note';
+    case 'note-promote-memory': return 'Promote note to memory';
+    case 'note-promote-persona': return 'Promote note to persona';
+    case 'note-promote-skill': return 'Promote note to skill';
+    case 'note-promote-routine': return 'Promote note to routine';
+    case 'note-promote-knowledge-url': return 'Promote note to knowledge';
+    case 'skill-edit': return 'Edit skill';
+    case 'skill-enable': return 'Enable skill';
+    case 'skill-disable': return 'Disable skill';
+    case 'skill-review': return 'Review skill';
+    case 'skill-delete': return 'Delete skill';
+    case 'routine-edit': return 'Edit routine';
+    case 'routine-enable': return 'Enable routine';
+    case 'routine-disable': return 'Disable routine';
+    case 'routine-review': return 'Review routine';
+    case 'routine-delete': return 'Delete routine';
+    default: return 'Apply local action';
+  }
+}
+
+function onboardingActionLabel(workspace: AgentWorkspace, action: AgentWorkspaceAction): string {
+  if (action.kind === 'settings-import') return 'Import GoodVibes preferences';
+  if (action.kind === 'setup-checkpoint') {
+    if (action.setupCheckpointOperation === 'show') return 'Review saved progress';
+    if (action.setupCheckpointOperation === 'mark-current') return 'Save progress';
+    if (action.setupCheckpointOperation === 'clear') return 'Clear saved progress';
+    return 'Review setup progress';
+  }
+  if (action.kind === 'model-picker') return action.modelPickerFlow === 'model' ? 'Choose model' : 'Choose provider and model';
+  if (action.kind === 'settings-modal') return 'Open settings';
+  if (action.kind === 'workspace') {
+    if (action.targetCategoryId) {
+      const target = workspace.categories.find((c) => c.id === action.targetCategoryId);
+      const label = target ? target.label : action.targetCategoryId;
+      return `Switch to ${label}`;
+    }
+    return 'Switch to setup area';
+  }
+  if (action.kind === 'editor') return action.editorKind ? editorPurposeLabel(action.editorKind) : 'Open form';
+  if (action.kind === 'local-selection') return 'Move selection';
+  if (action.kind === 'local-operation') return action.localOperation ? localOperationLabel(action.localOperation) : 'Apply local action';
+  if (action.kind === 'onboarding-complete') return 'Finish setup';
+  if (action.kind === 'command') {
+    const cmd = action.command ?? '';
+    return action.commandBehavior === 'inline' ? `Run: ${cmd}` : `Open: ${cmd}`;
+  }
+  if (action.safety === 'read-only') return 'Review';
+  if (action.safety === 'blocked') return 'Unavailable in this setup step';
+  return 'Open';
+}
+
+function onboardingActionColumns(workspace: AgentWorkspace, action: AgentWorkspaceAction): OnboardingActionColumns {
+  if (action.kind === 'setting') {
+    return workspace.settingActionDisplay(action) ?? {
+      setting: action.label,
+      defaultValue: '(unknown)',
+      currentValue: '(unknown)',
+    };
+  }
+  return {
+    setting: onboardingActionLabel(workspace, action),
+    defaultValue: '',
+    currentValue: '',
+  };
+}
+
+function actionChange(workspace: AgentWorkspace, category: AgentWorkspaceCategory, action: AgentWorkspaceAction): string {
+  return isOnboardingCategory(category) ? onboardingActionColumns(workspace, action).setting : actionCommand(action);
+}
+
+function actionMetaLine(workspace: AgentWorkspace, category: AgentWorkspaceCategory, action: AgentWorkspaceAction): ContextLine {
+  const onboarding = isOnboardingCategory(category);
+  if (onboarding) {
+    return {
+      text: `About: ${compactText(action.detail, 100)}`,
+      fg: action.safety === 'blocked' ? PALETTE.warn : PALETTE.muted,
+    };
+  }
   return {
-    text: `Does: ${actionCommand(action)}`,
+    text: `Does: ${actionChange(workspace, category, action)}`,
     fg: action.safety === 'blocked' ? PALETTE.warn : action.kind === 'command' ? PALETTE.info : PALETTE.muted,
   };
 }
 
+function shouldRenderOnboardingSettingsTable(actions: readonly AgentWorkspaceAction[]): boolean {
+  // Exclude the synthetic finish footer row — it is not a setting and must not block table mode.
+  const nonFinish = actions.filter((a) => a.kind !== 'onboarding-complete');
+  return nonFinish.length > 0 && nonFinish.every((action) => action.kind === 'setting');
+}
+
 function editorContextLines(editor: AgentWorkspaceLocalEditor, snapshot: AgentWorkspaceRuntimeSnapshot | null): ContextLine[] {
   const selected = editor.fields[editor.selectedFieldIndex];
   const lines: ContextLine[] = [
@@ -135,19 +483,20 @@ function buildContextRows(workspace: AgentWorkspace, category: AgentWorkspaceCat
   const selectedActionLines: ContextLine[] = action
     ? [
       { text: `Selected: ${action.label}`, fg: PALETTE.title, bold: true },
-      actionMetaLine(action),
+      actionMetaLine(workspace, category, action),
     ]
     : [];
   const snapshotContextLines = snapshotLines(workspace, category, workspace.runtimeSnapshot);
   lines.push(...selectedActionLines, ...snapshotContextLines);
 
+  const onboarding = isOnboardingCategory(category);
   if (workspace.lastActionResult) {
     lines.push(
-      { text: 'Action Result', fg: PALETTE.title, bold: true },
+      { text: onboarding ? 'Result' : 'Action Result', fg: PALETTE.title, bold: true },
       { text: workspace.lastActionResult.title, fg: actionResultColor(workspace.lastActionResult), bold: true },
       { text: compactText(workspace.lastActionResult.detail), fg: PALETTE.text },
     );
-    if (workspace.lastActionResult.command) {
+    if (!onboarding && workspace.lastActionResult.command) {
       lines.push({ text: `Command: ${workspace.lastActionResult.command}`, fg: PALETTE.muted });
     }
   }
@@ -211,10 +560,25 @@ function buildEditorFieldRows(editor: AgentWorkspaceLocalEditor, index: number,
   return rows;
 }
 
+function onboardingFinishPrerequisitesMet(workspace: AgentWorkspace): boolean {
+  const checklist = workspace.runtimeSnapshot?.setupChecklist ?? [];
+  return ONBOARDING_CRITICAL_STEP_IDS.every((id) => checklist.find((item) => item.id === id)?.status === 'ready');
+}
+
 function buildActionRows(workspace: AgentWorkspace, width: number, height: number): WorkspaceRow[] {
   if (workspace.localEditor) return buildEditorRows(workspace.localEditor, width, height);
+  const category = workspace.selectedActionCategory;
+  const onboarding = isOnboardingCategory(category);
+  const settingTable = onboarding
+    && !workspace.actionSearchActive
+    && shouldRenderOnboardingSettingsTable(workspace.actions);
   const rows: WorkspaceRow[] = [];
-  const labelWidth = Math.min(34, Math.max(18, Math.floor(width * 0.38)));
+  const valueWidth = settingTable
+    ? Math.min(22, Math.max(10, Math.floor(width * 0.18)))
+    : 0;
+  const labelWidth = settingTable
+    ? Math.max(18, width - (valueWidth * 2) - 6)
+    : Math.min(34, Math.max(18, Math.floor(width * 0.38)));
   const commandWidth = Math.max(10, width - labelWidth - 6);
   if (workspace.actionSearchActive) {
     rows.push({
@@ -224,40 +588,89 @@ function buildActionRows(workspace: AgentWorkspace, width: number, height: numbe
     });
   }
   rows.push({
-    text: `  ${padDisplay(workspace.actionSearchActive ? 'Result' : 'Action', labelWidth)}  ${padDisplay('Does', commandWidth)}`,
+    text: settingTable
+      ? `  ${padDisplay(workspace.actionSearchActive ? 'Result' : 'Setting', labelWidth)}  ${padDisplay('Default', valueWidth)}  ${padDisplay('Current', valueWidth)}`
+      : `  ${padDisplay(workspace.actionSearchActive ? 'Result' : onboarding ? 'Option' : 'Action', labelWidth)}  ${padDisplay('Does', commandWidth)}`,
     fg: PALETTE.muted,
     bold: true,
   });
 
-  const actions = workspace.actions;
+  // The finish footer row is appended to workspace.actions by the input layer
+  // (shouldShowOnboardingFinishFooter). Detect it here by action id for special styling.
+  const allActions = workspace.actions;
+  const finishActionIndex = allActions.findIndex((a) => a.id === ONBOARDING_COMPLETE_SYNTHETIC_ACTION.id);
+
   const visible = Math.max(1, height - (workspace.actionSearchActive ? 3 : 2));
-  const window = stableWindow(actions.length, workspace.selectedActionIndex, visible);
+  const window = stableWindow(allActions.length, workspace.selectedActionIndex, visible);
   if (window.start > 0) rows.push({ text: `${GLYPHS.navigation.moreAbove} ${window.start} more action(s) above`, kind: 'more', fg: PALETTE.dim, dim: true });
 
   for (let index = window.start; index < window.end; index += 1) {
-    const action = actions[index]!;
+    const action = allActions[index]!;
+    const isFinishFooterRow = finishActionIndex >= 0 && index === finishActionIndex;
     const selected = index === workspace.selectedActionIndex;
     const searchResult = workspace.actionSearchActive ? workspace.actionSearchResults[index] : null;
+    const actionCategory = searchResult?.category ?? category;
     const label = searchResult ? `${searchResult.category.label} / ${action.label}` : action.label;
     const marker = selected ? GLYPHS.navigation.selected : ' ';
-    rows.push({
-      text: `${marker} ${padDisplay(label, labelWidth)}  ${padDisplay(actionCommand(action), commandWidth)}`,
-      selected: selected && workspace.focusPane === 'actions',
-      fg: action.safety === 'blocked' ? PALETTE.warn : selected ? PALETTE.text : PALETTE.info,
-      bold: selected,
-    });
+
+    if (isFinishFooterRow) {
+      // Sticky Finish setup footer row
+      const prereqsMet = onboardingFinishPrerequisitesMet(workspace);
+      const sep = `${GLYPHS.frame.horizontal.repeat(3)} Finish setup ${GLYPHS.frame.horizontal.repeat(3)}`;
+      if (!selected) {
+        rows.push({
+          text: `  ${sep}`,
+          kind: 'item',
+          fg: PALETTE.dim,
+          dim: true,
+        });
+      }
+      const finishDetail = prereqsMet
+        ? 'Finish setup'
+        : (() => {
+          const checklist = workspace.runtimeSnapshot?.setupChecklist ?? [];
+          const unmet = [...ONBOARDING_CRITICAL_STEP_IDS]
+            .filter((id) => checklist.find((item) => item.id === id)?.status !== 'ready')
+            .map((id) => checklist.find((item) => item.id === id)?.label ?? id)
+            .join(', ');
+          return `Finish needs: ${unmet}`;
+        })();
+      const text = settingTable
+        ? `${marker} ${padDisplay('Finish setup', labelWidth)}  ${padDisplay('', valueWidth)}  ${padDisplay('', valueWidth)}`
+        : `${marker} ${padDisplay('Finish setup', labelWidth)}  ${padDisplay(finishDetail, commandWidth)}`;
+      rows.push({
+        text,
+        selected: selected && workspace.focusPane === 'actions',
+        fg: prereqsMet ? PALETTE.good : PALETTE.warn,
+        bold: selected,
+        kind: 'item',
+      });
+    } else {
+      const text = settingTable
+        ? (() => {
+          const columns = onboardingActionColumns(workspace, action);
+          return `${marker} ${padDisplay(columns.setting, labelWidth)}  ${padDisplay(columns.defaultValue, valueWidth)}  ${padDisplay(columns.currentValue, valueWidth)}`;
+        })()
+        : `${marker} ${padDisplay(label, labelWidth)}  ${padDisplay(actionChange(workspace, actionCategory, action), commandWidth)}`;
+      rows.push({
+        text,
+        selected: selected && workspace.focusPane === 'actions',
+        fg: action.safety === 'blocked' ? PALETTE.warn : selected ? PALETTE.text : PALETTE.info,
+        bold: selected,
+      });
+    }
   }
 
-  if (window.end < actions.length) rows.push({ text: `${GLYPHS.navigation.moreBelow} ${actions.length - window.end} more action(s) below`, kind: 'more', fg: PALETTE.dim, dim: true });
+  if (window.end < allActions.length) rows.push({ text: `${GLYPHS.navigation.moreBelow} ${allActions.length - window.end} more action(s) below`, kind: 'more', fg: PALETTE.dim, dim: true });
   rows.push({ text: '' });
   rows.push({ text: `Status: ${workspace.status}`, fg: PALETTE.muted });
   if (workspace.lastActionResult) {
     rows.push({ text: '' });
-    rows.push({ text: `Action Result: ${workspace.lastActionResult.title}`, fg: actionResultColor(workspace.lastActionResult), bold: true });
+    rows.push({ text: `${onboarding ? 'Result' : 'Action Result'}: ${workspace.lastActionResult.title}`, fg: actionResultColor(workspace.lastActionResult), bold: true });
     for (const line of wrapText(workspace.lastActionResult.detail, Math.max(1, width - 2))) {
       rows.push({ text: `  ${line}`, fg: PALETTE.text });
     }
-    if (workspace.lastActionResult.command) {
+    if (!onboarding && workspace.lastActionResult.command) {
       rows.push({ text: `  Command: ${workspace.lastActionResult.command}`, fg: PALETTE.muted });
     }
   }

package/src/runtime/tool-permission-safety.ts

@@ -67,7 +67,7 @@ const READ_ONLY_VIBE_ACTIONS = new Set(['', 'status', 'summary', 'list', 'show',
 const READ_ONLY_PERSONAL_OPS_ACTIONS = new Set(['', 'briefing', 'brief', 'daily', 'daily_brief', 'morning', 'status', 'summary', 'overview', 'map', 'list', 'queue', 'queues', 'review_queue', 'review_queues', 'personal_queue', 'ops_queue', 'intake', 'request', 'route', 'plan', 'triage', 'draft', 'lane', 'inspect', 'show']);
 const READ_ONLY_RESEARCH_ACTIONS = new Set(['', 'briefing', 'brief', 'status', 'dashboard', 'cockpit', 'next', 'plan', 'workflow', 'research', 'runner', 'browser', 'browser_runner', 'browser_backed', 'deep_research', 'runs', 'list_runs', 'run_list', 'run', 'show_run', 'inspect_run', 'sources', 'queue', 'source_queue', 'source', 'show_source', 'inspect_source', 'bundle', 'bundle_sources', 'source_bundle', 'search', 'public_search', 'collect', 'collect_sources', 'source_candidates', 'reports', 'list_reports', 'report_list', 'visual_reports', 'report_artifact', 'show_report', 'inspect_report', 'show_visual_report', 'visual_report_artifact']);
 const READ_ONLY_CHANNELS_ACTIONS = new Set(['', 'status', 'summary', 'list', 'readiness', 'channels', 'channel', 'show', 'inspect', 'setup', 'guide', 'setup_guide', 'channel_setup_guide', 'triage', 'inbox', 'blockers', 'retries', 'channel_triage', 'deliveries', 'delivery', 'receipts', 'history', 'channel_deliveries']);
-const READ_ONLY_MEMORY_ACTIONS = new Set(['', 'status', 'summary', 'posture', 'memory_posture', 'recall', 'providers', 'provider', 'memory_provider', 'embedding', 'external', 'external_provider', 'curator', 'learning', 'learning_curator', 'queue', 'review_queue', 'plan', 'candidate', 'learning_candidate', 'card', 'inspect_candidate', 'list', 'records', 'memories', 'search', 'find', 'lookup', 'get', 'show', 'inspect', 'read']);
+const READ_ONLY_MEMORY_ACTIONS = new Set(['', 'status', 'summary', 'posture', 'memory_posture', 'recall', 'providers', 'provider', 'memory_provider', 'embedding', 'external', 'external_provider', 'refinement', 'refinement_tasks', 'semantic_refinement', 'self_improvement', 'semantic_self_improvement', 'learning_loop', 'curator', 'learning', 'learning_curator', 'queue', 'review_queue', 'plan', 'candidate', 'learning_candidate', 'card', 'inspect_candidate', 'list', 'records', 'memories', 'search', 'find', 'lookup', 'get', 'show', 'inspect', 'read']);
 const READ_ONLY_COMPUTER_ACTIONS = new Set(['', 'status', 'summary', 'overview', 'computer', 'computer_use', 'plan', 'route', 'control_plan', 'browser_plan', 'desktop_plan', 'control', 'browser_control', 'desktop', 'desktop_control', 'screenshot', 'screen', 'screen_recording', 'observe', 'browser', 'pwa', 'cockpit', 'browser_cockpit', 'web', 'setup', 'configure', 'browser_desktop_control', 'mcp', 'tools', 'servers', 'mcp_servers']);
 const READ_ONLY_DEVICE_ACTIONS = new Set(['', 'status', 'map', 'capabilities', 'device', 'devices', 'mobile', 'phone', 'pairing', 'capability', 'route', 'pairing_route', 'show', 'inspect', 'browser', 'pwa', 'cockpit', 'browser_cockpit', 'web', 'control', 'browser_control', 'desktop', 'desktop_control', 'computer_use', 'voice', 'media', 'voice_media', 'workflows', 'provider', 'media_provider', 'voice_provider']);
 const READ_ONLY_MODELS_ACTIONS = new Set(['', 'status', 'routing', 'routes', 'models', 'model', 'readiness', 'route_readiness', 'route', 'model_route', 'inspect', 'show', 'candidate', 'endpoint', 'local', 'cookbook', 'local_cookbook', 'recipes', 'recipe', 'ollama', 'llama_cpp', 'llamacpp', 'vllm', 'local_servers', 'providers', 'provider_accounts', 'accounts', 'subscriptions', 'auth', 'logins', 'provider', 'provider_account', 'account', 'subscription', 'auth_status']);

package/src/tools/agent-harness-agent-orchestration-policy.ts

@@ -0,0 +1,75 @@
+export const AGENT_TOOL_MODES = [
+  'spawn',
+  'batch-spawn',
+  'list',
+  'templates',
+  'status',
+  'get',
+  'budget',
+  'plan',
+  'wait',
+  'message',
+  'cancel',
+  'wrfc-chains',
+  'wrfc-history',
+  'cohort-status',
+  'cohort-report',
+] as const;
+
+export const AGENT_TEMPLATES = ['orchestrator', 'engineer', 'reviewer', 'tester', 'researcher', 'integrator', 'general'] as const;
+
+export function agentOrchestrationDecisionCards(agentToolAvailable: boolean): readonly Record<string, unknown>[] {
+  return [
+    {
+      id: 'serial-by-default',
+      label: 'Stay serial by default',
+      status: 'ready',
+      chooseWhen: ['Ordinary chat, planning, research, setup, local context, and short current-workspace tool work.'],
+      route: 'main conversation',
+      reason: 'Lowest-friction route for the user when parallelism does not improve outcome.',
+    },
+    {
+      id: 'visible-single-agent',
+      label: 'Spawn one visible agent',
+      status: agentToolAvailable ? 'ready' : 'unavailable',
+      chooseWhen: ['A bounded autonomous task can run independently with visible status and cancellation.'],
+      requiredFields: ['task', 'successCriteria or requiredEvidence when outcome quality matters'],
+      modelRoute: 'agent { mode: "spawn" }',
+      inspectRoute: 'agent_harness mode:"agent_orchestration"',
+    },
+    {
+      id: 'visible-batch-spawn',
+      label: 'Batch-spawn independent agents',
+      status: agentToolAvailable ? 'ready' : 'unavailable',
+      chooseWhen: ['Tasks are genuinely independent and parallel work materially improves time-to-result.'],
+      doNotUseWhen: ['Review/test/verification role fanout for one deliverable; that collapses to one owner chain.'],
+      requiredFields: ['tasks[]', 'authoritativeTask for the original user ask when applicable'],
+      modelRoute: 'agent { mode: "batch-spawn" }',
+      inspectRoute: 'agent_harness mode:"agent_orchestration"',
+    },
+    {
+      id: 'managed-multi-runner-plan',
+      label: 'Use a managed multi-runner plan',
+      status: agentToolAvailable ? 'ready' : 'unavailable',
+      chooseWhen: ['A large task already has approval for parallel work and needs milestones, evidence, and cancellation routes.'],
+      requiredFields: ['original user ask', 'lane reason', 'success criteria', 'per-runner evidence', 'cancel/recovery route'],
+      modelRoute: 'agent_work_plan action:"dispatch_agents" ids:["..."] confirm:true explicitUserRequest:"..."',
+      inspectRoute: 'agent_harness mode:"agent_orchestration"',
+      policy: 'Read-only plan surface first; approved work-plan dispatch, spawn, message, wait, cancel, or remote mutation stays on confirmed first-class routes.',
+    },
+    {
+      id: 'inspect-or-control-visible-agent',
+      label: 'Inspect or control a visible agent',
+      status: agentToolAvailable ? 'ready' : 'unavailable',
+      chooseWhen: ['The user asks for progress, budget, plan, message, wait, cancel, WRFC chain, or cohort status.'],
+      modelRoutes: ['agent { mode: "list" }', 'agent { mode: "get" }', 'agent { mode: "message" }', 'agent { mode: "wait" }', 'agent { mode: "cancel" }'],
+    },
+    {
+      id: 'hidden-fanout-blocked',
+      label: 'Block hidden fanout',
+      status: 'blocked',
+      chooseWhen: ['A request implies invisible background agents, unmanaged parallel coding workers, or orphaned jobs.'],
+      saferRoutes: ['visible work plan', 'research run', 'confirmed schedule', 'agent { mode: "spawn" }', 'delegation action:"status"'],
+    },
+  ];
+}