@pellux/goodvibes-tui 0.18.4

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

@@ -0,0 +1,374 @@
+import type { CommandRegistry, CommandContext } from '../command-registry.ts';
+import { join } from 'node:path';
+import { AGENT_TEMPLATES } from '../../tools/agent/manager.ts';
+import { ArchetypeLoader, type AgentArchetype } from '@pellux/goodvibes-sdk/platform/agents/archetypes';
+import { requireOpsApi, requireReadModels, requireShellPaths } from './runtime-services.ts';
+import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils/error-display';
+
+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 createModeTask(mode: TeamworkMode, title: string, ctx: CommandContext): string {
+  const task = requireOpsApi(ctx).tasks.create({
+    kind: mode.taskKind,
+    owner: mode.owner,
+    title,
+    description: JSON.stringify({
+      title,
+      mode: mode.id,
+      template: mode.template,
+      reviewMode: mode.reviewMode,
+      executionProtocol: mode.executionProtocol,
+    }),
+  });
+  return task.id;
+}
+
+function createResolvedModeTask(mode: ResolvedArchetypeMode, title: string, ctx: CommandContext): string {
+  const task = requireOpsApi(ctx).tasks.create({
+    kind: mode.taskKind,
+    owner: mode.owner,
+    title,
+    description: JSON.stringify({
+      title,
+      mode: mode.id,
+      template: mode.template,
+      reviewMode: mode.reviewMode,
+      executionProtocol: mode.executionProtocol,
+      source: mode.source,
+      family: mode.family,
+    }),
+  });
+  return task.id;
+}
+
+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;
+        }
+        try {
+          const taskId = createModeTask(mode, title, ctx);
+          ctx.print(`Created teamwork task ${taskId} using mode ${mode.id}.`);
+        } catch (error) {
+          ctx.print(String(summarizeError(error) ?? error));
+        }
+        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;
+        }
+        try {
+          const taskId = createResolvedModeTask(mode, title, ctx);
+          ctx.print(`Created teamwork task ${taskId} using archetype ${mode.id}.`);
+        } catch (error) {
+          ctx.print(String(summarizeError(error) ?? error));
+        }
+        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 '@pellux/goodvibes-sdk/platform/runtime/remote/types';
+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/worktree-runtime.ts

@@ -0,0 +1,137 @@
+import { getPersistedWorktreeMeta, reviewWorktreeAttachments, summarizeWorktreeOwnership } from '../../runtime/worktree/registry.ts';
+import type { CommandRegistry } from '../command-registry.ts';
+import { openCommandPanel, requireShellPaths } from './runtime-services.ts';
+
+export function registerWorktreeRuntimeCommands(registry: CommandRegistry): void {
+  registry.register({
+    name: 'worktree',
+    aliases: ['worktrees'],
+    description: 'Review and manage orchestrator-owned git worktrees',
+    usage: '[review|panel|inspect <path>|attach <path> <session|task> <id>|session <id>|task <id>|recover <session|task> <id>|pause <path>|resume <path>|keep <path>|discard <path>|cleanup <path>]',
+    async handler(args, ctx) {
+      const sub = (args[0] ?? 'review').toLowerCase();
+      const runtime = ctx.workspace.worktreeRegistry;
+      const shellPaths = requireShellPaths(ctx);
+      if (!runtime) {
+        ctx.print('Worktree registry is not wired into this runtime.');
+        return;
+      }
+      if (sub === 'panel' || sub === 'open') {
+        openCommandPanel(ctx, 'worktrees');
+        return;
+      }
+      if (sub === 'inspect') {
+        const path = args[1];
+        if (!path) {
+          ctx.print('Usage: /worktree inspect <path>');
+          return;
+        }
+        const record = getPersistedWorktreeMeta(path, { workingDirectory: shellPaths.workingDirectory });
+        if (!record) {
+          ctx.print(`Worktree inspect: no tracked worktree metadata for ${path}.`);
+          return;
+        }
+        const nextSteps = [
+          record.state === 'paused' ? `/worktree resume ${record.path}` : null,
+          record.state === 'discard' || record.state === 'cleanup-pending' ? `/worktree cleanup ${record.path}` : null,
+          record.state === 'kept' ? `/worktree keep ${record.path}` : null,
+          record.sessionId ? `/worktree session ${record.sessionId}` : null,
+          record.taskId ? `/worktree task ${record.taskId}` : null,
+        ].filter((value): value is string => Boolean(value));
+        ctx.print([
+          'Worktree Inspect',
+          `  path: ${record.path}`,
+          `  kind: ${record.kind}`,
+          `  state: ${record.state}`,
+          `  owner: ${record.ownerId ?? 'n/a'}`,
+          `  session: ${record.sessionId ?? 'n/a'}`,
+          `  task: ${record.taskId ?? 'n/a'}`,
+          `  updated: ${new Date(record.updatedAt).toLocaleString()}`,
+          ...(nextSteps.length > 0 ? ['  next:', ...nextSteps.map((step) => `    ${step}`)] : ['  next: /worktree review']),
+        ].join('\n'));
+        return;
+      }
+      if (sub === 'attach') {
+        const path = args[1];
+        const targetKind = args[2];
+        const targetId = args[3];
+        if (!path || !targetKind || !targetId || (targetKind !== 'session' && targetKind !== 'task')) {
+          ctx.print('Usage: /worktree attach <path> <session|task> <id>');
+          return;
+        }
+        runtime.attach(path, targetKind === 'session' ? { sessionId: targetId } : { taskId: targetId });
+        ctx.print(`Attached ${path} to ${targetKind} ${targetId}.`);
+        return;
+      }
+      if (sub === 'session' || sub === 'task' || sub === 'recover') {
+        const targetKind = sub === 'recover' ? args[1] : sub;
+        const targetId = sub === 'recover' ? args[2] : args[1];
+        if (!targetId || (targetKind !== 'session' && targetKind !== 'task')) {
+          ctx.print(sub === 'recover'
+            ? 'Usage: /worktree recover <session|task> <id>'
+            : `Usage: /worktree ${sub} <id>`);
+          return;
+        }
+        const review = reviewWorktreeAttachments(targetKind, targetId, { workingDirectory: shellPaths.workingDirectory });
+        const header = sub === 'recover' ? 'Worktree Recovery' : 'Worktree Attachment Review';
+        ctx.print(review.total > 0
+          ? [
+              `${header}: ${targetKind} ${targetId}`,
+              `  total: ${review.total}`,
+              `  active: ${review.active}  paused: ${review.paused}  kept: ${review.kept}  discard: ${review.discard}  cleanup: ${review.cleanupPending}`,
+              ...review.records.map((record) => `  ${record.state.padEnd(15)} ${record.kind.padEnd(12)} ${record.path}`),
+              ...(sub === 'recover'
+                ? [
+                    '  next:',
+                    ...review.records.map((record) => `    /worktree ${record.state === 'paused' ? 'resume' : 'keep'} ${record.path}`),
+                    `    /${targetKind === 'session' ? 'session info' : 'task status'} ${targetId}`,
+                  ]
+                : []),
+            ].join('\n')
+          : `${header}: ${targetKind} ${targetId}\n  No attached worktrees tracked.`);
+        return;
+      }
+      if (sub === 'pause' || sub === 'resume' || sub === 'keep' || sub === 'discard') {
+        const path = args[1];
+        if (!path) {
+          ctx.print(`Usage: /worktree ${sub} <path>`);
+          return;
+        }
+        const nextState = sub === 'resume'
+          ? 'active'
+          : sub === 'pause'
+            ? 'paused'
+            : sub === 'keep'
+              ? 'kept'
+              : 'discard';
+        runtime.setState(path, nextState);
+        ctx.print(`Updated ${path} to state ${nextState}.`);
+        return;
+      }
+      if (sub === 'cleanup') {
+        const path = args[1];
+        if (!path) {
+          ctx.print('Usage: /worktree cleanup <path>');
+          return;
+        }
+        await runtime.cleanup(path);
+        ctx.print(`Cleaned up worktree ${path}.`);
+        return;
+      }
+      const rows = await runtime.list();
+      const summary = summarizeWorktreeOwnership(rows);
+      ctx.print(rows.length > 0
+        ? [
+            'Worktree Review',
+            `  total: ${summary.total}`,
+            `  active: ${summary.active}  paused: ${summary.paused}  kept: ${summary.kept}  discard: ${summary.discard}`,
+            `  session attached: ${summary.sessionAttached}  task attached: ${summary.taskAttached}`,
+            `  agent owned: ${summary.agentOwned}  orchestrator owned: ${summary.orchestratorOwned}  manual: ${summary.manualOwned}`,
+            ...rows.map((row) => (
+              `  ${row.kind.padEnd(12)} ${row.state.padEnd(15)} ${row.branch.padEnd(22)} session=${(row.sessionId ?? '-').padEnd(12)} task=${(row.taskId ?? '-').padEnd(12)} ${row.path}`
+            )),
+          ].join('\n')
+        : 'Worktree Review\n  No worktrees discovered.');
+    },
+  });
+}