@12ui/design 0.2.57 → 0.2.59

package/dist/cli-redesign-command.js

@@ -1,13 +1,10 @@
-import { createHash } from 'node:crypto';
 import { mkdir, readFile } from 'node:fs/promises';
 import path from 'node:path';
-import { TwelveUiBranchClient } from './branch-client.js';
-import { executeBranchRun } from './branch-execution.js';
-import { branchAttemptPath, readBranchAttempt } from './branch-run-record.js';
-import { imageWinner } from './branch-winner.js';
-import { booleanFlag, stringFlag } from './cli-arguments.js';
+import { createConcurrencyLimiter } from './bounded-concurrency.js';
+import { booleanFlag, stringFlag, stringFlags } from './cli-arguments.js';
 import { CliRefusal } from './cli-refusal.js';
 import { prepareOutputDirectory } from './cli-output-paths.js';
+import { BRANCH_PAGE_CONCURRENCY_DEFAULT } from './cli-progress.js';
 import { usageRefusal } from './cli-usage.js';
 import { readConceptValue } from './concept-input.js';
 import { readConversionConfig } from './config.js';
@@ -15,14 +12,19 @@ import { isConversionModel } from './conversion-models.js';
 import { runDraftCommand } from './cli-draft-command.js';
 import { DRAFT_CANDIDATE_COUNT, DRAFT_CANDIDATE_COUNT_MAXIMUM, DRAFT_CANDIDATE_COUNT_MINIMUM, } from './draft-run.js';
 import { draftPaths, readDraftRecord } from './draft-workspace.js';
-import { TwelveUiConversionPackageClient } from './package-client.js';
 import { TwelveUiPrototypeLabelClient } from './prototype-label-client.js';
 import { isPrototypeSkippedResult, runPrototypePoststep } from './prototype-poststep.js';
-import { captureRedesignPages, discoverRedesignPageUrls, REDESIGN_DEFAULT_MAX_PAGES, } from './redesign-capture.js';
+import { runRedesignBranchStage } from './redesign-branch-stage.js';
+import { redesignBranchPageDirectory } from './redesign-branch-identity.js';
+import { InvalidRedesignBranchRecordError, verifyRedesignBranchPages, } from './redesign-branch-record-verification.js';
+import { captureRedesignSite, captureRedesignPages, discoverRedesignPageUrls, parseImproveBootstrap, REDESIGN_DEFAULT_MAX_PAGES, } from './redesign-capture.js';
 import { buildRedesignPlan } from './redesign-plan.js';
 import { TwelveUiRedesignPlanClient, } from './redesign-plan-client.js';
 import { redesignPlanIdempotencyKey } from './redesign-plan-identity.js';
-import { createRedesignWorkspace, isRedesignStage, loadOrStartRedesignRecord, redesignPaths, REDESIGN_STAGES, writeRedesignRecord, } from './redesign-workspace.js';
+import { createRedesignWorkspace, InvalidRedesignRecordError, isRedesignStage, loadOrStartRedesignRecord, readRedesignRecord, redesignPaths, REDESIGN_STAGES, writeRedesignRecord, } from './redesign-workspace.js';
+import { draftForPage, pagesNeedingDraft, pagesNeedingPick, recordedDraftPages, recordedPickPages, redesignPageDraftConcept, redesignPageDraftRoute, redesignPrimaryPage, withDraftPages, withPickPages, } from './redesign-page-candidates.js';
+import { InvalidRedesignBranchArtifactError } from './redesign-branch-adoption.js';
+import { InvalidRedesignPageOwnershipError } from './redesign-page-ownership.js';
 /**
  * `12ui redesign <url> --direction <text>`: capture -> plan -> draft -> pick -> branch
  * -> polish, chained through the same library entry points and client
@@ -101,6 +103,30 @@ const readStageRange = (flags) => {
 const runCaptureStage = async (args) => {
     if (args.record.capture)
         return args.record;
+    // Tests that inject a one-page screenshot deliberately exercise record
+    // plumbing without a browser. Production and browser-backed tests discover
+    // from the rendered session, after bootstrap has seated authentication.
+    if (!args.dependencies.capture?.capturePage) {
+        const captured = await captureRedesignSite({
+            url: args.record.url,
+            outDir: args.paths.captureDir,
+            maxPages: args.pageCount,
+            bootstrap: args.bootstrap,
+            ...(args.dependencies.capture ? { dependencies: args.dependencies.capture } : {}),
+        });
+        if (captured.discovery.count < captured.discovery.cap) {
+            const context = captured.discovery.context === 'authenticated'
+                ? 'the authenticated capture context'
+                : 'the rendered public root; pass --bootstrap to seat a session before discovery';
+            args.warn(`Discovered ${captured.discovery.count} page(s), below the --pages cap of ${captured.discovery.cap}, from ${context}.`);
+        }
+        const record = {
+            ...args.record,
+            capture: { pages: captured.pages, discovery: captured.discovery },
+        };
+        await writeRedesignRecord(args.paths.record, record);
+        return record;
+    }
     const urls = await (args.dependencies.discoverPages ?? discoverRedesignPageUrls)({
         url: args.record.url,
         maxPages: args.pageCount,
@@ -115,47 +141,70 @@ const runCaptureStage = async (args) => {
     return record;
 };
 const runDraftStage = async (args) => {
-    if (args.record.draft)
-        return args.record;
     if (!args.record.capture)
         throw new Error('Cannot draft before capture has run');
     if (!args.record.plan)
         throw new Error('Cannot draft before hosted planning has run');
-    const homepage = args.record.capture.pages[0];
-    if (!homepage)
-        throw new Error('Capture recorded no pages to draft from');
-    const draftFlags = {
-        concept: args.record.plan.concept,
-        reference: homepage.path,
-        candidates: String(args.candidateCount),
-        wait: true,
-    };
+    const remaining = pagesNeedingDraft(args.record);
+    if (remaining.length === 0)
+        return args.record;
+    const plan = args.record.plan;
+    const primary = redesignPrimaryPage(args.record.capture.pages);
     const origin = stringFlag(args.flags, 'origin');
-    if (origin)
-        draftFlags.origin = origin;
     const apiKey = stringFlag(args.flags, 'api-key');
-    if (apiKey)
-        draftFlags['api-key'] = apiKey;
-    await mkdir(args.paths.draftDir, { recursive: true });
-    const result = await runDraftCommand(draftFlags, {
-        ...(args.dependencies.readConfig ? { readConfig: args.dependencies.readConfig } : {}),
-        ...(args.dependencies.createCorpusClient
-            ? { createCorpusClient: args.dependencies.createCorpusClient } : {}),
-        ...(args.dependencies.createHostedClient
-            ? { createHostedClient: args.dependencies.createHostedClient } : {}),
-        plannedDraft: {
-            corpusQuery: args.record.plan.corpusQuery,
-            retain: args.record.plan.retain,
-        },
-        workspaceRoot: args.paths.draftDir,
-        write: () => { },
-        ...(args.dependencies.warn ? { warn: args.dependencies.warn } : {}),
-    });
-    const record = {
-        ...args.record,
-        draft: { runDir: result.prepared.runDir, runId: result.prepared.runId },
-    };
-    await writeRedesignRecord(args.paths.record, record);
+    const limiter = createConcurrencyLimiter(BRANCH_PAGE_CONCURRENCY_DEFAULT);
+    const completed = await Promise.all(remaining.map((page) => limiter(async () => {
+        const pageRoute = redesignPageDraftRoute({ page, primary });
+        const draftFlags = {
+            concept: redesignPageDraftConcept({
+                planConcept: plan.concept,
+                page,
+                primary,
+            }),
+            reference: page.path,
+            candidates: String(args.candidateCount),
+            wait: true,
+            quiet: true,
+        };
+        if (origin)
+            draftFlags.origin = origin;
+        if (apiKey)
+            draftFlags['api-key'] = apiKey;
+        const workspaceRoot = path.join(args.paths.draftDir, page.id);
+        await mkdir(workspaceRoot, { recursive: true });
+        const result = await runDraftCommand(draftFlags, {
+            ...(args.dependencies.readConfig ? { readConfig: args.dependencies.readConfig } : {}),
+            ...(args.dependencies.createCorpusClient
+                ? { createCorpusClient: args.dependencies.createCorpusClient } : {}),
+            ...(args.dependencies.createHostedClient
+                ? { createHostedClient: args.dependencies.createHostedClient } : {}),
+            plannedDraft: {
+                corpusQuery: plan.corpusQuery,
+                retain: plan.retain,
+            },
+            workspaceRoot,
+            write: () => { },
+            referenceFromCapture: true,
+            ...(pageRoute ? { pageRoute } : {}),
+            ...(args.record.redrawGeneration ? { redrawGeneration: args.record.redrawGeneration } : {}),
+            ...(args.dependencies.warn ? { warn: args.dependencies.warn } : {}),
+        });
+        return { pageId: page.id, runDir: result.prepared.runDir, runId: result.prepared.runId };
+    })));
+    // Each Draft has already persisted its own paid handle. Fold the completed
+    // pages into redesign.json in capture order so resume and spend attribution
+    // stay deterministic even though independent page draws ran concurrently.
+    let record = args.record;
+    for (const page of completed) {
+        record = {
+            ...record,
+            draft: withDraftPages([
+                ...recordedDraftPages(record),
+                page,
+            ], primary.id),
+        };
+        await writeRedesignRecord(args.paths.record, record);
+    }
     return record;
 };
 const runPlanStage = async (args) => {
@@ -171,7 +220,9 @@ const runPlanStage = async (args) => {
     };
     const client = (args.dependencies.createRedesignPlanClient
         ?? ((config) => new TwelveUiRedesignPlanClient(config)))(args.config);
-    const plan = await client.plan(request, redesignPlanIdempotencyKey(request));
+    const plan = await client.plan(request, redesignPlanIdempotencyKey(request, {
+        ...(args.record.redrawGeneration ? { redrawGeneration: args.record.redrawGeneration } : {}),
+    }));
     const record = {
         ...args.record,
         plan: {
@@ -187,107 +238,109 @@ const runPlanStage = async (args) => {
     return record;
 };
 const runPickStage = async (args) => {
-    if (args.record.pick)
-        return args.record;
+    if (!args.record.capture)
+        throw new Error('Cannot pick before capture has run');
     if (!args.record.draft)
         throw new Error('Cannot pick before draft has run');
+    const remaining = pagesNeedingPick(args.record);
+    if (remaining.length === 0)
+        return args.record;
     const requestedSlot = stringFlag(args.flags, 'slot')?.trim();
-    const slotLetter = requestedSlot || DEFAULT_CANDIDATE_SLOT;
-    if (!requestedSlot) {
-        args.warn(`--slot was not given; defaulting to candidate ${DEFAULT_CANDIDATE_SLOT}.`);
+    const recordedSlots = new Set(recordedPickPages(args.record).map((page) => page.slot));
+    if (recordedSlots.size > 1) {
+        throw new CliRefusal(`Recorded page picks disagree on candidate slot in ${args.paths.runDir}; refusing to add another pick.`, 'redesign_pick_record_invalid');
     }
-    const draftRunPaths = draftPaths(args.record.draft.runDir);
-    const draftRecord = await readDraftRecord(draftRunPaths.draftRecord);
-    if (!draftRecord)
-        throw new Error(`No draft record in ${args.record.draft.runDir}`);
-    const candidate = draftRecord.hosted.candidates.find((entry) => entry.id === slotLetter);
-    if (!candidate) {
-        throw new CliRefusal(`--slot must be one of ${draftRecord.hosted.candidates.map((entry) => entry.id).join(', ')}`, 'redesign_slot_invalid');
+    const recordedSlot = recordedSlots.values().next().value;
+    if (requestedSlot && recordedSlot && requestedSlot !== recordedSlot) {
+        throw new CliRefusal(`--slot ${requestedSlot} does not match the durable candidate ${recordedSlot}`
+            + ` already picked in ${args.paths.runDir}. Reuse ${recordedSlot} or start a new redesign.`, 'redesign_slot_mismatch');
     }
-    const completion = await readFile(draftRunPaths.completion, 'utf8')
-        .then((raw) => JSON.parse(raw))
-        .catch(() => undefined);
-    const materialized = completion?.candidates.find((entry) => entry.slot === candidate.slot);
-    if (!materialized) {
-        throw new CliRefusal(`Draft candidate ${slotLetter} is not materialized in ${args.record.draft.runDir};`
-            + ' run the draft stage again with --from draft --to draft.', 'redesign_pick_not_materialized');
+    const slotLetter = recordedSlot ?? requestedSlot ?? DEFAULT_CANDIDATE_SLOT;
+    if (!requestedSlot && !recordedSlot) {
+        args.warn(`--slot was not given; defaulting to candidate ${DEFAULT_CANDIDATE_SLOT}.`);
     }
-    const record = {
-        ...args.record,
-        pick: { slot: candidate.id, imagePath: materialized.path, sha256: materialized.sha256 },
-    };
-    await writeRedesignRecord(args.paths.record, record);
-    return record;
-};
-const runBranchStage = async (args) => {
-    if (!args.record.capture)
-        throw new Error('Cannot branch before capture has run');
-    if (!args.record.pick)
-        throw new Error('Cannot branch before pick has run');
-    const capture = args.record.capture;
-    const pick = args.record.pick;
-    const alreadyDone = new Map((args.record.branch?.pages ?? []).map((page) => [page.pageId, page]));
-    const remaining = capture.pages.filter((page) => !alreadyDone.has(page.id));
-    if (remaining.length === 0)
-        return args.record;
-    const branchClient = (args.dependencies.createBranchClient
-        ?? args.dependencies.createHostedClient
-        ?? ((value) => new TwelveUiBranchClient(value)))(args.config);
-    const packageClient = (args.dependencies.createPackageClient
-        ?? ((value) => new TwelveUiConversionPackageClient(value)))(args.config);
-    const winner = await imageWinner(pick.imagePath, 'The picked candidate');
-    const pages = [...alreadyDone.values()];
+    const primary = redesignPrimaryPage(args.record.capture.pages);
     let record = args.record;
     for (const page of remaining) {
-        const branchDir = path.join(args.paths.branchDir, page.id);
-        await prepareOutputDirectory(branchDir);
-        const concept = readConceptValue({
-            value: `${args.direction} Rebuild the page at ${page.url}.`,
-            flag: '--direction',
-            trimHint: 'Shorten the direction; each page URL is appended automatically.',
-        });
-        const idempotencyKey = `redesign-branch:v2:${createHash('sha256')
-            .update(`${args.record.createdAt}\u0000${page.id}`)
-            .digest('hex')}`;
-        const resume = Boolean(await readBranchAttempt(branchAttemptPath(branchDir)));
-        const result = await (args.dependencies.executeBranch ?? executeBranchRun)({
-            branchClient,
-            packageClient,
-            inputs: {
-                outDir: branchDir,
-                scope: 'page',
-                concept,
-                idempotencyKey,
-                winner,
-                maxScreens: args.maxScreens,
-                convert: {
-                    output: 'html',
-                    model: args.conversionModel,
+        let draft;
+        try {
+            draft = draftForPage(record, page.id);
+        }
+        catch {
+            throw new CliRefusal(`Captured page ${page.id} has no page-specific draft in ${args.paths.runDir}.`
+                + ' Re-run with --from draft so each remaining page can buy its own candidates.', 'redesign_page_draft_missing');
+        }
+        const draftRunPaths = draftPaths(draft.runDir);
+        const draftRecord = await readDraftRecord(draftRunPaths.draftRecord);
+        if (!draftRecord)
+            throw new Error(`No draft record in ${draft.runDir}`);
+        const candidate = draftRecord.hosted.candidates.find((entry) => entry.id === slotLetter);
+        if (!candidate) {
+            throw new CliRefusal(`--slot must be one of ${draftRecord.hosted.candidates.map((entry) => entry.id).join(', ')}`, 'redesign_slot_invalid');
+        }
+        const completion = await readFile(draftRunPaths.completion, 'utf8')
+            .then((raw) => JSON.parse(raw))
+            .catch(() => undefined);
+        const materialized = completion?.candidates.find((entry) => entry.slot === candidate.slot);
+        if (!materialized) {
+            throw new CliRefusal(`Draft candidate ${slotLetter} is not materialized in ${draft.runDir};`
+                + ' run the draft stage again with --from draft --to draft.', 'redesign_pick_not_materialized');
+        }
+        record = {
+            ...record,
+            pick: withPickPages([
+                ...recordedPickPages(record),
+                {
+                    pageId: page.id,
+                    slot: candidate.id,
+                    imagePath: materialized.path,
+                    sha256: materialized.sha256,
                 },
-            },
-            origin: args.config.origin,
-            resume,
-            pageConcurrency: 1,
-        });
-        const labelClient = (args.dependencies.createPrototypeLabelClient
-            ?? ((value) => new TwelveUiPrototypeLabelClient(value)))(args.config);
-        await (args.dependencies.runPrototype ?? runPrototypePoststep)({ branchDir, labelClient });
-        pages.push({
-            pageId: page.id,
-            branchDir,
-            status: result.completion.status,
-            completionPath: result.completionPath,
-        });
-        record = { ...record, branch: { pages: [...pages] } };
+            ], primary.id),
+        };
         await writeRedesignRecord(args.paths.record, record);
-        if (result.failure)
-            throw result.failure;
     }
     return record;
 };
 const runPolishStage = async (args) => {
     if (!args.record.branch)
         throw new Error('Cannot polish before branch has run');
+    if (!args.record.capture)
+        throw new Error('Cannot polish before capture has run');
+    let verified;
+    try {
+        verified = await verifyRedesignBranchPages({
+            record: args.record,
+            pages: args.record.capture.pages,
+            branchDirectory: (page) => redesignBranchPageDirectory({
+                paths: args.paths,
+                record: args.record,
+                pageId: page.id,
+            }),
+            branchConcept: (page) => readConceptValue({
+                value: `${args.record.direction} Rebuild the page at ${page.url}.`,
+                flag: '--direction',
+                trimHint: 'Shorten the direction; each page URL is appended automatically.',
+            }),
+        });
+    }
+    catch (error) {
+        if (error instanceof InvalidRedesignPageOwnershipError) {
+            throw new CliRefusal(`${error.message} Refusing polish.`, 'redesign_page_ownership_invalid', { cause: error });
+        }
+        if (error instanceof InvalidRedesignBranchArtifactError
+            || error instanceof InvalidRedesignBranchRecordError) {
+            throw new CliRefusal(`${error.message} Refusing polish.`, 'redesign_branch_artifact_invalid', { cause: error });
+        }
+        throw error;
+    }
+    const missing = verified.find((entry) => !entry.recorded);
+    if (missing) {
+        throw new CliRefusal(`Captured page ${missing.input.page.id} has no validated parent branch record; refusing polish.`, 'redesign_branch_missing');
+    }
+    const failure = verified.find((entry) => entry.adopted?.failure)?.adopted?.failure;
+    if (failure)
+        throw failure;
     const alreadyDone = new Map((args.record.polish?.pages ?? []).map((page) => [page.pageId, page]));
     const remaining = args.record.branch.pages.filter((page) => !alreadyDone.has(page.pageId));
     if (remaining.length === 0)
@@ -331,28 +384,31 @@ export const runRedesignCommand = async (command, flags, dependencies = {}) => {
         }
     })();
     const directionValue = stringFlag(flags, 'direction');
-    if (!directionValue?.trim()) {
-        throw usageRefusal({
-            reason: 'A redesign needs a visual direction in words, and --direction was not given.',
-            code: 'redesign_usage',
-            verb: ['redesign'],
-        });
-    }
-    const direction = readConceptValue({
-        value: directionValue,
-        flag: '--direction',
-        trimHint: 'Keep the visual direction: mood, layout emphasis, and what should change.',
-    });
-    const pageCount = readPages(flags);
-    const candidateCount = readCandidateCount(flags);
-    const maxScreens = readMaxScreens(flags);
-    const conversionModel = readConversionModel(flags);
-    const { from, to } = readStageRange(flags);
+    const requestedDirection = directionValue?.trim()
+        ? readConceptValue({
+            value: directionValue,
+            flag: '--direction',
+            trimHint: 'Keep the visual direction: mood, layout emphasis, and what should change.',
+        })
+        : undefined;
+    const bootstrap = stringFlags(flags, 'bootstrap').map(parseImproveBootstrap);
+    let { from, to } = readStageRange(flags);
     const write = dependencies.write ?? ((line) => { process.stdout.write(`${line}\n`); });
     const warn = dependencies.warn ?? ((line) => { process.stderr.write(`${line}\n`); });
     if (booleanFlag(flags, 'dry-run')) {
+        if (!requestedDirection) {
+            throw usageRefusal({
+                reason: 'A redesign needs a visual direction in words, and --direction was not given.',
+                code: 'redesign_usage',
+                verb: ['redesign'],
+            });
+        }
+        const pageCount = readPages(flags);
+        const candidateCount = readCandidateCount(flags);
+        const maxScreens = readMaxScreens(flags);
+        const conversionModel = readConversionModel(flags);
         const plan = buildRedesignPlan({
-            url, direction, pageCount, candidateCount, maxScreens, conversionModel,
+            url, direction: requestedDirection, pageCount, candidateCount, maxScreens, conversionModel,
         });
         console.log(JSON.stringify({
             dryRun: true,
@@ -366,7 +422,7 @@ export const runRedesignCommand = async (command, flags, dependencies = {}) => {
             createdAt: new Date().toISOString(),
             runDir: '',
             url,
-            direction,
+            direction: requestedDirection,
             requestedPages: pageCount,
             requestedMaxScreens: maxScreens,
             requestedConversionModel: conversionModel,
@@ -391,14 +447,66 @@ export const runRedesignCommand = async (command, flags, dependencies = {}) => {
     write(paths.runDir);
     dependencies.onRunDirectory?.(paths.runDir);
     dependencies.journal?.note({ workspace: paths.runDir });
-    let record = await loadOrStartRedesignRecord({
+    const existing = await readRedesignRecord(paths.record).catch((error) => {
+        if (error instanceof InvalidRedesignRecordError) {
+            throw new CliRefusal(`${error.message} Refusing to resume or start paid work in this directory.`, 'redesign_record_invalid', { cause: error });
+        }
+        throw error;
+    });
+    if (!existing && !requestedDirection) {
+        throw usageRefusal({
+            reason: 'A redesign needs a visual direction in words, and --direction was not given.',
+            code: 'redesign_usage',
+            verb: ['redesign'],
+        });
+    }
+    const redraw = booleanFlag(flags, 'redraw');
+    const reusingRecord = Boolean(existing) && !redraw;
+    const direction = requestedDirection ?? existing.direction;
+    // A resume is a replay of the durable invocation, not a chance for a
+    // caller's current defaults (or incidental copied flags) to drift a later
+    // stage. `--redraw` is the explicit boundary that accepts replacement.
+    const pageCount = reusingRecord ? existing.requestedPages : readPages(flags);
+    const candidateCount = reusingRecord
+        ? existing.requestedCandidateCount ?? DRAFT_CANDIDATE_COUNT
+        : readCandidateCount(flags);
+    const maxScreens = reusingRecord
+        ? existing.requestedMaxScreens ?? REDESIGN_MAX_SCREENS_MAXIMUM
+        : readMaxScreens(flags);
+    const conversionModel = reusingRecord
+        ? existing.requestedConversionModel ?? 'standard'
+        : readConversionModel(flags);
+    if (existing && requestedDirection && requestedDirection !== existing.direction
+        && !redraw) {
+        throw new CliRefusal('--direction does not match the durable redesign record. Drop --direction to reuse'
+            + ' the recorded direction, or pass --redraw to replace the dependent plan and draft.', 'redesign_record_mismatch');
+    }
+    let record = existing ?? await loadOrStartRedesignRecord({
         paths,
         url,
         direction,
         requestedPages: pageCount,
+        requestedCandidateCount: candidateCount,
         requestedMaxScreens: maxScreens,
         requestedConversionModel: conversionModel,
     });
+    if (existing && redraw) {
+        const { plan: _plan, draft: _draft, pick: _pick, branch: _branch, polish: _polish, ...retained } = existing;
+        record = {
+            ...retained,
+            direction,
+            redrawGeneration: (existing.redrawGeneration ?? 0) + 1,
+            requestedPages: pageCount,
+            requestedCandidateCount: candidateCount,
+            requestedMaxScreens: maxScreens,
+            requestedConversionModel: conversionModel,
+        };
+        // A redraw invalidates every dependent paid identity even when its words
+        // are unchanged. Capture remains frozen; generation names the fresh plan,
+        // draft, child directory, and branch idempotency namespace.
+        from = record.capture ? 'plan' : 'capture';
+        await writeRedesignRecord(paths.record, record);
+    }
     const config = (dependencies.readConfig ?? readConversionConfig)({
         origin: stringFlag(flags, 'origin'),
         apiKey: stringFlag(flags, 'api-key'),
@@ -408,7 +516,7 @@ export const runRedesignCommand = async (command, flags, dependencies = {}) => {
     const needed = (stage) => stageIndex(stage) <= stageIndex(to);
     if (needed('capture')) {
         if (withinRange('capture')) {
-            record = await runCaptureStage({ record, paths, pageCount, dependencies });
+            record = await runCaptureStage({ record, paths, pageCount, bootstrap, dependencies, warn });
         }
         if (!record.capture) {
             throw new CliRefusal(`Stage capture has not run in ${paths.runDir}. Run this command with --to capture first,`
@@ -427,21 +535,25 @@ export const runRedesignCommand = async (command, flags, dependencies = {}) => {
         if (withinRange('draft')) {
             record = await runDraftStage({ record, paths, candidateCount, flags, dependencies });
         }
-        if (!record.draft) {
-            throw new CliRefusal(`Stage draft has not run in ${paths.runDir}.`, 'redesign_draft_missing');
+        if (!record.draft || pagesNeedingDraft(record).length > 0) {
+            throw new CliRefusal(pagesNeedingDraft(record).length > 0
+                ? `Stage draft has not produced a page-specific candidate for ${pagesNeedingDraft(record).map((page) => page.id).join(', ')} in ${paths.runDir}. Re-run with --from draft.`
+                : `Stage draft has not run in ${paths.runDir}.`, 'redesign_draft_missing');
         }
     }
     if (needed('pick')) {
         if (withinRange('pick')) {
             record = await runPickStage({ record, paths, flags, warn });
         }
-        if (!record.pick) {
-            throw new CliRefusal(`Stage pick has not run in ${paths.runDir}.`, 'redesign_pick_missing');
+        if (!record.pick || pagesNeedingPick(record).length > 0) {
+            throw new CliRefusal(pagesNeedingPick(record).length > 0
+                ? `Stage pick has not materialized a page-specific candidate for ${pagesNeedingPick(record).map((page) => page.id).join(', ')} in ${paths.runDir}. Re-run with --from draft.`
+                : `Stage pick has not run in ${paths.runDir}.`, 'redesign_pick_missing');
         }
     }
     if (needed('branch')) {
         if (withinRange('branch')) {
-            record = await runBranchStage({
+            record = await runRedesignBranchStage({
                 record,
                 paths,
                 direction,