cognitive-core 0.2.5 → 0.3.1

package/src/workspace/templates/team-playbook-extraction.ts

@@ -1,631 +0,0 @@
-/**
- * Team Playbook Extraction Template
- *
- * Batch extraction of team coordination playbooks and role playbooks
- * from accumulated team analysis results. The team-level analog of
- * playbook-extraction.ts.
- *
- * - Small batches → heuristic extraction
- * - Larger batches → agent semantically identifies coordination patterns
- */
-
-import type { WorkspaceHandle } from 'agent-workspace';
-import type {
-  TeamPlaybook,
-  RolePlaybook,
-  TeamMetaStrategy,
-} from '../../types/index.js';
-import {
-  createTeamPlaybook,
-  createRolePlaybook,
-  createTeamMetaStrategy,
-} from '../../types/index.js';
-import type { TeamAnalysisResult } from '../../memory/team-experience.js';
-import type { TeamTrajectory, AgentInteraction } from '../../types/index.js';
-import type {
-  AgenticTaskTemplate,
-  AnalysisComplexity,
-} from '../types.js';
-import type { ComputeRequirements } from '../../runtime/compute-provider.js';
-
-// ============================================================
-// Input / Output Types
-// ============================================================
-
-export interface TeamPlaybookExtractionInput {
-  /** Accumulated team analyses from the pipeline */
-  analyses: Array<{
-    teamTrajectory: TeamTrajectory;
-    analysis: TeamAnalysisResult;
-  }>;
-  /** Existing team playbooks for deduplication */
-  existingTeamPlaybooks: TeamPlaybook[];
-  /** Existing role playbooks for deduplication */
-  existingRolePlaybooks: RolePlaybook[];
-}
-
-export interface TeamPlaybookExtractionOutput {
-  newTeamPlaybooks: TeamPlaybook[];
-  newRolePlaybooks: RolePlaybook[];
-  newMetaStrategies: TeamMetaStrategy[];
-  teamPlaybookUpdates: TeamPlaybookUpdate[];
-  rolePlaybookUpdates: RolePlaybookUpdate[];
-}
-
-export interface TeamPlaybookUpdate {
-  id: string;
-  refinementContext: string;
-  refinementAddition: string;
-}
-
-export interface RolePlaybookUpdate {
-  id: string;
-  refinementContext: string;
-  refinementAddition: string;
-}
-
-// ============================================================
-// Helpers
-// ============================================================
-
-/**
- * Summarize step-level interactions for workspace serialization.
- */
-function summarizeInteractions(interactions: AgentInteraction[]): {
-  totalCount: number;
-  byType: Record<string, number>;
-  byRolePair: Array<{ from: string; to: string; count: number; types: string[] }>;
-  unexpectedCount: number;
-} {
-  const byType: Record<string, number> = {};
-  const rolePairMap = new Map<string, { from: string; to: string; count: number; types: Set<string> }>();
-  let unexpectedCount = 0;
-
-  for (const interaction of interactions) {
-    byType[interaction.type] = (byType[interaction.type] ?? 0) + 1;
-    if (!interaction.wasExpected) unexpectedCount++;
-
-    const key = `${interaction.from.role}->${interaction.to.role}`;
-    if (!rolePairMap.has(key)) {
-      rolePairMap.set(key, { from: interaction.from.role, to: interaction.to.role, count: 0, types: new Set() });
-    }
-    const pair = rolePairMap.get(key)!;
-    pair.count++;
-    pair.types.add(interaction.type);
-  }
-
-  return {
-    totalCount: interactions.length,
-    byType,
-    byRolePair: [...rolePairMap.values()].map(p => ({
-      from: p.from, to: p.to, count: p.count, types: [...p.types],
-    })),
-    unexpectedCount,
-  };
-}
-
-/**
- * Extract interaction patterns from successful entries using graph data when available.
- */
-function extractInteractionPatterns(
-  entries: Array<{ teamTrajectory: TeamTrajectory; analysis: TeamAnalysisResult }>
-): Array<{ name: string; description: string; roles: string[]; frequency: 'once' | 'per-task' | 'continuous'; correlatedWithSuccess: boolean }> {
-  const patterns: Array<{ name: string; description: string; roles: string[]; frequency: 'once' | 'per-task' | 'continuous'; correlatedWithSuccess: boolean }> = [];
-
-  // Collect interaction type counts across entries
-  const typeCounts = new Map<string, { count: number; rolePairs: Set<string> }>();
-
-  for (const entry of entries) {
-    for (const interaction of entry.teamTrajectory.interactions) {
-      const key = `${interaction.type}:${interaction.from.role}->${interaction.to.role}`;
-      if (!typeCounts.has(key)) {
-        typeCounts.set(key, { count: 0, rolePairs: new Set() });
-      }
-      const tc = typeCounts.get(key)!;
-      tc.count++;
-      tc.rolePairs.add(interaction.from.role);
-      tc.rolePairs.add(interaction.to.role);
-    }
-  }
-
-  // Convert frequent patterns to interaction patterns
-  for (const [key, data] of typeCounts) {
-    if (data.count < 2) continue;
-    const [type, rolePair] = key.split(':');
-    patterns.push({
-      name: `${type}-${rolePair}`,
-      description: `${type} interaction from ${rolePair} observed ${data.count} times`,
-      roles: [...data.rolePairs],
-      frequency: data.count > entries.length * 2 ? 'continuous' : 'per-task',
-      correlatedWithSuccess: true,
-    });
-  }
-
-  return patterns.slice(0, 10); // Limit to top 10
-}
-
-// ============================================================
-// Heuristic Fallback
-// ============================================================
-
-function heuristicTeamPlaybookExtraction(
-  input: TeamPlaybookExtractionInput
-): TeamPlaybookExtractionOutput {
-  const newTeamPlaybooks: TeamPlaybook[] = [];
-  const newRolePlaybooks: RolePlaybook[] = [];
-
-  // Group analyses by topology type
-  const byTopology = new Map<string, typeof input.analyses>();
-  for (const entry of input.analyses) {
-    const topo = entry.teamTrajectory.topologyType;
-    if (!byTopology.has(topo)) byTopology.set(topo, []);
-    byTopology.get(topo)!.push(entry);
-  }
-
-  // For each topology with enough data, try to extract a team playbook
-  for (const [topology, entries] of byTopology) {
-    const successfulEntries = entries.filter(
-      (e) => e.teamTrajectory.outcome.success
-    );
-    if (successfulEntries.length < 2) continue;
-
-    // Extract common domains
-    const domains = [
-      ...new Set(successfulEntries.map((e) => e.teamTrajectory.domain)),
-    ];
-
-    // Extract common roles
-    const roleCounts = new Map<string, number>();
-    for (const entry of successfulEntries) {
-      for (const role of entry.teamTrajectory.roles) {
-        roleCounts.set(role, (roleCounts.get(role) ?? 0) + 1);
-      }
-    }
-    const commonRoles = [...roleCounts.entries()]
-      .filter(([, count]) => count >= successfulEntries.length * 0.5)
-      .map(([role]) => role);
-
-    // Build team playbook
-    const teamPlaybook = createTeamPlaybook({
-      name: `${topology}-${domains[0] ?? 'general'}-pattern`,
-      applicability: {
-        taskTypes: [...new Set(successfulEntries.map((e) => e.teamTrajectory.complexity))],
-        teamSizeRange: {
-          min: Math.min(...successfulEntries.map((e) => e.teamTrajectory.teamSize)),
-          max: Math.max(...successfulEntries.map((e) => e.teamTrajectory.teamSize)),
-        },
-        complexityLevels: [...new Set(successfulEntries.map((e) => e.teamTrajectory.complexity))],
-        domains,
-        antiPatterns: [],
-      },
-      composition: {
-        topology: topology as TeamPlaybook['composition']['topology'],
-        roles: commonRoles.map((role) => ({
-          role,
-          rationale: `Observed in ${roleCounts.get(role)} successful executions`,
-          capabilities: [],
-          optional: roleCounts.get(role)! < successfulEntries.length,
-          spawnAs: 'root' as const,
-        })),
-        spawnRules: {},
-        enforcement: successfulEntries[0].teamTrajectory.enforcement,
-      },
-      coordination: {
-        executionModel: topology === 'wave' ? 'wave-parallel' : 'sequential',
-        channels: [],
-        interactionPatterns: extractInteractionPatterns(successfulEntries),
-        delegationStrategy: 'inferred from successful executions',
-      },
-      evolution: {
-        version: '1.0.0',
-        createdFrom: successfulEntries.map((e) => e.teamTrajectory.id),
-        refinements: [],
-        successCount: successfulEntries.length,
-        failureCount: entries.length - successfulEntries.length,
-      },
-      confidence: Math.min(0.3 + successfulEntries.length * 0.1, 0.8),
-    });
-
-    // Skip if similar playbook already exists
-    const isDuplicate = input.existingTeamPlaybooks.some(
-      (p) => p.composition.topology === topology && p.applicability.domains.some((d) => domains.includes(d))
-    );
-    if (!isDuplicate) {
-      newTeamPlaybooks.push(teamPlaybook);
-    }
-  }
-
-  // Extract role playbooks from successful role lessons
-  const roleLessonsMap = new Map<string, {
-    strengths: string[];
-    improvements: string[];
-    count: number;
-    trajectoryIds: string[];
-    topologies: Set<string>;
-    domains: Set<string>;
-  }>();
-
-  for (const entry of input.analyses) {
-    if (!entry.teamTrajectory.outcome.success) continue;
-    for (const lesson of entry.analysis.roleLessons) {
-      if (!roleLessonsMap.has(lesson.role)) {
-        roleLessonsMap.set(lesson.role, {
-          strengths: [],
-          improvements: [],
-          count: 0,
-          trajectoryIds: [],
-          topologies: new Set(),
-          domains: new Set(),
-        });
-      }
-      const acc = roleLessonsMap.get(lesson.role)!;
-      acc.strengths.push(...lesson.strengths);
-      acc.improvements.push(...lesson.improvements);
-      acc.count++;
-      acc.trajectoryIds.push(entry.teamTrajectory.id);
-      acc.topologies.add(entry.teamTrajectory.topologyType);
-      acc.domains.add(entry.teamTrajectory.domain);
-    }
-  }
-
-  for (const [role, data] of roleLessonsMap) {
-    if (data.count < 2) continue;
-
-    const isDuplicate = input.existingRolePlaybooks.some((p) => p.role === role);
-    if (isDuplicate) continue;
-
-    const rolePlaybook = createRolePlaybook({
-      name: `effective-${role}`,
-      role,
-      teamContext: {
-        topologies: [...data.topologies] as RolePlaybook['teamContext']['topologies'],
-        teamSizeRange: { min: 2, max: 10 },
-        taskTypes: [],
-        domains: [...data.domains],
-      },
-      guidance: {
-        responsibilities: [...new Set(data.strengths)].slice(0, 5),
-        interactionGuidance: [],
-        decisionFrameworks: [],
-        antiPatterns: [...new Set(data.improvements)].slice(0, 3),
-      },
-      evolution: {
-        version: '1.0.0',
-        createdFrom: data.trajectoryIds,
-        refinements: [],
-        successCount: data.count,
-        failureCount: 0,
-      },
-      confidence: Math.min(0.3 + data.count * 0.1, 0.7),
-    });
-
-    newRolePlaybooks.push(rolePlaybook);
-  }
-
-  // Cross-pollination: link team playbooks to role playbooks
-  for (const teamPb of newTeamPlaybooks) {
-    const roleRefs = newRolePlaybooks
-      .filter((rp) => teamPb.composition.roles.some((r) => r.role === rp.role))
-      .map((rp) => ({ role: rp.role, suggestedPlaybookIds: [rp.id] }));
-    if (roleRefs.length > 0) {
-      teamPb.rolePlaybookReferences = roleRefs;
-    }
-  }
-
-  // Cross-pollination: link role playbooks to their source team playbooks
-  for (const rolePb of newRolePlaybooks) {
-    const relatedTeam = newTeamPlaybooks.find((tp) =>
-      tp.composition.roles.some((r) => r.role === rolePb.role)
-    );
-    if (relatedTeam) {
-      rolePb.relatedTaskPlaybooks = [{
-        playbookId: relatedTeam.id,
-        playbookName: relatedTeam.name,
-        applicableToTask: relatedTeam.applicability.taskTypes.join(', ') || 'general',
-        rationale: `Role ${rolePb.role} is part of ${relatedTeam.name} team pattern`,
-      }];
-    }
-  }
-
-  return {
-    newTeamPlaybooks,
-    newRolePlaybooks,
-    newMetaStrategies: [],
-    teamPlaybookUpdates: [],
-    rolePlaybookUpdates: [],
-  };
-}
-
-// ============================================================
-// Template Implementation
-// ============================================================
-
-export const teamPlaybookExtractionTemplate: AgenticTaskTemplate<
-  TeamPlaybookExtractionInput,
-  TeamPlaybookExtractionOutput
-> = {
-  taskType: 'team-playbook-extraction',
-  domain: 'team-playbook-extraction',
-  description: 'Extract team coordination playbooks and role playbooks from accumulated team analyses',
-
-  assessComplexity(input: TeamPlaybookExtractionInput): AnalysisComplexity {
-    if (input.analyses.length <= 3) return 'heuristic';
-    if (input.analyses.length > 10) return 'thorough';
-    return 'standard';
-  },
-
-  async heuristicFallback(
-    input: TeamPlaybookExtractionInput
-  ): Promise<TeamPlaybookExtractionOutput> {
-    return heuristicTeamPlaybookExtraction(input);
-  },
-
-  async prepareWorkspace(
-    input: TeamPlaybookExtractionInput,
-    handle: WorkspaceHandle
-  ): Promise<void> {
-    // Write summary
-    const successCount = input.analyses.filter(
-      (a) => a.teamTrajectory.outcome.success
-    ).length;
-    const topologies = [...new Set(input.analyses.map((a) => a.teamTrajectory.topologyType))];
-    const domains = [...new Set(input.analyses.map((a) => a.teamTrajectory.domain))];
-
-    await handle.writeJson('input', 'summary.json', {
-      batchSize: input.analyses.length,
-      successRate: input.analyses.length > 0 ? successCount / input.analyses.length : 0,
-      topologies,
-      domains,
-      existingTeamPlaybookCount: input.existingTeamPlaybooks.length,
-      existingRolePlaybookCount: input.existingRolePlaybooks.length,
-    });
-
-    // Write each analysis batch entry (include graph data when available)
-    for (const entry of input.analyses) {
-      const batchData: Record<string, unknown> = {
-        id: entry.teamTrajectory.id,
-        objective: entry.teamTrajectory.objective,
-        domain: entry.teamTrajectory.domain,
-        topologyType: entry.teamTrajectory.topologyType,
-        roles: entry.teamTrajectory.roles,
-        teamSize: entry.teamTrajectory.teamSize,
-        enforcement: entry.teamTrajectory.enforcement,
-        complexity: entry.teamTrajectory.complexity,
-        outcome: entry.teamTrajectory.outcome,
-        agentCredits: entry.analysis.agentCredits,
-        coordinationAssessment: entry.analysis.coordinationAssessment,
-        roleLessons: entry.analysis.roleLessons,
-        teamLessons: entry.analysis.teamLessons,
-        metaObservation: entry.analysis.metaObservation,
-        interactionSummary: summarizeInteractions(entry.teamTrajectory.interactions),
-        graphMetrics: entry.teamTrajectory.graphMetrics,
-      };
-
-      await handle.writeJson(
-        'input',
-        `lesson-batches/${entry.teamTrajectory.id}.json`,
-        batchData
-      );
-    }
-
-    // Write existing playbooks for deduplication
-    for (const pb of input.existingTeamPlaybooks) {
-      await handle.writeJson('input', `existing-team-playbooks/${pb.id}.json`, {
-        id: pb.id,
-        name: pb.name,
-        topology: pb.composition.topology,
-        domains: pb.applicability.domains,
-        taskTypes: pb.applicability.taskTypes,
-        successCount: pb.evolution.successCount,
-        failureCount: pb.evolution.failureCount,
-      });
-    }
-
-    for (const pb of input.existingRolePlaybooks) {
-      await handle.writeJson('input', `existing-role-playbooks/${pb.id}.json`, {
-        id: pb.id,
-        name: pb.name,
-        role: pb.role,
-        topologies: pb.teamContext.topologies,
-        domains: pb.teamContext.domains,
-      });
-    }
-  },
-
-  buildTaskPrompt(input: TeamPlaybookExtractionInput): string {
-    return [
-      `Extract team coordination playbooks and role playbooks from ${input.analyses.length} team execution analyses.`,
-      '',
-      'Read input/summary.json for batch overview.',
-      'Read input/lesson-batches/*.json for individual team execution data.',
-      'Read input/existing-team-playbooks/*.json and input/existing-role-playbooks/*.json to avoid duplication.',
-      '',
-      'Look for:',
-      '1. **Team Coordination Patterns**: How teams should be composed and coordinated for specific task types',
-      '2. **Role-Specific Guidance**: How to be effective in specific team roles',
-      '3. **Meta-Strategies**: Patterns about when to use which team formation',
-      '',
-      'Write results to output/extraction.json with this schema:',
-      '```json',
-      '{',
-      '  "teamPlaybooks": [{ "name": string, "topology": string, "taskTypes": string[], "domains": string[], "roles": [{ "role": string, "rationale": string, "optional": boolean }], "executionModel": string, "delegationStrategy": string, "interactionPatterns": [{ "name": string, "description": string, "correlatedWithSuccess": boolean }], "confidence": 0-1 }],',
-      '  "rolePlaybooks": [{ "name": string, "role": string, "topologies": string[], "domains": string[], "responsibilities": string[], "interactionGuidance": [{ "withRole": string, "guidance": string }], "antiPatterns": string[], "confidence": 0-1 }],',
-      '  "metaStrategies": [{ "name": string, "taskCharacteristics": string[], "domains": string[], "teamSizeAdjustment": "increase"|"decrease"|"maintain", "roleAdjustments": string[], "coordinationHints": string[] }],',
-      '  "teamPlaybookUpdates": [{ "id": string, "refinementContext": string, "refinementAddition": string }],',
-      '  "rolePlaybookUpdates": [{ "id": string, "refinementContext": string, "refinementAddition": string }]',
-      '}',
-      '```',
-    ].join('\n');
-  },
-
-  getSkills() { return []; },
-  getResources() { return []; },
-
-  outputConfig: {
-    files: [
-      {
-        path: 'extraction.json',
-        format: 'json' as const,
-        required: true,
-        description: 'Extracted team playbooks, role playbooks, meta-strategies, and updates',
-      },
-    ],
-  },
-
-  async collectOutput(handle: WorkspaceHandle): Promise<TeamPlaybookExtractionOutput> {
-    const raw = await handle.readJson('output', 'extraction.json') as Record<string, unknown>;
-
-    // Parse team playbooks
-    const newTeamPlaybooks: TeamPlaybook[] = [];
-    if (Array.isArray(raw.teamPlaybooks)) {
-      for (const item of raw.teamPlaybooks as Record<string, unknown>[]) {
-        newTeamPlaybooks.push(createTeamPlaybook({
-          name: String(item.name ?? 'unnamed-team-playbook'),
-          applicability: {
-            taskTypes: Array.isArray(item.taskTypes) ? item.taskTypes.map(String) : [],
-            teamSizeRange: { min: 2, max: 10 },
-            complexityLevels: ['moderate', 'complex'],
-            domains: Array.isArray(item.domains) ? item.domains.map(String) : [],
-            antiPatterns: [],
-          },
-          composition: {
-            topology: (['hierarchical', 'flat', 'wave', 'custom'].includes(String(item.topology))
-              ? String(item.topology)
-              : 'flat') as TeamPlaybook['composition']['topology'],
-            roles: Array.isArray(item.roles)
-              ? (item.roles as Record<string, unknown>[]).map((r) => ({
-                  role: String(r.role ?? ''),
-                  rationale: String(r.rationale ?? ''),
-                  capabilities: [],
-                  optional: Boolean(r.optional),
-                  spawnAs: 'root' as const,
-                }))
-              : [],
-            spawnRules: {},
-            enforcement: 'permissive',
-          },
-          coordination: {
-            executionModel: (['sequential', 'wave-parallel', 'fully-parallel', 'pipeline'].includes(String(item.executionModel))
-              ? String(item.executionModel)
-              : 'sequential') as TeamPlaybook['coordination']['executionModel'],
-            channels: [],
-            interactionPatterns: Array.isArray(item.interactionPatterns)
-              ? (item.interactionPatterns as Record<string, unknown>[]).map((p) => ({
-                  name: String(p.name ?? ''),
-                  description: String(p.description ?? ''),
-                  roles: [],
-                  frequency: 'per-task' as const,
-                  correlatedWithSuccess: Boolean(p.correlatedWithSuccess),
-                }))
-              : [],
-            delegationStrategy: String(item.delegationStrategy ?? ''),
-          },
-          confidence: typeof item.confidence === 'number' ? item.confidence : 0.5,
-        }));
-      }
-    }
-
-    // Parse role playbooks
-    const newRolePlaybooks: RolePlaybook[] = [];
-    if (Array.isArray(raw.rolePlaybooks)) {
-      for (const item of raw.rolePlaybooks as Record<string, unknown>[]) {
-        newRolePlaybooks.push(createRolePlaybook({
-          name: String(item.name ?? 'unnamed-role-playbook'),
-          role: String(item.role ?? ''),
-          teamContext: {
-            topologies: (Array.isArray(item.topologies) ? item.topologies.map(String) : ['flat']) as RolePlaybook['teamContext']['topologies'],
-            teamSizeRange: { min: 2, max: 10 },
-            taskTypes: [],
-            domains: Array.isArray(item.domains) ? item.domains.map(String) : [],
-          },
-          guidance: {
-            responsibilities: Array.isArray(item.responsibilities) ? item.responsibilities.map(String) : [],
-            interactionGuidance: Array.isArray(item.interactionGuidance)
-              ? (item.interactionGuidance as Record<string, unknown>[]).map((ig) => ({
-                  withRole: String(ig.withRole ?? ''),
-                  interactionType: 'coordination',
-                  guidance: String(ig.guidance ?? ''),
-                  examples: [],
-                  antiPatterns: [],
-                }))
-              : [],
-            decisionFrameworks: [],
-            antiPatterns: Array.isArray(item.antiPatterns) ? item.antiPatterns.map(String) : [],
-          },
-          confidence: typeof item.confidence === 'number' ? item.confidence : 0.5,
-        }));
-      }
-    }
-
-    // Parse meta-strategies
-    const newMetaStrategies: TeamMetaStrategy[] = [];
-    if (Array.isArray(raw.metaStrategies)) {
-      for (const item of raw.metaStrategies as Record<string, unknown>[]) {
-        newMetaStrategies.push(createTeamMetaStrategy({
-          name: String(item.name ?? 'unnamed-strategy'),
-          condition: {
-            taskCharacteristics: Array.isArray(item.taskCharacteristics) ? item.taskCharacteristics.map(String) : [],
-            resourceConstraints: [],
-            domains: Array.isArray(item.domains) ? item.domains.map(String) : [],
-          },
-          adjustment: {
-            teamSizeAdjustment: (['increase', 'decrease', 'maintain'].includes(String(item.teamSizeAdjustment))
-              ? String(item.teamSizeAdjustment)
-              : 'maintain') as 'increase' | 'decrease' | 'maintain',
-            roleAdjustments: Array.isArray(item.roleAdjustments) ? item.roleAdjustments.map(String) : [],
-            coordinationHints: Array.isArray(item.coordinationHints) ? item.coordinationHints.map(String) : [],
-          },
-        }));
-      }
-    }
-
-    // Parse updates
-    const teamPlaybookUpdates: TeamPlaybookUpdate[] = Array.isArray(raw.teamPlaybookUpdates)
-      ? (raw.teamPlaybookUpdates as Record<string, unknown>[]).map((u) => ({
-          id: String(u.id ?? ''),
-          refinementContext: String(u.refinementContext ?? ''),
-          refinementAddition: String(u.refinementAddition ?? ''),
-        }))
-      : [];
-
-    const rolePlaybookUpdates: RolePlaybookUpdate[] = Array.isArray(raw.rolePlaybookUpdates)
-      ? (raw.rolePlaybookUpdates as Record<string, unknown>[]).map((u) => ({
-          id: String(u.id ?? ''),
-          refinementContext: String(u.refinementContext ?? ''),
-          refinementAddition: String(u.refinementAddition ?? ''),
-        }))
-      : [];
-
-    return {
-      newTeamPlaybooks,
-      newRolePlaybooks,
-      newMetaStrategies,
-      teamPlaybookUpdates,
-      rolePlaybookUpdates,
-    };
-  },
-
-  async processOutput(): Promise<void> {
-    // Pipeline handles storage
-  },
-
-  computeRequirements: {
-    mode: 'local',
-    complexity: 'standard',
-  },
-
-  getComputeRequirements(
-    _input: TeamPlaybookExtractionInput,
-    complexity: AnalysisComplexity
-  ): ComputeRequirements {
-    return {
-      mode: 'local',
-      complexity,
-      timeout: complexity === 'thorough' ? 600_000 : 300_000,
-    };
-  },
-
-  agentType: 'claude-code',
-  timeout: 300_000,
-  captureToolCalls: true,
-};