@codeyam/codeyam-cli 0.1.7 → 0.1.9

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

@@ -0,0 +1,3215 @@
+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 { error as errorLog, ProgressReporter, withoutSpinner, } from "../utils/progress.js";
+import { initializeEnvironment, requireBranchAndProject, testEnvironment, } from "../utils/database.js";
+import { loadAnalyses, loadEntities, updateProjectMetadata, } from "../../../packages/database/index.js";
+import { IS_INTERNAL_BUILD } from "../utils/buildFlags.js";
+import { startBackgroundServer } from "../utils/backgroundServer.js";
+import { installClaudeCodeSkills } from "../utils/install-skills.js";
+import { setupClaudeCodeSettings } from "../utils/setupClaudeCodeSettings.js";
+import { ensureAnalyzerFinalized } from "../utils/analyzerFinalization.js";
+import { APP_FORMATS, TECH_STACKS } from "../data/techStacks.js";
+import { getProjectRoot as getStateProjectRoot } from "../state.js";
+import initCommand from "./init.js";
+import { scanScenarioFiles, syncScenarioFilesToDatabase, backfillScenarioMetadata, } from "../utils/scenariosManifest.js";
+import { clearEditorState, clearEditorUserPrompt, validateStepTransition, } from "../utils/editorScenarios.js";
+import { validateSeedData, detectSeedAdapter, } from "../utils/editorSeedAdapter.js";
+import { buildEditorApiRequest, callEditorApi, EDITOR_API_SUBCOMMANDS, } from "../utils/editorApi.js";
+import { parseRegisterArg } from "../utils/parseRegisterArg.js";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const STEP_LABELS = {
+    1: 'Plan',
+    2: 'Prototype',
+    3: 'Confirm',
+    4: 'Deconstruct',
+    5: 'Extract',
+    6: 'Glossary',
+    7: 'Analyze',
+    8: 'App Scenarios',
+    9: 'User Scenarios',
+    10: 'Verify',
+    11: 'Journal',
+    12: 'Review',
+    13: 'Present',
+    14: 'Commit',
+    15: 'Finalize',
+    16: 'Push',
+};
+/**
+ * Append a JSONL log entry to .codeyam/logs/editor-log.jsonl
+ */
+function logEvent(root, event, data) {
+    try {
+        const logsDir = path.join(root, '.codeyam', 'logs');
+        fs.mkdirSync(logsDir, { recursive: true });
+        const logPath = path.join(logsDir, 'editor-log.jsonl');
+        const entry = JSON.stringify({
+            ts: new Date().toISOString(),
+            event,
+            ...data,
+        });
+        fs.appendFileSync(logPath, entry + '\n', 'utf8');
+    }
+    catch {
+        // Logging is best-effort
+    }
+}
+/**
+ * Read the design system file if it exists.
+ */
+function readDesignSystem(root) {
+    const designSystemPath = path.join(root, '.codeyam', 'design-system.md');
+    try {
+        return fs.readFileSync(designSystemPath, 'utf8');
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Get the project root (where .codeyam/ lives) or cwd.
+ */
+function getProjectRoot() {
+    return process.env.CODEYAM_ROOT_PATH || process.cwd();
+}
+/**
+ * Path to the editor step state file.
+ */
+function getStatePath(root) {
+    return path.join(root, '.codeyam', 'editor-step.json');
+}
+/**
+ * Read the current editor state, or null if none.
+ */
+function readState(root) {
+    const statePath = getStatePath(root);
+    try {
+        const content = fs.readFileSync(statePath, 'utf8');
+        return JSON.parse(content);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Write the editor state.
+ */
+function writeState(root, state) {
+    const statePath = getStatePath(root);
+    const dir = path.dirname(statePath);
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(statePath, JSON.stringify(state, null, 2), 'utf8');
+}
+/**
+ * Clear the editor state (for starting a new feature).
+ * Does NOT clear the user prompt file — that's handled separately
+ * via clearEditorUserPrompt when the previous feature commits.
+ */
+function clearState(root) {
+    clearEditorState(root);
+}
+/**
+ * Check if a project has been scaffolded (package.json exists).
+ */
+function hasProject(root) {
+    return fs.existsSync(path.join(root, 'package.json'));
+}
+/**
+ * Get the CodeYam server port.
+ * Reads from the server state file first (actual running port), then falls
+ * back to CODEYAM_PORT env var, then to the default 3111.
+ * This is critical when the server auto-selected a different port because
+ * the default was occupied by another project's server.
+ */
+function getServerPort() {
+    try {
+        const root = getProjectRoot();
+        if (root) {
+            const statePath = path.join(root, '.codeyam', 'server.json');
+            if (fs.existsSync(statePath)) {
+                const state = JSON.parse(fs.readFileSync(statePath, 'utf8'));
+                if (state.port)
+                    return String(state.port);
+            }
+        }
+    }
+    catch {
+        // Fall through to defaults
+    }
+    return process.env.CODEYAM_PORT || '3111';
+}
+/**
+ * Print a checklist item.
+ * Inline backtick-wrapped text is highlighted in cyan for visibility.
+ */
+function checkbox(text) {
+    // Highlight `backtick-wrapped` segments in cyan
+    const highlighted = text.replace(/`([^`]+)`/g, (_m, code) => chalk.cyan(code));
+    console.log(`  ${chalk.dim('[ ]')} ${highlighted}`);
+}
+/**
+ * Print a section header.
+ */
+function stepHeader(step, title, feature) {
+    console.log();
+    console.log(chalk.bold.cyan(`━━━ Step ${step}: ${title} ━━━`));
+    if (feature) {
+        console.log(chalk.dim(`Feature: "${feature}"`));
+    }
+    console.log();
+}
+/**
+ * Print a colored progress tracker showing all 16 steps.
+ * Steps before `current` are green ✓, `current` is bold cyan →, future steps are dim ○.
+ */
+function printProgressTracker(current) {
+    console.log();
+    console.log(chalk.dim('  ┌─────────────────────────────────────┐'));
+    for (let i = 1; i <= 16; i++) {
+        const label = STEP_LABELS[i];
+        const num = i < 10 ? ` ${i}` : `${i}`;
+        const content = `${num}. ${label.padEnd(28)}`;
+        if (i < current) {
+            console.log(chalk.dim('  │') + chalk.green(`  ✓  ${content}`) + chalk.dim('│'));
+        }
+        else if (i === current) {
+            console.log(chalk.dim('  │') + chalk.bold.cyan(`  →  ${content}`) + chalk.dim('│'));
+        }
+        else {
+            console.log(chalk.dim(`  │  ○  ${content}│`));
+        }
+    }
+    console.log(chalk.dim('  └─────────────────────────────────────┘'));
+}
+/**
+ * Print a hard STOP gate directing to the next command.
+ *
+ * Options:
+ * - confirm: true  → step requires user confirmation before proceeding (steps 1, 3, 11)
+ */
+function stopGate(current, opts) {
+    console.log();
+    console.log(chalk.bold.red('━━━ STOP ━━━'));
+    console.log();
+    console.log(chalk.red('Complete each checklist item above before proceeding to the next step.'));
+    if (opts?.confirm) {
+        console.log();
+        console.log(chalk.yellow('Wait for user confirmation before moving on.'));
+    }
+    console.log();
+    console.log(chalk.bold.yellow('Present the following progress tracker to the user (copy it verbatim):'));
+    printProgressTracker(current);
+    console.log();
+    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 < 16) {
+        console.log(chalk.green('When done, run: ') +
+            chalk.bold(`codeyam editor ${current + 1}`));
+    }
+    else {
+        console.log(chalk.green('Feature complete! Run: ') +
+            chalk.bold('codeyam editor 1') +
+            chalk.green(' to start the next feature'));
+    }
+    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      `codeyam editor scenarios`'],
+        9: [
+            'Check existing user-persona scenarios:\n      `codeyam 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      `codeyam editor journal-list`',
+            'If an entry exists, use PATCH to update it — do NOT create a new one',
+        ],
+        12: ['Re-verify is safe to repeat — just re-run the checks'],
+        13: ['Check if commit already made:\n      `git log --oneline -3`'],
+        14: ['Check if commit already made:\n      `git log --oneline -3`'],
+        15: [
+            'Check if journal was already updated with commit SHA:\n      `codeyam editor journal-list`',
+            'Check if commit was already amended:\n      `git log --oneline -3`',
+        ],
+        16: [
+            'Check if already pushed:\n      `git remote -v && git log --oneline origin/HEAD..HEAD 2>/dev/null`',
+        ],
+    };
+    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 <= 16) {
+                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();
+    logEvent(root, 'setup');
+    console.log();
+    console.log(chalk.bold.cyan('━━━ Editor Mode: Project Setup ━━━'));
+    console.log();
+    console.log("No project detected. Let's get started.");
+    console.log();
+    // ── Design System ────────────────────────────────────────────────
+    console.log(chalk.bold('Design System (ask FIRST):'));
+    console.log(chalk.dim('  Ask: "Do you have a design system, brand guidelines, or style preferences you\'d like me to follow?"'));
+    console.log(chalk.dim('  Use AskUserQuestion with these EXACT option labels:'));
+    console.log(chalk.yellow('    Option 1 label: "Yes, I\'ll paste my design system"'));
+    console.log(chalk.dim('       → Wait for paste, save to .codeyam/design-system.md, confirm with brief summary'));
+    console.log(chalk.yellow('    Option 2 label: "No, use sensible defaults"'));
+    console.log(chalk.dim('       → Skip'));
+    console.log();
+    console.log(chalk.bold('Checklist:'));
+    checkbox('Read `.codeyam/editor-mode-context.md` for session state');
+    checkbox('Ask the user what they want to build');
+    console.log();
+    // ── App Format Selection ───────────────────────────────────────────
+    console.log(chalk.bold('App Format Selection:'));
+    console.log(chalk.dim('  After the user describes their project, ask which app formats they want to target.'));
+    console.log(chalk.dim('  Use AskUserQuestion with CHECKBOXES (multiple selections allowed):'));
+    console.log();
+    for (const format of APP_FORMATS) {
+        console.log(chalk.yellow(`    [ ] ${format.label}`) +
+            chalk.dim(` — ${format.description}`));
+    }
+    console.log();
+    // ── Tech Stack Selection ───────────────────────────────────────────
+    console.log(chalk.bold('Tech Stack Selection:'));
+    console.log(chalk.dim('  Based on the selected formats, present ONLY the matching tech stacks.'));
+    console.log(chalk.dim('  A stack matches if ANY of the user\'s selected formats appears in its "Supports" list.'));
+    console.log(chalk.dim('  Show ALL matching stacks even if there is only one. Mark the recommended option.'));
+    console.log(chalk.dim('  Use AskUserQuestion to let the user pick one.'));
+    console.log();
+    console.log(chalk.bold('  Available Tech Stacks:'));
+    for (const stack of TECH_STACKS) {
+        const recommended = stack.recommended ? chalk.green(' (Recommended)') : '';
+        const formatLabels = stack.supportedFormats
+            .map((f) => APP_FORMATS.find((af) => af.id === f)?.label)
+            .join(', ');
+        console.log(chalk.bold.yellow(`    ${stack.name}`) +
+            recommended +
+            chalk.dim(` [id: ${stack.id}]`));
+        console.log(chalk.dim(`      ${stack.description}`));
+        console.log(chalk.dim('      Technologies:'));
+        for (const tech of stack.technologies) {
+            console.log(chalk.dim(`        - ${tech}`));
+        }
+        console.log(chalk.dim(`      Supports: ${formatLabels}`));
+        console.log();
+    }
+    console.log(chalk.dim('  If NO stacks match the selected formats, tell the user that support for that format is coming soon'));
+    console.log(chalk.dim('  and suggest they pick a supported format for now.'));
+    console.log();
+    // ── Default Screen Size Selection ──────────────────────────────────
+    console.log(chalk.bold('Default Screen Size:'));
+    console.log(chalk.dim('  After selecting a tech stack, ask the user to choose the default screen size for previews and captures.'));
+    console.log(chalk.dim('  Use AskUserQuestion with RADIO buttons (single selection):'));
+    console.log();
+    console.log(chalk.yellow('    ( ) Desktop') + chalk.dim(' — 1440 × 900'));
+    console.log(chalk.yellow('    ( ) Laptop') + chalk.dim(' — 1024 × 768'));
+    console.log(chalk.yellow('    ( ) Tablet') + chalk.dim(' — 768 × 1024'));
+    console.log(chalk.yellow('    ( ) Mobile') + chalk.dim(' — 375 × 667'));
+    console.log(chalk.yellow('    ( ) Custom') + chalk.dim(' — ask for width × height'));
+    console.log();
+    console.log(chalk.dim('  Pre-select based on app format: mobile-responsive-web-app/desktop-app → Desktop, mobile-app → Mobile, chrome-extension → Custom (400×600).'));
+    console.log(chalk.dim('  If only one obvious choice, confirm it rather than asking.'));
+    console.log(chalk.dim('  Save the choice via: curl -s -X POST http://localhost:PORT/api/editor-project-info -H "Content-Type: application/json" -d \'{"defaultScreenSize":{"name":"Desktop","width":1440,"height":900}}\''));
+    console.log();
+    console.log(chalk.bold('Named Screen Sizes (for multi-resolution apps):'));
+    console.log(chalk.dim('  For mobile-responsive web apps or apps that need screenshots at multiple resolutions,'));
+    console.log(chalk.dim('  also save named screen sizes. Each scenario can reference a dimension name.'));
+    console.log(chalk.dim('  curl -s -X POST http://localhost:PORT/api/editor-project-info -H "Content-Type: application/json" \\'));
+    console.log(chalk.dim('    -d \'{"screenSizes":{"Desktop":{"width":1440,"height":900},"Mobile":{"width":375,"height":667}}}\''));
+    console.log();
+    console.log(chalk.bold.red('━━━ STOP ━━━'));
+    console.log();
+    console.log(chalk.red('Ask the user what they want to build, then ask about app formats, then present tech stacks, then choose a default screen size. Then run:'));
+    console.log();
+    console.log(chalk.green('  ') +
+        chalk.bold('codeyam editor 1 --feature "Feature Name" --app-formats "FORMAT_IDS" --tech-stack "STACK_ID" --prompt "the user\'s original message"'));
+    console.log(chalk.dim('  Replace "Feature Name" with a short title for what the user described.'));
+    console.log(chalk.dim('  Replace FORMAT_IDS with the comma-separated format IDs the user selected (e.g., "chrome-extension" or "mobile-responsive-web-app").'));
+    console.log(chalk.dim('  Replace STACK_ID with the tech stack id shown in [brackets] above (e.g., "nextjs-prisma-sqlite" or "chrome-extension-react").'));
+    console.log(chalk.dim("  Pass --prompt with the user's exact original request so it appears in the journal."));
+    console.log(chalk.dim('  Step 1 will guide you through planning and getting user confirmation before any code is written.'));
+    console.log();
+}
+// ─── Cycle overview (no args, has project) ────────────────────────────
+function printCycleOverview(root, state) {
+    logEvent(root, 'overview', state ? { feature: state.feature, step: state.step } : {});
+    console.log();
+    console.log(chalk.bold.cyan('━━━ Editor Mode: Feature Cycle ━━━'));
+    console.log();
+    if (state) {
+        console.log(chalk.yellow(`Current: Step ${state.step} (${state.label}) — "${state.feature}"`));
+        console.log();
+        console.log(chalk.green('Continue with: ') +
+            chalk.bold(`codeyam editor ${state.step}`));
+        console.log(chalk.dim('Or run ') +
+            chalk.bold('codeyam editor 1') +
+            chalk.dim(' to start a new feature'));
+        console.log();
+        console.log(chalk.yellow('If the user reports a bug or requests any change, run: ') +
+            chalk.bold('codeyam editor change'));
+        console.log(chalk.yellow('This applies even after committing — always use the change workflow.'));
+    }
+    else {
+        console.log('Each feature follows 16 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`);
+        console.log(`  ${chalk.bold.yellow(' 3')} ${chalk.bold('Confirm')}         — Confirm prototype with user`);
+        console.log(`  ${chalk.bold.yellow(' 4')} ${chalk.bold('Deconstruct')}     — Read code, plan all extractions`);
+        console.log(`  ${chalk.bold.yellow(' 5')} ${chalk.bold('Extract')}         — TDD extraction of functions + components`);
+        console.log(`  ${chalk.bold.yellow(' 6')} ${chalk.bold('Glossary')}        — Record functions in glossary`);
+        console.log(`  ${chalk.bold.yellow(' 7')} ${chalk.bold('Analyze')}         — Analyze and verify components`);
+        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('Journal')}         — Create/update journal entry`);
+        console.log(`  ${chalk.bold.yellow('12')} ${chalk.bold('Review')}          — Verify screenshots and audit`);
+        console.log(`  ${chalk.bold.yellow('13')} ${chalk.bold('Present')}         — Present summary, get approval`);
+        console.log(`  ${chalk.bold.yellow('14')} ${chalk.bold('Commit')}          — Commit all changes`);
+        console.log(`  ${chalk.bold.yellow('15')} ${chalk.bold('Finalize')}        — Journal update + amend commit`);
+        console.log(`  ${chalk.bold.yellow('16')} ${chalk.bold('Push')}            — Push to remote`);
+        console.log();
+        console.log(chalk.green('Start now: ') + chalk.bold('codeyam editor 1'));
+        console.log(chalk.dim('  If the user already described what they want, pass it: codeyam editor 1 --prompt "their message"'));
+    }
+    console.log();
+}
+// ─── Step 1: Plan ─────────────────────────────────────────────────────
+function printStep1(root, feature, options, userPrompt) {
+    const port = getServerPort();
+    const prevState = readState(root);
+    const isResuming = prevState?.step === 1;
+    if (!isResuming) {
+        clearState(root);
+    }
+    // Always persist state so step 2's validation sees that step 1 ran.
+    // The feature name may not be known yet (it's an output of planning) —
+    // use an empty string as placeholder; step 2 requires --feature anyway.
+    const now = new Date().toISOString();
+    writeState(root, {
+        feature: feature || prevState?.feature || '',
+        step: 1,
+        label: STEP_LABELS[1],
+        startedAt: isResuming ? prevState.startedAt : now,
+        featureStartedAt: isResuming ? prevState.featureStartedAt : now,
+        appFormats: options?.appFormats || prevState?.appFormats,
+        techStackId: options?.techStackId || prevState?.techStackId,
+    });
+    // Save the user's original prompt to a separate file
+    if (userPrompt) {
+        const promptPath = path.join(root, '.codeyam', 'editor-user-prompt.txt');
+        fs.mkdirSync(path.dirname(promptPath), { recursive: true });
+        fs.writeFileSync(promptPath, userPrompt, 'utf8');
+    }
+    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:'));
+    checkbox('Read `.codeyam/glossary.json` for reusable functions/components');
+    checkbox('Ask the user what they want to build (if not already described)');
+    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.'));
+    checkbox("Summarize what you'll build in plain language the user can verify against their vision");
+    checkbox('Include a brief note on what interesting data states the scenarios should demonstrate');
+    console.log(chalk.dim('    Think: what seed data would put this feature through its paces? Diverse content, edge cases, empty vs rich.'));
+    checkbox('Set the project title and description for the App tab:');
+    console.log(chalk.dim(`  curl -s -X POST http://localhost:${port}/api/editor-project-info \\`));
+    console.log(chalk.dim('    -H "Content-Type: application/json" \\'));
+    console.log(chalk.dim('    -d \'{"projectTitle":"My App","projectDescription":"A short description of what this app does"}\''));
+    console.log();
+    const designSystem = readDesignSystem(root);
+    if (designSystem) {
+        console.log(chalk.bold.magenta('Design System (from .codeyam/design-system.md):'));
+        console.log(chalk.dim('  Keep these design tokens in mind during planning.'));
+        console.log();
+        console.log(designSystem);
+        console.log();
+    }
+    console.log(chalk.bold('Present a selection menu to the user (use AskUserQuestion with these EXACT option labels):'));
+    console.log(chalk.green('    Option 1 label: "This plan is accurate, let\'s prototype it!"') + chalk.dim(' — proceed to step 2'));
+    console.log(chalk.yellow('    Option 2 label: "I\'d like some changes"') +
+        chalk.dim(' — user describes changes, you revise the plan, then re-present'));
+    console.log();
+    console.log(chalk.dim('This step is for understanding user goals and getting buy-in. Code comes in Step 2.'));
+    console.log();
+    console.log(chalk.bold.red('━━━ STOP ━━━'));
+    console.log();
+    console.log(chalk.red('Complete each checklist item above before proceeding to the next step.'));
+    console.log();
+    console.log(chalk.yellow('Wait for user confirmation before moving on.'));
+    console.log();
+    console.log(chalk.bold.yellow('Present the following progress tracker to the user (copy it verbatim):'));
+    printProgressTracker(1);
+    console.log();
+    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();
+    console.log(chalk.green('When done, run: ') +
+        chalk.bold('codeyam editor 2 --feature "Feature Name"'));
+    console.log(chalk.dim('  Replace "Feature Name" with a short title for what you just described.'));
+    console.log();
+}
+// ─── Step 2: Prototype ────────────────────────────────────────────────
+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: isResuming ? prevState.startedAt : now,
+        featureStartedAt: isResuming ? prevState.featureStartedAt : now,
+        appFormats: prevState?.appFormats,
+        techStackId: prevState?.techStackId,
+    });
+    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
+    if (!projectExists) {
+        console.log(chalk.bold('Scaffold the project:'));
+        checkbox('Run `codeyam editor template` to scaffold, install dependencies, init git, and configure CodeYam');
+        console.log(chalk.dim('  This copies the Next.js + Prisma 7 + SQLite template, runs npm install,'));
+        console.log(chalk.dim('  initializes git, runs codeyam init, and refreshes the editor — all in one command.'));
+        console.log();
+        checkbox('Define your data models in `prisma/schema.prisma`');
+        console.log(chalk.dim("  Replace the placeholder Todo model with your app's models"));
+        console.log();
+        checkbox('Push schema and seed the database');
+        console.log(chalk.dim('  npm run db:push'));
+        console.log(chalk.dim('  # Edit prisma/seed.ts with your seed data, then:'));
+        console.log(chalk.dim('  npm run db:seed'));
+        console.log(chalk.dim(`  # After re-seeding, restart the dev server to pick up fresh data:`));
+        console.log(chalk.dim(`  # codeyam editor dev-server '{"action":"restart"}'`));
+        console.log();
+        console.log(chalk.yellow('  IMPORTANT: When adding new required columns to existing tables,'));
+        console.log(chalk.yellow('  provide a @default(...) value so `db push` can fill existing rows.'));
+        console.log(chalk.dim('  Example: userId String @default("anonymous")  — existing rows get "anonymous"'));
+        console.log(chalk.dim('  Without a default, Prisma requires --force-reset which drops ALL data.'));
+        console.log(chalk.dim('  NEVER use --force-reset — it is blocked in this environment.'));
+        console.log();
+        console.log(chalk.dim('  See DATABASE.md for Prisma patterns and important warnings.'));
+        console.log(chalk.dim('  Key: import { prisma } from "@/app/lib/prisma" in API routes.'));
+        console.log(chalk.dim('  Key: Seed scripts must use the adapter pattern (see prisma/seed.ts).'));
+        console.log();
+        console.log(chalk.bold('Build the feature:'));
+    }
+    console.log(chalk.bold('Checklist:'));
+    checkbox('Create API routes that read from the database via Prisma');
+    checkbox('Seed the database with demo data');
+    checkbox('Create `.codeyam/seed-adapter.ts` so CodeYam can seed the database for scenarios');
+    console.log(chalk.dim('    The seed adapter reads a JSON file (path passed as CLI arg), wipes tables, inserts rows.'));
+    console.log(chalk.dim("    Use the project's own ORM (Prisma, Drizzle, etc.). See template for example."));
+    console.log(chalk.dim('    Run with: npx tsx .codeyam/seed-adapter.ts <path-to-seed-data.json>'));
+    checkbox('Verify the dev server shows the changes');
+    checkbox('If the feature involves auth, email, payments, or other common patterns: read FEATURE_PATTERNS.md');
+    // Responsive design guidance when building a mobile-responsive web app
+    if (prevState?.appFormats?.includes('mobile-responsive-web-app')) {
+        console.log();
+        console.log(chalk.bold.magenta('Responsive Design (mobile-responsive-web-app):'));
+        console.log(chalk.magenta('  This app must look great on BOTH desktop AND mobile. It is NOT a mobile-only app.'));
+        console.log(chalk.magenta('  Design desktop-first with a full-width layout, then ensure it adapts gracefully to mobile.'));
+        console.log(chalk.dim('  Use Tailwind responsive prefixes (sm:, md:, lg:) for layout shifts.'));
+        console.log(chalk.dim('  Test at both Desktop (1280×800) and Mobile (390×844) sizes before presenting.'));
+    }
+    const designSystem = readDesignSystem(root);
+    if (designSystem) {
+        console.log();
+        console.log(chalk.bold.magenta('Design System (from .codeyam/design-system.md):'));
+        console.log();
+        console.log(designSystem);
+        console.log();
+        checkbox('Define ALL design tokens as CSS custom properties in globals.css — not just colors');
+        console.log(chalk.dim('    Colors: --bg-surface, --text-primary, --accent-green-a, etc.'));
+        console.log(chalk.dim('    Typography: --text-xs, --text-sm, --text-lg, --text-2xl (font-size values)'));
+        console.log(chalk.dim('    Font weights: --font-weight-normal, --font-weight-medium, --font-weight-semibold'));
+        console.log(chalk.dim('    Spacing: --spacing-xs, --spacing-sm, --spacing-md, --spacing-lg, etc.'));
+        console.log(chalk.dim('    Border radius, shadows, transitions — every value the design system defines.'));
+        checkbox('Reference tokens from components — ZERO hardcoded px values for font-size, spacing, or colors');
+        console.log(chalk.dim('    Bad:  fontSize: 14, padding: "12px 16px", gap: 8'));
+        console.log(chalk.dim('    Good: fontSize: "var(--text-sm)", padding: "var(--spacing-md) var(--spacing-lg)", gap: "var(--spacing-sm)"'));
+        console.log(chalk.dim('    This ensures the entire app updates when the design system changes.'));
+    }
+    console.log();
+    console.log(chalk.bold.cyan('Keep the preview moving:'));
+    console.log(chalk.cyan('  The user is watching the preview. Refresh it after each meaningful change:'));
+    console.log(chalk.cyan(`  codeyam editor preview`));
+    console.log(chalk.cyan('  Refresh after: first visible page, adding each UI section, seeding data, styling.'));
+    console.log(chalk.cyan('  Aim for 4-8+ refreshes during prototyping — not one big reveal at the end.'));
+    console.log(chalk.cyan('  If you build a NEW page (e.g., /drinks/[id]), navigate the preview there:'));
+    console.log(chalk.cyan(`  codeyam editor preview '{"path":"/drinks/1"}'`));
+    console.log();
+    console.log(chalk.bold('Verify the dev server:'));
+    console.log(chalk.dim(`  # Get dev server URL: codeyam editor dev-server`));
+    console.log(chalk.dim('  # Check page loads: curl -s -o /dev/null -w "%{http_code}" http://localhost:<dev-port>'));
+    console.log(chalk.dim('  # Check API routes: curl -s http://localhost:<dev-port>/api/your-route'));
+    console.log();
+    console.log(chalk.bold('Verify before proceeding:'));
+    console.log(chalk.yellow('  Verify everything works before presenting the prototype to the user.'));
+    checkbox('Verify the page loads: curl the dev server URL and confirm HTTP 200 (not an error page)');
+    checkbox('Verify API routes return valid JSON: curl each route and confirm no error responses');
+    checkbox('Check for broken images: `codeyam editor verify-images \'{"paths":["/"], "imageUrls":["url1","url2"]}\'`');
+    console.log(chalk.dim('    Pass ALL page paths and ALL image URLs you used in seed data / API responses.'));
+    console.log(chalk.dim('    Client-rendered pages need imageUrls — the HTML shell has no images to scan.'));
+    console.log(chalk.dim('    Fix or replace any broken image URLs in the seed data before proceeding.'));
+    checkbox('Check the dev server terminal output for runtime errors (missing modules, failed imports)');
+    checkbox('Verify the live preview renders: `codeyam editor client-errors`');
+    console.log(chalk.dim('    If `hasContent=false` or `liveErrors>0`, the preview is broken — fix the issue before proceeding.'));
+    console.log(chalk.dim('    The user is looking at the preview — a blank page means something is broken.'));
+    console.log(chalk.dim('    If any check fails, fix the issue and re-verify before proceeding.'));
+    console.log();
+    console.log(chalk.bold('Update README and setup script:'));
+    checkbox('Update `README.md`: set the project name, write a one-line description, and list any setup prerequisites');
+    checkbox('Update `npm run setup` in `package.json` if setup requires extra steps (e.g. env vars, external services)');
+    console.log(chalk.dim('    The README and setup script must stay accurate as you make changes.'));
+    console.log(chalk.dim('    A new clone should work with just: git clone → npm run setup → npm run dev'));
+    console.log();
+    console.log(chalk.dim('Focus on building the prototype. Scenarios and refactoring happen in later steps.'));
+    stopGate(2);
+}
+// ─── Step 3: Confirm ──────────────────────────────────────────────────
+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: 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: \`codeyam editor preview\` — check the \`preview\` field for \`healthy: false\``);
+    checkbox('Verify API routes return valid data (curl each route)');
+    console.log();
+    console.log(chalk.bold.red('  Verify EVERY image loads (this is the #1 source of broken prototypes):'));
+    checkbox('Run `codeyam editor verify-images \'{"paths":["/"], "imageUrls":["url1","url2"]}\'`');
+    console.log(chalk.dim('    Include ALL page paths and ALL image URLs from seed data / API responses.'));
+    console.log(chalk.dim('    Client-rendered pages need imageUrls — the HTML shell has no images.'));
+    checkbox('Fix or remove any image that returns non-200 before continuing');
+    checkbox('Check for client-side errors: `codeyam editor client-errors`');
+    console.log(chalk.dim('    If there are errors, fix the underlying issue before presenting.'));
+    checkbox('Verify `hasContent=true` and `liveErrors=0` — do NOT ask the user to confirm if the preview is broken');
+    console.log();
+    console.log(chalk.bold('Then present to the user:'));
+    checkbox('Summarize what was built (routes, components, data)');
+    checkbox('Navigate the preview to the feature\'s primary page: `codeyam editor preview \'{"path":"/your-page"}\'`');
+    console.log(chalk.dim('    The user needs to SEE the new feature. If you built a new page, navigate there.'));
+    console.log(chalk.dim('    If you modified an existing page, refresh the preview to show the changes.'));
+    console.log();
+    console.log(chalk.bold.cyan('Guide the user through interactive testing:'));
+    checkbox('Tell the user: "The preview is fully interactive — click around to test!"');
+    checkbox('Prompt the user to try key interactions: forms, navigation, buttons, etc.');
+    checkbox('Ask the user: "Does everything work as expected?"');
+    console.log();
+    console.log(chalk.bold('Present a selection menu to the user (use AskUserQuestion with these EXACT option labels):'));
+    console.log(chalk.green('    Option 1 label: "The live preview is displaying what I expected"') + chalk.dim(' — proceed to step 4'));
+    console.log(chalk.yellow('    Option 2 label: "I\'d like some changes"') +
+        chalk.dim(' — make changes, refresh preview, re-run `codeyam editor 3`'));
+    console.log();
+    console.log(chalk.dim('Wait for user approval before moving on. Refactoring and scenarios happen in later steps.'));
+    stopGate(3, { confirm: true });
+}
+// ─── 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: 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();
+    console.log(chalk.bold.red('THE RULE: No direct JSX in page files.'));
+    console.log(chalk.yellow('  After extraction, a page/route file should import and compose components — nothing else.'));
+    console.log(chalk.yellow('  Every distinct visual section in the page is its own component.'));
+    console.log(chalk.yellow('  Every component that renders multiple distinct sections should be split into sub-components.'));
+    console.log(chalk.yellow('  If a component has N visually distinct parts, it should compose N sub-components.'));
+    console.log();
+    console.log(chalk.bold('Checklist:'));
+    checkbox('Read `.codeyam/glossary.json` — note reusable functions/components');
+    checkbox('Read EVERY file created or modified in this session');
+    console.log(chalk.yellow('    For EACH file, identify EVERY extractable piece:'));
+    console.log(chalk.yellow('    Components: headers, nav, loading states, empty states, error states,'));
+    console.log(chalk.yellow('      badges/pills, image containers, card sections, form fields, modals,'));
+    console.log(chalk.yellow('      titles, descriptions, rating displays, status indicators, buttons'));
+    console.log(chalk.yellow('    Functions: data transforms, calculations, formatting, validation,'));
+    console.log(chalk.yellow('      API response shaping, any logic that is not directly about rendering'));
+    console.log(chalk.yellow('    Hooks: data fetching, state management, side effects'));
+    console.log();
+    checkbox('Write a numbered extraction plan listing EVERYTHING you will extract');
+    console.log(chalk.yellow('    The end state: every page file is ONLY imports + component composition.'));
+    console.log(chalk.yellow('    No raw <div>, <span>, <h1>, <p>, <img>, or <ul> in page files.'));
+    console.log(chalk.yellow('    Every visual section in every component is itself a component.'));
+    console.log();
+    console.log(chalk.yellow('    For each item in the plan, note:'));
+    console.log(chalk.yellow('    — What it is (component, function, hook)'));
+    console.log(chalk.yellow('    — Where it currently lives (source file + approximate lines)'));
+    console.log(chalk.yellow('    — Where it will go (new file path)'));
+    console.log();
+    console.log(chalk.dim('Present the numbered plan, then proceed to step 5 to execute it.'));
+    stopGate(4);
+}
+// ─── Step 5: Extract ──────────────────────────────────────────────────
+function printStep5(root, feature) {
+    const port = getServerPort();
+    const prevState = readState(root);
+    const isResuming = prevState?.step === 5;
+    const now = new Date().toISOString();
+    writeState(root, {
+        feature,
+        step: 5,
+        label: STEP_LABELS[5],
+        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:'));
+    checkbox('Extract each component from your plan into its own file');
+    checkbox('Page/route files must contain ZERO direct JSX — only imported components');
+    checkbox('Every component that renders multiple sections must be split into sub-components');
+    console.log(chalk.dim('    No tests needed — visual verification happens in step 7'));
+    console.log();
+    console.log(chalk.bold('Library functions AND hooks (TDD):'));
+    checkbox('For each function/hook: write MULTIPLE failing tests FIRST, then extract to make them pass');
+    console.log(chalk.dim('    Cover: typical inputs, edge cases, empty/null inputs, error conditions'));
+    console.log(chalk.dim('    Aim for 3-8 test cases per function depending on complexity'));
+    console.log(chalk.dim('    Hooks count as functions — useDrinks, useAuth, etc. all need test files'));
+    checkbox('Place test files next to source: `app/lib/drinks.ts` → `app/lib/drinks.test.ts`');
+    console.log(chalk.yellow('  Tests ARE the only coverage for library functions/hooks — step 7 only captures component screenshots.'));
+    console.log();
+    console.log(chalk.bold('Recursive pass:'));
+    checkbox('Re-read EVERY new file you just created — extract components from components, functions from functions');
+    checkbox('Keep going until every file is a thin shell: just imports and composition');
+    console.log(chalk.yellow('    Check: does any file contain raw <div>, <span>, <h1>, <p>, <img>, or <ul>?'));
+    console.log(chalk.yellow('    If yes → that JSX section is a component waiting to be extracted.'));
+    console.log();
+    console.log(chalk.bold('Verify before proceeding:'));
+    checkbox('Run all tests and verify they pass');
+    checkbox('Page files contain ONLY imports + component composition — no raw HTML tags');
+    checkbox('Every component renders ONE thing or composes sub-components — no multi-section JSX');
+    checkbox(`Refresh the preview after each batch of extractions: \`codeyam editor preview\``);
+    console.log(chalk.dim('    The user should see the preview stay healthy as you refactor — refresh periodically, not just at the end.'));
+    console.log(chalk.dim('Reuse glossary functions when they fit naturally. Extract a new function when the use case diverges.'));
+    console.log();
+    console.log(chalk.dim('Focus on TDD for functions and extraction for components. Scenarios come in later steps.'));
+    stopGate(5);
+}
+// ─── 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: 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:'));
+    checkbox("Read `.codeyam/glossary.json` (create if it doesn't exist)");
+    checkbox('Add an entry for each new function/component extracted in step 5');
+    checkbox('Each entry should have: name, filePath, description, parameters, returnType, tags, feature');
+    checkbox('Every non-component entry MUST have `testFile` set — hooks and functions all need tests');
+    console.log(chalk.yellow('    If a function/hook has no test yet, go back and write one (TDD). The audit will block you.'));
+    console.log();
+    console.log(chalk.bold('Entry format:'));
+    console.log(chalk.dim('  { "name": "calculateTotal", "filePath": "app/utils/pricing.ts",'));
+    console.log(chalk.dim('    "description": "Calculates total price including tax and discounts",'));
+    console.log(chalk.dim('    "parameters": [{ "name": "items", "type": "CartItem[]" }],'));
+    console.log(chalk.dim('    "returnType": "number", "tags": ["pricing"],'));
+    console.log(chalk.dim('    "testFile": "app/utils/pricing.test.ts",'));
+    console.log(chalk.dim(`    "feature": "${feature}", "createdAt": "..." }`));
+    console.log();
+    console.log(chalk.dim('Focus on updating the glossary. Application code and scenarios come in later steps.'));
+    stopGate(6);
+}
+// ─── Step 7: Analyze ──────────────────────────────────────────────────
+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: 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:'));
+    checkbox('List all files with new/modified visual components from step 5');
+    checkbox('Create isolation route dirs: `codeyam editor isolate "ComponentA ComponentB ..."`');
+    console.log(chalk.dim('    This creates app/isolated-components/layout.tsx (with production notFound() guard) and'));
+    console.log(chalk.dim('    a directory per component. List ALL components that need isolation routes.'));
+    checkbox('Check existing scenarios: `codeyam editor scenarios`');
+    console.log(chalk.dim('    Reuse and improve existing scenarios where possible — update mock data'));
+    console.log(chalk.dim('    to reflect current changes. Add new scenarios only for genuinely new states.'));
+    console.log(chalk.dim('    Ensure at least one scenario clearly demonstrates what changed in this session.'));
+    checkbox('For each visual component:');
+    console.log(chalk.dim('    1. Read the source AND find where it is used in the app to understand:'));
+    console.log(chalk.dim('       — Props/interface'));
+    console.log(chalk.dim('       — Container width in the real app (e.g. card in a 3-col grid → max-w-sm)'));
+    console.log(chalk.dim('    2. Plan multiple scenarios that exercise the component like tests:'));
+    console.log(chalk.dim('       — Default/happy path with typical data'));
+    console.log(chalk.dim('       — Edge cases: empty/missing data, long text, maximum items, zero counts'));
+    console.log(chalk.dim('       — Different visual states: loading, error, disabled, selected, hover'));
+    console.log(chalk.dim('       — Boundary values: single item vs many, min/max ratings, very long names'));
+    console.log(chalk.dim('    3. Create ONE isolation route per component with a scenarios map and ?s= query param:'));
+    console.log(chalk.dim('       Remix:   app/routes/isolated-components.ComponentName.tsx → /isolated-components/ComponentName'));
+    console.log(chalk.dim('       Next.js: app/isolated-components/ComponentName/page.tsx → /isolated-components/ComponentName'));
+    console.log(chalk.dim('       The route defines a `scenarios` object mapping scenario names to props,'));
+    console.log(chalk.dim('       reads `?s=ScenarioName` from the URL, and renders the component with those props.'));
+    console.log(chalk.dim('       Wrap the component in a capture container with id="codeyam-capture":'));
+    console.log(chalk.dim('       <div id="codeyam-capture" style={{ display:"inline-block", padding:"20px" }}>'));
+    console.log(chalk.dim('         <div style={{ width:"100%", maxWidth:"..." }}> ← match the app\'s container width'));
+    console.log(chalk.dim('       e.g. card in a 3-col grid → maxWidth:"24rem", full-width component → omit maxWidth'));
+    console.log(chalk.dim('       The screenshot captures just this wrapper, so the component fills the image.'));
+    console.log(chalk.dim('       Center the wrapper on the page (flexbox center both axes) and set a page background'));
+    console.log(chalk.dim('       color that matches where the component normally appears (e.g. white for light UIs).'));
+    console.log(chalk.dim('    4. Wait 2 seconds for HMR, then register + capture each scenario:'));
+    console.log(chalk.dim(`       codeyam editor register '{"name":"ComponentName - Scenario",`));
+    console.log(chalk.dim(`         "componentName":"ComponentName","componentPath":"path/to/file.tsx",`));
+    console.log(chalk.dim(`         "url":"/isolated-components/ComponentName?s=Scenario",`));
+    console.log(chalk.dim(`         "mockData":{"routes":{"/api/...":{"body":[...]}}}}'`));
+    console.log(chalk.dim('       Optional: add "dimension" to use a named screen size, or "viewportWidth"/"viewportHeight" for raw override'));
+    console.log(chalk.dim('       If omitted, captures use the project default from setup. Only override for scenarios that need a different size.'));
+    console.log(chalk.dim('       url is a PATH (starts with /) — the proxy routes it and intercepts API calls'));
+    console.log(chalk.dim('       mockData.routes provides data for API calls the component makes internally'));
+    console.log(chalk.dim('       (omit mockData if the component has no internal API calls)'));
+    console.log(chalk.dim('       For large JSON: use your Write tool to create .codeyam/tmp/scenario.json,'));
+    console.log(chalk.dim('       then: codeyam editor register @.codeyam/tmp/scenario.json'));
+    console.log(chalk.yellow('    5. IMPORTANT: Check the register response for `clientErrors` array'));
+    console.log(chalk.yellow('       If clientErrors is non-empty → fix the isolation route and re-register'));
+    console.log(chalk.yellow('       Fix client errors and re-register before moving on'));
+    console.log(chalk.dim('    Isolation routes are committed to git — the layout guard blocks them in production'));
+    console.log();
+    console.log(chalk.bold('Library Functions — run tests:'));
+    checkbox('Run ALL test files created in step 5');
+    console.log(chalk.dim('    Example: npx vitest run app/lib/drinks.test.ts'));
+    checkbox('Verify every test passes');
+    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/hooks have tests');
+    console.log(chalk.red.bold('    The audit is a HARD GATE — step 8 will refuse to run until the audit passes.'));
+    console.log(chalk.dim('    When audit passes, the import graph is built automatically for change tracking.'));
+    console.log();
+    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: 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 with rich data that robustly demonstrates this feature.');
+    console.log();
+    console.log(chalk.bold('Goal: Every scenario should thoroughly exercise the feature with realistic data.'));
+    console.log(chalk.dim('  Scenarios with minimal or generic data ("Test Item 1") won\'t reveal whether the feature works.'));
+    console.log(chalk.dim('  Use rich, diverse seed data that puts the feature through its paces.'));
+    console.log();
+    console.log(chalk.bold.cyan('Make seed data work hard:'));
+    console.log(chalk.cyan('  Every scenario — new or existing — should have data that EXERCISES the feature:'));
+    console.log(chalk.cyan('  • Add data that uses new fields, relationships, or states the feature introduces'));
+    console.log(chalk.cyan('  • Include realistic variety — different categories, lengths, statuses, counts'));
+    console.log(chalk.cyan("  • Populate optional fields the feature depends on (don't leave them empty)"));
+    console.log(chalk.cyan('  • Make content diverse enough that edge cases surface naturally'));
+    console.log(chalk.cyan("  • Think: would this data reveal a bug in the feature? If it's too simple, enrich it."));
+    console.log();
+    console.log(chalk.bold.cyan('When to create new vs reuse existing:'));
+    console.log(chalk.cyan('  • New pages or pages with no scenarios yet → create new scenarios'));
+    console.log(chalk.cyan('  • Existing scenarios on affected pages → re-register with enhanced data'));
+    console.log(chalk.cyan("  • New data states that can't coexist in one scenario (empty vs rich, error vs success) → new scenario"));
+    console.log(chalk.cyan("  • Don't duplicate — if an existing scenario can cover a state with richer data, enhance it instead"));
+    console.log();
+    console.log(chalk.bold('Checklist:'));
+    checkbox('Run `codeyam editor scenarios` — review all existing scenarios');
+    checkbox("Create new scenarios for any pages that don't have scenarios yet");
+    console.log(chalk.yellow('    Each page needs its own scenarios — a detail page needs different data than the catalog'));
+    checkbox('Re-register every existing scenario whose page was affected by this feature');
+    console.log(chalk.dim('    Use the SAME name to update. Enhance seed data to showcase this feature where relevant.'));
+    console.log(chalk.yellow("    Don't just re-register unchanged data — enrich it so the feature is thoroughly demonstrated."));
+    checkbox('If the project has a database + seed adapter, use seed-based scenarios:');
+    console.log(chalk.dim(`    codeyam editor register '{"name":"Full Catalog","type":"application","url":"/","seed":{"products":[...],"categories":[...]}}'`));
+    console.log(chalk.dim('    Seed data is written to the DB via the seed adapter. Real app renders real data.'));
+    checkbox('Optional: add "dimension" to use a named screen size (e.g. "Mobile", "Desktop")');
+    console.log(chalk.dim('    References a named size from config screenSizes. For multi-resolution: register "Home - Desktop" with dimension "Desktop"'));
+    console.log(chalk.dim('    and "Home - Mobile" with dimension "Mobile". Or use raw "viewportWidth"/"viewportHeight" to override directly.'));
+    checkbox('IMPORTANT: Always include "url" — the page path to screenshot for this scenario');
+    console.log(chalk.dim('    Use "/" for home page, "/drinks/1" for detail pages, etc.'));
+    console.log(chalk.dim('    Without url, the screenshot captures the root page regardless of the scenario.'));
+    console.log(chalk.yellow('    Create separate scenarios for each page that shows different data.'));
+    checkbox('For large seed data, use your Write tool to create .codeyam/tmp/scenario.json, then:');
+    console.log(chalk.dim('    codeyam editor register @.codeyam/tmp/scenario.json'));
+    console.log(chalk.yellow('    IMPORTANT: Use the Write tool — NOT cat/heredoc — to avoid permission prompts'));
+    checkbox('For external API mocks (Stripe, weather, etc.), add externalApis:');
+    console.log(chalk.dim(`    "externalApis":{"GET https://api.stripe.com/v1/prices":{"body":[...],"status":200}}`));
+    checkbox('If the app uses auth, email, or other patterns: see FEATURE_PATTERNS.md for scenario guidance');
+    checkbox('If the app uses localStorage/sessionStorage instead of a database, use localStorage scenarios:');
+    console.log(chalk.dim(`    codeyam editor register '{"name":"Full Library","type":"application","url":"/","localStorage":{"articles":[...],"collections":[...]}}'`));
+    console.log(chalk.dim('    The proxy injects data into localStorage before the app loads. Fully interactive — the app can read and write normally.'));
+    console.log(chalk.dim('    For an empty state, register with an empty localStorage or omit it entirely.'));
+    checkbox('If no database and no localStorage, use component-style mock scenarios:');
+    console.log(chalk.dim(`    codeyam editor register '{"name":"Empty","description":"...","url":"/","mockData":{"routes":{"/api/...":{"body":[...]}}}}'`));
+    checkbox('After each registration, check the response for `clientErrors`');
+    console.log(chalk.yellow('    If clientErrors is non-empty → fix the issue and re-register the scenario'));
+    console.log(chalk.yellow('    Fix client errors and re-register before moving on'));
+    checkbox('CRITICAL: After EACH registration, view the captured screenshot to verify it');
+    console.log(chalk.yellow('    Read the screenshot file path from the registration response and view it.'));
+    console.log(chalk.yellow('    Does the screenshot actually SHOW the data you put in? If you seeded 5 articles'));
+    console.log(chalk.yellow('    but the screenshot shows an empty page, the scenario is broken — fix the code or data.'));
+    console.log(chalk.yellow('    Do NOT create scenarios with data the app cannot yet render.'));
+    console.log();
+    console.log(chalk.dim('Focus on creating and registering app-level scenarios. Code fixes happen in step 10 if needed.'));
+    console.log();
+    console.log(chalk.bold.cyan("Verify your work — screenshots don't lie:"));
+    console.log(chalk.cyan('  • View every captured screenshot. Does it show what the scenario name promises?'));
+    console.log(chalk.cyan('  • A "Library with Articles" screenshot showing an empty page means the scenario is BROKEN.'));
+    console.log(chalk.cyan('  • Is the seed data diverse — different lengths, categories, counts — or just placeholders?'));
+    console.log(chalk.cyan('  • Only create scenarios for states the CURRENT code can render.'));
+    console.log();
+    console.log(chalk.bold.yellow('GATE: Before proceeding, run `codeyam editor scenario-coverage`'));
+    console.log(chalk.yellow('  This checks which existing scenarios have stale screenshots.'));
+    console.log(chalk.yellow('  Re-register every stale scenario listed until the check passes.'));
+    stopGate(8);
+}
+// ─── Step 9: User Scenarios ───────────────────────────────────────────
+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: 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 variations of existing scenarios. Skip to step 10 if no users.');
+    console.log();
+    console.log(chalk.bold('If the app has NO users/auth:'));
+    console.log(chalk.dim('  Skip this step and proceed to step 10 (Verify).'));
+    console.log();
+    console.log(chalk.bold('If the app has users/auth:'));
+    console.log();
+    console.log(chalk.bold('Goal: Create persona variations of EXISTING app scenarios.'));
+    console.log(chalk.dim('  Do NOT create standalone persona scenarios. Each user-persona scenario should be'));
+    console.log(chalk.dim('  a variation of an existing app scenario from step 8, with user-specific state layered on.'));
+    console.log();
+    console.log(chalk.bold('Checklist:'));
+    checkbox('Run `codeyam editor scenarios` — list all existing app scenarios');
+    checkbox('For EACH existing app scenario, create a logged-in variation:');
+    console.log(chalk.dim('    Copy the scenario seed data and add "session":{"cookieValue":"sess_alice"} + user seed'));
+    console.log(chalk.dim('    Name: "<Original Name> - Logged In" (e.g. "Full Catalog - Logged In")'));
+    console.log(chalk.dim('    Step 8 scenarios already serve as logged-out versions (no session cookie)'));
+    checkbox('If there are multiple user roles (admin, regular, etc.), create role-specific variations too');
+    console.log(chalk.dim('    Each persona scenario layers user-specific seed data on top of an app scenario'));
+    checkbox('After each registration, check the response for `clientErrors`');
+    console.log(chalk.yellow('    If clientErrors is non-empty → fix the issue and re-register the scenario'));
+    console.log();
+    console.log(chalk.dim('See FEATURE_PATTERNS.md and AUTH_PATTERNS.md for auth scenario guidance.'));
+    stopGate(9);
+}
+// ─── Step 10: Verify ──────────────────────────────────────────────────
+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: 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:'));
+    checkbox('Review component screenshots in the App tab (grouped under Components)');
+    checkbox('If any screenshot looks wrong, fix the component code');
+    console.log(chalk.yellow('    After fixing a visual component, re-register the affected scenarios:'));
+    console.log(chalk.dim(`    codeyam editor register '{"name":"ComponentName - Scenario",...}'`));
+    console.log();
+    console.log(chalk.bold('Editor scenarios (App tab) — visual + error check:'));
+    checkbox(`Refresh the preview: \`codeyam editor preview\``);
+    checkbox('Click through each app-level and user-persona scenario in the preview');
+    checkbox('For seed-based scenarios: verify data renders correctly after switching');
+    console.log(chalk.dim('    Switch between scenarios and confirm the app reflects the seeded data each time'));
+    checkbox(`Check for client-side errors: \`codeyam editor client-errors\``);
+    console.log(chalk.yellow('    If `hasErrors` is true: list each scenario with errors, fix the source code,'));
+    console.log(chalk.yellow('    re-register the affected scenarios, and re-check until hasErrors is false'));
+    console.log(chalk.dim('    Common errors: React errors, failed fetches, undefined references, hydration mismatches'));
+    checkbox('Verify no broken images: `codeyam editor verify-images \'{"paths":["/"], "imageUrls":["url1"]}\'` with all page paths and image URLs');
+    console.log();
+    console.log(chalk.bold('Library functions — test check:'));
+    checkbox('Re-run all test files from step 5 to confirm they still pass');
+    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.dim('Focus on fixing issues. All component screenshots, scenarios, and tests must be clean before proceeding.'));
+    stopGate(10);
+}
+// ─── 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: isResuming ? prevState.startedAt : now,
+        featureStartedAt: prevState?.featureStartedAt || now,
+    });
+    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('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(`    codeyam editor journal '{"title":"...","type":"feature","description":"...","includeSessionScenarios":true}'`));
+    console.log(chalk.dim('    includeSessionScenarios auto-discovers component + app + user persona screenshots'));
+    checkbox(`Returning to step 11 (before commit) — update the existing journal entry:`);
+    console.log(chalk.dim(`    codeyam editor journal-update '{"time":"<journal entry time>","description":"<updated>","includeSessionScenarios":true}'`));
+    console.log(chalk.dim('    Note: PATCH only works before the entry is committed. After commit, use POST to create a new entry.'));
+    console.log();
+    console.log(chalk.dim('Focus on creating or updating the journal entry. Summary and presentation happen in step 13.'));
+    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 all screenshots and checks pass before presenting to the user.');
+    console.log();
+    console.log(chalk.bold('Checklist (do all of this silently):'));
+    checkbox(`Refresh the preview: \`codeyam editor 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: \`codeyam editor client-errors\``);
+    checkbox('If `hasErrors` is true, fix them and re-capture affected scenarios');
+    checkbox('Run `codeyam editor verify-images \'{"paths":["/"], "imageUrls":["url1"]}\'` with all page paths and image URLs');
+    checkbox('Fix or remove any broken images before continuing');
+    checkbox('Run `codeyam editor audit` to verify completeness of scenarios and tests');
+    checkbox('Do not proceed until all checks pass');
+    stopGate(12);
+}
+// ─── Step 13: Present ─────────────────────────────────────────────────
+function printStep13(root, feature) {
+    const port = getServerPort();
+    const prevState = readState(root);
+    const isResuming = prevState?.step === 13;
+    const now = new Date().toISOString();
+    writeState(root, {
+        feature,
+        step: 13,
+        label: STEP_LABELS[13],
+        startedAt: isResuming ? prevState.startedAt : now,
+        featureStartedAt: prevState?.featureStartedAt || now,
+    });
+    logEvent(root, 'step', { step: 13, label: 'Present', feature });
+    stepHeader(13, 'Present', feature);
+    if (isResuming) {
+        printResumptionHeader(13);
+    }
+    console.log('Present the results to the user and get their approval.');
+    console.log();
+    console.log(chalk.bold('Checklist:'));
+    checkbox('Fetch all scenarios: `codeyam editor scenarios`');
+    console.log(chalk.dim('    Each scenario has a `changeStatus` field: "new", "edited", "impacted", or null.'));
+    checkbox('Pick the best scenario to showcase from this working session:');
+    console.log(chalk.dim('    Prefer scenarios with changeStatus "new" or "edited" (directly changed in this session).'));
+    console.log(chalk.dim('    For app-level scenarios, prefer those showing the new/changed functionality.'));
+    console.log(chalk.dim('    NEVER pick a scenario with changeStatus null — those are unchanged from a previous commit.'));
+    checkbox('Switch the preview to that scenario using its `id`:');
+    console.log(chalk.dim(`    codeyam editor preview '{"scenarioId":"<id>"}'`));
+    checkbox(`Show the results panel: \`codeyam 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.'));
+    checkbox('Write a 1-2 sentence summary of what was built');
+    checkbox('Report test count and audit status (one line)');
+    console.log();
+    console.log(chalk.bold('Present a selection menu to the user (use AskUserQuestion with these EXACT option labels):'));
+    console.log(chalk.green('    Option 1 label: "Save & commit"') +
+        chalk.dim(' — git commit all changes and record in journal'));
+    console.log(chalk.yellow('    Option 2 label: "I\'d like to make some changes"') +
+        chalk.dim(' — describe changes, then re-verify'));
+    console.log();
+    console.log(chalk.bold('If the user chooses "Save & commit":'));
+    checkbox('Advance to the commit step: `codeyam editor 14`');
+    console.log();
+    console.log(chalk.bold('If the user chooses "Make changes" (or asks for ANY change, even as a question):'));
+    checkbox(`Hide the results panel: \`codeyam editor hide-results\``);
+    checkbox('Ask what changes the user wants (if not already clear)');
+    checkbox(`Run: \`codeyam editor change "${feature}"\` — this gives you the change checklist`);
+    checkbox('THEN make the requested changes and follow the checklist');
+    console.log(chalk.red.bold('  IMPORTANT: Always run the change command BEFORE writing any code.'));
+    stopGate(13, { confirm: true });
+}
+// ─── Step 14: Commit ─────────────────────────────────────────────────
+function printStep14(root, feature) {
+    const prevState = readState(root);
+    const isResuming = prevState?.step === 14;
+    const now = new Date().toISOString();
+    writeState(root, {
+        feature,
+        step: 14,
+        label: STEP_LABELS[14],
+        startedAt: isResuming ? prevState.startedAt : now,
+        featureStartedAt: prevState?.featureStartedAt || now,
+    });
+    logEvent(root, 'step', { step: 14, label: 'Commit', feature });
+    stepHeader(14, 'Commit', feature);
+    if (isResuming) {
+        printResumptionHeader(14);
+    }
+    console.log('Commit all changes for this feature.');
+    console.log();
+    console.log(chalk.bold('Checklist:'));
+    checkbox(`Hide the results panel: \`codeyam editor hide-results\``);
+    checkbox(`Git commit using the journal description: \`codeyam editor commit '{"message":"feat: <title>\\n\\n<journal description>"}'\``);
+    console.log(chalk.dim('    The commit message body MUST match the journal description exactly'));
+    stopGate(14);
+}
+// ─── Step 15: Finalize ───────────────────────────────────────────────
+function printStep15(root, feature) {
+    const prevState = readState(root);
+    const isResuming = prevState?.step === 15;
+    const now = new Date().toISOString();
+    writeState(root, {
+        feature,
+        step: 15,
+        label: STEP_LABELS[15],
+        startedAt: isResuming ? prevState.startedAt : now,
+        featureStartedAt: prevState?.featureStartedAt || now,
+    });
+    logEvent(root, 'step', { step: 15, label: 'Finalize', feature });
+    stepHeader(15, 'Finalize', feature);
+    if (isResuming) {
+        printResumptionHeader(15);
+    }
+    console.log('Update the journal with the commit SHA and amend the commit.');
+    console.log();
+    console.log(chalk.bold('Checklist:'));
+    checkbox(`Update journal with commit SHA: \`codeyam editor journal-update '{"time":"<journal entry time>","commitSha":"<sha>","commitMessage":"feat: <title>"}'\``);
+    checkbox('Amend the commit to include the journal update: `git add .codeyam/journal/ && git commit --amend --no-edit`');
+    console.log(chalk.dim('    The journal-update modifies journal files after the commit — amend to keep the tree clean.'));
+    stopGate(15);
+}
+// ─── Step 16: Push ───────────────────────────────────────────────────
+function printStep16(root, feature) {
+    const prevState = readState(root);
+    const isResuming = prevState?.step === 16;
+    const now = new Date().toISOString();
+    writeState(root, {
+        feature,
+        step: 16,
+        label: STEP_LABELS[16],
+        startedAt: isResuming ? prevState.startedAt : now,
+        featureStartedAt: prevState?.featureStartedAt || now,
+    });
+    logEvent(root, 'step', { step: 16, label: 'Push', feature });
+    stepHeader(16, 'Push', feature);
+    if (isResuming) {
+        printResumptionHeader(16);
+    }
+    console.log('Push the commit to the remote repository.');
+    console.log();
+    console.log(chalk.bold('Checklist:'));
+    checkbox('Check if a git remote is configured: `git remote -v`');
+    checkbox("Offer to push to remote (AskUserQuestion — STOP and wait for the user's answer before proceeding):");
+    console.log(chalk.dim('    If a remote exists, ask (AskUserQuestion): "Would you like me to push this commit to the remote?" with options "Yes, push" and "No, skip"'));
+    console.log(chalk.dim('    If the user says yes, run: `git push`'));
+    console.log(chalk.dim('    If NO remote exists, ask (AskUserQuestion): "This project doesn\'t have a git remote yet. Would you like help setting one up? I can walk you through creating a GitHub repository." with options "Yes, set up remote" and "No, skip"'));
+    console.log(chalk.dim('    If the user wants help, guide them through `gh repo create` or manual GitHub setup, then push.'));
+    checkbox('After the user responds, run: `codeyam editor steps` to start the next feature');
+    console.log();
+    console.log(chalk.red.bold('  If the user reports a bug or requests a fix after committing:'));
+    console.log(chalk.red.bold('  You MUST still run `codeyam editor change` before making any changes.'));
+    console.log(chalk.red.bold('  The change workflow applies to ALL changes — post-commit fixes are not an exception.'));
+    stopGate(16, { confirm: true });
+}
+// ─── Command definition ───────────────────────────────────────────────
+// ─── Analyze-imports subcommand ────────────────────────────────────────
+/**
+ * `codeyam editor analyze-imports`
+ *
+ * Runs data-structure-only analysis for all glossary entities, then outputs
+ * an import graph and entity data structures as JSON to stdout.
+ */
+async function handleAnalyzeImports(options = {}) {
+    const root = getProjectRoot();
+    // Read glossary
+    const glossaryPath = path.join(root, '.codeyam', 'glossary.json');
+    if (!fs.existsSync(glossaryPath)) {
+        if (options.silent) {
+            // Internal caller — glossary doesn't exist yet, nothing to analyze
+            return;
+        }
+        console.error(chalk.red('Error: .codeyam/glossary.json not found.'));
+        console.error(chalk.dim('  Run codeyam editor 6 to create the glossary first.'));
+        process.exit(1);
+    }
+    let glossaryEntries;
+    try {
+        glossaryEntries = JSON.parse(fs.readFileSync(glossaryPath, 'utf8'));
+    }
+    catch {
+        console.error(chalk.red('Error: Could not parse .codeyam/glossary.json.'));
+        process.exit(1);
+    }
+    if (!Array.isArray(glossaryEntries) || glossaryEntries.length === 0) {
+        console.error(chalk.red('Error: glossary.json is empty.'));
+        process.exit(1);
+    }
+    const filePaths = glossaryEntries.map((e) => e.filePath);
+    // Include page files so pages get analyzed as entities too.
+    // This allows the import graph to map page names to their dependencies.
+    const { scanPageFilePaths } = await import('../utils/entityChangeStatus.server.js');
+    const pageFilePaths = scanPageFilePaths(root);
+    for (const pageFile of Object.values(pageFilePaths)) {
+        if (!filePaths.includes(pageFile)) {
+            filePaths.push(pageFile);
+        }
+    }
+    const progress = new ProgressReporter();
+    // Run data-structure-only analysis for all entities (glossary + pages)
+    // Don't pass entityNames — entities may not exist yet (fresh clone).
+    // The analyzer will discover and create them from file paths.
+    progress.start('Running import analysis for all entities...');
+    try {
+        await runAnalysisForEntities({
+            projectRoot: root,
+            filePaths,
+            progress,
+            onlyDataStructure: true,
+        });
+    }
+    catch (err) {
+        progress.fail('Analysis failed');
+        const msg = err instanceof Error ? err.message : String(err);
+        console.error(chalk.red(`Error: ${msg}`));
+        process.exit(1);
+    }
+    progress.succeed('Analysis complete');
+    // Load entities WITH metadata from database
+    progress.start('Loading entity metadata...');
+    await initializeEnvironment();
+    const entities = await loadEntities({});
+    if (!entities || entities.length === 0) {
+        progress.succeed('No entities found in database yet — skipping import analysis. This is normal on the first feature.');
+        if (!options.silent) {
+            console.log(JSON.stringify({ imports: {}, entities: {} }));
+        }
+        return;
+    }
+    // Deduplicate to latest versions
+    const latestByKey = new Map();
+    for (const entity of entities) {
+        const key = `${entity.name}::${entity.filePath}`;
+        const existing = latestByKey.get(key);
+        if (!existing ||
+            (entity.createdAt &&
+                existing.createdAt &&
+                entity.createdAt > existing.createdAt)) {
+            latestByKey.set(key, entity);
+        }
+    }
+    const entityNameSet = new Set(glossaryEntries.map((e) => e.name));
+    const latestEntities = [...latestByKey.values()].filter((e) => entityNameSet.has(e.name));
+    // Build import graph from importedExports metadata
+    const imports = {};
+    const entityData = {};
+    // Also load analyses for data structures
+    const entityShas = latestEntities.map((e) => e.sha);
+    const analyses = await loadAnalyses({ entityShas });
+    const analysisMap = new Map();
+    if (analyses) {
+        for (const a of analyses) {
+            if (!analysisMap.has(a.entitySha) ||
+                (a.createdAt &&
+                    (!analysisMap.get(a.entitySha).createdAt ||
+                        a.createdAt > analysisMap.get(a.entitySha).createdAt))) {
+                analysisMap.set(a.entitySha, a);
+            }
+        }
+    }
+    for (const entity of latestEntities) {
+        const importedExports = entity.metadata?.importedExports || [];
+        const importedNames = importedExports
+            .map((ie) => ie.name)
+            .filter((name) => entityNameSet.has(name));
+        if (importedNames.length > 0) {
+            imports[entity.name] = importedNames;
+        }
+        // Collect entity data with analysis data structures
+        const analysis = analysisMap.get(entity.sha);
+        const analysisMetadata = analysis?.metadata;
+        entityData[entity.name] = {
+            filePath: entity.filePath || '',
+            entityType: entity.entityType || 'visual',
+            dataForMocks: analysisMetadata?.scenariosDataStructure?.dataForMocks,
+            dependencySchemas: analysisMetadata?.mergedDataStructure?.dependencySchemas,
+        };
+    }
+    progress.succeed('Done');
+    // Output combined JSON (suppressed when called internally during startup)
+    if (!options.silent) {
+        const summary = formatApiSubcommandResult('analyze-imports', {
+            imports,
+            entities: entityData,
+        });
+        console.log(summary || JSON.stringify({ imports, entities: entityData }));
+    }
+}
+// ─── Validate-seed subcommand ─────────────────────────────────────────
+/**
+ * Validate seed data structure and check for a seed adapter.
+ * Usage: codeyam editor validate-seed '{"products":[...]}'
+ */
+function handleValidateSeed(jsonArg) {
+    const root = process.cwd();
+    // Check for seed adapter
+    const adapterPath = detectSeedAdapter(root);
+    if (adapterPath) {
+        console.log(chalk.green(`Seed adapter found: ${adapterPath}`));
+    }
+    else {
+        console.log(chalk.yellow('No seed adapter found. Create .codeyam/seed-adapter.ts to use seed-based scenarios.'));
+    }
+    if (!jsonArg) {
+        return;
+    }
+    let data;
+    try {
+        data = JSON.parse(jsonArg);
+    }
+    catch {
+        console.error(chalk.red('Error: Invalid JSON.'));
+        process.exit(1);
+    }
+    const result = validateSeedData(data);
+    if (result.valid) {
+        const tables = Object.keys(data);
+        const totalRows = tables.reduce((sum, t) => sum + (Array.isArray(data[t]) ? data[t].length : 0), 0);
+        console.log(chalk.green(`Seed data valid: ${tables.length} table(s), ${totalRows} total row(s)`));
+        for (const table of tables) {
+            const rows = Array.isArray(data[table])
+                ? data[table].length
+                : 0;
+            console.log(chalk.dim(`  ${table}: ${rows} row(s)`));
+        }
+    }
+    else {
+        console.error(chalk.red('Seed data validation failed:'));
+        for (const err of result.errors) {
+            console.error(chalk.red(`  - ${err}`));
+        }
+        process.exit(1);
+    }
+}
+// ─── Isolate subcommand ───────────────────────────────────────────────
+/**
+ * `codeyam editor isolate "StarRating CategoryBadge DrinkCard"`
+ *
+ * Creates isolation route directories and the layout guard file.
+ * This avoids brace-expansion permission prompts in the embedded terminal.
+ */
+function handleIsolate(componentNames) {
+    const root = process.cwd();
+    if (componentNames.length === 0) {
+        console.error(chalk.red('Usage: codeyam editor isolate "ComponentA ComponentB ..."'));
+        process.exit(1);
+    }
+    const isolateDir = path.join(root, 'app', 'isolated-components');
+    // Create layout.tsx with production guard if missing
+    const layoutPath = path.join(isolateDir, 'layout.tsx');
+    if (!fs.existsSync(layoutPath)) {
+        fs.mkdirSync(isolateDir, { recursive: true });
+        fs.writeFileSync(layoutPath, [
+            'import { notFound } from "next/navigation";',
+            '',
+            'export default function CaptureLayout({ children }: { children: React.ReactNode }) {',
+            '  if (process.env.NODE_ENV === "production") notFound();',
+            '  return <>{children}</>;',
+            '}',
+            '',
+        ].join('\n'), 'utf8');
+        console.log(chalk.green(`Created layout guard: app/isolated-components/layout.tsx`));
+    }
+    // Create a directory for each component
+    const created = [];
+    const existed = [];
+    for (const name of componentNames) {
+        const dir = path.join(isolateDir, name);
+        if (fs.existsSync(dir)) {
+            existed.push(name);
+        }
+        else {
+            fs.mkdirSync(dir, { recursive: true });
+            created.push(name);
+        }
+    }
+    if (created.length > 0) {
+        console.log(chalk.green(`Created ${created.length} isolation route dir(s): ${created.join(', ')}`));
+    }
+    if (existed.length > 0) {
+        console.log(chalk.dim(`Already existed: ${existed.join(', ')}`));
+    }
+}
+// ─── Register subcommand ──────────────────────────────────────────────
+/**
+ * Format API subcommand results as concise one-line summaries.
+ * Prevents Claude from piping output to python3 just to extract key fields.
+ * Returns null for subcommands that should keep raw JSON output.
+ */
+function formatApiSubcommandResult(subcommand, data) {
+    if (!data || typeof data !== 'object')
+        return null;
+    switch (subcommand) {
+        case 'journal': {
+            const parts = [`success=${data.success}`];
+            if (data.entry?.time)
+                parts.push(`time="${data.entry.time}"`);
+            if (data.entry?.title)
+                parts.push(`title="${data.entry.title}"`);
+            if (data.scenarioScreenshotsFound != null) {
+                parts.push(`screenshots=${data.scenarioScreenshotsFound}`);
+            }
+            return parts.join(' ');
+        }
+        case 'journal-update': {
+            const parts = [`success=${data.success}`];
+            if (data.entry?.time)
+                parts.push(`time="${data.entry.time}"`);
+            if (data.scenarioScreenshotsFound != null) {
+                parts.push(`screenshots=${data.scenarioScreenshotsFound}`);
+            }
+            return parts.join(' ');
+        }
+        case 'commit': {
+            const parts = [`success=${data.success}`];
+            if (data.sha)
+                parts.push(`sha=${data.sha}`);
+            if (data.message)
+                parts.push(`message="${data.message.split('\n')[0]}"`);
+            return parts.join(' ');
+        }
+        case 'preview': {
+            const parts = [
+                `success=${!!data.ok || data.success !== false}`,
+            ];
+            if (data.path)
+                parts.push(`path="${data.path}"`);
+            if (data.scenarioId)
+                parts.push(`scenarioId="${data.scenarioId}"`);
+            if (data.sessionsNotified != null)
+                parts.push(`notified=${data.sessionsNotified}`);
+            return parts.join(' ');
+        }
+        case 'dev-server': {
+            if (data.status) {
+                const parts = [`status=${data.status}`, `pid=${data.pid || 'none'}`];
+                if (data.url)
+                    parts.push(`url=${data.url}`);
+                if (data.proxyUrl)
+                    parts.push(`proxyUrl=${data.proxyUrl}`);
+                if (data.errorMessage)
+                    parts.push(`error: ${data.errorMessage}`);
+                return parts.join(' ');
+            }
+            return null;
+        }
+        case 'client-errors': {
+            const parts = [`hasErrors=${data.hasErrors}`];
+            parts.push(`totalErrors=${data.totalErrors ?? 0}`);
+            if (data.livePreview) {
+                const lp = data.livePreview;
+                parts.push(`livePreview=${lp.loaded ? 'loaded' : 'not-loaded'}`);
+                if (lp.loaded) {
+                    parts.push(`hasContent=${lp.hasContent}`);
+                }
+                const liveErrors = lp.errors?.length ?? 0;
+                parts.push(`liveErrors=${liveErrors}`);
+                if (liveErrors > 0) {
+                    // Show first few error messages for context
+                    for (const err of lp.errors.slice(0, 3)) {
+                        parts.push(`  error: ${err.message}`);
+                    }
+                }
+            }
+            else {
+                parts.push('livePreview=not-loaded');
+            }
+            return parts.join(' ');
+        }
+        case 'analyze-imports': {
+            const importEntries = Object.entries(data.imports || {});
+            const entityEntries = Object.entries(data.entities || {});
+            const parts = [];
+            parts.push(`entities=${entityEntries.length}`);
+            parts.push(`withImports=${importEntries.length}`);
+            if (importEntries.length > 0) {
+                parts.push(`imports: ${importEntries.map(([name, deps]) => `${name}→[${deps.join(',')}]`).join(' ')}`);
+            }
+            return parts.join(' ');
+        }
+        default:
+            return null; // journal-list, show/hide-results: keep full JSON
+    }
+}
+/**
+ * `codeyam editor register '{"name":"...","componentName":"...",...}'`
+ *
+ * Thin CLI wrapper around POST /api/editor-register-scenario.
+ * Auto-approved via `Bash(codeyam:*)` — no manual approval needed.
+ */
+async function handleRegister(jsonArg) {
+    if (!jsonArg) {
+        console.error(chalk.red('Error: JSON argument required.'));
+        console.error(chalk.dim('  Usage: codeyam editor register \'{"name":"DrinkCard - Default","componentName":"DrinkCard","url":"/isolated-components/DrinkCard?s=Default"}\''));
+        console.error(chalk.dim('  For large payloads: codeyam editor register @/tmp/scenario.json'));
+        process.exit(1);
+    }
+    const parsed = parseRegisterArg(jsonArg);
+    if (parsed.error) {
+        console.error(chalk.red(`Error: ${parsed.error}`));
+        if (parsed.error === 'Invalid JSON') {
+            console.error(chalk.dim(`  Received: ${jsonArg.slice(0, 200)}`));
+        }
+        process.exit(1);
+    }
+    const body = parsed.body;
+    const port = getServerPort();
+    const url = `http://localhost:${port}/api/editor-register-scenario`;
+    try {
+        const res = await fetch(url, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(body),
+        });
+        const data = await res.json();
+        // Print concise summary instead of raw JSON so Claude doesn't need python3
+        const parts = [];
+        parts.push(`success=${data.success}`);
+        if (data.scenario?.name)
+            parts.push(`name="${data.scenario.name}"`);
+        parts.push(`screenshot=${!!data.screenshotCaptured}`);
+        if (data.capturedViewport) {
+            parts.push(`viewport=${data.capturedViewport.width}×${data.capturedViewport.height}`);
+        }
+        if (data.scenario?.dimension)
+            parts.push(`dimension="${data.scenario.dimension}"`);
+        if (data.clientErrors?.length > 0) {
+            parts.push(chalk.red(`errors=${data.clientErrors.length}`));
+        }
+        else {
+            parts.push(`errors=0`);
+        }
+        if (data.seedResult)
+            parts.push(`seed=${data.seedResult.success}`);
+        if (data.captureError)
+            parts.push(chalk.yellow(`captureError="${data.captureError}"`));
+        console.log(parts.join(' '));
+        // Surface client errors prominently so they can't be missed
+        if (data.clientErrors && data.clientErrors.length > 0) {
+            console.log(chalk.red.bold(`⚠ WARNING: ${data.clientErrors.length} client error${data.clientErrors.length !== 1 ? 's' : ''} detected during capture:`));
+            for (const err of data.clientErrors) {
+                console.log(chalk.red(`  → ${err}`));
+            }
+            console.log(chalk.yellow('  The screenshot may show an error screen instead of the actual component.'));
+            console.log(chalk.yellow('  Fix the issue and re-register this scenario.'));
+        }
+        if (!res.ok) {
+            console.error(chalk.dim(JSON.stringify(data, null, 2)));
+            process.exit(1);
+        }
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        console.error(chalk.red(`Error: Could not reach editor server at ${url}`));
+        console.error(chalk.dim(`  ${msg}`));
+        console.error(chalk.dim('  Is the editor running? Start it with: codeyam editor'));
+        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();
+    let allEntities = await loadEntities({});
+    if (!allEntities || allEntities.length === 0) {
+        progress.succeed('No entities found — running analyze-imports first...');
+        try {
+            await handleAnalyzeImports({ silent: true });
+        }
+        catch {
+            console.error(chalk.red('Could not build import graph. Run `codeyam editor analyze-imports` manually.'));
+            process.exit(1);
+        }
+        // Reload entities after analysis
+        const reloaded = await loadEntities({});
+        if (!reloaded || reloaded.length === 0) {
+            progress.fail('No entities found even after analyze-imports');
+            process.exit(1);
+        }
+        allEntities = reloaded;
+    }
+    // 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. When called from
+ * step 13+, this loops back to step 13 (present). When called from an
+ * earlier step, it returns to that step so the normal flow continues.
+ */
+function handleChange(feature) {
+    const root = getProjectRoot();
+    const state = readState(root);
+    if (!feature) {
+        // Try to read feature from state
+        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 currentStep = state?.step ?? 13;
+    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();
+    const designSystem = readDesignSystem(root);
+    if (designSystem) {
+        console.log(chalk.bold.magenta('Design System (active):'));
+        console.log(chalk.magenta('  Use existing CSS custom property tokens when making visual changes — no hardcoded px or hex values.'));
+        console.log(chalk.magenta('  Use var(--text-sm) not 14, var(--spacing-lg) not 16px, var(--text-primary) not #1A1B25.'));
+        console.log();
+        console.log(designSystem);
+        console.log();
+    }
+    console.log(chalk.bold.cyan('Keep the preview moving:'));
+    console.log(chalk.cyan(`  Refresh after EACH individual change — not after all changes are done:`));
+    console.log(chalk.cyan(`  codeyam editor preview`));
+    console.log(chalk.cyan('  The user is watching the preview. Let them see progress incrementally.'));
+    console.log();
+    console.log(chalk.bold('0. Close the results panel:'));
+    checkbox(`Hide results: \`codeyam editor hide-results\``);
+    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","componentName":"ComponentName","componentPath":"app/components/ComponentName.tsx","url":"/isolated-components/ComponentName?s=ScenarioName"}'`));
+    checkbox('For any NEW components: `codeyam editor isolate NewComponent` then 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');
+    checkbox('If you re-seeded the database, restart the dev server to pick up fresh data');
+    console.log(chalk.dim(`    codeyam editor dev-server '{"action":"restart"}'`));
+    console.log();
+    console.log(chalk.bold('3. Re-capture app-level scenarios:'));
+    checkbox('For each changed component, run `codeyam editor dependents ComponentName` to find affected pages');
+    checkbox('Run `codeyam editor scenarios` to list all existing scenarios');
+    checkbox('For EACH page listed by dependents: find its existing scenarios in the list and re-register every one');
+    console.log(chalk.dim('    Shared components (headers, navbars, layouts) affect MANY pages — re-register all of them.'));
+    console.log(chalk.dim('    Re-register with the SAME name to update — do NOT create new/duplicate scenarios.'));
+    console.log(chalk.dim('    Example: if Header changed and Home, Catalog, Detail pages use it,'));
+    console.log(chalk.dim('    re-register "Home - Default", "Catalog - Full", "Detail - WithReviews", etc.'));
+    checkbox("Enrich existing scenario data to exercise the change — don't just re-register unchanged data");
+    console.log(chalk.dim('    Add data that demonstrates what changed: new fields, relationships, states, content variety.'));
+    checkbox('After each re-registration, view the screenshot to verify data is visible');
+    console.log(chalk.dim("    If the screenshot doesn't show the data you put in, the scenario is broken."));
+    console.log();
+    console.log(chalk.bold('4. Verify completeness:'));
+    checkbox(`Refresh the preview: \`codeyam editor preview\``);
+    checkbox(`Navigate to key pages to verify changes: \`codeyam editor preview '{"path":"/your-route"}'\``);
+    checkbox('Run `codeyam editor scenario-coverage` — all affected scenarios must be fresh');
+    checkbox('Run `codeyam editor audit` — all checks must pass');
+    checkbox(`Check for client-side errors: \`codeyam editor client-errors\``);
+    console.log(chalk.dim('    If `hasContent=false`, the preview is blank — fix the code before proceeding.'));
+    console.log(chalk.dim('    If `liveErrors>0`, there are JS errors in the preview — fix them.'));
+    checkbox('Fix any errors, then re-register affected scenarios');
+    checkbox('If changes affect setup, new dependencies, or new scripts: update `README.md` and `npm run setup`');
+    console.log();
+    console.log(chalk.bold('5. Update the existing journal entry:'));
+    checkbox('Get existing entry: `codeyam editor journal-list`');
+    checkbox('Find the uncommitted entry (commitSha is null) from this feature session');
+    checkbox(`Update it: \`codeyam editor journal-update '{"time":"<entry time>","description":"<updated description including changes>","includeSessionScenarios":true}'\``);
+    console.log(chalk.dim('    Always update the existing uncommitted entry — do NOT create a new one.'));
+    console.log(chalk.dim('    Only create a new entry (POST) if no uncommitted entry exists for this feature.'));
+    console.log();
+    // If the change was initiated from a step before 13, return to that step
+    // instead of jumping to step 13. The change workflow should only loop to
+    // step 13 when changes are requested FROM step 13.
+    if (currentStep < 13) {
+        console.log(chalk.red('  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
+        console.log(chalk.red.bold('  REQUIRED: Return to current step'));
+        console.log(chalk.red.bold('  When all checks pass, you MUST run: ') +
+            chalk.bold(`codeyam editor ${currentStep}`));
+        console.log(chalk.red('  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
+    }
+    else {
+        console.log(chalk.red('  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
+        console.log(chalk.red.bold('  REQUIRED: Show Results'));
+        console.log(chalk.red.bold('  When all checks pass, you MUST run: ') +
+            chalk.bold(`codeyam editor 13`));
+        console.log(chalk.red.bold('  The user ALWAYS expects to see results after changes. DO NOT skip this step.'));
+        console.log(chalk.red('  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
+    }
+    console.log();
+}
+// ─── Audit gate ─────────────────────────────────────────────────────
+/**
+ * Silently check whether the audit passes. Returns true if allPassing,
+ * false if any issues remain or the server is unreachable.
+ * Used as a hard gate before steps 8+.
+ */
+async function checkAuditGate() {
+    const port = getServerPort();
+    try {
+        const res = await fetch(`http://localhost:${port}/api/editor-audit`);
+        if (!res.ok)
+            return false;
+        const data = await res.json();
+        return data?.summary?.allPassing === true;
+    }
+    catch {
+        // Server not running or unreachable — can't verify, so don't block
+        return true;
+    }
+}
+// ─── 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('✗');
+            let detail;
+            if (c.status === 'has_errors') {
+                detail = chalk.red(` — ${c.scenarioCount} scenario${c.scenarioCount !== 1 ? 's' : ''} but has client errors`);
+            }
+            else if (c.status === 'ok') {
+                detail = chalk.dim(` (${c.scenarioCount} scenario${c.scenarioCount !== 1 ? 's' : ''})`);
+            }
+            else {
+                detail = chalk.red(' — no scenarios registered');
+            }
+            console.log(`  ${icon} ${c.name}${detail}`);
+            if (c.clientErrors && c.clientErrors.length > 0) {
+                for (const err of c.clientErrors.slice(0, 3)) {
+                    console.log(chalk.red(`      → ${err}`));
+                }
+                if (c.clientErrors.length > 3) {
+                    console.log(chalk.dim(`      … and ${c.clientErrors.length - 3} more`));
+                }
+            }
+        }
+        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('✗');
+            let detail;
+            switch (f.status) {
+                case 'ok':
+                    detail = chalk.dim(` (${f.testFile})`);
+                    break;
+                case 'failing':
+                    detail = chalk.red(` — tests failing: ${f.testFile}`);
+                    break;
+                case 'name_mismatch':
+                    detail = chalk.red(` — tests pass but missing top-level describe("${f.name}", ...) — tests won't display in UI`);
+                    break;
+                case 'missing':
+                default:
+                    detail = f.testFile
+                        ? chalk.red(` — test file missing: ${f.testFile}`)
+                        : chalk.red(' — no test file specified');
+                    break;
+            }
+            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.componentsWithErrors > 0) {
+            parts.push(`${summary.componentsWithErrors} component${summary.componentsWithErrors !== 1 ? 's' : ''} with client errors`);
+        }
+        if (summary.functionsMissing > 0) {
+            parts.push(`${summary.functionsMissing} function${summary.functionsMissing !== 1 ? 's' : ''} missing tests`);
+        }
+        if (summary.functionsFailing > 0) {
+            parts.push(`${summary.functionsFailing} function${summary.functionsFailing !== 1 ? 's' : ''} with failing tests`);
+        }
+        if (summary.functionsNameMismatch > 0) {
+            parts.push(`${summary.functionsNameMismatch} function${summary.functionsNameMismatch !== 1 ? 's' : ''} with test name mismatch (missing top-level describe)`);
+        }
+        console.log(chalk.red.bold('Audit failed: ') + parts.join(', '));
+    }
+    console.log();
+    if (!allOk) {
+        process.exit(1);
+    }
+    // Auto-run analyze-imports when audit passes — this builds the import graph
+    // so the App tab can show component/function dependencies for each page.
+    // Previously this was a manual step that Claude had to remember to run.
+    console.log(chalk.dim('Building import graph...'));
+    try {
+        await handleAnalyzeImports({ silent: true });
+    }
+    catch {
+        // Non-fatal — audit passed, import graph is a bonus
+        console.log(chalk.yellow('Warning: Could not build import graph. Run `codeyam editor analyze-imports` manually.'));
+    }
+}
+// ─── 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' : ''}`));
+    // Show screenshot paths so Claude can verify images with the Read tool
+    const withScreenshots = scenarios.filter((s) => s.screenshotPath);
+    if (withScreenshots.length > 0) {
+        console.log();
+        console.log(chalk.bold.cyan('Screenshots:'));
+        for (const s of withScreenshots) {
+            console.log(chalk.dim(`  ${s.name}: ${s.screenshotPath}`));
+        }
+    }
+    console.log();
+}
+// ─── Scenario Coverage subcommand ───────────────────────────────────
+async function handleScenarioCoverage() {
+    const port = getServerPort();
+    const url = `http://localhost:${port}/api/editor-scenario-coverage`;
+    let data;
+    try {
+        const res = await fetch(url);
+        if (!res.ok) {
+            console.error(chalk.red(`Error: Scenario coverage 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);
+    }
+    console.log();
+    console.log(chalk.bold.cyan('━━━ Scenario Coverage ━━━'));
+    console.log();
+    if (data.note) {
+        console.log(chalk.yellow(data.note));
+        console.log();
+        return;
+    }
+    // Fresh scenarios (already recaptured this feature)
+    if (data.freshScenarios.length > 0) {
+        console.log(chalk.green(`✓ ${data.freshScenarios.length} scenario(s) captured this feature:`));
+        for (const s of data.freshScenarios) {
+            console.log(chalk.dim(`    ${s.name} (${s.url || '/'})`));
+        }
+        console.log();
+    }
+    // Stale scenarios (need recapturing)
+    if (data.staleScenarios.length > 0) {
+        console.log(chalk.red(`✗ ${data.staleScenarios.length} scenario(s) need re-registering (stale screenshots):`));
+        for (const s of data.staleScenarios) {
+            console.log(chalk.yellow(`    ${s.name} (${s.url || '/'}) — ${s.changeStatus} but not recaptured`));
+        }
+        console.log();
+        console.log(chalk.yellow('Re-register each stale scenario with the SAME name to update its screenshot.'));
+        console.log(chalk.yellow("Enhance the seed data to reflect this feature's changes where relevant."));
+        console.log();
+    }
+    // Uncovered pages (changed but no scenarios at all)
+    if (data.uncoveredPages.length > 0) {
+        console.log(chalk.red(`✗ ${data.uncoveredPages.length} page(s) affected by changes with no scenarios:`));
+        for (const p of data.uncoveredPages) {
+            console.log(chalk.yellow(`    ${p.entityName} — ${p.changeStatus}`));
+        }
+        console.log();
+    }
+    // Summary
+    if (data.pass) {
+        console.log(chalk.green.bold('PASS — all affected scenarios are fresh'));
+    }
+    else {
+        console.log(chalk.red.bold('FAIL — re-register stale scenarios before proceeding'));
+    }
+    console.log();
+}
+// ─── Template subcommand ─────────────────────────────────────────────
+async function handleTemplate() {
+    const root = getProjectRoot();
+    const port = getServerPort();
+    if (hasProject(root)) {
+        console.log(chalk.yellow('Project already exists (package.json found). Skipping.'));
+        return;
+    }
+    // Determine which template to use from editor state
+    const state = readState(root);
+    const techStackId = state?.techStackId;
+    const stack = techStackId
+        ? TECH_STACKS.find((s) => s.id === techStackId)
+        : undefined;
+    const templateName = stack?.templateDir || 'nextjs-prisma-sqlite';
+    const templateDir = path.join(__dirname, '..', '..', 'templates', templateName);
+    if (!fs.existsSync(templateDir)) {
+        console.error(chalk.red('Error: Template directory not found at ' + templateDir));
+        process.exit(1);
+    }
+    const { execSync } = await import('child_process');
+    // 1. Copy template files
+    console.log(chalk.bold(`Copying ${stack?.name || templateName} template files...`));
+    execSync(`cp -r ${templateDir}/* .`, { cwd: root, stdio: 'inherit' });
+    // Copy dotfiles that are stored without the dot prefix in templates
+    const gitignorePath = path.join(templateDir, 'gitignore');
+    if (fs.existsSync(gitignorePath)) {
+        execSync(`cp ${templateDir}/gitignore .gitignore`, {
+            cwd: root,
+            stdio: 'inherit',
+        });
+    }
+    const envPath = path.join(templateDir, 'env');
+    if (fs.existsSync(envPath)) {
+        execSync(`cp ${templateDir}/env .env`, { cwd: root, stdio: 'inherit' });
+    }
+    // Copy seed adapter into .codeyam/ (stored outside .codeyam/ in the template
+    // to avoid gitignore issues — .codeyam/ is selectively ignored in user projects)
+    const seedAdapterSrc = path.join(templateDir, 'seed-adapter.ts');
+    if (fs.existsSync(seedAdapterSrc)) {
+        const codeyamDir = path.join(root, '.codeyam');
+        if (!fs.existsSync(codeyamDir)) {
+            fs.mkdirSync(codeyamDir, { recursive: true });
+        }
+        fs.copyFileSync(seedAdapterSrc, path.join(codeyamDir, 'seed-adapter.ts'));
+    }
+    console.log(chalk.green('  Template files copied.'));
+    // 2. Install dependencies
+    console.log(chalk.bold('Installing dependencies...'));
+    execSync('npm install', { cwd: root, stdio: 'inherit' });
+    console.log(chalk.green('  Dependencies installed.'));
+    // 3. Initialize git
+    const hasGit = fs.existsSync(path.join(root, '.git'));
+    if (!hasGit) {
+        console.log(chalk.bold('Initializing git...'));
+        execSync('git init && git add -A && git commit -m "Initial commit"', {
+            cwd: root,
+            stdio: 'inherit',
+        });
+        console.log(chalk.green('  Git initialized.'));
+    }
+    // 4. Run codeyam init
+    console.log(chalk.bold('Running codeyam init...'));
+    await initCommand.handler({
+        force: true,
+        'keep-server': true,
+        autoInit: false,
+        $0: '',
+        _: [],
+    });
+    console.log(chalk.green('  CodeYam initialized.'));
+    // 5. Verify config has startCommand
+    const configPath = path.join(root, '.codeyam', 'config.json');
+    if (fs.existsSync(configPath)) {
+        try {
+            const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+            const webapps = config.webapps || [];
+            const hasStartCommand = webapps.some((w) => w.startCommand);
+            if (!hasStartCommand) {
+                console.log(chalk.yellow('  Warning: No startCommand found in .codeyam/config.json webapps.'));
+                console.log(chalk.dim('  You may need to add: "startCommand": { "command": "sh", "args": ["-c", "npm run dev -- --port $PORT"] }'));
+            }
+        }
+        catch {
+            // Config parse error is non-fatal
+        }
+    }
+    // 5b. Write a fresh prototypeId so the proxy clears stale localStorage
+    const activeScenarioPath = path.join(root, '.codeyam', 'active-scenario.json');
+    fs.writeFileSync(activeScenarioPath, JSON.stringify({ prototypeId: Date.now().toString() }), 'utf-8');
+    // 6. Trigger editor-refresh so the server picks up the new project
+    console.log(chalk.bold('Refreshing editor...'));
+    try {
+        await fetch(`http://localhost:${port}/api/editor-refresh`, {
+            method: 'POST',
+        });
+        console.log(chalk.green('  Editor refreshed.'));
+    }
+    catch {
+        console.log(chalk.yellow('  Could not reach the CodeYam server for refresh. You may need to restart it.'));
+    }
+    console.log();
+    console.log(chalk.green.bold('Project scaffolded and ready!'));
+    console.log(chalk.dim('Next: Define your Prisma models, push the schema, seed the database, and build your feature.'));
+}
+// ─── Sync subcommand ─────────────────────────────────────────────────
+/**
+ * `codeyam editor sync`
+ * Import scenarios from editor-scenarios/ files into the local database.
+ * Falls back to legacy scenarios-manifest.json if no _metadata files found.
+ */
+async function handleSync() {
+    const root = getProjectRoot();
+    const entries = scanScenarioFiles(root);
+    if (entries.length === 0) {
+        console.log(chalk.yellow('No scenario files with metadata found. Nothing to sync.'));
+        return;
+    }
+    const configPath = path.join(root, '.codeyam', 'config.json');
+    let projectSlug = null;
+    try {
+        const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+        projectSlug = config.projectSlug || null;
+    }
+    catch {
+        // fall through
+    }
+    if (!projectSlug) {
+        console.error(chalk.red('Error: No project slug found. Run codeyam init first.'));
+        process.exit(1);
+    }
+    const connectionOk = await withoutSpinner(() => testEnvironment());
+    if (!connectionOk) {
+        errorLog('Environment validation failed');
+        return;
+    }
+    const { project } = await requireBranchAndProject(projectSlug);
+    const { getDatabase } = await import('../../../packages/database/index.js');
+    const db = getDatabase();
+    const existingRows = await db
+        .selectFrom('editor_scenarios')
+        .select(['id', 'updated_at'])
+        .where('project_id', '=', project.id)
+        .execute();
+    const result = await syncScenarioFilesToDatabase(root, project.id, existingRows, async (row) => {
+        await db
+            .insertInto('editor_scenarios')
+            .values(row)
+            .execute();
+    }, async (id, row) => {
+        await db
+            .updateTable('editor_scenarios')
+            .set(row)
+            .where('id', '=', id)
+            .execute();
+    });
+    if (result.inserted === 0 && result.updated === 0) {
+        console.log(chalk.dim('All scenarios up to date.'));
+    }
+    else {
+        const parts = [];
+        if (result.inserted > 0)
+            parts.push(`${result.inserted} imported`);
+        if (result.updated > 0)
+            parts.push(`${result.updated} updated`);
+        if (result.skipped > 0)
+            parts.push(`${result.skipped} unchanged`);
+        console.log(chalk.green(`Synced scenarios: ${parts.join(', ')}`));
+    }
+}
+// ─── Verify Images subcommand ─────────────────────────────────────────
+async function handleVerifyImages(jsonArg) {
+    const port = getServerPort();
+    const { parseVerifyImagesInput, extractImageUrls, resolveImageUrl, verifyImageUrls, buildVerifyImagesReport, extractImageUrlsFromScenarioFiles, } = await import('../utils/editorImageVerifier.js');
+    let paths;
+    let explicitImageUrls;
+    try {
+        const input = parseVerifyImagesInput(jsonArg);
+        paths = input.paths;
+        explicitImageUrls = input.imageUrls;
+    }
+    catch {
+        console.error(chalk.red('Error: Invalid JSON argument'));
+        process.exit(1);
+    }
+    // Get dev server URL
+    let devServerUrl;
+    try {
+        const res = await fetch(`http://localhost:${port}/api/editor-dev-server`);
+        const data = await res.json();
+        devServerUrl = data.url || `http://localhost:${data.port || 3000}`;
+    }
+    catch {
+        console.error(chalk.red('Error: Could not reach the CodeYam server. Is it running?'));
+        process.exit(1);
+    }
+    const allUrls = new Set();
+    let pagesChecked = 0;
+    for (const pagePath of paths) {
+        const pageUrl = `${devServerUrl}${pagePath}`;
+        try {
+            const res = await fetch(pageUrl);
+            if (!res.ok) {
+                console.error(chalk.red(`  ✗ ${pagePath} — HTTP ${res.status}`));
+                continue;
+            }
+            const html = await res.text();
+            const imageUrls = extractImageUrls(html);
+            for (const url of imageUrls) {
+                allUrls.add(resolveImageUrl(url, devServerUrl));
+            }
+            pagesChecked++;
+        }
+        catch (err) {
+            console.error(chalk.red(`  ✗ ${pagePath} — ${err.message}`));
+        }
+    }
+    // Add explicitly-provided image URLs (Claude passes these directly)
+    for (const url of explicitImageUrls) {
+        allUrls.add(resolveImageUrl(url, devServerUrl));
+    }
+    // Also scan scenario mock data files for image URLs (client-rendered pages)
+    const scenariosDir = path.join(getProjectRoot(), '.codeyam', 'editor-scenarios');
+    const { urls: scenarioUrls, filesScanned: scenarioFilesScanned } = extractImageUrlsFromScenarioFiles(scenariosDir);
+    for (const url of scenarioUrls) {
+        allUrls.add(resolveImageUrl(url, devServerUrl));
+    }
+    const urlList = [...allUrls];
+    const results = urlList.length > 0 ? await verifyImageUrls(urlList) : [];
+    const report = buildVerifyImagesReport({
+        pagesChecked,
+        imageUrls: urlList,
+        results,
+        scenarioFilesScanned,
+    });
+    console.log(JSON.stringify(report, null, 2));
+    if (report.failures.length > 0) {
+        process.exit(1);
+    }
+}
+// ─── 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,
+        13: printStep13,
+        14: printStep14,
+        15: printStep15,
+        16: printStep16,
+    };
+    for (let step = 1; step <= 16; 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) => {
+        const stepDescription = IS_INTERNAL_BUILD
+            ? 'Step number (1-16) or subcommand (template, register, isolate, analyze-imports, dependents, audit, scenarios, scenario-coverage, change, sync, debug, preview, show-results, hide-results, commit, journal, journal-list, journal-update, dev-server, client-errors)'
+            : 'Step number (1-16) or subcommand (template, register, isolate, analyze-imports, dependents, audit, scenarios, scenario-coverage, change, sync, preview, show-results, hide-results, commit, journal, journal-list, journal-update, dev-server, client-errors)';
+        let builder = yargs
+            .positional('step', {
+            type: 'string',
+            describe: stepDescription,
+        })
+            .positional('json', {
+            type: 'string',
+            describe: 'JSON argument for register subcommand',
+        })
+            .option('feature', {
+            type: 'string',
+            describe: 'Feature name (required for step 2)',
+        })
+            .option('app-formats', {
+            type: 'string',
+            describe: 'Comma-separated app formats (mobile-responsive-web-app, desktop-app, mobile-app)',
+        })
+            .option('tech-stack', {
+            type: 'string',
+            describe: 'Selected tech stack ID (e.g., nextjs-prisma-sqlite)',
+        })
+            .option('prompt', {
+            type: 'string',
+            describe: "User's original prompt (captured for journal/results)",
+        })
+            .option('port', {
+            type: 'number',
+            alias: 'p',
+            describe: 'Port to run the web server on',
+            default: 3111,
+        });
+        if (IS_INTERNAL_BUILD) {
+            builder = builder
+                .option('target', {
+                type: 'string',
+                describe: 'Debug target (setup, overview, overview-with-state, step-1..step-16, 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();
+        // API subcommands: preview, show-results, hide-results, commit,
+        // journal, journal-update, dev-server, client-errors
+        if (argv.step && EDITOR_API_SUBCOMMANDS.includes(argv.step)) {
+            const port = getServerPort();
+            try {
+                const request = buildEditorApiRequest(argv.step, argv.json || undefined);
+                const result = await callEditorApi(request, port);
+                if (!result.ok) {
+                    console.error(chalk.red(`Error: ${request.endpoint} returned ${result.status}`));
+                    if (result.data)
+                        console.error(JSON.stringify(result.data, null, 2));
+                    process.exit(1);
+                }
+                if (result.data != null) {
+                    const summary = formatApiSubcommandResult(argv.step, result.data);
+                    if (summary) {
+                        console.log(summary);
+                    }
+                    else {
+                        console.log(JSON.stringify(result.data, null, 2));
+                    }
+                }
+            }
+            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);
+            }
+            return;
+        }
+        // Subcommand: codeyam editor register '{"name":"..."}'
+        if (argv.step === 'register') {
+            await handleRegister(argv.json || '');
+            return;
+        }
+        // Subcommand: codeyam editor analyze-imports
+        if (argv.step === 'analyze-imports') {
+            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 scenario-coverage
+        if (argv.step === 'scenario-coverage') {
+            await handleScenarioCoverage();
+            return;
+        }
+        // Subcommand: codeyam editor change <feature>
+        if (argv.step === 'change') {
+            handleChange(argv.json || '');
+            return;
+        }
+        // Subcommand: codeyam editor verify-images '{"paths":["/","/drinks/1"]}'
+        if (argv.step === 'verify-images') {
+            await handleVerifyImages(argv.json || '');
+            return;
+        }
+        // Subcommand: codeyam editor validate-seed '{"products":[...]}'
+        if (argv.step === 'validate-seed') {
+            await handleValidateSeed(argv.json || '');
+            return;
+        }
+        // Subcommand: codeyam editor isolate "StarRating CategoryBadge DrinkCard"
+        if (argv.step === 'isolate') {
+            const names = [];
+            if (argv.json)
+                names.push(...argv.json.split(/[\s,]+/).filter(Boolean));
+            // Collect any extra positional args (yargs puts them in argv._)
+            const extras = argv._.filter((a) => typeof a === 'string' && a !== 'editor');
+            names.push(...extras);
+            handleIsolate(names);
+            return;
+        }
+        // Subcommand: codeyam editor template — scaffold project from template
+        if (argv.step === 'template') {
+            await handleTemplate();
+            return;
+        }
+        // Subcommand: codeyam editor sync — import scenarios from manifest
+        if (argv.step === 'sync') {
+            await handleSync();
+            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;
+        }
+        // Subcommand: codeyam editor steps — show setup or cycle overview
+        if (argv.step === 'steps') {
+            if (!hasProject(root)) {
+                printSetup(root);
+            }
+            else {
+                const state = readState(root);
+                // Clear prompt file when feature is done (step 16) so the hook
+                // can capture the next feature request from the user.
+                if (state?.step === 16) {
+                    clearEditorUserPrompt(root);
+                }
+                printCycleOverview(root, state);
+            }
+            return;
+        }
+        const step = argv.step ? parseInt(argv.step, 10) : undefined;
+        if (step != null && (isNaN(step) || step < 1 || step > 16)) {
+            console.error(chalk.red(`Error: Invalid step "${argv.step}". Must be 1-16.`));
+            process.exit(1);
+        }
+        if (step == null) {
+            // No step specified: launch editor server + open browser
+            // Auto-init if needed
+            let projectRoot = getStateProjectRoot();
+            if (!projectRoot) {
+                await initCommand.handler({
+                    force: false,
+                    autoInit: true,
+                    $0: '',
+                    _: [],
+                });
+                projectRoot = getStateProjectRoot();
+                if (!projectRoot) {
+                    return;
+                }
+            }
+            const configPath = path.join(projectRoot, '.codeyam', 'config.json');
+            try {
+                const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+                const { projectSlug } = config;
+                if (!projectSlug) {
+                    errorLog('Missing project slug. Try reinitializing with: codeyam init --force');
+                    return;
+                }
+                const connectionOk = await withoutSpinner(() => testEnvironment());
+                if (!connectionOk) {
+                    errorLog('Environment validation failed');
+                    return;
+                }
+                const { project, branch } = await requireBranchAndProject(projectSlug);
+                // Backfill _metadata into existing scenario files that predate the embedded metadata feature.
+                // This reads metadata from the DB and writes it into files that don't have _metadata yet.
+                try {
+                    const { getDatabase } = await import('../../../packages/database/index.js');
+                    const db = getDatabase();
+                    const dbScenarios = await db
+                        .selectFrom('editor_scenarios')
+                        .select([
+                        'id',
+                        'name',
+                        'description',
+                        'component_name',
+                        'component_path',
+                        'url',
+                        'type',
+                        'screenshot_path',
+                        'viewport_width',
+                        'viewport_height',
+                        'created_at',
+                        'updated_at',
+                    ])
+                        .where('project_id', '=', project.id)
+                        .execute();
+                    if (dbScenarios.length > 0) {
+                        const backfilled = backfillScenarioMetadata(projectRoot, dbScenarios);
+                        if (backfilled > 0) {
+                            console.log(chalk.green(`  Backfilled metadata into ${backfilled} scenario file${backfilled > 1 ? 's' : ''}`));
+                        }
+                    }
+                }
+                catch {
+                    // Non-fatal — backfill is best-effort
+                }
+                // Auto-sync scenario files (with _metadata) to database
+                const scenarioEntries = scanScenarioFiles(projectRoot);
+                if (scenarioEntries.length > 0) {
+                    try {
+                        const { getDatabase } = await import('../../../packages/database/index.js');
+                        const db = getDatabase();
+                        const existingRows = await db
+                            .selectFrom('editor_scenarios')
+                            .select(['id', 'updated_at'])
+                            .where('project_id', '=', project.id)
+                            .execute();
+                        const syncResult = await syncScenarioFilesToDatabase(projectRoot, project.id, existingRows, async (row) => {
+                            await db
+                                .insertInto('editor_scenarios')
+                                .values(row)
+                                .execute();
+                        }, async (id, row) => {
+                            await db
+                                .updateTable('editor_scenarios')
+                                .set(row)
+                                .where('id', '=', id)
+                                .execute();
+                        });
+                        if (syncResult.inserted > 0 || syncResult.updated > 0) {
+                            const parts = [];
+                            if (syncResult.inserted > 0)
+                                parts.push(`${syncResult.inserted} imported`);
+                            if (syncResult.updated > 0)
+                                parts.push(`${syncResult.updated} updated`);
+                            console.log(chalk.green(`  Synced scenarios from files: ${parts.join(', ')}`));
+                        }
+                    }
+                    catch {
+                        // Non-fatal — sync failure shouldn't block editor startup
+                    }
+                }
+                // `codeyam editor` (no step) always implies editor mode.
+                // The empty-folder heuristic is no longer needed here — running this
+                // command IS the signal.  We still detect empty folders so that
+                // the very first `codeyam editor` in a bare directory works before
+                // metadata has been persisted.
+                const editorMode = true;
+                if (editorMode && !project.metadata?.labs?.simulations) {
+                    try {
+                        await updateProjectMetadata({
+                            projectSlug,
+                            metadataUpdate: {
+                                editorMode: true,
+                                labs: { simulations: true },
+                            },
+                        });
+                        const refreshed = await requireBranchAndProject(projectSlug);
+                        Object.assign(project, refreshed.project);
+                    }
+                    catch {
+                        // Non-fatal
+                    }
+                }
+                // Install skills/hooks
+                const simulationsEnabled = project.metadata?.labs?.simulations ?? false;
+                const skillMode = simulationsEnabled
+                    ? 'full'
+                    : editorMode
+                        ? 'editor'
+                        : 'memory';
+                await installClaudeCodeSkills(projectRoot, {
+                    mode: skillMode,
+                    editorMode,
+                });
+                setupClaudeCodeSettings(projectRoot, {
+                    mode: skillMode,
+                    editorMode,
+                });
+                // Auto-finalize analyzer so codeyam analyze works
+                if (editorMode) {
+                    const finalization = ensureAnalyzerFinalized();
+                    if (finalization.needed) {
+                        console.log(`  Setting up simulations (${finalization.stepsRun.join(', ')})...`);
+                    }
+                    if (finalization.errors.length > 0) {
+                        for (const err of finalization.errors) {
+                            console.warn(`  Warning: ${err.step} failed: ${err.message}`);
+                        }
+                    }
+                }
+                // Start background server (handles killing existing servers internally)
+                const editorPort = argv.port || 3111;
+                const { url } = await startBackgroundServer({
+                    port: editorPort,
+                    rootPath: projectRoot,
+                    project,
+                    branch,
+                });
+                // Build import graph on first startup if glossary exists but no entities yet
+                const glossaryPath = path.join(projectRoot, '.codeyam', 'glossary.json');
+                if (fs.existsSync(glossaryPath)) {
+                    const entities = await loadEntities({});
+                    if (!entities || entities.length === 0) {
+                        try {
+                            await handleAnalyzeImports({ silent: true });
+                        }
+                        catch {
+                            // Non-fatal
+                        }
+                    }
+                }
+                console.log();
+                console.log(`  Dashboard: ${url}`);
+                console.log('  Run "codeyam --help" for all commands');
+                console.log(chalk.bold('  Run "codeyam editor" to launch the editor at any time'));
+                console.log();
+                // Open browser to /editor
+                try {
+                    const { execSync } = await import('child_process');
+                    const openCommand = process.platform === 'darwin'
+                        ? 'open'
+                        : process.platform === 'win32'
+                            ? 'start ""'
+                            : 'xdg-open';
+                    execSync(`${openCommand} "${url}/editor"`, { stdio: 'ignore' });
+                }
+                catch {
+                    // Silently fail if open command doesn't work
+                }
+            }
+            catch (err) {
+                errorLog('Failed to start CodeYam editor server');
+                errorLog(err);
+                process.exit(1);
+            }
+            return;
+        }
+        const state = readState(root);
+        // Validate step transition — prevent skipping steps.
+        // Exception: step 2 with --feature is always allowed because step 1's
+        // instructions explicitly tell Claude to run `codeyam editor 2 --feature "..."`.
+        // Step 1 is planning-only and may not persist state (no --feature flag).
+        const skipValidation = step === 2 && argv.feature;
+        if (!skipValidation) {
+            const stepError = validateStepTransition(step, state?.step ?? null);
+            if (stepError) {
+                console.error(chalk.red(`Error: ${stepError}`));
+                process.exit(1);
+            }
+        }
+        switch (step) {
+            case 1: {
+                const feature = argv.feature || undefined;
+                const appFormats = argv['app-formats']
+                    ? argv['app-formats'].split(',').map((f) => f.trim())
+                    : undefined;
+                const techStackId = argv['tech-stack'] || undefined;
+                const prompt = argv.prompt || undefined;
+                printStep1(root, feature, { appFormats, techStackId }, prompt);
+                break;
+            }
+            case 2: {
+                const feature = argv.feature || state?.feature;
+                if (!feature) {
+                    console.error(chalk.red('Error: --feature "Feature Name" is required for step 2.'));
+                    console.error(chalk.dim('  Usage: codeyam editor 2 --feature "Drink Rating System"'));
+                    process.exit(1);
+                }
+                printStep2(root, feature);
+                break;
+            }
+            case 3:
+            case 4:
+            case 5:
+            case 6:
+            case 7:
+            case 8:
+            case 9:
+            case 10:
+            case 11:
+            case 12:
+            case 13:
+            case 14:
+            case 15:
+            case 16: {
+                const feature = argv.feature || state?.feature;
+                if (!feature) {
+                    console.error(chalk.red('Error: No feature in progress. Run codeyam editor 1 first.'));
+                    process.exit(1);
+                }
+                // Hard gate: steps 8+ require audit to have passed
+                if (step >= 8) {
+                    const auditOk = await checkAuditGate();
+                    if (!auditOk) {
+                        console.error(chalk.red.bold('BLOCKED: The audit has not passed. Run `codeyam editor audit` and fix all issues before proceeding.'));
+                        console.error(chalk.yellow('Every function and hook must have a test file. Every component must have scenarios.'));
+                        process.exit(1);
+                    }
+                }
+                const stepFns = {
+                    3: printStep3,
+                    4: printStep4,
+                    5: printStep5,
+                    6: printStep6,
+                    7: printStep7,
+                    8: printStep8,
+                    9: printStep9,
+                    10: printStep10,
+                    11: printStep11,
+                    12: printStep12,
+                    13: printStep13,
+                    14: printStep14,
+                    15: printStep15,
+                    16: printStep16,
+                };
+                stepFns[step](root, feature);
+                break;
+            }
+        }
+    },
+};
+export default editorCommand;
+//# sourceMappingURL=editor.js.map