@maka/maka-cli 5.65.2 → 5.67.0

package/bundle/typescript/src/commands/game/sideQuest/commands/backlog.js

@@ -1,11 +1,12 @@
 import { Command } from './command.js';
 import { hint } from '../utilities/hints.js';
 import { authToken } from '../utilities/cloud-saves.js';
-import { submitBacklog, fetchBacklog, postBacklogComment, postBacklogSignoff, BACKLOG_STATUSES, } from '../utilities/backlog.js';
+import { submitBacklog, fetchBacklog, postBacklogComment, postBacklogSignoff, postBacklogReject, postBacklogClose, BACKLOG_STATUSES, } from '../utilities/backlog.js';
 import { noteBacklogOutcome } from '../utilities/playtester.js';
 import { takeIndex } from '../utilities/fuzzy-match.js';
 import { optionMark } from '../utilities/log-style.js';
-import { loadReviewQueue, reviewSnapshot, reviewItemAt, isValidationRow, markReviewAnswered, } from '../utilities/backlog-review.js';
+import { statusLabel, verdictLabel, boardPrintOrder } from '../utilities/backlog-vocab.js';
+import { loadReviewQueue, reviewSnapshot, reviewItemAt, isValidationRow, reviewDisplayOrder, parseRejection, parseReproRequest, markReviewAnswered, rememberBoard, boardItemAt, boardSize, } from '../utilities/backlog-review.js';
 /** One line of somebody's report, kept to a skimmable width. */
 function truncate(text, max) {
     const flat = text.replace(/\s+/g, ' ').trim();
@@ -36,7 +37,10 @@ export class BacklogCommand extends Command {
     static description = 'File a play-tester item that somebody acts on -- it goes to maka-cli.com, keeps a link to this session, and comes back checked against the rulebooks. "backlog <what you noticed>" files one; "backlog list [status]" reads the board. For private scribbles, use "note".';
     static subcommands = [
         { usage: 'backlog <text>', short: 'File an item against this session.' },
-        { usage: 'backlog list', short: 'The whole board, newest first.' },
+        { usage: 'backlog list', short: 'The whole board, what needs you last.' },
+        { usage: 'backlog <n>', short: 'Read board item n in full.' },
+        { usage: 'backlog repro <n>', short: 'Play the repro bench for board item n.' },
+        { usage: 'backlog close <n> [why]', short: 'Close item n outright -- filed in error, duplicate, no longer real.' },
         { usage: 'backlog list <status>', short: `Filter: ${BACKLOG_STATUSES.join(', ')}.` },
         {
             usage: 'backlog review',
@@ -44,9 +48,9 @@ export class BacklogCommand extends Command {
             long: 'Items where somebody has asked you something and is waiting: a clarifying question about a report you filed, or a fix that has landed and wants confirming in play. Listed 1..n, oldest first.',
         },
         {
-            usage: 'backlog review <n> <your answer>',
+            usage: 'backlog review <n> <your answer>  |  backlog review <n> reject <what is still wrong>',
             short: 'Answer item n from that list.',
-            long: 'Posts your words against item n as an answer. The numbers come from the list you were last shown and do not move when you answer one, so you can work down them. "backlog review <n>" on its own reads that item in full without replying.',
+            long: 'Answers item n. On a row asking you to confirm a fix, your words sign it off and close it; "reject <what is still wrong>" instead sends it back to the board as open, with your reason attached. On a row asking you a question, your words are posted as the answer. "backlog review <n>" on its own reads that item in full without replying. The list is re-read and redealt from 1 after every answer.',
         },
     ];
     async execute(args = []) {
@@ -63,6 +67,44 @@ export class BacklogCommand extends Command {
         if (args.length === 0 || sub === 'list') {
             return this.list(args[1]);
         }
+        // A BARE NUMBER READS THAT ROW OF THE BOARD, and it has to be caught
+        // here for the same reason `list` and `review` are: everything that
+        // reaches the bottom of this method FILES AN ITEM. Without this,
+        // "backlog 3" -- the obvious thing to type at a numbered list --
+        // would quietly file a new report whose entire text is "3".
+        //
+        // `backlog repro <n>` drops into that row's bench. Both resolve
+        // against the BOARD snapshot, never the review queue's: they are
+        // different sets, so a number cannot mean a row in both.
+        if (/^\d{1,3}$/.test(sub)) {
+            return this.readBoardItem(Number(sub));
+        }
+        if (sub === 'repro') {
+            return this.reproFromBoard(args[1]);
+        }
+        if (sub === 'close') {
+            return this.closeFromBoard(args[1], args.slice(2).join(' '));
+        }
+        // ACCEPT AND REJECT ARE COMMANDS, NOT REPORTS.
+        //
+        // Claimed here for the same reason `repro` was, and after the same
+        // kind of accident: on 2026-08-28 a play-tester in a bench typed
+        // "backlog accept" and this method filed a backlog item whose entire
+        // text was the word "accept" -- which then went off to be vetted
+        // against the rulebooks, came back "needs detail", and sat on the
+        // open board as noise (4svHkpnDhWcXDzPsX).
+        //
+        // The rule this keeps proving: on a verb whose default is to CREATE
+        // something, every unclaimed word is data. Any word a player could
+        // reasonably read as a command has to be claimed before they can
+        // reach for it -- and being in a bench is exactly when "accept" is
+        // the obvious thing to type.
+        if (sub === 'accept' || sub === 'reject') {
+            // Route to the review answer rather than refusing: in a bench this
+            // is precisely what they meant, and outside one the review path
+            // explains itself far better than an error here could.
+            return this.review(args);
+        }
         // "review" is checked BEFORE the fall-through to file(), or
         // answering an item would file a new one whose text begins with the
         // word "review" -- the same shape as `backlog open` filing an item
@@ -118,6 +160,23 @@ export class BacklogCommand extends Command {
         // numbering. This is the ONLY place the queue is refetched.
         if (args.length === 0)
             return this.showQueue();
+        // YOU ARE ALREADY REVIEWING ONE (player ruling 2026-08-28: "I
+        // shouldn't have to pick from the list of review items -- I AM
+        // reviewing an item").
+        //
+        // In a repro bench the session was stood up FOR a specific report,
+        // so "backlog review reject <why>" needs no number: asking which
+        // item is asking a question the launch already answered. Checked
+        // before the index resolver, because "reject" is not a number and
+        // takeIndex would refuse it with advice to go and read a list --
+        // which is the exact detour being removed.
+        //
+        // Outside a bench nothing changes: with no bound item there is
+        // genuinely more than one thing they could mean, and the list is
+        // the honest answer.
+        const boundId = this.game?.reproItemId;
+        if (boundId)
+            return this.answerBound(boundId, args.join(' ').trim());
         const queue = reviewSnapshot();
         if (queue.length === 0) {
             // No snapshot means no list they could have counted on, so we do
@@ -164,6 +223,62 @@ export class BacklogCommand extends Command {
         // status fallback renderItem uses, so both halves agree about which
         // row this is.
         const validation = isValidationRow(item);
+        // "repro" IS A COMMAND, NOT AN ANSWER, and it is claimed here --
+        // BEFORE the sign-off below -- because everything that reaches the
+        // sign-off is treated as the reporter's confirmation.
+        //
+        // Claimed the hard way. On 2026-08-28 the reporter typed
+        // "backlog review 1 repro" at a verb that did not exist yet; it fell
+        // through as their answer and closed b9YeNqTNBJuk9dbrk. A sign-off
+        // is irreversible from the client -- the reject route refuses any
+        // item already carrying one -- so a word had to be reserved the
+        // moment it was described to anybody, not the moment it worked.
+        //
+        // Reserved on BOTH kinds of row. On a question row it would only
+        // post a stray comment rather than close anything, but "repro"
+        // is no more an answer to a question than it is a confirmation.
+        if (parseReproRequest(text)) {
+            return this.repro(item, n);
+        }
+        // "backlog review 1 reject <why>" -- the reporter says NO (user
+        // request 2026-08-27). Until this existed the only answer a
+        // validation request could take was yes: saying "still broken" left
+        // a comment that changed nothing, and to the board that was
+        // indistinguishable from saying nothing at all.
+        //
+        // The keyword is matched only as the FIRST word and only on a
+        // validation row, so a report whose text merely contains "reject"
+        // cannot bounce a fix by accident. Everything after it is the
+        // reason, verbatim.
+        const why = validation ? parseRejection(text) : null;
+        if (why !== null) {
+            // A bare "reject" is refused rather than sent. The reason is the
+            // whole value of a rejection -- it is what the next person fixing
+            // this has to work from -- and the server demands one anyway.
+            if (!why) {
+                return `Say what's still wrong: {white-fg}backlog review ${n} reject <what you saw>{/white-fg}`;
+            }
+            // The INDEXED path is never a bench (a bench answers through
+            // answerBound), so the runner name here is a real one.
+            const rejOutcome = await postBacklogReject(item.id, why, this.actor?.name);
+            noteBacklogOutcome(rejOutcome);
+            if (rejOutcome !== 'ok')
+                return this.explain(rejOutcome);
+            markReviewAnswered(item.id);
+            const after = await loadReviewQueue();
+            const head = `{red-fg}Rejected item ${n}. It's back on the board as open, with your reason on it.{/red-fg}`;
+            if (after.outcome !== 'ok' || !after.items) {
+                return `${head}\n{white-fg}(Couldn't re-read the board just now -- "backlog review" when the grid's back.){/white-fg}`;
+            }
+            if (after.items.length === 0) {
+                return `${head}\n{white-fg}Nothing else is waiting on you.{/white-fg}`;
+            }
+            return [
+                head,
+                `{white-fg}${after.items.length} still waiting on you:{/white-fg}`,
+                ...this.renderRows(after.items),
+            ].filter(Boolean).join('\n');
+        }
         const outcome = validation
             ? await postBacklogSignoff(item.id, text, this.actor?.name)
             : await postBacklogComment(item.id, text, {
@@ -206,10 +321,33 @@ export class BacklogCommand extends Command {
         return [
             head,
             `{white-fg}${left} still waiting on you:{/white-fg}`,
-            ...refreshed.items.map((it, i) => this.renderItem(it, i + 1, { full: false })),
-            hint(`"backlog review <n> <your answer>" -- the numbers have been redealt from 1.`),
+            ...this.renderRows(refreshed.items),
+            hint(`"backlog review <n> <your answer>" -- the numbers have been redealt from 1. "backlog review <n> repro" plays a bench.`),
         ].filter(Boolean).join('\n');
     }
+    /**
+     * THE ROWS, NUMBERED IN BOARD ORDER AND PRINTED IN REVERSE.
+     *
+     * User ruling 2026-08-27, twice: "so I see 1. as the first, not 8."
+     * and then "REVERSE THE ORDER OF THE REVIEW ITEMS."
+     *
+     * A terminal scrolls, so the LAST line printed is the one under the
+     * player's eye when the list stops. Printing 1..n top-to-bottom put
+     * the HIGHEST number closest to the prompt -- the list read as though
+     * it started at 8. Reversing the print order puts item 1 last, which
+     * is where it is actually read first.
+     *
+     * THE NUMBERS STAY BOUND TO THEIR ITEMS. They are assigned in the
+     * server's order BEFORE the reverse, so `backlog review 1` resolves
+     * to the same row it did before and to the same row reviewItemAt
+     * returns. Renumbering to match the printed order would have meant
+     * the display and the index disagreed -- and an answer posted against
+     * the wrong item lands somewhere plausible enough that nobody
+     * notices, which is the one failure this queue must not have.
+     */
+    renderRows(items) {
+        return reviewDisplayOrder(items).map(({ item, n }) => this.renderItem(item, n, { full: false }));
+    }
     /** Fetch and render the queue, adopting its order as the numbering. */
     async showQueue() {
         const { outcome, items } = await loadReviewQueue();
@@ -220,8 +358,8 @@ export class BacklogCommand extends Command {
         }
         return [
             `{cyan-fg}WAITING ON YOU{/cyan-fg}`,
-            ...items.map((it, i) => this.renderItem(it, i + 1, { full: false })),
-            hint(`"backlog review <n> <your answer>" replies. "backlog review <n>" alone reads one in full.`),
+            ...this.renderRows(items),
+            hint(`"backlog review <n> <your answer>" replies, "reject <what is wrong>" sends it back. "backlog review <n> repro" drops you into its bench.`),
         ].filter(Boolean).join('\n');
     }
     /**
@@ -260,8 +398,292 @@ export class BacklogCommand extends Command {
         if (validation && it.commits?.length) {
             rows.push(`     {white-fg}fixed by: ${it.commits.slice(0, 3).join(', ')}{/white-fg}`);
         }
+        // A BENCH EXISTS -- said on the row, so it is visible while skimming
+        // rather than found by typing "repro" at each one in turn.
+        if (it.repro?.steps?.length) {
+            rows.push(`     {green-fg}bench ready -- "backlog review ${n} repro"{/green-fg}`);
+        }
         return rows.join('\n');
     }
+    /**
+     * ANSWERING THE ITEM THIS SESSION IS ABOUT -- no index, because there
+     * is only one thing it could mean.
+     *
+     *   backlog review reject <what is still wrong>
+     *   backlog review accept [what you saw]
+     *   backlog review <what you saw>          (accept, said plainly)
+     *   backlog review repro                   (re-read the steps)
+     *
+     * `accept` is spelled out as a keyword AND left optional, which looks
+     * redundant and is not. Bare prose has always signed an item off, and
+     * removing that would break the habit of everyone already using it --
+     * but a person who has just typed "reject <reason>" reasonably
+     * expects "accept <reason>" to exist, and finding that it does not is
+     * how somebody ends up typing "accept" alone as their whole
+     * confirmation note.
+     */
+    async answerBound(itemId, text) {
+        // WHOSE WORD IS THIS? The account is the identity that matters and
+        // the server resolves it from the token -- but the runner NAME is
+        // read from the session, and in a bench that is the pregen. Your
+        // first playtest recorded six sign-offs as "signed by Testbed", a
+        // street name belonging to nobody. Omitted here so the board falls
+        // back to the handle: no name is more honest than a fictional one.
+        const asRunner = this.game?.isBench ? undefined : this.actor?.name;
+        const fresh = await loadReviewQueue();
+        if (fresh.outcome !== 'ok' || !fresh.items)
+            return this.explain(fresh.outcome);
+        const item = fresh.items.find(i => i.id === itemId);
+        if (!item) {
+            // Already answered, or moved on while the bench was open. Not an
+            // error -- say what is true and do not post anything.
+            return `This item isn't waiting on you any more -- it may already be answered.${hint(` ("backlog review" shows what is.)`)}`;
+        }
+        if (text.length === 0)
+            return this.renderItem(item, 1, { full: true });
+        if (parseReproRequest(text))
+            return this.repro(item, 1);
+        const validation = isValidationRow(item);
+        const why = validation ? parseRejection(text) : null;
+        if (why !== null) {
+            if (!why)
+                return `Say what's still wrong: {white-fg}backlog review reject <what you saw>{/white-fg}`;
+            const outcome = await postBacklogReject(item.id, why, asRunner);
+            noteBacklogOutcome(outcome);
+            if (outcome !== 'ok')
+                return this.explain(outcome);
+            markReviewAnswered(item.id);
+            return `{red-fg}Rejected. It's back on the board as open, with your reason on it.{/red-fg}`
+                + this.closeBench('rejected');
+        }
+        // "accept" is stripped when it leads, so the note is what follows
+        // rather than the word itself.
+        const note = /^accepts?\b/i.test(text) ? text.replace(/^accepts?\b\s*/i, '').trim() : text;
+        const outcome = validation
+            ? await postBacklogSignoff(item.id, note || 'Confirmed in play.', asRunner)
+            : await postBacklogComment(item.id, note, { kind: 'answer', awaitingReporter: false, runnerName: asRunner });
+        noteBacklogOutcome(outcome);
+        if (outcome !== 'ok')
+            return this.explain(outcome);
+        markReviewAnswered(item.id);
+        return (validation
+            ? `{green-fg}Signed off. That closes it -- your word is what the board was waiting for.{/green-fg}`
+            : `{cyan-fg}Answered. It's on the record against your report.{/cyan-fg}`)
+            + this.closeBench(validation ? 'signed off' : 'answered');
+    }
+    /**
+     * A BENCH IS DONE WHEN THE ITEM IS ANSWERED (player request
+     * 2026-08-28: "after accepting or rejecting, give a 3s timeout and
+     * then close the session").
+     *
+     * It exists to answer one report; once that is posted there is
+     * nothing left in it. Three seconds so the confirmation above can
+     * actually be read -- closing on the same frame would wipe the only
+     * evidence the answer went anywhere.
+     *
+     * ONLY in a bench, and only after a post that SUCCEEDED. Answering
+     * from an ordinary session must never shut the game down: that is
+     * somebody's run, not a scratch scene, and the failure would be
+     * spectacular.
+     */
+    /**
+     * ASK THE LAUNCHER FOR THE BENCH, then leave so it can run it.
+     *
+     * Returns the line to print, or undefined when this session cannot
+     * hand off -- in which case the caller falls back to simply showing
+     * the steps, which is strictly better than an error.
+     *
+     * REFUSED DURING A SHARED RUN, and this is the guard that matters:
+     * quitting to a bench would drop the table and take everyone else's
+     * evening with it. The refusal names the route that IS safe from
+     * anywhere, because a refusal that does not is just a wall.
+     */
+    async requestBenchHandoff(item) {
+        const game = this.game;
+        const dir = game?.sessionDir;
+        if (!game || !dir)
+            return undefined;
+        if (game.remoteSession) {
+            return `You're on a shared run -- dropping into a bench would end the table for everyone.`
+                + `\n{white-fg}Outside the game: {/white-fg}maka play:shadowrun --repro ${item.id}`;
+        }
+        try {
+            const { writeHandoff } = await import('../utilities/handoff.js');
+            writeHandoff(dir, { kind: 'repro', itemId: item.id });
+        }
+        catch {
+            // Could not leave the note -- say nothing about benches and let
+            // the caller print the steps instead. Never strand the player.
+            return undefined;
+        }
+        // Exiting 0 is what seals the save (see the quit hook in ui.ts), so
+        // the resume the launcher performs picks up exactly here.
+        game.closeAfter(3000, `repro handoff for ${item.id}`);
+        return [
+            `{cyan-fg}Dropping into the bench for this item...{/cyan-fg}`,
+            `{white-fg}Your run is saved. You'll come straight back to it when you leave the bench.{/white-fg}`,
+        ].join('\n');
+    }
+    closeBench(reason) {
+        if (!this.game?.isBench)
+            return '';
+        this.game.closeAfter(3000, reason);
+        return `\n{white-fg}Closing the bench...{/white-fg}`;
+    }
+    /**
+     * THE BENCH FOR ONE ITEM.
+     *
+     * Wired as far as it currently goes, and no further: the repro spec
+     * lives on the board (server work, not yet deployed), so today this
+     * can only report honestly that there is nothing attached. What it
+     * must NEVER do is fall through to the sign-off, which is the whole
+     * reason it exists this early.
+     */
+    async repro(item, n) {
+        const repro = item.repro;
+        // IN A BENCH, "repro" RE-READS. You are already standing in it, so
+        // the only useful meaning is "show me the steps again".
+        //
+        // OUTSIDE ONE, it TAKES YOU THERE -- and it does that by leaving.
+        // The scene cannot be swapped underneath a live session: the game
+        // holds the terminal through blessed, and a second blessed screen
+        // on one terminal is the exact failure the parent-as-janitor rule
+        // exists to prevent. So the game seals its save, leaves a note for
+        // the launcher, and exits; the launcher plays the bench and brings
+        // the same runner back on a resume. Quit -> bench -> back, which is
+        // what was asked for, and it needs no new run lifecycle.
+        if (repro && repro.steps.length > 0 && !this.game?.isBench) {
+            const handoff = await this.requestBenchHandoff(item);
+            if (handoff)
+                return handoff;
+        }
+        if (!repro || repro.steps.length === 0) {
+            // ABSENCE IS ORDINARY, and must not read as breakage. Plenty of
+            // items are about a verb, a menu or a note and have no scene to
+            // stand in. Say so, and say the thing that actually matters here:
+            // nothing was recorded against the item.
+            return [
+                `{yellow-fg}No repro bench is attached to item ${n}.{/yellow-fg}`,
+                `{white-fg}Not every fix has one -- some are about a verb or a menu rather than a place.{/white-fg}`,
+                hint(` Nothing was posted, and the item was NOT signed off.`),
+            ].filter(Boolean).join('\n');
+        }
+        const lines = [`{cyan-fg}REPRO -- item ${n}{/cyan-fg}`];
+        if (repro.premise)
+            lines.push(`{white-fg}${repro.premise}{/white-fg}`, '');
+        // The steps are printed 1..n whatever the queue does, because these
+        // are read top-down and typed in order -- the review LIST reverses
+        // for a scrolling terminal, and a sequence of instructions is the
+        // one thing that must not.
+        repro.steps.forEach((step, i) => lines.push(`  ${i + 1}. {white-fg}${step}{/white-fg}`));
+        if (repro.expect)
+            lines.push('', `{white-fg}Passing looks like: ${repro.expect}{/white-fg}`);
+        lines.push('', `{white-fg}Play it: {/white-fg}maka play:shadowrun --repro ${item.id}`);
+        lines.push(hint(this.game?.isBench
+            ? ` "review accept <what you saw>" or "review reject <what is wrong>" answers it -- no number needed.`
+            : ` Answer with "backlog review ${n} <what you saw>" when you have looked.`));
+        return lines.filter(Boolean).join('\n');
+    }
+    /**
+     * ONE ROW OF THE BOARD, in full.
+     *
+     * Resolved against the snapshot that was PRINTED, never a fresh
+     * fetch -- the same invariant the review queue holds, and for the
+     * same reason: a list that reshuffles between being read and being
+     * numbered at hands the player a different item than the one they
+     * counted. With no snapshot it shows the board rather than guessing
+     * which list they had in mind.
+     */
+    async readBoardItem(n) {
+        if (boardSize() === 0) {
+            const shown = await this.list();
+            return `${shown}\n\n{white-fg}(Pick from the list above -- "backlog <n>".){/white-fg}`;
+        }
+        const item = boardItemAt(n);
+        if (!item)
+            return `There's no item ${n}. The board runs 1-${boardSize()}.`;
+        const lines = [`${this.statusMark(item.status)} ${item.text}`];
+        const who = [item.runnerName, item.reporterHandle].filter(Boolean).join(' / ');
+        if (who)
+            lines.push(`  {white-fg}${who}{/white-fg}`);
+        const v = item.vetting;
+        if (v?.verdict) {
+            lines.push(`  ${this.verdictTag(v.verdict)}${v.justification ? ` ${v.justification}` : ''}`);
+        }
+        for (const c of (v?.citations ?? []).slice(0, 3)) {
+            lines.push(`  {cyan-fg}${c.book} p.${c.page ?? '?'}${c.section ? ` (${c.section})` : ''}{/cyan-fg}`);
+        }
+        if (item.commits?.length) {
+            lines.push(`  {white-fg}fixed by: ${item.commits.map(c => c.slice(0, 8)).join(', ')}{/white-fg}`);
+        }
+        if (item.repro?.steps?.length) {
+            lines.push('', `{green-fg}BENCH -- "backlog repro ${n}" drops you into it{/green-fg}`);
+            if (item.repro.premise)
+                lines.push(`  {white-fg}${item.repro.premise}{/white-fg}`);
+            item.repro.steps.forEach((step, i) => lines.push(`    ${i + 1}. {white-fg}${step}{/white-fg}`));
+            if (item.repro.expect)
+                lines.push(`  {white-fg}passing looks like: ${item.repro.expect}{/white-fg}`);
+        }
+        return lines.join('\n');
+    }
+    /**
+     * PLAY ANY BOARD ITEM'S BENCH, not just one awaiting review.
+     *
+     * The review queue holds only what is waiting on YOU, so once an item
+     * is answered its bench became unreachable from in-game -- even
+     * though checking a fix a second time, or showing somebody what you
+     * saw, are ordinary things to want. The board is the wider set and
+     * this is its verb.
+     */
+    async reproFromBoard(arg) {
+        if (boardSize() === 0) {
+            const shown = await this.list();
+            return `${shown}\n\n{white-fg}(Pick from the list above -- "backlog repro <n>".){/white-fg}`;
+        }
+        const n = Number(arg);
+        const item = Number.isInteger(n) ? boardItemAt(n) : undefined;
+        if (!item)
+            return `Which one? "backlog repro <n>" -- the board runs 1-${boardSize()}.`;
+        if (!item.repro?.steps?.length) {
+            return `No bench is attached to that one.${hint(` Not every fix has a place to stand in -- "backlog list" marks the ones that do.`)}`;
+        }
+        // Same handoff the review path uses: the game cannot swap its own
+        // scene, so it leaves a note and the launcher does the rest.
+        const handoff = await this.requestBenchHandoff({ id: item._id, text: item.text });
+        return handoff ?? `Couldn't hand off to the bench from here.`;
+    }
+    /**
+     * CLOSE A BOARD ROW OUTRIGHT -- no verdict, no evidence, no sign-off.
+     *
+     * "backlog close <n> [why]". For an item that should never have been
+     * filed: a duplicate, a mis-typed command that became a report, or
+     * something you have since decided was never real.
+     *
+     * Deliberately NOT one of the review verbs. Accepting a mistake would
+     * record a confirmation nobody made; rejecting it would send
+     * imaginary work back to whoever fixed it. This says the third thing.
+     */
+    async closeFromBoard(arg, why = '') {
+        if (boardSize() === 0) {
+            const shown = await this.list();
+            return `${shown}\n\n{white-fg}(Pick from the list above -- "backlog close <n> [why]".){/white-fg}`;
+        }
+        const n = Number(arg);
+        const item = Number.isInteger(n) ? boardItemAt(n) : undefined;
+        if (!item)
+            return `Which one? "backlog close <n> [why]" -- the board runs 1-${boardSize()}.`;
+        const outcome = await postBacklogClose(item._id, why.trim(), this.game?.isBench ? undefined : this.actor?.name);
+        noteBacklogOutcome(outcome);
+        if (outcome === 'forbidden') {
+            return `That one isn't yours to close -- only the play-tester who filed it, or an admin.`;
+        }
+        if (outcome !== 'ok')
+            return this.explain(outcome);
+        // The board is re-read on the next "backlog list"; the numbering
+        // belongs to what was printed, so it is not silently redealt here.
+        return `{white-fg}Closed: ${truncate(item.text, 60)}{/white-fg}`
+            + hint(` It's off the board as "wont-fix", with your reason on the record.`);
+    }
     async list(statusArg) {
         let status;
         if (statusArg) {
@@ -285,9 +707,37 @@ export class BacklogCommand extends Command {
         // "headers like that are too cluttery"). The heading itself stays --
         // it carries what the panel divider can't say for it.
         const lines = [`BACKLOG (${items.length}${status ? `, ${status}` : ''})`];
-        for (const item of items)
-            lines.push(...this.row(item));
-        const footer = hint(`"backlog <what you noticed>" files one. Status moves are an admin's call.`);
+        // PRINTED LOWEST-PRIORITY FIRST, so the rows that need you land at
+        // the BOTTOM, closest to the prompt -- which is where a scrolling
+        // panel leaves your eye.
+        //
+        // The server sorts in-review first, and that is the right order for
+        // a CALLER to iterate. Printing it top-down put wont-fix under the
+        // cursor and scrolled the urgent rows off the top: reported here in
+        // exactly those words ("I see 'wont' items first"), and reported the
+        // same way about the out-of-game board an hour earlier -- which I
+        // fixed there and did not carry across, so the same list read
+        // correctly in one place and backwards in the other.
+        //
+        // Reversed at the point of PRINT, never in the data, so the
+        // server's priority and which end you read first stay separate
+        // facts. Same rule as reviewDisplayOrder and as the CLI dump.
+        // NUMBERED, so there is something to name. In-game the rows carried
+        // neither an id nor a number, which left the board readable and
+        // completely inert -- and an id would not have helped, because
+        // selecting text out of a blessed panel to paste back into it is
+        // not a thing anybody should be asked to do.
+        //
+        // Numbers are bound in the SERVER's order and only then reversed for
+        // printing, exactly as reviewDisplayOrder does: bind first, reverse
+        // second, or "3" labels one row and resolves to another.
+        rememberBoard(items);
+        const numbered = items.map((item, i) => ({ item, n: i + 1 }));
+        for (const { item, n } of boardPrintOrder(numbered)) {
+            const rows = this.row(item);
+            lines.push(`${optionMark(n)}${rows[0].trimStart()}`, ...rows.slice(1));
+        }
+        const footer = hint(`"backlog <n>" reads one in full, "backlog repro <n>" plays its bench. "backlog <what you noticed>" files one.`);
         if (footer)
             lines.push('', footer);
         return lines.join('\n');
@@ -315,29 +765,37 @@ export class BacklogCommand extends Command {
         }
         return out;
     }
+    /** Blessed's ink for a shared tone. Gray is deliberately absent: it
+     *  reads as absent on this screen (playtest ruling), so 'dim' lands on
+     *  plain white -- unemphatic without being unreadable. */
+    paint(tone, text) {
+        const fg = tone === 'good' ? 'green'
+            : tone === 'bad' ? 'red'
+                : tone === 'warn' ? 'yellow'
+                    : tone === 'alert' ? 'magenta'
+                        : tone === 'info' ? 'cyan'
+                            : 'white';
+        return `{${fg}-fg}${text}{/${fg}-fg}`;
+    }
+    /** The label and its loudness both come from utilities/backlog-vocab,
+     *  which the out-of-game dump reads too -- one place decides what a
+     *  status is CALLED and how much it matters, and each surface maps
+     *  that to its own palette.
+     *
+     *  An in-review row now paints MAGENTA rather than the same cyan as
+     *  in-progress. It is the one status that is waiting on the reader,
+     *  and it did not look like it -- the same complaint, in a smaller
+     *  font, as the board being unreadable out of game. */
     statusMark(status) {
-        switch (status) {
-            case 'complete': return '{green-fg}[done]{/green-fg}';
-            case 'in-progress': return '{cyan-fg}[wip] {/cyan-fg}';
-            // Fixed, and waiting on the reporter to confirm it in play. It
-            // used to fall through to the default and read "[open]" -- an
-            // item awaiting your word shown as one nobody had touched.
-            case 'in-review': return '{cyan-fg}[you?] {/cyan-fg}';
-            case 'wont-fix': return '{cyan-fg}[no]  {/cyan-fg}';
-            default: return '{yellow-fg}[open]{/yellow-fg}';
-        }
+        const { label, tone } = statusLabel(status);
+        return this.paint(tone, label);
     }
     /** The verdict is about the GAME, not the rulebooks (reframed
      *  2026-08-27). Asking canon whether a stale map mattered graded every
      *  real defect out of scope and cited a zoo at it. */
     verdictTag(verdict) {
-        switch (verdict) {
-            case 'canon-violation': return `{red-fg}breaks the rules:{/red-fg}`;
-            case 'bug': return `{red-fg}bug:{/red-fg}`;
-            case 'enhancement': return `{yellow-fg}wants building:{/yellow-fg}`;
-            case 'works-as-intended': return `{green-fg}working as meant:{/green-fg}`;
-            default: return `{cyan-fg}needs detail:{/cyan-fg}`;
-        }
+        const { label, tone } = verdictLabel(verdict);
+        return this.paint(tone, `${label}:`);
     }
     explain(outcome) {
         switch (outcome) {