toolroll 0.9.14 → 0.9.15

package/dist/result-acts.d.ts

@@ -3,7 +3,9 @@
  * most one outline act beside it. A result that can't be accepted says why
  * in one line before them.
  *
- *   everything met                      → Accept
+ *   everything met                      → Accept and finish
+ *   a "You check this one" unanswered   → the next check, then Accept without your check
+ *   a check you marked Not right        → Request changes, then Accept anyway
  *   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,
@@ -11,14 +13,19 @@
  *                                         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
+ *   a failed build                      → Retry (its note starts with what to change), then Run checks when they
+ *                                         didn't run; never Accept: a failed build is not a result to accept
+ *   a failed task's delivered result    → Retry, then Accept anyway (in outline, with a reason) where it may be
+ *                                         accepted; Run checks stays in its Checks row
  *
- * Accepting means what it always meant: the same forms post to the same
- * endpoints. This only decides which one is ink. */
+ * Accepting finishes the task in one request (Accept and finish): the person's
+ * acceptance, when one is owed, and the completion together. This only decides
+ * which act is ink; the page recomputes it as the person answers each check. */
 /** The words over the reason field an Accept of a refuted result requires. */
 export declare const ACCEPT_NEEDS_REASON = "Accepting needs a reason";
-export type ResultActKind = "accept" | "checks-running" | "run-checks" | "request-changes" | "rebuild" | "confirm-stopped" | "revise" | "draft-repair";
+export type ResultActKind = "retry" | "accept" | "accept-anyway" | "next-check" | "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. */
+    /** An Accept this page can post (Accept and finish, or the person's acceptance alone); `ready`: every requirement met and checks passed. */
     accept: {
         ready: boolean;
     } | null;
@@ -34,6 +41,16 @@ export type ResultActFacts = {
     need: "rebuild" | "confirm-stopped" | null;
     /** Saved notes ready to become a revision, or a failing pull request's repair. */
     next: "revise" | "draft-repair" | null;
+    /** A failed build: `retry` when the task can be retried from here; `acceptAnyway` when it delivered a result that
+     * may still be accepted, with a reason. */
+    failed?: {
+        retry: boolean;
+        acceptAnyway?: boolean;
+    } | null;
+    /** "You check this one" items not answered yet on this page. */
+    unanswered?: number;
+    /** Items the person marked Not right. */
+    notRight?: number;
 };
 export type ResultActs = {
     /** The one ink act, or null when nothing waits on the person. */
@@ -44,3 +61,30 @@ export type ResultActs = {
     line: string | null;
 };
 export declare function resultActsOf(facts: ResultActFacts): ResultActs;
+/** The words a result's Accept wears and the one line before it, given the
+ * server's words for everything but the person's own checks (`base`) and how
+ * those stand on this page: an unanswered check names itself; a check marked
+ * Not right says so; otherwise the base words stand. */
+export type AcceptLabel = "Accept and finish" | "Accept without checks" | "Accept without your check" | "Accept anyway";
+export declare function acceptWithChecksOf(base: {
+    label: AcceptLabel;
+    ready: boolean;
+    why: string | null;
+}, checks: {
+    unanswered: readonly string[];
+    notRight: readonly string[];
+}): {
+    label: AcceptLabel;
+    ready: boolean;
+    why: string | null;
+};
+/** The Requirements row as the person answers their checks: each Looks right is met, each answer leaves "You check". */
+export declare function requirementsWordsOf(req: {
+    met: number;
+    total: number;
+    yours: number;
+}, looked: number, notRight: number): {
+    text: string;
+    done: boolean;
+    short: boolean;
+};

package/dist/result-acts.js

@@ -3,7 +3,9 @@
  * most one outline act beside it. A result that can't be accepted says why
  * in one line before them.
  *
- *   everything met                      → Accept
+ *   everything met                      → Accept and finish
+ *   a "You check this one" unanswered   → the next check, then Accept without your check
+ *   a check you marked Not right        → Request changes, then Accept anyway
  *   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,
@@ -11,14 +13,24 @@
  *                                         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
+ *   a failed build                      → Retry (its note starts with what to change), then Run checks when they
+ *                                         didn't run; never Accept: a failed build is not a result to accept
+ *   a failed task's delivered result    → Retry, then Accept anyway (in outline, with a reason) where it may be
+ *                                         accepted; Run checks stays in its Checks row
  *
- * Accepting means what it always meant: the same forms post to the same
- * endpoints. This only decides which one is ink. */
+ * Accepting finishes the task in one request (Accept and finish): the person's
+ * acceptance, when one is owed, and the completion together. This only decides
+ * which act is ink; the page recomputes it as the person answers each check. */
 /** The words over the reason field an Accept of a refuted result requires. */
 export const ACCEPT_NEEDS_REASON = "Accepting needs a reason";
 export function resultActsOf(facts) {
     const request = facts.canRequest ? "request-changes" : null;
     const accept = facts.accept === null ? null : "accept";
+    if (facts.failed != null) {
+        const checks = facts.runChecks && !facts.checksRunning ? "run-checks" : facts.checksRunning ? "checks-running" : null;
+        const anyway = facts.failed.acceptAnyway === true ? "accept-anyway" : null;
+        return facts.failed.retry ? { primary: "retry", secondary: anyway ?? checks, line: null } : { primary: checks, secondary: anyway, line: null };
+    }
     if (facts.need !== null)
         return { primary: facts.need, secondary: request, line: null };
     if (facts.next !== null)
@@ -26,6 +38,11 @@ export function resultActsOf(facts) {
     // 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 };
+    // The person's own checks come first: the next one is ink until each is answered.
+    if (accept !== null && (facts.unanswered ?? 0) > 0)
+        return { primary: "next-check", secondary: accept, line: null };
+    if (accept !== null && (facts.notRight ?? 0) > 0)
+        return { primary: request, secondary: accept, line: null };
     if (facts.checksRunning)
         return { primary: "checks-running", secondary: accept ?? request, line: null };
     if (facts.accept === null)
@@ -36,3 +53,17 @@ export function resultActsOf(facts) {
         return { primary: "run-checks", secondary: "accept", line: null };
     return { primary: "accept", secondary: request, line: null };
 }
+export function acceptWithChecksOf(base, checks) {
+    const named = (all) => `“${all[0].replace(/[.!?]+$/, "")}”${all.length > 1 ? ` and ${all.length - 1} more` : ""}`;
+    if (checks.unanswered.length > 0)
+        return { label: "Accept without your check", ready: false, why: `Not checked yet: ${named(checks.unanswered)}.` };
+    if (checks.notRight.length > 0)
+        return { label: "Accept anyway", ready: false, why: `You marked ${named(checks.notRight)} not right.` };
+    return base;
+}
+/** The Requirements row as the person answers their checks: each Looks right is met, each answer leaves "You check". */
+export function requirementsWordsOf(req, looked, notRight) {
+    const met = req.met + looked;
+    const yours = Math.max(0, req.yours - looked - notRight);
+    return { text: `${met} of ${req.total} met${yours > 0 ? ` · You check ${yours}` : ""}`, done: met === req.total, short: req.total - met - yours > 0 };
+}

package/dist/result-review.d.ts

@@ -149,9 +149,10 @@ export declare const RESULT_FACT_KEYS: readonly ["run", "head", "base", "head-so
  * (place, lead, task, user) are not facts and are left out. */
 export declare function resultFactsFromHtml(html: string): Record<string, string>[];
 /** Where a result form may send its reader back: the review cockpit's
- * own deep link, the chat's result detail, or the run page. Anything else
- * lands on the run page. Matched exactly — never a bare open redirect. */
-export declare function resultReturnTarget(raw: string | null | undefined, runId: number): string;
+ * own deep link, the chat's result detail, the page of a task named in
+ * `tasks` (the run's own), or the run page. Anything else lands on the run
+ * page. Matched exactly — never a bare open redirect. */
+export declare function resultReturnTarget(raw: string | null | undefined, runId: number, tasks?: readonly string[]): string;
 /** A form's own request token, minted per render — the same shape the
  * chat composer uses. A replayed submission carries the same token, so
  * the server can recognise it and mint nothing twice. */

package/dist/result-review.js

@@ -149,9 +149,10 @@ export function resultFactsFromHtml(html) {
     return found;
 }
 /** Where a result form may send its reader back: the review cockpit's
- * own deep link, the chat's result detail, or the run page. Anything else
- * lands on the run page. Matched exactly — never a bare open redirect. */
-export function resultReturnTarget(raw, runId) {
+ * own deep link, the chat's result detail, the page of a task named in
+ * `tasks` (the run's own), or the run page. Anything else lands on the run
+ * page. Matched exactly — never a bare open redirect. */
+export function resultReturnTarget(raw, runId, tasks = []) {
     if (raw !== null && raw !== undefined) {
         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))
@@ -159,6 +160,9 @@ export function resultReturnTarget(raw, runId) {
         const chat = /^\/chat\?task=([A-Za-z0-9._~%-]{1,200})&result=([0-9]{1,15})(?:&conversation=[A-Za-z0-9-]{1,128})?$/.exec(raw);
         if (chat !== null && Number(chat[2]) === runId)
             return raw;
+        // The run's own task page, which offered Run checks in place; never another task's.
+        if (tasks.some(task => raw === `/t/${encodeURIComponent(task)}`))
+            return raw;
     }
     return `/r/${runId}`;
 }

package/dist/serve.d.ts

@@ -208,6 +208,9 @@ export declare function createDecisionServer(options: ServeOptions): DecisionSer
  * text, never to a 500. The scheme is a constant, never data.
  */
 export declare function editorFileHref(worktree: string, path: string, line?: number | null): string | null;
+/** Earlier versions of a task still in flight, in plain words: queued
+ * while they only wait, running once one has started; null when none. */
+export declare function earlierVersionsWords(active: number, running: number): string | null;
 /** The Agents view every console surface renders (v47): the SAME
  * projection the CLI prints — who plans, builds, and revises,
  * whether each was recommended, overridden, or pinned, its reasons, and