popeye-cli 2.1.0 → 2.7.0

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,7 +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');
+}

package/src/state/index.ts

@@ -578,6 +578,10 @@ export interface ProjectProgressAnalysis {
   statusMismatch: boolean;  // true if status='complete' but work is incomplete
   planMismatch: boolean;    // true if plan file has more tasks than state
 
+  // Pipeline state (when applicable)
+  pipelinePhase?: string;       // Current pipeline phase (e.g. 'DONE', 'STUCK', 'IMPLEMENTATION')
+  pipelineTerminal: boolean;    // true if pipeline is in DONE or STUCK state
+
   // Milestone breakdown (from state)
   totalMilestones: number;
   completedMilestones: number;
@@ -780,14 +784,42 @@ export async function analyzeProjectProgress(projectDir: string): Promise<Projec
     : 0;
 
   // Determine if actually complete - must match plan if plan has more tasks
-  const isActuallyComplete = totalMilestones > 0 &&
-    completedMilestones === totalMilestones &&
-    completedTasks === totalTasks &&
-    !planMismatch; // Can't be complete if plan has more tasks
+  // v2.4.6: When no milestones/tasks exist in state but project was explicitly
+  // marked complete (status='complete' + phase='complete'), trust the status.
+  // completeProject() only sets both to 'complete' after build verification passes.
+  const noTrackingData = totalMilestones === 0 && totalTasks === 0;
+  const explicitlyCompleted = state.status === 'complete' && state.phase === 'complete';
+
+  // Pipeline state detection — pipeline truth overrides milestone truth.
+  // RECOVERY_LOOP is treated as stuck-like: the pipeline was interrupted mid-recovery
+  // and will just re-fail without new guidance.
+  const pipelinePhase = state.pipeline?.pipelinePhase;
+  const pipelineStuckLike = pipelinePhase === 'STUCK' || pipelinePhase === 'RECOVERY_LOOP';
+  const pipelineTerminal = pipelinePhase === 'DONE' || pipelineStuckLike;
+  const pipelineDone = pipelinePhase === 'DONE';
+
+  let isActuallyComplete: boolean;
+  if (noTrackingData && pipelinePhase) {
+    // Pipeline project: pipeline state is the source of truth.
+    // DONE = complete, STUCK = not complete.
+    // planMismatch is irrelevant — pipeline projects don't track milestones.
+    isActuallyComplete = pipelineDone;
+  } else if (noTrackingData) {
+    // Legacy project with no tracking: trust explicit completion only
+    isActuallyComplete = explicitlyCompleted && !planMismatch;
+  } else {
+    // Standard milestone-based: all milestones + tasks must be complete
+    isActuallyComplete = totalMilestones > 0 &&
+      completedMilestones === totalMilestones &&
+      completedTasks === totalTasks &&
+      !planMismatch; // Can't be complete if plan has more tasks
+  }
 
-  // Check for status mismatch
+  // Check for status mismatch.
+  // Pipeline terminal states are handled separately — not "mismatches".
   const statusMismatch = (state.status === 'complete' || state.phase === 'complete') &&
-    (!isActuallyComplete || planMismatch);
+    (!isActuallyComplete || planMismatch) &&
+    !pipelineTerminal;
 
   // Find next items to work on
   let nextMilestone: { id: string; name: string } | undefined;
@@ -836,6 +868,15 @@ export async function analyzeProjectProgress(projectDir: string): Promise<Projec
   if (planMismatch) {
     progressSummary = `PLAN MISMATCH: State has ${completedTasks}/${totalTasks} tasks but plan has ${planTaskCount} tasks. ` +
       `Only ${percentComplete}% of plan completed.`;
+  } else if (isActuallyComplete && pipelineDone && noTrackingData) {
+    progressSummary = 'Project completed via pipeline';
+  } else if (isActuallyComplete && noTrackingData) {
+    progressSummary = 'Project completed (no milestone tracking data)';
+  } else if (pipelineStuckLike) {
+    const failedAt = state.pipeline?.failedPhase ?? 'unknown';
+    const recoveryCount = state.pipeline?.recoveryCount ?? 0;
+    const label = pipelinePhase === 'RECOVERY_LOOP' ? 'PIPELINE STUCK (in recovery)' : 'PIPELINE STUCK';
+    progressSummary = `${label}: Failed at ${failedAt} after ${recoveryCount} recovery attempts`;
   } else if (isActuallyComplete) {
     progressSummary = `All ${totalTasks} tasks complete across ${totalMilestones} milestones`;
   } else if (statusMismatch) {
@@ -848,6 +889,8 @@ export async function analyzeProjectProgress(projectDir: string): Promise<Projec
     isActuallyComplete,
     statusMismatch,
     planMismatch,
+    pipelinePhase,
+    pipelineTerminal,
     totalMilestones,
     completedMilestones,
     inProgressMilestones,
@@ -927,6 +970,15 @@ export async function verifyProjectCompletion(projectDir: string): Promise<{
  * @returns Updated state
  */
 export async function resetIncompleteProject(projectDir: string): Promise<ProjectState> {
+  const current = await loadProject(projectDir);
+
+  // Pipeline projects should not be reset via legacy path —
+  // legacy reset changes phase/status but not pipeline.pipelinePhase,
+  // creating inconsistent state. Pipeline resume handles its own recovery.
+  if (current.pipeline?.pipelinePhase) {
+    return current;
+  }
+
   const verification = await verifyProjectCompletion(projectDir);
 
   if (verification.isComplete) {
@@ -955,8 +1007,8 @@ export async function resetIncompleteProject(projectDir: string): Promise<Projec
   }
 
   // Reset any failed tasks to pending for retry
-  const current = await loadProject(projectDir);
-  const updatedMilestones = current.milestones.map(m => ({
+  const latestState = await loadProject(projectDir);
+  const updatedMilestones = latestState.milestones.map(m => ({
     ...m,
     // Reset milestone status if it was incorrectly marked complete
     status: m.tasks.every(t => t.status === 'complete')

package/src/types/consensus.ts

@@ -35,6 +35,7 @@ export interface ConsensusResult {
   analysis: string;
   strengths: string[];
   concerns: string[];
+  blockingIssues: string[];
   recommendations: string[];
   approved: boolean;
   rawResponse: string;

package/src/types/workflow.ts

@@ -11,6 +11,8 @@ import type { TestPlanOutput } from './tester.js';
 import { TestPlanOutputSchema, TestVerdictSchema } from './tester.js';
 import type { DbConfig } from './database.js';
 import { DbConfigSchema } from './database.js';
+import { PipelineStateSchema } from '../pipeline/types.js';
+import type { PipelineState } from '../pipeline/types.js';
 
 /**
  * Workflow phases
@@ -244,6 +246,8 @@ export interface ProjectState {
   auditLastRunAt?: string;
   /** Unique identifier for the audit run */
   auditRunId?: string;
+  /** Pipeline execution state — persisted for resume across sessions (v2.4.5) */
+  pipeline?: PipelineState;
 }
 
 /**
@@ -271,6 +275,7 @@ export const ProjectStateSchema = z.object({
         analysis: z.string(),
         strengths: z.array(z.string()),
         concerns: z.array(z.string()),
+        blockingIssues: z.array(z.string()).default([]),
         recommendations: z.array(z.string()),
         approved: z.boolean(),
         rawResponse: z.string(),
@@ -296,6 +301,7 @@ export const ProjectStateSchema = z.object({
   auditRecoveryInProgress: z.boolean().optional(),
   auditLastRunAt: z.string().optional(),
   auditRunId: z.string().optional(),
+  pipeline: PipelineStateSchema.optional(),
 });
 
 /**

package/src/upgrade/handlers.ts

@@ -21,7 +21,7 @@ import {
   generateRootDockerCompose,
 } from '../generators/templates/fullstack.js';
 import { loadState, saveState } from '../state/persistence.js';
-import { buildWebsiteContext, resolveBrandAssets, validateWebsiteContext } from '../generators/website-context.js';
+import { buildWebsiteContext, resolveBrandAssets, validateWebsiteContext, extractDocPathsFromText } from '../generators/website-context.js';
 import type { WebsiteContentContext } from '../generators/website-context.js';
 import { resolveWorkspaceRoot } from '../generators/workspace-root.js';
 import { loadWebsiteStrategy } from '../workflow/website-strategy.js';
@@ -61,11 +61,17 @@ export async function buildUpgradeContentContext(
   projectName: string,
 ): Promise<{ context?: WebsiteContentContext; warning?: string }> {
   try {
+    // Load state once for idea text + brand context
+    const state = await loadState(projectDir);
+
     // Build context from user docs (scans projectDir + parent via getScanDirectories)
-    const context = await buildWebsiteContext(projectDir, projectName);
+    // Extract extra doc paths from state idea text if available
+    const extraDocPaths = state?.idea ? extractDocPathsFromText(state.idea) : [];
+    const context = await buildWebsiteContext(
+      projectDir, projectName, state?.specification ?? state?.idea, extraDocPaths,
+    );
 
     // Apply brand context from state if available
-    const state = await loadState(projectDir);
     if (state?.brandContext?.primaryColor) {
       context.brand = { ...context.brand, primaryColor: state.brandContext.primaryColor };
     }

package/src/workflow/consensus.ts

@@ -1176,6 +1176,7 @@ export async function runOptimizedConsensusProcess(
       score: combinedScore,
       analysis: combinedAnalysis,
       concerns: allConcerns,
+      blockingIssues: [],
       recommendations: allRecommendations,
       approved: combinedScore >= threshold,
       strengths: [],

package/src/workflow/website-strategy.ts

@@ -13,6 +13,7 @@ import type {
   BrandAssetsContract,
 } from '../types/website-strategy.js';
 import { WebsiteStrategySchema } from '../types/website-strategy.js';
+import { formatWebsiteStrategy } from '../shared/website-strategy-format.js';
 import { createClient } from '../adapters/openai.js';
 
 /** File name for persisted strategy */
@@ -187,42 +188,7 @@ Respond with ONLY valid JSON, no markdown code fences or explanation.`;
 export function formatStrategyForPlanContext(
   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');
+  return formatWebsiteStrategy(strategy);
 }
 
 /**

package/src/workflow/website-updater.ts

@@ -9,7 +9,7 @@ import path from 'node:path';
 import type { ProjectState } from '../types/workflow.js';
 import type { OutputLanguage } from '../types/project.js';
 import { isWorkspace } from '../types/project.js';
-import { buildWebsiteContext, resolveBrandAssets, validateWebsiteContext } from '../generators/website-context.js';
+import { buildWebsiteContext, resolveBrandAssets, validateWebsiteContext, extractDocPathsFromText } from '../generators/website-context.js';
 import { resolveWorkspaceRoot } from '../generators/workspace-root.js';
 import { generateWebsiteLandingPage } from '../generators/templates/website-landing.js';
 import { generateWebsitePricingPage } from '../generators/templates/website-pricing.js';
@@ -52,10 +52,12 @@ export async function updateWebsiteContent(
 
   // Build content context from user docs and specification
   const parentDir = path.dirname(projectDir);
+  const extraDocPaths = state.idea ? extractDocPathsFromText(state.idea) : [];
   const context = await buildWebsiteContext(
     parentDir,
     state.name,
-    state.specification
+    state.specification,
+    extraDocPaths,
   );
 
   // Apply brand context from state if available