popeye-cli 2.2.0 → 2.7.0

package/src/pipeline/skills/coverage-gate.ts

@@ -0,0 +1,199 @@
+/**
+ * Skill Coverage Gate — deterministic assertion that every active role
+ * has recorded usage (or is explicitly exempt).
+ *
+ * Called at CONSENSUS_ROLE_PLANS and PRODUCTION_GATE gates.
+ */
+
+import type { PipelineRole, PipelinePhase, PipelineState } from '../types.js';
+import type { SkillUsageEvent } from './usage-registry.js';
+
+// ─── Phase Order (must match orchestrator/gate phase sequence) ────
+
+/** Canonical phase order — used for phase-aware deferral in coverage checks. */
+export const PHASE_ORDER: PipelinePhase[] = [
+  'INTAKE', 'CONSENSUS_MASTER_PLAN', 'ARCHITECTURE', 'CONSENSUS_ARCHITECTURE',
+  'ROLE_PLANNING', 'CONSENSUS_ROLE_PLANS', 'IMPLEMENTATION', 'QA_VALIDATION',
+  'REVIEW', 'AUDIT', 'PRODUCTION_GATE', 'RECOVERY_LOOP', 'DONE', 'STUCK',
+];
+
+// ─── Required Usage Configuration ────────────────────────
+
+export interface RoleUsageRequirement {
+  phases: PipelinePhase[];
+  minEvents: number;
+  conditional?: 'always' | 'if_recovery' | 'if_arbitrated' | 'if_journal_triggered';
+}
+
+export const ROLE_REQUIRED_USAGE: Record<PipelineRole, RoleUsageRequirement> = {
+  DISPATCHER:          { phases: [],                    minEvents: 0 },
+  ARCHITECT:           { phases: ['ARCHITECTURE'],      minEvents: 1 },
+  DB_EXPERT:           { phases: ['ROLE_PLANNING'],     minEvents: 1 },
+  BACKEND_PROGRAMMER:  { phases: ['ROLE_PLANNING'],     minEvents: 1 },
+  FRONTEND_PROGRAMMER: { phases: ['ROLE_PLANNING'],     minEvents: 1 },
+  WEBSITE_PROGRAMMER:  { phases: ['ROLE_PLANNING'],     minEvents: 1 },
+  UI_UX_SPECIALIST:    { phases: ['ROLE_PLANNING'],     minEvents: 1 },
+  MARKETING_EXPERT:    { phases: ['ROLE_PLANNING'],     minEvents: 1 },
+  SOCIAL_EXPERT:       { phases: ['ROLE_PLANNING'],     minEvents: 1 },
+  QA_TESTER:           { phases: ['ROLE_PLANNING', 'QA_VALIDATION'], minEvents: 1 },
+  REVIEWER:            { phases: ['REVIEW'],            minEvents: 1 },
+  ARBITRATOR:          { phases: [],                    minEvents: 0, conditional: 'if_arbitrated' },
+  DEBUGGER:            { phases: ['RECOVERY_LOOP'],     minEvents: 0, conditional: 'if_recovery' },
+  AUDITOR:             { phases: ['AUDIT'],             minEvents: 1 },
+  JOURNALIST: {
+    phases: [
+      'CONSENSUS_MASTER_PLAN', 'CONSENSUS_ARCHITECTURE', 'CONSENSUS_ROLE_PLANS',
+      'AUDIT', 'PRODUCTION_GATE', 'RECOVERY_LOOP', 'DONE',
+    ],
+    minEvents: 1,
+    conditional: 'if_journal_triggered',
+  },
+  RELEASE_MANAGER:     { phases: ['DONE'],              minEvents: 1 },
+};
+
+// ─── Coverage Result ─────────────────────────────────────
+
+export interface CoverageMissing {
+  role: PipelineRole;
+  expectedPhases: PipelinePhase[];
+  reason: string;
+}
+
+export interface CoverageResult {
+  pass: boolean;
+  missing: CoverageMissing[];
+  covered: PipelineRole[];
+  /** Roles skipped because their required phases haven't been reached yet (v2.4.5) */
+  deferred: PipelineRole[];
+}
+
+// ─── Assertion Logic ─────────────────────────────────────
+
+/**
+ * Assert that all active roles have recorded skill usage
+ * according to their requirements.
+ *
+ * Args:
+ *   activeRoles: Roles currently active in the pipeline.
+ *   events: All recorded skill usage events.
+ *   pipeline: Full pipeline state for conditional checks.
+ *   currentPhase: Current pipeline phase for phase-aware deferral (v2.4.5).
+ *     Omit for strict mode (checks all roles regardless of phase).
+ *
+ * Returns:
+ *   CoverageResult with pass/fail and details.
+ */
+export function assertSkillCoverage(
+  activeRoles: PipelineRole[],
+  events: SkillUsageEvent[],
+  pipeline: PipelineState,
+  currentPhase?: PipelinePhase,
+): CoverageResult {
+  const missing: CoverageMissing[] = [];
+  const covered: PipelineRole[] = [];
+  const deferred: PipelineRole[] = [];
+
+  // Resolve phase index; -1 means unknown/omitted -> strict mode (check all)
+  const currentIdx = currentPhase ? PHASE_ORDER.indexOf(currentPhase) : -1;
+
+  for (const role of activeRoles) {
+    const requirement = ROLE_REQUIRED_USAGE[role];
+    if (!requirement) {
+      // Reason: Unknown role — skip rather than crash
+      continue;
+    }
+
+    // Meta-only roles (DISPATCHER) with minEvents 0 and no conditional
+    if (requirement.minEvents === 0 && !requirement.conditional) {
+      covered.push(role);
+      continue;
+    }
+
+    // Conditional roles — check if their condition is met
+    if (requirement.conditional) {
+      const isRequired = isConditionalRequired(requirement.conditional, pipeline);
+      if (!isRequired) {
+        // Condition not met — not required, count as covered
+        covered.push(role);
+        continue;
+      }
+    }
+
+    // v2.4.5: Phase-aware deferral — skip roles whose phases are all after currentPhase.
+    // Only applies when currentIdx >= 0 (known phase). Unknown phase = strict mode.
+    if (currentIdx >= 0 && requirement.phases.length > 0) {
+      const anyPhaseReached = requirement.phases.some(
+        (p) => PHASE_ORDER.indexOf(p) <= currentIdx,
+      );
+      if (!anyPhaseReached) {
+        // Reason: Role's required phases are all after currentPhase — defer check
+        deferred.push(role);
+        continue;
+      }
+    }
+
+    // Check if role has at least minEvents usage events
+    const roleEvents = events.filter((e) => e.role === role);
+    const effectiveMin = Math.max(requirement.minEvents, 1);
+
+    if (roleEvents.length >= effectiveMin) {
+      covered.push(role);
+    } else {
+      missing.push({
+        role,
+        expectedPhases: requirement.phases,
+        reason: roleEvents.length === 0
+          ? `No skill usage recorded for ${role}`
+          : `Only ${roleEvents.length}/${effectiveMin} usage events for ${role}`,
+      });
+    }
+  }
+
+  return {
+    pass: missing.length === 0,
+    missing,
+    covered,
+    deferred,
+  };
+}
+
+// ─── Conditional Helpers ─────────────────────────────────
+
+function isConditionalRequired(
+  conditional: NonNullable<RoleUsageRequirement['conditional']>,
+  pipeline: PipelineState,
+): boolean {
+  switch (conditional) {
+    case 'always':
+      return true;
+
+    case 'if_recovery':
+      return pipeline.recoveryCount > 0;
+
+    case 'if_arbitrated':
+      return hasArbitratedConsensus(pipeline);
+
+    case 'if_journal_triggered':
+      return hasJournalTriggered(pipeline);
+
+    default:
+      return false;
+  }
+}
+
+/** Check if any arbitration occurred during consensus phases. */
+function hasArbitratedConsensus(pipeline: PipelineState): boolean {
+  // Reason: Arbitration artifacts are created when consensus requires arbitrator intervention
+  const arbitrationArtifacts = pipeline.artifacts.filter((a) => a.type === 'arbitration');
+  return arbitrationArtifacts.length > 0;
+}
+
+/** Check if any journalist-triggering phases have completed. */
+function hasJournalTriggered(pipeline: PipelineState): boolean {
+  const journalPhases: PipelinePhase[] = [
+    'CONSENSUS_MASTER_PLAN', 'CONSENSUS_ARCHITECTURE', 'CONSENSUS_ROLE_PLANS',
+    'AUDIT', 'PRODUCTION_GATE', 'RECOVERY_LOOP', 'DONE',
+  ];
+  const completedPhases = new Set(Object.keys(pipeline.gateResults));
+  return journalPhases.some((phase) => completedPhases.has(phase));
+}

package/src/pipeline/skills/usage-registry.ts

@@ -0,0 +1,87 @@
+/**
+ * Skill Usage Registry — in-memory helper wrapping the persistent
+ * SkillUsageEvent[] array from PipelineState.
+ *
+ * Records when a skill is actually injected into an LLM prompt
+ * or execution context (not on mere load).
+ */
+
+import type { PipelineRole, PipelinePhase } from '../types.js';
+
+// ─── Types ───────────────────────────────────────────────
+
+export type SkillUsedAs =
+  | 'system_prompt'
+  | 'review_prompt'
+  | 'arbitration_prompt'
+  | 'role_context'
+  | 'planning_prompt'
+  | 'strategy_context'
+  | 'other';
+
+export type SkillSource = 'project_override' | 'defaults' | 'disk';
+
+export interface SkillUsageEvent {
+  role: PipelineRole;
+  phase: PipelinePhase;
+  used_as: SkillUsedAs;
+  skill_source: SkillSource;
+  skill_version?: string;
+  timestamp: string;
+}
+
+// ─── Registry ────────────────────────────────────────────
+
+/**
+ * Wraps the persistent events array from PipelineState.
+ * Pushes directly into the shared array reference so state
+ * serialization captures all recorded events.
+ */
+export class SkillUsageRegistry {
+  constructor(private readonly events: SkillUsageEvent[]) {}
+
+  /**
+   * Record a usage event.
+   *
+   * Call ONLY when skill is injected into an LLM prompt
+   * or execution context, not on mere load.
+   *
+   * Args:
+   *   role: The pipeline role whose skill was used.
+   *   phase: The phase during which usage occurred.
+   *   usedAs: How the skill was consumed.
+   *   skillSource: Whether from project override or defaults.
+   *   version: Optional skill version string.
+   */
+  record(
+    role: PipelineRole,
+    phase: PipelinePhase,
+    usedAs: SkillUsedAs,
+    skillSource: SkillSource,
+    version?: string,
+  ): void {
+    this.events.push({
+      role,
+      phase,
+      used_as: usedAs,
+      skill_source: skillSource,
+      skill_version: version,
+      timestamp: new Date().toISOString(),
+    });
+  }
+
+  /** Get a copy of all recorded events. */
+  getEvents(): SkillUsageEvent[] {
+    return [...this.events];
+  }
+
+  /** Get events for a specific role. */
+  getEventsForRole(role: PipelineRole): SkillUsageEvent[] {
+    return this.events.filter((e) => e.role === role);
+  }
+
+  /** Check if any usage has been recorded for a role. */
+  hasUsage(role: PipelineRole): boolean {
+    return this.events.some((e) => e.role === role);
+  }
+}

package/src/pipeline/strategy-context.ts

@@ -0,0 +1,60 @@
+/**
+ * Strategy context loader for pipeline roles.
+ * Loads website strategy from disk and formats it for injection
+ * into role planning and execution prompts.
+ */
+
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+import type { PipelineRole } from './types.js';
+import { WebsiteStrategySchema } from '../types/website-strategy.js';
+import { formatWebsiteStrategy } from '../shared/website-strategy-format.js';
+
+/** Roles that should receive website strategy context */
+export const STRATEGY_ROLES: readonly PipelineRole[] = [
+  'WEBSITE_PROGRAMMER',
+  'MARKETING_EXPERT',
+  'SOCIAL_EXPERT',
+];
+
+/** Known strategy file locations, checked in order */
+const STRATEGY_PATHS = [
+  '.popeye/website-strategy.json',
+  '.popeye/website-strategy.md',
+] as const;
+
+/**
+ * Load website strategy from disk and format for prompt injection.
+ * Checks known paths in order. Returns undefined if no valid strategy found.
+ *
+ * Args:
+ *   projectDir: Root project directory containing .popeye/.
+ *
+ * Returns:
+ *   string | undefined: Formatted strategy text, or undefined if not found/invalid.
+ */
+export function loadStrategyForRole(projectDir: string): string | undefined {
+  for (const relPath of STRATEGY_PATHS) {
+    const fullPath = join(projectDir, relPath);
+    if (!existsSync(fullPath)) continue;
+
+    try {
+      const raw = readFileSync(fullPath, 'utf-8');
+
+      // .md files: return raw content directly
+      if (relPath.endsWith('.md')) return raw;
+
+      // .json files: parse, validate, format
+      const parsed = JSON.parse(raw);
+      const strategyData = parsed.strategy ?? parsed;
+      const result = WebsiteStrategySchema.safeParse(strategyData);
+      if (!result.success) continue;
+
+      return formatWebsiteStrategy(result.data);
+    } catch {
+      continue; // Malformed file, try next path
+    }
+  }
+  return undefined;
+}

package/src/pipeline/type-defs/artifacts.ts

@@ -32,8 +32,12 @@ export const ArtifactTypeSchema = z.enum([
   'resolved_commands',
   'constitution',
   'change_request',
+  'recovery_fix_plan',
+  'auto_recovery_guidance',
   'additional_context',
   'skill_generation_log',
+  'skill_usage_log',
+  'install_check',
 ]);
 export type ArtifactType = z.infer<typeof ArtifactTypeSchema>;
 

package/src/pipeline/type-defs/checks.ts

@@ -16,6 +16,8 @@ export const GateCheckTypeSchema = z.enum([
   'placeholder_scan',
   'start',
   'env_check',
+  'skill_coverage',
+  'install',
 ]);
 export type GateCheckType = z.infer<typeof GateCheckTypeSchema>;
 
@@ -42,6 +44,8 @@ export const ResolvedCommandsSchema = z.object({
   typecheck: z.string().optional(),
   migrations: z.string().optional(),
   start: z.string().optional(),
+  install: z.string().optional(),
+  install_cwd: z.string().optional(),
   resolved_from: z.string(),
 });
 export type ResolvedCommands = z.infer<typeof ResolvedCommandsSchema>;

package/src/pipeline/type-defs/packets.ts

@@ -51,8 +51,10 @@ export const ReviewerVoteSchema = z.object({
   vote: z.enum(['APPROVE', 'REJECT', 'CONDITIONAL']),
   confidence: z.number().min(0).max(1),
   blocking_issues: z.array(z.string()),
+  required_changes: z.array(z.string()).optional(),
   suggestions: z.array(z.string()),
   evidence_refs: z.array(ArtifactRefSchema),
+  reviewer_inconsistency: z.boolean().optional(),
 });
 export type ReviewerVote = z.infer<typeof ReviewerVoteSchema>;
 
@@ -69,6 +71,7 @@ export const ConsensusResultSchema = z.object({
   score: z.number().min(0).max(1),
   weighted_score: z.number().min(0).max(1),
   participating_reviewers: z.number().int(),
+  has_true_blockers: z.boolean().default(false),
 });
 
 export const ArbitratorResultSchema = z.object({
@@ -77,6 +80,13 @@ export const ArbitratorResultSchema = z.object({
   artifact_ref: ArtifactRefSchema.optional(),
 });
 
+export const NormalizationMovesSchema = z.object({
+  tagged_blockers_demoted_to_suggestions: z.number(),
+  tagged_blockers_demoted_to_required: z.number(),
+  untagged_from_blocking_routed_to_required: z.number(),
+  forced_rejects: z.number(),
+}).optional();
+
 export const ConsensusPacketSchema = z.object({
   metadata: z.object({
     packet_id: z.string(),
@@ -89,6 +99,7 @@ export const ConsensusPacketSchema = z.object({
   consensus_result: ConsensusResultSchema,
   arbitrator_result: ArbitratorResultSchema.optional(),
   final_status: z.enum(['APPROVED', 'REJECTED', 'ARBITRATED']),
+  normalization_moves: NormalizationMovesSchema,
 });
 export type ConsensusPacket = z.infer<typeof ConsensusPacketSchema>;
 
@@ -125,7 +136,13 @@ export const ChangeRequestSchema = z.object({
     affected_phases: z.array(PipelinePhaseSchema),
     risk_level: z.enum(['low', 'medium', 'high']),
   }),
-  status: z.enum(['proposed', 'approved', 'rejected']),
+  status: z.enum(['proposed', 'approved', 'rejected', 'resolved']),
   approval_artifact: ArtifactRefSchema.optional(),
+  /** Deterministic drift fingerprint for CR deduplication (v2.4.9) */
+  drift_key: z.string().optional(),
+  /** ISO timestamp when the CR was resolved (v2.4.9) */
+  resolved_at: z.string().optional(),
+  /** How the CR was resolved (v2.4.9) */
+  resolution: z.enum(['accepted_baseline', 'reverted', 'manual_override']).optional(),
 });
 export type ChangeRequest = z.infer<typeof ChangeRequestSchema>;

package/src/pipeline/type-defs/state.ts

@@ -9,6 +9,7 @@ import { GateCheckTypeSchema, GateCheckResultSchema, ResolvedCommandsSchema, typ
 import type { ArtifactType } from './artifacts.js';
 import type { ConsensusPacket } from './packets.js';
 import type { RCAPacket } from './packets.js';
+// Reason: SkillUsageEvent type is defined inline in the Zod schema to keep state serialization self-contained
 
 // ─── Gate Definition ─────────────────────────────────────
 
@@ -88,6 +89,7 @@ export const PipelineStateSchema = z.object({
     missingArtifacts: z.array(ArtifactTypeSchema),
     failedChecks: z.array(GateCheckTypeSchema),
     consensusScore: z.number().optional(),
+    finalStatus: z.string().optional(),  // v2.4.3: 'APPROVED' | 'REJECTED' | 'ARBITRATED'
     timestamp: z.string(),
   })),
   gateChecks: z.record(z.string(), z.array(GateCheckResultSchema)),
@@ -97,6 +99,12 @@ export const PipelineStateSchema = z.object({
   resolvedCommands: ResolvedCommandsSchema.optional(),
   /** Tracks which phase failed, for recovery routing */
   failedPhase: PipelinePhaseSchema.optional(),
+  /** Last rewind target from recovery — detects repeated same-target rewinds (v2.4.6) */
+  lastRewindTarget: PipelinePhaseSchema.optional(),
+  /** v2.6.0: Auto-recovery result — tracks whether arbitrator guidance was attempted before STUCK */
+  autoRecoveryResult: z.enum(['success', 'timeout', 'invalid', 'error']).optional(),
+  /** v2.7.0: Baseline failure count before recovery — for regression detection */
+  recoveryBaselineFailedCheckCount: z.number().int().min(0).optional(),
   /** Session guidance: user steering, upgrade context, or resume instructions */
   sessionGuidance: z.string().optional(),
   /** Pending change requests that force re-routing to consensus phases (v1.1) */
@@ -104,7 +112,23 @@ export const PipelineStateSchema = z.object({
     cr_id: z.string(),
     change_type: z.enum(['scope', 'architecture', 'dependency', 'config', 'requirement']),
     target_phase: PipelinePhaseSchema,
-    status: z.enum(['proposed', 'approved', 'rejected']),
+    status: z.enum(['proposed', 'approved', 'rejected', 'resolved']),
+    drift_key: z.string().optional(),
+  })).optional(),
+  /** ID of the CR currently being processed by the routed phase (v2.4.9) */
+  activeChangeRequestId: z.string().optional(),
+  /** Snapshot override: after config CR resolved, REVIEW uses this instead of CONSENSUS_ROLE_PLANS baseline (v2.4.9) */
+  baselineSnapshotOverride: ArtifactRefSchema.optional(),
+  /** Rolling loop signatures for stagnation detection (v2.4.9) */
+  lastSignatures: z.array(z.string()).optional(),
+  /** Skill usage events for coverage enforcement (v2.2.1) */
+  skillUsageEvents: z.array(z.object({
+    role: PipelineRoleSchema,
+    phase: PipelinePhaseSchema,
+    used_as: z.enum(['system_prompt', 'review_prompt', 'arbitration_prompt', 'role_context', 'planning_prompt', 'other']),
+    skill_source: z.enum(['project_override', 'defaults']),
+    skill_version: z.string().optional(),
+    timestamp: z.string(),
   })).optional(),
 });
 export type PipelineState = z.infer<typeof PipelineStateSchema>;
@@ -163,5 +187,6 @@ export function createDefaultPipelineState(): PipelineState {
     gateChecks: {},
     activeRoles: [],
     constitutionHash: '',
+    skillUsageEvents: [],
   };
 }

package/src/shared/text-utils.ts

@@ -0,0 +1,70 @@
+/**
+ * Text utilities for normalizing LLM-generated issue lists.
+ * Detects false-positive "no issues" responses that LLMs produce in
+ * BLOCKING_ISSUES fields (e.g. "No blocking issues found", "N/A", "None identified").
+ */
+
+/** Exact-match tokens that mean "nothing" after trim+lowercase */
+const NONE_EXACT = new Set(['none', 'n/a', 'na', 'nil', 'nothing']);
+
+/**
+ * Anchored phrase patterns that indicate "no issues".
+ * Tested against the cleaned text (bullet-stripped, trimmed, lowercased,
+ * trailing punctuation removed).
+ */
+const NONE_PHRASES: RegExp[] = [
+  /^no\s+(?:(?:blocking|critical|significant|major)\s+)*(?:issues?|concerns?|problems?|blockers?|showstoppers?)\b/,
+  /^none\s+(?:identified|found|detected|noted|observed|reported|applicable|at this time)\b/,
+  /^there\s+are\s+no\s+(?:(?:significant|major|critical|blocking)\s+)*(?:issues|concerns|problems|blockers)\b/,
+];
+
+/**
+ * Determine whether a text string is a "none-variant" — an LLM's way of
+ * saying "no blocking issues" rather than an actual issue description.
+ *
+ * @param text - Raw text from a blocking_issues list item
+ * @returns true if the text is a none-variant (should be filtered out)
+ */
+export function isNoneVariant(text: string): boolean {
+  // Empty / whitespace-only
+  const trimmed = text.trim();
+  if (trimmed.length === 0) return true;
+
+  // Strip leading bullet prefixes: "- ", "* ", "+ ", "1) ", "1. ", etc.
+  const stripped = trimmed.replace(/^[-*+\d.)\s]+/, '').trim();
+  if (stripped.length === 0) return true;
+
+  // Strip trailing punctuation
+  const cleaned = stripped.replace(/[.,;!]+$/, '').trim();
+  if (cleaned.length === 0) return true;
+
+  const lower = cleaned.toLowerCase();
+
+  // Exact match check
+  if (NONE_EXACT.has(lower)) return true;
+
+  // Anchored phrase check
+  for (const pattern of NONE_PHRASES) {
+    if (pattern.test(lower)) return true;
+  }
+
+  // Length guard: >80 chars and no phrase match means it is likely a real issue
+  if (cleaned.length > 80) return false;
+
+  return false;
+}
+
+/**
+ * Normalize an issue list by filtering out empty strings and none-variants.
+ * Intended as a drop-in replacement for the weak `.filter(i => i.toLowerCase() !== 'none')`
+ * used across adapters.
+ *
+ * @param items - Raw list items from parseList()
+ * @returns Filtered list with only genuine issues
+ */
+export function normalizeIssueList(items: string[]): string[] {
+  return items
+    .map((i) => i.trim())
+    .filter((i) => i.length > 0)
+    .filter((i) => !isNoneVariant(i));
+}

package/src/shared/website-strategy-format.ts

@@ -0,0 +1,56 @@
+/**
+ * Shared website strategy formatter.
+ * Formats a WebsiteStrategyDocument as structured text for prompt injection.
+ * Used by both workflow (plan-mode consensus) and pipeline (role planning/execution).
+ */
+
+import type { WebsiteStrategyDocument } from '../types/website-strategy.js';
+
+/**
+ * Format a WebsiteStrategyDocument as structured text for prompt injection.
+ *
+ * Args:
+ *   strategy: The validated strategy document to format.
+ *
+ * Returns:
+ *   string: Multi-line formatted text with ICP, Positioning, Messaging,
+ *           SEO Keywords, Site Architecture, and Conversion Strategy sections.
+ */
+export function formatWebsiteStrategy(strategy: WebsiteStrategyDocument): string {
+  const lines: string[] = [];
+
+  lines.push(`### Target Customer`);
+  lines.push(`- Persona: ${strategy.icp.primaryPersona}`);
+  lines.push(`- Pain points: ${strategy.icp.painPoints.join(', ')}`);
+  lines.push('');
+
+  lines.push(`### Positioning`);
+  lines.push(`- Category: ${strategy.positioning.category}`);
+  lines.push(`- Value proposition: ${strategy.positioning.valueProposition}`);
+  lines.push(`- Differentiators: ${strategy.positioning.differentiators.join(', ')}`);
+  lines.push('');
+
+  lines.push(`### Messaging`);
+  lines.push(`- Headline: ${strategy.messaging.headline}`);
+  lines.push(`- Subheadline: ${strategy.messaging.subheadline}`);
+  lines.push('');
+
+  lines.push(`### SEO Keywords`);
+  lines.push(`- Primary: ${strategy.seoStrategy.primaryKeywords.join(', ')}`);
+  lines.push(`- Secondary: ${strategy.seoStrategy.secondaryKeywords.join(', ')}`);
+  lines.push('');
+
+  lines.push(`### Site Architecture`);
+  for (const page of strategy.siteArchitecture.pages) {
+    lines.push(`- ${page.path} (${page.pageType}): ${page.purpose}`);
+  }
+  lines.push('');
+
+  lines.push(`### Conversion Strategy`);
+  lines.push(`- Primary CTA: "${strategy.conversionStrategy.primaryCta.text}" -> ${strategy.conversionStrategy.primaryCta.href}`);
+  lines.push(`- Secondary CTA: "${strategy.conversionStrategy.secondaryCta.text}" -> ${strategy.conversionStrategy.secondaryCta.href}`);
+  lines.push(`- Trust signals: ${strategy.conversionStrategy.trustSignals.join(', ')}`);
+  lines.push(`- Lead capture: ${strategy.conversionStrategy.leadCapture}`);
+
+  return lines.join('\n');
+}