toolroll 0.9.11 → 0.9.13

package/dist/result-acts.d.ts

@@ -0,0 +1,44 @@
+/** The result page's acts (2026-10-02), chosen in one place: exactly one ink
+ * act, the one that resolves the result's state, and never navigation; at
+ * most one outline act beside it. A result that can't be accepted says why
+ * in one line before them.
+ *
+ *   everything met                      → Accept
+ *   checks queued or running            → Checks running (disabled), then Accept without checks
+ *   checks didn't run, a check exists   → Run checks, then Accept without checks
+ *   report and changes disagree,
+ *   or the proof is refuted             → Request changes, then Accept (as allowed);
+ *                                         never Accept as ink, even with no form here
+ *   a Needs you form resolves it        → that form (Build again, Confirm it stopped)
+ *   saved notes or a failing PR         → Revise / Draft a repair task
+ *
+ * Accepting means what it always meant: the same forms post to the same
+ * endpoints. This only decides which one is ink. */
+export type ResultActKind = "accept" | "checks-running" | "run-checks" | "request-changes" | "rebuild" | "confirm-stopped" | "revise" | "draft-repair";
+export type ResultActFacts = {
+    /** An Accept this page can post (Mark complete, or the person's acceptance); `ready`: every requirement met and checks passed. */
+    accept: {
+        ready: boolean;
+    } | null;
+    /** The checks didn't run, the project has one, and this person may run it. */
+    runChecks: boolean;
+    /** Checks on this result are queued or running. */
+    checksRunning: boolean;
+    /** Why it can't be accepted yet (cantAcceptYetOf), or null. */
+    blocked: string | null;
+    /** The feedback form is on this page. */
+    canRequest: boolean;
+    /** A Needs you form that resolves it here. */
+    need: "rebuild" | "confirm-stopped" | null;
+    /** Saved notes ready to become a revision, or a failing pull request's repair. */
+    next: "revise" | "draft-repair" | null;
+};
+export type ResultActs = {
+    /** The one ink act, or null when nothing waits on the person. */
+    primary: ResultActKind | null;
+    /** The one outline act beside it. */
+    secondary: ResultActKind | null;
+    /** The one line before the acts: why it can't be accepted yet. */
+    line: string | null;
+};
+export declare function resultActsOf(facts: ResultActFacts): ResultActs;

package/dist/result-acts.js

@@ -0,0 +1,36 @@
+/** The result page's acts (2026-10-02), chosen in one place: exactly one ink
+ * act, the one that resolves the result's state, and never navigation; at
+ * most one outline act beside it. A result that can't be accepted says why
+ * in one line before them.
+ *
+ *   everything met                      → Accept
+ *   checks queued or running            → Checks running (disabled), then Accept without checks
+ *   checks didn't run, a check exists   → Run checks, then Accept without checks
+ *   report and changes disagree,
+ *   or the proof is refuted             → Request changes, then Accept (as allowed);
+ *                                         never Accept as ink, even with no form here
+ *   a Needs you form resolves it        → that form (Build again, Confirm it stopped)
+ *   saved notes or a failing PR         → Revise / Draft a repair task
+ *
+ * Accepting means what it always meant: the same forms post to the same
+ * endpoints. This only decides which one is ink. */
+export function resultActsOf(facts) {
+    const request = facts.canRequest ? "request-changes" : null;
+    const accept = facts.accept === null ? null : "accept";
+    if (facts.need !== null)
+        return { primary: facts.need, secondary: request, line: null };
+    if (facts.next !== null)
+        return { primary: facts.next, secondary: accept ?? request, line: null };
+    // Can't be accepted yet: Accept is never the ink act, even when the feedback form isn't here.
+    if (facts.blocked !== null)
+        return { primary: request, secondary: accept, line: facts.blocked };
+    if (facts.checksRunning)
+        return { primary: "checks-running", secondary: accept ?? request, line: null };
+    if (facts.accept === null)
+        return { primary: null, secondary: request, line: null };
+    if (facts.accept.ready)
+        return { primary: "accept", secondary: request, line: null };
+    if (facts.runChecks)
+        return { primary: "run-checks", secondary: "accept", line: null };
+    return { primary: "accept", secondary: request, line: null };
+}

package/dist/result-review.js

@@ -153,7 +153,7 @@ export function resultFactsFromHtml(html) {
  * lands on the run page. Matched exactly — never a bare open redirect. */
 export function resultReturnTarget(raw, runId) {
     if (raw !== null && raw !== undefined) {
-        const review = /^\/review\?result=[A-Za-z0-9._~%-]{1,200}(?:&run=([0-9]{1,15}))?$/.exec(raw);
+        const review = /^\/review\?result=[A-Za-z0-9._~%-]{1,200}(?:&run=([0-9]{1,15}))?(?:&tab=(?:summary|changes|checks))?$/.exec(raw);
         if (review !== null && (review[1] === undefined || Number(review[1]) === runId))
             return raw;
         const chat = /^\/chat\?task=([A-Za-z0-9._~%-]{1,200})&result=([0-9]{1,15})(?:&conversation=[A-Za-z0-9-]{1,128})?$/.exec(raw);

package/dist/serve.d.ts

@@ -189,10 +189,14 @@ export type ServeOptions = {
 /** Where `up`'s one-time sign-in link points, and how long it works. */
 export declare const SIGN_IN_LINK_PATH = "/login/once/";
 export declare const SIGN_IN_LINK_MS: number;
-/** The console's server, and the one-time sign-in link `up` opens: a path on this server, or null for no such approver. */
+/** The console's server, and the one-time sign-in link `up` opens: a path on this server, or null for no such approver.
+ * closeCoding starts the coding shutdown on its own, ahead of the rest of a stop; close() awaits the same promise. */
 export type DecisionServer = Server & {
     mintSignInLink(account: string): string | null;
+    closeCoding(): Promise<void>;
 };
+/** How long a stop waits for teammates and the lead's follow pass before closing anyway. */
+export declare const SHUTDOWN_WAIT_MS = 5000;
 export declare function createDecisionServer(options: ServeOptions): DecisionServer;
 /**
  * A vscode://file href, or null (arc 6, finding 2): the link exists only
@@ -554,6 +558,7 @@ export declare function needActionOf(assignment: AssignmentSnapshot | null, stat
     run: number;
     action: string;
     rebuildable?: boolean;
+    refuted?: boolean;
 }): BrowserNeedAction | null;
 /** The facts region alone, for the open-run poll (A4). A finished run's
  * fragment says so instead of quietly growing forms (finding 5), and a run