@12ui/design 0.2.55 → 0.2.57

package/dist/cli-help/design.d.ts

@@ -10,7 +10,7 @@ export declare const DESIGN_HELP: {
         readonly summary: "Search the Design Corpus and download validated visual references.";
         readonly sections: readonly [{
             readonly heading: "Behavior";
-            readonly items: readonly ["Runs in the foreground and writes an attempt record before the metered search, then a manifest, evidence, receipts, and downloaded references.", "Defaults to four references in balanced mode; --count accepts 1–48.", "--reference-image conditions retrieval on an existing PNG, JPEG, or WebP."];
+            readonly items: readonly ["Runs in the foreground and writes an attempt record before the metered search, then a manifest, evidence, receipts, and downloaded references.", "Defaults to four references in balanced mode; --count accepts 1–48 (hedge: 4–12).", "--reference-image conditions retrieval on an existing PNG, JPEG, or WebP."];
         }, {
             readonly heading: "Modes";
             readonly items: readonly ["direct stays closest to the literal query.", "balanced is the default relevance, quality, and variety trade-off.", "adventurer keeps a relevant head while exploring less expected directions."];
@@ -84,7 +84,7 @@ export declare const DESIGN_HELP: {
         readonly summary: "Improve one live interface or screenshot and produce a replayable implementation kit.";
         readonly sections: readonly [{
             readonly heading: "Behavior";
-            readonly items: readonly ["Five stages run in order: local capture, hosted draft candidates retaining layout and content, explicit pick, fused LayerDoc and responsive HTML conversion, then a local implementation plan.", "URL input uses one Playwright context for repeated --bootstrap actions, screenshot capture, and selector-verified DOM extraction. Image input normalizes the source locally.", "The kit keeps every candidate, winner, target, plan, assets, and improve.json replay record. Repeating a settled stage reuses it; --from pick --pick <slot> invalidates only the old target and plan.", "--responsive-quality selects standard or pro responsive export. If that export fails or reaches the improve deadline after LayerDoc materialization, improve derives fixed HTML free and continues to plan with a warning.", "--fresh abandons and records a stuck conversion identity, then uses a new idempotency key. A temporarily unavailable stage retries once after 30 seconds.", "--target brings your own design image or LayerDoc, skips draft and pick, converts an image when needed, and aligns the plan to the captured URL DOM."];
+            readonly items: readonly ["Five stages run in order: local capture, hosted draft candidates retaining layout and content, explicit pick, fused LayerDoc and responsive HTML conversion, then a local implementation plan.", "The pick is explicit and has no default. With no --pick and no pick already recorded, the run stops after the draw, prints where the candidates are and the exact command that continues (--from pick --pick <slot>), and buys no conversion: converting a candidate nobody chose spends money on a guess that cannot be cancelled. --target supplies the design instead and skips draft and pick.", "URL input uses one Playwright context for repeated --bootstrap actions, screenshot capture, and selector-verified DOM extraction. Image input normalizes the source locally.", string, "The kit keeps every candidate, winner, target, plan, assets, and improve.json replay record. Repeating a settled stage reuses it; --from pick --pick <slot> invalidates only the old target and plan.", "--responsive-quality selects standard or pro responsive export. If that export fails or reaches the improve deadline after LayerDoc materialization, improve derives fixed HTML free and continues to plan with a warning.", "--convert-stall-seconds bounds every hosted wait the convert stage makes, including the free fixed-layout derivation (default: twice the model's typical wall, 480s standard and pro, 300s fast; refused below one typical wall). If a wait ends with no LayerDoc on disk there is nothing to derive, so improve records the abandoned conversion and dispatches exactly ONE fresh one; a second stall writes plan/STALL.md and exits non-zero. The retry budget belongs to the kit: a resume re-attaches to the newest conversion already bought, a kit that has spent its retry refuses to dispatch again, and a pro conversion is never retried automatically because no measured wall justifies it. Stopping the wait does not stop the conversion: there is no cancel, so an abandoned run keeps billing.", "--fresh re-buys ONE conversion of the same settled winner under a new idempotency key: it records the abandoned conversion identity and reuses capture, draft and pick untouched. --redraw is the one that buys new candidates — it discards draft, pick, convert and plan, moves the old draw to candidates.previous, records any conversion it drops, and runs the draft stage again; it is also the one path allowed to change --direction, --candidates or --retain against the record. A temporarily unavailable stage retries once after 30 seconds.", "--target brings your own design image or LayerDoc, skips draft and pick, converts an image when needed, and aligns the plan to the captured URL DOM."];
         }, {
             readonly heading: "Planning";
             readonly items: readonly ["URL plans require at least 60% plausible DOM-side coverage; a blocked gate writes GATE.md while target HTML and LayerDoc remain authoritative sidecars.", "Image plans are target-only by default. --plan-source-convert buys one source LayerDoc conversion for an unanchored LayerDoc comparison.", "--repo adds evidence-ranked src/ TSX, JSX, and CSS file hints to a URL plan. The command never applies code.", "--dry-run prints exact catalog price ceilings for every stage and makes no network request."];

package/dist/cli-help/design.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"design.d.ts","sourceRoot":"","sources":["../../src/cli-help/design.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8NW,CAAC"}
+{"version":3,"file":"design.d.ts","sourceRoot":"","sources":["../../src/cli-help/design.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwOW,CAAC"}

package/dist/cli-help/design.js

@@ -16,7 +16,7 @@ export const DESIGN_HELP = {
                 heading: 'Behavior',
                 items: [
                     'Runs in the foreground and writes an attempt record before the metered search, then a manifest, evidence, receipts, and downloaded references.',
-                    'Defaults to four references in balanced mode; --count accepts 1–48.',
+                    'Defaults to four references in balanced mode; --count accepts 1–48 (hedge: 4–12).',
                     '--reference-image conditions retrieval on an existing PNG, JPEG, or WebP.',
                 ],
             },
@@ -168,10 +168,20 @@ export const DESIGN_HELP = {
                 heading: 'Behavior',
                 items: [
                     'Five stages run in order: local capture, hosted draft candidates retaining layout and content, explicit pick, fused LayerDoc and responsive HTML conversion, then a local implementation plan.',
+                    'The pick is explicit and has no default. With no --pick and no pick already recorded, the run stops after the draw, prints where the candidates are and the exact command that continues (--from pick --pick <slot>), and buys no conversion: converting a candidate nobody chose spends money on a guess that cannot be cancelled. --target supplies the design instead and skips draft and pick.',
                     'URL input uses one Playwright context for repeated --bootstrap actions, screenshot capture, and selector-verified DOM extraction. Image input normalizes the source locally.',
+                    "--bootstrap takes ONE quoted pipe-separated triple, not three alternatives:"
+                        + " '<url>|<click-selector>|<wait-url>'. Any field may be empty and the flag repeats, so"
+                        + " --bootstrap '|button[data-test=sign-in]|**/dashboard' clicks and then waits. A value"
+                        + ' with no pipe is read as a click selector unless it starts with http:// or https://.'
+                        + ' A magic-link triple carries a live session token, so improve.json records only a'
+                        + ' redacted form of it (query values and fragment replaced) plus a sha256; the live'
+                        + ' value is never written to disk, and a resume that has to capture again asks for'
+                        + ' --bootstrap once more.',
                     'The kit keeps every candidate, winner, target, plan, assets, and improve.json replay record. Repeating a settled stage reuses it; --from pick --pick <slot> invalidates only the old target and plan.',
                     '--responsive-quality selects standard or pro responsive export. If that export fails or reaches the improve deadline after LayerDoc materialization, improve derives fixed HTML free and continues to plan with a warning.',
-                    '--fresh abandons and records a stuck conversion identity, then uses a new idempotency key. A temporarily unavailable stage retries once after 30 seconds.',
+                    "--convert-stall-seconds bounds every hosted wait the convert stage makes, including the free fixed-layout derivation (default: twice the model's typical wall, 480s standard and pro, 300s fast; refused below one typical wall). If a wait ends with no LayerDoc on disk there is nothing to derive, so improve records the abandoned conversion and dispatches exactly ONE fresh one; a second stall writes plan/STALL.md and exits non-zero. The retry budget belongs to the kit: a resume re-attaches to the newest conversion already bought, a kit that has spent its retry refuses to dispatch again, and a pro conversion is never retried automatically because no measured wall justifies it. Stopping the wait does not stop the conversion: there is no cancel, so an abandoned run keeps billing.",
+                    '--fresh re-buys ONE conversion of the same settled winner under a new idempotency key: it records the abandoned conversion identity and reuses capture, draft and pick untouched. --redraw is the one that buys new candidates — it discards draft, pick, convert and plan, moves the old draw to candidates.previous, records any conversion it drops, and runs the draft stage again; it is also the one path allowed to change --direction, --candidates or --retain against the record. A temporarily unavailable stage retries once after 30 seconds.',
                     '--target brings your own design image or LayerDoc, skips draft and pick, converts an image when needed, and aligns the plan to the captured URL DOM.',
                 ],
             },

package/dist/cli-help/design.js.map

@@ -1 +1 @@
-{"version":3,"file":"design.js","sourceRoot":"","sources":["../../src/cli-help/design.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"design.js","sourceRoot":"","sources":["../../src/cli-help/design.ts"],"names":[],"mappings":"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"}

package/dist/cli-help/index.d.ts

@@ -70,7 +70,7 @@ export declare const CLI_HELP_CONTEXTS: {
         readonly summary: "Search the Design Corpus and download validated visual references.";
         readonly sections: readonly [{
             readonly heading: "Behavior";
-            readonly items: readonly ["Runs in the foreground and writes an attempt record before the metered search, then a manifest, evidence, receipts, and downloaded references.", "Defaults to four references in balanced mode; --count accepts 1–48.", "--reference-image conditions retrieval on an existing PNG, JPEG, or WebP."];
+            readonly items: readonly ["Runs in the foreground and writes an attempt record before the metered search, then a manifest, evidence, receipts, and downloaded references.", "Defaults to four references in balanced mode; --count accepts 1–48 (hedge: 4–12).", "--reference-image conditions retrieval on an existing PNG, JPEG, or WebP."];
         }, {
             readonly heading: "Modes";
             readonly items: readonly ["direct stays closest to the literal query.", "balanced is the default relevance, quality, and variety trade-off.", "adventurer keeps a relevant head while exploring less expected directions."];
@@ -144,7 +144,7 @@ export declare const CLI_HELP_CONTEXTS: {
         readonly summary: "Improve one live interface or screenshot and produce a replayable implementation kit.";
         readonly sections: readonly [{
             readonly heading: "Behavior";
-            readonly items: readonly ["Five stages run in order: local capture, hosted draft candidates retaining layout and content, explicit pick, fused LayerDoc and responsive HTML conversion, then a local implementation plan.", "URL input uses one Playwright context for repeated --bootstrap actions, screenshot capture, and selector-verified DOM extraction. Image input normalizes the source locally.", "The kit keeps every candidate, winner, target, plan, assets, and improve.json replay record. Repeating a settled stage reuses it; --from pick --pick <slot> invalidates only the old target and plan.", "--responsive-quality selects standard or pro responsive export. If that export fails or reaches the improve deadline after LayerDoc materialization, improve derives fixed HTML free and continues to plan with a warning.", "--fresh abandons and records a stuck conversion identity, then uses a new idempotency key. A temporarily unavailable stage retries once after 30 seconds.", "--target brings your own design image or LayerDoc, skips draft and pick, converts an image when needed, and aligns the plan to the captured URL DOM."];
+            readonly items: readonly ["Five stages run in order: local capture, hosted draft candidates retaining layout and content, explicit pick, fused LayerDoc and responsive HTML conversion, then a local implementation plan.", "The pick is explicit and has no default. With no --pick and no pick already recorded, the run stops after the draw, prints where the candidates are and the exact command that continues (--from pick --pick <slot>), and buys no conversion: converting a candidate nobody chose spends money on a guess that cannot be cancelled. --target supplies the design instead and skips draft and pick.", "URL input uses one Playwright context for repeated --bootstrap actions, screenshot capture, and selector-verified DOM extraction. Image input normalizes the source locally.", string, "The kit keeps every candidate, winner, target, plan, assets, and improve.json replay record. Repeating a settled stage reuses it; --from pick --pick <slot> invalidates only the old target and plan.", "--responsive-quality selects standard or pro responsive export. If that export fails or reaches the improve deadline after LayerDoc materialization, improve derives fixed HTML free and continues to plan with a warning.", "--convert-stall-seconds bounds every hosted wait the convert stage makes, including the free fixed-layout derivation (default: twice the model's typical wall, 480s standard and pro, 300s fast; refused below one typical wall). If a wait ends with no LayerDoc on disk there is nothing to derive, so improve records the abandoned conversion and dispatches exactly ONE fresh one; a second stall writes plan/STALL.md and exits non-zero. The retry budget belongs to the kit: a resume re-attaches to the newest conversion already bought, a kit that has spent its retry refuses to dispatch again, and a pro conversion is never retried automatically because no measured wall justifies it. Stopping the wait does not stop the conversion: there is no cancel, so an abandoned run keeps billing.", "--fresh re-buys ONE conversion of the same settled winner under a new idempotency key: it records the abandoned conversion identity and reuses capture, draft and pick untouched. --redraw is the one that buys new candidates — it discards draft, pick, convert and plan, moves the old draw to candidates.previous, records any conversion it drops, and runs the draft stage again; it is also the one path allowed to change --direction, --candidates or --retain against the record. A temporarily unavailable stage retries once after 30 seconds.", "--target brings your own design image or LayerDoc, skips draft and pick, converts an image when needed, and aligns the plan to the captured URL DOM."];
         }, {
             readonly heading: "Planning";
             readonly items: readonly ["URL plans require at least 60% plausible DOM-side coverage; a blocked gate writes GATE.md while target HTML and LayerDoc remain authoritative sidecars.", "Image plans are target-only by default. --plan-source-convert buys one source LayerDoc conversion for an unanchored LayerDoc comparison.", "--repo adds evidence-ranked src/ TSX, JSX, and CSS file hints to a URL plan. The command never applies code.", "--dry-run prints exact catalog price ceilings for every stage and makes no network request."];

package/dist/cli-improve-command.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cli-improve-command.d.ts","sourceRoot":"","sources":["../src/cli-improve-command.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AAMnD,OAAO,EAQL,KAAK,0BAA0B,EAChC,MAAM,4BAA4B,CAAC;AACpC,OAAO,EAIL,KAAK,aAAa,EAEnB,MAAM,wBAAwB,CAAC;AAgEhC,eAAO,MAAM,iBAAiB,GAC5B,SAAS,SAAS,MAAM,EAAE,EAC1B,OAAO,QAAQ,EACf,eAAc,0BAA+B,KAC5C,OAAO,CAAC,aAAa,CAqJvB,CAAC"}
+{"version":3,"file":"cli-improve-command.d.ts","sourceRoot":"","sources":["../src/cli-improve-command.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AA4BnD,OAAO,EAQL,KAAK,0BAA0B,EAChC,MAAM,4BAA4B,CAAC;AACpC,OAAO,EAIL,KAAK,aAAa,EAEnB,MAAM,wBAAwB,CAAC;AAyGhC,eAAO,MAAM,iBAAiB,GAC5B,SAAS,SAAS,MAAM,EAAE,EAC1B,OAAO,QAAQ,EACf,eAAc,0BAA+B,KAC5C,OAAO,CAAC,aAAa,CA2VvB,CAAC"}

package/dist/cli-improve-command.js

@@ -1,10 +1,21 @@
 import { createHash, randomUUID } from 'node:crypto';
 import { readFile } from 'node:fs/promises';
+import path from 'node:path';
 import { CliRefusal } from './cli-refusal.js';
 import { prepareOutputDirectory } from './cli-output-paths.js';
 import { parseImproveOptions } from './improve-options.js';
 import { buildImprovePricingPlan } from './improve-pricing-plan.js';
-import { retryImproveTemporarilyUnavailable } from './improve-convert-resilience.js';
+import { assertImproveCaptureNotRedirected } from './improve-capture-redirect.js';
+import { improveBootstrapDigest, improveBootstrapRecordFields, redactImproveBootstrap, } from './improve-bootstrap-secret.js';
+import { improveStalled, retryImproveTemporarilyUnavailable } from './improve-convert-resilience.js';
+import { ensureImproveKitIgnored } from './improve-kit-ignore.js';
+import { resolveImproveStall, writeImproveFallbackStall, writeImproveStallReport, } from './improve-kit-stall.js';
+import { readImproveKitStatus } from './improve-kit-status.js';
+import { resetImproveDraw } from './improve-reset.js';
+import { awaitingImprovePick, buildImproveRunSummary, improveStallErrorWithSummary, } from './improve-run-summary.js';
+import { markImproveStageStalled } from './improve-stage-shared.js';
+import { registerImproveStopHandler } from './improve-stop-handler.js';
+import { noteImproveTerminalEvent } from './improve-terminal-event.js';
 import { runImproveCaptureStage, runImproveConvertStage, runImproveDraftStage, markImproveStageSkipped, runImprovePickStage, runImprovePlanStage, writeImproveReadme, } from './improve-stage-runners.js';
 import { IMPROVE_STAGES, readImproveRecord, writeImproveRecord, } from './improve-workspace.js';
 /**
@@ -13,11 +24,34 @@ import { IMPROVE_STAGES, readImproveRecord, writeImproveRecord, } from './improv
  * modules. No server route or billing path is introduced here.
  */
 const same = (left, right) => JSON.stringify(left) === JSON.stringify(right);
+/**
+ * A mismatch refusal that names neither value is a dead end: the reader knows
+ * the flag disagrees with the record and has to open `improve.json` to find out
+ * what it holds. `--bootstrap` is the case that cost a run — its recorded value
+ * is a quoted triple nobody remembers typing.
+ */
+const describeRecordedValue = (value) => {
+    if (value === undefined || value === null)
+        return 'nothing';
+    if (Array.isArray(value)) {
+        return value.length === 0 ? 'nothing' : value.map((entry) => `'${String(entry)}'`).join(', ');
+    }
+    if (typeof value === 'object')
+        return JSON.stringify(value);
+    return `'${String(value)}'`;
+};
 const assertCompatibleRecord = async (args) => {
     if (!same(args.record.input.kind, args.parsed.input.kind)
         || !same(args.record.input.value, args.parsed.input.value)) {
         throw new CliRefusal('This improve directory belongs to a different input', 'improve_record_mismatch');
     }
+    // `--redraw` throws the draw away and buys another one, so the three flags
+    // that describe a draw are the ones it is entitled to change. Refusing them
+    // made the documented redraw command — the one that passes a new
+    // `--direction` — impossible to run, and sent the reader to a fresh
+    // `--out-dir`, which re-buys the capture too. Everything else still has to
+    // match: a redraw does not license a different model or a different page.
+    const drawFlags = new Set(args.parsed.redraw ? ['direction', 'candidates', 'retain'] : []);
     const explicitChecks = [
         ['direction', args.record.direction, args.parsed.direction],
         ['candidates', args.record.candidates, args.parsed.candidates],
@@ -26,14 +60,31 @@ const assertCompatibleRecord = async (args) => {
         ['responsive-quality', args.record.responsiveQuality, args.parsed.responsiveQuality],
         ['viewport', args.record.viewport, args.parsed.viewport],
         ['full-page', args.record.fullPage, args.parsed.fullPage],
-        ['bootstrap', args.record.bootstrap, args.parsed.bootstrapValues],
         ['repo', args.record.repo, args.parsed.repo],
         ['plan-source-convert', args.record.planSourceConvert, args.parsed.planSourceConvert],
         ['target', args.record.target && { kind: args.record.target.kind, value: args.record.target.value }, args.parsed.target],
     ];
+    // `--bootstrap` compares by digest, because the record deliberately holds no
+    // live value to compare against (F31), and neither side of the refusal may
+    // print the secret.
+    if (args.flags.bootstrap !== undefined
+        && !same(args.record.bootstrapSha256 ?? [], args.parsed.bootstrapValues.map(improveBootstrapDigest))) {
+        throw new CliRefusal('--bootstrap does not match the durable improve record.'
+            + ` The record holds ${describeRecordedValue(args.record.bootstrap)}`
+            + ' (query values redacted; the live value is never stored);'
+            + ` this run asked for ${describeRecordedValue(args.parsed.bootstrapValues.map(redactImproveBootstrap))}.`
+            + ' Drop --bootstrap to reuse what the record already captured,'
+            + ' or pass a fresh --out-dir to start over with the changed input.', 'improve_record_mismatch');
+    }
     for (const [flag, recorded, requested] of explicitChecks) {
+        if (drawFlags.has(flag))
+            continue;
         if (args.flags[flag] !== undefined && !same(recorded, requested)) {
-            throw new CliRefusal(`--${flag} does not match the durable improve record. Start a new --out-dir for changed inputs.`, 'improve_record_mismatch');
+            throw new CliRefusal(`--${flag} does not match the durable improve record.`
+                + ` The record holds ${describeRecordedValue(recorded)};`
+                + ` this run asked for ${describeRecordedValue(requested)}.`
+                + ` Drop --${flag} to reuse what the record already captured,`
+                + ' or pass a fresh --out-dir to start over with the changed input.', 'improve_record_mismatch');
         }
     }
     if (args.record.input.kind === 'image' && args.record.input.sha256) {
@@ -95,7 +146,7 @@ export const runImproveCommand = async (command, flags, dependencies = {}) => {
             responsiveQuality: parsed.responsiveQuality,
             viewport: parsed.viewport,
             fullPage: parsed.fullPage,
-            bootstrap: parsed.bootstrapValues,
+            ...improveBootstrapRecordFields(parsed.bootstrapValues),
             ...(parsed.repo ? { repo: parsed.repo } : {}),
             planSourceConvert: parsed.planSourceConvert,
             stages: {},
@@ -122,92 +173,288 @@ export const runImproveCommand = async (command, flags, dependencies = {}) => {
         responsiveQuality: parsed.responsiveQuality,
         viewport: parsed.viewport,
         fullPage: parsed.fullPage,
-        bootstrap: parsed.bootstrapValues,
+        ...improveBootstrapRecordFields(parsed.bootstrapValues),
         ...(parsed.repo ? { repo: parsed.repo } : {}),
         planSourceConvert: parsed.planSourceConvert,
         stages: {},
     };
+    // A kit written inside the repository it improves is ~100 MB of paid
+    // artifacts one `git add -A` away from someone's history (F17). Decided every
+    // run, because the repository's own `.gitignore` can change between them.
+    const kitIgnore = await ensureImproveKitIgnored({ outDir: parsed.paths.runDir });
+    record = { ...record, ...(kitIgnore ? { kitIgnore } : {}) };
     await writeImproveRecord(parsed.paths.record, record);
     const write = dependencies.write ?? ((line) => { process.stdout.write(`${line}\n`); });
     write(parsed.paths.runDir);
     dependencies.onRunDirectory?.(parsed.paths.runDir);
     dependencies.journal?.note({ workspace: parsed.paths.runDir, writes: [parsed.paths.record] });
+    // The kit describes itself after every stage, not only at the end. It derives
+    // from the record plus what is on disk, so writing it repeatedly is cheap and
+    // idempotent — and a run that dies between stages still leaves a front door.
+    const refreshReadme = async () => writeImproveReadme(record, { requestedTo: parsed.to });
     const index = (stage) => IMPROVE_STAGES.indexOf(stage);
     const within = (stage) => index(stage) >= index(parsed.from) && index(stage) <= index(parsed.to);
     const needed = (stage) => index(stage) <= index(parsed.to);
-    const runStage = (stage, action) => (retryImproveTemporarilyUnavailable({
-        stage,
-        action,
-        ...(dependencies.sleep ? { sleep: dependencies.sleep } : {}),
-        ...(dependencies.warn ? { warn: dependencies.warn } : {}),
-    }));
+    // The stage this invocation is INSIDE, which is what tells a stop mid-flight
+    // apart from a signal after completion. The record cannot: `--fresh` clears
+    // convert and plan from the durable record inside the convert stage, and
+    // `record` here is only reassigned when that stage returns.
+    let liveStage;
+    const runStage = async (stage, action) => {
+        liveStage = stage;
+        try {
+            return await retryImproveTemporarilyUnavailable({
+                stage,
+                action,
+                ...(dependencies.sleep ? { sleep: dependencies.sleep } : {}),
+                ...(dependencies.warn ? { warn: dependencies.warn } : {}),
+            });
+        }
+        finally {
+            liveStage = undefined;
+        }
+    };
     const freshConversionNonce = parsed.fresh ? randomUUID() : undefined;
-    if (needed('capture')) {
-        if (within('capture'))
-            record = await runStage('capture', () => runImproveCaptureStage({
-                record, options: parsed, dependencies, price: price.get('capture') ?? 0,
-            }));
-        if (!record.capture)
-            missingStage('capture', parsed.paths.runDir);
-    }
-    if (needed('draft')) {
-        if (record.target) {
-            record = await markImproveStageSkipped(record, 'draft');
+    // A stalled or killed stage still owes the reader a kit that says what is
+    // missing and how to recover, and owes every other shell a terminal journal
+    // line. Without them a lane reads an empty `target/` and hand-authors the
+    // design in CSS — which is what happened on the pipedrive landing, and that
+    // lane was KILLED, not stalled, so it threw nothing the catch below could
+    // have seen. The handler is armed here, before the first stage, because a
+    // kill during capture, draft or pick used to leave nothing at all.
+    // A signal wrote this kit's `plan/STALL.md` during this very invocation, so
+    // nothing later in it may resolve that file away: in production the handler
+    // exits the process, and a harness that lets the stage unwind must not answer
+    // the signal by declaring the run fine (F21).
+    let stopped = false;
+    const disarmStop = registerImproveStopHandler({
+        getRecord: () => record,
+        onStopped: () => { stopped = true; },
+        getLiveStage: () => liveStage,
+        write,
+        requestedTo: parsed.to,
+        ...(dependencies.journal ? { journal: dependencies.journal } : {}),
+        ...(dependencies.stopTarget ? { target: dependencies.stopTarget } : {}),
+        ...(dependencies.exit ? { exit: dependencies.exit } : {}),
+    });
+    try {
+        // `--redraw` is the flag `--fresh` was being mistaken for. `--fresh` rotates
+        // the conversion key and re-buys ONE conversion of the SAME settled winner;
+        // it never touches the draw. A caller who wanted different candidates had no
+        // flag at all. This one empties draft, pick, convert and plan, renames the
+        // old draw aside rather than deleting it, and lets the normal stage order buy
+        // a new one — announced, because it is the most expensive thing improve does.
+        if (parsed.redraw) {
+            const hadDraw = Boolean(record.draft || record.pick);
+            // Only the flags this run actually passed reach the record. A redraw that
+            // reset `--candidates` to the default because the flag was absent would
+            // buy a draw nobody asked for.
+            const reset = await resetImproveDraw({
+                record,
+                draw: {
+                    ...(flags.direction !== undefined
+                        ? { direction: parsed.direction, concept: parsed.concept }
+                        : {}),
+                    ...(flags.candidates !== undefined ? { candidates: parsed.candidates } : {}),
+                    ...(flags.retain !== undefined
+                        ? { retain: parsed.retain, retainFlag: parsed.retainFlag }
+                        : {}),
+                },
+                ...(dependencies.warn ? { warn: dependencies.warn } : {}),
+            });
+            record = reset.record;
+            await writeImproveRecord(parsed.paths.record, record);
+            if (hadDraw) {
+                write(`--redraw: the previous draw moved to ${parsed.paths.candidatesDir}.previous;`
+                    + ` buying ${record.candidates} new candidates.`);
+                dependencies.journal?.note({ degradations: ['improve_draw_discarded'] });
+            }
+            // A settled conversion the redraw threw away is paid work, and there is
+            // no cancel. It belongs in the same ledger `--fresh` and a re-pick write.
+            if (reset.abandonedId) {
+                dependencies.journal?.note({ degradations: ['improve_redraw_abandoned_conversion'] });
+            }
         }
-        else {
-            if (within('draft'))
-                record = await runStage('draft', () => runImproveDraftStage({
-                    record, options: parsed, flags, dependencies, price: price.get('draft') ?? 0,
+        if (needed('capture')) {
+            if (within('capture'))
+                record = await runStage('capture', () => runImproveCaptureStage({
+                    record, options: parsed, dependencies, price: price.get('capture') ?? 0,
                 }));
-            if (!record.draft)
-                missingStage('draft', parsed.paths.runDir);
+            if (!record.capture)
+                missingStage('capture', parsed.paths.runDir);
+            await refreshReadme();
+            // Free, deterministic, and BEFORE the draft purchase: the captured page
+            // and the requested one have to be the same page, or nothing is bought
+            // (F27). The capture and the README above are already on disk, so the
+            // refusal costs a reader nothing and the next run replays them.
+            assertImproveCaptureNotRedirected({
+                record, allowRedirect: parsed.allowRedirect, runDir: parsed.paths.runDir,
+            });
         }
-    }
-    if (needed('pick')) {
-        if (record.target) {
-            record = await markImproveStageSkipped(record, 'pick');
+        if (needed('draft')) {
+            if (record.target) {
+                record = await markImproveStageSkipped(record, 'draft');
+            }
+            else {
+                if (within('draft'))
+                    record = await runStage('draft', () => runImproveDraftStage({
+                        record, options: parsed, flags, dependencies, price: price.get('draft') ?? 0,
+                    }));
+                if (!record.draft)
+                    missingStage('draft', parsed.paths.runDir);
+            }
+            await refreshReadme();
         }
-        else {
-            if (within('pick'))
-                record = await runStage('pick', () => runImprovePickStage({
-                    record, options: parsed, price: price.get('pick') ?? 0,
-                }));
-            if (!record.pick)
-                missingStage('pick', parsed.paths.runDir);
+        if (needed('pick')) {
+            if (record.target) {
+                record = await markImproveStageSkipped(record, 'pick');
+            }
+            else {
+                // DISPATCH DISCIPLINE. A draw is alternatives; converting one of them
+                // before anyone has looked spends money on a guess. `--pick` used to
+                // default to A and the convert stage ran straight on, so notion bought
+                // a conversion of candidate A four milliseconds after the draft
+                // settled — and then a second process converted D, the one actually
+                // chosen. With no `--pick` and no recorded pick, the run stops here.
+                const chosen = parsed.pick ?? record.pick?.slot;
+                if (within('pick')) {
+                    // Nothing to settle and nobody to ask: stop, and print the one
+                    // command that continues. A range that starts AFTER pick asked to
+                    // skip this stage, so it falls through to the honest refusal below
+                    // rather than quietly stopping where it was told not to.
+                    if (!chosen) {
+                        await refreshReadme();
+                        write(awaitingImprovePick({ record, options: parsed }));
+                        dependencies.journal?.note({
+                            workspace: parsed.paths.runDir,
+                            artifacts: [parsed.paths.record, parsed.paths.readme],
+                            purchased: record.draft ? [record.draft.runId] : [],
+                            terminal: false,
+                        });
+                        console.log(JSON.stringify({ from: parsed.from, to: parsed.to, ...record }, null, 2));
+                        return record;
+                    }
+                    record = await runStage('pick', () => runImprovePickStage({
+                        record, options: parsed, pick: chosen, dependencies, price: price.get('pick') ?? 0,
+                    }));
+                }
+                if (!record.pick)
+                    missingStage('pick', parsed.paths.runDir);
+            }
+            await refreshReadme();
         }
-    }
-    if (needed('convert')) {
-        if (within('convert'))
-            record = await runStage('convert', () => runImproveConvertStage({
+        try {
+            if (needed('convert')) {
+                if (within('convert'))
+                    record = await runStage('convert', () => runImproveConvertStage({
+                        record,
+                        options: parsed,
+                        dependencies,
+                        price: price.get('convert') ?? 0,
+                        ...(freshConversionNonce ? { freshConversionNonce } : {}),
+                    }));
+                if (!record.convert)
+                    missingStage('convert', parsed.paths.runDir);
+                await refreshReadme();
+            }
+            if (needed('plan')) {
+                if (within('plan'))
+                    record = await runStage('plan', () => runImprovePlanStage({
+                        record, options: parsed, dependencies, price: price.get('plan') ?? 0,
+                    }));
+                if (!record.plan)
+                    missingStage('plan', parsed.paths.runDir);
+            }
+        }
+        catch (error) {
+            // The durable record is the truth here: a stage that failed still wrote
+            // down what it abandoned before it threw, and the in-memory copy this
+            // function holds predates that.
+            record = await readImproveRecord(parsed.paths.record) ?? record;
+            const stalledStage = record.convert ? 'plan' : 'convert';
+            // A stall closes the record itself, before the recovery files, so a
+            // reader never sees a run whose last line is a progress entry. A stage
+            // that failed for a reason the journal can already classify — an auth
+            // failure, a refusal — keeps that classification: `withRunJournal` ends
+            // it on the way out and the throw below is what gets there.
+            const stalled = improveStalled(error);
+            // The durable record has to say the paid call never came back. `outcome`
+            // is the one field a supervisor or a parser reads, and it stayed
+            // `dispatched` — which reads as "in flight" long after the run ended (F28).
+            const marked = markImproveStageStalled({ record, stage: stalledStage, stalled });
+            if (marked !== record) {
+                record = marked;
+                await writeImproveRecord(parsed.paths.record, record);
+            }
+            if (stalled) {
+                // Everything the record is owed goes in HERE. The session refuses to
+                // write after its end line, so the note that used to follow this call
+                // was dropped in silence and `improve_<stage>_stalled` never reached a
+                // single stalled record.
+                await noteImproveTerminalEvent({
+                    record,
+                    stage: stalledStage,
+                    kind: 'stalled',
+                    error,
+                    writes: [path.join(parsed.paths.planDir, 'STALL.md'), parsed.paths.readme],
+                    degradations: [`improve_${stalledStage}_stalled`],
+                    ...(dependencies.journal ? { journal: dependencies.journal } : {}),
+                });
+            }
+            const stall = await writeImproveStallReport({
+                record, stage: stalledStage, error, requestedTo: parsed.to,
+            });
+            const readme = await refreshReadme();
+            // A failure the journal can already classify — an auth failure, a refusal
+            // — has an open session still, and `withRunJournal` ends it on the way
+            // out; this is the last chance to name what it produced.
+            if (!stalled) {
+                dependencies.journal?.note({
+                    workspace: parsed.paths.runDir,
+                    artifacts: [parsed.paths.record, readme, stall],
+                    degradations: [`improve_${stalledStage}_stalled`],
+                });
+            }
+            throw improveStallErrorWithSummary(error, await buildImproveRunSummary({ record, requestedTo: parsed.to }));
+        }
+        // A run that fell back to fixed layout finished, but something stalled on
+        // the way. It gets the same `plan/STALL.md` a dead run gets — written after
+        // the plan, so it can say the plan was built from the derivation — and the
+        // README, written next, links to it (F8).
+        const fallbackStall = await writeImproveFallbackStall({ record, requestedTo: parsed.to });
+        // And a run that SETTLED what an earlier one stalled on replaces the file
+        // that earlier one left. Freshdesk shipped a settled plan under a README
+        // saying "settled" beside a STALL.md saying "INCOMPLETE — no plan"; the
+        // reader had no way to tell which was current (F21).
+        const resolvedStall = fallbackStall || stopped
+            ? undefined
+            : await resolveImproveStall({
                 record,
-                options: parsed,
-                dependencies,
-                price: price.get('convert') ?? 0,
-                ...(freshConversionNonce ? { freshConversionNonce } : {}),
-            }));
-        if (!record.convert)
-            missingStage('convert', parsed.paths.runDir);
+                status: await readImproveKitStatus({ record, requestedTo: parsed.to }),
+            });
+        const stallFile = fallbackStall ?? resolvedStall;
+        const readme = await refreshReadme();
+        dependencies.journal?.note({
+            workspace: parsed.paths.runDir,
+            artifacts: [
+                parsed.paths.record,
+                readme,
+                ...(stallFile ? [stallFile] : []),
+                ...(record.plan?.artifacts ?? []),
+            ],
+            purchased: [
+                ...(record.draft ? [record.draft.runId] : []),
+                ...(record.convert?.purchaseIds ?? []),
+                ...(record.sourceConvert?.purchaseIds ?? []),
+            ],
+            terminal: parsed.to === 'plan',
+        });
+        console.log(JSON.stringify({ from: parsed.from, to: parsed.to, ...record }, null, 2));
+        write(await buildImproveRunSummary({ record, requestedTo: parsed.to }));
+        return record;
     }
-    if (needed('plan')) {
-        if (within('plan'))
-            record = await runStage('plan', () => runImprovePlanStage({
-                record, options: parsed, dependencies, price: price.get('plan') ?? 0,
-            }));
-        if (!record.plan)
-            missingStage('plan', parsed.paths.runDir);
+    finally {
+        disarmStop();
     }
-    const readme = await writeImproveReadme(record);
-    dependencies.journal?.note({
-        workspace: parsed.paths.runDir,
-        artifacts: [parsed.paths.record, readme, ...(record.plan?.artifacts ?? [])],
-        purchased: [
-            ...(record.draft ? [record.draft.runId] : []),
-            ...(record.convert?.purchaseIds ?? []),
-            ...(record.sourceConvert?.purchaseIds ?? []),
-        ],
-        terminal: parsed.to === 'plan',
-    });
-    console.log(JSON.stringify({ from: parsed.from, to: parsed.to, ...record }, null, 2));
-    return record;
 };
 //# sourceMappingURL=cli-improve-command.js.map