@pellux/goodvibes-agent 0.1.0

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

@@ -0,0 +1,339 @@
+import type { CommandRegistry, CommandContext } from '../command-registry.ts';
+import { join } from 'node:path';
+import { AGENT_TEMPLATES } from '@pellux/goodvibes-sdk/platform/tools';
+import { ArchetypeLoader, type AgentArchetype } from '@pellux/goodvibes-sdk/platform/agents';
+import { requireReadModels, requireShellPaths } from './runtime-services.ts';
+
+type TeamworkModeId =
+  | 'local-engineer'
+  | 'local-shell'
+  | 'remote-engineer'
+  | 'teammate'
+  | 'research'
+  | 'dream'
+  | 'review'
+  | 'verifier'
+  | 'integration';
+
+interface TeamworkMode {
+  readonly id: TeamworkModeId;
+  readonly label: string;
+  readonly taskKind: 'agent' | 'exec' | 'acp' | 'integration';
+  readonly owner: string;
+  readonly template?: keyof typeof AGENT_TEMPLATES;
+  readonly reviewMode: 'none' | 'wrfc';
+  readonly executionProtocol: 'direct' | 'gather-plan-apply';
+}
+
+interface TeamworkRecipe {
+  readonly id: string;
+  readonly summary: string;
+  readonly steps: readonly string[];
+}
+
+interface ResolvedArchetypeMode {
+  readonly id: string;
+  readonly label: string;
+  readonly owner: string;
+  readonly taskKind: 'agent' | 'exec' | 'acp' | 'integration';
+  readonly template?: string;
+  readonly reviewMode: 'none' | 'wrfc';
+  readonly executionProtocol: 'direct' | 'gather-plan-apply';
+  readonly source: 'builtin' | 'custom';
+  readonly family: 'implement' | 'review' | 'test' | 'research' | 'general';
+  readonly sourcePath?: string;
+  readonly validationIssues: readonly string[];
+  readonly tools: readonly string[];
+}
+
+interface TeamworkReviewSnapshot {
+  readonly builtinArchetypes: number;
+  readonly customArchetypes: number;
+  readonly archetypesWithIssues: number;
+  readonly implementArchetypes: number;
+  readonly reviewArchetypes: number;
+  readonly researchArchetypes: number;
+  readonly activeTaskCount: number;
+  readonly blockedTaskCount: number;
+  readonly reviewTaskCount: number;
+}
+
+const TEAMWORK_MODES: readonly TeamworkMode[] = [
+  { id: 'local-engineer', label: 'Local engineer task', taskKind: 'agent', owner: 'local-engineer', template: 'engineer', reviewMode: 'wrfc', executionProtocol: 'gather-plan-apply' },
+  { id: 'local-shell', label: 'Local shell task', taskKind: 'exec', owner: 'local-shell', reviewMode: 'none', executionProtocol: 'direct' },
+  { id: 'remote-engineer', label: 'Remote engineer task', taskKind: 'acp', owner: 'remote-engineer', template: 'engineer', reviewMode: 'wrfc', executionProtocol: 'gather-plan-apply' },
+  { id: 'teammate', label: 'In-process teammate task', taskKind: 'agent', owner: 'teammate', template: 'general', reviewMode: 'wrfc', executionProtocol: 'gather-plan-apply' },
+  { id: 'research', label: 'Research task', taskKind: 'agent', owner: 'research', template: 'researcher', reviewMode: 'none', executionProtocol: 'gather-plan-apply' },
+  { id: 'dream', label: 'Speculative dream task', taskKind: 'agent', owner: 'dream', template: 'researcher', reviewMode: 'none', executionProtocol: 'gather-plan-apply' },
+  { id: 'review', label: 'Review-only task', taskKind: 'agent', owner: 'review', template: 'reviewer', reviewMode: 'wrfc', executionProtocol: 'gather-plan-apply' },
+  { id: 'verifier', label: 'Verifier task', taskKind: 'agent', owner: 'verifier', template: 'reviewer', reviewMode: 'wrfc', executionProtocol: 'gather-plan-apply' },
+  { id: 'integration', label: 'Integration task', taskKind: 'integration', owner: 'integration', template: 'engineer', reviewMode: 'wrfc', executionProtocol: 'gather-plan-apply' },
+];
+
+const TEAMWORK_RECIPES: readonly TeamworkRecipe[] = [
+  {
+    id: 'research-implement-review',
+    summary: 'Research first, implement second, certify with WRFC review.',
+    steps: ['research', 'local-engineer', 'review', 'verifier'],
+  },
+  {
+    id: 'remote-certification',
+    summary: 'Remote engineer execution with local review and integration.',
+    steps: ['remote-engineer', 'review', 'integration'],
+  },
+  {
+    id: 'triage-delegate-integrate',
+    summary: 'Triage locally, delegate focused teammate work, then integrate.',
+    steps: ['teammate', 'review', 'integration'],
+  },
+  {
+    id: 'dream-then-certify',
+    summary: 'Run a speculative research pass, then ground it through engineer, review, and verifier steps.',
+    steps: ['dream', 'local-engineer', 'review', 'verifier'],
+  },
+];
+
+function formatMode(mode: TeamworkMode): string {
+  return `  ${mode.id.padEnd(18)} ${mode.taskKind.padEnd(11)} ${mode.owner.padEnd(16)} ${mode.reviewMode.padEnd(4)} ${mode.executionProtocol}${mode.template ? `  template=${mode.template}` : ''}`;
+}
+
+function classifyArchetype(archetype: AgentArchetype): ResolvedArchetypeMode['family'] {
+  const haystack = `${archetype.name} ${archetype.description}`.toLowerCase();
+  const tools = new Set(archetype.tools.map((tool) => tool.toLowerCase()));
+  if (haystack.includes('review') || haystack.includes('audit')) return 'review';
+  if (haystack.includes('test') || tools.has('exec') && tools.has('write') && !tools.has('edit')) return 'test';
+  if (haystack.includes('research') || haystack.includes('analysis') || (tools.has('find') && tools.has('analyze') && !tools.has('write') && !tools.has('edit'))) return 'research';
+  if (tools.has('write') || tools.has('edit')) return 'implement';
+  return 'general';
+}
+
+function buildArchetypeMode(archetype: AgentArchetype): ResolvedArchetypeMode {
+  const family = classifyArchetype(archetype);
+  const source = archetype.isCustom ? 'custom' : 'builtin';
+  return {
+    id: archetype.name,
+    label: archetype.description || `${archetype.name} archetype`,
+    owner: source === 'custom' ? `custom:${archetype.name}` : archetype.name,
+    taskKind: 'agent',
+    template: archetype.name,
+    reviewMode: family === 'review' ? 'wrfc' : 'none',
+    executionProtocol: family === 'research' ? 'gather-plan-apply' : family === 'implement' ? 'gather-plan-apply' : 'direct',
+    source,
+    family,
+    sourcePath: archetype.sourcePath,
+    validationIssues: archetype.validationIssues ?? [],
+    tools: archetype.tools,
+  };
+}
+
+function listArchetypeModes(projectRoot: string): ResolvedArchetypeMode[] {
+  const loader = new ArchetypeLoader(join(projectRoot, '.goodvibes', 'agents'));
+  return loader.listArchetypes()
+    .map(buildArchetypeMode)
+    .sort((a, b) => a.id.localeCompare(b.id));
+}
+
+function buildTeamworkReviewSnapshot(ctx: CommandContext): TeamworkReviewSnapshot {
+  const projectRoot = requireShellPaths(ctx).workingDirectory;
+  const archetypes = listArchetypeModes(projectRoot);
+  const tasks = [...requireReadModels(ctx).tasks.getSnapshot().tasks];
+  return {
+    builtinArchetypes: archetypes.filter((entry) => entry.source === 'builtin').length,
+    customArchetypes: archetypes.filter((entry) => entry.source === 'custom').length,
+    archetypesWithIssues: archetypes.filter((entry) => entry.validationIssues.length > 0).length,
+    implementArchetypes: archetypes.filter((entry) => entry.family === 'implement').length,
+    reviewArchetypes: archetypes.filter((entry) => entry.family === 'review').length,
+    researchArchetypes: archetypes.filter((entry) => entry.family === 'research').length,
+    activeTaskCount: tasks.filter((task) => task.status === 'running' || task.status === 'queued').length,
+    blockedTaskCount: tasks.filter((task) => task.status === 'blocked').length,
+    reviewTaskCount: tasks.filter((task) => task.owner === 'review' || task.owner === 'verifier').length,
+  };
+}
+
+function printAgentDelegationBoundary(ctx: CommandContext, requestedAction: string): void {
+  ctx.print([
+    'GoodVibes Agent does not create local teamwork, Engineer, Reviewer, Tester, Verifier, or WRFC-owned tasks.',
+    `  requested: ${requestedAction}`,
+    '  policy: keep ordinary work serial in the main assistant conversation',
+    '  build/fix/review: delegate one request to GoodVibes TUI through the public shared-session/build-delegation contract',
+    '  preserve: full original user ask and executionIntent; let TUI own WRFC when explicitly requested',
+  ].join('\n'));
+}
+
+export function registerTeamworkRuntimeCommands(registry: CommandRegistry): void {
+  registry.register({
+    name: 'teamwork',
+    aliases: ['teammates'],
+    description: 'Packaged task modes, teammate templates, and orchestration recipes',
+    usage: '[review|modes|mode <id>|create-mode <id> <title...>|recipes|recipe <id>|templates|archetypes|validate|archetype <name>|create-archetype <name> <title...>]',
+    handler(args, ctx) {
+      const sub = args[0]?.toLowerCase() ?? 'review';
+
+      if (sub === 'review') {
+        const snapshot = buildTeamworkReviewSnapshot(ctx);
+        ctx.print([
+          'Teamwork Review',
+          `  modes: ${TEAMWORK_MODES.length}`,
+          `  recipes: ${TEAMWORK_RECIPES.length}`,
+          `  builtin archetypes: ${snapshot.builtinArchetypes}`,
+          `  custom archetypes: ${snapshot.customArchetypes}`,
+          `  archetypes with issues: ${snapshot.archetypesWithIssues}`,
+          `  implement/review/research: ${snapshot.implementArchetypes}/${snapshot.reviewArchetypes}/${snapshot.researchArchetypes}`,
+          `  active tasks: ${snapshot.activeTaskCount}`,
+          `  blocked tasks: ${snapshot.blockedTaskCount}`,
+          `  review tasks: ${snapshot.reviewTaskCount}`,
+          '  next: /teamwork archetypes',
+          '  next: /teamwork validate',
+          '  next: /tasks',
+        ].join('\n'));
+        return;
+      }
+
+      if (sub === 'modes') {
+        ctx.print([
+          'Teamwork Modes',
+          ...TEAMWORK_MODES.map(formatMode),
+        ].join('\n'));
+        return;
+      }
+
+      if (sub === 'mode') {
+        const modeId = args[1] as TeamworkModeId | undefined;
+        const mode = TEAMWORK_MODES.find((entry) => entry.id === modeId);
+        if (!mode) {
+          ctx.print('Usage: /teamwork mode <local-engineer|local-shell|remote-engineer|teammate|research|dream|review|verifier|integration>');
+          return;
+        }
+        ctx.print([
+          `Teamwork Mode ${mode.id}`,
+          `  label: ${mode.label}`,
+          `  taskKind: ${mode.taskKind}`,
+          `  owner: ${mode.owner}`,
+          `  template: ${mode.template ?? '(none)'}`,
+          `  reviewMode: ${mode.reviewMode}`,
+          `  executionProtocol: ${mode.executionProtocol}`,
+        ].join('\n'));
+        return;
+      }
+
+      if (sub === 'create-mode') {
+        const modeId = args[1] as TeamworkModeId | undefined;
+        const title = args.slice(2).join(' ').trim();
+        const mode = TEAMWORK_MODES.find((entry) => entry.id === modeId);
+        if (!mode || !title) {
+          ctx.print('Usage: /teamwork create-mode <local-engineer|local-shell|remote-engineer|teammate|research|dream|review|verifier|integration> <title...>');
+          return;
+        }
+        printAgentDelegationBoundary(ctx, `/teamwork create-mode ${mode.id} ${title}`);
+        return;
+      }
+
+      if (sub === 'recipes') {
+        ctx.print([
+          'Teamwork Recipes',
+          ...TEAMWORK_RECIPES.map((recipe) => `  ${recipe.id.padEnd(26)} ${recipe.summary}`),
+        ].join('\n'));
+        return;
+      }
+
+      if (sub === 'recipe') {
+        const recipeId = args[1];
+        const recipe = TEAMWORK_RECIPES.find((entry) => entry.id === recipeId);
+        if (!recipe) {
+          ctx.print('Usage: /teamwork recipe <id>');
+          return;
+        }
+        ctx.print([
+          `Teamwork Recipe ${recipe.id}`,
+          `  summary: ${recipe.summary}`,
+          `  steps: ${recipe.steps.join(' -> ')}`,
+        ].join('\n'));
+        return;
+      }
+
+      if (sub === 'templates') {
+        const archetypes = listArchetypeModes(requireShellPaths(ctx).workingDirectory);
+        ctx.print([
+          'Teamwork Templates',
+          ...Object.entries(AGENT_TEMPLATES).map(([name, template]) => (
+            `  ${name.padEnd(12)} ${template.description}`
+          )),
+          '',
+          'Discovered Archetypes',
+          ...archetypes.map((entry) => `  ${entry.id.padEnd(12)} ${entry.family.padEnd(10)} ${entry.source.padEnd(7)} ${entry.label}`),
+        ].join('\n'));
+        return;
+      }
+
+      if (sub === 'archetypes') {
+        const archetypes = listArchetypeModes(requireShellPaths(ctx).workingDirectory);
+        ctx.print([
+          'Teamwork Archetypes',
+          ...archetypes.map((entry) => `  ${entry.id.padEnd(18)} ${entry.family.padEnd(10)} ${entry.source.padEnd(7)} ${entry.reviewMode.padEnd(4)} ${entry.executionProtocol}${entry.validationIssues.length > 0 ? '  issues' : ''}`),
+        ].join('\n'));
+        return;
+      }
+
+      if (sub === 'validate') {
+        const archetypes = listArchetypeModes(requireShellPaths(ctx).workingDirectory);
+        const invalid = archetypes.filter((entry) => entry.validationIssues.length > 0);
+        ctx.print(invalid.length > 0
+          ? [
+              'Teamwork Archetype Validation',
+              ...invalid.flatMap((entry) => [
+                `  ${entry.id} (${entry.source})`,
+                ...entry.validationIssues.map((issue) => `    issue: ${issue}`),
+              ]),
+            ].join('\n')
+          : 'Teamwork Archetype Validation\n  All discovered archetypes are currently valid.');
+        return;
+      }
+
+      if (sub === 'archetype') {
+        const archetypeName = args[1];
+        if (!archetypeName) {
+          ctx.print('Usage: /teamwork archetype <name>');
+          return;
+        }
+        const mode = listArchetypeModes(requireShellPaths(ctx).workingDirectory).find((entry) => entry.id === archetypeName);
+        if (!mode) {
+          ctx.print(`Unknown archetype: ${archetypeName}`);
+          return;
+        }
+        ctx.print([
+          `Teamwork Archetype ${mode.id}`,
+          `  label: ${mode.label}`,
+          `  family: ${mode.family}`,
+          `  source: ${mode.source}`,
+          `  owner: ${mode.owner}`,
+          `  reviewMode: ${mode.reviewMode}`,
+          `  executionProtocol: ${mode.executionProtocol}`,
+          `  tools: ${mode.tools.join(', ') || '(none)'}`,
+          `  sourcePath: ${mode.sourcePath ?? '(builtin)'}`,
+          ...(mode.validationIssues.length > 0
+            ? mode.validationIssues.map((issue) => `  issue: ${issue}`)
+            : ['  validation: clean']),
+        ].join('\n'));
+        return;
+      }
+
+      if (sub === 'create-archetype') {
+        const archetypeName = args[1];
+        const title = args.slice(2).join(' ').trim();
+        if (!archetypeName || !title) {
+          ctx.print('Usage: /teamwork create-archetype <name> <title...>');
+          return;
+        }
+        const mode = listArchetypeModes(requireShellPaths(ctx).workingDirectory).find((entry) => entry.id === archetypeName);
+        if (!mode) {
+          ctx.print(`Unknown archetype: ${archetypeName}`);
+          return;
+        }
+        printAgentDelegationBoundary(ctx, `/teamwork create-archetype ${mode.id} ${title}`);
+        return;
+      }
+
+      ctx.print('Usage: /teamwork [review|modes|mode <id>|create-mode <id> <title...>|recipes|recipe <id>|templates|archetypes|validate|archetype <name>|create-archetype <name> <title...>]');
+    },
+  });
+}

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

@@ -0,0 +1,57 @@
+import { readFileSync } from 'node:fs';
+import type { CommandRegistry } from '../command-registry.ts';
+import type { RemoteSessionBundle } from '@/runtime/index.ts';
+import { requirePeerClient, requireShellPaths } from './runtime-services.ts';
+
+function inspectRemoteSessionBundle(bundle: RemoteSessionBundle): string {
+  return [
+    'Teleport Bundle Review',
+    `  session: ${bundle.sessionId}`,
+    `  exportedAt: ${new Date(bundle.exportedAt).toISOString()}`,
+    `  active connections: ${bundle.activeConnectionIds.length}`,
+    `  pools: ${bundle.pools.length}`,
+    `  contracts: ${bundle.contracts.length}`,
+    `  artifacts: ${bundle.artifacts.length}`,
+  ].join('\n');
+}
+
+export function registerTeleportRuntimeCommands(registry: CommandRegistry): void {
+  registry.register({
+    name: 'teleport',
+    description: 'Package, inspect, and import portable remote-session handoff bundles',
+    usage: '[export <path>|inspect <path>|import <path>]',
+    async handler(args, ctx) {
+      const shellPaths = requireShellPaths(ctx);
+      const mode = (args[0] ?? 'export').toLowerCase();
+      const pathArg = args[1];
+      if (!pathArg) {
+        ctx.print('Usage: /teleport [export <path>|inspect <path>|import <path>]');
+        return;
+      }
+      let peerClient;
+      try {
+        peerClient = requirePeerClient(ctx);
+      } catch {
+        ctx.print('Remote runner registry is not available in this runtime.');
+        return;
+      }
+      const targetPath = shellPaths.resolveWorkspacePath(pathArg);
+      if (mode === 'export') {
+        const exported = await peerClient.runners.exportSessionBundle(targetPath);
+        ctx.print(`Teleport bundle exported for session ${exported.bundle.sessionId} to ${exported.path}`);
+        return;
+      }
+      if (mode === 'inspect') {
+        const bundle = JSON.parse(readFileSync(targetPath, 'utf-8')) as RemoteSessionBundle;
+        ctx.print(inspectRemoteSessionBundle(bundle));
+        return;
+      }
+      if (mode === 'import') {
+        const bundle = await peerClient.runners.importSessionBundle(targetPath);
+        ctx.print(`Imported teleport bundle ${bundle.sessionId} with ${bundle.contracts.length} contracts.`);
+        return;
+      }
+      ctx.print('Usage: /teleport [export <path>|inspect <path>|import <path>]');
+    },
+  });
+}

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

@@ -0,0 +1,29 @@
+import type { CommandRegistry } from '../command-registry.ts';
+
+export function registerTtsRuntimeCommands(registry: CommandRegistry): void {
+  registry.register({
+    name: 'tts',
+    description: 'Submit a normal prompt and play the assistant response through live TTS',
+    usage: '<prompt>|stop',
+    handler(args, ctx) {
+      const first = (args[0] ?? '').toLowerCase();
+      if (first === 'stop' || first === 'cancel') {
+        ctx.stopSpokenOutput?.();
+        ctx.print('Live TTS playback stopped.');
+        return;
+      }
+
+      const prompt = args.join(' ').trim();
+      if (!prompt) {
+        ctx.print('Usage: /tts <prompt> or /tts stop');
+        return;
+      }
+      if (!ctx.submitSpokenInput) {
+        ctx.print('Live TTS is not available in this runtime.');
+        return;
+      }
+      ctx.submitSpokenInput(prompt);
+    },
+  });
+
+}

package/src/input/commands/work-plan-runtime.ts

@@ -0,0 +1,169 @@
+import type { CommandRegistry } from '../command-registry.ts';
+import type { WorkPlanItemStatus, WorkPlanStore } from '../../work-plans/work-plan-store.ts';
+import { WORK_PLAN_STATUSES } from '../../work-plans/work-plan-store.ts';
+import { requirePanelManager } from './runtime-services.ts';
+import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
+
+const STATUS_COMMANDS: Record<string, WorkPlanItemStatus> = {
+  pending: 'pending',
+  todo: 'pending',
+  start: 'in_progress',
+  active: 'in_progress',
+  progress: 'in_progress',
+  block: 'blocked',
+  blocked: 'blocked',
+  done: 'done',
+  complete: 'done',
+  fail: 'failed',
+  failed: 'failed',
+  cancel: 'cancelled',
+  cancelled: 'cancelled',
+};
+
+function getStore(ctx: import('../command-registry.ts').CommandContext): WorkPlanStore | null {
+  return ctx.workspace.workPlanStore ?? null;
+}
+
+function openPanel(ctx: import('../command-registry.ts').CommandContext): void {
+  if (ctx.showPanel) {
+    ctx.showPanel('work-plan');
+    return;
+  }
+  const panelManager = requirePanelManager(ctx);
+  panelManager.open('work-plan');
+  panelManager.show();
+  ctx.renderRequest();
+}
+
+function formatList(store: WorkPlanStore): string {
+  const items = store.listItems();
+  if (items.length === 0) return 'Work plan is empty. Add one with /workplan add <title>.';
+  return [
+    `Work Plan (${items.length})`,
+    ...items.map((item) => {
+      const owner = item.owner ? ` @${item.owner}` : '';
+      return `  ${item.id}  ${item.status.padEnd(11)} ${item.title}${owner}`;
+    }),
+  ].join('\n');
+}
+
+function parseAddArgs(args: string[]): { title: string; owner?: string; source?: string; notes?: string } {
+  const titleParts: string[] = [];
+  let owner: string | undefined;
+  let source: string | undefined;
+  let notes: string | undefined;
+  for (let i = 0; i < args.length; i++) {
+    const part = args[i] ?? '';
+    if (part === '--owner' && args[i + 1]) {
+      owner = args[++i];
+      continue;
+    }
+    if (part === '--source' && args[i + 1]) {
+      source = args[++i];
+      continue;
+    }
+    if (part === '--notes' && args[i + 1]) {
+      notes = args.slice(i + 1).join(' ').trim();
+      break;
+    }
+    titleParts.push(part);
+  }
+  return {
+    title: titleParts.join(' ').trim(),
+    ...(owner ? { owner } : {}),
+    ...(source ? { source } : {}),
+    ...(notes ? { notes } : {}),
+  };
+}
+
+export function registerWorkPlanRuntimeCommands(registry: CommandRegistry): void {
+  registry.register({
+    name: 'workplan',
+    aliases: ['wp', 'todo'],
+    description: 'Track a persistent workspace-scoped work plan',
+    usage: '[panel|list|show|add <title> [--owner name] [--source label] [--notes text]|done <id>|start <id>|block <id>|fail <id>|cancel <id>|pending <id>|remove <id>|clear-done]',
+    argsHint: '[panel|add|list|done]',
+    handler(args, ctx) {
+      const store = getStore(ctx);
+      if (!store) {
+        ctx.print('Work plan store is not available in this runtime.');
+        return;
+      }
+      const subcommand = (args[0] ?? 'panel').toLowerCase();
+      try {
+        if (subcommand === 'panel' || subcommand === 'open') {
+          openPanel(ctx);
+          ctx.print('Opened work plan panel.');
+          return;
+        }
+        if (subcommand === 'list') {
+          ctx.print(formatList(store));
+          return;
+        }
+        if (subcommand === 'show' || subcommand === 'markdown') {
+          ctx.print(store.toMarkdown());
+          return;
+        }
+        if (subcommand === 'add') {
+          const parsed = parseAddArgs(args.slice(1));
+          if (!parsed.title) {
+            ctx.print('Usage: /workplan add <title> [--owner name] [--source label] [--notes text]');
+            return;
+          }
+          const addOptions = {
+            ...(parsed.owner ? { owner: parsed.owner } : {}),
+            source: parsed.source ?? 'manual',
+            ...(parsed.notes ? { notes: parsed.notes } : {}),
+          };
+          const item = store.addItem(parsed.title, addOptions);
+          openPanel(ctx);
+          ctx.print(`Added work plan item ${item.id}.`);
+          return;
+        }
+        if (subcommand === 'remove' || subcommand === 'delete' || subcommand === 'rm') {
+          const id = args[1];
+          if (!id) {
+            ctx.print(`Usage: /workplan ${subcommand} <id>`);
+            return;
+          }
+          const item = store.removeItem(id);
+          ctx.print(`Removed work plan item ${item.id}: ${item.title}`);
+          return;
+        }
+        if (subcommand === 'clear-done' || subcommand === 'clear-completed') {
+          const count = store.clearCompleted();
+          ctx.print(`Cleared ${count} completed/cancelled work plan item${count === 1 ? '' : 's'}.`);
+          return;
+        }
+        if (subcommand === 'cycle' || subcommand === 'toggle') {
+          const id = args[1];
+          if (!id) {
+            ctx.print(`Usage: /workplan ${subcommand} <id>`);
+            return;
+          }
+          const item = store.cycleItemStatus(id);
+          ctx.print(`Updated ${item.id}: ${item.status}.`);
+          return;
+        }
+        const status = STATUS_COMMANDS[subcommand];
+        if (status) {
+          const id = args[1];
+          if (!id) {
+            ctx.print(`Usage: /workplan ${subcommand} <id>`);
+            return;
+          }
+          const item = store.setItemStatus(id, status);
+          ctx.print(`Updated ${item.id}: ${item.status}.`);
+          return;
+        }
+        if (WORK_PLAN_STATUSES.includes(subcommand as WorkPlanItemStatus)) {
+          ctx.print(`Usage: /workplan ${subcommand} <id>`);
+          return;
+        }
+        ctx.print(`Unknown workplan subcommand: ${subcommand}`);
+      } catch (error) {
+        ctx.print(summarizeError(error));
+      }
+    },
+  });
+}