popeye-cli 1.10.0 → 2.0.0

package/src/pipeline/phases/audit.ts

@@ -0,0 +1,193 @@
+/**
+ * AUDIT phase — holistic system verification before Production Gate.
+ * Creates structured AuditReport with AuditFindings (P2-1).
+ * v1.1: Creates Change Requests for architectural findings.
+ */
+
+import type { PhaseContext, PhaseResult } from './phase-context.js';
+import { successResult, failureResult, triggerJournalist } from './phase-context.js';
+import { buildAuditReport } from '../packets/audit-report-builder.js';
+import { generateRepoSnapshot, createSnapshotArtifact } from '../repo-snapshot.js';
+import { buildChangeRequest, formatChangeRequest, routeChangeRequest } from '../change-request.js';
+import type { AuditFinding, ArtifactEntry, ChangeRequest } from '../types.js';
+import type { ArtifactManager } from '../artifact-manager.js';
+
+export async function runAudit(context: PhaseContext): Promise<PhaseResult> {
+  const { pipeline, artifactManager, skillLoader, projectDir } = context;
+  const artifacts = [];
+
+  try {
+    // 1. Fresh repo snapshot
+    const snapshot = await generateRepoSnapshot(projectDir);
+    const snapshotEntry = createSnapshotArtifact(snapshot, artifactManager, 'AUDIT');
+    artifacts.push(snapshotEntry);
+    pipeline.latestRepoSnapshot = artifactManager.toArtifactRef(snapshotEntry);
+
+    // 2. Load auditor skill
+    const auditorSkill = skillLoader.loadSkill('AUDITOR');
+
+    // 3. Run audit checks via Claude
+    const { executePrompt } = await import('../../adapters/claude.js');
+    const auditPrompt = [
+      auditorSkill.systemPrompt,
+      '',
+      '## Audit Instructions',
+      'Perform a holistic system audit covering:',
+      '1. Integration audit (FE<->BE, BE<->DB)',
+      '2. Config/env audit',
+      '3. Tests/coverage audit',
+      '4. Migration audit',
+      '5. Basic security audit',
+      '6. Deployment readiness audit',
+      '',
+      'For each finding, classify severity as P0/P1/P2/P3.',
+      'Mark blocking findings that must be resolved before production.',
+      '',
+      `## Repo Snapshot`,
+      `Total files: ${snapshot.total_files}`,
+      `Languages: ${snapshot.languages_detected.join(', ')}`,
+      `Test framework: ${snapshot.test_framework ?? 'none'}`,
+      `Build tool: ${snapshot.build_tool ?? 'none'}`,
+    ].join('\n');
+
+    const auditResult = await executePrompt(auditPrompt);
+    const auditResponse = auditResult.response;
+
+    // 4. Parse findings from audit response (simplified extraction)
+    const findings = parseAuditFindings(auditResponse);
+
+    // 5. Build structured audit report
+    const auditReport = buildAuditReport({
+      repoSnapshot: artifactManager.toArtifactRef(snapshotEntry),
+      findings,
+    });
+
+    // 6. Store audit report
+    const auditEntry = artifactManager.createAndStoreJson(
+      'audit_report',
+      auditReport,
+      'AUDIT',
+    );
+    artifacts.push(auditEntry);
+
+    // Also store the raw audit text
+    const auditTextEntry = artifactManager.createAndStoreText(
+      'audit_report',
+      auditResponse,
+      'AUDIT',
+    );
+    artifacts.push(auditTextEntry);
+
+    // 7. v1.1: Create change requests for architectural findings
+    const changeRequests = createAuditChangeRequests(findings, artifactManager, snapshotEntry);
+    for (const cr of changeRequests) {
+      const crEntry = artifactManager.createAndStoreText(
+        'change_request',
+        formatChangeRequest(cr),
+        'AUDIT',
+      );
+      artifacts.push(crEntry);
+
+      // Register CR in pipeline state for orchestrator routing
+      if (!pipeline.pendingChangeRequests) {
+        pipeline.pendingChangeRequests = [];
+      }
+      pipeline.pendingChangeRequests.push({
+        cr_id: cr.cr_id,
+        change_type: cr.change_type,
+        target_phase: routeChangeRequest(cr),
+        status: 'proposed',
+      });
+    }
+
+    pipeline.artifacts.push(...artifacts);
+
+    // 8. Journalist trigger
+    await triggerJournalist('AUDIT', artifacts, context);
+
+    return successResult(
+      'AUDIT',
+      artifacts,
+      `Audit ${auditReport.overall_status}: ${findings.length} findings, risk score ${auditReport.system_risk_score}, ${changeRequests.length} CRs`,
+    );
+  } catch (err) {
+    const message = err instanceof Error ? err.message : 'Unknown error';
+    return failureResult('AUDIT', 'Audit failed', message);
+  }
+}
+
+/** Parse audit findings from LLM response (best-effort) */
+function parseAuditFindings(response: string): AuditFinding[] {
+  const findings: AuditFinding[] = [];
+  const lines = response.split('\n');
+  let findingCount = 0;
+
+  for (const line of lines) {
+    // Look for severity markers: P0, P1, P2, P3
+    const severityMatch = line.match(/\b(P[0-3])\b/);
+    if (severityMatch) {
+      findingCount++;
+      const severity = severityMatch[1] as 'P0' | 'P1' | 'P2' | 'P3';
+      findings.push({
+        id: `finding-${findingCount}`,
+        severity,
+        category: 'integration', // Default; would be refined with better parsing
+        description: line.trim(),
+        evidence: [],
+        suggested_owner: 'DISPATCHER',
+        blocking: severity === 'P0' || severity === 'P1',
+      });
+    }
+  }
+
+  return findings;
+}
+
+/** Create change requests for high-severity audit findings (v1.1) */
+function createAuditChangeRequests(
+  findings: AuditFinding[],
+  artifactManager: ArtifactManager,
+  snapshotEntry: ArtifactEntry,
+): ChangeRequest[] {
+  const changeRequests: ChangeRequest[] = [];
+
+  // Create CRs for blocking findings in integration/schema categories
+  const architecturalFindings = findings.filter(
+    (f) => f.blocking && (f.category === 'integration' || f.category === 'schema'),
+  );
+
+  if (architecturalFindings.length > 0) {
+    const cr = buildChangeRequest({
+      originPhase: 'AUDIT',
+      requestedBy: 'AUDITOR',
+      changeType: 'architecture',
+      description: `${architecturalFindings.length} blocking architectural findings: ${architecturalFindings.map((f) => f.description.slice(0, 80)).join('; ')}`,
+      justification: 'Blocking audit findings require architectural review before production',
+      affectedArtifacts: [artifactManager.toArtifactRef(snapshotEntry)],
+      affectedPhases: ['CONSENSUS_ARCHITECTURE', 'IMPLEMENTATION'],
+      riskLevel: architecturalFindings.some((f) => f.severity === 'P0') ? 'high' : 'medium',
+    });
+    changeRequests.push(cr);
+  }
+
+  // Create CRs for security findings
+  const securityFindings = findings.filter(
+    (f) => f.blocking && f.category === 'security',
+  );
+
+  if (securityFindings.length > 0) {
+    const cr = buildChangeRequest({
+      originPhase: 'AUDIT',
+      requestedBy: 'AUDITOR',
+      changeType: 'requirement',
+      description: `${securityFindings.length} blocking security findings require review`,
+      justification: 'Security issues must be resolved before production deployment',
+      affectedArtifacts: [artifactManager.toArtifactRef(snapshotEntry)],
+      affectedPhases: ['CONSENSUS_MASTER_PLAN', 'IMPLEMENTATION'],
+      riskLevel: 'high',
+    });
+    changeRequests.push(cr);
+  }
+
+  return changeRequests;
+}

package/src/pipeline/phases/consensus-architecture.ts

@@ -0,0 +1,104 @@
+/**
+ * CONSENSUS_ARCHITECTURE phase — validate architecture is feasible,
+ * consistent, and complete. Same pattern as consensus-master-plan.
+ */
+
+import type { PhaseContext, PhaseResult } from './phase-context.js';
+import { successResult, failureResult, triggerJournalist } from './phase-context.js';
+import { buildPlanPacket } from '../packets/plan-packet-builder.js';
+import { generateRepoSnapshot, createSnapshotArtifact } from '../repo-snapshot.js';
+import type { PipelineState, ArtifactRef } from '../types.js';
+
+/** Get constitution artifact ref from pipeline state, or fallback */
+function getConstitutionRef(pipeline: PipelineState): ArtifactRef {
+  const constitutionArtifact = pipeline.artifacts.find((a) => a.type === 'constitution');
+  if (constitutionArtifact) {
+    return {
+      artifact_id: constitutionArtifact.id,
+      path: constitutionArtifact.path,
+      sha256: constitutionArtifact.sha256,
+      version: constitutionArtifact.version,
+      type: 'constitution',
+    };
+  }
+  return { artifact_id: 'constitution', path: 'skills/POPEYE_CONSTITUTION.md', sha256: '', version: 1, type: 'constitution' };
+}
+
+export async function runConsensusArchitecture(context: PhaseContext): Promise<PhaseResult> {
+  const { pipeline, artifactManager, gateEngine, consensusRunner, projectDir } = context;
+  const artifacts = [];
+
+  try {
+    // 1. Fresh repo snapshot
+    const snapshot = await generateRepoSnapshot(projectDir);
+    const snapshotEntry = createSnapshotArtifact(snapshot, artifactManager, 'CONSENSUS_ARCHITECTURE');
+    artifacts.push(snapshotEntry);
+    pipeline.latestRepoSnapshot = artifactManager.toArtifactRef(snapshotEntry);
+
+    // 2. Find architecture artifact
+    const archArtifact = pipeline.artifacts.find((a) => a.type === 'architecture');
+    if (!archArtifact) {
+      return failureResult('CONSENSUS_ARCHITECTURE', 'No architecture artifact found');
+    }
+
+    const masterPlanArtifact = pipeline.artifacts.find((a) => a.type === 'master_plan');
+
+    // 3. Build plan packet
+    const planPacket = buildPlanPacket({
+      phase: 'CONSENSUS_ARCHITECTURE',
+      submittedBy: 'ARCHITECT',
+      masterPlanRef: masterPlanArtifact
+        ? artifactManager.toArtifactRef(masterPlanArtifact)
+        : { artifact_id: 'none', path: '', sha256: '', version: 1, type: 'master_plan' },
+      constitutionRef: getConstitutionRef(pipeline),
+      repoSnapshotRef: artifactManager.toArtifactRef(snapshotEntry),
+      proposedArtifacts: [artifactManager.toArtifactRef(archArtifact)],
+      acceptanceCriteria: [
+        'Contracts explicit enough for FE/BE to build without guessing',
+        'Env vars enumerated',
+        'Integration points enumerated',
+        'No contradictory contracts',
+      ],
+      dependencies: [],
+      constraints: [],
+    });
+
+    // 4. Run consensus
+    const gateDef = gateEngine.getGateDefinition('CONSENSUS_ARCHITECTURE');
+    const consensusPacket = await consensusRunner.runStructuredConsensus(planPacket, gateDef);
+
+    // 5. Store consensus artifact
+    const consensusEntry = artifactManager.createAndStoreJson(
+      'consensus',
+      consensusPacket,
+      'CONSENSUS_ARCHITECTURE',
+    );
+    artifacts.push(consensusEntry);
+    pipeline.artifacts.push(...artifacts);
+
+    // 5b. Store consensus score in gateResults for parseConsensusScore()
+    pipeline.gateResults['CONSENSUS_ARCHITECTURE'] = {
+      phase: 'CONSENSUS_ARCHITECTURE',
+      pass: consensusPacket.final_status === 'APPROVED' || consensusPacket.final_status === 'ARBITRATED',
+      score: consensusPacket.consensus_result.weighted_score,
+      blockers: [],
+      missingArtifacts: [],
+      failedChecks: [],
+      consensusScore: consensusPacket.consensus_result.score,
+      timestamp: new Date().toISOString(),
+    };
+
+    // 6. Journalist trigger
+    await triggerJournalist('CONSENSUS_ARCHITECTURE', artifacts, context);
+
+    const approved = consensusPacket.final_status === 'APPROVED' || consensusPacket.final_status === 'ARBITRATED';
+    return successResult(
+      'CONSENSUS_ARCHITECTURE',
+      artifacts,
+      approved ? 'Architecture consensus APPROVED' : 'Architecture consensus REJECTED',
+    );
+  } catch (err) {
+    const message = err instanceof Error ? err.message : 'Unknown error';
+    return failureResult('CONSENSUS_ARCHITECTURE', 'Architecture consensus failed', message);
+  }
+}

package/src/pipeline/phases/consensus-master-plan.ts

@@ -0,0 +1,100 @@
+/**
+ * CONSENSUS_MASTER_PLAN phase — multi-LLM validation of Master Plan.
+ * Uses independent review mode by default (P1-D).
+ */
+
+import type { PhaseContext, PhaseResult } from './phase-context.js';
+import { successResult, failureResult, triggerJournalist } from './phase-context.js';
+import { buildPlanPacket } from '../packets/plan-packet-builder.js';
+import { generateRepoSnapshot, createSnapshotArtifact } from '../repo-snapshot.js';
+import type { PipelineState, ArtifactRef } from '../types.js';
+
+/** Get constitution artifact ref from pipeline state, or fallback */
+function getConstitutionRef(pipeline: PipelineState): ArtifactRef {
+  const constitutionArtifact = pipeline.artifacts.find((a) => a.type === 'constitution');
+  if (constitutionArtifact) {
+    return {
+      artifact_id: constitutionArtifact.id,
+      path: constitutionArtifact.path,
+      sha256: constitutionArtifact.sha256,
+      version: constitutionArtifact.version,
+      type: 'constitution',
+    };
+  }
+  return { artifact_id: 'constitution', path: 'skills/POPEYE_CONSTITUTION.md', sha256: '', version: 1, type: 'constitution' };
+}
+
+export async function runConsensusMasterPlan(context: PhaseContext): Promise<PhaseResult> {
+  const { pipeline, artifactManager, gateEngine, consensusRunner, projectDir } = context;
+  const artifacts = [];
+
+  try {
+    // 1. Fresh repo snapshot for consensus
+    const snapshot = await generateRepoSnapshot(projectDir);
+    const snapshotEntry = createSnapshotArtifact(snapshot, artifactManager, 'CONSENSUS_MASTER_PLAN');
+    artifacts.push(snapshotEntry);
+    pipeline.latestRepoSnapshot = artifactManager.toArtifactRef(snapshotEntry);
+
+    // 2. Find master plan artifact
+    const masterPlanArtifact = pipeline.artifacts.find((a) => a.type === 'master_plan');
+    if (!masterPlanArtifact) {
+      return failureResult('CONSENSUS_MASTER_PLAN', 'No master plan artifact found');
+    }
+
+    // 3. Build plan packet
+    const planPacket = buildPlanPacket({
+      phase: 'CONSENSUS_MASTER_PLAN',
+      submittedBy: 'DISPATCHER',
+      masterPlanRef: artifactManager.toArtifactRef(masterPlanArtifact),
+      constitutionRef: getConstitutionRef(pipeline),
+      repoSnapshotRef: artifactManager.toArtifactRef(snapshotEntry),
+      proposedArtifacts: [],
+      acceptanceCriteria: [
+        'Master plan is deterministic (no vague features)',
+        'Assumptions are explicit',
+        'Out-of-scope is explicit',
+        'Success criteria defined',
+      ],
+      dependencies: [],
+      constraints: [],
+    });
+
+    // 4. Run structured consensus
+    const gateDef = gateEngine.getGateDefinition('CONSENSUS_MASTER_PLAN');
+    const consensusPacket = await consensusRunner.runStructuredConsensus(planPacket, gateDef);
+
+    // 5. Store consensus artifact
+    const consensusEntry = artifactManager.createAndStoreJson(
+      'consensus',
+      consensusPacket,
+      'CONSENSUS_MASTER_PLAN',
+    );
+    artifacts.push(consensusEntry);
+    pipeline.artifacts.push(...artifacts);
+
+    // 5b. Store consensus score in gateResults for parseConsensusScore()
+    pipeline.gateResults['CONSENSUS_MASTER_PLAN'] = {
+      phase: 'CONSENSUS_MASTER_PLAN',
+      pass: consensusPacket.final_status === 'APPROVED' || consensusPacket.final_status === 'ARBITRATED',
+      score: consensusPacket.consensus_result.weighted_score,
+      blockers: [],
+      missingArtifacts: [],
+      failedChecks: [],
+      consensusScore: consensusPacket.consensus_result.score,
+      timestamp: new Date().toISOString(),
+    };
+
+    // 6. Trigger journalist (P1-F)
+    await triggerJournalist('CONSENSUS_MASTER_PLAN', artifacts, context);
+
+    const approved = consensusPacket.final_status === 'APPROVED' || consensusPacket.final_status === 'ARBITRATED';
+    return successResult(
+      'CONSENSUS_MASTER_PLAN',
+      artifacts,
+      approved ? 'Master Plan consensus APPROVED' : 'Master Plan consensus REJECTED',
+    );
+  } catch (err) {
+    const message = err instanceof Error ? err.message : 'Unknown error';
+    return failureResult('CONSENSUS_MASTER_PLAN', 'Consensus failed', message);
+  }
+}

package/src/pipeline/phases/consensus-role-plans.ts

@@ -0,0 +1,105 @@
+/**
+ * CONSENSUS_ROLE_PLANS phase — validate each role plan.
+ * Checks dependency satisfaction (FE->API, BE->DB, QA->features).
+ */
+
+import type { PhaseContext, PhaseResult } from './phase-context.js';
+import { successResult, failureResult, triggerJournalist } from './phase-context.js';
+import { buildPlanPacket } from '../packets/plan-packet-builder.js';
+import { generateRepoSnapshot, createSnapshotArtifact } from '../repo-snapshot.js';
+import type { PipelineState, ArtifactRef } from '../types.js';
+
+/** Get constitution artifact ref from pipeline state, or fallback */
+function getConstitutionRef(pipeline: PipelineState): ArtifactRef {
+  const constitutionArtifact = pipeline.artifacts.find((a) => a.type === 'constitution');
+  if (constitutionArtifact) {
+    return {
+      artifact_id: constitutionArtifact.id,
+      path: constitutionArtifact.path,
+      sha256: constitutionArtifact.sha256,
+      version: constitutionArtifact.version,
+      type: 'constitution',
+    };
+  }
+  return { artifact_id: 'constitution', path: 'skills/POPEYE_CONSTITUTION.md', sha256: '', version: 1, type: 'constitution' };
+}
+
+export async function runConsensusRolePlans(context: PhaseContext): Promise<PhaseResult> {
+  const { pipeline, artifactManager, gateEngine, consensusRunner, projectDir } = context;
+  const artifacts = [];
+
+  try {
+    // 1. Fresh repo snapshot
+    const snapshot = await generateRepoSnapshot(projectDir);
+    const snapshotEntry = createSnapshotArtifact(snapshot, artifactManager, 'CONSENSUS_ROLE_PLANS');
+    artifacts.push(snapshotEntry);
+    pipeline.latestRepoSnapshot = artifactManager.toArtifactRef(snapshotEntry);
+
+    // 2. Find all role plan artifacts
+    const rolePlanArtifacts = pipeline.artifacts.filter((a) => a.type === 'role_plan');
+    if (rolePlanArtifacts.length === 0) {
+      return failureResult('CONSENSUS_ROLE_PLANS', 'No role plan artifacts found');
+    }
+
+    const masterPlanArtifact = pipeline.artifacts.find((a) => a.type === 'master_plan');
+
+    // 3. Build plan packet referencing all role plans
+    const planPacket = buildPlanPacket({
+      phase: 'CONSENSUS_ROLE_PLANS',
+      submittedBy: 'DISPATCHER',
+      masterPlanRef: masterPlanArtifact
+        ? artifactManager.toArtifactRef(masterPlanArtifact)
+        : { artifact_id: 'none', path: '', sha256: '', version: 1, type: 'master_plan' },
+      constitutionRef: getConstitutionRef(pipeline),
+      repoSnapshotRef: artifactManager.toArtifactRef(snapshotEntry),
+      proposedArtifacts: rolePlanArtifacts.map((a) => artifactManager.toArtifactRef(a)),
+      acceptanceCriteria: [
+        'All required role plans present',
+        'Each plan includes deterministic file-level outputs',
+        'FE plan references API contracts',
+        'BE plan references DB schema',
+        'QA plan lists executable tests',
+      ],
+      dependencies: [],
+      constraints: [],
+    });
+
+    // 4. Run consensus
+    const gateDef = gateEngine.getGateDefinition('CONSENSUS_ROLE_PLANS');
+    const consensusPacket = await consensusRunner.runStructuredConsensus(planPacket, gateDef);
+
+    // 5. Store consensus artifact
+    const consensusEntry = artifactManager.createAndStoreJson(
+      'consensus',
+      consensusPacket,
+      'CONSENSUS_ROLE_PLANS',
+    );
+    artifacts.push(consensusEntry);
+    pipeline.artifacts.push(...artifacts);
+
+    // 5b. Store consensus score in gateResults for parseConsensusScore()
+    pipeline.gateResults['CONSENSUS_ROLE_PLANS'] = {
+      phase: 'CONSENSUS_ROLE_PLANS',
+      pass: consensusPacket.final_status === 'APPROVED' || consensusPacket.final_status === 'ARBITRATED',
+      score: consensusPacket.consensus_result.weighted_score,
+      blockers: [],
+      missingArtifacts: [],
+      failedChecks: [],
+      consensusScore: consensusPacket.consensus_result.score,
+      timestamp: new Date().toISOString(),
+    };
+
+    // 6. Journalist trigger
+    await triggerJournalist('CONSENSUS_ROLE_PLANS', artifacts, context);
+
+    const approved = consensusPacket.final_status === 'APPROVED' || consensusPacket.final_status === 'ARBITRATED';
+    return successResult(
+      'CONSENSUS_ROLE_PLANS',
+      artifacts,
+      approved ? 'Role plans consensus APPROVED' : 'Role plans consensus REJECTED',
+    );
+  } catch (err) {
+    const message = err instanceof Error ? err.message : 'Unknown error';
+    return failureResult('CONSENSUS_ROLE_PLANS', 'Role plans consensus failed', message);
+  }
+}

package/src/pipeline/phases/done.ts

@@ -0,0 +1,68 @@
+/**
+ * DONE phase — finalize documentation + release packaging.
+ * RELEASE_MANAGER creates release/deployment/rollback artifacts.
+ */
+
+import type { PhaseContext, PhaseResult } from './phase-context.js';
+import { successResult, failureResult } from './phase-context.js';
+
+export async function runDone(context: PhaseContext): Promise<PhaseResult> {
+  const { pipeline, artifactManager, skillLoader } = context;
+  const artifacts = [];
+
+  try {
+    // 1. Load release manager skill
+    const rmSkill = skillLoader.loadSkill('RELEASE_MANAGER');
+
+    // 2. Generate release notes
+    const { executePrompt } = await import('../../adapters/claude.js');
+
+    const releasePrompt = [
+      rmSkill.systemPrompt,
+      '',
+      '## Instructions',
+      'Generate release notes, deployment instructions, and rollback plan.',
+      'Base this on the artifacts produced during the pipeline.',
+      '',
+      '## Artifacts Summary',
+      ...pipeline.artifacts.map((a) => `- [${a.type}] v${a.version}: ${a.path}`),
+    ].join('\n');
+
+    const releaseResult = await executePrompt(releasePrompt);
+    const releaseResponse = releaseResult.response;
+
+    // 3. Create release notes artifact
+    const releaseEntry = artifactManager.createAndStoreText(
+      'release_notes',
+      releaseResponse,
+      'DONE',
+    );
+    artifacts.push(releaseEntry);
+
+    // 4. Create deployment instructions artifact
+    const deployEntry = artifactManager.createAndStoreText(
+      'deployment',
+      `# Deployment Instructions\n\n${releaseResponse.includes('deployment') ? 'See release notes.' : 'Standard deployment procedure.'}`,
+      'DONE',
+    );
+    artifacts.push(deployEntry);
+
+    // 5. Create rollback plan artifact
+    const rollbackEntry = artifactManager.createAndStoreText(
+      'rollback',
+      `# Rollback Plan\n\nRevert to previous version if issues detected post-deploy.`,
+      'DONE',
+    );
+    artifacts.push(rollbackEntry);
+
+    pipeline.artifacts.push(...artifacts);
+
+    // 6. Final INDEX.md update
+    artifactManager.updateIndex(pipeline.artifacts);
+
+    return successResult('DONE', artifacts, 'Pipeline complete. Release artifacts created.');
+  } catch (err) {
+    const message = err instanceof Error ? err.message : 'Unknown error';
+    return failureResult('DONE', 'Release packaging failed', message);
+  }
+}

package/src/pipeline/phases/implementation.ts

@@ -0,0 +1,48 @@
+/**
+ * IMPLEMENTATION phase — build the system according to approved plans.
+ * Reuses runExecutionMode() from existing workflow.
+ * v1.1: Injects role-specific execution contexts via role-execution-adapter.
+ */
+
+import type { PhaseContext, PhaseResult } from './phase-context.js';
+import { successResult, failureResult } from './phase-context.js';
+import { generateRepoSnapshot, createSnapshotArtifact } from '../repo-snapshot.js';
+import { buildAllRoleContexts } from '../role-execution-adapter.js';
+
+export async function runImplementation(context: PhaseContext): Promise<PhaseResult> {
+  const { pipeline, artifactManager, projectDir, skillLoader } = context;
+  const artifacts = [];
+
+  try {
+    // v1.1: Build role contexts for execution
+    const roleContexts = buildAllRoleContexts(pipeline, skillLoader, projectDir);
+
+    // Build combined role context for system prompt injection
+    let combinedRolePrompt = '';
+    if (roleContexts.size > 0) {
+      const contextEntries = Array.from(roleContexts.entries());
+      combinedRolePrompt = contextEntries
+        .map(([role, ctx]) => `## ${role}\nScope: ${ctx.taskScope.slice(0, 500)}`)
+        .join('\n\n');
+    }
+
+    // Run existing execution mode with optional role context
+    const { runExecutionMode } = await import('../../workflow/execution-mode.js');
+    await runExecutionMode({
+      projectDir,
+      ...(combinedRolePrompt ? { systemPrompt: combinedRolePrompt } : {}),
+    });
+
+    // Generate post-implementation repo snapshot
+    const snapshot = await generateRepoSnapshot(projectDir);
+    const snapshotEntry = createSnapshotArtifact(snapshot, artifactManager, 'IMPLEMENTATION');
+    artifacts.push(snapshotEntry);
+    pipeline.latestRepoSnapshot = artifactManager.toArtifactRef(snapshotEntry);
+
+    pipeline.artifacts.push(...artifacts);
+    return successResult('IMPLEMENTATION', artifacts, `Implementation complete. ${roleContexts.size} roles active.`);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : 'Unknown error';
+    return failureResult('IMPLEMENTATION', 'Implementation failed', message);
+  }
+}

package/src/pipeline/phases/index.ts

@@ -0,0 +1,21 @@
+/**
+ * Re-exports all phase implementations.
+ */
+
+export { runIntake } from './intake.js';
+export { runConsensusMasterPlan } from './consensus-master-plan.js';
+export { runArchitecture } from './architecture.js';
+export { runConsensusArchitecture } from './consensus-architecture.js';
+export { runRolePlanning } from './role-planning.js';
+export { runConsensusRolePlans } from './consensus-role-plans.js';
+export { runImplementation } from './implementation.js';
+export { runQaValidation } from './qa-validation.js';
+export { runReview } from './review.js';
+export { runAudit } from './audit.js';
+export { runProductionGate } from './production-gate.js';
+export { runRecoveryLoop } from './recovery-loop.js';
+export { runDone } from './done.js';
+export { runStuck } from './stuck.js';
+
+export type { PhaseContext, PhaseResult } from './phase-context.js';
+export { triggerJournalist, successResult, failureResult } from './phase-context.js';