@pellux/goodvibes-agent 0.1.117 → 1.0.0

package/src/input/commands/agent-workspace-runtime.ts

@@ -1,18 +1,34 @@
-import type { CommandRegistry } from '../command-registry.ts';
+import type { CommandContext, CommandRegistry } from '../command-registry.ts';
+import { AGENT_WORKSPACE_CATEGORY_IDS } from '../agent-workspace-types.ts';
+
+const AGENT_WORKSPACE_ARGS_HINT = `${AGENT_WORKSPACE_CATEGORY_IDS.join('|')}|connected-host`;
 
 export function registerAgentWorkspaceRuntimeCommands(registry: CommandRegistry): void {
+  function openAgentWorkspace(ctx: CommandContext, categoryId: string | undefined): void {
+    if (!ctx.openAgentWorkspace) {
+      ctx.print('Agent operator workspace is not available in this runtime.');
+      return;
+    }
+    ctx.openAgentWorkspace(categoryId);
+  }
+
   registry.register({
     name: 'agent',
     aliases: ['home', 'operator'],
     description: 'Open the GoodVibes Agent operator workspace',
     usage: '[category]',
-    argsHint: 'home|setup|channels|tools|knowledge|voice-media|profiles|memory|personas|skills|routines|work|automation|delegate',
+    argsHint: AGENT_WORKSPACE_ARGS_HINT,
     handler(args, ctx) {
-      if (!ctx.openAgentWorkspace) {
-        ctx.print('Agent operator workspace is not available in this runtime.');
-        return;
-      }
-      ctx.openAgentWorkspace(args[0]);
+      openAgentWorkspace(ctx, args[0]);
+    },
+  });
+  registry.register({
+    name: 'notes',
+    aliases: ['scratchpad'],
+    description: 'Open Agent-local scratchpad notes in the operator workspace',
+    usage: '',
+    handler(_args, ctx) {
+      openAgentWorkspace(ctx, 'notes');
     },
   });
 }

package/src/input/commands/brief-runtime.ts

@@ -39,7 +39,7 @@ function countSetupGaps(items: readonly { readonly missingRequirementCount?: num
 }
 
 function formatWorkPlanLine(total: number, counts: StatusCounts): string {
-  if (total === 0) return '  work plan: empty';
+  if (total === 0) return '  work plan empty';
   const active = counts.pending + counts.in_progress + counts.blocked;
   return [
     `  work plan: ${plural(total, 'item')}`,
@@ -52,8 +52,8 @@ function formatWorkPlanLine(total: number, counts: StatusCounts): string {
 }
 
 function formatWarnings(warnings: readonly string[]): readonly string[] {
-  if (warnings.length === 0) return ['  warnings: none'];
-  return ['  warnings:', ...warnings.slice(0, 4).map((warning) => `    - ${warning}`)];
+  if (warnings.length === 0) return ['  warnings none'];
+  return ['  warnings', ...warnings.slice(0, 4).map((warning) => `    - ${warning}`)];
 }
 
 export function formatAgentOperatorBriefing(ctx: CommandContext): string {
@@ -76,63 +76,64 @@ export function formatAgentOperatorBriefing(ctx: CommandContext): string {
 
   const nextActions = [
     snapshot.provider === 'unknown' || snapshot.model === 'unknown'
-      ? 'Choose the assistant model with /model.'
+      ? 'Choose the assistant model from Agent Workspace -> Home -> Choose model.'
       : '',
     snapshot.localMemoryCount === 0
-      ? 'Store durable non-secret facts with /memory add or the Agent workspace memory form.'
+      ? 'Store durable non-secret facts from Agent Workspace -> Memory -> Add memory.'
       : snapshot.localMemoryReviewQueueCount > 0
-        ? `Review ${plural(snapshot.localMemoryReviewQueueCount, 'memory record')} with /memory queue.`
+        ? `Review ${plural(snapshot.localMemoryReviewQueueCount, 'memory record')} from Agent Workspace -> Memory -> Review queue.`
         : '',
     !hasLocalSkillBehavior
-      ? 'Create reusable procedures with /agent-skills create or import reviewed skill files.'
+      ? 'Create reusable procedures from Agent Workspace -> Skills or import reviewed skill files.'
       : '',
     skillSetupGaps > 0
-      ? `Resolve ${plural(skillSetupGaps, 'skill')} with setup gaps from /agent skills.`
+      ? `Resolve ${plural(skillSetupGaps, 'skill')} with setup gaps from Agent Workspace -> Skills.`
       : '',
     skillBundleSetupGaps > 0
-      ? `Resolve ${plural(skillBundleSetupGaps, 'skill bundle')} with setup gaps from /agent skills.`
+      ? `Resolve ${plural(skillBundleSetupGaps, 'skill bundle')} with setup gaps from Agent Workspace -> Skills.`
       : '',
     hasLocalSkillBehavior && skillSetupGaps === 0 && skillBundleSetupGaps === 0 && snapshot.activeSkillCount === 0
-      ? 'Enable reviewed skills or bundles with /agent-skills enabled and /agent-skills bundle enabled.'
+      ? 'Enable reviewed skills or bundles from Agent Workspace -> Skills.'
       : '',
     snapshot.localRoutineCount === 0
-      ? 'Create repeatable workflows with /routines create; promote schedules only with explicit confirmation.'
+      ? 'Create repeatable workflows from Agent Workspace -> Routines; promote schedules only with explicit confirmation.'
       : routineSetupGaps > 0
-        ? `Resolve ${plural(routineSetupGaps, 'routine')} with setup gaps from /agent routines.`
+        ? `Resolve ${plural(routineSetupGaps, 'routine')} with setup gaps from Agent Workspace -> Routines.`
         : snapshot.enabledRoutineCount === 0
-        ? 'Enable reviewed routines with /routines enable.'
+        ? 'Enable reviewed routines from Agent Workspace -> Routines.'
         : '',
     channelSetupGaps > 0
-      ? `Review ${plural(channelSetupGaps, 'enabled channel')} needing setup from /agent channels.`
+      ? `Review ${plural(channelSetupGaps, 'enabled channel')} needing setup from Agent Workspace -> Channels.`
       : '',
     voiceSetupNeedsReview
-      ? 'Review voice setup with /agent voice-media before relying on spoken replies.'
+      ? 'Review voice setup from Agent Workspace -> Voice & Media before relying on spoken replies.'
       : '',
     mediaSetupNeedsReview
-      ? 'Review media provider setup with /agent voice-media before relying on image or media workflows.'
+      ? 'Review media provider setup from Agent Workspace -> Voice & Media before relying on image or media workflows.'
       : '',
-    'Use /agent knowledge for Agent Knowledge status, search, and explicit ingest forms.',
-    'Use /delegate only for explicit build, fix, implementation, or review handoff to GoodVibes TUI.',
+    'Use Agent Workspace -> Knowledge for Agent Knowledge status, search, and explicit ingest forms.',
+    'Use Agent Workspace -> Build Delegation only for explicit build, fix, implementation, or review handoff to GoodVibes TUI.',
   ].filter((line): line is string => line.length > 0);
 
   return [
     'Agent Briefing',
     `  chat route: ${snapshot.provider} / ${snapshot.modelDisplayName}`,
-    `  session: ${snapshot.sessionId}`,
-    `  profile: ${snapshot.activeRuntimeProfile}`,
-    `  policy: ${snapshot.executionPolicy}; WRFC ${snapshot.wrfcPolicy}`,
-    `  knowledge: ${snapshot.knowledgeRoute} (${snapshot.knowledgeIsolation}; no fallback)`,
+    `  session ${snapshot.sessionId}`,
+    `  profile ${snapshot.activeRuntimeProfile}`,
+    `  policy ${snapshot.executionPolicy}; delegated review ${snapshot.delegatedReviewPolicy}`,
+    `  knowledge ${snapshot.knowledgeRoute} (${snapshot.knowledgeIsolation}; no fallback)`,
     '',
     'Readiness',
-    `  setup: ${setupReady}/${snapshot.setupChecklist.length} ready; ${setupRecommended} recommended; ${setupBlocked} blocked`,
+    `  setup ${setupReady}/${snapshot.setupChecklist.length} ready; ${setupRecommended} recommended; ${setupBlocked} blocked`,
     `  local memory: ${plural(snapshot.localMemoryCount, 'record')}; prompt-active ${snapshot.localMemoryPromptActiveCount}; review queue ${snapshot.localMemoryReviewQueueCount}`,
+    `  scratchpad notes: ${plural(snapshot.localNoteCount, 'note')}; review queue ${snapshot.localNoteReviewQueueCount}`,
     `  personas: ${plural(snapshot.localPersonaCount, 'persona')}; active ${snapshot.activePersonaName}`,
     `  skills: ${snapshot.enabledSkillCount}/${snapshot.localSkillCount} enabled; bundles ${snapshot.enabledSkillBundleCount}/${snapshot.localSkillBundleCount}; active ${snapshot.activeSkillCount}; setup gaps ${skillSetupGaps} skill, ${skillBundleSetupGaps} bundle`,
     `  routines: ${snapshot.enabledRoutineCount}/${snapshot.localRoutineCount} enabled; setup gaps ${routineSetupGaps}`,
     `  channels: ${readyChannels}/${snapshot.channels.length} ready; ${enabledChannels} enabled; setup gaps ${channelSetupGaps}`,
     `  voice/media: ${snapshot.voiceProviderCount} voice, ${snapshot.mediaProviderCount} media; browser tools ${snapshot.voiceMediaReadiness.browserToolState}`,
     formatWorkPlanLine(workPlan.total, workPlan.counts),
-    `  schedules: ${enabledJobs}/${jobs.length} visible jobs enabled`,
+    `  schedules ${enabledJobs}/${jobs.length} visible jobs enabled`,
     '',
     'Next Actions',
     ...nextActions.map((line) => `  - ${line}`),

package/src/input/commands/channels-runtime.ts

@@ -4,11 +4,29 @@ import type { CommandRegistry } from '../command-registry.ts';
 import type { CommandContext } from '../command-registry.ts';
 import type { AgentWorkspaceChannelStatus } from '../agent-workspace-channels.ts';
 import { buildAgentWorkspaceChannels } from '../agent-workspace-channels.ts';
+import {
+  buildAgentChannelDeliveryPreview,
+  deliverAgentChannelMessage,
+  formatAgentChannelDeliveryPreview,
+  formatAgentChannelDeliveryResult,
+} from '../../agent/channel-delivery.ts';
+import { requireYesFlag, stripYesFlag } from './confirmation.ts';
 
 type ChannelFilter = 'all' | 'ready' | 'attention';
 type JsonRecord = Record<string, unknown>;
 
-interface ChannelDaemonConnection {
+interface ChannelSendArgs {
+  readonly message: string;
+  readonly title?: string;
+  readonly channel?: string;
+  readonly route?: string;
+  readonly webhook?: string;
+  readonly link?: string;
+  readonly yes: boolean;
+  readonly errors: readonly string[];
+}
+
+interface ChannelConnectedHostConnection {
   readonly baseUrl: string;
   readonly token: string | null;
   readonly tokenPath: string;
@@ -23,12 +41,20 @@ interface ChannelRouteSuccess {
 interface ChannelRouteFailure {
   readonly ok: false;
   readonly route: string;
-  readonly kind: 'auth_required' | 'daemon_unavailable' | 'route_unavailable' | 'daemon_error';
+  readonly kind: 'auth_required' | 'connected_host_unavailable' | 'connected_host_route_unavailable' | 'connected_host_error';
+  readonly baseUrl: string;
   readonly message: string;
 }
 
 type ChannelRouteResult = ChannelRouteSuccess | ChannelRouteFailure;
 
+const CHANNEL_FAILURE_LABELS: Record<ChannelRouteFailure['kind'], string> = {
+  auth_required: 'auth required',
+  connected_host_unavailable: 'connected host unavailable',
+  connected_host_route_unavailable: 'connected host route unavailable',
+  connected_host_error: 'connected host error',
+};
+
 function isRecord(value: unknown): value is JsonRecord {
   return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
 }
@@ -48,7 +74,59 @@ function readRecordArray(record: JsonRecord, key: string): readonly JsonRecord[]
   return Array.isArray(value) ? value.filter(isRecord) : [];
 }
 
-function resolveChannelDaemonConnection(context: CommandContext): ChannelDaemonConnection {
+function readFlagValue(args: readonly string[], index: number, flag: string, errors: string[]): string | null {
+  const value = args[index + 1];
+  if (!value || value.startsWith('--')) {
+    errors.push(`${flag} requires a value.`);
+    return null;
+  }
+  return value;
+}
+
+function parseChannelSendArgs(args: readonly string[]): ChannelSendArgs {
+  const parsed = stripYesFlag([...args]);
+  const errors: string[] = [];
+  const messageParts: string[] = [];
+  let title: string | undefined;
+  let channel: string | undefined;
+  let route: string | undefined;
+  let webhook: string | undefined;
+  let link: string | undefined;
+
+  for (let index = 0; index < parsed.rest.length; index += 1) {
+    const arg = parsed.rest[index];
+    if (arg === '--title' || arg === '--message' || arg === '--channel' || arg === '--route' || arg === '--webhook' || arg === '--link') {
+      const value = readFlagValue(parsed.rest, index, arg, errors);
+      index += 1;
+      if (!value) continue;
+      if (arg === '--title') title = value;
+      else if (arg === '--message') messageParts.push(value);
+      else if (arg === '--channel') channel = value;
+      else if (arg === '--route') route = value;
+      else if (arg === '--webhook') webhook = value;
+      else link = value;
+    } else if (arg?.startsWith('--')) {
+      errors.push(`Unknown channel send flag ${arg}`);
+    } else if (arg) {
+      messageParts.push(arg);
+    }
+  }
+
+  const message = messageParts.join(' ').trim();
+  if (!message) errors.push('Channel send message is required.');
+  return {
+    message,
+    ...(title ? { title } : {}),
+    ...(channel ? { channel } : {}),
+    ...(route ? { route } : {}),
+    ...(webhook ? { webhook } : {}),
+    ...(link ? { link } : {}),
+    yes: parsed.yes,
+    errors,
+  };
+}
+
+function resolveChannelConnectedHostConnection(context: CommandContext): ChannelConnectedHostConnection {
   const hostValue = context.platform?.configManager?.get('controlPlane.host');
   const portValue = context.platform?.configManager?.get('controlPlane.port');
   const host = typeof hostValue === 'string' && hostValue.trim().length > 0 ? hostValue.trim() : '127.0.0.1';
@@ -66,13 +144,14 @@ function resolveChannelDaemonConnection(context: CommandContext): ChannelDaemonC
 }
 
 async function fetchChannelRoute(context: CommandContext, route: string): Promise<ChannelRouteResult> {
-  const connection = resolveChannelDaemonConnection(context);
+  const connection = resolveChannelConnectedHostConnection(context);
   if (!connection.token) {
     return {
       ok: false,
       route,
       kind: 'auth_required',
-      message: `No runtime operator token found at ${connection.tokenPath}`,
+      baseUrl: connection.baseUrl,
+      message: `No connected-host operator token found at ${connection.tokenPath}`,
     };
   }
 
@@ -97,8 +176,9 @@ async function fetchChannelRoute(context: CommandContext, route: string): Promis
         kind: response.status === 401 || response.status === 403
           ? 'auth_required'
           : response.status === 404
-            ? 'route_unavailable'
-            : 'daemon_error',
+            ? 'connected_host_route_unavailable'
+            : 'connected_host_error',
+        baseUrl: connection.baseUrl,
         message: `HTTP ${response.status}${detail ? `: ${detail}` : ''}`,
       };
     }
@@ -107,7 +187,8 @@ async function fetchChannelRoute(context: CommandContext, route: string): Promis
     return {
       ok: false,
       route,
-      kind: 'daemon_unavailable',
+      kind: 'connected_host_unavailable',
+      baseUrl: connection.baseUrl,
       message: error instanceof Error ? error.message : String(error),
     };
   }
@@ -116,7 +197,9 @@ async function fetchChannelRoute(context: CommandContext, route: string): Promis
 function formatChannelRouteFailure(title: string, failure: ChannelRouteFailure): string {
   return [
     `${title}: unavailable`,
+    `  status: ${CHANNEL_FAILURE_LABELS[failure.kind]}`,
     `  kind: ${failure.kind}`,
+    `  connected host: ${failure.baseUrl}`,
     `  route: ${failure.route}`,
     `  error: ${failure.message}`,
     '  policy: read-only; no channel send/action route was called',
@@ -207,8 +290,8 @@ function formatChannelAccounts(body: unknown): string {
   const accounts = readRecordArray(root, 'accounts');
   const lines = [
     'Channel Accounts',
-    `  accounts: ${accounts.length}`,
-    '  policy: read-only account posture; secret values are never shown',
+    `  accounts ${accounts.length}`,
+    '  policy read-only account posture; secret values are never shown',
     '',
   ];
   if (accounts.length === 0) return [...lines, '  No channel accounts reported by connected host.'].join('\n');
@@ -218,10 +301,10 @@ function formatChannelAccounts(body: unknown): string {
     const authState = readString(account, 'authState', readString(account, 'state', 'unknown'));
     const configured = readBoolean(account, 'configured') ? 'configured' : 'not-configured';
     const linked = readBoolean(account, 'linked') ? 'linked' : 'not-linked';
-    const secrets = readRecordArray(account, 'secrets')
-      .map((secret) => `${readString(secret, 'field', 'secret')}:${readString(secret, 'source', 'configured')}`)
+    const secretFields = readRecordArray(account, 'secrets')
+      .map((secret) => readString(secret, 'field', 'secret'))
       .join(', ') || 'none';
-    lines.push(`  ${surface}${accountId ? `/${accountId}` : ''}: ${configured}; ${linked}; auth=${authState}; secret refs=${secrets}`);
+    lines.push(`  ${surface}${accountId ? `/${accountId}` : ''}: ${configured}; ${linked}; auth=${authState}; secret refs=${secretFields === 'none' ? 'none' : secretFields.split(', ').map((field) => `${field}:config`).join(',')}`);
   }
   if (accounts.length > 20) lines.push(`  ${accounts.length - 20} more account(s) omitted.`);
   return lines.join('\n');
@@ -232,8 +315,8 @@ function formatChannelPolicies(body: unknown): string {
   const policies = readRecordArray(root, 'policies');
   const lines = [
     'Channel Policies',
-    `  policies: ${policies.length}`,
-    '  policy: read-only policy posture; use exact confirmed commands for changes',
+    `  policies ${policies.length}`,
+    '  policy read-only policy posture; use exact confirmed commands for changes',
     '',
   ];
   if (policies.length === 0) return [...lines, '  No channel policies reported by connected host.'].join('\n');
@@ -254,8 +337,8 @@ function formatChannelStatus(body: unknown): string {
   const channels = readRecordArray(root, 'channels');
   const lines = [
     'Connected Channel Status',
-    `  channels: ${channels.length}`,
-    '  policy: read-only connected-host status',
+    `  channels ${channels.length}`,
+    '  policy read-only connected-host status',
     '',
   ];
   if (channels.length === 0) return [...lines, '  No connected channel status reported.'].join('\n');
@@ -276,9 +359,9 @@ function formatChannelDoctor(surface: string, body: unknown): string {
   const repairActions = readRecordArray(root, 'repairActions');
   const lines = [
     `Channel Doctor: ${readString(root, 'surface', surface)}`,
-    `  checks: ${checks.length}`,
-    `  repair actions: ${repairActions.length}`,
-    '  policy: read-only doctor report; repair actions are not run here',
+    `  checks ${checks.length}`,
+    `  repair actions ${repairActions.length}`,
+    '  policy read-only doctor report; repair actions are not run here',
     '',
   ];
   if (checks.length === 0) lines.push('  No doctor checks reported.');
@@ -298,18 +381,18 @@ function formatChannelSetup(surface: string, body: unknown): string {
   const secretTargets = readRecordArray(root, 'secretTargets');
   const lines = [
     `Channel Setup Schema: ${readString(root, 'surface', surface)}`,
-    `  version: ${typeof root.version === 'number' ? root.version : 'unknown'}`,
-    `  fields: ${fields.length}`,
-    `  secret targets: ${secretTargets.length}`,
-    '  policy: read-only setup schema; no credentials or values are printed',
+    `  version ${typeof root.version === 'number' ? root.version : 'unknown'}`,
+    `  fields ${fields.length}`,
+    `  secret targets ${secretTargets.length}`,
+    '  policy read-only setup form; no credentials or values are printed',
     '',
   ];
   if (fields.length > 0) {
-    lines.push('  Fields:');
+    lines.push('  Fields');
     for (const field of fields.slice(0, 20)) lines.push(`  - ${readString(field, 'id', 'field')}`);
   }
   if (secretTargets.length > 0) {
-    lines.push('', '  Secret targets:');
+    lines.push('', '  Secret targets');
     for (const target of secretTargets.slice(0, 12)) {
       const required = readBoolean(target, 'required') ? 'required' : 'optional';
       lines.push(`  - ${readString(target, 'id', 'secret')} (${required})`);
@@ -336,9 +419,9 @@ export function registerChannelsRuntimeCommands(registry: CommandRegistry): void
   registry.register({
     name: 'channels',
     aliases: ['channel'],
-    description: 'Inspect Agent channel readiness without sending messages',
-    usage: '[list|readiness|ready|attention|show <id>|accounts|policies|status|doctor <id>|setup <id>]',
-    argsHint: 'list|readiness|ready|attention|show|accounts|policies|status|doctor|setup',
+    description: 'Inspect Agent channel readiness or send an explicitly confirmed delivery message',
+    usage: '[list|readiness|ready|attention|show <id>|send --channel <id> --message <text> --yes|accounts|policies|status|doctor <id>|setup <id>]',
+    argsHint: 'list|readiness|ready|attention|show|send|accounts|policies|status|doctor|setup',
     async handler(args, ctx) {
       const channels = buildAgentWorkspaceChannels(ctx);
       const subcommand = (args[0] ?? 'readiness').trim().toLowerCase();
@@ -366,13 +449,44 @@ export function registerChannelsRuntimeCommands(registry: CommandRegistry): void
         }
         const channel = channels.find((entry) => entry.id.toLowerCase() === channelId || entry.label.toLowerCase() === channelId);
         if (!channel) {
-          ctx.print(`Unknown channel: ${channelId}\nUse /channels list to see available channel ids.`);
+          ctx.print(`Unknown channel ${channelId}\nUse /channels list to see available channel ids.`);
           return;
         }
         printChannelDetail(ctx.print, channel);
         return;
       }
 
+      if (subcommand === 'send') {
+        const router = ctx.platform.channelDeliveryRouter;
+        if (!router) {
+          ctx.print('Channel delivery is not available in this Agent runtime.');
+          return;
+        }
+        const parsed = parseChannelSendArgs(args.slice(1));
+        if (parsed.errors.length > 0) {
+          ctx.print(`[channels] ${parsed.errors.join('\n[channels] ')}`);
+          return;
+        }
+        let preview: ReturnType<typeof buildAgentChannelDeliveryPreview>;
+        try {
+          preview = buildAgentChannelDeliveryPreview(parsed);
+        } catch (error) {
+          ctx.print(`[channels] ${error instanceof Error ? error.message : String(error)}`);
+          return;
+        }
+        if (!parsed.yes) {
+          ctx.print(formatAgentChannelDeliveryPreview(preview, router.listStrategies().length));
+          requireYesFlag(ctx, 'send a channel delivery message', '/channels send --channel <surface[:route[:label]]> --message <text> --yes');
+          return;
+        }
+        try {
+          ctx.print(formatAgentChannelDeliveryResult(await deliverAgentChannelMessage(router, parsed)));
+        } catch (error) {
+          ctx.print(`[channels] Send failed ${error instanceof Error ? error.message : String(error)}`);
+        }
+        return;
+      }
+
       if (subcommand === 'accounts') {
         await printReadOnlyChannelRoute(ctx, 'Channel accounts', '/api/channels/accounts', formatChannelAccounts);
         return;
@@ -403,7 +517,7 @@ export function registerChannelsRuntimeCommands(registry: CommandRegistry): void
         return;
       }
 
-      ctx.print('Usage: /channels [list|readiness|ready|attention|show <id>|accounts|policies|status|doctor <id>|setup <id>]');
+      ctx.print('Usage: /channels [list|readiness|ready|attention|show <id>|send --channel <id> --message <text> --yes|accounts|policies|status|doctor <id>|setup <id>]');
     },
   });
 }

package/src/input/commands/delegation-runtime.ts

@@ -6,11 +6,15 @@ function hasFlag(args: readonly string[], flag: string): boolean {
   return args.includes(flag);
 }
 
+function hasAnyFlag(args: readonly string[], flags: readonly string[]): boolean {
+  return flags.some((flag) => hasFlag(args, flag));
+}
+
 function delegationTaskValues(args: readonly string[]): string[] {
   const values: string[] = [];
   for (let index = 0; index < args.length; index += 1) {
     const token = args[index]!;
-    if (token === '--wrfc') continue;
+    if (token === '--review' || token === '--wrfc') continue;
     if (!token.startsWith('--')) {
       values.push(token);
       continue;
@@ -19,35 +23,35 @@ function delegationTaskValues(args: readonly string[]): string[] {
   return values;
 }
 
-function buildDelegationBody(task: string, wrfcRequested: boolean): string {
+function buildDelegationBody(task: string, reviewRequested: boolean): string {
   return [
     'GoodVibes Agent explicit build delegation.',
     '',
-    'Original user ask:',
+    'Original user ask',
     task,
     '',
-    'Agent policy:',
+    'Agent policy',
     '- GoodVibes Agent is not the coding TUI.',
     '- Preserve the full original ask.',
-    '- GoodVibes TUI owns file edits, git/worktree flows, execution isolation UX, and any WRFC owner chain.',
-    wrfcRequested
-      ? '- WRFC was explicitly requested by the Agent user for this build/fix/review delegation.'
-      : '- WRFC was not explicitly requested; do not turn this into WRFC solely because it came from Agent.',
+    '- GoodVibes TUI owns file edits, git/worktree flows, execution isolation UX, and any delegated review owner chain.',
+    reviewRequested
+      ? '- Delegated review was explicitly requested by the Agent user for this build/fix/review handoff.'
+      : '- Delegated review was not explicitly requested; do not add review solely because this came from Agent.',
   ].join('\n');
 }
 
 export function registerDelegationRuntimeCommands(registry: CommandRegistry): void {
-  const makeHandler = (defaultWrfc: boolean) => async (args: string[], ctx: CommandContext): Promise<void> => {
-    const wrfcRequested = defaultWrfc || hasFlag(args, '--wrfc');
+  const makeHandler = (defaultReview: boolean) => async (args: string[], ctx: CommandContext): Promise<void> => {
+    const reviewRequested = defaultReview || hasAnyFlag(args, ['--review', '--wrfc']);
     const task = delegationTaskValues(args).join(' ').trim();
     if (!task) {
-      ctx.print(defaultWrfc ? 'Usage: /wrfc <build/fix/review task>' : 'Usage: /delegate [--wrfc] <build/fix/review task>');
+      ctx.print(defaultReview ? 'Usage: /delegate --review <build/fix/review task>' : 'Usage: /delegate [--review] <build/fix/review task>');
       return;
     }
     const operator = ctx.clients?.operator;
     if (!operator) {
       ctx.print([
-        'Delegation unavailable: no operator client is attached.',
+        'Delegation unavailable. No operator client is attached.',
         'Use the shared-session route from a configured Agent runtime, or open GoodVibes TUI in the target workspace.',
       ].join('\n'));
       return;
@@ -67,12 +71,13 @@ export function registerDelegationRuntimeCommands(registry: CommandRegistry): vo
           originSurface: 'goodvibes-agent',
           sourceSessionId: ctx.session.runtime.sessionId,
           task,
-          wrfcRequested,
+          reviewRequested,
+          wrfcRequested: reviewRequested,
         },
       });
       await operator.sessions.submitMessage({
         sessionId: session.id,
-        body: buildDelegationBody(task, wrfcRequested),
+        body: buildDelegationBody(task, reviewRequested),
         surfaceKind: participant.surfaceKind,
         surfaceId: participant.surfaceId,
         externalId: participant.externalId,
@@ -83,7 +88,8 @@ export function registerDelegationRuntimeCommands(registry: CommandRegistry): vo
           sourceSessionId: ctx.session.runtime.sessionId,
           kind: 'task',
           task,
-          wrfcRequested,
+          reviewRequested,
+          wrfcRequested: reviewRequested,
         },
         routing: {
           executionIntent: {
@@ -96,16 +102,16 @@ export function registerDelegationRuntimeCommands(registry: CommandRegistry): vo
       });
       ctx.print([
         'Delegation submitted to GoodVibes TUI/shared-session routes.',
-        `  session: ${session.id}`,
-        `  mode: ${wrfcRequested ? 'WRFC requested' : 'direct build delegation'}`,
-        `  task: ${task}`,
-        '  next: check GoodVibes TUI shared-session/task status for the result.',
+        `  session ${session.id}`,
+        `  mode ${reviewRequested ? 'delegated review requested' : 'direct build delegation'}`,
+        `  task ${task}`,
+        '  next check GoodVibes TUI shared-session/task status for the result.',
       ].join('\n'));
     } catch (error) {
       ctx.print([
         'Delegation failed.',
-        `  error: ${summarizeError(error)}`,
-        '  fallback: open GoodVibes TUI in the target workspace and paste the original task there.',
+        `  error ${summarizeError(error)}`,
+        '  fallback open GoodVibes TUI in the target workspace and paste the original task there.',
       ].join('\n'));
     }
   };
@@ -114,8 +120,8 @@ export function registerDelegationRuntimeCommands(registry: CommandRegistry): vo
     name: 'delegate',
     aliases: ['build'],
     description: 'Explicitly delegate build/fix/review work to GoodVibes TUI through shared-session routes',
-    usage: '[--wrfc] <task>',
-    argsHint: '[--wrfc] <task>',
+    usage: '[--review] <task>',
+    argsHint: '[--review] <task>',
     handler: makeHandler(false),
   });
 }

package/src/input/commands/experience-runtime.ts

@@ -3,6 +3,7 @@ import { dirname, resolve } from 'node:path';
 import type { CommandRegistry } from '../command-registry.ts';
 import { requireShellPaths } from './runtime-services.ts';
 import { requireYesFlag, stripYesFlag } from './confirmation.ts';
+import { handleApprovalOperatorAction } from './operator-actions-runtime.ts';
 
 interface VoiceBundle {
   readonly version: 1;
@@ -25,18 +26,19 @@ export function registerExperienceRuntimeCommands(registry: CommandRegistry): vo
     name: 'approval',
     aliases: ['approvals'],
     description: 'Review action-specific approval classes and the specialized security UX matrix',
-    usage: '[matrix|review <kind>]',
+    usage: '[matrix|review <kind>|approve <id> --yes|deny <id> --yes|cancel <id> --yes]',
     async handler(args, ctx) {
       const sub = (args[0] ?? 'matrix').toLowerCase();
+      if (await handleApprovalOperatorAction(args, ctx)) return;
       if (sub === 'open' || sub === 'panel') {
-        ctx.print('Approval panels are not part of the Agent workspace. Use /approval matrix.');
+        ctx.print('Open Agent Workspace -> Work -> Review approvals for the workspace view, or run /approval matrix for the compact command output.');
         return;
       }
       const matrix = [
         ['shell', 'Shell execution approval with side-effect and credential review.'],
         ['file', 'File mutation approval with config/notebook differentiation.'],
         ['network', 'Network access approval with host/scope review.'],
-        ['delegate', 'Explicit GoodVibes TUI build delegation approval; local Agent spawn is blocked.'],
+        ['delegate', 'Explicit GoodVibes TUI build delegation approval; Agent-owned job fanout is blocked.'],
         ['mcp', 'MCP trust escalation approval with host/path review.'],
         ['remote', 'Remote dispatch approval with trust/artifact review.'],
         ['hook', 'Hook execution approval with deny/mutate authority review.'],
@@ -63,7 +65,7 @@ export function registerExperienceRuntimeCommands(registry: CommandRegistry): vo
         ].join('\n'));
         return;
       }
-      ctx.print('Usage: /approval [matrix|review <kind>]');
+      ctx.print('Usage: /approval [matrix|review <kind>|approve <id> --yes|deny <id> --yes|cancel <id> --yes]');
     },
   });
 

package/src/input/commands/guidance-runtime.ts

@@ -22,10 +22,10 @@ export function registerGuidanceRuntimeCommands(registry: CommandRegistry): void
           '  /setup              - open Agent setup with current settings preloaded',
           '  /agent              - open the Agent operator workspace',
           '  /knowledge          - inspect isolated Agent Knowledge status, ask, and search',
-          '  /memory             - manage local Agent memory',
-          '  /personas           - manage local Agent personas',
-          '  /agent-skills       - manage reusable local Agent skills',
-          '  /routines           - manage local Agent routines',
+          '  /memory             - manage Agent-local memory',
+          '  /personas           - manage Agent-local personas',
+          '  /skills       - manage reusable Agent-local skills',
+          '  /routines           - manage Agent-local routines',
           '  /delegate           - explicitly hand build/fix/review work to GoodVibes TUI',
         ].join('\n'));
         return;