mindforge-cc 11.5.1 → 11.7.0

package/.mindforge/dynamic-workflows/scripts/deep-research.js

@@ -0,0 +1,151 @@
+export const meta = {
+  name: 'deep-research',
+  description: 'Fan-out web research with adversarial claim verification and cited synthesis',
+  whenToUse: 'When you need a deep, multi-source, fact-checked research report on any topic',
+  phases: [
+    { title: 'Scope', detail: 'Decompose question into 5 search angles' },
+    { title: 'Search', detail: '5 parallel web search agents, one per angle' },
+    { title: 'Fetch', detail: 'Dedup URLs, fetch top 15 sources, extract falsifiable claims' },
+    { title: 'Verify', detail: '3-vote adversarial verification per claim (need 2/3 to kill)' },
+    { title: 'Synthesize', detail: 'Merge semantic dupes, rank by confidence, cite sources' },
+  ],
+};
+
+export default async function run({ agent, parallel, pipeline, phase, log, args, budget }) {
+  const ANGLES_SCHEMA = {
+    type: 'object',
+    properties: {
+      angles: {
+        type: 'array',
+        items: { type: 'object', properties: { label: { type: 'string' }, query: { type: 'string' } }, required: ['label', 'query'] },
+        minItems: 5, maxItems: 5,
+      },
+    },
+    required: ['angles'],
+  };
+
+  const SEARCH_SCHEMA = {
+    type: 'object',
+    properties: {
+      results: {
+        type: 'array',
+        items: { type: 'object', properties: { title: { type: 'string' }, url: { type: 'string' }, snippet: { type: 'string' } }, required: ['title', 'url', 'snippet'] },
+      },
+    },
+    required: ['results'],
+  };
+
+  const CLAIMS_SCHEMA = {
+    type: 'object',
+    properties: {
+      claims: {
+        type: 'array',
+        items: { type: 'object', properties: { claim: { type: 'string' }, source: { type: 'string' }, evidence: { type: 'string' } }, required: ['claim', 'source', 'evidence'] },
+      },
+    },
+    required: ['claims'],
+  };
+
+  const VERDICT_SCHEMA = {
+    type: 'object',
+    properties: { refuted: { type: 'boolean' }, reason: { type: 'string' } },
+    required: ['refuted', 'reason'],
+  };
+
+  const SYNTH_SCHEMA = {
+    type: 'object',
+    properties: {
+      summary: { type: 'string' },
+      findings: {
+        type: 'array',
+        items: { type: 'object', properties: { claim: { type: 'string' }, confidence: { type: 'string' }, sources: { type: 'array', items: { type: 'string' } }, evidence: { type: 'string' } }, required: ['claim', 'confidence', 'sources', 'evidence'] },
+      },
+    },
+    required: ['summary', 'findings'],
+  };
+
+  const question = args || 'No question provided — please pass your research question as args.';
+
+  phase('Scope');
+  log(`Q: ${question.slice(0, 60)}…`);
+  const scoped = await agent(
+    `Decompose this research question into exactly 5 independent search angles. Each angle should approach the topic from a different perspective (e.g., implementation, theory, examples, trade-offs, contrarian view). Question: "${question}"`,
+    { schema: ANGLES_SCHEMA, label: 'decompose' }
+  );
+  const angles = scoped.angles;
+  log(`Decomposed into ${angles.length} angles: ${angles.map(a => a.label).join(', ')}`);
+
+  phase('Search');
+  const searchResults = await parallel(
+    angles.map(angle => () => agent(
+      `Web search for: "${angle.query}". Return the top 6 most relevant results with title, URL, and a brief snippet explaining why each is relevant to: "${angle.query}"`,
+      { schema: SEARCH_SCHEMA, label: angle.label }
+    ))
+  );
+
+  phase('Fetch');
+  const allUrls = new Map();
+  for (const res of searchResults.filter(Boolean)) {
+    for (const r of res.results) {
+      if (!allUrls.has(r.url)) allUrls.set(r.url, r);
+    }
+  }
+  const uniqueUrls = [...allUrls.values()].slice(0, 15);
+  log(`Fetched ${searchResults.filter(Boolean).length * 6} results → ${uniqueUrls.length} unique sources → extracting claims`);
+
+  const claimBatches = await parallel(
+    uniqueUrls.map(src => () => agent(
+      `Read this source and extract up to 5 specific, falsifiable factual claims from it. Only extract claims that are directly relevant to: "${question}". Source URL: ${src.url}\nSnippet: ${src.snippet}`,
+      { schema: CLAIMS_SCHEMA, label: `claims:${src.url.slice(8, 40)}` }
+    ))
+  );
+  const allClaims = claimBatches.filter(Boolean).flatMap(b => b.claims).slice(0, 25);
+  log(`Extracted ${allClaims.length} claims → verifying top 25`);
+
+  phase('Verify');
+  const verified = await parallel(
+    allClaims.map(c => () =>
+      parallel([
+        () => agent(`Try to REFUTE this claim. Default to refuted=true if uncertain or unverifiable. Claim: "${c.claim}"`, { schema: VERDICT_SCHEMA, label: `verify-1:${c.claim.slice(0, 30)}` }),
+        () => agent(`Adversarially challenge this claim from a different angle. Default to refuted=true if you cannot confirm it. Claim: "${c.claim}"`, { schema: VERDICT_SCHEMA, label: `verify-2:${c.claim.slice(0, 30)}` }),
+        () => agent(`As a skeptical fact-checker, evaluate this claim. Default to refuted=true if evidence is weak. Claim: "${c.claim}"`, { schema: VERDICT_SCHEMA, label: `verify-3:${c.claim.slice(0, 30)}` }),
+      ]).then(votes => {
+        const refutes = votes.filter(Boolean).filter(v => v.refuted).length;
+        return { ...c, survives: refutes <= 1, votes: `${3 - refutes}-${refutes}` };
+      })
+    )
+  );
+  const confirmed = verified.filter(Boolean).filter(c => c.survives);
+  const killed = verified.filter(Boolean).filter(c => !c.survives);
+  log(`Verify done: ${allClaims.length} claims → ${confirmed.length} confirmed, ${killed.length} killed`);
+
+  phase('Synthesize');
+  const synthesis = await agent(
+    `Synthesize these verified research findings into a comprehensive report answering: "${question}"
+
+  Confirmed findings (${confirmed.length}):
+  ${confirmed.map((c, i) => `${i + 1}. [${c.votes}] ${c.claim} (source: ${c.source})`).join('\n')}
+
+  Killed findings (${killed.length}):
+  ${killed.map(c => `- [${c.votes}] ${c.claim}`).join('\n')}
+
+  Produce a clear summary and a ranked findings list. For each finding, state the claim, confidence level (high/medium/low), sources, and evidence.`,
+    { schema: SYNTH_SCHEMA, label: 'synthesize' }
+  );
+
+  return {
+    question,
+    summary: synthesis.summary,
+    findings: synthesis.findings,
+    refuted: killed.map(c => ({ claim: c.claim, vote: c.votes, source: c.source })),
+    sources: uniqueUrls.map(u => u.url),
+    stats: {
+      angles: angles.length,
+      sourcesFetched: uniqueUrls.length,
+      claimsExtracted: allClaims.length,
+      claimsVerified: allClaims.length,
+      confirmed: confirmed.length,
+      killed: killed.length,
+    },
+  };
+}

package/.mindforge/dynamic-workflows/scripts/feature-planner.js

@@ -0,0 +1,104 @@
+export const meta = {
+  name: 'feature-planner',
+  description: 'Sequential pipeline: brief → PRD → architecture → user stories',
+  whenToUse: 'When starting a new feature and need a complete specification before coding',
+  phases: [
+    { title: 'Brief', detail: 'Clarify goals, users, success criteria' },
+    { title: 'PRD', detail: 'Generate product requirements document' },
+    { title: 'Architecture', detail: 'Design technical architecture and data flow' },
+    { title: 'Stories', detail: 'Break into implementation user stories' },
+  ],
+};
+
+export default async function run({ agent, parallel, pipeline, phase, log, args, budget }) {
+  const BRIEF_SCHEMA = {
+    type: 'object',
+    properties: {
+      featureName: { type: 'string' },
+      problem: { type: 'string' },
+      targetUsers: { type: 'string' },
+      successCriteria: { type: 'array', items: { type: 'string' } },
+      outOfScope: { type: 'array', items: { type: 'string' } },
+    },
+    required: ['featureName', 'problem', 'targetUsers', 'successCriteria', 'outOfScope'],
+  };
+
+  const PRD_SCHEMA = {
+    type: 'object',
+    properties: {
+      overview: { type: 'string' },
+      requirements: { type: 'array', items: { type: 'object', properties: { id: { type: 'string' }, type: { type: 'string' }, description: { type: 'string' }, priority: { type: 'string' } }, required: ['id', 'type', 'description', 'priority'] } },
+      nonFunctional: { type: 'array', items: { type: 'string' } },
+      acceptanceCriteria: { type: 'array', items: { type: 'string' } },
+    },
+    required: ['overview', 'requirements', 'nonFunctional', 'acceptanceCriteria'],
+  };
+
+  const ARCH_SCHEMA = {
+    type: 'object',
+    properties: {
+      approach: { type: 'string' },
+      components: { type: 'array', items: { type: 'object', properties: { name: { type: 'string' }, responsibility: { type: 'string' } }, required: ['name', 'responsibility'] } },
+      dataFlow: { type: 'string' },
+      newFiles: { type: 'array', items: { type: 'string' } },
+      modifiedFiles: { type: 'array', items: { type: 'string' } },
+      risks: { type: 'array', items: { type: 'string' } },
+    },
+    required: ['approach', 'components', 'dataFlow', 'newFiles', 'modifiedFiles', 'risks'],
+  };
+
+  const STORIES_SCHEMA = {
+    type: 'object',
+    properties: {
+      stories: {
+        type: 'array',
+        items: {
+          type: 'object',
+          properties: {
+            id: { type: 'string' },
+            title: { type: 'string' },
+            asA: { type: 'string' },
+            iWant: { type: 'string' },
+            soThat: { type: 'string' },
+            acceptanceCriteria: { type: 'array', items: { type: 'string' } },
+            estimate: { type: 'string' },
+          },
+          required: ['id', 'title', 'asA', 'iWant', 'soThat', 'acceptanceCriteria', 'estimate'],
+        },
+      },
+    },
+    required: ['stories'],
+  };
+
+  const feature = args || 'No feature described — pass your feature description as args.';
+
+  phase('Brief');
+  log(`Feature: ${feature.slice(0, 60)}`);
+  const brief = await agent(
+    `Create a feature brief for: "${feature}". Clarify the core problem, target users, measurable success criteria, and explicit out-of-scope items.`,
+    { schema: BRIEF_SCHEMA, label: 'brief' }
+  );
+
+  phase('PRD');
+  const briefText = `Feature: ${brief.featureName}\nProblem: ${brief.problem}\nUsers: ${brief.targetUsers}\nSuccess: ${brief.successCriteria.join(', ')}`;
+  const prd = await agent(
+    `Write a product requirements document for this feature:\n${briefText}\n\nInclude functional requirements (must/should/could), non-functional requirements, and acceptance criteria.`,
+    { schema: PRD_SCHEMA, label: 'prd' }
+  );
+
+  phase('Architecture');
+  const reqSummary = prd.requirements.slice(0, 8).map(r => `${r.id} [${r.priority}]: ${r.description}`).join('\n');
+  const arch = await agent(
+    `Design the technical architecture for this feature:\nBrief: ${briefText}\nRequirements:\n${reqSummary}\n\nIdentify the implementation approach, components, data flow, files to create/modify, and key risks.`,
+    { schema: ARCH_SCHEMA, label: 'architecture' }
+  );
+
+  phase('Stories');
+  const archSummary = `Approach: ${arch.approach}\nNew files: ${arch.newFiles.join(', ')}\nModified: ${arch.modifiedFiles.join(', ')}`;
+  const stories = await agent(
+    `Break this feature into user stories:\nBrief: ${briefText}\nArchitecture: ${archSummary}\n\nWrite stories in "As a [user], I want [goal], so that [benefit]" format with acceptance criteria and t-shirt size estimates (XS/S/M/L/XL).`,
+    { schema: STORIES_SCHEMA, label: 'stories' }
+  );
+
+  return { feature, brief, prd, architecture: arch, stories: stories.stories };
+}

package/.mindforge/dynamic-workflows/scripts/incident-response.js

@@ -0,0 +1,106 @@
+export const meta = {
+  name: 'incident-response',
+  description: 'Parallel investigation across logs, metrics, traces, and code → mitigation → RCA → postmortem',
+  whenToUse: 'When responding to a production incident or unexpected system failure',
+  phases: [
+    { title: 'Alert', detail: 'Characterize the incident: impact, scope, timeline' },
+    { title: 'Investigate', detail: '4 parallel agents: logs / metrics / traces / code changes' },
+    { title: 'Mitigate', detail: 'Identify and apply immediate mitigation steps' },
+    { title: 'RCA', detail: 'Root cause analysis and postmortem document' },
+  ],
+};
+
+export default async function run({ agent, parallel, pipeline, phase, log, args, budget }) {
+  const CHARACTERIZE_SCHEMA = {
+    type: 'object',
+    properties: {
+      incidentTitle: { type: 'string' },
+      severity: { type: 'string', enum: ['P0', 'P1', 'P2', 'P3'] },
+      impactDescription: { type: 'string' },
+      affectedSystems: { type: 'array', items: { type: 'string' } },
+      startTime: { type: 'string' },
+      symptoms: { type: 'array', items: { type: 'string' } },
+      hypothesis: { type: 'string' },
+    },
+    required: ['incidentTitle', 'severity', 'impactDescription', 'affectedSystems', 'symptoms', 'hypothesis'],
+  };
+
+  const INVESTIGATE_SCHEMA = {
+    type: 'object',
+    properties: {
+      angle: { type: 'string' },
+      findings: { type: 'array', items: { type: 'string' } },
+      suspectedCause: { type: 'string' },
+      confidence: { type: 'string', enum: ['high', 'medium', 'low'] },
+    },
+    required: ['angle', 'findings', 'suspectedCause', 'confidence'],
+  };
+
+  const MITIGATE_SCHEMA = {
+    type: 'object',
+    properties: {
+      immediateActions: { type: 'array', items: { type: 'object', properties: { action: { type: 'string' }, command: { type: 'string' }, risk: { type: 'string' } }, required: ['action', 'risk'] } },
+      estimatedRecoveryTime: { type: 'string' },
+      rollbackSteps: { type: 'array', items: { type: 'string' } },
+    },
+    required: ['immediateActions', 'estimatedRecoveryTime', 'rollbackSteps'],
+  };
+
+  const POSTMORTEM_SCHEMA = {
+    type: 'object',
+    properties: {
+      rootCause: { type: 'string' },
+      timeline: { type: 'array', items: { type: 'object', properties: { time: { type: 'string' }, event: { type: 'string' } }, required: ['time', 'event'] } },
+      contributingFactors: { type: 'array', items: { type: 'string' } },
+      actionItems: { type: 'array', items: { type: 'object', properties: { action: { type: 'string' }, owner: { type: 'string' }, priority: { type: 'string' } }, required: ['action', 'owner', 'priority'] } },
+      lessonsLearned: { type: 'array', items: { type: 'string' } },
+    },
+    required: ['rootCause', 'timeline', 'contributingFactors', 'actionItems', 'lessonsLearned'],
+  };
+
+  const incident = args || 'No incident description provided — pass your incident description, symptoms, and affected systems as args.';
+
+  phase('Alert');
+  log(`Incident: ${incident.slice(0, 80)}`);
+  const characterization = await agent(
+    `Characterize this production incident: "${incident}"\n\nDetermine severity (P0=total outage, P1=major degradation, P2=partial impact, P3=minor), list affected systems, symptoms, and your initial hypothesis about the root cause.`,
+    { schema: CHARACTERIZE_SCHEMA, label: 'characterize' }
+  );
+  log(`[${characterization.severity}] ${characterization.incidentTitle} — ${characterization.symptoms.length} symptoms identified`);
+
+  phase('Investigate');
+  const context = `Incident: ${characterization.incidentTitle}\nHypothesis: ${characterization.hypothesis}\nSystems: ${characterization.affectedSystems.join(', ')}`;
+
+  const INVESTIGATION_ANGLES = [
+    { label: 'logs', prompt: `Investigate this incident from the LOGS angle: ${context}\n\nWhat log patterns, error messages, or anomalies would you look for? What do recent application/system logs likely show? What would confirm or refute the hypothesis?` },
+    { label: 'metrics', prompt: `Investigate this incident from the METRICS angle: ${context}\n\nWhat metrics (CPU, memory, latency, error rates, throughput) would spike or drop? What dashboards to check? What thresholds were likely crossed?` },
+    { label: 'traces', prompt: `Investigate this incident from the DISTRIBUTED TRACES angle: ${context}\n\nWhat trace patterns would reveal the failure point? Which service calls would show elevated latency or errors? What would a flame graph show?` },
+    { label: 'code', prompt: `Investigate this incident from the RECENT CODE CHANGES angle: ${context}\n\nWhat types of recent deployments, config changes, or dependency updates could cause this? What specific code patterns are suspect? What git history to examine?` },
+  ];
+
+  const investigations = await parallel(
+    INVESTIGATION_ANGLES.map(a => () => agent(a.prompt, { schema: INVESTIGATE_SCHEMA, label: `investigate:${a.label}`, phase: 'Investigate' }))
+  );
+
+  phase('Mitigate');
+  const investigationSummary = investigations.filter(Boolean).map(i => `[${i.angle}] ${i.suspectedCause} (${i.confidence} confidence): ${i.findings.slice(0, 2).join(', ')}`).join('\n');
+  const mitigation = await agent(
+    `Based on these investigation findings, identify IMMEDIATE mitigation actions:\n${investigationSummary}\n\nPrioritize actions that restore service quickly. Include rollback steps and estimate recovery time.`,
+    { schema: MITIGATE_SCHEMA, label: 'mitigate' }
+  );
+
+  phase('RCA');
+  const allContext = `Incident: ${characterization.incidentTitle}\nInvestigations:\n${investigationSummary}\nMitigation: ${mitigation.immediateActions.map(a => a.action).join(', ')}`;
+  const postmortem = await agent(
+    `Write a blameless postmortem for this incident:\n${allContext}\n\nIdentify the root cause, create a timeline, list contributing factors, define concrete action items (with owners and priority), and extract lessons learned.`,
+    { schema: POSTMORTEM_SCHEMA, label: 'postmortem' }
+  );
+
+  return {
+    incident,
+    characterization,
+    investigations: investigations.filter(Boolean),
+    mitigation,
+    postmortem,
+  };
+}

package/.mindforge/dynamic-workflows/scripts/onboard-codebase.js

@@ -0,0 +1,102 @@
+export const meta = {
+  name: 'onboard-codebase',
+  description: 'Map structure → domain analysis → architecture → generate guided tour and onboarding docs',
+  whenToUse: 'When joining a new codebase or onboarding a team member to an existing repo',
+  phases: [
+    { title: 'Map', detail: 'Discover file structure, languages, entry points' },
+    { title: 'Domain', detail: 'Identify business domains and core abstractions' },
+    { title: 'Architecture', detail: 'Map layers, data flow, and key patterns' },
+    { title: 'Tour', detail: 'Generate guided tour and onboarding documentation' },
+  ],
+};
+
+export default async function run({ agent, parallel, pipeline, phase, log, args, budget }) {
+  const MAP_SCHEMA = {
+    type: 'object',
+    properties: {
+      primaryLanguage: { type: 'string' },
+      secondaryLanguages: { type: 'array', items: { type: 'string' } },
+      frameworks: { type: 'array', items: { type: 'string' } },
+      entryPoints: { type: 'array', items: { type: 'string' } },
+      testingFrameworks: { type: 'array', items: { type: 'string' } },
+      totalFiles: { type: 'string' },
+      keyDirectories: { type: 'array', items: { type: 'object', properties: { path: { type: 'string' }, purpose: { type: 'string' } }, required: ['path', 'purpose'] } },
+    },
+    required: ['primaryLanguage', 'frameworks', 'entryPoints', 'keyDirectories'],
+  };
+
+  const DOMAIN_SCHEMA = {
+    type: 'object',
+    properties: {
+      domains: { type: 'array', items: { type: 'object', properties: { name: { type: 'string' }, description: { type: 'string' }, keyFiles: { type: 'array', items: { type: 'string' } } }, required: ['name', 'description', 'keyFiles'] } },
+      coreAbstractions: { type: 'array', items: { type: 'string' } },
+      businessPurpose: { type: 'string' },
+    },
+    required: ['domains', 'coreAbstractions', 'businessPurpose'],
+  };
+
+  const ARCH_SCHEMA = {
+    type: 'object',
+    properties: {
+      architectureStyle: { type: 'string' },
+      layers: { type: 'array', items: { type: 'object', properties: { name: { type: 'string' }, responsibility: { type: 'string' } }, required: ['name', 'responsibility'] } },
+      dataFlow: { type: 'string' },
+      keyPatterns: { type: 'array', items: { type: 'string' } },
+      externalDependencies: { type: 'array', items: { type: 'string' } },
+      gotchas: { type: 'array', items: { type: 'string' } },
+    },
+    required: ['architectureStyle', 'layers', 'dataFlow', 'keyPatterns', 'gotchas'],
+  };
+
+  const TOUR_SCHEMA = {
+    type: 'object',
+    properties: {
+      quickStart: { type: 'string' },
+      tourSteps: { type: 'array', items: { type: 'object', properties: { step: { type: 'number' }, title: { type: 'string' }, file: { type: 'string' }, explanation: { type: 'string' } }, required: ['step', 'title', 'explanation'] } },
+      keyConventions: { type: 'array', items: { type: 'string' } },
+      whereToStartCoding: { type: 'string' },
+      commonPitfalls: { type: 'array', items: { type: 'string' } },
+    },
+    required: ['quickStart', 'tourSteps', 'keyConventions', 'whereToStartCoding', 'commonPitfalls'],
+  };
+
+  const repo = args || 'current repository (run from repo root)';
+
+  phase('Map');
+  log(`Mapping: ${repo}`);
+  const map = await agent(
+    `Map the structure of this codebase: "${repo}"\n\nIdentify: primary language, frameworks, entry points (main files, index, CLI), test frameworks, and the purpose of each top-level directory. Be specific — list actual file paths.`,
+    { schema: MAP_SCHEMA, label: 'map' }
+  );
+  log(`${map.primaryLanguage} codebase, ${map.frameworks.join('+')} — ${map.keyDirectories.length} key directories`);
+
+  phase('Domain');
+  const mapSummary = `Stack: ${map.primaryLanguage} + ${map.frameworks.join(', ')}\nDirs: ${map.keyDirectories.map(d => `${d.path} (${d.purpose})`).join(', ')}`;
+  const domain = await agent(
+    `Identify the business domains and core abstractions in: "${repo}"\n${mapSummary}\n\nWhat problem does this software solve? What are the main domain concepts? What are the key abstractions (models, services, controllers, etc.)?`,
+    { schema: DOMAIN_SCHEMA, label: 'domain' }
+  );
+  log(`${domain.domains.length} domains: ${domain.domains.map(d => d.name).join(', ')}`);
+
+  phase('Architecture');
+  const domainSummary = `Purpose: ${domain.businessPurpose}\nDomains: ${domain.domains.map(d => d.name).join(', ')}\nAbstractions: ${domain.coreAbstractions.join(', ')}`;
+  const arch = await agent(
+    `Map the technical architecture of: "${repo}"\n${domainSummary}\n\nWhat architecture style (MVC, layered, event-driven, microservices)? What are the layers? How does data flow? What key patterns and gotchas should a new developer know?`,
+    { schema: ARCH_SCHEMA, label: 'architecture' }
+  );
+
+  phase('Tour');
+  const archSummary = `Style: ${arch.architectureStyle}\nLayers: ${arch.layers.map(l => l.name).join(' → ')}\nPatterns: ${arch.keyPatterns.join(', ')}`;
+  const tour = await agent(
+    `Create an onboarding tour for: "${repo}"\n${mapSummary}\n${domainSummary}\n${archSummary}\n\nWrite a quick start, a 5-10 step guided tour through the most important files (in learning order), key conventions to follow, where to start making changes, and common pitfalls to avoid.`,
+    { schema: TOUR_SCHEMA, label: 'tour' }
+  );
+
+  return {
+    repo,
+    map,
+    domain,
+    architecture: arch,
+    tour,
+  };
+}

package/.mindforge/dynamic-workflows/scripts/perf-optimize.js

@@ -0,0 +1,128 @@
+export const meta = {
+  name: 'perf-optimize',
+  description: 'Profile → parallel bottleneck hunt across DB/network/CPU/memory → prioritized fix plan',
+  whenToUse: 'When an application is slow and you need to find and fix performance bottlenecks',
+  phases: [
+    { title: 'Profile', detail: 'Establish baseline metrics and identify slow paths' },
+    { title: 'Identify', detail: '4 parallel agents: DB queries / network / CPU / memory' },
+    { title: 'Plan', detail: 'Prioritize fixes by impact-to-effort ratio' },
+    { title: 'Benchmark', detail: 'Define verification benchmarks for each fix' },
+  ],
+};
+
+export default async function run({ agent, parallel, pipeline, phase, log, args, budget }) {
+  const PROFILE_SCHEMA = {
+    type: 'object',
+    properties: {
+      slowestPaths: { type: 'array', items: { type: 'object', properties: { path: { type: 'string' }, currentLatency: { type: 'string' }, target: { type: 'string' } }, required: ['path', 'currentLatency'] } },
+      bottleneckHypothesis: { type: 'string' },
+      profilingCommands: { type: 'array', items: { type: 'string' } },
+    },
+    required: ['slowestPaths', 'bottleneckHypothesis', 'profilingCommands'],
+  };
+
+  const BOTTLENECK_SCHEMA = {
+    type: 'object',
+    properties: {
+      dimension: { type: 'string' },
+      issues: {
+        type: 'array',
+        items: {
+          type: 'object',
+          properties: {
+            description: { type: 'string' },
+            location: { type: 'string' },
+            impact: { type: 'string', enum: ['high', 'medium', 'low'] },
+            fix: { type: 'string' },
+            effort: { type: 'string', enum: ['low', 'medium', 'high'] },
+          },
+          required: ['description', 'impact', 'fix', 'effort'],
+        },
+      },
+    },
+    required: ['dimension', 'issues'],
+  };
+
+  const FIX_PLAN_SCHEMA = {
+    type: 'object',
+    properties: {
+      prioritized: {
+        type: 'array',
+        items: {
+          type: 'object',
+          properties: {
+            rank: { type: 'number' },
+            fix: { type: 'string' },
+            dimension: { type: 'string' },
+            expectedImprovement: { type: 'string' },
+            effort: { type: 'string' },
+            implementation: { type: 'string' },
+          },
+          required: ['rank', 'fix', 'expectedImprovement', 'effort', 'implementation'],
+        },
+      },
+      totalEstimate: { type: 'string' },
+      quickWins: { type: 'array', items: { type: 'string' } },
+    },
+    required: ['prioritized', 'totalEstimate', 'quickWins'],
+  };
+
+  const BENCHMARK_SCHEMA = {
+    type: 'object',
+    properties: {
+      baselineTests: { type: 'array', items: { type: 'string' } },
+      successCriteria: { type: 'array', items: { type: 'object', properties: { fix: { type: 'string' }, metric: { type: 'string' }, target: { type: 'string' } }, required: ['fix', 'metric', 'target'] } },
+      monitoringSetup: { type: 'array', items: { type: 'string' } },
+    },
+    required: ['baselineTests', 'successCriteria', 'monitoringSetup'],
+  };
+
+  const target = args || 'current application (run from repo root)';
+
+  phase('Profile');
+  log(`Profiling: ${target}`);
+  const profile = await agent(
+    `Identify the slowest code paths and performance bottleneck hypothesis for: "${target}"\n\nWhat are the likely slow endpoints/functions? What profiling commands should be run? What is your initial bottleneck hypothesis?`,
+    { schema: PROFILE_SCHEMA, label: 'profile' }
+  );
+  log(`${profile.slowestPaths.length} slow paths identified, hypothesis: ${profile.bottleneckHypothesis.slice(0, 80)}`);
+
+  phase('Identify');
+  const context = `Target: ${target}\nSlow paths: ${profile.slowestPaths.map(p => p.path).join(', ')}\nHypothesis: ${profile.bottleneckHypothesis}`;
+
+  const DIMENSIONS = [
+    { label: 'db', prompt: `Hunt for DATABASE performance bottlenecks in: ${context}\n\nLook for: N+1 queries, missing indexes, full table scans, unoptimized JOINs, missing query caching, connection pool exhaustion, slow aggregate queries.` },
+    { label: 'network', prompt: `Hunt for NETWORK performance bottlenecks in: ${context}\n\nLook for: missing HTTP caching, no CDN, uncompressed responses, chatty APIs (many small requests), missing connection pooling, DNS lookups in hot paths, synchronous external calls.` },
+    { label: 'cpu', prompt: `Hunt for CPU/COMPUTE performance bottlenecks in: ${context}\n\nLook for: inefficient algorithms (O(n²) where O(n log n) exists), regex in hot paths, JSON serialization overhead, cryptographic operations in request path, missing memoization.` },
+    { label: 'memory', prompt: `Hunt for MEMORY performance bottlenecks in: ${context}\n\nLook for: memory leaks, unbounded caches, large object retention, excessive GC pressure, buffer accumulation, object pool exhaustion, unnecessary data loading.` },
+  ];
+
+  const bottlenecks = await parallel(
+    DIMENSIONS.map(d => () => agent(d.prompt, { schema: BOTTLENECK_SCHEMA, label: `identify:${d.label}`, phase: 'Identify' }))
+  );
+
+  phase('Plan');
+  const allIssues = bottlenecks.filter(Boolean).flatMap(b => b.issues.map(i => ({ ...i, dimension: b.dimension })));
+  log(`${allIssues.length} bottlenecks found across ${bottlenecks.filter(Boolean).length} dimensions`);
+  const issueList = allIssues.slice(0, 20).map(i => `[${i.dimension}][${i.impact}/${i.effort}] ${i.description} → ${i.fix}`).join('\n');
+  const fixPlan = await agent(
+    `Prioritize this performance fix backlog by impact-to-effort ratio:\n${issueList}\n\nRank by: high impact + low effort first. List quick wins (can implement in <1 hour) separately. Include implementation guidance for each.`,
+    { schema: FIX_PLAN_SCHEMA, label: 'plan' }
+  );
+
+  phase('Benchmark');
+  const topFixes = fixPlan.prioritized.slice(0, 5).map(f => `${f.rank}. ${f.fix} (expected: ${f.expectedImprovement})`).join('\n');
+  const benchmarks = await agent(
+    `Define performance benchmarks for verifying these fixes:\n${topFixes}\n\nFor each fix, specify: the baseline test to run before, the success metric (P95 latency, throughput, memory), and the target value. Include monitoring setup recommendations.`,
+    { schema: BENCHMARK_SCHEMA, label: 'benchmark' }
+  );
+
+  return {
+    target,
+    profile,
+    bottlenecks: bottlenecks.filter(Boolean),
+    fixPlan,
+    benchmarks,
+    stats: { totalIssues: allIssues.length, quickWins: fixPlan.quickWins.length },
+  };
+}