@codeyam/codeyam-cli 0.1.0-staging.30dc541 → 0.1.0-staging.39719f5

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

@@ -21,6 +21,7 @@ import { validateSeedData, detectSeedAdapter, validateSeedKeysAgainstPrisma, } f
 import { deleteScenarioViaCli } from "../utils/editorDeleteScenario.js";
 import { buildEditorApiRequest, callEditorApi, EDITOR_API_SUBCOMMANDS, } from "../utils/editorApi.js";
 import { parseRegisterArg } from "../utils/parseRegisterArg.js";
+import { classifyRegistrationResult } from "../utils/registerScenarioResult.js";
 import { sanitizeGlossaryEntries } from "../utils/editorLoaderHelpers.js";
 import { readMigrationState, writeMigrationState, advanceToNextPage, completePage, getMigrationResumeInfo, } from "../utils/editorMigration.js";
 const __filename = fileURLToPath(import.meta.url);
@@ -121,6 +122,13 @@ function writeState(root, state) {
     const dir = path.dirname(statePath);
     fs.mkdirSync(dir, { recursive: true });
     fs.writeFileSync(statePath, JSON.stringify(state, null, 2), 'utf8');
+    // Write task tracking file — marks that a task is expected for this step.
+    // The step hook sets taskCreated=true when it sees a TaskCreate tool call.
+    // Steps 1 and below don't require tasks (feature not named yet).
+    if (state.step && state.step >= 2) {
+        const trackingPath = path.join(root, '.codeyam', 'editor-task-tracking.json');
+        fs.writeFileSync(trackingPath, JSON.stringify({ step: state.step, taskCreated: false }, null, 2), 'utf8');
+    }
 }
 /**
  * Clear the editor state (for starting a new feature).
@@ -203,6 +211,34 @@ function checkbox(text) {
     const highlighted = text.replace(/`([^`]+)`/g, (_m, code) => chalk.cyan(code));
     console.log(`  ${chalk.dim('[ ]')} ${highlighted}`);
 }
+/**
+ * Instructions for creating/updating .codeyam/data-structure.json.
+ * Only prints creation instructions if the file doesn't exist yet.
+ * If it exists, reminds Claude to update it if data models changed.
+ */
+function printDataStructureInstructions() {
+    const root = getProjectRoot();
+    const dsPath = path.join(root, '.codeyam', 'data-structure.json');
+    const exists = fs.existsSync(dsPath);
+    if (!exists) {
+        console.log(chalk.bold('Create the data structure config:'));
+        checkbox('Create `.codeyam/data-structure.json` describing all data sources');
+        console.log(chalk.dim("  This file tells the editor what data the app uses and how it's stored."));
+        console.log(chalk.dim('  The file is a JSON array. Each entry describes one data source:'));
+        console.log(chalk.dim('  { "name": "Drink", "description": "...", "category": "datastore", "order": 1,'));
+        console.log(chalk.dim('    "fields": [{ "name": "id", "type": "number", "isId": true, "required": true }, ...] }'));
+        console.log();
+        console.log(chalk.dim('  category: "datastore" for persisted data (DB, localStorage)'));
+        console.log(chalk.dim('           "mock-api" for mocked external API responses'));
+        console.log(chalk.dim('  order: 1 = primary data store, 2 = secondary, etc.'));
+        console.log(chalk.dim('  Do NOT include types only used as component props.'));
+    }
+    else {
+        checkbox('If this feature changes data models, update `.codeyam/data-structure.json`');
+        console.log(chalk.dim('  Add new tables, update fields, or change descriptions to match.'));
+    }
+    console.log();
+}
 /**
  * Shared app scenario registration instructions used by editor Step 8 and migration Steps 1/6.
  * Prints seed-based scenarios, mock-based fallback, @ file prefix, externalApis, url requirement, and error checking.
@@ -248,11 +284,15 @@ function printAppScenarioInstructions(pageName, route) {
         console.log(chalk.dim('    Use "mockData":{"routes":{"/api/...":{"body":[...]}}} to mock API responses'));
         console.log(chalk.dim('    For external APIs: add "externalApis":{"GET https://...":{"body":[...],"status":200}}'));
     }
-    checkbox('For large seed/mock data, write JSON to a temp file and use @ prefix:');
-    console.log(chalk.dim('    Write JSON to .codeyam/tmp/scenario.json then register with:'));
-    console.log(chalk.dim('    codeyam editor register @.codeyam/tmp/scenario.json'));
+    console.log();
+    console.log(chalk.bold('Register ALL scenarios at once (bulk registration):'));
+    console.log(chalk.dim('    Write an array of scenario objects to a temp file:'));
+    console.log(chalk.dim('    [{"name":"...","type":"application","url":"/","seed":{...}}, {"name":"...","url":"/other",...}]'));
+    console.log(chalk.dim('    Then register all at once: codeyam editor register @.codeyam/tmp/scenarios.json'));
+    console.log(chalk.yellow('    Bulk registration is preferred — faster and avoids repeated capture overhead.'));
+    console.log();
     checkbox('If the app uses auth, email, or other patterns: see FEATURE_PATTERNS.md for scenario guidance');
-    checkbox('After each registration, check the response for `clientErrors`');
+    checkbox('After 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'));
 }
@@ -317,7 +357,7 @@ function printExtractionPlanInstructions() {
  */
 function printComponentCaptureInstructions() {
     checkbox('Create isolation route dirs: `codeyam editor isolate ComponentA ComponentB ...`');
-    console.log(chalk.dim('    This creates app/codeyam-isolate/layout.tsx (with production notFound() guard) and'));
+    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('For each visual component:');
     console.log(chalk.dim('    1. Read the source AND find where it is used in the app to understand:'));
@@ -329,8 +369,8 @@ function printComponentCaptureInstructions() {
     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/codeyam-isolate.ComponentName.tsx → /codeyam-isolate/ComponentName'));
-    console.log(chalk.dim('       Next.js: app/codeyam-isolate/ComponentName/page.tsx → /codeyam-isolate/ComponentName'));
+    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":'));
@@ -343,9 +383,9 @@ function printComponentCaptureInstructions() {
     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":"/codeyam-isolate/ComponentName?s=Scenario",`));
+    console.log(chalk.dim(`         "url":"/isolated-components/ComponentName?s=Scenario",`));
     console.log(chalk.dim(`         "mockData":{"routes":{"/api/...":{"body":[...]}}}}'`));
-    console.log(chalk.yellow('       IMPORTANT: url MUST be an isolation route (/codeyam-isolate/... or /isolated-components/...).'));
+    console.log(chalk.yellow('       IMPORTANT: url MUST be an isolation route (/isolated-components/...).'));
     console.log(chalk.yellow('       Do NOT use real page URLs (like /library) for component scenarios.'));
     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)'));
@@ -353,6 +393,10 @@ function printComponentCaptureInstructions() {
     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('  Bulk registration: write all component scenarios to a temp file as an array:'));
+    console.log(chalk.dim('    [{"name":"Comp - Default","componentName":"Comp","componentPath":"...","url":"/isolated-components/Comp?s=Default"}, ...]'));
+    console.log(chalk.dim('    codeyam editor register @.codeyam/tmp/scenarios.json'));
 }
 /**
  * Print a section header.
@@ -393,9 +437,33 @@ function printProgressTracker(current) {
  *
  * Options:
  * - confirm: true  → step requires user confirmation before proceeding (steps 1, 3, 11)
+ * - feature: string → feature name for task directive
  */
 function stopGate(current, opts) {
-    console.log();
+    const totalSteps = Object.keys(STEP_LABELS).length;
+    const currentLabel = STEP_LABELS[current] || `Step ${current}`;
+    const nextLabel = current < totalSteps ? STEP_LABELS[current + 1] : undefined;
+    console.log();
+    // ━━━ TASK ━━━ — deterministic task lifecycle directive
+    // Skip step 1 (no feature name yet — task starts at step 2)
+    if (current >= 2) {
+        console.log(chalk.bold.cyan('━━━ TASK ━━━'));
+        console.log(chalk.cyan('Before creating the task below, delete ALL existing tasks:'));
+        console.log(chalk.cyan('  1. Run TaskList to find all tasks'));
+        console.log(chalk.cyan('  2. Run TaskUpdate with status "deleted" for EACH task returned'));
+        console.log(chalk.cyan('Then create a new task with this EXACT title (copy verbatim):'));
+        console.log();
+        let taskTitle;
+        if (current < totalSteps) {
+            taskTitle = `Complete codeyam editor step ${current}: '${currentLabel}' and move on to step ${current + 1}: '${nextLabel}'`;
+        }
+        else {
+            taskTitle =
+                'Ask user what to build next and restart codeyam editor workflow';
+        }
+        console.log(chalk.bold.cyan(`EXACT_TASK_TITLE: ${taskTitle}`));
+        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.'));
@@ -404,20 +472,12 @@ function stopGate(current, opts) {
         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 < 18) {
+    if (current < totalSteps) {
         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 steps') +
-            chalk.green(' to start the next feature'));
+        console.log(chalk.green('Feature complete! Ask the user what to build next, then run: ') + chalk.bold('codeyam editor 1'));
     }
     console.log();
 }
@@ -785,9 +845,7 @@ function printCycleOverview(root, state) {
         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(chalk.dim('Or ask the user what to build next, then run `codeyam editor 1` yourself (never expose this command to the user)'));
         console.log();
         console.log(chalk.yellow('If the user reports a bug or requests any change, run: ') +
             chalk.bold('codeyam editor change'));
@@ -815,7 +873,8 @@ function printCycleOverview(root, state) {
         console.log(`  ${chalk.bold.yellow('17')} ${chalk.bold('Finalize')}           — Journal update + amend commit`);
         console.log(`  ${chalk.bold.yellow('18')} ${chalk.bold('Push')}               — Push to remote`);
         console.log();
-        console.log(chalk.green('Start now: ') + chalk.bold('codeyam editor 1'));
+        console.log(chalk.green('Start now: ') +
+            'Ask the user what they want to build, then run `codeyam editor 1` (never expose this command to the user)');
         console.log(chalk.dim('  If the user already described what they want, pass it: codeyam editor 1 --prompt "their message"'));
     }
     console.log(chalk.dim('If stuck on CLI commands, scenarios, or debugging, read: .codeyam/docs/editor-reference.md'));
@@ -894,12 +953,6 @@ function printStep1(root, feature, options, userPrompt) {
     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.'));
@@ -927,13 +980,6 @@ function printStep2(root, feature) {
     if (isResuming) {
         printResumptionHeader(2);
     }
-    console.log(chalk.bold.red('━━━ MANDATORY: CREATE TASK NOW ━━━'));
-    console.log();
-    console.log(chalk.red(`Run TaskCreate with title: "Use \`codeyam editor\` to work on ${feature}"`));
-    console.log(chalk.red('DO NOT read files, scaffold, write code, or do ANYTHING else until this task exists.'));
-    console.log(chalk.red('This is not optional. Create the task, then continue below.'));
-    console.log(chalk.bold.red('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
-    console.log();
     console.log('Get the project ready to build.');
     console.log();
     // If no project exists yet, include scaffolding instructions first
@@ -963,6 +1009,7 @@ function printStep2(root, feature) {
         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();
+        printDataStructureInstructions();
     }
     else {
         console.log(chalk.bold('Prepare the database for this feature:'));
@@ -977,6 +1024,7 @@ function printStep2(root, feature) {
         console.log(chalk.dim('    This switches the active scenario, runs the seed adapter, and refreshes the preview.'));
         console.log(chalk.dim('    If no existing scenario fits, use the default seed: npm run db:seed'));
         console.log();
+        printDataStructureInstructions();
     }
     stopGate(2);
 }
@@ -1012,6 +1060,13 @@ function printStep3(root, feature) {
         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>'));
+        console.log();
+        console.log(chalk.bold.cyan('Make seed data visually rich:'));
+        console.log(chalk.cyan('  • Use real placeholder images from Unsplash (https://images.unsplash.com/photo-<id>?w=400&h=300&fit=crop)'));
+        console.log(chalk.cyan('  • Use avatar services like i.pravatar.cc for user profile photos'));
+        console.log(chalk.cyan('  • Write realistic, varied content — not "Item 1", "Item 2", "Test Description"'));
+        console.log(chalk.cyan('  • Include different text lengths, categories, dates, and statuses'));
+        console.log(chalk.cyan('  • Rich seed data makes the prototype look real and surfaces layout issues early'));
     }
     checkbox('Verify the dev server shows the changes');
     checkbox('If the feature involves auth, email, payments, or other common patterns: read FEATURE_PATTERNS.md');
@@ -1051,6 +1106,8 @@ function printStep3(root, feature) {
     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","dimension":"${dim}"}'`));
     printDimensionGuidance(dim, dimNames);
+    console.log(chalk.red.bold('  NEVER claim "you should see X" or "the preview shows X" unless you just ran a preview command.'));
+    console.log(chalk.red('  The preview only updates when you explicitly refresh it. Verify, then describe.'));
     console.log();
     stopGate(3);
 }
@@ -1147,6 +1204,8 @@ function printStep5(root, feature) {
     printDimensionGuidance(dim, dimNames);
     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(chalk.red.bold('    NEVER claim "you should see X" or "the preview shows X" unless you just ran a preview command.'));
+    console.log(chalk.red('    The preview only updates when you explicitly call `codeyam editor preview`. Verify, then describe.'));
     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!"');
@@ -1300,7 +1359,13 @@ function printStep9(root, feature) {
     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 10 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(chalk.dim('    The audit auto-fixes incomplete entities by running targeted analysis on just the affected files.'));
+    console.log(chalk.dim('    If the audit reports issues (including pre-existing ones), fix ALL of them — do not skip.'));
+    console.log(chalk.dim('    Re-run `codeyam editor audit` until all checks pass. Do NOT run `codeyam editor analyze-imports`'));
+    console.log(chalk.dim('    — the audit runs targeted analysis automatically and is much faster.'));
+    console.log(chalk.dim('    If the audit reports "MANUAL ANALYSIS REQUIRED" for any entities,'));
+    console.log(chalk.dim('    follow the manual analysis steps in the audit output.'));
+    console.log(chalk.dim('    Do NOT re-run analyze-imports for those entities — it will fail again.'));
     console.log();
     stopGate(9);
 }
@@ -1335,6 +1400,7 @@ function printStep10(root, feature) {
     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('  • Use real image URLs (Unsplash, Pravatar) — not broken placeholders or empty strings'));
     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:'));
@@ -1549,7 +1615,7 @@ function printStep15(root, feature) {
     console.log(chalk.bold('Checklist:'));
     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 preview automatically switches to the first app-level scenario.'));
+    console.log(chalk.dim('    The first scenario is automatically selected and its live preview is shown.'));
     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)');
@@ -1789,7 +1855,7 @@ function printMigrateStep4(root) {
     checkbox('Check for client errors: `codeyam editor client-errors`');
     checkbox('If any issues: fix the scenario data, re-register affected scenarios');
     checkbox('Show results: `codeyam editor show-results`');
-    console.log(chalk.dim('    The preview automatically switches to the first app-level scenario.'));
+    console.log(chalk.dim('    The first scenario is automatically selected and its live preview is shown.'));
     console.log();
     console.log(chalk.dim('The user should now see their existing page with live screenshots in the preview.'));
     migrationStopGate(4, pageName, pageIndex, totalPages);
@@ -1901,7 +1967,7 @@ function printMigrateStep8(root) {
     console.log(chalk.bold.red('Re-register App Scenarios (REQUIRED):'));
     console.log(chalk.yellow(`  You MUST re-register application scenarios for "${page.route}" to get fresh screenshots.`));
     checkbox('Fetch existing scenarios: `codeyam editor scenarios`');
-    checkbox('Find all scenarios that use the real page route (not /codeyam-isolate/ paths)');
+    checkbox('Find all scenarios that use the real page route (not /isolated-components/ paths)');
     checkbox('Re-register each one with the SAME name to update its screenshot');
     console.log(chalk.dim(`    Example: codeyam editor register '{"name":"${pageName} - Full Data","type":"application","url":"${page.route}",...}'`));
     checkbox('After each registration, check the response for `clientErrors`');
@@ -1956,7 +2022,7 @@ function printMigrateStep10(root) {
     console.log();
     console.log(chalk.bold('Checklist:'));
     checkbox('Show results: `codeyam editor show-results`');
-    console.log(chalk.dim('    The preview automatically switches to the first app-level scenario.'));
+    console.log(chalk.dim('    The first scenario is automatically selected and its live preview is shown.'));
     checkbox('Write a 1-2 sentence summary of what was migrated');
     console.log();
     console.log(chalk.bold('Present a selection menu (AskUserQuestion with these EXACT option labels):'));
@@ -2253,15 +2319,13 @@ function printStep18(root, feature) {
     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('Mark the current build task as complete');
-    checkbox('Create a new task with EXACTLY this title: "Ask the user what to build next, then run `codeyam editor 1` to start the next feature"');
-    console.log(chalk.dim('    There must ALWAYS be an active task. Never leave the task list empty.'));
-    console.log(chalk.dim('    This task reminds you to use the editor workflow for the next feature.'));
+    console.log(chalk.dim('    Task management is handled by the ━━━ TASK ━━━ directive below.'));
     console.log();
     console.log(chalk.bold.yellow('IMPORTANT: After this step, the current feature is DONE.'));
     console.log(chalk.yellow('  Any new user request — even if it sounds related — is a NEW feature.'));
     console.log(chalk.yellow('  Do NOT use `codeyam editor change` or start building directly.'));
-    console.log(chalk.yellow('  The next feature MUST start with `codeyam editor 1`.'));
+    console.log(chalk.yellow('  Ask the user what they want to build. Once they tell you, run `codeyam editor 1` yourself.'));
+    console.log(chalk.yellow('  NEVER tell the user to run `codeyam editor` commands — these are internal. Just ask what to build.'));
     console.log(chalk.yellow('  The change workflow is ONLY for modifications during steps 1-15, not after commit.'));
     stopGate(18, { confirm: true });
 }
@@ -2337,25 +2401,132 @@ async function handleAnalyzeImports(options = {}) {
         // Non-fatal — scenario file paths just won't be included
     }
     const progress = new ProgressReporter();
-    // Run data-structure-only analysis for all entities (glossary + pages)
+    // Filter to only files that actually need analysis — avoids re-analyzing
+    // ~120 files when only 2 are incomplete.
+    let targetFilePaths = filePaths;
+    try {
+        const { getDatabase } = await import('../../../packages/database/index.js');
+        const db = getDatabase();
+        const { requireBranchAndProject: rbp } = await import('../utils/database.js');
+        const { project } = await rbp(JSON.parse(fs.readFileSync(path.join(root, '.codeyam', 'config.json'), 'utf8')).projectSlug);
+        const { filterToIncompleteFilePaths } = await import('../utils/editorAudit.js');
+        const incomplete = await filterToIncompleteFilePaths(db, project.id, filePaths);
+        if (incomplete.length < filePaths.length && incomplete.length > 0) {
+            if (!options.silent) {
+                console.log(chalk.dim(`Skipping ${filePaths.length - incomplete.length} already-analyzed files, analyzing ${incomplete.length} remaining...`));
+            }
+            targetFilePaths = incomplete;
+        }
+        else if (incomplete.length === 0) {
+            if (!options.silent) {
+                console.log(chalk.green('All entities already have analyses — nothing to do.'));
+            }
+            // Still need to run the import graph + backfill below
+            targetFilePaths = [];
+        }
+    }
+    catch {
+        // Non-fatal — fall back to analyzing all files
+    }
+    // Run data-structure-only analysis for entities that need it.
     // 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,
-        });
+    if (targetFilePaths.length > 0) {
+        progress.start(`Running import analysis for ${targetFilePaths.length} entit${targetFilePaths.length !== 1 ? 'ies' : 'y'}...`);
+        try {
+            await runAnalysisForEntities({
+                projectRoot: root,
+                filePaths: targetFilePaths,
+                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');
     }
-    catch (err) {
-        progress.fail('Analysis failed');
-        const msg = err instanceof Error ? err.message : String(err);
-        console.error(chalk.red(`Error: ${msg}`));
-        process.exit(1);
+    // Surface analysis errors if any occurred
+    const errorReportPath = path.join(root, '.codeyam', 'analysis-errors.txt');
+    if (fs.existsSync(errorReportPath)) {
+        if (!options.silent) {
+            console.log(chalk.yellow('\nSome entity analyses failed. Full details in .codeyam/analysis-errors.txt'));
+            console.log(chalk.yellow('Send this file to the CodeYam team for diagnosis.'));
+            console.log(chalk.dim('Affected entities will be missing from the import graph.'));
+        }
+        // Write structured analysis-failures.json for the audit to detect.
+        // Parse the error report to find which entities failed, and cross-reference
+        // with the files we tried to analyze.
+        try {
+            const { readAnalysisFailures, writeAnalysisFailures } = await import('../utils/manualEntityAnalysis.js');
+            const errorContent = fs.readFileSync(errorReportPath, 'utf8');
+            const existingFailures = readAnalysisFailures(root);
+            // Parse error messages to identify failed file paths.
+            // Error format: "Error on step <StepName> for entity <Name> (<filePath>)"
+            // or more generic "CodeYam Error: <message>"
+            const entityErrorRegex = /(?:Error on step \w+ for entity (\w+))|(?:entity[: ]+["']?(\w+)["']?)/gi;
+            const failedEntityNames = new Set();
+            let match;
+            while ((match = entityErrorRegex.exec(errorContent)) !== null) {
+                const name = match[1] || match[2];
+                if (name)
+                    failedEntityNames.add(name);
+            }
+            // Map failed entity names back to file paths from targetFilePaths
+            const glossaryPath = path.join(root, '.codeyam', 'glossary.json');
+            let glossary = [];
+            try {
+                glossary = sanitizeGlossaryEntries(JSON.parse(fs.readFileSync(glossaryPath, 'utf8')));
+            }
+            catch {
+                // Non-fatal
+            }
+            // Also: any targetFilePaths that didn't produce entities are failures
+            const now = new Date().toISOString();
+            const updatedFailures = { ...existingFailures };
+            if (failedEntityNames.size > 0) {
+                for (const name of failedEntityNames) {
+                    const entry = glossary.find((e) => e.name === name);
+                    if (entry) {
+                        updatedFailures[entry.filePath] = {
+                            entityName: name,
+                            error: `Automated analysis failed — see .codeyam/analysis-errors.txt`,
+                            failedAt: now,
+                        };
+                    }
+                }
+            }
+            else if (targetFilePaths.length > 0) {
+                // Couldn't parse specific entity names — mark all target files
+                // that we attempted to analyze as potentially failed
+                for (const fp of targetFilePaths) {
+                    const entry = glossary.find((e) => e.filePath === fp);
+                    updatedFailures[fp] = {
+                        entityName: entry?.name || path.basename(fp, path.extname(fp)),
+                        error: `Automated analysis failed — see .codeyam/analysis-errors.txt`,
+                        failedAt: now,
+                    };
+                }
+            }
+            writeAnalysisFailures(root, updatedFailures);
+        }
+        catch {
+            // Non-fatal — failure tracking is best-effort
+        }
+    }
+    else {
+        // No errors — clear any stale failure tracking
+        try {
+            const { writeAnalysisFailures } = await import('../utils/manualEntityAnalysis.js');
+            writeAnalysisFailures(root, {});
+        }
+        catch {
+            // Non-fatal
+        }
     }
-    progress.succeed('Analysis complete');
     // Load entities WITH metadata from database
     progress.start('Loading entity metadata...');
     await initializeEnvironment();
@@ -2705,11 +2876,15 @@ async function handleRegister(jsonArg) {
     }
     // Normalize to array for uniform handling
     const items = Array.isArray(parsed.body) ? parsed.body : [parsed.body];
+    const root = getProjectRoot();
     const port = getServerPort();
     const url = `http://localhost:${port}/api/editor-register-scenario`;
     const isBatch = items.length > 1;
     let succeeded = 0;
     let failed = 0;
+    let warnings = 0;
+    const issues = [];
+    const screenshotEntries = [];
     for (let i = 0; i < items.length; i++) {
         const body = items[i];
         const prefix = isBatch ? chalk.dim(`[${i + 1}/${items.length}] `) : '';
@@ -2737,6 +2912,12 @@ async function handleRegister(jsonArg) {
             else {
                 parts.push(`errors=0`);
             }
+            if (data.visibleText) {
+                const truncated = data.visibleText.length > 100
+                    ? data.visibleText.substring(0, 97) + '...'
+                    : data.visibleText;
+                parts.push(`visibleText="${truncated}"`);
+            }
             if (data.seedResult) {
                 if (data.seedResult.success) {
                     parts.push(`seed=ok`);
@@ -2772,12 +2953,29 @@ async function handleRegister(jsonArg) {
                 }
                 console.log(chalk.yellow('  Fix the issue and re-register this scenario.'));
             }
+            const resultIssues = classifyRegistrationResult(res.ok, res.status, data, String(body.name || `item ${i + 1}`));
             if (!res.ok) {
                 console.error(chalk.dim(JSON.stringify(data, null, 2)));
                 failed++;
             }
             else {
+                if (resultIssues.length > 0)
+                    warnings++;
                 succeeded++;
+                // Collect screenshot paths for duplicate detection
+                if (data.screenshotCaptured &&
+                    data.scenario?.screenshotPath &&
+                    data.scenario?.name) {
+                    const absPath = path.join(root, '.codeyam', 'editor-scenarios', data.scenario.screenshotPath);
+                    screenshotEntries.push({
+                        scenarioName: data.scenario.name,
+                        screenshotAbsPath: absPath,
+                    });
+                }
+            }
+            // Collect issues from this registration
+            for (const issue of resultIssues) {
+                issues.push(`"${issue.scenarioName}": ${issue.message}`);
             }
         }
         catch (error) {
@@ -2788,10 +2986,50 @@ async function handleRegister(jsonArg) {
             failed++;
         }
     }
+    // Detect duplicate screenshots in the batch
+    if (isBatch && screenshotEntries.length > 1) {
+        const { computeScreenshotHash, findDuplicateScreenshots } = await import('../utils/screenshotHash.js');
+        const hashEntries = screenshotEntries
+            .map((e) => {
+            const hash = computeScreenshotHash(e.screenshotAbsPath);
+            return hash
+                ? {
+                    scenarioName: e.scenarioName,
+                    screenshotPath: e.screenshotAbsPath,
+                    hash,
+                }
+                : null;
+        })
+            .filter((e) => e !== null);
+        const duplicates = findDuplicateScreenshots(hashEntries);
+        if (duplicates.size > 0) {
+            console.log('');
+            console.log(chalk.yellow.bold('WARNING: Identical screenshots detected:'));
+            for (const [, names] of duplicates) {
+                const quoted = names.map((n) => `"${n}"`);
+                console.log(chalk.yellow(`  ${quoted.join(' and ')} produced the same screenshot`));
+            }
+            console.log(chalk.yellow("  This usually means the app's view state depends on something scenarios can't control"));
+            console.log(chalk.yellow('  (e.g., a hardcoded function return value, or identical localStorage not differentiating views).'));
+        }
+    }
     if (isBatch) {
-        console.log(chalk.dim(`\nBatch complete: ${succeeded}/${items.length} succeeded`));
+        console.log('');
+        if (failed > 0 || warnings > 0) {
+            console.log(chalk.red.bold(`ERROR: ${failed} failed, ${warnings} with warnings out of ${items.length} scenarios`));
+            console.log('');
+            console.log(chalk.red.bold('Issues that MUST be fixed:'));
+            for (const issue of issues) {
+                console.log(chalk.red(`  ✗ ${issue}`));
+            }
+            console.log('');
+            console.log(chalk.red('Do NOT skip these errors. Fix each issue and re-register the affected scenarios.'));
+        }
+        else {
+            console.log(chalk.green(`✓ Batch complete: ${succeeded}/${items.length} succeeded with no issues`));
+        }
     }
-    if (failed > 0) {
+    if (failed > 0 || warnings > 0) {
         process.exit(1);
     }
 }
@@ -3003,6 +3241,8 @@ function handleChange(feature) {
     console.log(chalk.cyan(`  codeyam editor preview '{"dimension":"${dim}"}'`));
     printDimensionGuidance(dim, dimNames);
     console.log(chalk.cyan('  The user is watching the preview. Let them see progress incrementally.'));
+    console.log(chalk.red.bold('  NEVER claim "you should see X" or "the preview shows X" unless you just ran a preview command.'));
+    console.log(chalk.red('  The preview only updates when you explicitly refresh it. Verify, then describe.'));
     console.log();
     console.log(chalk.bold('0. Close the results panel:'));
     checkbox(`Hide results: \`codeyam editor hide-results\``);
@@ -3078,10 +3318,11 @@ function handleChange(feature) {
  * Fetch the audit result from the server.
  * Returns null if the server is unreachable.
  */
-async function fetchAuditResult() {
+async function fetchAuditResult(options) {
     const port = getServerPort();
+    const params = options?.skipTests ? '?skipTests=true' : '';
     try {
-        const res = await fetch(`http://localhost:${port}/api/editor-audit`);
+        const res = await fetch(`http://localhost:${port}/api/editor-audit${params}`);
         if (!res.ok)
             return null;
         return await res.json();
@@ -3104,17 +3345,34 @@ async function checkAuditGate() {
         return true; // Server unreachable — don't block
     if (data.summary?.allPassing === true)
         return true;
-    // If incomplete entities are the only issue, auto-fix with analyze-imports (once)
-    const { isAutoRemediable } = await import('../utils/editorAudit.js');
-    if (isAutoRemediable(data.summary, false)) {
+    // Lightweight auto-fix: backfill entity_sha (DB-only, fast).
+    // Never run handleAnalyzeImports here — it takes minutes on large projects.
+    const { isOnlyIncompleteEntities, isOnlyPreExistingIncomplete } = await import('../utils/editorAudit.js');
+    // If the only failures are pre-existing incomplete entities (not caused by
+    // this session), don't block — the audit text already calls these "non-blocking".
+    if (isOnlyPreExistingIncomplete(data.summary, data.incompleteEntities)) {
+        return true;
+    }
+    if (isOnlyIncompleteEntities(data.summary)) {
         try {
-            await handleAnalyzeImports({ silent: true });
+            const entities = await loadEntities({});
+            if (entities && entities.length > 0) {
+                const { getDatabase } = await import('../../../packages/database/index.js');
+                const db = getDatabase();
+                await backfillEntityShaOnScenarios(db, entities.map((e) => ({
+                    sha: e.sha,
+                    name: e.name,
+                    filePath: e.filePath || '',
+                    isDefaultExport: e.metadata?.notExported === false &&
+                        e.metadata?.namedExport === false,
+                })));
+            }
         }
         catch {
-            return false;
+            // Fall through
         }
-        // Re-check after fix
-        const retry = await fetchAuditResult();
+        // Re-check after backfill — skip re-running tests (backfill is DB-only)
+        const retry = await fetchAuditResult({ skipTests: true });
         if (retry?.summary?.allPassing === true)
             return true;
     }
@@ -3137,6 +3395,8 @@ function printAuditGateFailures(data) {
         const missing = (data.components || []).filter((c) => c.status === 'missing');
         for (const c of missing) {
             issues.push(`    → ${c.name}${c.filePath ? ` (${c.filePath})` : ''}`);
+            if (c.hint)
+                issues.push(`      Fix: ${c.hint}`);
         }
     }
     if (s.componentsWithErrors > 0) {
@@ -3150,7 +3410,15 @@ function printAuditGateFailures(data) {
         issues.push(`${s.functionsMissing} function(s) missing test files`);
         const missing = (data.functions || []).filter((f) => f.status === 'missing');
         for (const f of missing) {
-            issues.push(`    → ${f.name}${f.filePath ? ` (${f.filePath})` : ''}`);
+            if (f.testFile) {
+                issues.push(`    → ${f.name} — test file missing: ${f.testFile}`);
+            }
+            else {
+                issues.push(`    → ${f.name} (${f.filePath}) — no testFile in glossary`);
+                if (f.suggestedTestFile) {
+                    issues.push(`      Fix: Create ${f.suggestedTestFile} or add "testFile": "${f.suggestedTestFile}" to .codeyam/glossary.json`);
+                }
+            }
         }
     }
     if (s.functionsFailing > 0) {
@@ -3165,6 +3433,10 @@ function printAuditGateFailures(data) {
         const runnerErrors = (data.functions || []).filter((f) => f.status === 'runner_error');
         for (const f of runnerErrors) {
             issues.push(`    → ${f.name}${f.testFile ? ` (${f.testFile})` : ''}`);
+            if (f.hint)
+                issues.push(`      ${f.hint}`);
+            else if (f.errorMessage)
+                issues.push(`      Error: ${f.errorMessage}`);
         }
     }
     if (s.functionsNameMismatch > 0) {
@@ -3172,13 +3444,36 @@ function printAuditGateFailures(data) {
         const mismatch = (data.functions || []).filter((f) => f.status === 'name_mismatch');
         for (const f of mismatch) {
             issues.push(`    → ${f.name}${f.testFile ? ` (${f.testFile})` : ''}`);
+            if (f.hint)
+                issues.push(`      Fix: ${f.hint}`);
         }
     }
-    if (s.missingFromGlossary > 0)
+    if (s.missingFromGlossary > 0) {
         issues.push(`${s.missingFromGlossary} file(s) with scenarios not in glossary`);
+        const missingGlossary = data.missingFromGlossary || [];
+        for (const m of missingGlossary) {
+            issues.push(`    → ${m.name} (${m.filePath})`);
+        }
+        issues.push(`      Fix: Run \`codeyam editor analyze-imports\` to add these files to the glossary`);
+    }
     if (s.incompleteEntities > 0) {
+        // Check for persistent analysis failures
+        let analysisFailures = {};
+        try {
+            const failuresPath = path.join(getProjectRoot(), '.codeyam', 'analysis-failures.json');
+            if (fs.existsSync(failuresPath)) {
+                analysisFailures = JSON.parse(fs.readFileSync(failuresPath, 'utf8'));
+            }
+        }
+        catch {
+            // Non-fatal
+        }
         const preCount = s.preExistingIncompleteEntities || 0;
-        if (preCount > 0 && preCount === s.incompleteEntities) {
+        const hasFailures = Object.keys(analysisFailures).length > 0;
+        if (hasFailures) {
+            issues.push(`${s.incompleteEntities} entity/entities — automated analysis failed, manual analysis required`);
+        }
+        else if (preCount > 0 && preCount === s.incompleteEntities) {
             issues.push(`${s.incompleteEntities} entity/entities need import analysis (pre-existing — not caused by your current changes, but must be fixed before proceeding)`);
         }
         else if (preCount > 0) {
@@ -3187,11 +3482,44 @@ function printAuditGateFailures(data) {
         else {
             issues.push(`${s.incompleteEntities} entity/entities need import analysis`);
         }
+        const incomplete = data.incompleteEntities || [];
+        for (const e of incomplete) {
+            const failureEntry = Object.values(analysisFailures).find((f) => f.entityName === e.name);
+            if (failureEntry) {
+                issues.push(`    → ${e.name} — MANUAL ANALYSIS REQUIRED (automated analysis failed)`);
+                issues.push(`      Run \`codeyam editor audit\` for step-by-step manual analysis instructions`);
+            }
+            else {
+                issues.push(`    → ${e.name} (${e.scenarioCount} scenario${e.scenarioCount !== 1 ? 's' : ''})${e.preExisting ? ' [pre-existing]' : ''}`);
+            }
+        }
+        if (!hasFailures) {
+            issues.push(`      Fix: Run \`codeyam editor analyze-imports\` to build import graphs`);
+        }
+    }
+    if (s.unassociatedScenarios > 0) {
+        issues.push(`${s.unassociatedScenarios} component(s) have scenarios with no entity link — run \`codeyam editor analyze-imports\` then re-run audit`);
+        const unassociated = data.unassociatedScenarios || [];
+        for (const u of unassociated) {
+            issues.push(`    → ${u.name} (${u.filePath}) — ${u.scenarioCount} scenario${u.scenarioCount !== 1 ? 's' : ''}`);
+        }
     }
-    if (s.miscategorizedScenarios > 0)
+    if (s.miscategorizedScenarios > 0) {
         issues.push(`${s.miscategorizedScenarios} component(s) using page URLs instead of isolation routes`);
-    if (s.scenariosNeedingRecapture > 0)
+        const miscategorized = data.miscategorizedScenarios || [];
+        for (const m of miscategorized) {
+            issues.push(`    → ${m.componentName} at ${m.url} (${m.scenarioNames.length} scenario${m.scenarioNames.length !== 1 ? 's' : ''})`);
+        }
+        issues.push(`      Fix: Re-register these as app-level scenarios (with pageFilePath, no componentName) or use isolation routes`);
+    }
+    if (s.scenariosNeedingRecapture > 0) {
         issues.push(`${s.scenariosNeedingRecapture} scenario(s) need recapture (dependency tree changed)`);
+        const recapture = data.scenariosNeedingRecapture || [];
+        for (const r of recapture) {
+            issues.push(`    → "${r.scenarioName}" (entity: ${r.entityName}, ${r.status?.status || 'changed'})`);
+        }
+        issues.push(`      Fix: Re-capture affected scenarios to update screenshots after code changes`);
+    }
     if (issues.length > 0) {
         console.error(chalk.yellow('\nAudit failures:'));
         for (const issue of issues) {
@@ -3232,30 +3560,45 @@ async function handleAudit() {
         console.error(chalk.red('Error: Could not reach the CodeYam server. Is it running?'));
         process.exit(1);
     }
-    // Auto-fix incomplete entities — but only once.
-    // If analyze-imports runs and entities are STILL incomplete, report clearly
-    // instead of retrying. The analysis may have errors (e.g., stale entity
-    // references from refactoring) that can't be fixed by re-running.
+    // Lightweight auto-fix: backfill entity_sha on scenarios that were
+    // registered before entity records existed. This is fast (DB-only).
+    // Import analysis is NOT triggered here — it scans all files and takes
+    // minutes on large projects. Users should run it separately if needed.
     const incompleteBeforeFix = data.incompleteEntities || [];
+    const unassociatedBeforeFix = data.unassociatedScenarios || [];
     let autoRemediationFailed = false;
-    if (incompleteBeforeFix.length > 0) {
-        console.log(chalk.dim(`Running import analysis for ${incompleteBeforeFix.length} incomplete entit${incompleteBeforeFix.length !== 1 ? 'ies' : 'y'}...`));
+    if (incompleteBeforeFix.length > 0 || unassociatedBeforeFix.length > 0) {
+        const issueCount = incompleteBeforeFix.length + unassociatedBeforeFix.length;
+        console.log(chalk.dim(`Backfilling ${issueCount} entity association issue${issueCount !== 1 ? 's' : ''}...`));
+        // Backfill entity_sha on scenarios that were registered before entities existed
         try {
-            await handleAnalyzeImports({ silent: true });
+            const entities = await loadEntities({});
+            if (entities && entities.length > 0) {
+                const { getDatabase } = await import('../../../packages/database/index.js');
+                const db = getDatabase();
+                await backfillEntityShaOnScenarios(db, entities.map((e) => ({
+                    sha: e.sha,
+                    name: e.name,
+                    filePath: e.filePath || '',
+                    isDefaultExport: e.metadata?.notExported === false &&
+                        e.metadata?.namedExport === false,
+                })));
+            }
         }
         catch {
-            // Fall through — the audit will still report them as incomplete
+            // Fall through — re-fetch will show remaining issues
         }
-        // Re-fetch audit results after the fix
-        data = await fetchAuditResult();
+        // Re-fetch audit results after the backfill — skip re-running tests
+        // since they haven't changed (backfill is DB-only).
+        data = await fetchAuditResult({ skipTests: true });
         if (!data) {
-            console.error(chalk.red('Error: Could not reach the CodeYam server after analyze-imports.'));
+            console.error(chalk.red('Error: Could not reach the CodeYam server after backfill.'));
             process.exit(1);
         }
-        // If entities are still incomplete after running analyze-imports,
-        // flag it so we can show a clear message instead of looping
+        // If issues persist after backfill, flag it so we show clear guidance
         const incompleteAfterFix = data.incompleteEntities || [];
-        if (incompleteAfterFix.length > 0) {
+        const unassociatedAfterFix = data.unassociatedScenarios || [];
+        if (incompleteAfterFix.length > 0 || unassociatedAfterFix.length > 0) {
             autoRemediationFailed = true;
         }
     }
@@ -3289,6 +3632,9 @@ async function handleAudit() {
             }
             else {
                 detail = chalk.red(' — no scenarios registered');
+                if (c.hint) {
+                    detail += `\n      ${chalk.yellow('Fix: ' + c.hint)}`;
+                }
             }
             // Show file path for failing components always, for OK only when name is ambiguous
             const isDuplicate = (componentNameCounts.get(c.name) || 0) > 1;
@@ -3332,9 +3678,16 @@ async function handleAudit() {
                     break;
                 case 'missing':
                 default:
-                    detail = f.testFile
-                        ? chalk.red(` — test file missing: ${f.testFile}`)
-                        : chalk.red(' — no test file specified');
+                    if (f.testFile) {
+                        detail = chalk.red(` — test file missing: ${f.testFile}`);
+                    }
+                    else {
+                        detail = chalk.red(` — no test file specified in glossary`);
+                        detail += chalk.dim(` (source: ${f.filePath})`);
+                        if (f.suggestedTestFile) {
+                            detail += `\n      ${chalk.yellow(`Fix: Either create ${f.suggestedTestFile} or add "testFile": "${f.suggestedTestFile}" to this entry in .codeyam/glossary.json`)}`;
+                        }
+                    }
                     break;
             }
             console.log(`  ${icon} ${f.name}${detail}`);
@@ -3351,23 +3704,68 @@ async function handleAudit() {
         console.log(chalk.yellow('    Add these to .codeyam/glossary.json and run `codeyam editor analyze-imports`'));
         console.log();
     }
-    // Incomplete entities (scenarios without analyses)
+    // Incomplete entities (scenarios without analyses) — report with guidance.
+    // We intentionally do NOT run analysis here: it starts the analyzer
+    // template which is slow even for a few files. Users should run
+    // `codeyam editor analyze-imports` separately if needed.
     const incompleteEntities = data.incompleteEntities || [];
     if (incompleteEntities.length > 0) {
+        const { formatIncompleteEntityGuidance, formatManualAnalysisGuidance } = await import('../utils/editorAudit.js');
+        const { readAnalysisFailures } = await import('../utils/manualEntityAnalysis.js');
+        // Check for persistent analysis failures
+        const analysisFailures = readAnalysisFailures(getProjectRoot());
         console.log(chalk.bold('Incomplete entities (need import analysis):'));
         for (const e of incompleteEntities) {
-            console.log(`  ${chalk.red('✗')} ${e.name} — ${e.scenarioCount} scenario${e.scenarioCount !== 1 ? 's' : ''} but entity not analyzed`);
+            // Check if this entity has a persistent failure
+            const failureEntry = Object.values(analysisFailures).find((f) => f.entityName === e.name);
+            if (failureEntry) {
+                // Show manual analysis instructions instead of "run analyze-imports"
+                const filePath = Object.entries(analysisFailures).find(([, f]) => f.entityName === e.name)?.[0];
+                const guidance = formatManualAnalysisGuidance({
+                    name: e.name,
+                    filePath: filePath || '',
+                    scenarioCount: e.scenarioCount,
+                    error: failureEntry.error,
+                });
+                // Print each line with proper indentation
+                for (const line of guidance.split('\n')) {
+                    console.log(`  ${chalk.red('✗')} ${line}`);
+                }
+            }
+            else {
+                const guidance = formatIncompleteEntityGuidance(e);
+                console.log(`  ${chalk.red('✗')} ${guidance}`);
+            }
+        }
+        const incompleteErrorReportPath = path.join(getProjectRoot(), '.codeyam', 'analysis-errors.txt');
+        if (fs.existsSync(incompleteErrorReportPath)) {
+            console.log(chalk.dim('    See .codeyam/analysis-errors.txt for error details.'));
+        }
+        console.log();
+    }
+    // Unassociated scenarios (NULL entity_sha with file paths)
+    const unassociatedScenarios = data.unassociatedScenarios || [];
+    if (unassociatedScenarios.length > 0) {
+        console.log(chalk.bold('Unassociated scenarios (missing entity link):'));
+        for (const u of unassociatedScenarios) {
+            console.log(`  ${chalk.red('✗')} ${u.name} ${chalk.dim(`(${u.filePath})`)} — ${u.scenarioCount} scenario${u.scenarioCount !== 1 ? 's' : ''} with no entity_sha`);
+            for (const sn of u.scenarioNames.slice(0, 3)) {
+                console.log(chalk.dim(`      "${sn}"`));
+            }
+            if (u.scenarioNames.length > 3) {
+                console.log(chalk.dim(`      … and ${u.scenarioNames.length - 3} more`));
+            }
         }
         if (autoRemediationFailed) {
-            console.log(chalk.red('    analyze-imports was run automatically but these entities are STILL incomplete.'));
-            console.log(chalk.red('    DO NOT re-run analyze-imports or the audit in a loop — the result will be the same.'));
-            console.log(chalk.yellow('    This means the analysis failed for these entities. Common causes:'));
-            console.log(chalk.yellow('      • Source file was renamed/deleted but glossary still references the old path'));
-            console.log(chalk.yellow('      • Entity has import errors that prevent analysis'));
-            console.log(chalk.yellow('    To investigate: run `codeyam editor analyze-imports` (without --silent) to see the full error.'));
+            console.log(chalk.yellow('    analyze-imports ran automatically but could not resolve these.'));
+            console.log(chalk.yellow('    Run `codeyam editor analyze-imports` to see the full error output.'));
         }
         else {
-            console.log(chalk.yellow('    Run `codeyam editor analyze-imports` to analyze these entities'));
+            console.log(chalk.yellow('    Run `codeyam editor analyze-imports` to create entity records, then re-run audit to backfill.'));
+        }
+        const unassocErrorReportPath = path.join(getProjectRoot(), '.codeyam', 'analysis-errors.txt');
+        if (fs.existsSync(unassocErrorReportPath)) {
+            console.log(chalk.dim('    See .codeyam/analysis-errors.txt for error details.'));
         }
         console.log();
     }
@@ -3444,6 +3842,9 @@ async function handleAudit() {
         if (summary.incompleteEntities > 0) {
             parts.push(`${summary.incompleteEntities} entit${summary.incompleteEntities !== 1 ? 'ies' : 'y'} need import analysis`);
         }
+        if (summary.unassociatedScenarios > 0) {
+            parts.push(`${summary.unassociatedScenarios} component${summary.unassociatedScenarios !== 1 ? 's' : ''} with scenarios missing entity link`);
+        }
         if (summary.miscategorizedScenarios > 0) {
             parts.push(`${summary.miscategorizedScenarios} component${summary.miscategorizedScenarios !== 1 ? 's' : ''} using page URLs instead of isolation routes`);
         }
@@ -3456,17 +3857,6 @@ async function handleAudit() {
     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.'));
-    }
 }
 // ─── Recapture-stale subcommand ────────────────────────────────────────
 /**
@@ -3673,14 +4063,14 @@ async function handleScenarioCoverage() {
     // Safety net: heal any scenarios with null entity_sha before checking coverage
     try {
         const { getDatabase } = await import('../../../packages/database/index.js');
-        const { countScenariosNeedingEntityBackfill } = await import('../utils/editorScenarios');
+        const { countScenariosNeedingEntityBackfill } = await import('../utils/editorScenarios.js');
         const db = getDatabase();
         const backfillCount = await countScenariosNeedingEntityBackfill(db);
         if (backfillCount > 0) {
             console.log(chalk.dim(`  Healing ${backfillCount} scenario(s) with unlinked entities...`));
             await handleAnalyzeImports({ silent: true });
             // Run backfill after analysis
-            const { backfillEntityShaOnScenarios } = await import('../utils/editorScenarios');
+            const { backfillEntityShaOnScenarios } = await import('../utils/editorScenarios.js');
             const entities = await loadEntities({});
             if (entities && entities.length > 0) {
                 await backfillEntityShaOnScenarios(db, entities.map((e) => ({
@@ -4177,14 +4567,205 @@ function handleEditorDebug(args) {
     console.log(chalk.dim('  Open index.md for the full list of scenario outputs.'));
     console.log();
 }
+// ─── Manual entity analysis ───────────────────────────────────────────
+/**
+ * `codeyam editor manual-entity <JSON|@file>`
+ *
+ * Creates entity and analysis records from Claude-provided metadata when
+ * automated analyze-imports fails. This unblocks the audit gate without
+ * needing the analyzer template to parse the source file.
+ */
+async function handleManualEntity(jsonArg) {
+    const root = getProjectRoot();
+    // Parse JSON input (supports @file.json convention)
+    const parsed = parseRegisterArg(jsonArg);
+    if (parsed.error || !parsed.body) {
+        console.error(chalk.red(`Error: ${parsed.error || 'Invalid input'}`));
+        console.error(chalk.dim('  Usage: codeyam editor manual-entity \'{"name":"Header","filePath":"src/components/Header.tsx","entityType":"visual",...}\''));
+        console.error(chalk.dim('  Or: codeyam editor manual-entity @.codeyam/tmp/manual-entity.json'));
+        process.exit(1);
+    }
+    const input = parsed.body;
+    // Validate input
+    const { validateManualEntityInput, convertTypeInfoToDataForMocks, readAnalysisFailures, clearFailureForPath, writeAnalysisFailures, } = await import('../utils/manualEntityAnalysis.js');
+    // Read glossary for validation
+    const glossaryPath = path.join(root, '.codeyam', 'glossary.json');
+    let glossaryEntries = [];
+    try {
+        glossaryEntries = sanitizeGlossaryEntries(JSON.parse(fs.readFileSync(glossaryPath, 'utf8')));
+    }
+    catch {
+        // Empty glossary — validation will still check file existence
+    }
+    const errors = validateManualEntityInput(input, glossaryEntries, {
+        fileExists: (p) => fs.existsSync(path.join(root, p)),
+    });
+    if (errors.length > 0) {
+        console.error(chalk.red('Validation errors:'));
+        for (const err of errors) {
+            console.error(chalk.red(`  • ${err}`));
+        }
+        process.exit(1);
+    }
+    // Read source file and compute SHA
+    const sourceContent = fs.readFileSync(path.join(root, input.filePath), 'utf8');
+    const { generateSha } = await import('../../../packages/database/index.js');
+    const entitySha = generateSha(input.filePath, input.name, sourceContent);
+    // Get project and branch
+    await initializeEnvironment();
+    const configPath = path.join(root, '.codeyam', 'config.json');
+    let projectSlug;
+    try {
+        const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+        projectSlug = config.projectSlug;
+    }
+    catch {
+        console.error(chalk.red('Error: .codeyam/config.json not found or invalid.'));
+        process.exit(1);
+    }
+    const { project, branch } = await requireBranchAndProject(projectSlug);
+    const { getDatabase } = await import('../../../packages/database/index.js');
+    const db = getDatabase();
+    // Convert type info to dataForMocks format
+    const dataForMocks = convertTypeInfoToDataForMocks(input.typeInfo);
+    // Create entity record
+    const entityMetadata = {
+        importedExports: (input.importedExports || []).map((ie) => ({
+            name: ie.name,
+            filePath: ie.filePath,
+        })),
+        manuallyAnalyzed: true,
+    };
+    // Check if entity already exists
+    const existingEntity = await db
+        .selectFrom('entities')
+        .select('sha')
+        .where('sha', '=', entitySha)
+        .executeTakeFirst();
+    if (!existingEntity) {
+        await db
+            .insertInto('entities')
+            .values({
+            sha: entitySha,
+            project_id: project.id,
+            name: input.name,
+            entity_type: input.entityType,
+            file_path: input.filePath,
+            metadata: JSON.stringify(entityMetadata),
+        })
+            .onConflict((oc) => oc.column('sha').doNothing())
+            .execute();
+        console.log(chalk.dim(`Created entity record: ${input.name} (${entitySha.slice(0, 8)}...)`));
+    }
+    else {
+        // Update metadata on existing entity
+        await db
+            .updateTable('entities')
+            .set({
+            metadata: JSON.stringify(entityMetadata),
+        })
+            .where('sha', '=', entitySha)
+            .execute();
+        console.log(chalk.dim(`Updated existing entity: ${input.name} (${entitySha.slice(0, 8)}...)`));
+    }
+    // Create entity_branch record
+    await db
+        .insertInto('entity_branches')
+        .values({
+        entity_sha: entitySha,
+        branch_id: branch.id,
+        active: true,
+    })
+        .onConflict((oc) => oc.columns(['entity_sha', 'branch_id']).doUpdateSet({ active: true }))
+        .execute();
+    // Create analysis record
+    const { randomUUID } = await import('crypto');
+    const analysisId = randomUUID();
+    const now = new Date().toISOString();
+    const analysisMetadata = {
+        scenariosDataStructure: {
+            dataForMocks: Object.keys(dataForMocks).length > 0 ? dataForMocks : null,
+        },
+        mergedDataStructure: {
+            dependencySchemas: null,
+        },
+        manuallyAnalyzed: true,
+    };
+    const analysisStatus = {
+        startedAt: now,
+        finishedAt: now,
+        steps: [],
+        errors: [],
+    };
+    // Check if analysis already exists for this entity
+    const existingAnalysis = await db
+        .selectFrom('analyses')
+        .select('id')
+        .where('entity_sha', '=', entitySha)
+        .executeTakeFirst();
+    if (!existingAnalysis) {
+        await db
+            .insertInto('analyses')
+            .values({
+            id: analysisId,
+            project_id: project.id,
+            entity_sha: entitySha,
+            entity_name: input.name,
+            entity_type: input.entityType,
+            file_path: input.filePath,
+            status: JSON.stringify(analysisStatus),
+            metadata: JSON.stringify(analysisMetadata),
+        })
+            .execute();
+        console.log(chalk.dim(`Created analysis record: ${analysisId.slice(0, 8)}...`));
+    }
+    else {
+        // Update existing analysis with manual metadata
+        await db
+            .updateTable('analyses')
+            .set({
+            metadata: JSON.stringify(analysisMetadata),
+            status: JSON.stringify(analysisStatus),
+        })
+            .where('entity_sha', '=', entitySha)
+            .execute();
+        console.log(chalk.dim(`Updated existing analysis for ${input.name}`));
+    }
+    // Backfill entity_sha on scenarios
+    const backfillResult = await backfillEntityShaOnScenarios(db, [
+        {
+            sha: entitySha,
+            name: input.name,
+            filePath: input.filePath,
+            isDefaultExport: false,
+        },
+    ]);
+    if (backfillResult.updated > 0) {
+        console.log(chalk.dim(`Linked ${backfillResult.updated} scenario(s) to entity`));
+    }
+    // Clear from analysis failures tracker
+    const failures = readAnalysisFailures(root);
+    if (failures[input.filePath]) {
+        const updated = clearFailureForPath(failures, input.filePath);
+        writeAnalysisFailures(root, updated);
+        console.log(chalk.dim(`Cleared analysis failure for ${input.filePath}`));
+    }
+    console.log();
+    console.log(chalk.green.bold(`✓ Manual entity analysis complete: ${input.name}`));
+    console.log(chalk.dim(`  Entity SHA: ${entitySha.slice(0, 12)}...`));
+    console.log(chalk.dim(`  Imports: ${(input.importedExports || []).length} glossary entities`));
+    console.log(chalk.dim(`  Type info: ${Object.keys(dataForMocks).length} fields`));
+    console.log();
+    console.log(chalk.dim('Re-run `codeyam editor audit` to verify.'));
+}
 // ─── Command definition ───────────────────────────────────────────────
 const editorCommand = {
     command: 'editor [step] [json]',
     describe: 'Editor mode guided workflow',
     builder: (yargs) => {
         const stepDescription = IS_INTERNAL_BUILD
-            ? 'Step number (1-18) or subcommand (template, register, isolate, analyze-imports, dependents, audit, scenarios, scenario-coverage, recapture-stale, change, sync, debug, preview, show-results, hide-results, commit, journal, journal-list, journal-update, dev-server, client-errors)'
-            : 'Step number (1-18) or subcommand (template, register, isolate, analyze-imports, dependents, audit, scenarios, scenario-coverage, recapture-stale, change, sync, preview, show-results, hide-results, commit, journal, journal-list, journal-update, dev-server, client-errors)';
+            ? 'Step number (1-18) or subcommand (template, register, isolate, analyze-imports, manual-entity, dependents, audit, scenarios, scenario-coverage, recapture-stale, change, sync, debug, preview, show-results, hide-results, commit, journal, journal-list, journal-update, dev-server, client-errors, task-ontrack)'
+            : 'Step number (1-18) or subcommand (template, register, isolate, analyze-imports, manual-entity, dependents, audit, scenarios, scenario-coverage, recapture-stale, change, sync, preview, show-results, hide-results, commit, journal, journal-list, journal-update, dev-server, client-errors, task-ontrack)';
         let builder = yargs
             .positional('step', {
             type: 'string',
@@ -4245,6 +4826,18 @@ const editorCommand = {
         // API subcommands: preview, show-results, hide-results, commit,
         // journal, journal-update, dev-server, client-errors
         if (argv.step && EDITOR_API_SUBCOMMANDS.includes(argv.step)) {
+            // Guard: commit requires step 16 to have been run first.
+            // Without this, Claude shortcuts the process by running
+            // `codeyam editor commit` directly from step 15, skipping
+            // steps 16-18 entirely.
+            if (argv.step === 'commit') {
+                const state = readState(root);
+                if (state && state.step !== 16) {
+                    console.error(chalk.red('Error: Run `codeyam editor 16` before committing.'));
+                    console.error(chalk.dim(`  Current step: ${state.step} (${state.label || 'unknown'}). Step 16 (Commit) must be run first.`));
+                    process.exit(1);
+                }
+            }
             const port = getServerPort();
             try {
                 const request = buildEditorApiRequest(argv.step, argv.json || undefined);
@@ -4288,11 +4881,58 @@ const editorCommand = {
             await handleGlossaryAdd(argv.json || '');
             return;
         }
+        // Subcommand: codeyam editor task-ontrack
+        // Corrective command when Claude advanced without creating a task.
+        if (argv.step === 'task-ontrack') {
+            const state = readState(root);
+            if (!state?.step) {
+                console.error(chalk.red('No editor state found. Run `codeyam editor 1` to start.'));
+                process.exit(1);
+            }
+            const currentLabel = STEP_LABELS[state.step] || `Step ${state.step}`;
+            const totalSteps = Object.keys(STEP_LABELS).length;
+            const nextLabel = state.step < totalSteps ? STEP_LABELS[state.step + 1] : undefined;
+            console.log();
+            console.log(chalk.bold.yellow('━━━ GETTING BACK ON TRACK ━━━'));
+            console.log();
+            console.log(chalk.yellow('You went off-track by not creating a task. Create the task below to continue.'));
+            console.log();
+            // Print the TASK directive for the current step
+            let taskTitle;
+            if (state.step < totalSteps) {
+                taskTitle = `Complete codeyam editor step ${state.step}: '${currentLabel}' and move on to step ${state.step + 1}: '${nextLabel}'`;
+            }
+            else {
+                taskTitle =
+                    'Ask user what to build next and restart codeyam editor workflow';
+            }
+            console.log(chalk.bold.cyan('━━━ TASK ━━━'));
+            console.log(chalk.cyan('Before creating the task below, delete ALL existing tasks:'));
+            console.log(chalk.cyan('  1. Run TaskList to find all tasks'));
+            console.log(chalk.cyan('  2. Run TaskUpdate with status "deleted" for EACH task returned'));
+            console.log(chalk.cyan('Then create a new task with this EXACT title (copy verbatim):'));
+            console.log();
+            console.log(chalk.bold.cyan(`EXACT_TASK_TITLE: ${taskTitle}`));
+            console.log();
+            console.log(chalk.green(`After creating the task, re-run: codeyam editor ${state.step + 1}`));
+            console.log();
+            // Mark task as expected-created so the next step can proceed.
+            // The hook will set taskCreated=true when it sees the actual TaskCreate call.
+            // But we also allow advancement now since task-ontrack itself is the corrective action.
+            const trackingPath = path.join(root, '.codeyam', 'editor-task-tracking.json');
+            fs.writeFileSync(trackingPath, JSON.stringify({ step: state.step, taskCreated: true }, null, 2), 'utf8');
+            return;
+        }
         // Subcommand: codeyam editor analyze-imports
         if (argv.step === 'analyze-imports') {
             await handleAnalyzeImports();
             return;
         }
+        // Subcommand: codeyam editor manual-entity <JSON|@file>
+        if (argv.step === 'manual-entity') {
+            await handleManualEntity(argv.json || '');
+            return;
+        }
         // Subcommand: codeyam editor dependents <EntityName>
         if (argv.step === 'dependents') {
             await handleDependents(argv.json || '');
@@ -4533,13 +5173,24 @@ const editorCommand = {
                     try {
                         const { getDatabase: getDb } = await import('../../../packages/database/index.js');
                         const seedDb = getDb();
-                        const appScenario = await seedDb
+                        // Prefer the home page scenario (url "/") since the App tab
+                        // sorts "Home" first — fall back to any application scenario.
+                        const homeScenario = await seedDb
                             .selectFrom('editor_scenarios')
                             .select(['id', 'name', 'type'])
                             .where('project_id', '=', project.id)
-                            .where('type', '=', 'application')
+                            .where('url', '=', '/')
+                            .where('component_name', 'is', null)
                             .orderBy('created_at', 'asc')
                             .executeTakeFirst();
+                        const appScenario = homeScenario ||
+                            (await seedDb
+                                .selectFrom('editor_scenarios')
+                                .select(['id', 'name', 'type'])
+                                .where('project_id', '=', project.id)
+                                .where('type', '=', 'application')
+                                .orderBy('created_at', 'asc')
+                                .executeTakeFirst());
                         if (appScenario) {
                             const seedFile = path.join(projectRoot, '.codeyam', 'editor-scenarios', `${appScenario.id}.seed.json`);
                             if (fs.existsSync(seedFile)) {
@@ -4682,7 +5333,7 @@ const editorCommand = {
                         if (!needsAnalysis) {
                             try {
                                 const { getDatabase } = await import('../../../packages/database/index.js');
-                                const { countScenariosNeedingEntityBackfill } = await import('../utils/editorScenarios');
+                                const { countScenariosNeedingEntityBackfill } = await import('../utils/editorScenarios.js');
                                 const db = getDatabase();
                                 const backfillCount = await countScenariosNeedingEntityBackfill(db);
                                 if (backfillCount > 0) {
@@ -4721,7 +5372,7 @@ const editorCommand = {
                         .execute();
                     if (unresolved.length > 0) {
                         const { scanPageFilePaths: scanPfp } = await import('../utils/entityChangeStatus.server.js');
-                        const { matchUrlToPageFile } = await import('../utils/routePatternMatching');
+                        const { matchUrlToPageFile } = await import('../utils/routePatternMatching.js');
                         const { allFiles: pfpFiles } = scanPfp(projectRoot);
                         let pfpResolved = 0;
                         for (const row of unresolved) {
@@ -4804,7 +5455,7 @@ const editorCommand = {
         // 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);
+            const stepError = validateStepTransition(step, state?.step ?? null, state?.startedAt, root);
             if (stepError) {
                 console.error(chalk.red(`Error: ${stepError}`));
                 process.exit(1);
@@ -4858,7 +5509,6 @@ const editorCommand = {
                     if (!auditOk) {
                         // checkAuditGate() already printed specific failure details above
                         console.error(chalk.red.bold('BLOCKED: The audit has not passed. Fix the issues listed above before proceeding.'));
-                        console.error(chalk.yellow('DO NOT re-run the audit in a loop — fix the underlying issues first.'));
                         process.exit(1);
                     }
                 }