@codeyam/codeyam-cli 0.1.0-staging.a890816 → 0.1.0-staging.ae0de75

package/codeyam-cli/src/commands/editor.js

@@ -1,11 +1,13 @@
 import * as fs from 'fs';
 import * as path from 'path';
+import * as os from 'os';
 import { fileURLToPath } from 'url';
 import chalk from 'chalk';
 import { runAnalysisForEntities } from "../utils/analysisRunner.js";
 import { ProgressReporter } from "../utils/progress.js";
 import { initializeEnvironment } from "../utils/database.js";
 import { loadEntities, loadAnalyses } from "../../../packages/database/index.js";
+import { IS_INTERNAL_BUILD } from "../utils/buildFlags.js";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 const STEP_LABELS = {
@@ -19,7 +21,8 @@ const STEP_LABELS = {
     8: 'App Scenarios',
     9: 'User Scenarios',
     10: 'Verify',
-    11: 'Review',
+    11: 'Journal',
+    12: 'Review',
 };
 /**
  * Append a JSONL log entry to .codeyam/logs/editor-log.jsonl
@@ -125,7 +128,7 @@ function stepHeader(step, title, feature) {
 function printProgressTracker(current) {
     console.log();
     console.log(chalk.dim('┌─────────────────────────────────────┐'));
-    for (let i = 1; i <= 11; i++) {
+    for (let i = 1; i <= 12; i++) {
         const label = STEP_LABELS[i];
         const num = i < 10 ? ` ${i}` : `${i}`;
         const content = `${num}. ${label.padEnd(28)}`;
@@ -163,7 +166,7 @@ function stopGate(current, opts) {
     console.log(chalk.yellow('For the CURRENT step (→), show each checklist item with ✓ (done) or ✗ (skipped + reason).'));
     console.log(chalk.yellow('If any items are ✗, explain why and ask if the user wants to address them.'));
     console.log();
-    if (current < 10) {
+    if (current < 12) {
         console.log(chalk.green('When done, run: ') +
             chalk.bold(`codeyam editor ${current + 1}`));
     }
@@ -174,6 +177,219 @@ function stopGate(current, opts) {
     }
     console.log();
 }
+/**
+ * Print a RESUMING header with step-specific investigation instructions.
+ * Called when a step is re-entered (prevState.step === current step).
+ */
+function printResumptionHeader(step) {
+    const port = getServerPort();
+    const checks = {
+        1: [
+            'Check if plan was already written to context file:\n      `cat .codeyam/editor-mode-context.md`',
+        ],
+        2: ['Check if project files already exist:\n      `ls package.json src/`'],
+        3: ['This is a confirmation step — just re-present to user'],
+        4: [
+            'Check if extraction plan already exists in context file:\n      `cat .codeyam/editor-mode-context.md`',
+        ],
+        5: [
+            'Check if components/functions already extracted:\n      `ls src/components/ src/lib/`',
+        ],
+        6: [
+            'Check if glossary already populated:\n      `cat .codeyam/glossary.json`',
+        ],
+        7: ['Check if isolation routes and registered scenarios already exist'],
+        8: [
+            `Check existing scenarios:\n      \`curl -s http://localhost:${port}/api/editor-scenarios\``,
+        ],
+        9: [
+            `Check existing user-persona scenarios:\n      \`curl -s http://localhost:${port}/api/editor-scenarios\``,
+        ],
+        10: ['Re-verify is safe to repeat — just re-run the checks'],
+        11: [
+            `Check if a journal entry already exists for this feature:\n      \`curl -s http://localhost:${port}/api/editor-journal\``,
+            'If an entry exists, use PATCH to update it — do NOT create a new one',
+        ],
+        12: ['Check if commit already made:\n      `git log --oneline -3`'],
+    };
+    const label = STEP_LABELS[step] || 'Unknown';
+    console.log(chalk.bold.yellow(`━━━ RESUMING Step ${step}: ${label} ━━━`));
+    console.log(chalk.yellow('This step was already started. Before repeating any actions, investigate:'));
+    const items = checks[step] || [];
+    for (const item of items) {
+        checkbox(item);
+    }
+    console.log();
+}
+function captureOutput(fn) {
+    const stdoutWrite = process.stdout.write.bind(process.stdout);
+    const stderrWrite = process.stderr.write.bind(process.stderr);
+    const chunks = [];
+    const captureWrite = (chunk, encoding, cb) => {
+        const text = typeof chunk === 'string'
+            ? chunk
+            : chunk instanceof Buffer
+                ? chunk.toString(typeof encoding === 'string' ? encoding : undefined)
+                : String(chunk);
+        chunks.push(text);
+        if (typeof encoding === 'function') {
+            encoding();
+        }
+        if (typeof cb === 'function') {
+            cb();
+        }
+        return true;
+    };
+    process.stdout.write = captureWrite;
+    process.stderr.write = captureWrite;
+    try {
+        fn();
+    }
+    finally {
+        process.stdout.write = stdoutWrite;
+        process.stderr.write = stderrWrite;
+    }
+    return chunks.join('');
+}
+function withTempRoot(hasProject, fn) {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), 'codeyam-editor-debug-'));
+    if (hasProject) {
+        fs.writeFileSync(path.join(root, 'package.json'), '{"name":"codeyam-editor-debug","private":true}', 'utf8');
+    }
+    try {
+        return fn(root);
+    }
+    finally {
+        try {
+            fs.rmSync(root, { recursive: true, force: true });
+        }
+        catch {
+            // Best-effort cleanup
+        }
+    }
+}
+function makeState(step, feature) {
+    const now = new Date().toISOString();
+    return {
+        feature,
+        step,
+        label: STEP_LABELS[step],
+        startedAt: now,
+        featureStartedAt: now,
+    };
+}
+function normalizeDebugTarget(raw) {
+    const value = raw.trim().toLowerCase();
+    if (!value)
+        return '';
+    if (value === 'setup')
+        return 'setup';
+    if (value === 'overview')
+        return 'overview';
+    if (value === 'overview-with-state' || value === 'overview-state') {
+        return 'overview-with-state';
+    }
+    if (/^\d+$/.test(value)) {
+        return `step-${value}`;
+    }
+    if (/^step-?\d+$/.test(value)) {
+        const num = value.replace('step', '').replace('-', '');
+        return `step-${num}`;
+    }
+    return value;
+}
+function parseDebugTargets(target) {
+    if (!target || target.trim().toLowerCase() === 'all')
+        return null;
+    const rawTargets = target
+        .split(',')
+        .map((t) => normalizeDebugTarget(t))
+        .filter(Boolean);
+    const valid = new Set();
+    for (const entry of rawTargets) {
+        if (entry === 'setup' ||
+            entry === 'overview' ||
+            entry === 'overview-with-state') {
+            valid.add(entry);
+            continue;
+        }
+        if (entry.startsWith('step-')) {
+            const num = parseInt(entry.replace('step-', ''), 10);
+            if (!isNaN(num) && num >= 1 && num <= 12) {
+                valid.add(`step-${num}`);
+                continue;
+            }
+        }
+        throw new Error(`Invalid debug target: "${entry}"`);
+    }
+    return valid;
+}
+function writeContextSnapshot(root, outDir) {
+    const contextDir = path.join(outDir, 'context');
+    fs.mkdirSync(contextDir, { recursive: true });
+    const entries = [];
+    const skillPath = path.join(root, '.claude', 'skills', 'codeyam-editor', 'SKILL.md');
+    const skillFallback = path.join(__dirname, '..', '..', 'templates', 'codeyam-editor.md');
+    const skillSource = fs.existsSync(skillPath) ? skillPath : skillFallback;
+    const skillDest = path.join(contextDir, 'codeyam-editor-skill.md');
+    fs.copyFileSync(skillSource, skillDest);
+    entries.push({
+        label: 'codeyam-editor skill',
+        source: skillSource,
+        file: path.relative(outDir, skillDest),
+        status: fs.existsSync(skillPath) ? 'installed' : 'template',
+    });
+    const claudePath = path.join(root, 'CLAUDE.md');
+    if (fs.existsSync(claudePath)) {
+        const dest = path.join(contextDir, 'CLAUDE.md');
+        fs.copyFileSync(claudePath, dest);
+        entries.push({
+            label: 'CLAUDE.md',
+            source: claudePath,
+            file: path.relative(outDir, dest),
+            status: 'project',
+        });
+    }
+    else {
+        const fallback = path.join(__dirname, '..', '..', 'templates', 'codeyam-editor-claude.md');
+        if (fs.existsSync(fallback)) {
+            const dest = path.join(contextDir, 'CLAUDE.md');
+            fs.copyFileSync(fallback, dest);
+            entries.push({
+                label: 'CLAUDE.md',
+                source: fallback,
+                file: path.relative(outDir, dest),
+                status: 'template',
+            });
+        }
+        else {
+            entries.push({
+                label: 'CLAUDE.md',
+                file: path.relative(outDir, path.join(contextDir, 'CLAUDE.md')),
+                status: 'missing',
+            });
+        }
+    }
+    const contextPath = path.join(root, '.codeyam', 'editor-mode-context.md');
+    if (fs.existsSync(contextPath)) {
+        const dest = path.join(contextDir, 'editor-mode-context.md');
+        fs.copyFileSync(contextPath, dest);
+        entries.push({
+            label: 'editor-mode-context.md',
+            source: contextPath,
+            file: path.relative(outDir, dest),
+            status: 'project',
+        });
+    }
+    else {
+        entries.push({
+            label: 'editor-mode-context.md',
+            file: path.relative(outDir, path.join(contextDir, 'editor-mode-context.md')),
+            status: 'missing',
+        });
+    }
+    return entries;
+}
 // ─── Setup (no args, no project) ──────────────────────────────────────
 function printSetup(root) {
     const port = getServerPort();
@@ -212,7 +428,7 @@ function printCycleOverview(root, state) {
             chalk.dim(' to start a new feature'));
     }
     else {
-        console.log('Each feature follows 11 steps. You MUST run each command in order:');
+        console.log('Each feature follows 12 steps. You MUST run each command in order:');
         console.log();
         console.log(`  ${chalk.bold.yellow(' 1')} ${chalk.bold('Plan')}            — Plan the feature, confirm with user`);
         console.log(`  ${chalk.bold.yellow(' 2')} ${chalk.bold('Prototype')}       — Build a working prototype fast`);
@@ -224,7 +440,8 @@ function printCycleOverview(root, state) {
         console.log(`  ${chalk.bold.yellow(' 8')} ${chalk.bold('App Scenarios')}   — Create app-level scenarios`);
         console.log(`  ${chalk.bold.yellow(' 9')} ${chalk.bold('User Scenarios')}  — Create user-persona scenarios`);
         console.log(`  ${chalk.bold.yellow('10')} ${chalk.bold('Verify')}          — Review screenshots, check for errors`);
-        console.log(`  ${chalk.bold.yellow('11')} ${chalk.bold('Review')}          — Present summary, get approval`);
+        console.log(`  ${chalk.bold.yellow('11')} ${chalk.bold('Journal')}         — Create/update journal entry`);
+        console.log(`  ${chalk.bold.yellow('12')} ${chalk.bold('Review')}          — Present summary, get approval`);
         console.log();
         console.log(chalk.green('Start now: ') + chalk.bold('codeyam editor 1'));
     }
@@ -232,7 +449,11 @@ function printCycleOverview(root, state) {
 }
 // ─── Step 1: Plan ─────────────────────────────────────────────────────
 function printStep1(root, feature) {
-    clearState(root);
+    const prevState = readState(root);
+    const isResuming = prevState?.step === 1;
+    if (!isResuming) {
+        clearState(root);
+    }
     // If feature is provided, save initial state so step 2 can pick it up
     if (feature) {
         const now = new Date().toISOString();
@@ -240,12 +461,15 @@ function printStep1(root, feature) {
             feature,
             step: 1,
             label: STEP_LABELS[1],
-            startedAt: now,
-            featureStartedAt: now,
+            startedAt: isResuming ? prevState.startedAt : now,
+            featureStartedAt: isResuming ? prevState.featureStartedAt : now,
         });
     }
     logEvent(root, 'step', { step: 1, label: 'Plan', feature });
     stepHeader(1, 'Plan', feature);
+    if (isResuming) {
+        printResumptionHeader(1);
+    }
     console.log('Plan the feature before writing ANY code.');
     console.log();
     console.log(chalk.bold('Checklist:'));
@@ -254,6 +478,7 @@ function printStep1(root, feature) {
     checkbox('Ask clarifying questions using `AskUserQuestion` with selectable options');
     console.log(chalk.dim('    Use AskUserQuestion for EVERY clarifying question — give 2-4 concrete options the user can pick from.'));
     console.log(chalk.dim('    Focus on what the USER will see and do, not on databases, APIs, or components.'));
+    console.log(chalk.dim('    Do NOT ask about tech stack, frameworks, libraries, or implementation details — only ask about user-facing choices.'));
     console.log(chalk.dim('    Good: "What should happen when there are no results?" → options: "Show empty state message", "Show suggestions"'));
     console.log(chalk.dim('    Bad:  Free-form text asking "What do you think about the data model?"'));
     console.log(chalk.dim('    You can ask up to 4 questions at once. Bundle related questions into a single AskUserQuestion call.'));
@@ -288,16 +513,21 @@ function printStep1(root, feature) {
 function printStep2(root, feature) {
     const port = getServerPort();
     const projectExists = hasProject(root);
+    const prevState = readState(root);
+    const isResuming = prevState?.step === 2;
     const now = new Date().toISOString();
     writeState(root, {
         feature,
         step: 2,
         label: STEP_LABELS[2],
-        startedAt: now,
-        featureStartedAt: now,
+        startedAt: isResuming ? prevState.startedAt : now,
+        featureStartedAt: isResuming ? prevState.featureStartedAt : now,
     });
     logEvent(root, 'step', { step: 2, label: 'Prototype', feature });
     stepHeader(2, 'Prototype', feature);
+    if (isResuming) {
+        printResumptionHeader(2);
+    }
     console.log('Build fast with real data. Prioritize speed over quality.');
     console.log();
     // If no project exists yet, include scaffolding instructions first
@@ -327,7 +557,7 @@ function printStep2(root, feature) {
             console.log(chalk.dim('  Key: Seed scripts must use the adapter pattern (see prisma/seed.ts).'));
         }
         else {
-            checkbox('Scaffold the project (Next.js recommended) using temp-dir-rsync pattern');
+            checkbox('Scaffold the project (Next.js App Router) using temp-dir-rsync pattern');
             console.log();
             console.log(chalk.dim('  Scaffolding pattern (avoids .claude/ conflicts):'));
             console.log(chalk.dim('  SCAFFOLD_DIR="/tmp/codeyam-scaffold-$$" && mkdir -p "$SCAFFOLD_DIR"'));
@@ -382,22 +612,35 @@ function printStep2(root, feature) {
 function printStep3(root, feature) {
     const port = getServerPort();
     const prevState = readState(root);
+    const isResuming = prevState?.step === 3;
+    const now = new Date().toISOString();
     writeState(root, {
         feature,
         step: 3,
         label: STEP_LABELS[3],
-        startedAt: new Date().toISOString(),
-        featureStartedAt: prevState?.featureStartedAt || new Date().toISOString(),
+        startedAt: isResuming ? prevState.startedAt : now,
+        featureStartedAt: prevState?.featureStartedAt || now,
     });
     logEvent(root, 'step', { step: 3, label: 'Confirm', feature });
     stepHeader(3, 'Confirm', feature);
+    if (isResuming) {
+        printResumptionHeader(3);
+    }
     console.log('Summarize what was built and get user confirmation.');
     console.log();
     console.log(chalk.bold('Before presenting — verify everything works:'));
     checkbox(`Refresh the preview: \`curl -s -X POST http://localhost:${port}/api/editor-refresh\``);
-    checkbox('Verify the page loads without errors (no error pages, no blank screens)');
-    checkbox('Verify all images and assets render correctly (no broken images)');
+    checkbox(`Refresh and check for SSR errors: \`curl -s -X POST http://localhost:${port}/api/dev-mode-preview\` — look at the \`preview\` field for \`healthy: false\``);
     checkbox('Verify API routes return valid data (curl each route)');
+    checkbox(`Navigate to each page and check health: \`curl -s -X POST http://localhost:${port}/api/dev-mode-preview -H 'Content-Type: application/json' -d '{"path":"/your-route"}'\``);
+    console.log();
+    console.log(chalk.bold('  Check for broken images on each page:'));
+    checkbox('Get the dev server URL from `curl -s http://localhost:' +
+        port +
+        '/api/editor-dev-server` (the `url` field)');
+    checkbox('For each page: `curl -s <dev-server-url>/your-route` and inspect `<img>` src attributes');
+    checkbox('Verify every image src is a valid path (not a missing file, placeholder URL, or broken reference)');
+    checkbox('If any images are broken: fix the src (use real assets, placeholders from a CDN, or remove the image)');
     console.log(chalk.yellow('    Do not present to the user until all checks pass. Fix issues first.'));
     console.log();
     console.log(chalk.bold('Then present to the user:'));
@@ -416,15 +659,20 @@ function printStep3(root, feature) {
 // ─── Step 4: Deconstruct ──────────────────────────────────────────────
 function printStep4(root, feature) {
     const prevState = readState(root);
+    const isResuming = prevState?.step === 4;
+    const now = new Date().toISOString();
     writeState(root, {
         feature,
         step: 4,
         label: STEP_LABELS[4],
-        startedAt: new Date().toISOString(),
-        featureStartedAt: prevState?.featureStartedAt || new Date().toISOString(),
+        startedAt: isResuming ? prevState.startedAt : now,
+        featureStartedAt: prevState?.featureStartedAt || now,
     });
     logEvent(root, 'step', { step: 4, label: 'Deconstruct', feature });
     stepHeader(4, 'Deconstruct', feature);
+    if (isResuming) {
+        printResumptionHeader(4);
+    }
     console.log(chalk.bold('Goal: pages contain ONLY components. Components contain ONLY sub-components.'));
     console.log(chalk.yellow('This step is read and plan only. Code extraction happens in step 5.'));
     console.log();
@@ -461,15 +709,20 @@ function printStep4(root, feature) {
 // ─── Step 5: Extract ──────────────────────────────────────────────────
 function printStep5(root, feature) {
     const prevState = readState(root);
+    const isResuming = prevState?.step === 5;
+    const now = new Date().toISOString();
     writeState(root, {
         feature,
         step: 5,
         label: STEP_LABELS[5],
-        startedAt: new Date().toISOString(),
-        featureStartedAt: prevState?.featureStartedAt || new Date().toISOString(),
+        startedAt: isResuming ? prevState.startedAt : now,
+        featureStartedAt: prevState?.featureStartedAt || now,
     });
     logEvent(root, 'step', { step: 5, label: 'Extract', feature });
     stepHeader(5, 'Extract', feature);
+    if (isResuming) {
+        printResumptionHeader(5);
+    }
     console.log('Execute your extraction plan from step 4.');
     console.log();
     console.log(chalk.bold('Components:'));
@@ -503,15 +756,20 @@ function printStep5(root, feature) {
 // ─── Step 6: Glossary ─────────────────────────────────────────────────
 function printStep6(root, feature) {
     const prevState = readState(root);
+    const isResuming = prevState?.step === 6;
+    const now = new Date().toISOString();
     writeState(root, {
         feature,
         step: 6,
         label: STEP_LABELS[6],
-        startedAt: new Date().toISOString(),
-        featureStartedAt: prevState?.featureStartedAt || new Date().toISOString(),
+        startedAt: isResuming ? prevState.startedAt : now,
+        featureStartedAt: prevState?.featureStartedAt || now,
     });
     logEvent(root, 'step', { step: 6, label: 'Glossary', feature });
     stepHeader(6, 'Glossary', feature);
+    if (isResuming) {
+        printResumptionHeader(6);
+    }
     console.log('Record all new functions/components in `.codeyam/glossary.json`.');
     console.log();
     console.log(chalk.bold('Checklist:'));
@@ -535,15 +793,20 @@ function printStep6(root, feature) {
 function printStep7(root, feature) {
     const port = getServerPort();
     const prevState = readState(root);
+    const isResuming = prevState?.step === 7;
+    const now = new Date().toISOString();
     writeState(root, {
         feature,
         step: 7,
         label: STEP_LABELS[7],
-        startedAt: new Date().toISOString(),
-        featureStartedAt: prevState?.featureStartedAt || new Date().toISOString(),
+        startedAt: isResuming ? prevState.startedAt : now,
+        featureStartedAt: prevState?.featureStartedAt || now,
     });
     logEvent(root, 'step', { step: 7, label: 'Analyze', feature });
     stepHeader(7, 'Analyze and Verify', feature);
+    if (isResuming) {
+        printResumptionHeader(7);
+    }
     console.log('Verify visual components (via isolation routes) and library functions (via tests).');
     console.log();
     console.log(chalk.bold('Visual Components — Component Isolation:'));
@@ -590,21 +853,28 @@ function printStep7(root, feature) {
     checkbox('If any test fails, fix the source code and re-run');
     console.log();
     console.log(chalk.dim('Do not proceed until both component isolations and library tests pass.'));
+    console.log();
+    checkbox('Run `codeyam editor audit` to verify all components have scenarios and all functions have tests');
     stopGate(7);
 }
 // ─── Step 8: App Scenarios ────────────────────────────────────────────
 function printStep8(root, feature) {
     const port = getServerPort();
     const prevState = readState(root);
+    const isResuming = prevState?.step === 8;
+    const now = new Date().toISOString();
     writeState(root, {
         feature,
         step: 8,
         label: STEP_LABELS[8],
-        startedAt: new Date().toISOString(),
-        featureStartedAt: prevState?.featureStartedAt || new Date().toISOString(),
+        startedAt: isResuming ? prevState.startedAt : now,
+        featureStartedAt: prevState?.featureStartedAt || now,
     });
     logEvent(root, 'step', { step: 8, label: 'App Scenarios', feature });
     stepHeader(8, 'App Scenarios', feature);
+    if (isResuming) {
+        printResumptionHeader(8);
+    }
     console.log('Create app-level scenarios representing different data states.');
     console.log();
     console.log(chalk.bold('Checklist:'));
@@ -624,15 +894,20 @@ function printStep8(root, feature) {
 function printStep9(root, feature) {
     const port = getServerPort();
     const prevState = readState(root);
+    const isResuming = prevState?.step === 9;
+    const now = new Date().toISOString();
     writeState(root, {
         feature,
         step: 9,
         label: STEP_LABELS[9],
-        startedAt: new Date().toISOString(),
-        featureStartedAt: prevState?.featureStartedAt || new Date().toISOString(),
+        startedAt: isResuming ? prevState.startedAt : now,
+        featureStartedAt: prevState?.featureStartedAt || now,
     });
     logEvent(root, 'step', { step: 9, label: 'User Scenarios', feature });
     stepHeader(9, 'User Scenarios', feature);
+    if (isResuming) {
+        printResumptionHeader(9);
+    }
     console.log('Create per-persona scenarios if the app has users. Skip to step 10 if no users.');
     console.log();
     console.log(chalk.bold('If the app has users:'));
@@ -654,15 +929,20 @@ function printStep9(root, feature) {
 function printStep10(root, feature) {
     const port = getServerPort();
     const prevState = readState(root);
+    const isResuming = prevState?.step === 10;
+    const now = new Date().toISOString();
     writeState(root, {
         feature,
         step: 10,
         label: STEP_LABELS[10],
-        startedAt: new Date().toISOString(),
-        featureStartedAt: prevState?.featureStartedAt || new Date().toISOString(),
+        startedAt: isResuming ? prevState.startedAt : now,
+        featureStartedAt: prevState?.featureStartedAt || now,
     });
     logEvent(root, 'step', { step: 10, label: 'Verify', feature });
     stepHeader(10, 'Verify', feature);
+    if (isResuming) {
+        printResumptionHeader(10);
+    }
     console.log('Verify component isolation screenshots, editor scenarios, and library tests.');
     console.log();
     console.log(chalk.bold('Component isolation screenshots — verify:'));
@@ -688,65 +968,27 @@ function printStep10(root, feature) {
     console.log(chalk.dim('Focus on fixing issues. All component screenshots, scenarios, and tests must be clean before proceeding.'));
     stopGate(10);
 }
-// ─── Step 11: Review ──────────────────────────────────────────────────
+// ─── Step 11: Journal ─────────────────────────────────────────────────
 function printStep11(root, feature) {
     const port = getServerPort();
     const prevState = readState(root);
+    const isResuming = prevState?.step === 11;
+    const now = new Date().toISOString();
     writeState(root, {
         feature,
         step: 11,
         label: STEP_LABELS[11],
-        startedAt: new Date().toISOString(),
-        featureStartedAt: prevState?.featureStartedAt || new Date().toISOString(),
+        startedAt: isResuming ? prevState.startedAt : now,
+        featureStartedAt: prevState?.featureStartedAt || now,
     });
-    logEvent(root, 'step', { step: 11, label: 'Review', feature });
-    stepHeader(11, 'Review', feature);
-    console.log('Present a full summary, verify screenshots, then let the user save or revise.');
-    console.log();
-    console.log(chalk.bold('Phase 1 — Summary:'));
-    checkbox('Summarize the feature that was built');
-    checkbox('List all components and functions created');
-    checkbox('List glossary entries added in step 6');
-    checkbox('List all scenarios (app-level and user-persona)');
-    checkbox('Report analysis status (completed/in-progress from step 7)');
-    checkbox('Report verification status from step 10 (all clean?)');
-    checkbox(`Refresh the preview: \`curl -s -X POST http://localhost:${port}/api/dev-mode-refresh\``);
-    checkbox(`Get scenario list: \`curl -s http://localhost:${port}/api/editor-scenarios\``);
-    checkbox('Present scenarios in a markdown table — one scenario per row');
-    console.log(chalk.yellow('    EVERY scenario must use {{scenario:Name:ID}} — the terminal makes these clickable.'));
-    console.log(chalk.yellow('    Strip the component prefix: "DrinkCard - Default" → just "Default".'));
-    console.log(chalk.yellow('    Component name on first row of each group, blank for subsequent rows.'));
-    console.log();
-    console.log(chalk.dim('    Example:'));
-    console.log(chalk.dim('      | Component | Scenario |'));
-    console.log(chalk.dim('      |---|---|'));
-    console.log(chalk.dim('      | **App** | {{scenario:Full Catalog:abc}} |'));
-    console.log(chalk.dim('      | | {{scenario:Empty:def}} |'));
-    console.log(chalk.dim('      | | {{scenario:Error:ghi}} |'));
-    console.log(chalk.dim('      | **StarRating** | {{scenario:Perfect:jkl}} |'));
-    console.log(chalk.dim('      | | {{scenario:Medium:mno}} |'));
-    console.log();
-    console.log(chalk.bold('Phase 2 — Screenshot & error verification:'));
-    console.log(chalk.yellow('  CRITICAL: Verify screenshots AND check for client-side errors.'));
-    console.log();
-    console.log(chalk.bold('  Component isolation screenshots:'));
-    checkbox('Verify each component has screenshots in the App tab (grouped under Components)');
-    checkbox('If any are missing, re-register them using `codeyam editor register`');
-    console.log();
-    console.log(chalk.bold('  Client-side errors:'));
-    checkbox(`Check for errors: \`curl -s http://localhost:${port}/api/editor-client-errors\``);
-    checkbox('If `hasErrors` is true, list the errors and fix them in the source code');
-    checkbox('After fixing, re-capture affected scenarios to clear the errors');
-    console.log();
-    checkbox('Do not proceed until all components have screenshots and client errors are resolved');
-    console.log();
-    checkbox('Switch the active scenario to the best demo state for the feature');
-    console.log(chalk.dim(`    curl -s -X POST http://localhost:${port}/api/editor-switch-scenario \\`));
-    console.log(chalk.dim(`      -H 'Content-Type: application/json' -d '{"scenarioSlug":"...","scenarioId":"..."}'`));
-    console.log(chalk.dim('    Pick the scenario that best showcases the feature (not an error/empty state)'));
-    checkbox('Present the summary (with screenshot and error status) to the user');
+    logEvent(root, 'step', { step: 11, label: 'Journal', feature });
+    stepHeader(11, 'Journal', feature);
+    if (isResuming) {
+        printResumptionHeader(11);
+    }
+    console.log('Create or update the journal entry for this feature.');
     console.log();
-    console.log(chalk.bold('Phase 3 — Journal entry (create or update):'));
+    console.log(chalk.bold('Checklist:'));
     checkbox('Write a concise description of what was built (2-3 sentences)');
     checkbox(`First time at step 11 — create journal entry with ALL session screenshots:`);
     console.log(chalk.dim(`    curl -s -X POST http://localhost:${port}/api/editor-journal-entry \\`));
@@ -756,9 +998,51 @@ function printStep11(root, feature) {
     checkbox(`Returning after changes — update the existing journal entry:`);
     console.log(chalk.dim(`    curl -s -X PATCH http://localhost:${port}/api/editor-journal-update \\`));
     console.log(chalk.dim(`      -H 'Content-Type: application/json' \\`));
-    console.log(chalk.dim(`      -d '{"time":"<journal entry time>","description":"<updated description>"}'`));
+    console.log(chalk.dim(`      -d '{"time":"<journal entry time>","description":"<updated>","includeSessionScenarios":true}'`));
+    console.log();
+    console.log(chalk.dim('Focus on creating or updating the journal entry. Summary and review happen in step 12.'));
+    stopGate(11);
+}
+// ─── Step 12: Review ──────────────────────────────────────────────────
+function printStep12(root, feature) {
+    const port = getServerPort();
+    const prevState = readState(root);
+    const isResuming = prevState?.step === 12;
+    const now = new Date().toISOString();
+    writeState(root, {
+        feature,
+        step: 12,
+        label: STEP_LABELS[12],
+        startedAt: isResuming ? prevState.startedAt : now,
+        featureStartedAt: prevState?.featureStartedAt || now,
+    });
+    logEvent(root, 'step', { step: 12, label: 'Review', feature });
+    stepHeader(12, 'Review', feature);
+    if (isResuming) {
+        printResumptionHeader(12);
+    }
+    console.log('Verify everything, then present the scenario table to the user.');
+    console.log();
+    console.log(chalk.bold('Phase 1 — Verify (do all of this silently):'));
+    checkbox(`Refresh the preview: \`curl -s -X POST http://localhost:${port}/api/dev-mode-preview\``);
+    checkbox('Verify each component has screenshots in the App tab (grouped under Components)');
+    checkbox('If any are missing, re-register them using `codeyam editor register`');
+    checkbox(`Check for client errors: \`curl -s http://localhost:${port}/api/editor-client-errors\``);
+    checkbox('If `hasErrors` is true, fix them and re-capture affected scenarios');
+    checkbox('Run `codeyam editor audit` to verify completeness of scenarios and tests');
+    checkbox('Do not proceed until all checks pass');
+    console.log();
+    console.log(chalk.bold('Phase 2 — Present to the user:'));
+    checkbox('Write a 1-2 sentence summary of what was built');
+    checkbox('Report test count and audit status (one line)');
+    checkbox('Switch the active scenario to the best demo state for the feature:');
+    console.log(chalk.dim(`    curl -s -X POST http://localhost:${port}/api/dev-mode-preview \\`));
+    console.log(chalk.dim(`      -H 'Content-Type: application/json' -d '{"scenarioSlug":"...","scenarioId":"..."}'`));
+    checkbox(`Show the results panel: \`curl -s -X POST http://localhost:${port}/api/editor-show-results\``);
+    console.log(chalk.dim('    This opens a visual panel below the terminal showing all scenarios with screenshots.'));
+    console.log(chalk.dim('    The user can click scenarios to switch the live preview.'));
     console.log();
-    console.log(chalk.bold('Phase 4 — Present a selection menu to the user (use AskUserQuestion):'));
+    console.log(chalk.bold('Phase 3 — Present a selection menu to the user (use AskUserQuestion):'));
     console.log(chalk.green('    "Save & commit"') +
         chalk.dim(' — git commit all changes and record in journal'));
     console.log(chalk.yellow('    "I\'d like to make some changes"') +
@@ -776,11 +1060,13 @@ function printStep11(root, feature) {
     checkbox('Ask what changes the user wants');
     checkbox('Make the requested changes');
     console.log(chalk.yellow('  Then run: ') +
-        chalk.bold('codeyam editor 10') +
-        chalk.yellow(' to re-verify, which flows back to step 11'));
+        chalk.bold(`codeyam editor change "${feature}"`) +
+        chalk.yellow(' — this prints a post-change checklist to re-register scenarios,'));
+    console.log(chalk.yellow('  re-run tests, update journal screenshots, and loop back to this review step.'));
+    console.log(chalk.red.bold('  IMPORTANT: You MUST run the change command. Do not skip this or try to re-verify manually.'));
     console.log();
-    console.log(chalk.dim('Complete all phases in order: summary, screenshot verification, journal entry, user menu.'));
-    stopGate(11, { confirm: true });
+    console.log(chalk.dim('Complete all phases in order: summary, screenshot verification, user menu.'));
+    stopGate(12, { confirm: true });
 }
 // ─── Command definition ───────────────────────────────────────────────
 // ─── Analyze-imports subcommand ────────────────────────────────────────
@@ -938,15 +1224,479 @@ async function handleRegister(jsonArg) {
         process.exit(1);
     }
 }
+// ─── Dependents subcommand ────────────────────────────────────────────
+/**
+ * `codeyam editor dependents <EntityName>`
+ *
+ * Walks the importedBy reverse dependency tree to find all ancestors of a
+ * given entity — i.e., every component or page that transitively imports it.
+ * Used after code changes to determine what needs recapturing.
+ */
+async function handleDependents(entityName) {
+    if (!entityName) {
+        console.error(chalk.red('Error: Entity name required.'));
+        console.error(chalk.dim('  Usage: codeyam editor dependents DrinkCard'));
+        process.exit(1);
+    }
+    const progress = new ProgressReporter();
+    progress.start('Loading entities from database...');
+    await initializeEnvironment();
+    const allEntities = await loadEntities({});
+    if (!allEntities || allEntities.length === 0) {
+        progress.fail('No entities found in database');
+        console.error(chalk.dim('  Run codeyam editor analyze-imports first to populate entity data.'));
+        process.exit(1);
+    }
+    // Find the target entity by name (case-insensitive match)
+    const targetEntities = allEntities.filter((e) => e.name.toLowerCase() === entityName.toLowerCase());
+    if (targetEntities.length === 0) {
+        progress.fail(`Entity "${entityName}" not found in database`);
+        const names = [...new Set(allEntities.map((e) => e.name))].sort();
+        console.error(chalk.dim(`  Available entities: ${names.join(', ')}`));
+        process.exit(1);
+    }
+    progress.succeed('Entities loaded');
+    // Build lookup: entityName -> Set<entityName> of entities that import it.
+    // Each entity's metadata.importedBy is the pre-computed reverse graph:
+    //   { [filePath]: { [importerName]: { shas: string[] } } }
+    const importedByName = new Map();
+    for (const entity of allEntities) {
+        const importedBy = entity.metadata?.importedBy;
+        if (!importedBy || typeof importedBy !== 'object')
+            continue;
+        const importers = new Set();
+        for (const filePath of Object.keys(importedBy)) {
+            for (const importerName of Object.keys(importedBy[filePath])) {
+                importers.add(importerName);
+            }
+        }
+        if (importers.size > 0) {
+            importedByName.set(entity.name, importers);
+        }
+    }
+    // BFS walk up the dependency tree from the changed entity
+    const visited = new Set();
+    const result = [];
+    const queue = [
+        { name: entityName, depth: 0 },
+    ];
+    visited.add(entityName.toLowerCase());
+    // Collect entity types for display
+    const entityTypes = new Map();
+    for (const e of allEntities) {
+        if (!entityTypes.has(e.name)) {
+            entityTypes.set(e.name, e.entityType || 'unknown');
+        }
+    }
+    while (queue.length > 0) {
+        const { name, depth } = queue.shift();
+        result.push({
+            name,
+            entityType: entityTypes.get(name) || 'unknown',
+            depth,
+        });
+        // Find all entities that import this one
+        const importers = importedByName.get(name);
+        if (!importers)
+            continue;
+        for (const importerName of importers) {
+            if (visited.has(importerName.toLowerCase()))
+                continue;
+            visited.add(importerName.toLowerCase());
+            queue.push({ name: importerName, depth: depth + 1 });
+        }
+    }
+    // Output
+    if (result.length <= 1) {
+        console.log(chalk.yellow(`No dependents found for "${entityName}".`));
+        console.log(chalk.dim('  This entity is not imported by any other known entities.'));
+        console.log(chalk.dim('  Run codeyam editor analyze-imports to populate import data.'));
+        return;
+    }
+    console.log(chalk.bold(`Dependency tree for ${entityName} (${result.length} entities):`));
+    console.log();
+    for (const entry of result) {
+        const indent = '  '.repeat(entry.depth);
+        const prefix = entry.depth === 0 ? chalk.cyan('●') : chalk.dim('├──');
+        const label = entry.depth === 0
+            ? chalk.cyan(`${entry.name} (changed)`)
+            : chalk.white(entry.name);
+        const type = chalk.dim(`[${entry.entityType}]`);
+        console.log(`${indent}${prefix} ${label} ${type}`);
+    }
+    console.log();
+    console.log(chalk.dim('All listed entities need their scenarios recaptured after changes.'));
+}
+// ─── Change subcommand ───────────────────────────────────────────────
+/**
+ * `codeyam editor change <feature>`
+ *
+ * Prints a condensed post-change checklist that guides Claude through
+ * re-verifying after user-requested modifications. This is the "change
+ * loop" — it replaces the freeform "make changes" path with structured
+ * instructions that always loop back to step 12 review.
+ */
+function handleChange(feature) {
+    const root = getProjectRoot();
+    if (!feature) {
+        // Try to read feature from state
+        const state = readState(root);
+        if (state?.feature) {
+            feature = state.feature;
+        }
+        else {
+            console.error(chalk.red('Error: Feature name required.'));
+            console.error(chalk.dim('  Usage: codeyam editor change "My Feature"'));
+            process.exit(1);
+        }
+    }
+    const port = getServerPort();
+    console.log();
+    console.log(chalk.bold.cyan('━━━ Change Loop ━━━'));
+    console.log(chalk.dim(`Feature: ${feature}`));
+    console.log();
+    console.log('The user has requested changes. Follow this checklist after making them.');
+    console.log();
+    console.log(chalk.bold('1. Re-register affected component scenarios:'));
+    checkbox('For each component you modified, re-register ALL its scenarios');
+    console.log(chalk.dim(`    codeyam editor register '{"name":"ComponentName - ScenarioName","description":"...","componentName":"ComponentName","componentPath":"app/components/ComponentName.tsx"}'`));
+    checkbox('For any NEW components, create isolation routes and register scenarios');
+    console.log();
+    console.log(chalk.bold('2. Re-run affected tests:'));
+    checkbox('Re-run test files for any functions you modified');
+    console.log(chalk.dim('    Example: npx vitest run app/lib/drinks.test.ts'));
+    checkbox('If any test fails, fix the source code and re-run');
+    console.log();
+    console.log(chalk.bold('3. Re-capture app-level scenarios:'));
+    checkbox('If component changes affect app-level pages, re-register affected app scenarios');
+    checkbox(`Use \`codeyam editor dependents ComponentName\` to find what needs recapturing`);
+    console.log();
+    console.log(chalk.bold('4. Verify completeness:'));
+    checkbox(`Refresh the preview: \`curl -s -X POST http://localhost:${port}/api/dev-mode-preview\``);
+    checkbox(`Navigate to key pages to verify changes: \`curl -s -X POST http://localhost:${port}/api/dev-mode-preview -H 'Content-Type: application/json' -d '{"path":"/your-route"}'\``);
+    checkbox('Run `codeyam editor audit` — all checks must pass');
+    checkbox(`Check for client-side errors: \`curl -s http://localhost:${port}/api/editor-client-errors\``);
+    checkbox('Fix any errors, then re-register affected scenarios');
+    console.log();
+    console.log(chalk.bold('5. Update the journal:'));
+    checkbox(`Update journal entry with new screenshots: \`curl -s -X PATCH http://localhost:${port}/api/editor-journal-update -H 'Content-Type: application/json' -d '{"time":"<journal entry time>","description":"<updated>","includeSessionScenarios":true}'\``);
+    console.log(chalk.dim('    includeSessionScenarios refreshes ALL screenshots to reflect the changes'));
+    console.log();
+    console.log(chalk.bold.green('When all checks pass, run: ') +
+        chalk.bold(`codeyam editor 12`));
+    console.log(chalk.dim('  This re-enters the review step to present the updated summary to the user.'));
+    console.log();
+}
+// ─── Audit subcommand ────────────────────────────────────────────────
+/**
+ * `codeyam editor audit`
+ *
+ * Fetches the /api/editor-audit endpoint and prints a checklist showing
+ * which glossary components have registered scenarios and which functions
+ * have test files. Exits with code 1 if anything is missing.
+ */
+async function handleAudit() {
+    const port = getServerPort();
+    const url = `http://localhost:${port}/api/editor-audit`;
+    let data;
+    try {
+        const res = await fetch(url);
+        if (!res.ok) {
+            console.error(chalk.red(`Error: Audit endpoint returned ${res.status}`));
+            process.exit(1);
+        }
+        data = await res.json();
+    }
+    catch (err) {
+        console.error(chalk.red('Error: Could not reach the CodeYam server. Is it running?'));
+        console.error(chalk.dim(`  ${err.message}`));
+        process.exit(1);
+    }
+    const { components, functions, summary } = data;
+    console.log();
+    console.log(chalk.bold.cyan('━━━ Editor Audit ━━━'));
+    console.log();
+    // Components
+    if (components.length > 0) {
+        console.log(chalk.bold('Components (scenarios):'));
+        for (const c of components) {
+            const icon = c.status === 'ok' ? chalk.green('✓') : chalk.red('✗');
+            const count = c.status === 'ok'
+                ? chalk.dim(` (${c.scenarioCount} scenario${c.scenarioCount !== 1 ? 's' : ''})`)
+                : chalk.red(' — no scenarios registered');
+            console.log(`  ${icon} ${c.name}${count}`);
+        }
+        console.log();
+    }
+    // Functions
+    if (functions.length > 0) {
+        console.log(chalk.bold('Functions (test files):'));
+        for (const f of functions) {
+            const icon = f.status === 'ok' ? chalk.green('✓') : chalk.red('✗');
+            const detail = f.status === 'ok'
+                ? chalk.dim(` (${f.testFile})`)
+                : f.testFile
+                    ? chalk.red(` — test file missing: ${f.testFile}`)
+                    : chalk.red(' — no test file specified');
+            console.log(`  ${icon} ${f.name}${detail}`);
+        }
+        console.log();
+    }
+    // Summary
+    const allOk = summary.allPassing;
+    if (allOk) {
+        console.log(chalk.green.bold('All checks passed!') +
+            chalk.dim(` (${summary.totalComponents} component${summary.totalComponents !== 1 ? 's' : ''}, ${summary.totalFunctions} function${summary.totalFunctions !== 1 ? 's' : ''})`));
+    }
+    else {
+        const parts = [];
+        if (summary.componentsMissing > 0) {
+            parts.push(`${summary.componentsMissing} component${summary.componentsMissing !== 1 ? 's' : ''} missing scenarios`);
+        }
+        if (summary.functionsMissing > 0) {
+            parts.push(`${summary.functionsMissing} function${summary.functionsMissing !== 1 ? 's' : ''} missing tests`);
+        }
+        console.log(chalk.red.bold('Audit failed: ') + parts.join(', '));
+    }
+    console.log();
+    if (!allOk) {
+        process.exit(1);
+    }
+}
+// ─── Scenarios subcommand ─────────────────────────────────────────────
+async function handleScenarios() {
+    const port = getServerPort();
+    const url = `http://localhost:${port}/api/editor-scenarios`;
+    let data;
+    try {
+        const res = await fetch(url);
+        if (!res.ok) {
+            console.error(chalk.red(`Error: Scenarios endpoint returned ${res.status}`));
+            process.exit(1);
+        }
+        data = await res.json();
+    }
+    catch (err) {
+        console.error(chalk.red('Error: Could not reach the CodeYam server. Is it running?'));
+        console.error(chalk.dim(`  ${err.message}`));
+        process.exit(1);
+    }
+    const scenarios = data.scenarios;
+    if (scenarios.length === 0) {
+        console.log();
+        console.log(chalk.yellow('No scenarios found for this feature session.'));
+        console.log();
+        return;
+    }
+    // Group by componentName (null → "Uncategorized")
+    const groups = new Map();
+    for (const s of scenarios) {
+        const key = s.componentName || 'Uncategorized';
+        if (!groups.has(key))
+            groups.set(key, []);
+        groups.get(key).push(s);
+    }
+    // Strip component prefix from names (e.g. "DrinkCard - Default" → "Default")
+    function stripPrefix(name, componentName) {
+        if (!componentName)
+            return name;
+        const prefix = `${componentName} - `;
+        return name.startsWith(prefix) ? name.slice(prefix.length) : name;
+    }
+    // Calculate column widths
+    let maxCompLen = 'Component'.length;
+    let maxScenLen = 'Scenario'.length;
+    for (const [comp, items] of groups) {
+        maxCompLen = Math.max(maxCompLen, comp.length);
+        for (const s of items) {
+            const display = stripPrefix(s.name, s.componentName);
+            maxScenLen = Math.max(maxScenLen, display.length);
+        }
+    }
+    const pad = (str, len) => str + ' '.repeat(Math.max(0, len - str.length));
+    // Build OSC 8 hyperlink (display length = visible text only)
+    const osc8 = (url, text) => `\x1b]8;;${url}\x07${text}\x1b]8;;\x07`;
+    // Print table
+    console.log();
+    console.log(chalk.bold.cyan('━━━ Scenario Table ━━━'));
+    console.log();
+    const divComp = '─'.repeat(maxCompLen + 2);
+    const divScen = '─'.repeat(maxScenLen + 2);
+    // Header
+    console.log(`┌${divComp}┬${divScen}┐`);
+    console.log(`│ ${chalk.bold(pad('Component', maxCompLen))} │ ${chalk.bold(pad('Scenario', maxScenLen))} │`);
+    console.log(`├${divComp}┼${divScen}┤`);
+    // Rows
+    let groupIndex = 0;
+    for (const [comp, items] of groups) {
+        if (groupIndex > 0) {
+            console.log(`├${divComp}┼${divScen}┤`);
+        }
+        for (let i = 0; i < items.length; i++) {
+            const s = items[i];
+            const compCell = i === 0 ? chalk.bold(pad(comp, maxCompLen)) : pad('', maxCompLen);
+            const display = stripPrefix(s.name, s.componentName);
+            const linked = osc8(s.link, display);
+            // linked has invisible escape chars; pad based on display length
+            const scenPad = ' '.repeat(Math.max(0, maxScenLen - display.length));
+            console.log(`│ ${compCell} │ ${linked}${scenPad} │`);
+        }
+        groupIndex++;
+    }
+    // Footer
+    console.log(`└${divComp}┴${divScen}┘`);
+    console.log();
+    const total = scenarios.length;
+    const groupCount = groups.size;
+    console.log(chalk.dim(`${total} scenario${total !== 1 ? 's' : ''} across ${groupCount} component${groupCount !== 1 ? 's' : ''}`));
+    console.log();
+}
+// ─── Debug subcommand ────────────────────────────────────────────────
+function handleEditorDebug(args) {
+    const root = getProjectRoot();
+    const feature = args.feature || 'Sample Feature';
+    const includeContext = args.includeContext !== false;
+    let targets;
+    try {
+        targets = parseDebugTargets(args.target);
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.error(chalk.red(`Error: ${msg}`));
+        process.exit(1);
+    }
+    const includeResume = typeof args.resume === 'boolean' ? args.resume : true;
+    const includeNormal = typeof args.resume === 'boolean' ? !args.resume : true;
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+    const outputDir = args.output
+        ? path.resolve(args.output)
+        : path.join(root, '.codeyam', 'logs', 'editor-debug', timestamp);
+    fs.mkdirSync(outputDir, { recursive: true });
+    const contextEntries = includeContext
+        ? writeContextSnapshot(root, outputDir)
+        : [];
+    const scenarios = [];
+    const wants = (id) => (targets ? targets.has(id) : true);
+    if (wants('setup')) {
+        scenarios.push({
+            id: 'setup',
+            title: 'Setup (no project)',
+            render: () => withTempRoot(false, (tempRoot) => captureOutput(() => printSetup(tempRoot))),
+        });
+    }
+    if (wants('overview')) {
+        scenarios.push({
+            id: 'overview',
+            title: 'Cycle overview (project, no state)',
+            render: () => withTempRoot(true, (tempRoot) => captureOutput(() => printCycleOverview(tempRoot, null))),
+        });
+    }
+    if (wants('overview-with-state')) {
+        scenarios.push({
+            id: 'overview-with-state',
+            title: 'Cycle overview (project, with state)',
+            render: () => withTempRoot(true, (tempRoot) => captureOutput(() => printCycleOverview(tempRoot, makeState(4, feature)))),
+        });
+    }
+    const stepFns = {
+        1: (r, f) => printStep1(r, f),
+        2: printStep2,
+        3: printStep3,
+        4: printStep4,
+        5: printStep5,
+        6: printStep6,
+        7: printStep7,
+        8: printStep8,
+        9: printStep9,
+        10: printStep10,
+        11: printStep11,
+        12: printStep12,
+    };
+    for (let step = 1; step <= 12; step++) {
+        const stepId = `step-${step}`;
+        if (!wants(stepId))
+            continue;
+        if (includeNormal) {
+            scenarios.push({
+                id: stepId,
+                title: `Step ${step} (${STEP_LABELS[step]})`,
+                render: () => withTempRoot(true, (tempRoot) => captureOutput(() => stepFns[step](tempRoot, feature))),
+            });
+            if (step === 1 && !args.feature) {
+                scenarios.push({
+                    id: 'step-1-no-feature',
+                    title: 'Step 1 (Plan) — no feature provided',
+                    render: () => withTempRoot(true, (tempRoot) => captureOutput(() => printStep1(tempRoot, undefined))),
+                });
+            }
+            if (step === 2) {
+                scenarios.push({
+                    id: 'step-2-scaffold',
+                    title: 'Step 2 (Prototype) — scaffold flow (no project)',
+                    render: () => withTempRoot(false, (tempRoot) => captureOutput(() => printStep2(tempRoot, feature))),
+                });
+            }
+        }
+        if (includeResume) {
+            scenarios.push({
+                id: `${stepId}-resume`,
+                title: `Step ${step} (${STEP_LABELS[step]}) — resuming`,
+                render: () => withTempRoot(true, (tempRoot) => {
+                    writeState(tempRoot, makeState(step, feature));
+                    return captureOutput(() => stepFns[step](tempRoot, feature));
+                }),
+            });
+        }
+    }
+    const indexLines = [
+        '# CodeYam Editor Debug Bundle',
+        '',
+        `Generated: ${new Date().toISOString()}`,
+        `Feature: "${feature}"`,
+        `Resume variants: ${includeResume ? 'included' : 'skipped'}`,
+        'Note: Output files preserve ANSI color codes (as printed to the terminal).',
+        '',
+    ];
+    if (includeContext) {
+        indexLines.push('## Context snapshot');
+        if (contextEntries.length === 0) {
+            indexLines.push('- (none)');
+        }
+        else {
+            for (const entry of contextEntries) {
+                const source = entry.source ? ` ← ${entry.source}` : '';
+                indexLines.push(`- ${entry.label}: ${entry.file} (${entry.status})${source}`);
+            }
+        }
+        indexLines.push('');
+    }
+    indexLines.push('## Scenarios');
+    for (const scenario of scenarios) {
+        const fileName = `${scenario.id}.txt`;
+        const output = scenario.render();
+        fs.writeFileSync(path.join(outputDir, fileName), output, 'utf8');
+        indexLines.push(`- ${scenario.title}: ${fileName}`);
+    }
+    fs.writeFileSync(path.join(outputDir, 'index.md'), indexLines.join('\n'), 'utf8');
+    console.log();
+    console.log(chalk.bold.cyan('━━━ Editor Debug Bundle ━━━'));
+    console.log();
+    console.log(chalk.green('Wrote debug bundle to: ') + chalk.bold(outputDir));
+    console.log(chalk.dim('  Open index.md for the full list of scenario outputs.'));
+    console.log();
+}
 // ─── Command definition ───────────────────────────────────────────────
 const editorCommand = {
     command: 'editor [step] [json]',
     describe: 'Editor mode guided workflow',
     builder: (yargs) => {
-        return yargs
+        const stepDescription = IS_INTERNAL_BUILD
+            ? 'Step number (1-12) or subcommand (register, analyze-imports, dependents, audit, scenarios, change, debug)'
+            : 'Step number (1-12) or subcommand (register, analyze-imports, dependents, audit, scenarios, change)';
+        let builder = yargs
             .positional('step', {
             type: 'string',
-            describe: 'Step number (1-11) or subcommand (register, analyze-imports)',
+            describe: stepDescription,
         })
             .positional('json', {
             type: 'string',
@@ -956,6 +1706,27 @@ const editorCommand = {
             type: 'string',
             describe: 'Feature name (required for step 2)',
         });
+        if (IS_INTERNAL_BUILD) {
+            builder = builder
+                .option('target', {
+                type: 'string',
+                describe: 'Debug target (setup, overview, overview-with-state, step-1..step-12, or comma-separated list)',
+            })
+                .option('resume', {
+                type: 'boolean',
+                describe: 'Debug: only render resume variants (use --no-resume for only normal)',
+            })
+                .option('include-context', {
+                type: 'boolean',
+                default: true,
+                describe: 'Debug: include CLAUDE.md, skill, and editor-mode-context snapshots',
+            })
+                .option('output', {
+                type: 'string',
+                describe: 'Debug: output directory for the bundle',
+            });
+        }
+        return builder;
     },
     handler: async (argv) => {
         const root = getProjectRoot();
@@ -969,9 +1740,38 @@ const editorCommand = {
             await handleAnalyzeImports();
             return;
         }
+        // Subcommand: codeyam editor dependents <EntityName>
+        if (argv.step === 'dependents') {
+            await handleDependents(argv.json || '');
+            return;
+        }
+        // Subcommand: codeyam editor audit
+        if (argv.step === 'audit') {
+            await handleAudit();
+            return;
+        }
+        // Subcommand: codeyam editor scenarios
+        if (argv.step === 'scenarios') {
+            await handleScenarios();
+            return;
+        }
+        // Subcommand: codeyam editor change <feature>
+        if (argv.step === 'change') {
+            handleChange(argv.json || '');
+            return;
+        }
+        // Subcommand: codeyam editor debug [--target ...]
+        if (argv.step === 'debug') {
+            if (!IS_INTERNAL_BUILD) {
+                console.error(chalk.red('Error: "codeyam editor debug" is internal-only.'));
+                process.exit(1);
+            }
+            await handleEditorDebug(argv);
+            return;
+        }
         const step = argv.step ? parseInt(argv.step, 10) : undefined;
-        if (step != null && (isNaN(step) || step < 1 || step > 11)) {
-            console.error(chalk.red(`Error: Invalid step "${argv.step}". Must be 1-11.`));
+        if (step != null && (isNaN(step) || step < 1 || step > 12)) {
+            console.error(chalk.red(`Error: Invalid step "${argv.step}". Must be 1-12.`));
             process.exit(1);
         }
         if (step == null) {
@@ -1010,7 +1810,8 @@ const editorCommand = {
             case 8:
             case 9:
             case 10:
-            case 11: {
+            case 11:
+            case 12: {
                 const feature = argv.feature || state?.feature;
                 if (!feature) {
                     console.error(chalk.red('Error: No feature in progress. Run codeyam editor 1 first.'));
@@ -1026,6 +1827,7 @@ const editorCommand = {
                     9: printStep9,
                     10: printStep10,
                     11: printStep11,
+                    12: printStep12,
                 };
                 stepFns[step](root, feature);
                 break;