bmalph 2.3.0 → 2.5.0

package/dist/commands/status.js

@@ -2,6 +2,8 @@ import chalk from "chalk";
 import { readConfig } from "../utils/config.js";
 import { readState, readRalphStatus, getPhaseLabel, getPhaseInfo } from "../utils/state.js";
 import { withErrorHandling } from "../utils/errors.js";
+import { resolveProjectPlatform } from "../platform/resolve.js";
+import { scanProjectArtifacts } from "../transition/artifact-scan.js";
 export async function statusCommand(options) {
     await withErrorHandling(() => runStatus(options));
 }
@@ -15,17 +17,37 @@ export async function runStatus(options) {
     }
     // Read current state
     const state = await readState(projectDir);
-    const phase = state?.currentPhase ?? 1;
+    const storedPhase = state?.currentPhase ?? 1;
     const status = state?.status ?? "planning";
-    const phaseName = getPhaseLabel(phase);
-    const phaseInfo = getPhaseInfo(phase);
     // Read Ralph status if in implementation phase
     let ralphStatus = null;
-    if (phase === 4) {
+    if (storedPhase === 4) {
         ralphStatus = await readRalphStatus(projectDir);
     }
-    // Determine next action
-    const nextAction = getNextAction(phase, status, ralphStatus);
+    // Scan artifacts for phases 1-3 to detect actual progress
+    let artifactScan = null;
+    let phase = storedPhase;
+    let phaseDetected = false;
+    if (phase < 4) {
+        artifactScan = await scanProjectArtifacts(projectDir);
+        if (artifactScan && artifactScan.detectedPhase > phase) {
+            phase = artifactScan.detectedPhase;
+            phaseDetected = true;
+        }
+    }
+    const phaseName = getPhaseLabel(phase);
+    const phaseInfo = getPhaseInfo(phase);
+    // Resolve platform for next action hints
+    const platform = await resolveProjectPlatform(projectDir);
+    // Determine next action — use artifact-based suggestion when available
+    const nextAction = artifactScan && phaseDetected
+        ? artifactScan.nextAction
+        : getNextAction(phase, status, ralphStatus, platform);
+    // Detect when Ralph completed but bmalph state hasn't caught up
+    const completionMismatch = phase === 4 &&
+        status === "implementing" &&
+        ralphStatus !== null &&
+        ralphStatus.status === "completed";
     if (options.json) {
         const output = {
             phase,
@@ -40,17 +62,37 @@ export async function runStatus(options) {
                 tasksTotal: ralphStatus.tasksTotal,
             };
         }
+        if (artifactScan) {
+            output.artifacts = {
+                directory: artifactScan.directory,
+                found: artifactScan.found,
+                detectedPhase: artifactScan.detectedPhase,
+                missing: artifactScan.missing,
+            };
+        }
         if (nextAction) {
             output.nextAction = nextAction;
         }
+        if (completionMismatch) {
+            output.completionMismatch = true;
+        }
         console.log(JSON.stringify(output, null, 2));
         return;
     }
     // Human-readable output
     console.log(chalk.bold("bmalph status\n"));
-    console.log(`  ${chalk.cyan("Phase:")} ${phase} - ${phaseName}`);
+    const phaseLabel = phaseDetected
+        ? `${phase} - ${phaseName} (detected from artifacts)`
+        : `${phase} - ${phaseName}`;
+    console.log(`  ${chalk.cyan("Phase:")} ${phaseLabel}`);
     console.log(`  ${chalk.cyan("Agent:")} ${phaseInfo.agent}`);
     console.log(`  ${chalk.cyan("Status:")} ${formatStatus(status)}`);
+    // Show artifact checklist for phases 1-3
+    if (artifactScan) {
+        console.log("");
+        console.log(chalk.bold(`  Artifacts (${artifactScan.directory})`));
+        printArtifactChecklist(artifactScan);
+    }
     if (phase === 4 && ralphStatus) {
         console.log("");
         console.log(chalk.bold("  Ralph Loop"));
@@ -63,11 +105,55 @@ export async function runStatus(options) {
         console.log(chalk.bold("  Ralph Loop"));
         console.log(`    ${chalk.cyan("Status:")} ${chalk.dim("not started")}`);
     }
-    if (nextAction) {
+    if (completionMismatch) {
+        console.log("");
+        console.log(chalk.green("  Ralph has completed all tasks."));
+        console.log(`  ${chalk.cyan("Next:")} Review changes and update project phase`);
+    }
+    else if (nextAction) {
         console.log("");
         console.log(`  ${chalk.cyan("Next:")} ${nextAction}`);
     }
 }
+const ARTIFACT_DEFINITIONS = [
+    { phase: 1, name: "Product Brief", required: false },
+    { phase: 1, name: "Market Research", required: false },
+    { phase: 1, name: "Domain Research", required: false },
+    { phase: 1, name: "Technical Research", required: false },
+    { phase: 2, name: "PRD", required: true },
+    { phase: 2, name: "UX Design", required: false },
+    { phase: 3, name: "Architecture", required: true },
+    { phase: 3, name: "Epics & Stories", required: true },
+    { phase: 3, name: "Readiness Report", required: true },
+];
+const PHASE_LABELS = {
+    1: "Phase 1 - Analysis",
+    2: "Phase 2 - Planning",
+    3: "Phase 3 - Solutioning",
+};
+function printArtifactChecklist(scan) {
+    const foundByName = new Map();
+    for (const artifacts of [scan.phases[1], scan.phases[2], scan.phases[3]]) {
+        for (const artifact of artifacts) {
+            foundByName.set(artifact.name, artifact);
+        }
+    }
+    let currentPhase = 0;
+    for (const def of ARTIFACT_DEFINITIONS) {
+        if (def.phase !== currentPhase) {
+            currentPhase = def.phase;
+            console.log(`    ${PHASE_LABELS[currentPhase]}`);
+        }
+        const found = foundByName.get(def.name);
+        if (found) {
+            console.log(`      ${chalk.green("*")} ${def.name} (${found.filename})`);
+        }
+        else {
+            const suffix = def.required ? " (required)" : "";
+            console.log(`      ${chalk.dim("-")} ${def.name}${suffix}`);
+        }
+    }
+}
 function formatStatus(status) {
     switch (status) {
         case "planning":
@@ -94,7 +180,7 @@ function formatRalphStatus(status) {
             return status;
     }
 }
-function getNextAction(phase, status, ralphStatus) {
+function getNextAction(phase, status, ralphStatus, platform) {
     if (status === "completed") {
         return null;
     }
@@ -104,10 +190,13 @@ function getNextAction(phase, status, ralphStatus) {
         case 2:
             return "Run /pm to create PRD";
         case 3:
-            return "Run /bmalph-implement when ready for implementation";
+            return "Run: bmalph implement";
         case 4:
             if (!ralphStatus || ralphStatus.status === "not_started") {
-                return "Start Ralph loop with: bash .ralph/ralph_loop.sh";
+                if (platform.tier === "full") {
+                    return `Start Ralph loop with: bash .ralph/drivers/${platform.id}.sh`;
+                }
+                return "Ralph requires a full-tier platform (Claude Code or Codex)";
             }
             if (ralphStatus.status === "blocked") {
                 return "Review Ralph logs: bmalph doctor";

package/dist/commands/watch.d.ts

@@ -0,0 +1,6 @@
+interface WatchCommandOptions {
+    interval?: string;
+    projectDir: string;
+}
+export declare function watchCommand(options: WatchCommandOptions): Promise<void>;
+export {};

package/dist/commands/watch.js

@@ -0,0 +1,19 @@
+import { readConfig } from "../utils/config.js";
+import { withErrorHandling } from "../utils/errors.js";
+import { startDashboard } from "../watch/dashboard.js";
+const DEFAULT_INTERVAL_MS = 2000;
+export async function watchCommand(options) {
+    await withErrorHandling(() => runWatch(options));
+}
+async function runWatch(options) {
+    const projectDir = options.projectDir;
+    const config = await readConfig(projectDir);
+    if (!config) {
+        throw new Error("Project not initialized. Run: bmalph init");
+    }
+    const interval = options.interval ? parseInt(options.interval, 10) : DEFAULT_INTERVAL_MS;
+    if (isNaN(interval) || interval < 500) {
+        throw new Error("Interval must be a number >= 500 (milliseconds)");
+    }
+    await startDashboard({ projectDir, interval });
+}

package/dist/installer.d.ts

@@ -28,12 +28,6 @@ export declare function generateManifests(projectDir: string): Promise<void>;
  * Creates the file if it doesn't exist, replaces an existing BMAD section on upgrade.
  */
 export declare function mergeInstructionsFile(projectDir: string, platform?: Platform): Promise<void>;
-/**
- * @deprecated Use `mergeInstructionsFile(projectDir)` instead.
- * Kept for backward compatibility during migration.
- */
-export declare function mergeClaudeMd(projectDir: string): Promise<void>;
 export declare function isInitialized(projectDir: string): Promise<boolean>;
-export declare function hasExistingBmadDir(projectDir: string): Promise<boolean>;
 export declare function previewInstall(projectDir: string, platform?: Platform): Promise<PreviewInstallResult>;
 export declare function previewUpgrade(projectDir: string, platform?: Platform): Promise<PreviewUpgradeResult>;

package/dist/installer.js

@@ -424,19 +424,9 @@ export async function mergeInstructionsFile(projectDir, platform) {
     }
     await atomicWriteFile(instructionsPath, existing + snippet);
 }
-/**
- * @deprecated Use `mergeInstructionsFile(projectDir)` instead.
- * Kept for backward compatibility during migration.
- */
-export async function mergeClaudeMd(projectDir) {
-    return mergeInstructionsFile(projectDir);
-}
 export async function isInitialized(projectDir) {
     return exists(join(projectDir, CONFIG_FILE));
 }
-export async function hasExistingBmadDir(projectDir) {
-    return exists(join(projectDir, "_bmad"));
-}
 export async function previewInstall(projectDir, platform) {
     const p = platform ?? (await getDefaultPlatform());
     const wouldCreate = [];

package/dist/platform/claude-code.js

@@ -36,7 +36,6 @@ Use \`/bmalph\` to navigate phases. Use \`/bmad-help\` to discover all commands.
 | \`/bmalph-implement\` | Transition planning artifacts → prepare Ralph loop |
 | \`/bmalph-upgrade\` | Update bundled assets to match current bmalph version |
 | \`/bmalph-doctor\` | Check project health and report issues |
-| \`/bmalph-reset\` | Reset state (soft or hard reset with confirmation) |
 
 ### Available Agents
 

package/dist/reset.d.ts

@@ -0,0 +1,18 @@
+import type { Platform } from "./platform/types.js";
+import type { DryRunAction } from "./utils/dryrun.js";
+export interface ResetPlan {
+    directories: string[];
+    commandFiles: string[];
+    instructionsCleanup: {
+        path: string;
+        sectionsToRemove: string[];
+    } | null;
+    gitignoreLines: string[];
+    warnings: Array<{
+        path: string;
+        message: string;
+    }>;
+}
+export declare function buildResetPlan(projectDir: string, platform: Platform): Promise<ResetPlan>;
+export declare function executeResetPlan(projectDir: string, plan: ResetPlan): Promise<void>;
+export declare function planToDryRunActions(plan: ResetPlan): DryRunAction[];

package/dist/reset.js

@@ -0,0 +1,181 @@
+import { readdir, readFile, rm } from "fs/promises";
+import { join, posix } from "path";
+import { getSlashCommandsDir } from "./installer.js";
+import { exists, atomicWriteFile } from "./utils/file-system.js";
+import { isEnoent } from "./utils/errors.js";
+import { BMAD_DIR, RALPH_DIR, BMALPH_DIR, BMAD_OUTPUT_DIR } from "./utils/constants.js";
+export async function buildResetPlan(projectDir, platform) {
+    const plan = {
+        directories: [],
+        commandFiles: [],
+        instructionsCleanup: null,
+        gitignoreLines: [],
+        warnings: [],
+    };
+    // Check which managed directories exist
+    for (const dir of [BMAD_DIR, RALPH_DIR, BMALPH_DIR]) {
+        if (await exists(join(projectDir, dir))) {
+            plan.directories.push(dir);
+        }
+    }
+    // Check for slash commands to remove (directory delivery only)
+    if (platform.commandDelivery.kind === "directory") {
+        const commandsDir = join(projectDir, platform.commandDelivery.dir);
+        if (await exists(commandsDir)) {
+            const bundledNames = await getBundledCommandNames();
+            try {
+                const existingFiles = await readdir(commandsDir);
+                for (const file of existingFiles) {
+                    if (file.endsWith(".md") && bundledNames.has(file)) {
+                        plan.commandFiles.push(posix.join(platform.commandDelivery.dir, file));
+                    }
+                }
+            }
+            catch (err) {
+                if (!isEnoent(err))
+                    throw err;
+            }
+        }
+    }
+    // Check instructions file for BMAD sections
+    try {
+        const content = await readFile(join(projectDir, platform.instructionsFile), "utf-8");
+        const sectionsToRemove = [];
+        if (content.includes(platform.instructionsSectionMarker)) {
+            sectionsToRemove.push(platform.instructionsSectionMarker);
+        }
+        // Codex (inline) also has a BMAD Commands section
+        if (platform.commandDelivery.kind === "inline" && content.includes("## BMAD Commands")) {
+            sectionsToRemove.push("## BMAD Commands");
+        }
+        if (sectionsToRemove.length > 0) {
+            plan.instructionsCleanup = {
+                path: platform.instructionsFile,
+                sectionsToRemove,
+            };
+        }
+    }
+    catch (err) {
+        if (!isEnoent(err))
+            throw err;
+    }
+    // Check .gitignore for bmalph entries
+    try {
+        const content = await readFile(join(projectDir, ".gitignore"), "utf-8");
+        const existingLines = new Set(content
+            .split(/\r?\n/)
+            .map((line) => line.trim())
+            .filter(Boolean));
+        const bmalpEntries = [".ralph/logs/", "_bmad-output/"];
+        for (const entry of bmalpEntries) {
+            if (existingLines.has(entry)) {
+                plan.gitignoreLines.push(entry);
+            }
+        }
+    }
+    catch (err) {
+        if (!isEnoent(err))
+            throw err;
+    }
+    // Warn about _bmad-output/
+    if (await exists(join(projectDir, BMAD_OUTPUT_DIR))) {
+        plan.warnings.push({
+            path: `${BMAD_OUTPUT_DIR}/`,
+            message: "Contains user planning artifacts — not removed by reset",
+        });
+    }
+    return plan;
+}
+async function getBundledCommandNames() {
+    const slashCommandsDir = getSlashCommandsDir();
+    try {
+        const files = await readdir(slashCommandsDir);
+        return new Set(files.filter((f) => f.endsWith(".md")));
+    }
+    catch (err) {
+        if (!isEnoent(err))
+            throw err;
+        return new Set();
+    }
+}
+export async function executeResetPlan(projectDir, plan) {
+    // Delete managed directories
+    for (const dir of plan.directories) {
+        await rm(join(projectDir, dir), { recursive: true, force: true });
+    }
+    // Delete slash command files
+    for (const file of plan.commandFiles) {
+        await rm(join(projectDir, file), { force: true });
+    }
+    // Clean instructions file
+    if (plan.instructionsCleanup) {
+        const filePath = join(projectDir, plan.instructionsCleanup.path);
+        try {
+            let content = await readFile(filePath, "utf-8");
+            for (const marker of plan.instructionsCleanup.sectionsToRemove) {
+                content = removeSection(content, marker);
+            }
+            content = content.trim();
+            if (content.length === 0) {
+                await rm(filePath, { force: true });
+            }
+            else {
+                await atomicWriteFile(filePath, content + "\n");
+            }
+        }
+        catch (err) {
+            if (!isEnoent(err))
+                throw err;
+        }
+    }
+    // Clean .gitignore
+    if (plan.gitignoreLines.length > 0) {
+        const filePath = join(projectDir, ".gitignore");
+        try {
+            const content = await readFile(filePath, "utf-8");
+            const cleaned = removeGitignoreLines(content, plan.gitignoreLines);
+            await atomicWriteFile(filePath, cleaned);
+        }
+        catch (err) {
+            if (!isEnoent(err))
+                throw err;
+        }
+    }
+}
+function removeSection(content, marker) {
+    if (!content.includes(marker))
+        return content;
+    const sectionStart = content.indexOf(marker);
+    const before = content.slice(0, sectionStart);
+    const afterSection = content.slice(sectionStart);
+    // Find next level-2 heading that doesn't match this section's heading
+    const markerEscaped = marker.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const nextHeadingMatch = afterSection.match(new RegExp(`\\n## (?!${markerEscaped.slice(3)})`));
+    const after = nextHeadingMatch ? afterSection.slice(nextHeadingMatch.index) : "";
+    return before.trimEnd() + after;
+}
+function removeGitignoreLines(content, linesToRemove) {
+    const removeSet = new Set(linesToRemove);
+    const lines = content.split(/\r?\n/);
+    const filtered = lines.filter((line) => !removeSet.has(line.trim()));
+    return filtered.join("\n");
+}
+export function planToDryRunActions(plan) {
+    const actions = [];
+    for (const dir of plan.directories) {
+        actions.push({ type: "delete", path: `${dir}/` });
+    }
+    for (const file of plan.commandFiles) {
+        actions.push({ type: "delete", path: file });
+    }
+    if (plan.instructionsCleanup) {
+        actions.push({ type: "modify", path: plan.instructionsCleanup.path });
+    }
+    if (plan.gitignoreLines.length > 0) {
+        actions.push({ type: "modify", path: ".gitignore" });
+    }
+    for (const warning of plan.warnings) {
+        actions.push({ type: "warn", path: warning.path, reason: warning.message });
+    }
+    return actions;
+}

package/dist/transition/artifact-scan.d.ts

@@ -0,0 +1,27 @@
+export interface ArtifactClassification {
+    phase: number;
+    name: string;
+    required: boolean;
+}
+export interface ScannedArtifact extends ArtifactClassification {
+    filename: string;
+}
+export interface PhaseArtifacts {
+    1: ScannedArtifact[];
+    2: ScannedArtifact[];
+    3: ScannedArtifact[];
+}
+export interface ProjectArtifactScan {
+    directory: string;
+    found: string[];
+    detectedPhase: number;
+    missing: string[];
+    phases: PhaseArtifacts;
+    nextAction: string;
+}
+export declare function classifyArtifact(filename: string): ArtifactClassification | null;
+export declare function scanArtifacts(files: string[]): PhaseArtifacts;
+export declare function detectPhase(phases: PhaseArtifacts): number;
+export declare function getMissing(phases: PhaseArtifacts): string[];
+export declare function suggestNext(phases: PhaseArtifacts, detectedPhase: number): string;
+export declare function scanProjectArtifacts(projectDir: string): Promise<ProjectArtifactScan | null>;

package/dist/transition/artifact-scan.js

@@ -0,0 +1,91 @@
+import { readdir } from "fs/promises";
+import { relative } from "path";
+import { findArtifactsDir } from "./artifacts.js";
+const ARTIFACT_RULES = [
+    { pattern: /brief/i, phase: 1, name: "Product Brief", required: false },
+    { pattern: /market/i, phase: 1, name: "Market Research", required: false },
+    { pattern: /domain/i, phase: 1, name: "Domain Research", required: false },
+    { pattern: /tech.*research/i, phase: 1, name: "Technical Research", required: false },
+    { pattern: /prd/i, phase: 2, name: "PRD", required: true },
+    { pattern: /ux/i, phase: 2, name: "UX Design", required: false },
+    { pattern: /architect/i, phase: 3, name: "Architecture", required: true },
+    { pattern: /epic|stor/i, phase: 3, name: "Epics & Stories", required: true },
+    { pattern: /readiness/i, phase: 3, name: "Readiness Report", required: true },
+];
+export function classifyArtifact(filename) {
+    for (const rule of ARTIFACT_RULES) {
+        if (rule.pattern.test(filename)) {
+            return { phase: rule.phase, name: rule.name, required: rule.required };
+        }
+    }
+    return null;
+}
+export function scanArtifacts(files) {
+    const phases = { 1: [], 2: [], 3: [] };
+    for (const file of files) {
+        const classification = classifyArtifact(file);
+        if (classification) {
+            const phaseKey = classification.phase;
+            phases[phaseKey].push({ ...classification, filename: file });
+        }
+    }
+    return phases;
+}
+export function detectPhase(phases) {
+    for (const phase of [3, 2, 1]) {
+        if (phases[phase].length > 0) {
+            return phase;
+        }
+    }
+    return 1;
+}
+export function getMissing(phases) {
+    const missing = [];
+    const foundNames = new Set([...phases[1], ...phases[2], ...phases[3]].map((a) => a.name));
+    for (const rule of ARTIFACT_RULES) {
+        if (rule.required && !foundNames.has(rule.name)) {
+            missing.push(rule.name);
+        }
+    }
+    return missing;
+}
+export function suggestNext(phases, detectedPhase) {
+    const foundNames = new Set([...phases[1], ...phases[2], ...phases[3]].map((a) => a.name));
+    if (detectedPhase <= 1 && phases[1].length === 0) {
+        return "Run /analyst to start analysis";
+    }
+    if (!foundNames.has("PRD")) {
+        return "Run /create-prd to create the PRD";
+    }
+    if (!foundNames.has("Architecture")) {
+        return "Run /architect to create architecture";
+    }
+    if (!foundNames.has("Epics & Stories")) {
+        return "Run /create-epics-stories to define epics and stories";
+    }
+    if (!foundNames.has("Readiness Report")) {
+        return "Run /architect to generate readiness report";
+    }
+    return "Run: bmalph implement";
+}
+export async function scanProjectArtifacts(projectDir) {
+    const artifactsDir = await findArtifactsDir(projectDir);
+    if (!artifactsDir) {
+        return null;
+    }
+    const files = await readdir(artifactsDir);
+    const phases = scanArtifacts(files);
+    const detectedPhase = detectPhase(phases);
+    const missing = getMissing(phases);
+    const nextAction = suggestNext(phases, detectedPhase);
+    const relativeDir = relative(projectDir, artifactsDir).replace(/\\/g, "/");
+    const found = files.filter((f) => classifyArtifact(f) !== null);
+    return {
+        directory: relativeDir,
+        found,
+        detectedPhase,
+        missing,
+        phases,
+        nextAction,
+    };
+}

package/dist/transition/artifacts.d.ts

@@ -1,2 +1 @@
 export declare function findArtifactsDir(projectDir: string): Promise<string | null>;
-export declare function validateArtifacts(files: string[], artifactsDir: string): Promise<string[]>;

package/dist/transition/artifacts.js

@@ -1,4 +1,3 @@
-import { readFile } from "fs/promises";
 import { join } from "path";
 import { debug } from "../utils/logger.js";
 import { exists } from "../utils/file-system.js";
@@ -19,28 +18,3 @@ export async function findArtifactsDir(projectDir) {
     debug(`No artifacts found. Checked: ${candidates.join(", ")}`);
     return null;
 }
-export async function validateArtifacts(files, artifactsDir) {
-    const warnings = [];
-    const hasPrd = files.some((f) => /prd/i.test(f));
-    if (!hasPrd) {
-        warnings.push("No PRD document found in planning artifacts");
-    }
-    const hasArchitecture = files.some((f) => /architect/i.test(f));
-    if (!hasArchitecture) {
-        warnings.push("No architecture document found in planning artifacts");
-    }
-    // Check readiness report for NO-GO
-    const readinessFile = files.find((f) => /readiness/i.test(f));
-    if (readinessFile) {
-        try {
-            const content = await readFile(join(artifactsDir, readinessFile), "utf-8");
-            if (/NO[-\s]?GO/i.test(content)) {
-                warnings.push("Readiness report indicates NO-GO status");
-            }
-        }
-        catch {
-            warnings.push("Could not read readiness report — NO-GO status unverified");
-        }
-    }
-    return warnings;
-}

package/dist/transition/context.js

@@ -37,6 +37,8 @@ export function extractProjectContext(artifacts) {
     // Combine all content, keyed by likely role
     let prdContent = "";
     let archContent = "";
+    let uxContent = "";
+    let researchContent = "";
     for (const [filename, content] of artifacts) {
         if (/prd/i.test(filename))
             prdContent += "\n" + content;
@@ -44,6 +46,10 @@ export function extractProjectContext(artifacts) {
             archContent += "\n" + content;
         if (/readiness/i.test(filename))
             archContent += "\n" + content;
+        if (/ux/i.test(filename))
+            uxContent += "\n" + content;
+        if (/research|market|domain|brief/i.test(filename))
+            researchContent += "\n" + content;
     }
     const allContent = prdContent + "\n" + archContent;
     const truncated = [];
@@ -98,6 +104,28 @@ export function extractProjectContext(artifacts) {
                 /^##\s+Quality Attributes/m,
             ],
         },
+        {
+            field: "designGuidelines",
+            source: uxContent,
+            patterns: [
+                /^##\s+Design Principles/m,
+                /^##\s+Design System/m,
+                /^##\s+Core Experience/m,
+                /^##\s+User Flows/m,
+                /^##\s+Visual Foundation/m,
+            ],
+        },
+        {
+            field: "researchInsights",
+            source: researchContent,
+            patterns: [
+                /^##\s+Key Findings/m,
+                /^##\s+Recommendations/m,
+                /^##\s+Market Analysis/m,
+                /^##\s+Domain Insights/m,
+                /^##\s+Summary/m,
+            ],
+        },
     ];
     const context = {
         projectGoals: "",
@@ -107,6 +135,8 @@ export function extractProjectContext(artifacts) {
         scopeBoundaries: "",
         targetUsers: "",
         nonFunctionalRequirements: "",
+        designGuidelines: "",
+        researchInsights: "",
     };
     for (const { field, source, patterns } of fields) {
         const result = extractFromPatternsWithInfo(source, patterns);
@@ -140,6 +170,8 @@ export function generateProjectContextMd(context, projectName) {
         { heading: "Scope Boundaries", content: context.scopeBoundaries },
         { heading: "Target Users", content: context.targetUsers },
         { heading: "Non-Functional Requirements", content: context.nonFunctionalRequirements },
+        { heading: "Design Guidelines", content: context.designGuidelines },
+        { heading: "Research Insights", content: context.researchInsights },
     ];
     for (const { heading, content } of sections) {
         if (content) {
@@ -161,6 +193,8 @@ export function generatePrompt(projectName, context) {
             context.targetUsers && `### Target Users\n${context.targetUsers}`,
             context.nonFunctionalRequirements &&
                 `### Non-Functional Requirements\n${context.nonFunctionalRequirements}`,
+            context.designGuidelines && `### Design Guidelines\n${context.designGuidelines}`,
+            context.researchInsights && `### Research Insights\n${context.researchInsights}`,
         ]
             .filter(Boolean)
             .join("\n\n")