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

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

@@ -20,61 +20,76 @@ 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.sketchFlagHelpOf = exports.SKETCH_USAGE = void 0;
 const unused_closure_1 = require("./system/sketch/unused-closure");
+const fs_1 = require("fs");
 const path_1 = require("path");
 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 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 viewed_shots_1 = require("./system/sketch/viewed-shots");
 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 invocation_1 = require("../invocation");
 const merged_parts_1 = require("./system/sketch/merged-parts");
 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 rebase_port_1 = require("./system/sketch/rebase-port");
+const theming_text_1 = require("./system/theming-text");
 const sketch_1 = require("./system/sketch/sketch");
 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] [--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 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>] --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',
+    '--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',
     '--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',
+    '--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 +99,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,7 +109,7 @@ 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',
@@ -180,6 +195,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 +215,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'],
@@ -228,14 +247,17 @@ const nextStepsOf = (sketch, product) => {
     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}`,
+        `  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, go.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) => {
@@ -339,9 +361,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 +381,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' : ''}`);
@@ -401,10 +434,30 @@ const noteEdited = (context) => withSketch(context, ({ sketch }) => {
     console.log(`${edited.target} variant ${variant}: ${note}`);
     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);
@@ -433,33 +486,61 @@ const readied = (context) => {
     return renderedAndReady(context, found);
 };
 const renderedAndReady = (context, found) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a;
     const { product, sketch } = found;
     const rendered = yield 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,
     });
     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 unloadedLinesOf({ target: context.target, config: context.config, product, sketch });
     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, ready_shots_1.sampleMarkDriftLines)({ target: context.target, config: context.config, product, sketch });
+    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, ready_shots_1.identicalRenderLines)({ target: context.target, config: context.config, product, sketch });
+    if (identical.length > 0)
+        return fail(`${identical.join('\n')}\n${sketch.target} draws variants alike - fix them before ready`);
+    const changes = sketch.targets.every((key) => product.parts.some((part) => (0, resolve_product_1.partKeyOf)(part) === key))
+        ? yield (0, ready_shots_1.variantChangesShown)({ target: context.target, config: context.config, product, sketch })
+        : 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`);
     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 autoMerged({ context, product, sketch: ready, again: sketch.status === 'ready', changes });
 });
-const autoMerged = (options) => __awaiter(void 0, void 0, void 0, function* () {
+const stillReady = (options) => {
+    if (options.again)
+        console.log(`${options.sketch.target} is still ready`);
+    return 0;
+};
+const autoMerged = (options) => {
     var _a, _b;
-    const { context, product, sketch, again } = options;
+    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 +548,120 @@ 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))) {
+    if (changes === null) {
         console.log('auto-merge skipped: new part, the user merges');
-        return again ? fail(`${sketch.target} is ready, not in progress`) : 0;
+        return stillReady({ sketch, again });
     }
-    const noChange = yield (0, ready_shots_1.shotsShowNoChange)({ target: context.target, config: context.config, product, sketch });
+    const noChange = 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 });
     }
     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 sketchFile = (0, path_1.resolve)(sketch.dir, sketch_1.SKETCH_FILE);
+    const undecided = (0, fs_1.readFileSync)(sketchFile, 'utf8');
     const decided = (0, sketch_1.decideSketch)({ sketch, decision: { kind: 'pick', variant } });
     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: context.target,
+        config: context.config,
+        product,
+        sketch: decided,
+        author,
+        decidedBy: 'auto: no visible change',
+    });
     if (!Array.isArray(result)) {
+        (0, fs_1.writeFileSync)(sketchFile, undecided);
         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.`);
+    commitHunksLines({
+        target: context.target,
+        files: written.filter((file, index) => contentOf(file) !== before[index]),
+        parts: sketch.targets,
+    }).forEach((line) => console.log(line));
     return 0;
-});
-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 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 readyRefusalOf = (context, { product, sketch }) => {
     const lineOf = (variant, problem) => `${sketch.target} ${variant}: ${problem.rule} ${(0, path_1.relative)(context.target, problem.file)}: ${problem.message}`;
     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,8 +683,12 @@ 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 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 renderedVariantsOf = (_a) => __awaiter(void 0, [_a], void 0, function* ({ target, config, product, entries, drawn, }) {
-    var _b, _c;
+    var _b, _c, _d;
     const rendered = yield (0, render_check_1.renderIssuesOf)({
         target,
         config,
@@ -565,6 +700,10 @@ const renderedVariantsOf = (_a) => __awaiter(void 0, [_a], void 0, function* ({
                 parts: [...preview.changed, ...preview.affected],
             };
         }),
+        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}`);
@@ -588,19 +727,29 @@ const renderedVariantsOf = (_a) => __awaiter(void 0, [_a], void 0, function* ({
             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));
+        (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, _c;
     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 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;
@@ -610,13 +759,19 @@ const checked = (context) => __awaiter(void 0, void 0, void 0, function* () {
         if (sketch.hold)
             console.warn(`HELD ${sketch.target}: until ${sketch.hold.until}`);
     });
+    const stale = (0, check_system_1.staleSketchBasesOf)({
+        product,
+        invocation: (_a = context.invocation) !== null && _a !== void 0 ? _a : (0, invocation_1.repoInvocation)({ root: target, subcommand: 'design' }),
+        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 });
+        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 +780,63 @@ const checked = (context) => __awaiter(void 0, void 0, void 0, function* () {
         }
         failed || (failed = all.length > 0);
     }
+    if (!failed)
+        for (const sketch of new Set(chosen.map((entry) => entry.sketch)))
+            (yield (0, ready_shots_1.aktuellPlaceholderWarnings)({ target, config, product, sketch })).forEach((warning) => console.warn(warning));
+    const rendered = failed
+        ? null
+        : yield renderedVariantsOf({
+            target,
+            config,
+            product,
+            entries: chosen,
+            drawn: true,
+        });
+    const busy = rendered !== null && 'issues' in rendered ? ((_b = rendered.busy) !== null && _b !== void 0 ? _b : []) : [];
+    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 unloadedLinesOf({ target, config, product, sketch });
+        const before = refused;
+        refuse([
+            ...unloaded,
+            ...openPointLinesOf({ product, sketch, busy }).added,
+            ...[(_c = roundNoteRefusalOf(sketch)) !== null && _c !== void 0 ? _c : []].flat(),
+        ]);
+        if (!failed && unloaded.length === 0) {
+            refuse(yield (0, ready_shots_1.sampleMarkDriftLines)({ target, config, product, sketch }));
+            refuse(yield (0, ready_shots_1.identicalRenderLines)({ target, config, product, sketch }));
+        }
+        if (!failed && refused === before) {
+            const problem = roundNotReadyProblemOf(sketch);
+            if (problem !== null) {
+                console.error(problem);
+                notReady = true;
+            }
+        }
+    }
     if (failed)
         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.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 +855,33 @@ 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;
+    var _a, _b;
     const { '--note': note, '--variant': flagVariant, '--allowed-by': planRef } = 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)({
+    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 }
+        : undefined;
+    const result = (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,
+        replaceNote,
+        by,
+        allowed,
     });
-    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(', ')}`);
+    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 +895,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,6 +935,38 @@ 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 });
+    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,
@@ -749,32 +985,28 @@ 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;
     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 +1021,7 @@ const designSketch = (options) => {
     const config = (0, cli_args_1.configOf)(target);
     if (typeof config === 'string')
         return fail(config);
-    return run({ target, config, args });
+    return run({ target, config, args, invocation });
 };
 exports.designSketch = designSketch;
 //# sourceMappingURL=sketch-command.js.map