cognitive-core 0.0.2 → 0.1.2

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

@@ -0,0 +1,631 @@
+/**
+ * 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,
+};