@pellux/goodvibes-agent 0.1.58 → 0.1.60

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

@@ -1,223 +0,0 @@
-import { existsSync, readFileSync } from 'node:fs';
-import { resolve } from 'node:path';
-import type { CommandContext, CommandRegistry } from '../command-registry.ts';
-import { CodeIntelligence } from '@pellux/goodvibes-sdk/platform/intelligence';
-import type { DocumentSymbol } from '@pellux/goodvibes-sdk/platform/intelligence';
-import type { SymbolInfo } from '@pellux/goodvibes-sdk/platform/intelligence';
-import { openCommandPanel, requireReadModels, requireShellPaths } from './runtime-services.ts';
-
-function resolveTargetPath(pathArg: string, ctx: CommandContext): string {
-  return requireShellPaths(ctx).resolveWorkspacePath(pathArg);
-}
-
-function parsePosition(lineArg: string | undefined, columnArg: string | undefined): { line: number; column: number } | null {
-  const line = Number.parseInt(lineArg ?? '', 10);
-  const column = Number.parseInt(columnArg ?? '', 10);
-  if (!Number.isFinite(line) || line < 1 || !Number.isFinite(column) || column < 1) return null;
-  return { line: line - 1, column: column - 1 };
-}
-
-function formatSymbolKind(kind: number | string | undefined): string {
-  if (typeof kind === 'number') return `kind=${kind}`;
-  if (typeof kind === 'string' && kind.trim().length > 0) return kind;
-  return 'symbol';
-}
-
-function formatDocumentSymbol(symbol: DocumentSymbol): string {
-  const line = (symbol.selectionRange?.start.line ?? symbol.range.start.line) + 1;
-  const column = (symbol.selectionRange?.start.character ?? symbol.range.start.character) + 1;
-  return `  ${symbol.name}  ${formatSymbolKind(symbol.kind)}  ${line}:${column}`;
-}
-
-function formatTreeSitterSymbol(symbol: SymbolInfo): string {
-  return `  ${symbol.name}  ${formatSymbolKind(symbol.kind)}  ${symbol.line + 1}:${symbol.column + 1}`;
-}
-
-function ensureExistingFile(pathArg: string | undefined, ctx: CommandContext): string | null {
-  if (!pathArg) {
-    ctx.print('Intelligence Review\n  Missing file path.');
-    return null;
-  }
-  const targetPath = resolveTargetPath(pathArg, ctx);
-  if (!existsSync(targetPath)) {
-    ctx.print(`Intelligence Review\n  File not found: ${targetPath}`);
-    return null;
-  }
-  return targetPath;
-}
-
-export function registerIntelligenceRuntimeCommands(registry: CommandRegistry): void {
-  registry.register({
-    name: 'intelligence',
-    aliases: ['intel'],
-    description: 'Review workspace intelligence readiness, diagnostics posture, and symbol search availability',
-    usage: '[review|panel|diagnostics [file]|symbols <file>|outline <file>|definition <file> <line> <column>|references <file> <line> <column>|hover <file> <line> <column>|repair]',
-    async handler(args, ctx) {
-      const sub = (args[0] ?? 'review').toLowerCase();
-      if (sub === 'panel' || sub === 'open') {
-        openCommandPanel(ctx, 'intelligence');
-        return;
-      }
-
-      const intelligence = new CodeIntelligence();
-      const state = requireReadModels(ctx).intelligence.getSnapshot();
-
-      if (sub === 'symbols' || sub === 'outline') {
-        const targetPath = ensureExistingFile(args[1], ctx);
-        if (!targetPath) return;
-        const content = readFileSync(targetPath, 'utf-8');
-        if (sub === 'symbols') {
-          const symbols = await intelligence.getDocumentSymbols(targetPath, content);
-          const entries = symbols.slice(0, 12).map((symbol) => ('selectionRange' in symbol ? formatDocumentSymbol(symbol) : formatTreeSitterSymbol(symbol)));
-          ctx.print([
-            `Intelligence Symbols: ${targetPath}`,
-            `  source: ${state.symbolSearchStatus === 'ready' ? 'LSP/tree-sitter' : 'best-effort tree-sitter/LSP fallback'}`,
-            `  status: ${state.symbolSearchStatus}`,
-            `  results: ${symbols.length}`,
-            ...(entries.length > 0 ? entries : ['  No symbols available for this file.']),
-            '  next: /health intelligence',
-          ].join('\n'));
-          return;
-        }
-
-        const outline = await intelligence.getOutline(targetPath, content);
-        ctx.print([
-          `Intelligence Outline: ${targetPath}`,
-          `  source: tree-sitter outline extraction`,
-          `  language ready: ${intelligence.hasTreeSitter(targetPath) ? 'yes' : 'no'}`,
-          `  results: ${outline.length}`,
-          ...(outline.slice(0, 12).map((entry) => `  ${entry.signature || entry.name}  line ${entry.line}`)),
-          ...(outline.length === 0 ? ['  No outline entries available for this file.'] : []),
-          '  next: /intelligence symbols ' + targetPath,
-        ].join('\n'));
-        return;
-      }
-
-      if (sub === 'definition' || sub === 'references' || sub === 'hover') {
-        const targetPath = ensureExistingFile(args[1], ctx);
-        if (!targetPath) return;
-        const position = parsePosition(args[2], args[3]);
-        if (!position) {
-          ctx.print(`Intelligence ${sub[0]!.toUpperCase()}${sub.slice(1)}\n  Usage: /intelligence ${sub} <file> <line> <column>`);
-          return;
-        }
-
-        if (sub === 'definition') {
-          const definition = await intelligence.getDefinition(targetPath, position.line, position.column);
-          ctx.print([
-            `Intelligence Definition: ${targetPath}:${position.line + 1}:${position.column + 1}`,
-            `  status: ${state.hoverStatus === 'ready' || state.symbolSearchStatus === 'ready' ? 'available' : 'best-effort'}`,
-            ...(definition
-              ? [
-                  `  target: ${definition.uri}`,
-                  `  line: ${definition.range.start.line + 1}`,
-                  `  column: ${definition.range.start.character + 1}`,
-                  '  next: open the target file or use /intelligence references on the same symbol',
-                ]
-              : ['  No definition was returned for that position.', '  next: /health intelligence']),
-          ].join('\n'));
-          return;
-        }
-
-        if (sub === 'references') {
-          const references = await intelligence.getReferences(targetPath, position.line, position.column);
-          ctx.print([
-            `Intelligence References: ${targetPath}:${position.line + 1}:${position.column + 1}`,
-            `  status: ${state.symbolSearchStatus}`,
-            `  results: ${references.length}`,
-            ...(references.slice(0, 12).map((reference) => `  ${reference.uri}  ${reference.range.start.line + 1}:${reference.range.start.character + 1}`)),
-            ...(references.length === 0 ? ['  No references were returned for that position.'] : []),
-            '  next: /intelligence definition ' + `${targetPath} ${position.line + 1} ${position.column + 1}`,
-          ].join('\n'));
-          return;
-        }
-
-        const hover = await intelligence.getHover(targetPath, position.line, position.column);
-        const hoverLines = typeof hover?.contents === 'string'
-          ? hover.contents.split('\n')
-          : Array.isArray(hover?.contents)
-            ? hover.contents.flatMap((entry) => typeof entry === 'string' ? entry : entry.value.split('\n'))
-            : hover?.contents && 'value' in hover.contents
-              ? hover.contents.value.split('\n')
-              : [];
-        ctx.print([
-          `Intelligence Hover: ${targetPath}:${position.line + 1}:${position.column + 1}`,
-          `  status: ${state.hoverStatus}`,
-          ...(hoverLines.length > 0 ? hoverLines.slice(0, 8).map((line) => `  ${line}`) : ['  No hover information was returned for that position.']),
-          '  next: /health intelligence',
-        ].join('\n'));
-        return;
-      }
-
-      if (sub === 'diagnostics') {
-        const file = args[1];
-        const entries = [...state.diagnostics.entries()]
-          .map(([filePath, diagnostics]) => ({
-            filePath,
-            diagnostics,
-            errors: diagnostics.filter((entry) => entry.severity === 'error').length,
-            warnings: diagnostics.filter((entry) => entry.severity === 'warning').length,
-          }))
-          .sort((a, b) => (b.errors - a.errors) || (b.warnings - a.warnings) || a.filePath.localeCompare(b.filePath));
-        const selected = file
-          ? entries.find((entry) => entry.filePath === file)
-          : entries[0];
-        if (!selected) {
-          ctx.print('Intelligence Diagnostics\n  No diagnostics are currently tracked.');
-          return;
-        }
-        ctx.print([
-          `Intelligence Diagnostics: ${selected.filePath}`,
-          `  errors: ${selected.errors}`,
-          `  warnings: ${selected.warnings}`,
-          ...selected.diagnostics.slice(0, 8).map((diagnostic) => (
-            `  [${diagnostic.severity}] ${diagnostic.line + 1}:${diagnostic.column + 1} ${diagnostic.message}`
-          )),
-          ...(entries.length > 1 ? [`  next: /intelligence diagnostics ${entries[1]!.filePath}`] : []),
-        ].join('\n'));
-        return;
-      }
-
-      if (sub === 'repair') {
-        const lines = [
-          'Intelligence Repair',
-          '  verify: /health intelligence',
-          ...(state.diagnosticsStatus !== 'ready' ? ['  /setup review', '  /health intelligence'] : []),
-          ...(state.symbolSearchStatus !== 'ready' ? ['  /symbols', '  /intelligence symbols <file>', '  /health intelligence'] : []),
-          ...(state.completionsStatus !== 'ready' || state.hoverStatus !== 'ready'
-            ? ['  /intelligence review', '  /intelligence hover <file> <line> <column>', '  /setup onboarding']
-            : []),
-        ];
-        ctx.print(lines.length > 1 ? lines.join('\n') : 'Intelligence Repair\n  No active repair actions suggested.');
-        return;
-      }
-
-      const issues: string[] = [];
-      if (state.diagnosticsStatus !== 'ready') issues.push(`diagnostics=${state.diagnosticsStatus}`);
-      if (state.symbolSearchStatus !== 'ready') issues.push(`symbols=${state.symbolSearchStatus}`);
-      if (state.completionsStatus !== 'ready') issues.push(`completions=${state.completionsStatus}`);
-      if (state.hoverStatus !== 'ready') issues.push(`hover=${state.hoverStatus}`);
-
-      ctx.print([
-        'Intelligence Review',
-        `  diagnostics: ${state.diagnosticsStatus}`,
-        `  symbols: ${state.symbolSearchStatus}`,
-        `  completions: ${state.completionsStatus}`,
-        `  hover: ${state.hoverStatus}`,
-        `  errors: ${state.errorCount}`,
-        `  warnings: ${state.warningCount}`,
-        `  requests: ${state.totalRequests}`,
-        `  avg latency: ${Math.round(state.avgLatencyMs)}ms`,
-        ...(issues.length > 0 ? [`  issues: ${issues.join(', ')}`] : ['  issues: none']),
-        `  diagnostic files: ${state.diagnostics.size}`,
-        ...(state.diagnostics.size > 0 ? ['  next: /intelligence diagnostics'] : []),
-        '  next: /intelligence symbols <file>',
-        '  next: /intelligence outline <file>',
-        '  next: /intelligence references <file> <line> <column>',
-        '  next: /intelligence definition <file> <line> <column>',
-        '  next: /intelligence hover <file> <line> <column>',
-        '  next: /intelligence repair',
-      ].join('\n'));
-    },
-  });
-}

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

@@ -1,339 +0,0 @@
-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...>]');
-    },
-  });
-}