@pellux/goodvibes-agent 0.1.117 → 1.0.0

package/src/renderer/agent-workspace.ts

@@ -1,11 +1,11 @@
 import type {
   AgentWorkspace,
   AgentWorkspaceAction,
-  AgentWorkspaceActionResult,
   AgentWorkspaceCategory,
   AgentWorkspaceLocalEditor,
   AgentWorkspaceRuntimeSnapshot,
 } from '../input/agent-workspace.ts';
+import { formatAgentRecordReviewState, formatAgentRecordSource } from '../agent/record-labels.ts';
 import type { Line } from '../types/grid.ts';
 import { wrapText } from '../utils/terminal-width.ts';
 import { GLYPHS } from './ui-primitives.ts';
@@ -17,20 +17,7 @@ import {
   WORKSPACE_PALETTE as PALETTE,
   type WorkspaceRow,
 } from './fullscreen-workspace.ts';
-
-function safetyColor(action: AgentWorkspaceAction): string {
-  if (action.safety === 'safe') return PALETTE.good;
-  if (action.safety === 'read-only') return PALETTE.info;
-  if (action.safety === 'delegates') return PALETTE.warn;
-  return PALETTE.bad;
-}
-
-function actionResultColor(result: AgentWorkspaceActionResult): string {
-  if (result.kind === 'blocked' || result.kind === 'error') return PALETTE.bad;
-  if (result.kind === 'dispatched') return PALETTE.info;
-  if (result.kind === 'refreshed') return PALETTE.good;
-  return PALETTE.muted;
-}
+import { actionResultColor, safetyColor, setupStatusColor, type AgentWorkspaceContextLine as ContextLine } from './agent-workspace-style.ts';
 
 function buildLeftRows(workspace: AgentWorkspace, height: number): WorkspaceRow[] {
   const rows: WorkspaceRow[] = [];
@@ -75,15 +62,6 @@ function actionCommand(action: AgentWorkspaceAction): string {
   return action.command ?? '(guidance)';
 }
 
-type ContextLine = { readonly text: string; readonly fg?: string; readonly bold?: boolean; readonly dim?: boolean };
-
-function setupStatusColor(status: AgentWorkspaceRuntimeSnapshot['setupChecklist'][number]['status']): string {
-  if (status === 'ready') return PALETTE.good;
-  if (status === 'recommended') return PALETTE.warn;
-  if (status === 'blocked') return PALETTE.bad;
-  return PALETTE.muted;
-}
-
 function setupChecklistLines(snapshot: AgentWorkspaceRuntimeSnapshot): ContextLine[] {
   const readyCount = snapshot.setupChecklist.filter((item) => item.status === 'ready').length;
   const recommendedCount = snapshot.setupChecklist.filter((item) => item.status === 'recommended').length;
@@ -104,22 +82,60 @@ function setupChecklistLines(snapshot: AgentWorkspaceRuntimeSnapshot): ContextLi
   return lines;
 }
 
-function discoverySummaryLine(label: string, summary: AgentWorkspaceRuntimeSnapshot['discoveredBehavior']['personas'], command: string): ContextLine[] {
+function homeNextActionLines(snapshot: AgentWorkspaceRuntimeSnapshot): ContextLine[] {
+  const blocked = snapshot.setupChecklist.filter((item) => item.status === 'blocked');
+  const recommended = snapshot.setupChecklist.filter((item) => item.status === 'recommended');
+  const optional = snapshot.setupChecklist.filter((item) => item.status === 'optional');
+  const candidates = [...blocked, ...recommended, ...optional].slice(0, 5);
+  if (candidates.length === 0) {
+    return [
+      { text: 'Next Actions', fg: PALETTE.title, bold: true },
+      { text: 'Core setup is ready. Continue normal assistant work, review Knowledge sources, or tune local skills/routines as needed.', fg: PALETTE.good },
+    ];
+  }
+  const lines: ContextLine[] = [{ text: 'Next Actions', fg: PALETTE.title, bold: true }];
+  for (const item of candidates) {
+    const command = item.command ? ` -> ${item.command}` : '';
+    lines.push({
+      text: `${item.status.toUpperCase()} ${item.label}${command}`,
+      fg: setupStatusColor(item.status),
+      bold: item.status === 'blocked',
+    });
+    lines.push({ text: `  ${item.detail}`, fg: PALETTE.muted });
+  }
+  return lines;
+}
+
+function companionAccessLine(snapshot: AgentWorkspaceRuntimeSnapshot): ContextLine {
+  const access = snapshot.companionAccess;
+  const tokenState = access.tokenReadable
+    ? `ready sha256:${access.tokenFingerprint ?? 'unknown'}`
+    : access.tokenPresent
+      ? 'present but unreadable'
+      : 'missing';
+  const error = access.tokenError ? `; token read error ${access.tokenError}` : '';
+  return {
+    text: `Companion: ${access.surface}; token ${tokenState}; QR ${access.qrCommand}; manual token text hidden${error}.`,
+    fg: access.pairingReady ? PALETTE.good : PALETTE.warn,
+  };
+}
+
+function discoverySummaryLine(label: string, summary: AgentWorkspaceRuntimeSnapshot['discoveredBehavior']['personas'], actionLabel: string): ContextLine[] {
   if (summary.count === 0) return [];
   const names = summary.names.length > 0
     ? ` ${summary.names.join(', ')}${summary.count > summary.names.length ? `, +${summary.count - summary.names.length} more` : ''}.`
     : '';
   return [
     { text: `${label}: ${summary.count} discovered; project ${summary.projectLocalCount}; global ${summary.globalCount}.`, fg: PALETTE.info, bold: true },
-    { text: `  ${command} to preview, then use the import form after review.${names}`, fg: PALETTE.muted },
+    { text: `  Choose ${actionLabel} to preview, then use the import form after review.${names}`, fg: PALETTE.muted },
   ];
 }
 
 function behaviorDiscoveryLines(snapshot: AgentWorkspaceRuntimeSnapshot): ContextLine[] {
   const lines: ContextLine[] = [
-    ...discoverySummaryLine('Discovered personas', snapshot.discoveredBehavior.personas, '/personas discover'),
-    ...discoverySummaryLine('Discovered skills', snapshot.discoveredBehavior.skills, '/agent-skills discover'),
-    ...discoverySummaryLine('Discovered routines', snapshot.discoveredBehavior.routines, '/routines discover'),
+    ...discoverySummaryLine('Discovered personas', snapshot.discoveredBehavior.personas, 'Personas -> Discover persona files'),
+    ...discoverySummaryLine('Discovered skills', snapshot.discoveredBehavior.skills, 'Skills -> Discover skill files'),
+    ...discoverySummaryLine('Discovered routines', snapshot.discoveredBehavior.routines, 'Routines -> Discover routine files'),
   ];
   if (lines.length === 0) return [];
   return [
@@ -153,11 +169,12 @@ function localLibraryLines(
       item.requirementCount !== undefined && item.requirementCount > 0
         ? (item.missingRequirementCount && item.missingRequirementCount > 0 ? `needs ${item.missingRequirementCount}/${item.requirementCount}` : `ready ${item.requirementCount}/${item.requirementCount}`)
         : '',
-      item.reviewState,
+      formatAgentRecordReviewState(item.reviewState),
+      item.source ? `origin ${item.source}` : '',
       item.startCount !== undefined ? `starts ${item.startCount}` : '',
     ].filter(Boolean).join(' / ');
-    const tags = item.tags.length > 0 ? ` tags=${item.tags.join(',')}` : '';
-    const triggers = item.triggers.length > 0 ? ` triggers=${item.triggers.join(',')}` : '';
+    const tags = item.tags.length > 0 ? ` tags ${item.tags.join(',')}` : '';
+    const triggers = item.triggers.length > 0 ? ` triggers ${item.triggers.join(',')}` : '';
     const marker = selected ? `${GLYPHS.navigation.selected} ` : '';
     lines.push({
       text: `${marker}${item.id}: ${item.name} (${status})`,
@@ -175,6 +192,86 @@ function localLibraryLines(
   return lines;
 }
 
+type LocalRoutineItem = AgentWorkspaceRuntimeSnapshot['localRoutines'][number];
+
+function readyRoutineItems(snapshot: AgentWorkspaceRuntimeSnapshot): readonly LocalRoutineItem[] {
+  return snapshot.localRoutines.filter((routine) =>
+    routine.enabled === true
+    && routine.reviewState === 'reviewed'
+    && (routine.missingRequirementCount ?? 0) === 0
+  );
+}
+
+function routinesNeedingSetup(snapshot: AgentWorkspaceRuntimeSnapshot): readonly LocalRoutineItem[] {
+  return snapshot.localRoutines.filter((routine) => (routine.missingRequirementCount ?? 0) > 0);
+}
+
+function routinesNeedingReview(snapshot: AgentWorkspaceRuntimeSnapshot): readonly LocalRoutineItem[] {
+  return snapshot.localRoutines.filter((routine) => routine.reviewState !== 'reviewed');
+}
+
+function routineNextActionLine(snapshot: AgentWorkspaceRuntimeSnapshot): ContextLine {
+  const discovered = snapshot.discoveredBehavior.routines.count;
+  const ready = readyRoutineItems(snapshot);
+  const needsSetup = routinesNeedingSetup(snapshot);
+  const needsReview = routinesNeedingReview(snapshot);
+
+  if (snapshot.localRoutineCount === 0 && discovered > 0) {
+    return { text: 'Next routine action: Discover routine files, preview one, then import it from this workspace.', fg: PALETTE.warn, bold: true };
+  }
+  if (snapshot.localRoutineCount === 0) {
+    return { text: 'Next routine action: Create routine for a repeatable main-conversation workflow.', fg: PALETTE.warn, bold: true };
+  }
+  if (needsSetup.length > 0) {
+    return { text: `Next routine action: Needs setup for ${needsSetup[0]?.id ?? 'a routine'} before it can be trusted for schedule promotion.`, fg: PALETTE.warn, bold: true };
+  }
+  if (needsReview.length > 0) {
+    return { text: `Next routine action: Review selected or inspect ${needsReview[0]?.id ?? 'a routine'} before schedule promotion.`, fg: PALETTE.warn, bold: true };
+  }
+  if (ready.length > 0 && snapshot.routineScheduleReceiptCount === 0) {
+    return { text: `Next routine action: Promote ${ready[0]?.id ?? 'a reviewed routine'} to a connected schedule when you have a real cadence.`, fg: PALETTE.good, bold: true };
+  }
+  return { text: 'Next routine action: Start selected in the main conversation, inspect receipts, or reconcile connected schedules.', fg: PALETTE.info, bold: true };
+}
+
+function routineScheduleReceiptLines(snapshot: AgentWorkspaceRuntimeSnapshot): ContextLine[] {
+  const latest = snapshot.latestRoutineScheduleReceipt;
+  const lines: ContextLine[] = [
+    {
+      text: `Promotion receipts: ${snapshot.routineScheduleReceiptCount}; created: ${snapshot.successfulRoutineScheduleReceiptCount}; failed: ${snapshot.failedRoutineScheduleReceiptCount}`,
+      fg: snapshot.failedRoutineScheduleReceiptCount > 0 ? PALETTE.warn : PALETTE.info,
+    },
+  ];
+  if (latest) {
+    lines.push({
+      text: `Latest receipt: ${latest.id} ${latest.status} routine=${latest.routineId} schedule="${latest.scheduleName}" ${latest.scheduleKind} ${latest.scheduleValue}`,
+      fg: latest.status === 'failed' ? PALETTE.warn : PALETTE.good,
+    });
+  } else {
+    lines.push({ text: 'No schedule promotion receipts yet. Confirm a routine promotion from Automation when ready.', fg: PALETTE.muted });
+  }
+  return lines;
+}
+
+function automationNextActionLine(snapshot: AgentWorkspaceRuntimeSnapshot): ContextLine {
+  const ready = readyRoutineItems(snapshot);
+  const needsSetup = routinesNeedingSetup(snapshot);
+  const needsReview = routinesNeedingReview(snapshot);
+  if (snapshot.routineScheduleReceiptCount > 0) {
+    return { text: 'Next automation action: Reconcile schedules to compare local receipts with the connected host.', fg: PALETTE.info, bold: true };
+  }
+  if (ready.length > 0) {
+    return { text: `Next automation action: Promote ${ready[0]?.id ?? 'a reviewed routine'} or create a one-off reminder.`, fg: PALETTE.good, bold: true };
+  }
+  if (needsSetup.length > 0) {
+    return { text: `Next automation action: Resolve routine setup gaps in ${needsSetup[0]?.id ?? 'Routines'} before promotion, or create a reminder.`, fg: PALETTE.warn, bold: true };
+  }
+  if (needsReview.length > 0) {
+    return { text: `Next automation action: Review ${needsReview[0]?.id ?? 'a routine'} in Routines before schedule promotion, or create a reminder.`, fg: PALETTE.warn, bold: true };
+  }
+  return { text: 'Next automation action: Create a reminder, or create/import a routine before recurring workflow promotion.', fg: PALETTE.warn, bold: true };
+}
+
 function profileLines(snapshot: AgentWorkspaceRuntimeSnapshot): ContextLine[] {
   const lines: ContextLine[] = [
     { text: 'Agent Profiles', fg: PALETTE.title, bold: true },
@@ -185,7 +282,7 @@ function profileLines(snapshot: AgentWorkspaceRuntimeSnapshot): ContextLine[] {
   }
   for (const profile of snapshot.runtimeProfiles.slice(0, 6)) {
     const starter = profile.starterTemplateId ? ` starter=${profile.starterTemplateId}` : ' starter=none';
-    const created = profile.createdAt ? ` created=${profile.createdAt.slice(0, 10)}` : '';
+    const created = profile.createdAt ? ` created ${profile.createdAt.slice(0, 10)}` : '';
     const states = [
       profile.id === snapshot.activeRuntimeProfile ? 'active' : '',
       profile.id === snapshot.selectedRuntimeProfile ? 'default' : '',
@@ -209,8 +306,9 @@ function starterTemplateLines(snapshot: AgentWorkspaceRuntimeSnapshot): ContextL
     { text: 'Starter Templates', fg: PALETTE.title, bold: true },
   ];
   for (const template of snapshot.runtimeStarterTemplates.slice(0, 6)) {
+    const origin = template.source === 'local' ? 'Local' : formatAgentRecordSource(template.source);
     lines.push({
-      text: `${template.id}: ${template.name} [${template.source}]`,
+      text: `${template.id}: ${template.name} [${origin}]`,
       fg: template.source === 'local' ? PALETTE.good : PALETTE.info,
       bold: template.id === 'research',
     });
@@ -232,7 +330,12 @@ function snapshotLines(workspace: AgentWorkspace, category: AgentWorkspaceCatego
     base.push(
       { text: `Chat route: ${snapshot.provider} / ${snapshot.modelDisplayName}`, fg: PALETTE.info },
       { text: `Session: ${snapshot.sessionId}`, fg: PALETTE.muted },
-      { text: `Policy: ${snapshot.executionPolicy}; WRFC ${snapshot.wrfcPolicy}`, fg: PALETTE.good },
+      { text: `Policy: ${snapshot.executionPolicy}; delegated review ${snapshot.delegatedReviewPolicy}`, fg: PALETTE.good },
+      { text: `Knowledge: ${snapshot.knowledgeRoute}; ${snapshot.knowledgeIsolation}; no fallback`, fg: PALETTE.good },
+      { text: `Local: ${snapshot.localMemoryCount} memory, ${snapshot.localNoteCount} notes, ${snapshot.localPersonaCount} personas, ${snapshot.localSkillCount} skills, ${snapshot.localRoutineCount} routines.`, fg: PALETTE.info },
+      { text: `Channels: ${snapshot.channels.filter((channel) => channel.ready).length}/${snapshot.channels.length} ready; MCP ${snapshot.mcpConnectedServerCount}/${snapshot.mcpServerCount} connected; voice/media ${snapshot.voiceProviderCount}/${snapshot.mediaProviderCount}.`, fg: PALETTE.info },
+      { text: '' },
+      ...homeNextActionLines(snapshot),
     );
   } else if (category.id === 'setup') {
     base.push(
@@ -244,6 +347,17 @@ function snapshotLines(workspace: AgentWorkspace, category: AgentWorkspaceCatego
       { text: `Workspace: ${snapshot.workingDirectory}`, fg: PALETTE.muted },
       { text: `Home: ${snapshot.homeDirectory}`, fg: PALETTE.muted },
     );
+  } else if (category.id === 'artifacts') {
+    const mediaReady = snapshot.voiceMediaReadiness.readyMediaProviderCount;
+    base.push(
+      { text: `Chat route: ${snapshot.provider} / ${snapshot.modelDisplayName}`, fg: PALETTE.info },
+      { text: `Agent Knowledge route: ${snapshot.knowledgeRoute}`, fg: PALETTE.info },
+      { text: `Media providers: ${mediaReady}/${snapshot.mediaProviderCount} ready; generation-capable ${snapshot.mediaGenerationProviderCount}.`, fg: mediaReady > 0 ? PALETTE.good : PALETTE.warn },
+      { text: 'Use this area for concrete files and generated output: attach images, export transcripts, ingest reviewed sources, inspect source records, and generate media.', fg: PALETTE.good },
+      { text: 'Agent Knowledge ingest writes only to the isolated Agent segment. Default knowledge and non-Agent routes are not fallback storage.', fg: PALETTE.warn },
+      { text: 'Generated media is stored as artifacts and referenced by id; the TUI should not print inline base64.', fg: PALETTE.muted },
+      { text: `Workspace path: ${snapshot.workingDirectory}`, fg: PALETTE.muted },
+    );
   } else if (category.id === 'channels') {
     const enabledCount = snapshot.channels.filter((channel) => channel.enabled).length;
     const readyCount = snapshot.channels.filter((channel) => channel.ready).length;
@@ -251,16 +365,20 @@ function snapshotLines(workspace: AgentWorkspace, category: AgentWorkspaceCatego
     const readyChannels = snapshot.channels.filter((channel) => channel.ready).map((channel) => channel.label);
     const needsTarget = snapshot.channels.filter((channel) => channel.setupState === 'needs-target');
     const needsConfig = snapshot.channels.filter((channel) => channel.setupState === 'needs-config');
+    const nextAttentionChannel = needsConfig[0] ?? needsTarget[0] ?? snapshot.channels.find((channel) => !channel.enabled);
     const disabledChannels = snapshot.channels.filter((channel) => !channel.enabled).map((channel) => channel.label);
     const disabledPreview = disabledChannels.slice(0, 6).join(', ');
     const disabledSuffix = disabledChannels.length > 6 ? `, +${disabledChannels.length - 6} more` : '';
     const orderedChannels = [
       ...snapshot.channels.filter((channel) => channel.enabled),
       ...snapshot.channels.filter((channel) => !channel.enabled),
-    ].slice(0, 6);
+    ].slice(0, 3);
     base.push(
       { text: `GoodVibes API: ${snapshot.runtimeBaseUrl}`, fg: PALETTE.info },
+      companionAccessLine(snapshot),
       { text: `Readiness: ${readyCount}/${snapshot.channels.length} ready; ${enabledCount} enabled; ${configuredDefaults} default target(s) configured.`, fg: PALETTE.info },
+      { text: 'Setup path: pair companion -> inspect readiness -> review accounts/policies/status -> fix one channel -> add explicit notification target if needed.', fg: PALETTE.good },
+      { text: `Next channel action: ${nextAttentionChannel ? `${nextAttentionChannel.label} - ${nextAttentionChannel.nextStep}` : 'All enabled channels are ready; keep delivery explicit and review policies before sending.'}`, fg: nextAttentionChannel ? PALETTE.warn : PALETTE.good },
       { text: `Ready channels: ${readyChannels.join(', ') || 'none'}.`, fg: readyChannels.length > 0 ? PALETTE.good : PALETTE.warn },
       { text: `Needs default target: ${needsTarget.map((channel) => `${channel.label} -> ${channel.defaultTargetKeys.join('|')}`).join(', ') || 'none'}.`, fg: needsTarget.length > 0 ? PALETTE.warn : PALETTE.muted },
       { text: `Needs config: ${needsConfig.map((channel) => `${channel.label} -> ${channel.missingRequiredKeys.join('|')}`).join(', ') || 'none'}.`, fg: needsConfig.length > 0 ? PALETTE.warn : PALETTE.muted },
@@ -274,16 +392,25 @@ function snapshotLines(workspace: AgentWorkspace, category: AgentWorkspaceCatego
         fg: channel.ready ? PALETTE.good : channel.enabled ? PALETTE.warn : PALETTE.dim,
       });
     }
-    base.push({ text: 'Only config key names and readiness state are rendered here.', fg: PALETTE.muted });
-    base.push({ text: 'Pairing: use /pair or /qrcode; inspect notification targets with /notify list and health with /health review.', fg: PALETTE.info });
   } else if (category.id === 'knowledge') {
     base.push(
       { text: `Route family: ${snapshot.knowledgeRoute}/{status,ask,search}`, fg: PALETTE.info },
-      { text: `Isolation: ${snapshot.knowledgeIsolation}; no default Knowledge/Wiki or non-Agent fallback`, fg: PALETTE.good },
+      { text: `Isolation: ${snapshot.knowledgeIsolation}; no default knowledge or non-Agent fallback`, fg: PALETTE.good },
       { text: 'Ingest: URL, URL-list, and bookmark imports require explicit --yes and write only to Agent Knowledge.', fg: PALETTE.info },
       { text: 'Review: queue, issues, candidates, reports, reindex, and consolidation stay inside the Agent segment.', fg: PALETTE.muted },
       { text: 'Agent-owned content appears here only after explicit Agent knowledge ingestion.', fg: PALETTE.muted },
     );
+  } else if (category.id === 'research') {
+    base.push(
+      { text: `Chat route: ${snapshot.provider} / ${snapshot.modelDisplayName}`, fg: PALETTE.info },
+      { text: `Agent Knowledge route: ${snapshot.knowledgeRoute}`, fg: PALETTE.info },
+      { text: `Browser tools: ${snapshot.voiceMediaReadiness.browserToolState}; public base URL ${snapshot.browserToolPublicBaseUrl}.`, fg: snapshot.browserToolExposureEnabled ? PALETTE.warn : PALETTE.muted },
+      { text: snapshot.voiceMediaReadiness.browserToolNextStep, fg: PALETTE.muted },
+      { text: 'Research requests are submitted to the main conversation. Agent may use connected read-only web tools when the user asks.', fg: PALETTE.good },
+      { text: 'URL references and web research do not ingest into Agent Knowledge. Ingestion is a separate confirmed Agent Knowledge action.', fg: PALETTE.warn },
+      { text: 'Use Agent Knowledge ask/search first for known source-backed context; use web research for current or external sources.', fg: PALETTE.info },
+      { text: 'External sends, browser-side effects, package installs, and connected-host mutations are outside this read-only research lane.', fg: PALETTE.warn },
+    );
   } else if (category.id === 'tools') {
     base.push(
       { text: `MCP servers: ${snapshot.mcpConnectedServerCount}/${snapshot.mcpServerCount} connected; quarantined ${snapshot.mcpQuarantinedServerCount}; allow-all ${snapshot.mcpAllowAllServerCount}.`, fg: snapshot.mcpQuarantinedServerCount > 0 || snapshot.mcpAllowAllServerCount > 0 ? PALETTE.warn : PALETTE.info },
@@ -357,18 +484,28 @@ function snapshotLines(workspace: AgentWorkspace, category: AgentWorkspaceCatego
     base.push(
       { text: `Session memories: ${snapshot.sessionMemoryCount}`, fg: PALETTE.info },
       { text: `Agent memory: ${snapshot.localMemoryCount}; prompt-active: ${snapshot.localMemoryPromptActiveCount}; review queue: ${snapshot.localMemoryReviewQueueCount}`, fg: PALETTE.info },
+      { text: `Scratchpad notes: ${snapshot.localNoteCount}; review queue: ${snapshot.localNoteReviewQueueCount}`, fg: PALETTE.info },
       { text: `Local routines: ${snapshot.localRoutineCount}; enabled: ${snapshot.enabledRoutineCount}`, fg: PALETTE.info },
       { text: `Local skills: ${snapshot.localSkillCount}; enabled: ${snapshot.enabledSkillCount}; bundles: ${snapshot.localSkillBundleCount}; active skills: ${snapshot.activeSkillCount}`, fg: PALETTE.info },
       { text: `Local personas: ${snapshot.localPersonaCount}; active: ${snapshot.activePersonaName}`, fg: PALETTE.info },
-      { text: 'Durable memory, routines, skills, and personas remain Agent-local until shared registry contracts exist.', fg: PALETTE.good },
+      { text: 'Durable memory, scratchpad notes, routines, skills, and personas remain Agent-local until shared registry contracts exist.', fg: PALETTE.good },
       { text: 'Secrets are rejected/redacted; store secret references instead of secret values.', fg: PALETTE.warn },
       { text: '' },
       ...localLibraryLines('Agent Memory', snapshot.localMemories, 'No Agent memory yet. Create one here with Create memory.', workspace.selectedLocalLibraryItem('memory')?.id ?? null),
     );
+  } else if (category.id === 'notes') {
+    base.push(
+      { text: `Scratchpad notes: ${snapshot.localNoteCount}; review queue: ${snapshot.localNoteReviewQueueCount}`, fg: PALETTE.info },
+      { text: 'Notes are Agent-local working context for source triage, temporary decisions, and operator handoff.', fg: PALETTE.good },
+      { text: 'Notes do not become memory and are not ingested into Agent Knowledge unless the user takes a separate explicit action.', fg: PALETTE.warn },
+      { text: 'Use reviewed notes to prefill durable memory, skills, routines, or personas, or to decide that a reviewed source deserves Agent Knowledge ingest.', fg: PALETTE.muted },
+      { text: '' },
+      ...localLibraryLines('Scratchpad Notes', snapshot.localNotes, 'No local notes yet. Create one here with Create note.', workspace.selectedLocalLibraryItem('note')?.id ?? null),
+    );
   } else if (category.id === 'personas') {
     base.push(
       { text: `Personas: ${snapshot.localPersonaCount}; active: ${snapshot.activePersonaName}`, fg: PALETTE.info },
-      { text: 'Personas are local behavior profiles for the serial main-conversation assistant, not spawned agents.', fg: PALETTE.good },
+      { text: 'Personas are local behavior profiles for the serial main-conversation assistant, not separate Agent jobs.', fg: PALETTE.good },
       { text: 'Use them for tone, role, domain constraints, tool posture, and repeatable operating preferences.', fg: PALETTE.muted },
       { text: '' },
       ...localLibraryLines('Persona Library', snapshot.localPersonas, 'No local personas yet. Create one here with Create persona.', workspace.selectedLocalLibraryItem('persona')?.id ?? null),
@@ -384,10 +521,16 @@ function snapshotLines(workspace: AgentWorkspace, category: AgentWorkspaceCatego
       ...localLibraryLines('Skill Bundles', snapshot.localSkillBundles, 'No local skill bundles yet. Use Skill bundles and Create bundle after creating skills.', null),
     );
   } else if (category.id === 'routines') {
+    const ready = readyRoutineItems(snapshot);
+    const needsSetup = routinesNeedingSetup(snapshot);
+    const needsReview = routinesNeedingReview(snapshot);
     base.push(
       { text: `Routines: ${snapshot.localRoutineCount}; enabled: ${snapshot.enabledRoutineCount}`, fg: PALETTE.info },
+      { text: `Schedule-ready routines: ${ready.length}; setup gaps: ${needsSetup.length}; review needed: ${needsReview.length}`, fg: needsSetup.length > 0 || needsReview.length > 0 ? PALETTE.warn : PALETTE.good },
       { text: 'Routines are repeatable main-conversation workflows. Starting one does not create hidden jobs.', fg: PALETTE.good },
       { text: 'Scheduling a reviewed routine is explicit and requires a confirmed schedule command.', fg: PALETTE.warn },
+      routineNextActionLine(snapshot),
+      ...routineScheduleReceiptLines(snapshot),
       { text: '' },
       ...localLibraryLines('Routine Library', snapshot.localRoutines, 'No local routines yet. Create one here with Create routine.', workspace.selectedLocalLibraryItem('routine')?.id ?? null),
     );
@@ -395,18 +538,26 @@ function snapshotLines(workspace: AgentWorkspace, category: AgentWorkspaceCatego
     base.push(
       { text: 'Work plan and approvals are read or explicitly confirmed through public operator routes.', fg: PALETTE.info },
       { text: 'This workspace does not approve, deny, cancel, or mutate requests by selection alone.', fg: PALETTE.good },
+      { text: 'Approve, deny, and cancel forms require an approval id and typed confirmation.', fg: PALETTE.warn },
     );
   } else if (category.id === 'automation') {
+    const ready = readyRoutineItems(snapshot);
     base.push(
-      { text: 'Automation and schedules default to read-only observability.', fg: PALETTE.info },
+      { text: 'Automation and schedules default to read-only observability; side effects require confirmed forms.', fg: PALETTE.info },
       { text: 'Confirmed reminders and routine promotion use connected schedules only.', fg: PALETTE.info },
-      { text: 'Local scheduler mutation/run controls remain blocked.', fg: PALETTE.warn },
+      { text: 'Local scheduler mutation controls remain blocked; job/run/schedule controls go through the connected host.', fg: PALETTE.warn },
+      { text: 'Reminder path: Create reminder -> choose at/every/cron -> optional delivery target -> confirm yes.', fg: PALETTE.good },
+      { text: 'Operator path: choose job/run/schedule action -> enter id -> type yes -> dispatch once.', fg: PALETTE.good },
+      { text: 'Routine path: Routines -> resolve setup -> review selected -> Promote routine -> Reconcile schedules.', fg: PALETTE.good },
+      { text: `Schedule-ready routines: ${ready.length}; local promotion receipts: ${snapshot.routineScheduleReceiptCount}`, fg: ready.length > 0 ? PALETTE.good : PALETTE.warn },
+      automationNextActionLine(snapshot),
+      ...routineScheduleReceiptLines(snapshot),
     );
   } else if (category.id === 'delegate') {
     base.push(
       { text: 'Build/fix/review work is handed to GoodVibes TUI/shared-session contracts.', fg: PALETTE.info },
-      { text: `WRFC policy: ${snapshot.wrfcPolicy}`, fg: PALETTE.warn },
-      { text: 'Agent does not spawn local Engineer/Reviewer/Tester roots.', fg: PALETTE.good },
+      { text: `Delegated review policy: ${snapshot.delegatedReviewPolicy}`, fg: PALETTE.warn },
+      { text: 'Agent does not create coding-role Agent jobs.', fg: PALETTE.good },
     );
   }
   if (snapshot.warnings.length > 0) {
@@ -440,6 +591,17 @@ function buildContextRows(workspace: AgentWorkspace, category: AgentWorkspaceCat
     { text: '' },
     { text: category.detail, fg: PALETTE.text },
     { text: '' },
+    ...(workspace.actionSearchActive ? [
+      { text: 'Action Search', fg: PALETTE.title, bold: true },
+      {
+        text: workspace.actionSearchQuery.length > 0
+          ? `Query: ${workspace.actionSearchQuery} (${workspace.actionSearchResults.length} result${workspace.actionSearchResults.length === 1 ? '' : 's'})`
+          : 'Type to search every Agent workspace action.',
+        fg: workspace.actionSearchQuery.length > 0 && workspace.actionSearchResults.length === 0 ? PALETTE.warn : PALETTE.info,
+      },
+      { text: 'Enter opens the selected result. Esc clears search and returns to normal workspace navigation.', fg: PALETTE.muted },
+      { text: '' },
+    ] satisfies ContextLine[] : []),
     ...(workspace.localEditor ? editorContextLines(workspace.localEditor) : []),
     ...(workspace.localEditor ? [{ text: '' }] : []),
     ...snapshotLines(workspace, category, workspace.runtimeSnapshot),
@@ -532,23 +694,32 @@ function buildActionRows(workspace: AgentWorkspace, width: number, height: numbe
   const labelWidth = Math.min(28, Math.max(16, Math.floor(width * 0.30)));
   const safetyWidth = 10;
   const commandWidth = Math.max(10, width - labelWidth - safetyWidth - 9);
+  if (workspace.actionSearchActive) {
+    rows.push({
+      text: `  Search: ${workspace.actionSearchQuery || '(type to filter actions)'}`,
+      fg: workspace.actionSearchQuery.length > 0 && workspace.actions.length === 0 ? PALETTE.warn : PALETTE.info,
+      bold: true,
+    });
+  }
   rows.push({
-    text: `  ${padDisplay('Action', labelWidth)}  ${padDisplay('Safety', safetyWidth)}  ${padDisplay('Command', commandWidth)}`,
+    text: `  ${padDisplay(workspace.actionSearchActive ? 'Result' : 'Action', labelWidth)}  ${padDisplay('Safety', safetyWidth)}  ${padDisplay('Command', commandWidth)}`,
     fg: PALETTE.muted,
     bold: true,
   });
 
   const actions = workspace.actions;
-  const visible = Math.max(1, height - 2);
+  const visible = Math.max(1, height - (workspace.actionSearchActive ? 3 : 2));
   const window = stableWindow(actions.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 selected = index === workspace.selectedActionIndex;
+    const searchResult = workspace.actionSearchActive ? workspace.actionSearchResults[index] : null;
+    const label = searchResult ? `${searchResult.category.label} / ${action.label}` : action.label;
     const marker = selected ? GLYPHS.navigation.selected : ' ';
     rows.push({
-      text: `${marker} ${padDisplay(action.label, labelWidth)}  ${padDisplay(action.safety, safetyWidth)}  ${padDisplay(actionCommand(action), commandWidth)}`,
+      text: `${marker} ${padDisplay(label, labelWidth)}  ${padDisplay(action.safety, safetyWidth)}  ${padDisplay(actionCommand(action), commandWidth)}`,
       selected: selected && workspace.focusPane === 'actions',
       fg: safetyColor(action),
       bold: selected,
@@ -577,12 +748,15 @@ function footerText(workspace: AgentWorkspace): string {
   if (workspace.localEditor) {
     return `Agent workspace · editing ${workspace.localEditor.kind} · Enter next/save · Ctrl-J newline · Esc cancel`;
   }
+  if (workspace.actionSearchActive) {
+    return 'Agent workspace · action search · type filter · Up/Down results · Enter open · Esc clear';
+  }
   const focus = workspace.focusPane === 'categories' ? 'categories' : 'actions';
-  return `Agent workspace · focus ${focus} · Up/Down navigate · Left/Right pane · Enter open/action · R refresh · Esc close`;
+  return `Agent workspace · ${focus} · / search · Up/Down · Left/Right · Ctrl+[/] area · Enter open/action · R refresh · Esc close`;
 }
 
 export function renderAgentWorkspace(workspace: AgentWorkspace, width: number, height: number): Line[] {
-  const category = workspace.selectedCategory;
+  const category = workspace.selectedActionCategory;
   const action = workspace.selectedAction;
   const setupCategory = category.id === 'setup';
   const layoutOptions = {
@@ -598,9 +772,11 @@ export function renderAgentWorkspace(workspace: AgentWorkspace, width: number, h
     width,
     height,
     title: 'GoodVibes Agent / Operator Workspace',
-    stateLabel: workspace.localEditor ? 'Editor' : workspace.focusPane === 'categories' ? 'Categories' : 'Actions',
+    stateLabel: workspace.localEditor ? 'Editor' : workspace.actionSearchActive ? 'Search' : workspace.focusPane === 'categories' ? 'Categories' : 'Actions',
     leftHeader: 'Operator Areas',
-    mainHeader: `${category.label} · ${category.actions.length} action(s)`,
+    mainHeader: workspace.actionSearchActive
+      ? `Search actions · ${workspace.actions.length} result(s)`
+      : `${category.label} · ${category.actions.length} action(s)`,
     leftRows: buildLeftRows(workspace, metrics.bodyRows),
     contextRows: buildContextRows(workspace, category, action, metrics.contextWidth),
     controlRows: buildActionRows(workspace, metrics.contextWidth, metrics.controlRows),

package/src/renderer/autocomplete-overlay.ts

@@ -15,6 +15,9 @@ const TITLE_FG = DEFAULT_OVERLAY_PALETTE.titleFg;
 const BODY_FG = DEFAULT_OVERLAY_PALETTE.bodyFg;
 const MUTED_FG = DEFAULT_OVERLAY_PALETTE.mutedFg;
 const SELECTED_BG = DEFAULT_OVERLAY_PALETTE.selectedBg;
+const AUTOCOMPLETE_TITLE = ' Commands';
+const AUTOCOMPLETE_EMPTY_QUERY = '/';
+const AUTOCOMPLETE_HINTS = '[Tab] Complete  [Up/Down] Navigate  [Enter] Execute  [Esc] Cancel';
 
 interface CellStyle {
   fg: string;
@@ -27,6 +30,23 @@ function putText(line: Line, startX: number, maxWidth: number, text: string, sty
   putOverlayText(line, startX, maxWidth, text, style);
 }
 
+function autocompleteQueryText(query: string): string {
+  return query ? `/${query}` : AUTOCOMPLETE_EMPTY_QUERY;
+}
+
+function autocompleteScrollText(selected: string | number, total: string | number): string {
+  return `${selected}/${total}`;
+}
+
+export function renderAutocompletePackageText(): string {
+  return [
+    AUTOCOMPLETE_TITLE.trim(),
+    autocompleteQueryText('<query>'),
+    autocompleteScrollText('<selected>', '<total>'),
+    AUTOCOMPLETE_HINTS,
+  ].join('\n');
+}
+
 /**
  * Render the slash command autocomplete dropdown as Line[] for overlay in the viewport.
  */
@@ -51,8 +71,8 @@ export function renderAutocompleteOverlay(
   lines.push(createOverlayBorderLine(width, layout, '┌', '─', '┐', BORDER_FG));
 
   const titleLine = createOverlayContentLine(width, layout);
-  const titleText = ' Commands';
-  const queryText = state.query ? `/${state.query}` : '/';
+  const titleText = AUTOCOMPLETE_TITLE;
+  const queryText = autocompleteQueryText(state.query);
   const queryWidth = Math.min(Math.floor(layout.innerWidth / 2), Math.max(8, layout.innerWidth - getDisplayWidth(titleText) - 2));
   const leftText = fitDisplay(titleText, Math.max(0, layout.innerWidth - queryWidth));
   const rightText = truncateDisplay(queryText, queryWidth);
@@ -126,8 +146,8 @@ export function renderAutocompleteOverlay(
   }
 
   if (total > maxVisible) {
-      const scrollLine = createOverlayContentLine(width, layout);
-    const scrollText = `${state.selectedIndex + 1}/${total}`;
+    const scrollLine = createOverlayContentLine(width, layout);
+    const scrollText = autocompleteScrollText(state.selectedIndex + 1, total);
     putText(
       scrollLine,
       layout.margin + 2 + Math.max(0, layout.innerWidth - getDisplayWidth(scrollText)),
@@ -139,12 +159,11 @@ export function renderAutocompleteOverlay(
   }
 
   const footerLine = createOverlayContentLine(width, layout);
-  const hints = '[Tab] Complete  [Up/Down] Navigate  [Enter] Execute  [Esc] Cancel';
   putText(
     footerLine,
     layout.margin + 2,
     layout.innerWidth,
-    fitDisplay(truncateDisplay(hints, layout.innerWidth), layout.innerWidth),
+    fitDisplay(truncateDisplay(AUTOCOMPLETE_HINTS, layout.innerWidth), layout.innerWidth),
     { fg: MUTED_FG, dim: true },
   );
   lines.push(footerLine);

package/src/renderer/bookmark-modal.ts

@@ -13,6 +13,21 @@ import { BookmarkModal } from '../input/bookmark-modal.ts';
 import type { BookmarkEntry } from '@pellux/goodvibes-sdk/platform/bookmarks';
 import { getOverlayContentBudget, getStableOverlayContentRows } from './overlay-viewport.ts';
 
+const BOOKMARK_MODAL_TITLE = 'Bookmarks';
+const BOOKMARK_MODAL_EMPTY_MESSAGE = 'No bookmarks - use Ctrl+B to bookmark a block';
+const BOOKMARK_MODAL_COLUMNS = '  Key                            Label                           Time';
+const BOOKMARK_MODAL_HINTS = ['Up/Down Navigate', 'Enter Jump', 'o Open file', 'd Remove', 'Esc Close'];
+
+export function renderBookmarkModalPackageText(): string {
+  return [
+    BOOKMARK_MODAL_TITLE,
+    BOOKMARK_MODAL_EMPTY_MESSAGE,
+    BOOKMARK_MODAL_COLUMNS.trim(),
+    '[<start>-<end> of <count>]',
+    ...BOOKMARK_MODAL_HINTS,
+  ].join('\n');
+}
+
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
@@ -60,7 +75,7 @@ export function renderBookmarkModal(
   const relSelected = Math.max(0, modal.selectedIndex - modal.scrollOffset);
 
   const items = visible.length === 0
-    ? [{ label: 'No bookmarks - use Ctrl+B to bookmark a block', selected: false }]
+    ? [{ label: BOOKMARK_MODAL_EMPTY_MESSAGE, selected: false }]
     : visible.map((entry, i) => ({
         label: entryLabel(entry),
         selected: i === relSelected,
@@ -68,7 +83,7 @@ export function renderBookmarkModal(
   const sections: import('./modal-factory.ts').ModalSection[] = [
     {
       type: 'text',
-      content: '  Key                            Label                           Time',
+      content: BOOKMARK_MODAL_COLUMNS,
       style: { dim: true },
     },
     { type: 'separator' },
@@ -90,11 +105,11 @@ export function renderBookmarkModal(
 
   return ModalFactory.createModal(
     {
-      title: `Bookmarks  ${totalStr}`,
+      title: `${BOOKMARK_MODAL_TITLE}  ${totalStr}`,
       width: 80,
       targetContentRows,
       sections,
-      hints: ['Up/Down Navigate', 'Enter Jump', 'o Open file', 'd Remove', 'Esc Close'],
+      hints: BOOKMARK_MODAL_HINTS,
     },
     width,
   );

package/src/renderer/buffer.ts

@@ -1,5 +1,7 @@
 import { type Line, type Cell, createEmptyLine, createEmptyCell } from '../types/grid.ts';
 
+const CELL_KEYS: readonly (keyof Cell)[] = ['char', 'fg', 'bg', 'bold', 'dim', 'underline', 'italic', 'strikethrough', 'link'];
+
 /**
  * TerminalBuffer - Represents a 2D grid of styled cells.
  * Tracks a per-row dirty bitmap so the diff engine can skip rows that were
@@ -21,8 +23,8 @@ export class TerminalBuffer {
       // already matches the current cell value (idempotent write).
       const current = this.cells[y][x]!;
       let changed = false;
-      for (const k in cell) {
-        if ((cell as unknown as Record<string, unknown>)[k] !== (current as unknown as Record<string, unknown>)[k]) {
+      for (const key of CELL_KEYS) {
+        if (Object.prototype.hasOwnProperty.call(cell, key) && cell[key] !== current[key]) {
           changed = true;
           break;
         }