@pellux/goodvibes-agent 0.1.1 → 0.1.3

package/src/cli/management.ts

@@ -21,6 +21,7 @@ import { beginOpenAICodexLogin, exchangeOpenAICodexCode } from '@pellux/goodvibe
 import { inspectProviderAuth } from '@/runtime/index.ts';
 import { getOrCreateCompanionToken, buildCompanionConnectionInfo, encodeConnectionPayload, formatConnectionBlock } from '@pellux/goodvibes-sdk/platform/pairing';
 import { generateQrMatrix, renderQrToString } from '@pellux/goodvibes-sdk/platform/pairing';
+import { UserAuthManager } from '@pellux/goodvibes-sdk/platform/security';
 import type { GoodVibesCliParseResult } from './types.ts';
 import { formatProviderAuthRoute, summarizeProviderAuthRoutes } from './provider-auth-routes.ts';
 import { classifyProviderSetup } from './provider-classification.ts';
@@ -31,6 +32,7 @@ import { handleServiceCommand } from './service-command.ts';
 import { handleBundleCommand } from './bundle-command.ts';
 import { buildListenerTestResult, formatListenerTestResult, handleSurfacesCommand } from './surface-command.ts';
 import { buildControlPlaneStatusResult, formatControlPlaneStatus, handleSecrets, handleSessions, handleTasks, renderPairing, renderRemote, renderSubscriptions, renderWeb } from './management-commands.ts';
+import { handleAgentKnowledgeCommand, handleCompatCommand, handleDelegateCommand } from './agent-knowledge-command.ts';
 import { GOODVIBES_AGENT_SURFACE_ROOT } from '../config/surface.ts';
 
 export interface CliCommandRuntime {
@@ -289,6 +291,14 @@ export function readAuthPaths(runtime: CliCommandRuntime) {
   };
 }
 
+function createCliLocalUserAuthManager(runtime: CliCommandRuntime): UserAuthManager {
+  const paths = readAuthPaths(runtime);
+  return new UserAuthManager({
+    bootstrapFilePath: paths.userStorePath,
+    bootstrapCredentialPath: paths.bootstrapCredentialPath,
+  });
+}
+
 export async function runNonInteractiveAgent(runtime: CliCommandRuntime): Promise<number> {
   const prompt = runtime.cli.flags.prompt ?? runtime.cli.positionals.join(' ').trim();
   if (!prompt) {
@@ -574,7 +584,7 @@ async function renderModels(runtime: CliCommandRuntime): Promise<string> {
 }
 
 async function renderAuth(runtime: CliCommandRuntime): Promise<string> {
-  return await withRuntimeServices(runtime, (services) => {
+  const localUserAuthManager = createCliLocalUserAuthManager(runtime);
     const [sub = 'status', ...rawRest] = runtime.cli.commandArgs;
     const rest = commandValues(rawRest);
     if (sub === 'add-user' || sub === 'add') {
@@ -583,13 +593,13 @@ async function renderAuth(runtime: CliCommandRuntime): Promise<string> {
       const password = readPassword(rawRest);
       if (!password) return 'Usage: goodvibes auth add-user <username> [--password <value>|--password-stdin] [--role <role>]';
       const roles = readOptionValues(rawRest, '--role').filter((role) => role.length > 0);
-      const user = services.localUserAuthManager.addUser(username, password, roles.length > 0 ? roles : ['user']);
+      const user = localUserAuthManager.addUser(username, password, roles.length > 0 ? roles : ['user']);
       return `Auth user added: ${user.username} (${user.roles.join(', ') || 'no roles'})`;
     }
     if (sub === 'delete-user' || sub === 'remove-user') {
       const username = rest[0];
       if (!username) return 'Usage: goodvibes auth delete-user <username>';
-      return services.localUserAuthManager.deleteUser(username)
+      return localUserAuthManager.deleteUser(username)
         ? `Auth user deleted: ${username}`
         : `No auth user found: ${username}`;
     }
@@ -598,31 +608,31 @@ async function renderAuth(runtime: CliCommandRuntime): Promise<string> {
       if (!username) return 'Usage: goodvibes auth rotate-password <username> [--password <value>|--password-stdin]';
       const password = readPassword(rawRest);
       if (!password) return 'Usage: goodvibes auth rotate-password <username> [--password <value>|--password-stdin]';
-      services.localUserAuthManager.rotatePassword(username, password);
+      localUserAuthManager.rotatePassword(username, password);
       return `Auth password rotated: ${username}`;
     }
     if (sub === 'revoke-session') {
       const token = rest[0];
       if (!token) return 'Usage: goodvibes auth revoke-session <token-or-fingerprint>';
-      return services.localUserAuthManager.revokeSession(token)
+      return localUserAuthManager.revokeSession(token)
         ? 'Auth session revoked.'
         : 'No auth session found.';
     }
     if (sub === 'revoke-sessions') {
       const username = rest[0];
       if (!username) return 'Usage: goodvibes auth revoke-sessions <username>';
-      const count = services.localUserAuthManager.revokeSessionsForUser(username);
+      const count = localUserAuthManager.revokeSessionsForUser(username);
       return `Auth sessions revoked for ${username}: ${count}`;
     }
     if (sub === 'clear-bootstrap') {
-      return services.localUserAuthManager.clearBootstrapCredentialFile()
+      return localUserAuthManager.clearBootstrapCredentialFile()
         ? 'Bootstrap credential file removed.'
         : 'Bootstrap credential file was already absent.';
     }
     if (sub !== 'status' && sub !== 'list' && sub !== 'users' && sub !== 'sessions') {
       return 'Usage: goodvibes auth [status|users|sessions|add-user|delete-user|rotate-password|revoke-session|revoke-sessions|clear-bootstrap]';
     }
-    const snapshot = services.localUserAuthManager.inspect();
+    const snapshot = localUserAuthManager.inspect();
     const paths = readAuthPaths(runtime);
     const value = {
       ...paths,
@@ -652,7 +662,6 @@ async function renderAuth(runtime: CliCommandRuntime): Promise<string> {
       `  bootstrap credential: ${paths.bootstrapCredentialPresent ? 'present' : 'missing'} (${paths.bootstrapCredentialPath})`,
       `  operator tokens: ${paths.operatorTokenPresent ? 'present' : 'missing'} (${paths.operatorTokenPath})`,
     ].join('\n'));
-  });
 }
 
 
@@ -684,6 +693,21 @@ export async function handleGoodVibesCliCommand(runtime: CliCommandRuntime): Pro
         console.log(output);
         return { handled: true, exitCode: exitCodeForText(output) };
       }
+      case 'compat': {
+        const result = await handleCompatCommand(runtime);
+        console.log(result.output);
+        return { handled: true, exitCode: result.exitCode };
+      }
+      case 'knowledge': {
+        const result = await handleAgentKnowledgeCommand(runtime);
+        console.log(result.output);
+        return { handled: true, exitCode: result.exitCode };
+      }
+      case 'delegate': {
+        const result = await handleDelegateCommand(runtime);
+        console.log(result.output);
+        return { handled: true, exitCode: result.exitCode };
+      }
       case 'subscription': {
         const output = await renderSubscriptions(runtime);
         console.log(output);

package/src/cli/parser.ts

@@ -26,6 +26,13 @@ const COMMAND_ALIASES: Readonly<Record<string, GoodVibesCliCommand>> = {
   providers: 'providers',
   provider: 'providers',
   auth: 'auth',
+  compat: 'compat',
+  compatibility: 'compat',
+  knowledge: 'knowledge',
+  know: 'knowledge',
+  kb: 'knowledge',
+  delegate: 'delegate',
+  build: 'delegate',
   subscription: 'subscription',
   subscriptions: 'subscription',
   secrets: 'secrets',

package/src/cli/types.ts

@@ -10,6 +10,9 @@ export type GoodVibesCliCommand =
   | 'models'
   | 'providers'
   | 'auth'
+  | 'compat'
+  | 'knowledge'
+  | 'delegate'
   | 'subscription'
   | 'secrets'
   | 'sessions'

package/src/config/surface.ts

@@ -1 +1,2 @@
 export const GOODVIBES_AGENT_SURFACE_ROOT = 'agent';
+export const GOODVIBES_AGENT_PAIRING_SURFACE = 'goodvibes-agent';

package/src/input/agent-workspace.ts

@@ -1,5 +1,7 @@
 import type { InputToken } from '@pellux/goodvibes-sdk/platform/core';
 import type { CommandContext } from './command-registry.ts';
+import { AgentPersonaRegistry } from '../agent/persona-registry.ts';
+import { AgentSkillRegistry } from '../agent/skill-registry.ts';
 
 export const AGENT_WORKSPACE_MODAL_NAME = 'agentWorkspace';
 
@@ -51,6 +53,10 @@ export interface AgentWorkspaceRuntimeSnapshot {
   readonly daemonBaseUrl: string;
   readonly daemonOwnership: 'external';
   readonly sessionMemoryCount: number;
+  readonly localSkillCount: number;
+  readonly enabledSkillCount: number;
+  readonly localPersonaCount: number;
+  readonly activePersonaName: string;
   readonly knowledgeRoute: '/api/goodvibes-agent/knowledge';
   readonly knowledgeIsolation: 'agent-only';
   readonly executionPolicy: 'serial-proactive';
@@ -98,6 +104,26 @@ export function buildAgentWorkspaceRuntimeSnapshot(context: CommandContext): Age
       return 0;
     }
   })();
+  const personaSnapshot = (() => {
+    try {
+      const shellPaths = context.workspace?.shellPaths;
+      if (!shellPaths) return { count: 0, activeName: '(none)' };
+      const snapshot = AgentPersonaRegistry.fromShellPaths(shellPaths).snapshot();
+      return { count: snapshot.personas.length, activeName: snapshot.activePersona?.name ?? '(none)' };
+    } catch {
+      return { count: 0, activeName: '(unavailable)' };
+    }
+  })();
+  const skillSnapshot = (() => {
+    try {
+      const shellPaths = context.workspace?.shellPaths;
+      if (!shellPaths) return { count: 0, enabled: 0 };
+      const snapshot = AgentSkillRegistry.fromShellPaths(shellPaths).snapshot();
+      return { count: snapshot.skills.length, enabled: snapshot.enabledSkills.length };
+    } catch {
+      return { count: 0, enabled: 0 };
+    }
+  })();
   const warnings: string[] = [];
   if (provider === 'unknown' || model === 'unknown') warnings.push('Provider/model unavailable in this runtime context.');
   if (!context.executeCommand) warnings.push('Command dispatch is unavailable; workspace actions will show guidance only.');
@@ -112,6 +138,10 @@ export function buildAgentWorkspaceRuntimeSnapshot(context: CommandContext): Age
     daemonBaseUrl: `http://${host}:${port}`,
     daemonOwnership: 'external',
     sessionMemoryCount,
+    localSkillCount: skillSnapshot.count,
+    enabledSkillCount: skillSnapshot.enabled,
+    localPersonaCount: personaSnapshot.count,
+    activePersonaName: personaSnapshot.activeName,
     knowledgeRoute: '/api/goodvibes-agent/knowledge',
     knowledgeIsolation: 'agent-only',
     executionPolicy: 'serial-proactive',
@@ -167,8 +197,8 @@ export const AGENT_WORKSPACE_CATEGORIES: readonly AgentWorkspaceCategory[] = [
     detail: 'Memory, skills, and personas stay Agent-local until stable shared daemon registry contracts exist. Secrets must not be stored as memory.',
     actions: [
       { id: 'memory', label: 'Open memory', detail: 'Inspect local/session memory commands and surfaces.', command: '/memory', kind: 'command', safety: 'read-only' },
-      { id: 'skills', label: 'Open skills', detail: 'Inspect discovered skills and skill catalog state.', command: '/skills open', kind: 'command', safety: 'read-only' },
-      { id: 'personas', label: 'Persona library', detail: 'Use local Agent personas to shape serial assistant behavior without spawning background agents.', kind: 'guidance', safety: 'safe' },
+      { id: 'skills', label: 'Local skill library', detail: 'Create, review, and enable local Agent reusable procedures.', command: '/agent-skills', kind: 'command', safety: 'safe' },
+      { id: 'personas', label: 'Persona library', detail: 'Use local Agent personas to shape serial assistant behavior without spawning background agents.', command: '/personas', kind: 'command', safety: 'safe' },
     ],
   },
   {
@@ -203,7 +233,7 @@ export const AGENT_WORKSPACE_CATEGORIES: readonly AgentWorkspaceCategory[] = [
     detail: 'Agent does not become the coding TUI. Build, implement, fix, patch, and review work must be handed to GoodVibes TUI with the full original ask and WRFC only when explicitly requested.',
     actions: [
       { id: 'delegate-guidance', label: 'Delegation rule', detail: 'For build/fix/review work, delegate one request to GoodVibes TUI instead of spawning local Engineer/Reviewer/Tester roots.', kind: 'guidance', safety: 'delegates' },
-      { id: 'review-command', label: 'Review delegation command', detail: 'Use /review or /wrfc only when the user explicitly asks for code review/build execution.', command: '/review', kind: 'command', safety: 'delegates' },
+      { id: 'review-command', label: 'Review delegation command', detail: 'Use /delegate --wrfc only when the user explicitly asks for code review/build execution.', command: '/delegate --wrfc <task>', kind: 'command', safety: 'delegates' },
       { id: 'remote-policy', label: 'Remote runner policy', detail: 'Remote dispatch/rerun is blocked in Agent; TUI owns runner topology for delegated build work.', command: '/remote dispatch', kind: 'command', safety: 'blocked' },
     ],
   },

package/src/input/command-registry.ts

@@ -180,7 +180,9 @@ export interface CommandExtensionRegistryServices {
 
 export interface CommandExtensionServices
   extends CommandExtensionRegistryServices,
-    CommandExtensionShellServices {}
+    CommandExtensionShellServices {
+  readonly agentKnowledgeService?: import('@pellux/goodvibes-sdk/platform/knowledge').KnowledgeService;
+}
 
 /**
  * CommandContext - Passed to every slash command handler so commands can
@@ -200,6 +202,7 @@ export interface CommandContext
     readonly operator?: OperatorClient;
     readonly peer?: PeerClient;
     readonly providerApi?: ProviderApi;
+    readonly agentKnowledgeApi?: KnowledgeApi;
     readonly knowledgeApi?: KnowledgeApi;
     readonly hookApi?: HookApi;
     readonly mcpApi?: McpApi;

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

@@ -0,0 +1,216 @@
+import { AgentSkillRegistry, type AgentSkillRecord } from '../../agent/skill-registry.ts';
+import type { CommandContext, CommandRegistry } from '../command-registry.ts';
+import { requireShellPaths } from './runtime-services.ts';
+
+interface ParsedSkillArgs {
+  readonly rest: readonly string[];
+  readonly flags: ReadonlyMap<string, string>;
+  readonly yes: boolean;
+}
+
+function parseSkillArgs(args: readonly string[]): ParsedSkillArgs {
+  const flags = new Map<string, string>();
+  const rest: string[] = [];
+  let yes = false;
+  for (let index = 0; index < args.length; index += 1) {
+    const token = args[index] ?? '';
+    if (token === '--yes') {
+      yes = true;
+      continue;
+    }
+    if (token.startsWith('--')) {
+      const key = token.slice(2);
+      const next = args[index + 1];
+      if (next !== undefined && !next.startsWith('--')) {
+        flags.set(key, next);
+        index += 1;
+      } else {
+        flags.set(key, 'true');
+      }
+      continue;
+    }
+    rest.push(token);
+  }
+  return { rest, flags, yes };
+}
+
+function splitList(value: string | undefined): readonly string[] {
+  if (!value) return [];
+  return value.split(',').map((entry) => entry.trim()).filter(Boolean);
+}
+
+function registryFromContext(ctx: CommandContext): AgentSkillRegistry {
+  return AgentSkillRegistry.fromShellPaths(requireShellPaths(ctx));
+}
+
+function requiredFlag(flags: ReadonlyMap<string, string>, key: string): string {
+  const value = flags.get(key)?.trim();
+  if (!value) throw new Error(`Missing --${key}.`);
+  return value;
+}
+
+function summarizeSkill(skill: AgentSkillRecord): string {
+  const enabled = skill.enabled ? 'enabled' : 'disabled';
+  const tags = skill.tags.length > 0 ? ` tags=${skill.tags.join(',')}` : '';
+  return `  ${skill.id}  ${enabled}  ${skill.reviewState}  ${skill.name} - ${skill.description}${tags}`;
+}
+
+function renderList(title: string, registry: AgentSkillRegistry, skills: readonly AgentSkillRecord[]): string {
+  const snapshot = registry.snapshot();
+  if (skills.length === 0) {
+    return `${title}\n  No local Agent skills yet. Create one with /agent-skills create --name <name> --description <summary> --procedure <steps>.`;
+  }
+  return [
+    `${title} (${skills.length})`,
+    `  store: ${snapshot.path}`,
+    `  enabled: ${snapshot.enabledSkills.length}`,
+    ...skills.map(summarizeSkill),
+  ].join('\n');
+}
+
+function renderSkill(skill: AgentSkillRecord): string {
+  return [
+    `Skill ${skill.name}`,
+    `  id: ${skill.id}`,
+    `  enabled: ${skill.enabled ? 'yes' : 'no'}`,
+    `  review: ${skill.reviewState}`,
+    `  source: ${skill.source}`,
+    `  provenance: ${skill.provenance}`,
+    `  tags: ${skill.tags.join(', ') || '(none)'}`,
+    `  triggers: ${skill.triggers.join(', ') || '(manual)'}`,
+    `  created: ${skill.createdAt}`,
+    `  updated: ${skill.updatedAt}`,
+    skill.staleReason ? `  stale reason: ${skill.staleReason}` : '',
+    '',
+    skill.description,
+    '',
+    skill.procedure,
+  ].filter(Boolean).join('\n');
+}
+
+function printError(ctx: CommandContext, error: unknown): void {
+  ctx.print(`Error: ${error instanceof Error ? error.message : String(error)}`);
+}
+
+export async function runAgentSkillsRuntimeCommand(args: readonly string[], ctx: CommandContext): Promise<void> {
+  const sub = (args[0] ?? 'list').toLowerCase();
+  const skillRegistry = registryFromContext(ctx);
+  try {
+    if (sub === 'list' || sub === 'open') {
+      ctx.print(renderList('Agent Skills', skillRegistry, skillRegistry.list()));
+      return;
+    }
+    if (sub === 'enabled') {
+      const snapshot = skillRegistry.snapshot();
+      ctx.print(renderList('Enabled Agent Skills', skillRegistry, snapshot.enabledSkills));
+      return;
+    }
+    if (sub === 'search') {
+      const query = args.slice(1).join(' ').trim();
+      ctx.print(renderList(query ? `Agent Skills matching "${query}"` : 'Agent Skills', skillRegistry, skillRegistry.search(query)));
+      return;
+    }
+    if (sub === 'show') {
+      const id = args[1];
+      if (!id) {
+        ctx.print('Usage: /agent-skills show <id>');
+        return;
+      }
+      const skill = skillRegistry.get(id);
+      ctx.print(skill ? renderSkill(skill) : `Unknown Agent skill: ${id}`);
+      return;
+    }
+    if (sub === 'create') {
+      const parsed = parseSkillArgs(args.slice(1));
+      const procedure = parsed.flags.get('procedure')?.trim() || parsed.rest.join(' ').trim();
+      const skill = skillRegistry.create({
+        name: requiredFlag(parsed.flags, 'name'),
+        description: requiredFlag(parsed.flags, 'description'),
+        procedure,
+        triggers: splitList(parsed.flags.get('triggers')),
+        tags: splitList(parsed.flags.get('tags')),
+        enabled: parsed.flags.get('enabled') === 'true',
+        source: 'user',
+        provenance: 'slash-command',
+      });
+      ctx.print(`Created Agent skill ${skill.id}: ${skill.name}`);
+      return;
+    }
+    if (sub === 'update') {
+      const id = args[1];
+      if (!id) {
+        ctx.print('Usage: /agent-skills update <id> [--name ...] [--description ...] [--procedure ...]');
+        return;
+      }
+      const parsed = parseSkillArgs(args.slice(2));
+      const updated = skillRegistry.update(id, {
+        name: parsed.flags.get('name'),
+        description: parsed.flags.get('description'),
+        procedure: parsed.flags.get('procedure'),
+        triggers: parsed.flags.has('triggers') ? splitList(parsed.flags.get('triggers')) : undefined,
+        tags: parsed.flags.has('tags') ? splitList(parsed.flags.get('tags')) : undefined,
+        provenance: 'slash-command',
+      });
+      ctx.print(`Updated Agent skill ${updated.id}: ${updated.name}`);
+      return;
+    }
+    if (sub === 'enable' || sub === 'disable') {
+      const id = args[1];
+      if (!id) {
+        ctx.print(`Usage: /agent-skills ${sub} <id>`);
+        return;
+      }
+      const skill = skillRegistry.setEnabled(id, sub === 'enable');
+      ctx.print(`${sub === 'enable' ? 'Enabled' : 'Disabled'} Agent skill ${skill.id}: ${skill.name}`);
+      return;
+    }
+    if (sub === 'review') {
+      const id = args[1];
+      if (!id) {
+        ctx.print('Usage: /agent-skills review <id>');
+        return;
+      }
+      const skill = skillRegistry.markReviewed(id);
+      ctx.print(`Reviewed Agent skill ${skill.id}.`);
+      return;
+    }
+    if (sub === 'stale') {
+      const id = args[1];
+      if (!id) {
+        ctx.print('Usage: /agent-skills stale <id> <reason...>');
+        return;
+      }
+      const skill = skillRegistry.markStale(id, args.slice(2).join(' '));
+      ctx.print(`Marked Agent skill ${skill.id} stale.`);
+      return;
+    }
+    if (sub === 'delete' || sub === 'remove') {
+      const parsed = parseSkillArgs(args.slice(1));
+      const id = parsed.rest[0];
+      if (!id) {
+        ctx.print('Usage: /agent-skills delete <id> --yes');
+        return;
+      }
+      if (!parsed.yes) {
+        ctx.print(`Refusing to delete Agent skill ${id} without --yes.`);
+        return;
+      }
+      const removed = skillRegistry.deleteSkill(id);
+      ctx.print(`Deleted Agent skill ${removed.id}: ${removed.name}`);
+      return;
+    }
+    ctx.print('Usage: /agent-skills [list|enabled|search|show|create|update|enable|disable|review|stale|delete]');
+  } catch (error) {
+    printError(ctx, error);
+  }
+}
+
+export function registerAgentSkillsRuntimeCommands(registry: CommandRegistry): void {
+  registry.register({
+    name: 'agent-skills',
+    aliases: ['askills', 'local-skills'],
+    description: 'Manage local GoodVibes Agent skills',
+    usage: '[list|enabled|search <query>|show <id>|create --name <name> --description <summary> --procedure <steps>|update <id> [--name ...] [--description ...] [--procedure ...]|enable <id>|disable <id>|review <id>|stale <id> <reason...>|delete <id> --yes]',
+    handler: runAgentSkillsRuntimeCommand,
+  });
+}

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

@@ -0,0 +1,129 @@
+import type { CommandContext, CommandRegistry } from '../command-registry.ts';
+import type { SharedSessionParticipant } from '@pellux/goodvibes-sdk/platform/control-plane';
+import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
+
+function hasFlag(args: readonly string[], flag: string): boolean {
+  return args.includes(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.startsWith('--')) {
+      values.push(token);
+      continue;
+    }
+  }
+  return values;
+}
+
+function buildDelegationBody(task: string, wrfcRequested: boolean): string {
+  return [
+    'GoodVibes Agent explicit build delegation.',
+    '',
+    'Original user ask:',
+    task,
+    '',
+    'Agent policy:',
+    '- GoodVibes Agent is not the coding TUI.',
+    '- Preserve the full original ask.',
+    '- GoodVibes TUI owns file edits, git/worktree flows, sandbox/QEMU 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.',
+  ].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 task = delegationTaskValues(args).join(' ').trim();
+    if (!task) {
+      ctx.print(defaultWrfc ? 'Usage: /wrfc <build/fix/review task>' : 'Usage: /delegate [--wrfc] <build/fix/review task>');
+      return;
+    }
+    const operator = ctx.clients?.operator;
+    if (!operator) {
+      ctx.print([
+        'Delegation unavailable: no operator client is attached.',
+        'Use the external daemon/shared-session route from a configured Agent runtime, or open GoodVibes TUI in the target workspace.',
+      ].join('\n'));
+      return;
+    }
+    try {
+      const participant = {
+        surfaceKind: 'service',
+        surfaceId: 'goodvibes-agent',
+        externalId: ctx.session.runtime.sessionId,
+        displayName: 'GoodVibes Agent',
+        lastSeenAt: Date.now(),
+      } satisfies SharedSessionParticipant;
+      const session = await operator.sessions.ensureSession({
+        title: `Agent delegation: ${task.slice(0, 72)}`,
+        participant,
+        metadata: {
+          originSurface: 'goodvibes-agent',
+          sourceSessionId: ctx.session.runtime.sessionId,
+          task,
+          wrfcRequested,
+        },
+      });
+      await operator.sessions.submitMessage({
+        sessionId: session.id,
+        body: buildDelegationBody(task, wrfcRequested),
+        surfaceKind: participant.surfaceKind,
+        surfaceId: participant.surfaceId,
+        externalId: participant.externalId,
+        displayName: participant.displayName,
+        title: `Agent delegation: ${task.slice(0, 72)}`,
+        metadata: {
+          originSurface: 'goodvibes-agent',
+          sourceSessionId: ctx.session.runtime.sessionId,
+          kind: 'task',
+          task,
+          wrfcRequested,
+        },
+        routing: {
+          executionIntent: {
+            riskClass: 'elevated',
+            requiresApproval: true,
+            networkPolicy: 'inherit',
+            filesystemPolicy: 'workspace-write',
+          },
+        },
+      });
+      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.',
+      ].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.',
+      ].join('\n'));
+    }
+  };
+
+  registry.register({
+    name: 'delegate',
+    aliases: ['build'],
+    description: 'Explicitly delegate build/fix/review work to GoodVibes TUI through shared-session routes',
+    usage: '[--wrfc] <task>',
+    argsHint: '[--wrfc] <task>',
+    handler: makeHandler(false),
+  });
+  registry.register({
+    name: 'wrfc',
+    aliases: ['review'],
+    description: 'Explicitly delegate build/fix/review work to GoodVibes TUI with WRFC requested',
+    usage: '<task>',
+    argsHint: '<task>',
+    handler: makeHandler(true),
+  });
+}