tumwater 0.4.1 → 0.4.2

package/dist/src/cli/cli-command-args.js

@@ -247,19 +247,19 @@ const PROMPT_FLAG_SPECS = [
     { names: ["--attach"], value: true, valueName: "<path>" },
     { names: ["--grep"], value: true, valueName: "<text>" },
 ];
-/** `tumwater prompt` argument handling, following parseInitArgs' pattern. Like init's,
- * positionals are free-form prompt content — but a double-dash token must be a real flag
- * (`--role <id>`, `--list`, `--json`, `--grep <text>`, `--cancel <n>`, `--edit <n>`,
- * `--top <n>`, `--file <path>`, `--at <duration>`), or
- * it would be baked into the queued prompt (the same class of bug parseInitArgs fixed: today
- * `tumwater prompt --foo text` enqueues "--foo text"). Single-dash positionals remain prompt
- * content. `--list`, `--cancel`, `--edit` and `--top` are mutually exclusive and may
- * not combine with positional text; `--role` is accepted in every mode and is never
- * prompt content. `--at <duration>` (PLANS.md "tumwater prompt --at <duration>") only queues
- * a prompt: it defers delivery — parsed here with parseDurationFlag, riding the enqueue as
- * the queue file's not-before marker — so the read-only and destructive modes refuse it
- * rather than silently ignore it. */
-export function parsePromptArgs(args) {
+/** The six `--list`/`--cancel`/`--edit`/`--top` mode pairs that may not combine, in today's
+ * exact order. */
+const PROMPT_MODE_EXCLUSIONS = [
+    ["--list", "--cancel"],
+    ["--list", "--edit"],
+    ["--cancel", "--edit"],
+    ["--list", "--top"],
+    ["--cancel", "--top"],
+    ["--edit", "--top"],
+];
+/** The flag-vocabulary gate and the once-check: the unknown-double-dash gate, the ten index
+ * collections and rejectDuplicateFlags's once-check all ride here, one scan, one home. */
+function scanPromptFlags(args) {
     // The unknown-double-dash gate reads PROMPT_FLAG_SPECS, so the list its error names admits
     // exactly what the duplicate-flag check below accepts — one vocabulary, one message renderer.
     rejectUnknownDoubleDash("prompt", args, PROMPT_FLAG_SPECS);
@@ -276,21 +276,30 @@ export function parsePromptArgs(args) {
     // --attach is repeatable: every occurrence claims itself and its value token, like --role's
     // single pair, so the pairs ride out of the prompt text in every mode.
     const attachFlags = args.flatMap((a, i) => (a === "--attach" ? [i] : []));
+    const roleFlag = args.indexOf("--role");
     const known = PROMPT_FLAG_SPECS.flatMap((s) => s.names).filter((f) => f !== "--attach"); // repeatable: the once-check skips it
     rejectDuplicateFlags(args, known);
-    if (listFlag >= 0 && cancelFlag >= 0)
-        fail("--list and --cancel are mutually exclusive");
-    if (listFlag >= 0 && editFlag >= 0)
-        fail("--list and --edit are mutually exclusive");
-    if (cancelFlag >= 0 && editFlag >= 0)
-        fail("--cancel and --edit are mutually exclusive");
-    if (listFlag >= 0 && topFlag >= 0)
-        fail("--list and --top are mutually exclusive");
-    if (cancelFlag >= 0 && topFlag >= 0)
-        fail("--cancel and --top are mutually exclusive");
-    if (editFlag >= 0 && topFlag >= 0)
-        fail("--edit and --top are mutually exclusive");
-    const roleFlag = args.indexOf("--role");
+    return { jsonFlags, listFlag, cancelFlag, editFlag, topFlag, fileFlag, atFlag, grepFlag, attachFlags, roleFlag };
+}
+/** The six mode mutual exclusions: the mutually-exclusive `--list`/`--cancel`/`--edit`/
+ * `--top` pairs, in the table's order, so the first failing pair reports as it did before. */
+function assertPromptModesDisjoint(scan) {
+    const index = {
+        "--list": scan.listFlag,
+        "--cancel": scan.cancelFlag,
+        "--edit": scan.editFlag,
+        "--top": scan.topFlag,
+    };
+    for (const [a, b] of PROMPT_MODE_EXCLUSIONS) {
+        // All four keys are always present in the object; ?? -1 just satisfies the strict
+        // indexed-access typing without changing the (never-undefined) compare.
+        if ((index[a] ?? -1) >= 0 && (index[b] ?? -1) >= 0)
+            fail(`${a} and ${b} are mutually exclusive`);
+    }
+}
+/** The `--role <id>` value pair: its raw value, its missing-value refusal and the pair it
+ * claims, verbatim. */
+function parsePromptRole(args, roleFlag) {
     const roleRaw = roleFlag >= 0 ? args[roleFlag + 1] : undefined;
     if (roleFlag >= 0 && (!roleRaw || roleRaw.startsWith("--")))
         fail(ROLE_VALUE_ERROR);
@@ -298,17 +307,30 @@ export function parsePromptArgs(args) {
     // The flag and its value are never prompt content: --role is a scope, not text. Only claimed
     // when actually present — negative indexes would over-claim real tokens.
     const roleClaim = roleFlag >= 0 ? [roleFlag, roleFlag + 1] : [];
+    return { role, roleClaim };
+}
+/** The `--json` list-only refusal: in enqueue or cancel mode it must never silently ride
+ * along as prompt text (or beside a state change). */
+function assertPromptJsonListOnly(scan) {
     // --json is list-only: in enqueue or cancel mode it must never silently ride along as
     // prompt text (or beside a state change), so it is refused before either branch runs.
-    if (jsonFlags.length > 0 && listFlag < 0)
+    if (scan.jsonFlags.length > 0 && scan.listFlag < 0)
         fail("--json only applies to --list");
-    if (grepFlag >= 0 && listFlag < 0)
+}
+/** The `--grep <text>` value pair and its list-only refusal, verbatim. */
+function parsePromptGrep(args, scan) {
+    if (scan.grepFlag >= 0 && scan.listFlag < 0)
         fail("--grep only applies to --list");
-    const grepRaw = grepFlag >= 0 ? args[grepFlag + 1] : undefined;
-    if (grepFlag >= 0 && (!grepRaw || grepRaw.startsWith("--"))) {
+    const grepRaw = scan.grepFlag >= 0 ? args[scan.grepFlag + 1] : undefined;
+    if (scan.grepFlag >= 0 && (!grepRaw || grepRaw.startsWith("--"))) {
         fail("--grep needs text (usage: tumwater prompt --list --grep <text>)");
     }
-    const grepClaim = grepFlag >= 0 ? [grepFlag, grepFlag + 1] : [];
+    const grepClaim = scan.grepFlag >= 0 ? [scan.grepFlag, scan.grepFlag + 1] : [];
+    return { grepRaw, grepClaim };
+}
+/** The queue-only-mode refusals: --file and --at have nothing to mean except in the enqueue
+ * mode, and --attach is refused by --list and --cancel (--edit accepts it). */
+function assertPromptQueueOnlyFlags(scan) {
     // The queue-only flags --file and --at have nothing to mean in the read-only and destructive
     // modes (--list and --cancel): --file is the file-shaped twin of free-form text (--edit
     // accepts it as its replacement text, so the editFlag test below exempts that one mode), and
@@ -318,16 +340,16 @@ export function parsePromptArgs(args) {
     // predicate and the `<flag> only queues a prompt` wording, so a new mode or queue-only flag
     // is added here.
     const refuseQueueOnlyFlag = (flag, present) => {
-        if (present && (listFlag >= 0 || cancelFlag >= 0 || editFlag >= 0 || topFlag >= 0))
+        if (present && (scan.listFlag >= 0 || scan.cancelFlag >= 0 || scan.editFlag >= 0 || scan.topFlag >= 0))
             fail(`${flag} only queues a prompt`);
     };
-    refuseQueueOnlyFlag("--file", fileFlag >= 0 && editFlag < 0);
-    refuseQueueOnlyFlag("--at", atFlag >= 0);
-    refuseQueueOnlyFlag("--attach", attachFlags.length > 0 && editFlag < 0);
-    // An edit keeps the target prompt's existing deferral exactly as it was (the marker is
-    // plumbing the edit carries over), so a --at alongside it has nothing to mean.
-    // The pair is claimed like --role's: the flag and its value are never prompt content.
-    const atClaim = atFlag >= 0 ? [atFlag, atFlag + 1] : [];
+    refuseQueueOnlyFlag("--file", scan.fileFlag >= 0 && scan.editFlag < 0);
+    refuseQueueOnlyFlag("--at", scan.atFlag >= 0);
+    refuseQueueOnlyFlag("--attach", scan.attachFlags.length > 0 && scan.editFlag < 0);
+}
+/** The `--attach <path>` value pair(s): every occurrence claims itself and its value token,
+ * with the missing-value refusal, verbatim. */
+function parsePromptAttachments(args, attachFlags) {
     // Each --attach pair claims the flag and its value; a trailing flag with no value names the
     // flag here, like --cancel's missing-value wording, before any queue write.
     const attachPaths = attachFlags.map((i) => args[i + 1]);
@@ -336,6 +358,14 @@ export function parsePromptArgs(args) {
         if (args[i + 1] === undefined)
             fail(`--attach needs a path (e.g. \`--attach shot.png\`)`);
     }
+    return { attachPaths, attachClaims };
+}
+/** The `--at <duration>` parse and its 90-day cap, verbatim. */
+function parsePromptDeferral(args, atFlag) {
+    // An edit keeps the target prompt's existing deferral exactly as it was (the marker is
+    // plumbing the edit carries over), so a --at alongside it has nothing to mean.
+    // The pair is claimed like --role's: the flag and its value are never prompt content.
+    const atClaim = atFlag >= 0 ? [atFlag, atFlag + 1] : [];
     let atDelayMs = null;
     if (atFlag >= 0) {
         atDelayMs = parseDurationFlag("--at", args[atFlag + 1]);
@@ -344,75 +374,146 @@ export function parsePromptArgs(args) {
         // (about 106751991d from now) made notBeforeMarker's toISOString throw a raw RangeError.
         failOverDurationCap("--at", atDelayMs, PAUSE_FOR_MAX_MS);
     }
-    if (listFlag >= 0) {
-        failStrayArg(args, "with --list there is no prompt text", listFlag, ...jsonFlags, ...roleClaim, ...grepClaim);
-        return { mode: "list", role, json: jsonFlags.length > 0, grep: grepRaw ?? null };
-    }
-    if (cancelFlag >= 0) {
-        const n = parsePositionFlag("--cancel", args[cancelFlag + 1], "--cancel 2");
-        // The position is the only token --cancel may carry; anything else alongside it would be
-        // prompt text, and this mode has none.
-        failStrayArg(args, "with --cancel there is no prompt text", cancelFlag, cancelFlag + 1, ...roleClaim);
-        return { mode: "cancel", role, position: n };
-    }
-    if (editFlag >= 0) {
-        const n = parsePositionFlag("--edit", args[editFlag + 1], '--edit 2 "new text"');
-        // The --edit pair, the --role pair, and any --attach pairs are the only flags this mode
-        // claims. Tokens preceding --edit (other than a claimed flag) would be silently dropped —
-        // a mistyped command would edit prompt N with only the trailing fragment — so they are
-        // refused here by the same stray-argument wording the sibling modes use; tokens after the
-        // position are the replacement text, minus any claimed attach pair (none: edit in $EDITOR).
-        const fileClaim = fileFlag >= 0 ? [fileFlag, fileFlag + 1] : [];
-        for (let i = 0; i < editFlag; i++) {
-            if (roleClaim.includes(i) || attachClaims.includes(i) || fileClaim.includes(i))
-                continue;
-            fail(`unexpected argument ${JSON.stringify(args[i])} — with --edit the replacement text comes after the position`);
-        }
-        if (fileFlag >= 0) {
-            // The replacement comes from the file (`-` reads stdin), kept line for line; editPromptAtFile
-            // trims it. Typed text beside it would be ambiguous, so it is refused.
-            const file = promptFileValue(args[fileFlag + 1]);
-            failStrayArg(args, "with --file the replacement text comes from the file", editFlag, editFlag + 1, ...fileClaim, ...roleClaim, ...attachClaims);
-            return { mode: "edit", role, position: n, text: readPromptFileArg(file), attachPaths };
-        }
-        const textTokens = [];
-        for (let i = editFlag + 2; i < args.length; i++) {
-            if (roleClaim.includes(i) || attachClaims.includes(i))
-                continue;
-            textTokens.push(args[i]);
-        }
-        const text = textTokens.join(" ").trim();
-        // No text and no --file: the caller opens the prompt's current body in the editor.
-        return { mode: "edit", role, position: n, text: text === "" ? null : text, attachPaths };
+    return { atDelayMs, atClaim };
+}
+/** `tumwater prompt`'s flag scan and the checks it owns — everything shared by two or more
+ * modes, so a new mode or queue-only flag is added here: the unknown-double-dash gate, the
+ * index collection, the once-check, the six mutual exclusions, the --role pair, the
+ * --json/--grep list-only refusals, the queue-only-flag refusals, the --attach pairs and the
+ * --at parse and cap. Each job lives in one helper — scanPromptFlags, assertPromptModesDisjoint,
+ * parsePromptRole, assertPromptJsonListOnly, parsePromptGrep, assertPromptQueueOnlyFlags,
+ * parsePromptAttachments and parsePromptDeferral — so a check is found by name. Returns a
+ * struct the mode branches read. */
+function parsePromptFlags(args) {
+    const scan = scanPromptFlags(args);
+    assertPromptModesDisjoint(scan);
+    const { role, roleClaim } = parsePromptRole(args, scan.roleFlag);
+    assertPromptJsonListOnly(scan);
+    const { grepRaw, grepClaim } = parsePromptGrep(args, scan);
+    assertPromptQueueOnlyFlags(scan);
+    const { attachPaths, attachClaims } = parsePromptAttachments(args, scan.attachFlags);
+    const { atDelayMs, atClaim } = parsePromptDeferral(args, scan.atFlag);
+    return {
+        role,
+        jsonFlags: scan.jsonFlags,
+        listFlag: scan.listFlag,
+        cancelFlag: scan.cancelFlag,
+        editFlag: scan.editFlag,
+        topFlag: scan.topFlag,
+        fileFlag: scan.fileFlag,
+        grepRaw,
+        grepClaim,
+        roleClaim,
+        attachPaths,
+        attachClaims,
+        atDelayMs,
+        atClaim,
+    };
+}
+/** `--list`: the queue listing, optionally machine-readable and filtered by --grep. */
+function listPromptArgs(args, f) {
+    failStrayArg(args, "with --list there is no prompt text", f.listFlag, ...f.jsonFlags, ...f.roleClaim, ...f.grepClaim);
+    return { mode: "list", role: f.role, json: f.jsonFlags.length > 0, grep: f.grepRaw ?? null };
+}
+/** `--cancel <n>`: remove one entry by its 1-based queue position. */
+function cancelPromptArgs(args, f) {
+    const n = parsePositionFlag("--cancel", args[f.cancelFlag + 1], "--cancel 2");
+    // The position is the only token --cancel may carry; anything else alongside it would be
+    // prompt text, and this mode has none.
+    failStrayArg(args, "with --cancel there is no prompt text", f.cancelFlag, f.cancelFlag + 1, ...f.roleClaim);
+    return { mode: "cancel", role: f.role, position: n };
+}
+/** `--edit <n>`: rewrite one entry's text in place — the replacement is the --file contents,
+ * the tokens after the position, or (with neither) an editor open in the caller. */
+function editPromptArgs(args, f) {
+    const n = parsePositionFlag("--edit", args[f.editFlag + 1], '--edit 2 "new text"');
+    // The --edit pair, the --role pair, and any --attach pairs are the only flags this mode
+    // claims. Tokens preceding --edit (other than a claimed flag) would be silently dropped —
+    // a mistyped command would edit prompt N with only the trailing fragment — so they are
+    // refused here by the same stray-argument wording the sibling modes use; tokens after the
+    // position are the replacement text, minus any claimed attach pair (none: edit in $EDITOR).
+    const fileClaim = f.fileFlag >= 0 ? [f.fileFlag, f.fileFlag + 1] : [];
+    for (let i = 0; i < f.editFlag; i++) {
+        if (f.roleClaim.includes(i) || f.attachClaims.includes(i) || fileClaim.includes(i))
+            continue;
+        fail(`unexpected argument ${JSON.stringify(args[i])} — with --edit the replacement text comes after the position`);
     }
-    if (topFlag >= 0) {
-        const n = parsePositionFlag("--top", args[topFlag + 1], "--top 2");
-        // The position is the only token --top may carry; anything else alongside it would be
-        // prompt text, and this mode has none.
-        failStrayArg(args, "with --top there is no prompt text", topFlag, topFlag + 1, ...roleClaim);
-        return { mode: "top", role, position: n };
+    if (f.fileFlag >= 0) {
+        // The replacement comes from the file (`-` reads stdin), kept line for line; editPromptAtFile
+        // trims it. Typed text beside it would be ambiguous, so it is refused.
+        const file = promptFileValue(args[f.fileFlag + 1]);
+        failStrayArg(args, "with --file the replacement text comes from the file", f.editFlag, f.editFlag + 1, ...fileClaim, ...f.roleClaim, ...f.attachClaims);
+        return { mode: "edit", role: f.role, position: n, text: readPromptFileArg(file), attachPaths: f.attachPaths };
     }
-    if (fileFlag >= 0) {
-        // The file is the prompt: read it whole (a path of `-` reads stdin, so a pipe or heredoc
-        // works), following parseInitArgs' --file branch — the same claim/stray/read/empty shape,
-        // so the two commands speak one idiom. The stdin read is memoized at module level: cli.ts
-        // pre-parses prompt's args and cmdPrompt re-parses them, and a second readFileSync(0) on a
-        // drained pipe would see an empty prompt (readFileSync(0) fails with EAGAIN on a TTY's
-        // stdin; errorMessage names it, and the operator passes a real pipe instead).
-        const file = promptFileValue(args[fileFlag + 1]);
-        failStrayArg(args, "with --file the prompt comes from the file", fileFlag, fileFlag + 1, ...roleClaim, ...atClaim, ...attachClaims);
-        const contents = readPromptFileArg(file);
-        return { mode: "enqueue", role, text: contents, atDelayMs, attachPaths: attachPaths };
+    const textTokens = [];
+    for (let i = f.editFlag + 2; i < args.length; i++) {
+        if (f.roleClaim.includes(i) || f.attachClaims.includes(i))
+            continue;
+        textTokens.push(args[i]);
     }
+    const text = textTokens.join(" ").trim();
+    // No text and no --file: the caller opens the prompt's current body in the editor.
+    return { mode: "edit", role: f.role, position: n, text: text === "" ? null : text, attachPaths: f.attachPaths };
+}
+/** `--top <n>`: move one entry to the head of its role's queue. */
+function topPromptArgs(args, f) {
+    const n = parsePositionFlag("--top", args[f.topFlag + 1], "--top 2");
+    // The position is the only token --top may carry; anything else alongside it would be
+    // prompt text, and this mode has none.
+    failStrayArg(args, "with --top there is no prompt text", f.topFlag, f.topFlag + 1, ...f.roleClaim);
+    return { mode: "top", role: f.role, position: n };
+}
+/** `--file <path>`: enqueue the file's (or stdin's) whole contents as the prompt. */
+function filePromptArgs(args, f) {
+    // The file is the prompt: read it whole (a path of `-` reads stdin, so a pipe or heredoc
+    // works), following parseInitArgs' --file branch — the same claim/stray/read/empty shape,
+    // so the two commands speak one idiom. The stdin read is memoized at module level: cli.ts
+    // pre-parses prompt's args and cmdPrompt re-parses them, and a second readFileSync(0) on a
+    // drained pipe would see an empty prompt (readFileSync(0) fails with EAGAIN on a TTY's
+    // stdin; errorMessage names it, and the operator passes a real pipe instead).
+    const file = promptFileValue(args[f.fileFlag + 1]);
+    failStrayArg(args, "with --file the prompt comes from the file", f.fileFlag, f.fileFlag + 1, ...f.roleClaim, ...f.atClaim, ...f.attachClaims);
+    const contents = readPromptFileArg(file);
+    return { mode: "enqueue", role: f.role, text: contents, atDelayMs: f.atDelayMs, attachPaths: f.attachPaths };
+}
+/** The default mode: free-form text (minus the claimed --role/--at/--attach tokens) is joined
+ * and enqueued. */
+function enqueuePromptArgs(args, f) {
     // Everything except the --role pair and the --at pair is prompt text; the join keeps
     // multi-word requests as one string exactly like the pre-1/2 behavior.
     const text = args
-        .filter((_, i) => !roleClaim.includes(i) && !atClaim.includes(i) && !attachClaims.includes(i))
+        .filter((_, i) => !f.roleClaim.includes(i) && !f.atClaim.includes(i) && !f.attachClaims.includes(i))
         .join(" ")
         .trim();
     // Name the fix, like the sibling operator commands' usage errors (bug/plan carry their
     // BUG_USAGE/PLAN_USAGE lines): "prompt text required" alone never said what to type.
     if (!text)
         fail('prompt text required — usage: tumwater prompt "<text>" (add --role <id> to aim it at one role)');
-    return { mode: "enqueue", role, text, atDelayMs, attachPaths: attachPaths };
+    return { mode: "enqueue", role: f.role, text, atDelayMs: f.atDelayMs, attachPaths: f.attachPaths };
+}
+/** `tumwater prompt` argument handling, following parseInitArgs' pattern. Like init's,
+ * positionals are free-form prompt content — but a double-dash token must be a real flag
+ * (`--role <id>`, `--list`, `--json`, `--grep <text>`, `--cancel <n>`, `--edit <n>`,
+ * `--top <n>`, `--file <path>`, `--at <duration>`), or
+ * it would be baked into the queued prompt (the same class of bug parseInitArgs fixed: today
+ * `tumwater prompt --foo text` enqueues "--foo text"). Single-dash positionals remain prompt
+ * content. `--list`, `--cancel`, `--edit` and `--top` are mutually exclusive and may
+ * not combine with positional text; `--role` is accepted in every mode and is never
+ * prompt content. `--at <duration>` (PLANS.md "tumwater prompt --at <duration>") only queues
+ * a prompt: it defers delivery — parsed here with parseDurationFlag, riding the enqueue as
+ * the queue file's not-before marker — so the read-only and destructive modes refuse it
+ * rather than silently ignore it. */
+export function parsePromptArgs(args) {
+    const f = parsePromptFlags(args);
+    if (f.listFlag >= 0)
+        return listPromptArgs(args, f);
+    if (f.cancelFlag >= 0)
+        return cancelPromptArgs(args, f);
+    if (f.editFlag >= 0)
+        return editPromptArgs(args, f);
+    if (f.topFlag >= 0)
+        return topPromptArgs(args, f);
+    if (f.fileFlag >= 0)
+        return filePromptArgs(args, f);
+    return enqueuePromptArgs(args, f);
 }

package/dist/src/cli/cli-flag-specs.js

@@ -257,11 +257,8 @@ export function hasFollowFlag(args) {
 /** The `--ready` flag spec, accepted by `backlog`: keep only the entries no hold keeps from
  * being picked. Value-less, like STAT_FLAG. */
 export const READY_FLAG = { names: ["--ready"] };
-/** Force re-probing of every claimed image-input model in `tumwater doctor` (part 2/5),
- * bypassing the 7-day cache: `--reprobe` (a value-less flag like JSON_FLAG). */
-export const REPROBE_FLAG = { names: ["--reprobe"] };
 /** The `--problems` flag spec, accepted by `doctor`: print only the warn and fail rows. Value-less,
- * like REPROBE_FLAG. */
+ * like KILL_ORPHANS_FLAG. */
 export const PROBLEMS_FLAG = { names: ["--problems"] };
 /** The `--kill-orphans` flag spec, accepted by `doctor`: first kill the orphaned processes the
  * orphans check lists, each with its descendants. Value-less, like PROBLEMS_FLAG. */

package/dist/src/cli/cli-review-commands.js

@@ -4,7 +4,8 @@
  * `readPostReviews` reads a missing, torn or hand-edited file as the well-formed subset (or `[]`),
  * so the command prints the empty line in any directory. Read-only except the one destructive
  * `--accept <n>` mode, which removes the Nth entry the operator deliberately accepts unreviewed
- * (the action the at-risk alert's advice names); that mode adds no new ready-repo requirement to
+ * (the action the doctor's at-risk post-review row's advice names); that mode adds no new
+ * ready-repo requirement to
  * the read path and gates the write with `requireReadyRepo`. Unlike `cmdQueue`'s `--cancel`, the
  * read case still writes no file. */
 import { JSON_FLAG, ROLE_FLAG, rejectUnknownArgs, statusFlagSpec } from "./cli-flag-specs.js";

package/dist/src/cli/cli-role-command.js

@@ -17,7 +17,7 @@ import { renderRoleMarkdown } from "../roles/role-render.js";
 import { DIRECTOR_ROLE, unknownRoleMessage } from "../roles/roles.js";
 import { saveRoleNote } from "../agent/role-notes-write.js";
 import { roleNotesPath } from "../paths.js";
-import { errorMessage } from "../text/text.js";
+import { errorMessage, isExponentSpelling } from "../text/text.js";
 import { readPromptFileArg } from "./cli-command-args.js";
 import { canonicalRoleId } from "../roles/legacy-role-ids.js";
 import { INSTANCE_ROLES, baseRoleOf } from "../roles/runner-ids.js";
@@ -44,12 +44,6 @@ const CAP_SPEC = { names: ["--cap"], value: true, valueName: "<usd>" };
 function plainDecimalToJson(raw) {
     return /^\d*\.?\d+$/.test(raw) ? String(Number(raw)) : null;
 }
-/** Detect exponent spellings that the cap, interval and instances writes must reject
- * before JSON parsing can turn them into otherwise valid numeric config values. Other
- * invalid spellings fall through to the config validator, which names the key. */
-function isExponentSpelling(raw) {
-    return raw.trim() !== "" && plainDecimalToJson(raw) === null && /^\d+(\.\d+)?[eE][+-]?\d+$/.test(raw.trim());
-}
 /** `role`'s min-run-interval write flags: clear it, or set it to a second count (0 is
  * back-to-back). */
 const CLEAR_MIN_RUN_INTERVAL_SPEC = { names: ["--clear-min-run-interval"] };
@@ -327,7 +321,7 @@ export async function cmdRole(root, args) {
         // already a plain decimal, so the exponent form is exactly the silent-write set; hex,
         // negative and non-numeric spellings fall through to the write path, whose
         // validateConfig message names the key.
-        if (isExponentSpelling(cap))
+        if (isExponentSpelling(cap.trim()))
             fail(`${cfgKey} must be a plain dollar amount like 25, 12.50, or .5 — no +/-, exponent, or hex notation`);
         writeRoleConfigKey(root, base, clearCap, cap, cfgKey, "daily cap", (v) => plainDecimalToJson(v) ?? v, (v) => v);
         return;
@@ -354,7 +348,7 @@ export async function cmdRole(root, args) {
         // plain decimal, so the exponent form is exactly the silent-write set; hex, negative and
         // non-numeric spellings fall through to the write path, whose validateConfig message
         // names the key.
-        if (isExponentSpelling(secs))
+        if (isExponentSpelling(secs.trim()))
             fail(`${cfgKey} must be a plain second count like 300, 0.5, or .5 — no +/-, exponent, or hex notation`);
         writeRoleConfigKey(root, base, clearInterval, secs, cfgKey, "min run interval", (v) => plainDecimalToJson(v) ?? v, (v) => `${v}s`);
         return;
@@ -384,7 +378,7 @@ export async function cmdRole(root, args) {
         // or out ("9e0" → 9 too) — is refused here, while fractional, hex, negative and plain
         // out-of-range integer spellings fall through to the write path, whose validateConfig
         // message names the key.
-        if (isExponentSpelling(n))
+        if (isExponentSpelling(n.trim()))
             fail(`${cfgKey} must be a plain integer from 1 to 8 — no exponent notation`);
         // An absent count already means 1 (instanceCount's default), so asking for 1 is a no-op —
         // but only for a role that may split; any other role falls through to validateConfig's refusal.
@@ -396,47 +390,30 @@ export async function cmdRole(root, args) {
         writeRoleConfigKey(root, base, clearInstances, n, `roles.${base}.instances`, "instances", (v) => v, (v) => v);
         return;
     }
-    // The model-triple writes: the terminal twins of `config set roles.<base>.provider|model|thinking
-    // <value>` and `config unset` — the three fields configForRole resolves through seamOverrides.
-    // `tumwater role <id>` renders them as its Model: line. Each lands in roles.<base>.<field>.
-    // Through setConfigKey/unsetConfigKey, validateConfig's checkModelTripleField ("tier-name"
-    // shape) owns validation (model accepts a tier name; thinking must be a THINKING_LEVELS level)
-    // and each write is atomic. No director refusal: accepted exactly as --min-run-interval is.
-    if (providerWrite) {
-        rejectSetClearAndJson(rest, "--provider", "--clear-provider", "a provider write");
-        requireKnownRole(root, id);
-        const base = baseRoleOf(id);
-        const provider = flagValue(rest, "--provider") ?? "";
-        writeRoleConfigKey(root, base, clearProvider, provider, `roles.${base}.provider`, "provider", (v) => JSON.stringify(v), (v) => v);
-        return;
-    }
-    if (modelWrite) {
-        rejectSetClearAndJson(rest, "--model", "--clear-model", "a model write");
-        requireKnownRole(root, id);
-        const base = baseRoleOf(id);
-        const model = flagValue(rest, "--model") ?? "";
-        writeRoleConfigKey(root, base, clearModel, model, `roles.${base}.model`, "model", (v) => JSON.stringify(v), (v) => v);
-        return;
-    }
-    if (thinkingWrite) {
-        rejectSetClearAndJson(rest, "--thinking", "--clear-thinking", "a thinking write");
-        requireKnownRole(root, id);
-        const base = baseRoleOf(id);
-        const level = flagValue(rest, "--thinking") ?? "";
-        writeRoleConfigKey(root, base, clearThinking, level, `roles.${base}.thinking`, "thinking", (v) => JSON.stringify(v), (v) => v);
-        return;
-    }
-    // The backend write: the twin of the provider/model/thinking writes, landing the role's
-    // backend (`pi`, `claude`, `opencode` or `codex`) in roles.<base>.backend through the same
-    // setConfigKey/unsetConfigKey core, so validateConfig's checkEntryBackend owns the id
-    // (rejecting an unknown one, and a `model` that cannot pair with the named backend) and
-    // the write stays atomic. An instance id writes its base role's key, like the others.
-    if (backendWrite) {
-        rejectSetClearAndJson(rest, "--backend", "--clear-backend", "a backend write");
+    // The model-writing branches — provider, model, thinking and backend — are one shape: each
+    // lands the role's field in roles.<base>.<field> (the terminal twin of `config set
+    // roles.<base>.<field> <value>` and `config unset`) through the same setConfigKey/unsetConfigKey
+    // core, so validateConfig owns the id — checkModelTripleField ("tier-name" shape: model
+    // accepts a tier name, thinking a THINKING_LEVELS level) for the provider/model/thinking
+    // fields that configForRole resolves through seamOverrides, checkEntryBackend for backend
+    // (`pi`, `claude`, `opencode` or `codex`, refusing an unknown one and a model that cannot
+    // pair with it) — and each write is atomic. No director refusal: each is accepted exactly as
+    // --min-run-interval is, and an instance id writes its base role's key. Every branch calls
+    // writeRoleConfigKey with the same JSON-encode/identity shaping, differing only in the flag
+    // spellings, the key field and the noun the confirmation line names — one table, one body.
+    for (const { flag, clearFlag, write, clear, field, noun } of [
+        { flag: "--provider", clearFlag: "--clear-provider", write: providerWrite, clear: clearProvider, field: "provider", noun: "provider" },
+        { flag: "--model", clearFlag: "--clear-model", write: modelWrite, clear: clearModel, field: "model", noun: "model" },
+        { flag: "--thinking", clearFlag: "--clear-thinking", write: thinkingWrite, clear: clearThinking, field: "thinking", noun: "thinking" },
+        { flag: "--backend", clearFlag: "--clear-backend", write: backendWrite, clear: clearBackend, field: "backend", noun: "backend" },
+    ]) {
+        if (!write)
+            continue;
+        rejectSetClearAndJson(rest, flag, clearFlag, `a ${noun} write`);
         requireKnownRole(root, id);
         const base = baseRoleOf(id);
-        const backend = flagValue(rest, "--backend") ?? "";
-        writeRoleConfigKey(root, base, clearBackend, backend, `roles.${base}.backend`, "backend", (v) => JSON.stringify(v), (v) => v);
+        const value = flagValue(rest, flag) ?? "";
+        writeRoleConfigKey(root, base, clear, value, `roles.${base}.${field}`, noun, (v) => JSON.stringify(v), (v) => v);
         return;
     }
     // The enable/disable write: the scoped write for the enabled state `tumwater role <id>`
@@ -466,7 +443,7 @@ export async function cmdRole(root, args) {
         say(`${base}: ${state}`);
         return;
     }
-    // The review-after-merge write: the one command the post-merge churn alert's remedy
+    // The review-after-merge write: the one command the post-merge churn row's remedy
     // needs — add the role to, or remove it from, review.afterMerge for the base id, the
     // membership test reviewedAfterMerge shares. The whole-list value lands through the same
     // setConfigKey core `config set review.afterMerge <json>` uses, so validateConfig owns the