@ethlete/cli 3.0.0-next.26 → 3.0.0-next.28

package/src/lib/design/sketch-command.js

@@ -20,61 +20,93 @@ var __rest = (this && this.__rest) || function (s, e) {
     return t;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.designSketch = exports.verdictLinesOf = exports.sketchFlagHelpOf = exports.SKETCH_USAGE = void 0;
+exports.designSketch = exports.verdictLinesOf = exports.beforeLinesOf = exports.retriedHeldMerges = exports.sketchFlagHelpOf = exports.SKETCH_USAGE = void 0;
 const unused_closure_1 = require("./system/sketch/unused-closure");
+const crypto_1 = require("crypto");
+const fs_1 = require("fs");
+const os_1 = require("os");
 const path_1 = require("path");
+const phase_timing_1 = require("./phase-timing");
+const write_origin_1 = require("./system/write-origin");
 const assets_1 = require("./system/assets");
 const comment_1 = require("./system/comments/comment");
 const product_1 = require("./system/product");
 const resolve_product_1 = require("./system/resolve-product");
 const check_format_1 = require("./system/sketch/check-format");
+const frame_budget_1 = require("./system/sketch/frame-budget");
+const note_language_1 = require("./system/sketch/note-language");
 const check_sketches_1 = require("./system/sketch/check-sketches");
 const cli_args_1 = require("./system/sketch/cli-args");
 const ready_shots_1 = require("./ready-shots");
+const no_visible_change_1 = require("./system/sketch/no-visible-change");
+const covered_diffs_1 = require("./system/sketch/covered-diffs");
+const viewed_shots_1 = require("./system/sketch/viewed-shots");
+const complete_1 = require("./system/complete");
 const merge_1 = require("./system/sketch/merge");
+const merge_step_1 = require("./system/sketch/merge-step");
+const check_system_1 = require("./system/check-system");
+const stale_base_1 = require("./system/sketch/stale-base");
+const invocation_1 = require("../invocation");
 const merged_parts_1 = require("./system/sketch/merged-parts");
+const no_verdict_1 = require("./system/no-verdict");
 const render_check_1 = require("./system/render-check");
 const merge_preview_1 = require("./system/sketch/merge-preview");
 const open_points_1 = require("./system/open-points");
 const read_open_points_1 = require("./system/read-open-points");
 const overlay_1 = require("./system/sketch/overlay");
+const system_modules_1 = require("./system/system-modules");
+const unchanged_states_1 = require("./system/sketch/unchanged-states");
+const rebase_port_1 = require("./system/sketch/rebase-port");
+const theming_text_1 = require("./system/theming-text");
+const warm_draw_1 = require("./warm-draw");
 const sketch_1 = require("./system/sketch/sketch");
+const plain_output_1 = require("../plain-output");
+const design_lint_1 = require("./design-lint");
 exports.SKETCH_USAGE = [
-    'sketch new <layer>/<name> [<layer>/<name>…] --variants a,b --by <model id> [--like <layer>/<name>[:<variant>]] [--round <title>] [--note <text>] [--variant-note <variant>=<text>]… [--override | --into-base] [--product <name>]',
+    'sketch new <layer>/<name> [<layer>/<name>…] --variants a,b --by <model id> [--like <layer>/<name>[:<variant>]] [--name <sketch name>] [--round <title>] [--note <text>] [--variant-note <variant>=<text>]… [--override | --into-base] [--ready] [--product <name>]',
     'sketch variant <layer>/<name> <variant>[,<variant>…] --from <variant> --by <model id> [--round <title> --note <why the running round lost> [--round-note <what the new round shows>]] [--product <name>]',
     'sketch round <layer>/<name> <round> [--title <text>] [--note <text>] [--drops <state,state>] --by <model id> [--product <name>]',
-    'sketch note <layer>/<name> <variant> <text> --by <model id> [--product <name>]',
+    'sketch covers <layer>/<name> [[<layer>/<name>:]<state>[@<x>,<y>,<w>,<h>]…] --by <model id> [--product <name>]',
+    'sketch note <layer>/<name> [<variant>] <text> [--round <round>] --by <model id> [--product <name>]',
     'sketch target add <layer>/<name> <layer>/<name> --by <model id> [--product <name>]',
+    'sketch target remove <layer>/<name> <layer>/<name> --by <model id> [--product <name>]',
     'sketch list [--product <name>] [--json]',
-    'sketch report <layer>/<name> --variant <key> --by <model id> (<text> | --done) [--product <name>]',
+    'sketch report <layer>/<name> --variant <key> --by <model id> (<text> | --done) [--reopen] [--product <name>]',
     'sketch ready <layer>/<name> --by <model id> [--product <name>]',
     'sketch hold <layer>/<name> --until <what the change waits on> --by <model id> [--product <name>]',
     'sketch release <layer>/<name> --by <model id> [--product <name>]',
     'sketch check [<layer>/<name>] [--fix] [--product <name>]',
     'sketch preview <layer>/<name> <variant> [--product <name>] [--json]',
-    'sketch rebase <layer>/<name> --by <model id> [--product <name>]',
-    'sketch merge <layer>/<name> [--note <reason>] [--variant <key> --allowed-by <plan ref>] --by <model id> [--product <name>]',
+    'sketch rebase <layer>/<name> [--ported] --by <model id> [--product <name>]',
+    'sketch merge <layer>/<name> [--note <reason> [--replace-note]] [--variant <key> --allowed-by <plan ref>] [--decided-by <name>] --by <model id> [--product <name>]',
     'sketch discard <layer>/<name> --by <model id> [--product <name>]',
     'sketch reject <layer>/<name> --variant <key> [--reason <text>] --by <model id | designer> [--product <name>]',
     'sketch reopen <layer>/<name> --variant <key> [--reason <text>] --by <model id | designer> [--product <name>]',
+    'sketch withdraw <layer>/<name> --variant <key> --by <model id> [--product <name>]',
 ];
 const FLAG_HELP = {
     '--variants': 'the variant folders to open, a comma list: a,b,c',
     '--variant-note': "the note of one variant, kept in sketch.json apart from the part's merged note; repeat it per variant: a=<text>",
     '--by': 'the exact model id the coordinator gave you, e.g. claude-opus-5-5',
+    '--name': 'a second sketch on a part that has one: it lives in its own folder and is addressed as <layer>/<name>@<sketch name>',
     '--like': 'start each variant from another part, or from a variant of the open sketch on it',
     '--override': 'on a base part: merge into a product copy that overrides the base, not into the base; on a product override: sketch that copy',
     '--into-base': 'on a part the product overrides: start from the product copy, merge into the base and remove the copy',
-    '--round': 'the title of a new round',
+    '--ready': 'on new: run sketch ready (its gates are the check) right after opening the sketch; it fails when either refuses and the sketch stays in progress',
+    '--ported': 'on rebase: the conflicting files hold the product change already, ported by hand - keep them and rebase',
+    '--round': 'the title of a new round; on note: the key of the round whose note to rewrite',
     '--round-note': 'what the new round shows',
     '--from': 'the variant to copy',
     '--title': 'the new title of the round',
     '--drops': 'the states the round drops on purpose, a comma list',
     '--variant': 'the variant the command is about; on merge, the only live variant of a sketch with no pick',
-    '--allowed-by': 'the plan entry that lets the merge go without a pick in Studio; logged in accepted.json, needs --variant',
+    '--allowed-by': 'the plan entry that lets the merge go without a pick in Studio; noted in merged.json, needs --variant',
+    '--decided-by': 'on merge: who picked the variant, as merged.json records it (default user); a name the designer gave you at this terminal, e.g. tom - not with --allowed-by',
+    '--replace-note': "on merge: also write --note over each target part's note",
     '--reason': 'why; on reject of a variant that is rejected already it sets the reason of that rejection; stored with who wrote it',
     '--until': 'what the pending change waits on: an open decision, a helper still to land',
     '--done': 'end the live report of the variant',
+    '--reopen': 'on report: move a ready sketch back to in progress',
     '--product': 'the product; needed only when config.json declares more than one and no other product has the sketch',
     '--json': 'print JSON',
     '--fix': "write the variants in the checkout's Prettier format first",
@@ -84,7 +116,7 @@ const NOTE_HELP = {
     new: 'what the first round shows',
     variant: 'why the running round lost; needed with --round',
     round: 'what the round shows',
-    merge: 'why this variant',
+    merge: "why this variant; noted in merged.json, the part's note stays",
 };
 /** One line per flag the usage line names, for `sketch <command> --help`. */
 const sketchFlagHelpOf = (usage) => {
@@ -94,13 +126,14 @@ const sketchFlagHelpOf = (usage) => {
     return [...new Set((_b = usage.match(/--[a-z-]+/gu)) !== null && _b !== void 0 ? _b : [])].flatMap((flag) => help[flag] === undefined ? [] : [`  ${flag.padEnd(16)}${help[flag]}`]);
 };
 exports.sketchFlagHelpOf = sketchFlagHelpOf;
-const VERDICTS = new Set(['reject', 'reopen']);
+const VERDICTS = new Set(['reject', 'reopen', 'withdraw']);
 const WRITES = new Set([
     'new',
     'target',
     'variant',
     'round',
     'note',
+    'covers',
     'report',
     'ready',
     'hold',
@@ -110,6 +143,11 @@ const WRITES = new Set([
     'discard',
     ...VERDICTS,
 ]);
+const RETRIES = new Set([...WRITES, 'check']);
+const staleBasesOf = (context, options) => {
+    var _a;
+    return (0, check_system_1.staleSketchBasesOf)(Object.assign(Object.assign({}, options), { invocation: (_a = context.invocation) !== null && _a !== void 0 ? _a : (0, invocation_1.repoInvocation)({ root: context.target, subcommand: 'design' }) }));
+};
 const fail = (message) => {
     console.error(message);
     return 1;
@@ -168,7 +206,7 @@ const variantLineOf = (options) => {
     const files = sketch.targets.map((part) => partFileOf(Object.assign(Object.assign({}, options), { part }))).join(', ');
     return `  ${variant}: ${files}  assets: ${(0, path_1.relative)(root, (0, path_1.resolve)(sketch.dir, variant, assets_1.ASSETS_FOLDER))}/`;
 };
-const created = (context) => {
+const opened = (context) => {
     var _a, _b, _c, _d, _e;
     const { target, config, args } = context;
     const product = (0, cli_args_1.oneProductOf)({ target, config, asked: args.values['--product'] });
@@ -180,6 +218,10 @@ const created = (context) => {
         return fail(unknown);
     if (parsed === undefined || typeof parsed === 'string')
         return fail((_a = exports.SKETCH_USAGE[0]) !== null && _a !== void 0 ? _a : '');
+    const name = args.values['--name'];
+    const named = name === undefined ? parsed : (0, sketch_1.parseTarget)(`${parsed.layer}/${parsed.name}@${name}`);
+    if (typeof named === 'string')
+        return fail(named);
     const variants = ((_b = args.values['--variants']) !== null && _b !== void 0 ? _b : '').split(',').filter((variant) => variant !== '');
     const notes = variantNotesOf((_c = args.repeated['--variant-note']) !== null && _c !== void 0 ? _c : [], variants);
     if (typeof notes === 'string')
@@ -196,7 +238,7 @@ const created = (context) => {
         return fail('pass --override or --into-base, not both');
     const sketch = (0, sketch_1.createSketch)({
         product,
-        sketch: parsed,
+        sketch: named,
         others: others.filter((entry) => typeof entry !== 'string'),
         variants,
         roundTitle: args.values['--round'],
@@ -217,25 +259,53 @@ const created = (context) => {
         console.log(`  shared by every variant, imported as @shared/<path>; edit it here, not in a copy:`);
         shared.forEach((file) => console.log(`    ${(0, path_1.relative)(target, file)}`));
     }
-    nextStepsOf(sketch, product.name).forEach((line) => console.log(line));
+    nextStepsOf(sketch, product).forEach((line) => console.log(line));
     return 0;
 };
-const nextStepsOf = (sketch, product) => {
+const created = (context) => __awaiter(void 0, void 0, void 0, function* () {
+    const code = opened(context);
+    if (code !== 0 || !context.args.flags.has('--ready'))
+        return code;
+    const found = productAndSketchOf(Object.assign(Object.assign({}, context), { args: Object.assign(Object.assign({}, context.args), { positional: [openedTargetOf(context)] }) }));
+    if (typeof found === 'string')
+        return fail(found);
+    const again = Object.assign(Object.assign({}, context), { args: Object.assign(Object.assign({}, context.args), { positional: [found.sketch.target] }) });
+    const readyCode = yield readied(again);
+    return readyCode === 0
+        ? 0
+        : fail(`${found.sketch.target} is still in progress: sketch ready refused - fix it, then run sketch ready`);
+});
+const openedTargetOf = ({ args }) => {
+    const [first] = args.positional;
+    const name = args.values['--name'];
+    return name === undefined ? (first !== null && first !== void 0 ? first : '') : `${first}@${name}`;
+};
+const noteLanguageLineOf = (product) => product.config.noteLanguage === undefined
+    ? []
+    : [
+        `  write every round and variant note in ${note_language_1.NOTE_LANGUAGE_NAMES[product.config.noteLanguage]}: that is the product's UI language`,
+    ];
+const nextStepsOf = (sketch, productSource) => {
     var _a;
+    const product = productSource.name;
     const at = `${sketch.target} --product ${product}`;
     const first = (_a = sketch.variants[0]) !== null && _a !== void 0 ? _a : '<key>';
     const running = (0, sketch_1.runningRoundOf)(sketch);
     return [
         'Next:',
         `  sketch report ${at} --variant ${first} --by <model id> "<what you draw>"   while you draw a variant`,
-        `  sketch report ${at} --variant ${first} --by <model id> --done              when you stop drawing it; no report runs yet, so none is needed now`,
         ...(running.note.trim() === ''
             ? [
                 `  sketch round ${sketch.target} ${running.key} --product ${product} --note "<what the round shows>" --by <model id>`,
             ]
             : []),
         `  sketch check ${at}`,
+        ...noteLanguageLineOf(productSource),
+        `  shot ${sketch.targets[0]} --states --variants --product ${product}   look at it: ready refuses a pixel diff without a viewed shot`,
         `  sketch ready ${at} --by <model id>`,
+        `  sketch report ${at} --variant ${first} --by <model id> --done              after ready, once you stop drawing a variant; no report runs yet, so none is needed now`,
+        `  a shared JSON file ready wrote (merged.json): commit it with \`et design commit-hunks <file> --part ${sketch.targets[0]}\`, never as a whole file another session also edits`,
+        theming_text_1.THEMING_TEXT,
     ];
 };
 const variantNotesOf = (pairs, variants) => {
@@ -253,7 +323,7 @@ const VARIANT_USAGE = 'usage: sketch variant <layer>/<name> <variant>[,<variant>
 const varied = (context) => {
     var _a;
     return withSketch(Object.assign(Object.assign({}, context), { noSketchHint: ` - start one with: sketch new ${(_a = context.args.positional[0]) !== null && _a !== void 0 ? _a : '<layer>/<name>'} --variants a,b,c --round "<title>"` }), ({ sketch }) => {
-        var _a, _b, _c, _d, _e;
+        var _a, _b, _c, _d, _e, _f;
         const { positional, values } = context.args;
         const variant = positional[1];
         const from = values['--from'];
@@ -300,6 +370,8 @@ const varied = (context) => {
         for (const name of variants) {
             console.log(`${added.target} in progress: variant ${name} from ${from} in round ${(_c = round === null || round === void 0 ? void 0 : round.key) !== null && _c !== void 0 ? _c : ''}`);
             console.log(variantLineOf({ root: context.target, sketch: added, variant: name }));
+            if (((_d = (0, sketch_1.rejectionOf)(added, from)) === null || _d === void 0 ? void 0 : _d.status) === 'withdrawn')
+                console.log(`  ${name}: from withdrawn ${from}`);
         }
         if (title !== undefined && (round === null || round === void 0 ? void 0 : round.note) === '')
             console.log(`round ${round.key} has no note yet - sketch ready needs one: sketch round ${added.target} ${round.key} --note "<what the round shows>" --by <model id>`);
@@ -309,12 +381,12 @@ const varied = (context) => {
             sketch,
             variant: from,
             reason: 'round',
-            author: (_d = (0, cli_args_1.authorOf)(context.args)) !== null && _d !== void 0 ? _d : undefined,
+            author: (_e = (0, cli_args_1.authorOf)(context.args)) !== null && _e !== void 0 ? _e : undefined,
             note: lostNote,
             round: round === null || round === void 0 ? void 0 : round.key,
         });
         if (addressed.length > 0)
-            console.log(`addressed ${addressed.length} comment(s) on variant ${from} in round ${(_e = round === null || round === void 0 ? void 0 : round.key) !== null && _e !== void 0 ? _e : ''}: ${addressed.map(({ id }) => id).join(', ')}`);
+            console.log(`addressed ${addressed.length} comment(s) on variant ${from} in round ${(_f = round === null || round === void 0 ? void 0 : round.key) !== null && _f !== void 0 ? _f : ''}: ${addressed.map(({ id }) => id).join(', ')}`);
         return 0;
     });
 };
@@ -339,9 +411,10 @@ const listed = (context) => {
                     ? `, picked ${sketch.decision.variant}`
                     : ', discard asked'
                 : '';
-            const rejected = sketch.variants.filter((variant) => (0, sketch_1.rejectionOf)(sketch, variant));
+            const rejected = sketch.variants.filter((variant) => { var _a; return ((_a = (0, sketch_1.rejectionOf)(sketch, variant)) === null || _a === void 0 ? void 0 : _a.status) !== 'withdrawn' && (0, sketch_1.rejectionOf)(sketch, variant); });
+            const withdrawnKeys = sketch.variants.filter((variant) => { var _a; return ((_a = (0, sketch_1.rejectionOf)(sketch, variant)) === null || _a === void 0 ? void 0 : _a.status) === 'withdrawn'; });
             const extra = sketch.targets.slice(1);
-            console.log(`${sketch.product}  ${sketch.target}${extra.length > 0 ? ` (+ ${extra.join(', ')})` : ''}  ${sketch.status}  ${sketch.variants.join(', ')}${decided}${rejected.length > 0 ? `, rejected ${rejected.join(', ')}` : ''}${sketch.hold ? `, held until: ${sketch.hold.until}` : ''}`);
+            console.log(`${sketch.product}  ${sketch.target}${extra.length > 0 ? ` (+ ${extra.join(', ')})` : ''}  ${sketch.status}  ${sketch.variants.join(', ')}${decided}${rejected.length > 0 ? `, rejected ${rejected.join(', ')}` : ''}${withdrawnKeys.length > 0 ? `, withdrawn ${withdrawnKeys.join(', ')}` : ''}${sketch.hold ? `, held until: ${sketch.hold.until}` : ''}`);
             for (const round of sketch.rounds) {
                 const variants = sketch.variants.filter((variant) => { var _a; return ((_a = sketch.variantInfo[variant]) === null || _a === void 0 ? void 0 : _a.round) === round.key; });
                 console.log(`  ${round.key}  ${round.title}  ${variants.join(', ')}${round.note === '' ? '' : `  - ${round.note}`}${round.lost ? `  - lost: ${round.lost}` : ''}`);
@@ -358,13 +431,23 @@ const reported = (context) => withSketch(context, ({ sketch }) => {
     const author = (0, cli_args_1.authorOf)(context.args);
     const done = context.args.flags.has('--done');
     if ((message === '' && !done) || !variant || !author)
-        return fail(`usage: sketch report <layer>/<name> --variant <key> --by <model id> (<text> | --done) [--product <name>] - --product is needed when config.json declares more than one product`);
+        return fail(`usage: sketch report <layer>/<name> --variant <key> --by <model id> (<text> | --done) [--reopen] [--product <name>] - --product is needed when config.json declares more than one product`);
     if (done) {
+        const notReady = roundNoteRefusalOf(sketch) === null ? roundNotReadyProblemOf(sketch) : null;
+        if (notReady !== null)
+            return fail(notReady);
         (0, sketch_1.finishSketchReport)({ checkout: context.target, sketch, variant });
         console.log(`${sketch.target} variant ${variant} marked done`);
         return 0;
     }
-    const reported = (0, sketch_1.reportSketch)({ checkout: context.target, sketch, variant, author, message });
+    const reported = (0, sketch_1.reportSketch)({
+        checkout: context.target,
+        sketch,
+        variant,
+        author,
+        message,
+        reopen: context.args.flags.has('--reopen'),
+    });
     if (typeof reported === 'string')
         return fail(reported);
     console.log(`reported on ${sketch.target} variant ${variant}: ${message}${sketch.status === 'ready' ? ' - back in progress, mark it ready again when done' : ''}`);
@@ -391,6 +474,17 @@ const roundEdited = (context) => withSketch(context, ({ sketch }) => {
     return 0;
 });
 const noteEdited = (context) => withSketch(context, ({ sketch }) => {
+    const round = context.args.values['--round'];
+    if (round !== undefined) {
+        const roundNote = context.args.positional.slice(1).join(' ').trim();
+        if (roundNote === '')
+            return fail('usage: sketch note <layer>/<name> --round <round> <text> --by <model id>');
+        const reworded = (0, sketch_1.editRound)({ sketch, round, note: roundNote });
+        if (typeof reworded === 'string')
+            return fail(reworded);
+        console.log(`${reworded.target} round ${round}: ${roundNote}`);
+        return 0;
+    }
     const [, variant, ...words] = context.args.positional;
     const note = words.join(' ').trim();
     if (!variant || note === '')
@@ -401,10 +495,46 @@ const noteEdited = (context) => withSketch(context, ({ sketch }) => {
     console.log(`${edited.target} variant ${variant}: ${note}`);
     return 0;
 });
+const coversEdited = (context) => withSketch(context, ({ sketch }) => {
+    var _a, _b;
+    const covers = context.args.positional.slice(1);
+    const partProblem = (0, covered_diffs_1.coverPartProblemOf)({ sketch, covers });
+    if (partProblem !== null) {
+        console.error(partProblem);
+        return 2;
+    }
+    const edited = (0, covered_diffs_1.editCovers)({ sketch, covers });
+    if (typeof edited === 'string')
+        return fail(edited);
+    console.log(((_a = edited.covers) !== null && _a !== void 0 ? _a : []).length === 0
+        ? `${edited.target} covers no compare DIFF`
+        : `${edited.target} covers the compare DIFFs of ${((_b = edited.covers) !== null && _b !== void 0 ? _b : []).join(', ')} while it is open (ADR 0222)`);
+    return 0;
+});
+const targetRemoved = (context) => {
+    const usage = `usage: ${exports.SKETCH_USAGE.find((line) => line.startsWith('sketch target remove'))}`;
+    const rest = context.args.positional.slice(1);
+    const [, part] = rest;
+    if (rest.length !== 2 || !part)
+        return fail(usage);
+    const parsed = (0, sketch_1.parseTarget)(part);
+    if (typeof parsed === 'string')
+        return fail(parsed);
+    return withSketch(Object.assign(Object.assign({}, context), { args: Object.assign(Object.assign({}, context.args), { positional: rest }) }), ({ sketch }) => {
+        const removed = (0, sketch_1.removeTarget)({ sketch, part: parsed });
+        if (typeof removed === 'string')
+            return fail(removed);
+        (0, check_format_1.formatSketch)({ target: context.target, sketch: removed, variants: removed.variants });
+        console.log(`${removed.target} now targets ${removed.targets.join(', ')}`);
+        return 0;
+    });
+};
 const targetAdded = (context) => {
     const [action, ...rest] = context.args.positional;
     const [, part] = rest;
     const usage = `usage: ${exports.SKETCH_USAGE.find((line) => line.startsWith('sketch target '))}`;
+    if (action === 'remove')
+        return targetRemoved(context);
     if (action !== 'add' || rest.length !== 2 || !part)
         return fail(usage);
     const parsed = (0, sketch_1.parseTarget)(part);
@@ -420,6 +550,31 @@ const targetAdded = (context) => {
         return 0;
     });
 };
+const readyLockOf = (sketch) => (0, path_1.resolve)((0, os_1.tmpdir)(), `et-sketch-ready-${(0, crypto_1.createHash)('sha256').update(sketch.dir).digest('hex').slice(0, 16)}.lock`);
+const isRunning = (pid) => {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (_a) {
+        return false;
+    }
+};
+const lockedReady = (sketch) => {
+    const lock = readyLockOf(sketch);
+    const holder = Number(contentOf(lock));
+    if (holder > 0 && isRunning(holder))
+        return null;
+    (0, fs_1.writeFileSync)(lock, String(process.pid));
+    return () => (0, fs_1.rmSync)(lock, { force: true });
+};
+const reportedReopen = (sketch) => {
+    const reopened = (0, sketch_1.reopenChangedReady)(sketch);
+    if (!reopened)
+        return sketch;
+    console.log(`${sketch.target} was ready; ${reopened.changed.join(', ')} changed since - back to in progress`);
+    return reopened.sketch;
+};
 const readied = (context) => {
     const found = productAndSketchOf(context);
     if (typeof found === 'string')
@@ -427,39 +582,122 @@ const readied = (context) => {
     const hold = (0, sketch_1.heldProblemOf)(found.sketch);
     if (hold !== null)
         return fail(hold);
-    const refused = readyRefusalOf(context, found);
+    const reopened = reportedReopen(found.sketch);
+    const current = { product: found.product, sketch: reopened };
+    const refused = (0, phase_timing_1.timedPhase)('gates', () => readyRefusalOf(context, current));
     if (refused !== null)
         return refused;
-    return renderedAndReady(context, found);
+    const unlinted = (0, phase_timing_1.timedPhase)('lint', () => (0, design_lint_1.lintGateLinesOf)({
+        target: context.target,
+        productDir: current.product.dir,
+        files: (0, design_lint_1.variantLintFilesOf)(reopened, reopened.variants.filter((variant) => !(0, sketch_1.rejectionOf)(reopened, variant))),
+    }));
+    if (unlinted.length > 0)
+        return fail(`${unlinted.join('\n')}\n${reopened.target} adds lint warnings - fix them before ready`);
+    const unlock = lockedReady(reopened);
+    if (!unlock)
+        return fail(`another sketch ready run on ${reopened.target} is going - wait for it`);
+    const run = context.warm
+        ? { warm: Object.assign(Object.assign({}, context.warm), { perRun: true }), close: () => __awaiter(void 0, void 0, void 0, function* () { return undefined; }) }
+        : (0, warm_draw_1.createRunDraw)(context.target);
+    return renderedAndReady(Object.assign(Object.assign({}, context), { warm: run.warm }), current).finally(() => __awaiter(void 0, void 0, void 0, function* () {
+        unlock();
+        yield run.close();
+    }));
 };
 const renderedAndReady = (context, found) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a;
     const { product, sketch } = found;
-    const rendered = yield renderedVariantsOf({
+    const rendered = yield (0, phase_timing_1.timedPhase)('render-check', () => renderedVariantsOf({
         target: context.target,
         config: context.config,
         product,
-        entries: sketch.variants.map((variant) => ({ sketch, variant })),
+        entries: sketch.variants
+            .filter((variant) => !(0, sketch_1.rejectionOf)(sketch, variant))
+            .map((variant) => ({ sketch, variant })),
         drawn: false,
-    });
+        warm: context.warm,
+    }));
+    if ('issues' in rendered && rendered.noVerdict)
+        return 1;
     if ('issues' in rendered && rendered.issues.length > 0)
         return fail(`${sketch.target} has problems - fix them before ready`);
+    const busyAdded = 'issues' in rendered ? openPointLinesOf({ product, sketch, busy: (_a = rendered.busy) !== null && _a !== void 0 ? _a : [] }).added : [];
+    if (busyAdded.length > 0)
+        return fail(`${busyAdded.join('\n')}\n${sketch.target} adds open points - close them before ready`);
     return loadedAndReady(context, found);
 });
 const loadedAndReady = (context_1, _a) => __awaiter(void 0, [context_1, _a], void 0, function* (context, { product, sketch }) {
-    var _b;
-    const unloaded = yield (0, ready_shots_1.variantsThatDoNotLoad)({ target: context.target, config: context.config, product, sketch });
+    var _b, _c;
+    const unloaded = yield (0, phase_timing_1.timedPhase)('load', () => unloadedLinesOf({ target: context.target, config: context.config, product, sketch, warm: context.warm }));
     if (unloaded.length > 0)
-        return fail(`${unloaded.map((line) => `${sketch.target} ${line}`).join('\n')}\n${sketch.target} does not load - fix it before ready`);
+        return fail(`${unloaded.join('\n')}\n${sketch.target} does not load - fix it before ready`);
+    const drifts = yield (0, phase_timing_1.timedPhase)('mark-drift', () => (0, ready_shots_1.sampleMarkDriftLines)({ target: context.target, config: context.config, product, sketch, warm: context.warm }));
+    if (drifts.length > 0)
+        return fail(`${drifts.join('\n')}\n${sketch.target} draws one sample with different marks - align them before ready`);
+    const identical = yield (0, phase_timing_1.timedPhase)('identical', () => (0, ready_shots_1.identicalRenderLines)({ target: context.target, config: context.config, product, sketch, warm: context.warm }));
+    if (identical.length > 0)
+        return fail(`${identical.join('\n')}\n${sketch.target} draws variants alike - fix them before ready`);
+    const undeclared = yield (0, phase_timing_1.timedPhase)('undeclared', () => undeclaredLinesOf({ target: context.target, config: context.config, product, sketch, warm: context.warm }));
+    if (typeof undeclared === 'string')
+        return fail(undeclared);
+    if (undeclared.length > 0)
+        return fail(`${undeclared.join('\n')}\n${sketch.target} draws controls no controls entry declares - declare them before ready`);
+    const changes = sketch.targets.every((key) => product.parts.some((part) => (0, resolve_product_1.partKeyOf)(part) === key))
+        ? yield (0, phase_timing_1.timedPhase)('changes-shot', () => (0, ready_shots_1.variantChangesShown)({ target: context.target, config: context.config, product, sketch, warm: context.warm }))
+        : null;
+    const unviewed = Array.isArray(changes)
+        ? (0, viewed_shots_1.unviewedShotLinesOf)({
+            target: context.target,
+            invocation: (_b = context.invocation) !== null && _b !== void 0 ? _b : (0, invocation_1.repoInvocation)({ root: context.target, subcommand: 'design' }),
+            sketch,
+            changes,
+        })
+        : [];
+    if (unviewed.length > 0)
+        return fail(`${unviewed.join('\n')}\n${sketch.target} draws a pixel diff - view its shot before ready`);
+    if (!(0, fs_1.existsSync)((0, path_1.resolve)(sketch.dir, sketch_1.SKETCH_FILE)))
+        return fail(`${sketch.target} is gone: another run merged or discarded it while this one checked it`);
     const ready = sketch.status === 'ready'
         ? sketch
-        : (0, sketch_1.markSketchReady)({ checkout: context.target, sketch, author: (_b = (0, cli_args_1.authorOf)(context.args)) !== null && _b !== void 0 ? _b : undefined });
+        : (0, sketch_1.markSketchReady)({ checkout: context.target, sketch, author: (_c = (0, cli_args_1.authorOf)(context.args)) !== null && _c !== void 0 ? _c : undefined });
     if (typeof ready === 'string')
         return fail(ready);
-    return autoMerged({ context, product, sketch: ready, again: sketch.status === 'ready' });
+    return (0, phase_timing_1.timedPhase)('auto-merge', () => autoMerged({ context, product, sketch: ready, again: sketch.status === 'ready', changes }));
 });
-const autoMerged = (options) => __awaiter(void 0, void 0, void 0, function* () {
-    var _a, _b;
-    const { context, product, sketch, again } = options;
+const stillReady = (options) => {
+    (0, sketch_1.writeSketchFile)(Object.assign(Object.assign({}, options.sketch), { mergeHold: { reason: options.reason, at: new Date().toISOString() } }));
+    if (options.again)
+        console.log(`${options.sketch.target} is still ready`);
+    return 0;
+};
+const gitIn = (target, ...args) => (0, plain_output_1.spawnPlain)(['git', ...args], { cwd: target });
+const mergeDirsOf = (product) => [product.dir, ...(product.base ? [product.base.dir] : [])];
+const cleanBesideSketch = (options) => {
+    const status = gitIn(options.target, 'status', '--porcelain', '-z', '--untracked-files=all', '--', ...mergeDirsOf(options.product));
+    const root = gitIn(options.target, 'rev-parse', '--show-toplevel');
+    if (status.status !== 0 || root.status !== 0)
+        return false;
+    const top = root.stdout.trim();
+    const sketchDir = (0, fs_1.realpathSync)(options.sketch.dir);
+    return status.stdout
+        .split('\0')
+        .filter((entry) => /^.. /.test(entry))
+        .every((entry) => (0, path_1.resolve)(top, entry.slice(3)).startsWith(`${sketchDir}/`));
+};
+const committedMerge = (options) => {
+    const dirs = mergeDirsOf(options.product);
+    const added = gitIn(options.target, 'add', '--all', '--', ...dirs);
+    const committed = added.status === 0
+        ? gitIn(options.target, 'commit', '-m', `feat(repo): Merge ${options.sketch.target}, no visible change`, '--', ...dirs)
+        : added;
+    if (committed.status !== 0)
+        console.warn(`Could not commit the merge: ${(committed.stderr || committed.stdout).trim()}`);
+    return committed.status === 0;
+};
+const autoMerged = (options) => {
+    var _a;
+    const { context, product, sketch, again, changes } = options;
     if (!again)
         console.log(`${sketch.target} is ready`);
     for (const variant of sketch.variants.filter((candidate) => !(0, sketch_1.rejectionOf)(sketch, candidate))) {
@@ -467,70 +705,191 @@ const autoMerged = (options) => __awaiter(void 0, void 0, void 0, function* () {
         if (shared.length > 0)
             console.log(`variant ${variant}: a shared/ edit reaches ${shared.join(', ')}`);
     }
-    if (!sketch.targets.every((key) => product.parts.some((part) => (0, resolve_product_1.partKeyOf)(part) === key))) {
-        console.log('auto-merge skipped: new part, the user merges');
-        return again ? fail(`${sketch.target} is ready, not in progress`) : 0;
-    }
-    const noChange = yield (0, ready_shots_1.shotsShowNoChange)({ target: context.target, config: context.config, product, sketch });
+    const noChange = changes === null ? 'new part, the user merges' : typeof changes === 'string' ? changes : (0, no_visible_change_1.noChangeOf)(changes);
     if (noChange !== true) {
         console.log(`auto-merge skipped: ${noChange}`);
-        return again ? fail(`${sketch.target} is ready, not in progress`) : 0;
+        return stillReady({ sketch, again, reason: noChange });
     }
-    const author = (_a = (0, cli_args_1.authorOf)(context.args)) !== null && _a !== void 0 ? _a : undefined;
-    const variant = (_b = sketch.variants.find((candidate) => !(0, sketch_1.rejectionOf)(sketch, candidate))) !== null && _b !== void 0 ? _b : '';
-    const decided = (0, sketch_1.decideSketch)({ sketch, decision: { kind: 'pick', variant } });
+    return mergedUnchanged({
+        target: context.target,
+        config: context.config,
+        author: (_a = (0, cli_args_1.authorOf)(context.args)) !== null && _a !== void 0 ? _a : undefined,
+        product,
+        sketch,
+    });
+};
+const mergedUnchanged = (options) => {
+    var _a;
+    const { target, config, author, product, sketch } = options;
+    const variant = (_a = sketch.variants.find((candidate) => !(0, sketch_1.rejectionOf)(sketch, candidate))) !== null && _a !== void 0 ? _a : '';
+    const commit = cleanBesideSketch({ target, product, sketch });
+    const decided = (0, sketch_1.decideSketch)({ sketch, decision: Object.assign({ kind: 'pick', variant }, (0, write_origin_1.originOf)(author !== null && author !== void 0 ? author : '')) });
     if (typeof decided === 'string')
         return fail(decided);
-    const result = (0, merge_1.mergeSketch)({ target: context.target, config: context.config, product, sketch: decided, author });
+    const written = sharedFilesOf(product);
+    const before = written.map((file) => contentOf(file));
+    const result = (0, merge_1.mergeSketch)({
+        target,
+        config,
+        product,
+        sketch: decided,
+        author,
+        decidedBy: 'auto: no visible change',
+    });
     if (!Array.isArray(result)) {
+        (0, sketch_1.writeSketchFile)(Object.assign(Object.assign({}, sketch), { mergeHold: Object.assign({ reason: result.reason, at: new Date().toISOString() }, (result.dirty ? { dirty: result.dirty } : {})) }));
         console.warn(`${sketch.target} shows no visible change but did not merge: ${result.reason}`);
         return 0;
     }
-    for (const part of sketch.targets)
-        (0, merged_parts_1.recordAutoMerge)({ product, part, by: author !== null && author !== void 0 ? author : 'user' });
     console.log(`No visible change in any state: merged ${sketch.targets.join(', ')} automatically.`);
+    if (commit && committedMerge({ target, product, sketch })) {
+        console.log(`Committed: feat(repo): Merge ${sketch.target}, no visible change`);
+        return 0;
+    }
+    commitHunksLines({
+        target,
+        files: written.filter((file, index) => contentOf(file) !== before[index]),
+        parts: sketch.targets,
+    }).forEach((line) => console.log(line));
     return 0;
+};
+const stillDirtyOf = (options) => {
+    const status = gitIn(options.target, 'status', '--porcelain', '--untracked-files=all', '--', ...options.dirty);
+    return status.status !== 0 || status.stdout.trim() !== '';
+};
+/**
+ * Merges every ready sketch whose automatic merge uncommitted files refused, once those files are committed or
+ * reverted; `except` is a sketch target to leave alone.
+ */
+const retriedHeldMerges = (options) => {
+    var _a;
+    const { target, config, author, except } = options;
+    for (const name of Object.keys((_a = config.products) !== null && _a !== void 0 ? _a : {})) {
+        const productDir = (0, product_1.productDirOf)({ target, product: name });
+        const held = (0, sketch_1.listSketches)({ productDir, product: name }).filter((sketch) => {
+            var _a;
+            return typeof sketch !== 'string' &&
+                sketch.status === 'ready' &&
+                !!((_a = sketch.mergeHold) === null || _a === void 0 ? void 0 : _a.dirty) &&
+                sketch.target !== except &&
+                !stillDirtyOf({ target, dirty: sketch.mergeHold.dirty });
+        });
+        if (held.length === 0)
+            continue;
+        const product = (0, cli_args_1.oneProductOf)({ target, config, asked: name });
+        if (typeof product === 'string')
+            continue;
+        for (const sketch of held) {
+            console.log(`${sketch.target}: the uncommitted edits that held its automatic merge are gone - merging it now`);
+            mergedUnchanged({ target, config, author, product, sketch });
+        }
+    }
+};
+exports.retriedHeldMerges = retriedHeldMerges;
+const contentOf = (file) => ((0, fs_1.existsSync)(file) ? (0, fs_1.readFileSync)(file, 'utf8') : null);
+const sharedFilesOf = (product) => [
+    (0, path_1.resolve)(product.dir, merged_parts_1.MERGED_FILE),
+    ...(product.base ? [(0, path_1.resolve)(product.base.dir, merged_parts_1.MERGED_FILE)] : []),
+];
+const commitHunksLines = ({ target, files, parts }) => files.length === 0
+    ? []
+    : [
+        'Shared files written; commit only the hunks of this sketch, never the whole file another session also edits:',
+        ...files.map((file) => `  et design commit-hunks ${(0, path_1.relative)(target, file)} ${parts.map((part) => `--part ${part}`).join(' ')}`),
+    ];
+const noteProblemsBefore = ({ target, sketch, variant, before, }) => before.forEach((problem) => console.warn(`NOTE ${sketch.target} ${variant}: ${problem.rule} ${(0, path_1.relative)(target, problem.file)}: ${problem.message} (there before)`));
+const variantGateProblemsOf = (options) => [...options.problems, ...(0, check_format_1.formatProblemsOf)(options), ...(0, unused_closure_1.unusedInVariantOf)(options)];
+const busyOfVariant = (busy, sketch) => busy
+    .filter((entry) => { var _a; return ((_a = entry.sketch) === null || _a === void 0 ? void 0 : _a.target) === sketch.target && entry.sketch.variant === sketch.variant; })
+    .map(({ part, state }) => ({ part, state }));
+const openPointLinesOf = ({ product, sketch, busy = [], }) => {
+    const pointLinesOf = (variant, list) => (0, open_points_1.openPointsText)(product.name, list)
+        .slice(1)
+        .map((line) => `${sketch.target} ${variant}: ${line.trim()}`);
+    const points = sketch.variants
+        .filter((variant) => !(0, sketch_1.rejectionOf)(sketch, variant))
+        .map((variant) => (Object.assign({ variant }, (0, read_open_points_1.sketchOpenPointsOf)({
+        merged: product,
+        variant: (0, overlay_1.overlaySketch)({ product, sketch, variant }),
+        targets: sketch.targets,
+        busy: { merged: [], variant: busyOfVariant(busy, { target: sketch.target, variant }) },
+    }))));
+    return {
+        added: points.flatMap(({ variant, added }) => pointLinesOf(variant, added)),
+        inherited: points.flatMap(({ variant, inherited }) => pointLinesOf(variant, inherited)),
+    };
+};
+const roundNoteRefusalOf = (sketch) => {
+    const running = (0, sketch_1.runningRoundOf)(sketch);
+    return running.note.trim() === ''
+        ? `${sketch.target} round ${running.key} has no note - set it with: sketch round ${sketch.target} ${running.key} --note "<what the round shows>" --by <model id>`
+        : null;
+};
+const roundNotReadyProblemOf = (sketch) => sketch.status === 'ready' || sketch.hold
+    ? null
+    : `ROUND-NOT-READY ${sketch.target}: round ${(0, sketch_1.runningRoundOf)(sketch).key} is drawn but still in progress - run \`design sketch ready ${sketch.target}\``;
+const unloadedLinesOf = (options) => __awaiter(void 0, void 0, void 0, function* () { return (yield (0, ready_shots_1.variantsThatDoNotLoad)(options)).map((line) => `${options.sketch.target} ${line}`); });
+const undeclaredLinesOf = (options) => __awaiter(void 0, void 0, void 0, function* () {
+    const { sketch } = options;
+    const lines = [];
+    for (const variant of sketch.variants.filter((name) => !(0, sketch_1.rejectionOf)(sketch, name))) {
+        const { changed } = (0, merge_preview_1.mergePreviewOf)({ product: options.product, sketch, variant });
+        const added = yield (0, complete_1.addedUndeclaredControlsOf)(Object.assign(Object.assign({}, options), { sketch: { target: sketch.target, variant }, parts: changed }));
+        if ('unavailable' in added)
+            return added.unavailable;
+        lines.push(...added.lines);
+    }
+    return lines;
 });
-const noteProblemsBefore = ({ sketch, variant, before }) => {
-    if (before.length > 0)
-        console.warn(`NOTE ${sketch.target} ${variant}: ${before.length} problem${before.length === 1 ? ' was' : 's were'} there before (design check lists them)`);
+const baseCommitOf = (options) => {
+    var _a;
+    const { context, product, sketch } = options;
+    const dirs = ((_a = (0, stale_base_1.staleBaseOf)({ product, sketch })) !== null && _a !== void 0 ? _a : []).flatMap((key) => {
+        const part = product.parts.find((candidate) => (0, resolve_product_1.partKeyOf)(candidate) === key);
+        return part ? [(0, path_1.dirname)(part.file)] : [];
+    });
+    if (dirs.length === 0)
+        return null;
+    const log = (0, plain_output_1.spawnPlain)(['git', 'log', '-1', '--format=%h', '--', ...dirs], { cwd: context.target });
+    return log.status === 0 && log.stdout.trim() ? log.stdout.trim() : null;
 };
 const readyRefusalOf = (context, { product, sketch }) => {
     const lineOf = (variant, problem) => `${sketch.target} ${variant}: ${problem.rule} ${(0, path_1.relative)(context.target, problem.file)}: ${problem.message}`;
+    const stale = staleBasesOf(context, { product, targets: new Set([sketch.target]) });
+    if (stale.length > 0) {
+        const commit = baseCommitOf({ context, product, sketch });
+        return fail(`${stale.map((problem) => problem.line).join('\n')}\n${sketch.target} is stale${commit ? ` (base changed in ${commit})` : ''} - rebase it before ready`);
+    }
     const found = (0, check_sketches_1.variantProblemsOf)({ product, sketch });
-    found.forEach(noteProblemsBefore);
-    const problems = found.flatMap(({ variant, problems }) => [
-        ...problems,
-        ...(0, check_format_1.formatProblemsOf)({ target: context.target, sketch, variant }),
-        ...((0, sketch_1.rejectionOf)(sketch, variant) ? [] : (0, unused_closure_1.unusedInVariantOf)({ product, sketch, variant })),
-    ].map((problem) => lineOf(variant, problem)));
+    found.forEach((entry) => noteProblemsBefore(Object.assign({ target: context.target }, entry)));
+    const problems = found
+        .filter(({ variant }) => !(0, sketch_1.rejectionOf)(sketch, variant))
+        .flatMap(({ variant, problems }) => variantGateProblemsOf({ target: context.target, product, sketch, variant, problems }).map((problem) => lineOf(variant, problem)));
     sketch.variants.forEach((variant) => (0, check_sketches_1.variantWarningsOf)({ target: context.target, product, sketch, variant }).forEach((warning) => console.warn(`${sketch.target} ${variant}: ${warning}`)));
     if (problems.length > 0)
         return fail(`${problems.join('\n')}\n${sketch.target} has problems - fix them before ready`);
-    const pointLinesOf = (variant, list) => (0, open_points_1.openPointsText)(product.name, list)
-        .slice(1)
-        .map((line) => `${sketch.target} ${variant}: ${line.trim()}`);
-    const open = sketch.variants
+    const { added, inherited } = openPointLinesOf({ product, sketch });
+    inherited.forEach((line) => console.log(`NOTE ${line} (inherited from the merged part)`));
+    sketch.variants
         .filter((variant) => !(0, sketch_1.rejectionOf)(sketch, variant))
-        .flatMap((variant) => {
-        const { added, inherited } = (0, read_open_points_1.sketchOpenPointsOf)({
-            merged: product,
-            variant: (0, overlay_1.overlaySketch)({ product, sketch, variant }),
-            targets: sketch.targets,
-        });
-        pointLinesOf(variant, inherited).forEach((line) => console.log(`NOTE ${line} (inherited from the merged part)`));
-        return pointLinesOf(variant, added);
-    });
-    if (open.length > 0)
-        return fail(`${open.join('\n')}\n${sketch.target} adds open points - close them before ready`);
-    const running = (0, sketch_1.runningRoundOf)(sketch);
-    if (running.note.trim() === '')
-        return fail(`${sketch.target} round ${running.key} has no note - set it with: sketch round ${sketch.target} ${running.key} --note "<what the round shows>" --by <model id>`);
-    return null;
+        .forEach((variant) => (0, read_open_points_1.instantLinesOf)((0, overlay_1.overlaySketch)({ product, sketch, variant }), sketch.targets).forEach((line) => console.log(`NOTE ${sketch.target} ${variant}: ${line}`)));
+    if (added.length > 0)
+        return fail(`${added.join('\n')}\n${sketch.target} adds open points - close them before ready`);
+    const noNote = roundNoteRefusalOf(sketch);
+    return noNote === null ? null : fail(noNote);
 };
 const rebased = (context) => withSketch(context, ({ product, sketch }) => {
+    const kept = context.args.flags.has('--ported');
+    const { ported, conflicts } = (0, rebase_port_1.portBaseChanges)({ target: context.target, product, sketch, keepConflicts: kept });
+    if (kept)
+        conflicts.forEach((line) => console.log(`KEPT ${line} (ported by hand)`));
+    else if (conflicts.length > 0)
+        return fail(`${conflicts.join('\n')}\n${sketch.target} not rebased - port these by hand, then run sketch rebase again`);
+    ported.forEach(({ variant, file, how }) => console.log(`PORTED ${variant}: ${file} (${how})`));
     (0, sketch_1.rebaseSketch)({ product, sketch });
     console.log(`${sketch.target} now compares with the product as it is`);
+    if (ported.length > 0 && sketch.status === 'ready')
+        console.log(`variants changed - run sketch ready ${sketch.target} to check them again`);
     return 0;
 });
 const held = (context) => withSketch(context, ({ sketch }) => {
@@ -552,19 +911,44 @@ const released = (context) => withSketch(context, ({ sketch }) => {
     console.log(`${freed.target} is no longer held - mark it ready once the change is in`);
     return 0;
 });
-const renderedVariantsOf = (_a) => __awaiter(void 0, [_a], void 0, function* ({ target, config, product, entries, drawn, }) {
-    var _b, _c;
+const beforeLinesOf = ({ sketches, before }) => [...new Set(sketches)].flatMap((sketch) => (0, render_check_1.groupedIssueLinesOf)(before
+    .filter((issue) => sketch.targets.includes(issue.part))
+    .map((issue) => (Object.assign(Object.assign({}, issue), { sketch: { target: sketch.target, variant: 'before' } })))));
+exports.beforeLinesOf = beforeLinesOf;
+const unchangedAffectedOf = (options) => (0, warm_draw_1.loadingOn)(options, (server) => __awaiter(void 0, void 0, void 0, function* () {
+    return Object.fromEntries(yield Promise.all(options.affected.map((part) => __awaiter(void 0, void 0, void 0, function* () {
+        return [
+            part,
+            yield (0, unchanged_states_1.unchangedStatesOf)(Object.assign(Object.assign({}, options), { part, load: ({ file, product, sketch }) => server.ssrLoadModule((0, system_modules_1.productModuleIdOf)({ file, product, sketch })) })),
+        ];
+    }))));
+}));
+const renderedVariantsOf = (_a) => __awaiter(void 0, [_a], void 0, function* ({ target, config, product, entries, drawn, warm, }) {
+    var _b, _c, _d;
+    const jobs = yield Promise.all(entries.map((_a) => __awaiter(void 0, [_a], void 0, function* ({ sketch, variant }) {
+        const preview = (0, merge_preview_1.mergePreviewOf)({ product, sketch, variant });
+        return {
+            product: product.name,
+            sketch: { target: sketch.target, variant },
+            parts: [...preview.changed, ...preview.affected],
+            unchanged: warm
+                ? yield unchangedAffectedOf({ target, config, warm, product, sketch, variant, affected: preview.affected })
+                : {},
+        };
+    })));
+    for (const { sketch, unchanged } of jobs)
+        for (const [part, states] of Object.entries(unchanged).filter(([, states]) => states.length > 0))
+            console.log(`NOTE ${sketch.target} ${sketch.variant}: ${part} draws ${states.length} state${states.length === 1 ? '' : 's'} as merged, not inspected`);
     const rendered = yield (0, render_check_1.renderIssuesOf)({
         target,
         config,
-        jobs: entries.map(({ sketch, variant }) => {
-            const preview = (0, merge_preview_1.mergePreviewOf)({ product, sketch, variant });
-            return {
-                product: product.name,
-                sketch: { target: sketch.target, variant },
-                parts: [...preview.changed, ...preview.affected],
-            };
-        }),
+        warm,
+        jobs,
+        onProgress: (line) => console.error(line),
+        before: [...new Set(entries.flatMap(({ sketch }) => sketch.targets))].map((part) => ({
+            product: product.name,
+            part,
+        })),
     });
     if ('unavailable' in rendered)
         console.log(`RENDER CHECK SKIPPED - ${rendered.unavailable}`);
@@ -587,36 +971,55 @@ const renderedVariantsOf = (_a) => __awaiter(void 0, [_a], void 0, function* ({
         if (drawn)
             rendered.grids.forEach(({ sketch, part, line }) => { var _a, _b; return console.log(`${(_a = sketch === null || sketch === void 0 ? void 0 : sketch.target) !== null && _a !== void 0 ? _a : ''} ${(_b = sketch === null || sketch === void 0 ? void 0 : sketch.variant) !== null && _b !== void 0 ? _b : ''}: ${part} ${line}`); });
         rendered.warnings.forEach((issue) => { var _a, _b, _c, _d; return console.warn(`${(_b = (_a = issue.sketch) === null || _a === void 0 ? void 0 : _a.target) !== null && _b !== void 0 ? _b : ''} ${(_d = (_c = issue.sketch) === null || _c === void 0 ? void 0 : _c.variant) !== null && _d !== void 0 ? _d : ''}: WARNING ${(0, render_check_1.renderIssueLineOf)(issue)}`); });
-        (0, render_check_1.groupedIssueLinesOf)(rendered.issues).forEach((line) => console.error(line));
+        const { noVerdict } = rendered;
+        if (noVerdict)
+            [...new Set(entries.map((entry) => entry.sketch.target))].forEach((sketchTarget) => console.error((0, no_verdict_1.noVerdictLineOf)(sketchTarget, noVerdict)));
+        else
+            (0, render_check_1.groupedIssueLinesOf)(rendered.issues).forEach((line) => console.error(line));
+        (0, exports.beforeLinesOf)({ sketches: entries.map((entry) => entry.sketch), before: (_d = rendered.before) !== null && _d !== void 0 ? _d : [] }).forEach((line) => console.log(line));
     }
     return rendered;
 });
 const checked = (context) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a, _b;
     const { target, config, args } = context;
     const product = sketchProductOf(context);
     if (typeof product === 'string')
         return fail(product);
     const asked = args.positional[0];
-    const { unreadable, variants } = (0, check_sketches_1.openSketchProblemsOf)(product);
-    const chosen = asked === undefined ? variants : variants.filter((entry) => entry.sketch.target === asked);
-    if (asked !== undefined && chosen.length === 0)
+    const { unreadable, variants } = (0, phase_timing_1.timedPhase)('gates', () => (0, check_sketches_1.openSketchProblemsOf)(product));
+    const named = asked === undefined ? variants : variants.filter((entry) => entry.sketch.target === asked);
+    if (asked !== undefined && named.length === 0)
         return fail(`NO SKETCH on ${asked} in ${product.name}`);
+    const isSkipped = ({ sketch, variant }) => Boolean((0, sketch_1.rejectionOf)(sketch, variant));
+    const chosen = named.filter((entry) => !isSkipped(entry));
+    named
+        .filter(isSkipped)
+        .forEach(({ sketch, variant }) => {
+        var _a;
+        return console.log(`NOTE ${sketch.target} ${variant}: ${((_a = (0, sketch_1.rejectionOf)(sketch, variant)) === null || _a === void 0 ? void 0 : _a.status) === 'withdrawn' ? 'withdrawn' : 'rejected'}, not checked`);
+    });
     if (args.flags.has('--fix'))
         new Set(chosen.map((entry) => entry.sketch)).forEach((sketch) => (0, check_format_1.formatSketch)({ target, sketch, variants: sketch.variants }));
     let failed = asked === undefined && unreadable.length > 0;
     if (asked === undefined)
         unreadable.forEach((problem) => console.error(`${problem.rule} ${(0, path_1.relative)(target, problem.file)}: ${problem.message}`));
     new Set(chosen.map((entry) => entry.sketch)).forEach((sketch) => {
+        reportedReopen(sketch);
+        if (product.config.noteLanguage)
+            (0, note_language_1.noteLanguageWarningsOf)(sketch, product.config.noteLanguage).forEach((warning) => console.warn(warning));
         if (sketch.hold)
             console.warn(`HELD ${sketch.target}: until ${sketch.hold.until}`);
     });
+    const stale = staleBasesOf(context, { product, targets: new Set(chosen.map((entry) => entry.sketch.target)) });
+    stale.forEach((problem) => console.error(problem.line));
+    failed || (failed = stale.length > 0);
     for (const { sketch, variant, problems, before } of chosen) {
-        const typed = (0, check_sketches_1.typecheckVariant)({ target, product, sketch, variant });
-        noteProblemsBefore({ sketch, variant, before });
+        const typed = (0, phase_timing_1.timedPhase)(`tsc ${variant}`, () => (0, check_sketches_1.typecheckVariant)({ target, product, sketch, variant }));
+        noteProblemsBefore({ target, sketch, variant, before });
         (0, check_sketches_1.variantWarningsOf)({ target, product, sketch, variant }).forEach((warning) => console.warn(`${sketch.target} ${variant}: ${warning}`));
         const all = [
-            ...problems,
-            ...(0, check_format_1.formatProblemsOf)({ target, sketch, variant }),
+            ...variantGateProblemsOf({ target, product, sketch, variant, problems }),
             ...(typed.kind === 'failed' ? [{ rule: 'TYPE-ERROR', file: sketch.dir, message: `\n${typed.output}` }] : []),
             ...(typed.kind === 'unavailable' ? [{ rule: 'NO-TYPE-CHECKER', file: sketch.dir, message: typed.message }] : []),
         ];
@@ -625,18 +1028,68 @@ const checked = (context) => __awaiter(void 0, void 0, void 0, function* () {
         }
         failed || (failed = all.length > 0);
     }
-    if (failed)
+    if (!failed)
+        for (const sketch of new Set(chosen.map((entry) => entry.sketch)))
+            (yield (0, phase_timing_1.timedPhase)('aktuell', () => (0, ready_shots_1.aktuellPlaceholderWarnings)({ target, config, product, sketch, warm: context.warm }))).forEach((warning) => console.warn(warning));
+    const rendered = failed
+        ? null
+        : yield (0, phase_timing_1.timedPhase)('render-check', () => renderedVariantsOf({
+            target,
+            config,
+            product,
+            entries: chosen,
+            drawn: true,
+            warm: context.warm,
+        }));
+    const busy = rendered !== null && 'issues' in rendered ? ((_a = rendered.busy) !== null && _a !== void 0 ? _a : []) : [];
+    if (rendered !== null && 'issues' in rendered)
+        (0, frame_budget_1.frameBudgetWarningsOf)({
+            drawn: rendered.drawn,
+            targets: [...new Set(chosen.map((entry) => entry.sketch))].map((sketch) => {
+                var _a;
+                return ({
+                    target: sketch.target,
+                    part: (_a = sketch.targets[0]) !== null && _a !== void 0 ? _a : sketch.target,
+                });
+            }),
+        }).forEach((warning) => console.warn(warning));
+    let refused = 0;
+    let notReady = false;
+    const refuse = (lines) => {
+        lines.forEach((line) => console.warn(`ready will refuse: ${line}`));
+        refused += lines.length;
+    };
+    for (const sketch of new Set(chosen.map((entry) => entry.sketch))) {
+        const unloaded = yield (0, phase_timing_1.timedPhase)('load', () => unloadedLinesOf({ target, config, product, sketch, warm: context.warm }));
+        const before = refused;
+        refuse([
+            ...unloaded,
+            ...openPointLinesOf({ product, sketch, busy }).added,
+            ...[(_b = roundNoteRefusalOf(sketch)) !== null && _b !== void 0 ? _b : []].flat(),
+        ]);
+        if (!failed && unloaded.length === 0) {
+            refuse(yield (0, phase_timing_1.timedPhase)('mark-drift', () => (0, ready_shots_1.sampleMarkDriftLines)({ target, config, product, sketch, warm: context.warm })));
+            refuse(yield (0, phase_timing_1.timedPhase)('identical', () => (0, ready_shots_1.identicalRenderLines)({ target, config, product, sketch, warm: context.warm })));
+        }
+        if (!failed && refused === before) {
+            const problem = roundNotReadyProblemOf(sketch);
+            if (problem !== null) {
+                console.error(problem);
+                notReady = true;
+            }
+        }
+    }
+    const staleSince = rendered === null
+        ? []
+        : staleBasesOf(context, { product, targets: new Set(chosen.map((entry) => entry.sketch.target)) }).filter((problem) => !stale.some((before) => before.line === problem.line));
+    staleSince.forEach((problem) => console.error(problem.line));
+    if (failed || staleSince.length > 0)
         return 1;
-    const rendered = yield renderedVariantsOf({
-        target,
-        config,
-        product,
-        entries: chosen,
-        drawn: true,
-    });
-    if ('issues' in rendered && rendered.issues.length > 0)
+    if (rendered !== null && 'issues' in rendered && (rendered.noVerdict || rendered.issues.length > 0))
+        return 1;
+    if (notReady)
         return 1;
-    console.log('ok');
+    console.log(refused > 0 ? `check ok - ready will refuse ${refused} (see above)` : 'ok');
     return 0;
 });
 const previewed = (context) => withSketch(context, ({ product, sketch }) => {
@@ -655,39 +1108,36 @@ const previewed = (context) => withSketch(context, ({ product, sketch }) => {
     }
     return 0;
 });
-const allowedMergeOf = (options) => {
-    const { sketch, variant } = options;
-    const live = sketch.variants.filter((candidate) => !(0, sketch_1.rejectionOf)(sketch, candidate));
-    if (live.length !== 1 || live[0] !== variant)
-        return `${sketch.target} has ${live.length} live variants (${live.join(', ') || 'none'}), not only "${variant}" - the user picks in Studio`;
-    return (0, sketch_1.decideSketch)({ sketch, decision: { kind: 'pick', variant } });
-};
 const merged = (context) => withSketch(context, ({ product, sketch }) => {
-    var _a, _b, _c, _d;
-    const { '--note': note, '--variant': flagVariant, '--allowed-by': planRef } = context.args.values;
+    var _a, _b;
+    const { '--note': note, '--variant': flagVariant, '--allowed-by': planRef, '--decided-by': decidedBy, } = context.args.values;
+    const replaceNote = context.args.flags.has('--replace-note');
     if (context.args.positional.length > 1)
         return fail(`usage: sketch merge <layer>/<name> [--note <reason>] - it merges the variant the user picked`);
+    if (replaceNote && (note !== null && note !== void 0 ? note : '').trim() === '')
+        return fail('--replace-note needs --note <the new part note>');
     if ((flagVariant === undefined) !== (planRef === undefined))
         return fail('--variant and --allowed-by go together: name the only live variant and the plan that allows the merge');
-    const allowed = flagVariant !== undefined && planRef !== undefined && ((_a = sketch.decision) === null || _a === void 0 ? void 0 : _a.kind) !== 'pick';
-    const decidedSketch = allowed ? allowedMergeOf({ sketch, variant: flagVariant }) : sketch;
-    if (typeof decidedSketch === 'string')
-        return fail(decidedSketch);
-    const result = (0, merge_1.mergeSketch)({
+    if (decidedBy !== undefined && (decidedBy.trim() === '' || planRef !== undefined))
+        return fail('--decided-by needs a name and does not go with --allowed-by, which records the plan');
+    const by = (_a = (0, cli_args_1.authorOf)(context.args)) !== null && _a !== void 0 ? _a : undefined;
+    const allowed = flagVariant !== undefined && planRef !== undefined && ((_b = sketch.decision) === null || _b === void 0 ? void 0 : _b.kind) !== 'pick'
+        ? { variant: flagVariant, planRef, editRef: (0, merge_step_1.editRefOf)({ target: context.target, sketch, planRef }) }
+        : undefined;
+    const result = (0, phase_timing_1.timedPhase)('merge', () => (0, merge_step_1.mergeAndRecord)({
         target: context.target,
         config: context.config,
         product,
-        sketch: decidedSketch,
+        sketch,
         note,
-        author: (_b = (0, cli_args_1.authorOf)(context.args)) !== null && _b !== void 0 ? _b : undefined,
-    });
-    if (!Array.isArray(result))
-        return fail(result.reason);
-    if (allowed)
-        for (const part of sketch.targets)
-            (0, merged_parts_1.recordAllowedMerge)({ product, part, by: (_c = (0, cli_args_1.authorOf)(context.args)) !== null && _c !== void 0 ? _c : 'user', planRef: planRef.trim() });
-    const variant = ((_d = decidedSketch.decision) === null || _d === void 0 ? void 0 : _d.kind) === 'pick' ? decidedSketch.decision.variant : '';
-    console.log(`merged ${sketch.target} variant ${variant} into ${product.name}: ${result.join(', ')}`);
+        replaceNote,
+        by,
+        decidedBy: decidedBy === null || decidedBy === void 0 ? void 0 : decidedBy.trim(),
+        allowed,
+    }));
+    if (typeof result === 'string')
+        return fail(result);
+    console.log(`merged ${sketch.target} variant ${result.variant} into ${product.name}: ${result.parts.join(', ')}`);
     return 0;
 });
 const discarded = (context) => withSketch(context, ({ sketch }) => {
@@ -701,27 +1151,37 @@ const discarded = (context) => withSketch(context, ({ sketch }) => {
 const verdictOriginOf = (by, of) => of && of !== by ? ` (reason by the ${of})` : '';
 /** The verdicts a variant had, oldest first, and whether it is rejected now. */
 const verdictLinesOf = (sketch, variant) => {
-    var _a, _b;
+    var _a, _b, _c;
     const history = (_b = (_a = sketch.rejections) === null || _a === void 0 ? void 0 : _a[variant]) !== null && _b !== void 0 ? _b : [];
-    const lines = history.flatMap((rejection) => [
-        `  rejected by the ${rejection.by} at ${rejection.decidedAt}${verdictOriginOf(rejection.by, rejection.reasonBy)}${rejection.reason ? `: ${rejection.reason}` : ''}`,
-        ...(rejection.reopened
-            ? [
-                `  reopened by the ${rejection.reopened.by} at ${rejection.reopened.decidedAt}${rejection.reopened.reason ? `: ${rejection.reopened.reason}` : ''}`,
-            ]
-            : []),
-    ]);
-    return [`${sketch.target} variant ${variant}: ${(0, sketch_1.rejectionOf)(sketch, variant) ? 'rejected' : 'live'}`, ...lines];
+    const lines = history.flatMap((rejection) => {
+        var _a;
+        return [
+            `  ${rejection.status === 'withdrawn' ? `withdrawn by ${(_a = rejection.withdrawnBy) !== null && _a !== void 0 ? _a : 'the agent'}` : `rejected by the ${rejection.by}`} at ${rejection.decidedAt}${verdictOriginOf(rejection.by, rejection.reasonBy)}${rejection.reason ? `: ${rejection.reason}` : ''}`,
+            ...(rejection.reopened
+                ? [
+                    `  reopened by the ${rejection.reopened.by} at ${rejection.reopened.decidedAt}${rejection.reopened.reason ? `: ${rejection.reopened.reason}` : ''}`,
+                ]
+                : []),
+        ];
+    });
+    return [
+        `${sketch.target} variant ${variant}: ${(0, sketch_1.rejectionOf)(sketch, variant) ? (((_c = (0, sketch_1.rejectionOf)(sketch, variant)) === null || _c === void 0 ? void 0 : _c.status) === 'withdrawn' ? 'withdrawn' : 'rejected') : 'live'}`,
+        ...lines,
+    ];
 };
 exports.verdictLinesOf = verdictLinesOf;
 const judged = (kind) => (context) => withSketch(context, ({ sketch }) => {
-    var _a;
+    var _a, _b;
     const { positional, values } = context.args;
     const variant = values['--variant'];
     const reason = ((_a = values['--reason']) === null || _a === void 0 ? void 0 : _a.trim()) || undefined;
-    const by = (0, cli_args_1.authorOf)(context.args) === 'designer' ? 'designer' : 'agent';
+    const author = (_b = (0, cli_args_1.authorOf)(context.args)) !== null && _b !== void 0 ? _b : '';
+    const by = author === 'designer' ? 'designer' : 'agent';
     if (positional.length !== 1 || !variant)
         return fail(`usage: sketch ${kind} <layer>/<name> --variant <key> [--reason <text>] --by <model id | designer> [--product <name>]`);
+    const invalid = (0, cli_args_1.verdictByProblemOf)(author);
+    if (invalid)
+        return fail(invalid);
     const decision = kind === 'reject' && reason && (0, sketch_1.rejectionOf)(sketch, variant)
         ? { kind: 'reason', variant, reason, by }
         : Object.assign(Object.assign({ kind, variant }, (reason ? { reason } : {})), { by });
@@ -731,11 +1191,50 @@ const judged = (kind) => (context) => withSketch(context, ({ sketch }) => {
     (0, exports.verdictLinesOf)(decided, variant).forEach((line) => console.log(line));
     return 0;
 });
+const withdrawn = (context) => {
+    const found = productAndSketchOf(context);
+    if (typeof found === 'string')
+        return fail(found);
+    return withdrawnVariant(context, found);
+};
+const withdrawnVariant = (context_1, _a) => __awaiter(void 0, [context_1, _a], void 0, function* (context, { product, sketch }) {
+    var _b;
+    const { positional, values } = context.args;
+    const variant = values['--variant'];
+    const by = (_b = (0, cli_args_1.authorOf)(context.args)) !== null && _b !== void 0 ? _b : '';
+    if (positional.length !== 1 || !variant)
+        return fail('usage: sketch withdraw <layer>/<name> --variant <key> --by <model id> [--product <name>]');
+    if (by === 'designer')
+        return fail('sketch withdraw is for the agent that drew the variant: --by must be a model id, not designer');
+    const invalid = (0, cli_args_1.verdictByProblemOf)(by);
+    if (invalid)
+        return fail(invalid);
+    if (!sketch.variants.includes(variant))
+        return fail(`${sketch.target} has no variant "${variant}" - it has ${sketch.variants.join(', ')}`);
+    if (!(0, sketch_1.authorsOf)(sketch, variant).includes(by))
+        return fail(`${sketch.target} variant ${variant} was not drawn by ${by} - only the agent that drew it withdraws it`);
+    const identical = yield (0, ready_shots_1.identicalRenders)({
+        target: context.target,
+        config: context.config,
+        product,
+        sketch,
+        warm: context.warm,
+    });
+    const twin = identical.find((render) => render.variant === variant && render.sibling !== null);
+    if (!twin)
+        return fail(`${sketch.target} variant ${variant} does not draw the same pixels as a sibling variant in its first changed state - redraw it or ask for a reject`);
+    const result = (0, sketch_1.withdrawVariant)({ sketch, variant, by, reason: `identisch mit ${twin.sibling}` });
+    if (typeof result === 'string')
+        return fail(result);
+    console.log(`withdrew ${sketch.target} variant ${variant} (identisch mit ${twin.sibling})`);
+    return 0;
+});
 const COMMANDS = {
     new: created,
     variant: varied,
     round: roundEdited,
     note: noteEdited,
+    covers: coversEdited,
     list: listed,
     report: reported,
     ready: readied,
@@ -749,32 +1248,29 @@ const COMMANDS = {
     target: targetAdded,
     reject: judged('reject'),
     reopen: judged('reopen'),
+    withdraw: withdrawn,
+};
+/** The value flags and switches the usage line of a sketch command names. */
+const flagsOf = (command) => {
+    var _a;
+    const line = (_a = exports.SKETCH_USAGE.find((usage) => usage.startsWith(`sketch ${command} `))) !== null && _a !== void 0 ? _a : '';
+    const named = [...line.matchAll(/(--[a-z-]+)( (?=[<a-z0-9]))?/gu)];
+    const unique = (flags) => [...new Set(flags)];
+    return {
+        values: unique(named.filter(([, , value]) => value).map(([, flag]) => flag !== null && flag !== void 0 ? flag : '')),
+        switches: unique(named.filter(([, , value]) => !value).map(([, flag]) => flag !== null && flag !== void 0 ? flag : '')),
+    };
 };
 /**
  * `et design sketch <command> …` opens, adds variants to, reports on, readies, checks, previews, rebases, merges and
- * discards sketches, and rejects and reopens their variants.
+ * discards sketches, and rejects, reopens and withdraws their variants.
  */
 const designSketch = (options) => {
-    const { target, argv, invocation } = options;
+    var _a, _b;
+    const { target, argv, invocation, warm } = options;
     const [command = '', ...rest] = argv;
     const run = COMMANDS[command];
-    const args = (0, cli_args_1.argsOf)(rest, [
-        '--product',
-        '--variants',
-        '--note',
-        '--variant',
-        '--by',
-        '--from',
-        '--round',
-        '--round-note',
-        '--title',
-        '--like',
-        '--drops',
-        '--variant-note',
-        '--reason',
-        '--allowed-by',
-        '--until',
-    ]);
+    const args = (0, cli_args_1.argsOf)(rest, flagsOf(command));
     const unauthored = typeof args !== 'string' && WRITES.has(command) && (0, cli_args_1.authorOf)(args) === null;
     if (!run || typeof args === 'string' || unauthored) {
         if (typeof args === 'string')
@@ -789,7 +1285,16 @@ const designSketch = (options) => {
     const config = (0, cli_args_1.configOf)(target);
     if (typeof config === 'string')
         return fail(config);
-    return run({ target, config, args });
+    if (RETRIES.has(command)) {
+        const named = (0, sketch_1.parseTarget)((_a = args.positional[0]) !== null && _a !== void 0 ? _a : '');
+        (0, exports.retriedHeldMerges)({
+            target,
+            config,
+            author: (_b = (0, cli_args_1.authorOf)(args)) !== null && _b !== void 0 ? _b : undefined,
+            except: typeof named === 'string' ? undefined : (0, resolve_product_1.partKeyOf)(named),
+        });
+    }
+    return run({ target, config, args, invocation, warm });
 };
 exports.designSketch = designSketch;
 //# sourceMappingURL=sketch-command.js.map