toolroll 0.9.13 → 0.9.15

package/dist/workspace-ui.d.ts

@@ -17,6 +17,8 @@
  * claimed without one.
  */
 import type { DispatchDiagnosis } from "./dispatch.js";
+import { ACCEPT_NEEDS_REASON, type AcceptLabel } from "./result-acts.js";
+export { ACCEPT_NEEDS_REASON };
 import { type ProofVerdict } from "./proof.js";
 import type { ReviewRetryState, TaskState } from "./store.js";
 import type { TaskControlView } from "./task-control.js";
@@ -194,18 +196,60 @@ export declare function dispatchActionLabel(dispatch: DispatchDiagnosis | null):
  * when nothing refutes it (a person's acceptance settles it). The result page
  * shows it before Request changes, its one ink act. */
 export declare function cantAcceptYetOf(verdict: ProofVerdict | null, reasons: readonly string[], accepted: boolean): string | null;
+/** The result's headline while its report disagrees with its saved changes. */
+export declare const MISMATCH_HEADLINE = "The report doesn't match the changes";
+/** One way the report disagrees with the saved changes, in plain words: the
+ * file and lines it concerns when they are in the saved changes, or
+ * `inChanges: false` for a file the report names that the changes don't have.
+ * `reason` is the recorded words it says plainly. */
+export type ReportMismatch = {
+    text: string;
+    path: string | null;
+    lines: {
+        from: number;
+        to: number;
+    } | null;
+    inChanges: boolean | null;
+    /** The report's own note (1-based) the disagreement is about, when it names one. */
+    note: number | null;
+    reason: string;
+};
+/** Each recorded way a refuted report disagrees with its saved changes, said
+ * plainly and tied to the changed lines it concerns. `changes` maps each
+ * changed file to the lines of its first change (null when it has no line
+ * changes, a binary file say). Presentation only: the verdict is unchanged. */
+export declare function reportMismatchesOf(reasons: readonly string[], criteria: readonly {
+    id: string;
+    statement: string;
+    answered: readonly {
+        kind: string;
+        ref: string;
+    }[];
+    state?: string;
+    detail?: readonly string[];
+}[], changes: ReadonlyMap<string, {
+    from: number;
+    to: number;
+} | null>): ReportMismatch[];
+/** The line a failing check ended on: the last line of its error output that
+ * names an error, else the last line it printed, with its 1-based number in
+ * the saved log. Null when the log printed nothing. */
+export declare function lastErrorLineOf(log: string): {
+    line: number;
+    text: string;
+} | null;
 /** The result page's own sentence when the decision is on it. */
 export declare const RESULT_DECISION_SENTENCE = "Review the change, then accept it or ask for changes.";
 /** What the result page's Accept says, from facts it already shows: the
- * recorded checks, the requirements not met, the ones a person still checks,
- * whether the saved proof reads, and what the button posts. "Accept" only when everything is met and the
- * checks passed; otherwise "Accept without checks" and one line naming what.
+ * recorded checks, the requirements not met, whether the saved proof reads,
+ * and what the button posts. "Accept and finish" only when everything is met
+ * and the checks passed; otherwise "Accept without checks" and one line naming
+ * what. The person's own checks are the page's to add (acceptWithChecksOf).
  * `effect` says what pressing it does, in the action's own terms. */
 export type AcceptFacts = {
     checks: "passed" | "failed" | "not-run" | "off" | "running" | "unavailable" | null;
     unmet: number;
-    yours: number;
-    /** `complete`: marks the exact result complete; `accept`: records a person's acceptance only. */
+    /** `complete`: accepts and finishes the exact result in one request; `accept`: records a person's acceptance only (nothing here can finish it). */
     action: "complete" | "accept";
     /** `pull-request`: one can be opened from the task after; `off`: publishing isn't set up; `other`: neither is said. Accept itself never publishes. */
     publishing: "pull-request" | "off" | "other";
@@ -213,7 +257,7 @@ export type AcceptFacts = {
     proof: boolean;
 };
 export type AcceptWords = {
-    label: "Accept" | "Accept without checks";
+    label: AcceptLabel;
     ready: boolean;
     why: string | null;
     effect: string;
@@ -243,3 +287,39 @@ export type PrimaryDestination = "chat" | "work" | "projects" | "flows" | "setti
 export declare function primaryDestinationOf(active: string): PrimaryDestination;
 /** Learning stays in Settings and a useful, closed result disclosure. */
 export declare function learningHtml(view: import('./project-learning.js').LearningView, csrf: string, canManage: boolean, source?: number): string;
+/** The first signed requirement a finished attempt missed (failed or unanswered; a person's own check is not a miss),
+ * with the evidence line behind it in plain words. Null when every requirement held. */
+export declare function missedRequirementOf(matrix: readonly {
+    id: string;
+    statement: string;
+    state: string;
+    detail: readonly string[];
+}[]): {
+    id: string;
+    statement: string;
+    evidence: string | null;
+} | null;
+/** One milestone of a live build's plan, as the agent last reported it; its words are null where only the recorded
+ * progress was read (a list row reads no plan file). */
+export type BuildStep = {
+    description: string | null;
+    state: "pending" | "current" | "completed" | "blocked";
+    note: string | null;
+};
+/** Where a live build is, in one line: "Step 3 of 6: …", or, when a step is blocked, "Stuck on step 4 of 6: <why>" in
+ * its place. `stuck` says which step and why; null while nothing is blocked. */
+export type BuildProgress = {
+    step: number;
+    total: number;
+    line: string;
+    stuck: {
+        step: number;
+        why: string | null;
+        line: string;
+    } | null;
+};
+/** A live build's progress: the step in progress (else the first one not done) as "Step N of M: <step>"; a blocked
+ * step replaces it as "Stuck on step N of M: <why>" (its note, else the step itself). Null with no plan steps. */
+export declare function buildProgressOf(steps: readonly BuildStep[] | null | undefined): BuildProgress | null;
+/** Earlier attempts that stopped before the one now running, in one quiet line. */
+export declare function earlierAttemptsWords(count: number): string;

package/dist/workspace-ui.js

@@ -16,8 +16,10 @@
  * observed" name observed publication records, and deployment is never
  * claimed without one.
  */
-import { GOAL_ASSESSMENT_PENDING, manualReviewOnly } from "./proof.js";
-import { plainReasonOf, stageOfCode, taskStatusOf, workToneOf } from "./task-status.js";
+import { ACCEPT_NEEDS_REASON } from "./result-acts.js";
+export { ACCEPT_NEEDS_REASON };
+import { GOAL_ASSESSMENT_PENDING, manualReviewOnly, plainReasonWords } from "./proof.js";
+import { OPEN_RESULT, plainReasonOf, stageOfCode, taskStatusOf, workToneOf } from "./task-status.js";
 export const WORK_VIEWS = [
     { key: "all", label: "All", hint: "Every task in view, most urgent first.", empty: "Nothing is in progress. Describe work in chat or add a task, and it appears here." },
     { key: "needs-you", label: "Needs you", hint: "Tasks waiting on an answer, approval, or your inspection.", empty: "Nothing needs you right now. Queued and running work continues on its own." },
@@ -65,7 +67,7 @@ export function reviewStatusOf(review) {
     // it would unreviewed, marked "not reviewed" by the result itself.
     if (review === null || review.automaticPending !== true || (review.state !== "queued" && review.state !== "running"))
         return null;
-    return { token: "reviewing", label: "Reviewing", detail: "An automatic review is reading this result before it reaches you.", tone: "live", action: { label: "Open the result", kind: "open-result" } };
+    return { token: "reviewing", label: "Reviewing", detail: "An automatic review is reading this result before it reaches you.", tone: "live", action: { label: OPEN_RESULT, kind: "open-result" } };
 }
 const FAILED_CHECK = /^the repository's approved verification command exited (-?[0-9]+)/;
 export function evidenceProblemOf(verdict, reasons) {
@@ -191,11 +193,11 @@ function storedResultStatusOf(result, publication) {
             // weighed, so it says nothing about whether that check passed.
             detail: withPublication("What the agent reported doesn't match the changes it saved."),
             tone: "problem",
-            action: { label: "Open the result", kind: "open-review" },
+            action: { label: OPEN_RESULT, kind: "open-review" },
         };
     }
     if (result.verdict === "short" && humanReview) {
-        return { token: "verification-needed", label: "Ready to inspect", detail: withPublication("The remaining requirements need a person's inspection."), tone: "attention", action: { label: "Inspect the result", kind: "open-review" } };
+        return { token: "verification-needed", label: "Ready to inspect", detail: withPublication("The remaining requirements need a person's inspection."), tone: "attention", action: { label: OPEN_RESULT, kind: "open-review" } };
     }
     if (result.verdict === "short") {
         return {
@@ -212,7 +214,7 @@ function storedResultStatusOf(result, publication) {
         // presence facts here.
         return result.recordComplete === false && result.verdict === null
             ? { token: "record-incomplete", label: "No-change result, record incomplete", detail: "The build concluded nothing needed to change, but its handoff or sealed diff is missing.", tone: "problem", action: { label: "Open the record", kind: "open-run" } }
-            : { token: "no-change", label: "No changes were needed", detail: withPublication("The build concluded nothing needed to change; its handoff and sealed diff are on record."), tone: "done", action: { label: "Open the result", kind: "open-result" } };
+            : { token: "no-change", label: "No changes were needed", detail: withPublication("The build concluded nothing needed to change; its handoff and sealed diff are on record."), tone: "done", action: { label: OPEN_RESULT, kind: "open-result" } };
     }
     if (result.verdict === null) {
         return {
@@ -229,7 +231,7 @@ function storedResultStatusOf(result, publication) {
             label: "Result saved — checks reported by the agent",
             detail: withPublication("No independent project check ran; the checks listed are the agent's own report."),
             tone: "neutral",
-            action: { label: "Open the result", kind: "open-result" },
+            action: { label: OPEN_RESULT, kind: "open-result" },
         };
     }
     if (published !== null && (published.token === "merge-observed" || published.token === "pr-opened" || published.token === "pr-closed")) {
@@ -238,7 +240,7 @@ function storedResultStatusOf(result, publication) {
             label: published.label,
             detail: `The approved check passed against this result. ${published.detail}`,
             tone: published.token === "pr-closed" ? "muted" : "done",
-            action: published.token === "merge-observed" ? { label: "Open the result", kind: "open-result" } : { label: "Open the pull request", kind: "open-pr" },
+            action: published.token === "merge-observed" ? { label: OPEN_RESULT, kind: "open-result" } : { label: "Open the pull request", kind: "open-pr" },
         };
     }
     return {
@@ -246,7 +248,7 @@ function storedResultStatusOf(result, publication) {
         label: "Ready",
         detail: withPublication("The approved check passed against this result."),
         tone: "ready",
-        action: { label: "Open the result", kind: "open-result" },
+        action: { label: OPEN_RESULT, kind: "open-result" },
     };
 }
 /** The completion receipt's heading: what the record actually supports.
@@ -286,7 +288,7 @@ export function needsPerson(dispatch) {
 /** Navigation labels describe the available help, not a mutation: opening
  * a hold or pause must never promise that the task has already resumed. */
 const DISPATCH_ACTION_LABELS = {
-    "open-result": "Open the result",
+    "open-result": OPEN_RESULT,
     "retry-task": "Review and retry",
     "place-task": "Choose a project",
     "write-scope": "Define the task",
@@ -318,9 +320,89 @@ const VERIFIED_RESULT = new Set(["ready-to-review", "pr-opened", "merge-observed
 export function cantAcceptYetOf(verdict, reasons, accepted) {
     if (accepted || verdict !== "refuted")
         return null;
+    // A mismatch is the status card's own headline; here only what accepting takes.
     return evidenceProblemOf(verdict, reasons) === "checks-failed"
         ? "Can't accept yet: the project's check failed on these changes."
-        : "Can't accept yet: what the agent reported doesn't match the changes it saved.";
+        : ACCEPT_NEEDS_REASON;
+}
+/** The result's headline while its report disagrees with its saved changes. */
+export const MISMATCH_HEADLINE = "The report doesn't match the changes";
+const OVERCLAIMED = /^claimed changed paths? not in the sealed diff: ([\s\S]+)$/;
+const RESTATED = /^criterion "([^"]+)" was signed as "[\s\S]*" and the proof restates it as "([\s\S]*)"$/;
+const CONTRADICTED_BY_CAVEAT = /^criterion "([^"]+)" is marked met, but caveat [0-9]+ admits an exception to it: ([\s\S]*)$/;
+const NOTE_NUMBER = /^caveat ([0-9]+) /;
+const CONTRADICTED_BY_REVIEW = /^(?:reviewer:)?[^\s"]+ contradicts criterion "([^"]+)": [\s\S]*$/i;
+/** Each recorded way a refuted report disagrees with its saved changes, said
+ * plainly and tied to the changed lines it concerns. `changes` maps each
+ * changed file to the lines of its first change (null when it has no line
+ * changes, a binary file say). Presentation only: the verdict is unchanged. */
+export function reportMismatchesOf(reasons, criteria, changes) {
+    const named = (id) => {
+        const statement = criteria.find(one => one.id === id)?.statement.trim() ?? "";
+        if (statement === "")
+            return `requirement ${id}`;
+        return `“${statement.length > 90 ? `${statement.slice(0, 90).replace(/\s+\S*$/, "")}…` : statement}”`;
+    };
+    // The first file the requirement cites that the saved changes have.
+    const place = (id) => {
+        const path = criteria.find(one => one.id === id)?.answered.find(ref => ref.kind === "changed-path" && changes.has(ref.ref))?.ref ?? null;
+        return path === null ? { path: null, lines: null, inChanges: null } : { path, lines: changes.get(path) ?? null, inChanges: true };
+    };
+    const rows = reasons.flatMap((reason) => {
+        const over = OVERCLAIMED.exec(reason);
+        if (over !== null)
+            return over[1].split(", ").map(path => ({ text: "The report says it changed", path, lines: null, inChanges: changes.has(path), note: null, reason }));
+        const restated = RESTATED.exec(reason);
+        if (restated !== null)
+            return [{ text: `The report rewords ${named(restated[1])} as “${restated[2]}”`, ...place(restated[1]), note: null, reason }];
+        const caveat = CONTRADICTED_BY_CAVEAT.exec(reason);
+        const note = /^criterion "[^"]+" is marked met, but caveat ([0-9]+) /.exec(reason)?.[1] ?? NOTE_NUMBER.exec(reason)?.[1] ?? null;
+        if (caveat !== null)
+            return [{ text: `The report marks ${named(caveat[1])} met, but its own note says: ${caveat[2]}`, ...place(caveat[1]), note: Number(note), reason }];
+        const review = CONTRADICTED_BY_REVIEW.exec(reason);
+        if (review !== null)
+            return [{ text: plainReasonWords(reason), ...place(review[1]), note: null, reason }];
+        const unsigned = UNSIGNED_NOTE.exec(reason);
+        if (unsigned !== null)
+            return [{ text: `The report's note ${unsigned[1]} is about ${unsigned[2]}, which isn't one of the signed requirements: ${unsigned[3]}`, path: null, lines: null, inChanges: null, note: Number(unsigned[1]), reason }];
+        if (FAILED_CHECK.test(reason))
+            return [];
+        return [{ text: sentenceOf(plainReasonWords(reason)), path: null, lines: null, inChanges: null, note: note === null ? null : Number(note), reason }];
+    });
+    // Evidence a requirement cites that doesn't hold, unless a reason above already says so.
+    const evidence = criteria.flatMap(one => one.state !== "failed" && one.state !== "missing" ? [] : (one.detail ?? [])
+        .filter(detail => !reasons.includes(detail) && !/is waiting for the final check|requires manual-review evidence|is marked met, but caveat|was signed as/.test(detail))
+        .map((detail) => {
+        const lead = [`criterion "${one.id}"'s `, `criterion "${one.id}" `].find(prefix => detail.startsWith(prefix));
+        const rest = lead === undefined ? detail : detail.slice(lead.length);
+        return { text: `${sentenceOf(named(one.id))}: ${rest}`, ...place(one.id), note: null, reason: detail };
+    }));
+    return [...rows, ...evidence];
+}
+const UNSIGNED_NOTE = /^caveat ([0-9]+) names ("[^"]*"(?:, "[^"]*")*), (?:a criterion the proof authored|which is no signed)[\s\S]*?: ([\s\S]*)$/;
+/** A sentence starts with a capital letter. */
+function sentenceOf(text) {
+    return text === "" ? text : `${text.charAt(0).toUpperCase()}${text.slice(1)}`;
+}
+/** The line a failing check ended on: the last line of its error output that
+ * names an error, else the last line it printed, with its 1-based number in
+ * the saved log. Null when the log printed nothing. */
+export function lastErrorLineOf(log) {
+    const lines = log.split("\n");
+    const printed = (text) => text.trim() !== "" && !/^\$ /.test(text) && !/^\(exit -?[0-9]+\)$/.test(text.trim()) && !/^--- (stdout|stderr) ---$/.test(text.trim());
+    const stderr = lines.findIndex(text => text.trim() === "--- stderr ---");
+    const pick = (from, to) => {
+        let last = null;
+        for (let index = to - 1; index >= from; index -= 1) {
+            if (!printed(lines[index]))
+                continue;
+            if (/error|fail|✗|✕|×|assert|exception|panic|cannot|not found/i.test(lines[index]))
+                return { line: index + 1, text: lines[index].trim() };
+            last ??= index;
+        }
+        return last === null ? null : { line: last + 1, text: lines[last].trim() };
+    };
+    return (stderr >= 0 ? pick(stderr + 1, lines.length) : null) ?? pick(0, stderr >= 0 ? stderr : lines.length);
 }
 /** The result page's own sentence when the decision is on it. */
 export const RESULT_DECISION_SENTENCE = "Review the change, then accept it or ask for changes.";
@@ -331,15 +413,14 @@ export function acceptWordsOf(facts) {
         ...(facts.checks === "passed" ? [] : [facts.checks === "failed" ? "checks failed" : facts.checks === "off" ? "checks are off for this project"
                 : facts.checks === "running" ? "checks are still running" : facts.checks === "unavailable" ? "saved checks can't be read" : "checks didn't run"]),
         ...(facts.unmet > 0 ? [`${plural(facts.unmet, "requirement isn't", "requirements aren't")} met`] : []),
-        ...(facts.yours > 0 ? [`${plural(facts.yours, "item still needs", "items still need")} your check`] : []),
     ];
     const ready = parts.length === 0;
     const joined = parts.length <= 1 ? parts.join("") : `${parts.slice(0, -1).join(", ")} and ${parts.at(-1)}`;
-    const effect = facts.action === "accept" ? "Records that you accept it. You mark it complete next."
-        : facts.publishing === "pull-request" ? "Marks it complete. No pull request opens; you can open one from the task after."
-            : facts.publishing === "off" ? "Marks it complete. The branch stays; publishing isn't set up."
-                : "Marks it complete. Nothing is published.";
-    return { label: ready ? "Accept" : "Accept without checks", ready, why: ready ? null : `${joined.charAt(0).toUpperCase()}${joined.slice(1)}.`, effect };
+    const effect = facts.action === "accept" ? "Records that you accept it. The task stays open."
+        : facts.publishing === "pull-request" ? "Finishes the task. No pull request opens; you can open one from the task after."
+            : facts.publishing === "off" ? "Finishes the task. The branch stays; publishing isn't set up."
+                : "Finishes the task. Nothing is published.";
+    return { label: ready ? "Accept and finish" : "Accept without checks", ready, why: ready ? null : `${joined.charAt(0).toUpperCase()}${joined.slice(1)}.`, effect };
 }
 export function resultHeadlineOf(status) {
     const read = RESULT_NEEDS_YOU.has(status.token) ? { stage: "needs-you", need: "other" }
@@ -470,3 +551,48 @@ export function learningHtml(view, csrf, canManage, source) {
     const history = view.events.map(ev => `<article class="card" data-learning-event="${e(ev.action)}"><p><strong>${e({ assessment: { propose: 'Learning suggested', none: 'No lesson needed', unassessed: 'Learning not assessed', invalid: 'Learning assessment invalid' }[ev.after] ?? 'Learning not assessed', proposal: 'Suggestion recorded', adopt: 'Lesson adopted', disable: 'Lesson disabled', reset: 'Learning reset', enable: 'Reuse enabled', pause: 'Reuse paused', reuse: 'Run context saved', failure: 'Learning issue', capture: 'Capture finished' }[ev.action] ?? ev.action)}</strong>${ev.action === "reuse" ? ` · ${e(ev.after)}` : ""}</p><p class="meta"><time datetime="${e(ev.at)}">${e(ev.at.replace("T", " ").replace(/\.\d+Z$/, " UTC"))}</time> · ${e(ev.actor)}${ev.run === null ? '' : ` · <a href="/r/${ev.run}">Run #${ev.run}</a>${ev.outcome === null ? "" : ` · ${e(ev.outcome)}`}`}</p><details><summary>Details</summary><p>${e(ev.before)} → ${e(ev.after)}</p><p>${e(ev.reason)}</p>${ev.lesson === null ? '' : `<p>Lesson #${ev.lesson}</p>`}<ul>${evidence(ev.evidence, ev.run)}</ul>${ev.snapshot === null ? "" : `<details><summary>Exact context</summary><pre>${e(ev.snapshot)}</pre></details>`}</details></article>`).join('');
     return `<section class="learning">${view.damaged ? '<p class="problem" role="alert">Some lessons no longer verify and are excluded from reuse.</p>' : ''}<p>${view.enabled ? 'Use adopted lessons: on' : 'Use adopted lessons: off'}</p>${act(view.enabled ? 'pause' : 'enable', view.enabled ? 'Pause reuse' : 'Enable reuse')}${cards || '<p>No lessons yet. Reviews may suggest useful advice here.</p>'}<details><summary>Reset learning</summary><p>Disable all adopted lessons and future reuse. Keep history, code, approvals and active run snapshots.</p>${act('reset', 'Reset learning')}</details><h2>Changes</h2>${history || '<p>No learning changes yet.</p>'}${view.next === null ? '' : `<a class="button-link" href="/settings/learning?repo=${encodeURIComponent(view.repo)}&before=${view.next}">Older changes</a>`}</section>`;
 }
+/** The first signed requirement a finished attempt missed (failed or unanswered; a person's own check is not a miss),
+ * with the evidence line behind it in plain words. Null when every requirement held. */
+export function missedRequirementOf(matrix) {
+    const missed = matrix.find(row => row.state === "failed") ?? matrix.find(row => row.state === "missing") ?? null;
+    if (missed === null)
+        return null;
+    const detail = missed.detail.find(one => !/is waiting for the final check/.test(one)) ?? missed.detail[0] ?? null;
+    return { id: missed.id, statement: missed.statement, evidence: detail === null ? (missed.state === "missing" ? "The agent's report doesn't answer it." : null) : requirementEvidenceWords(missed.id, detail) };
+}
+/** A matrix row's recorded detail as a sentence a person reads: the agent's own note when one admits the miss. */
+function requirementEvidenceWords(id, detail) {
+    const caveat = CONTRADICTED_BY_CAVEAT.exec(detail);
+    // The note often names its requirement first ("c1: …"); the line already says which requirement it is.
+    if (caveat !== null && caveat[1] === id)
+        return sentenceOf(`The agent's own note says: ${caveat[2].trim().replace(new RegExp(`^${id.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\s*[:—-]\\s*`), "")}`);
+    const lead = [`criterion "${id}"'s `, `criterion "${id}" `].find(prefix => detail.startsWith(prefix));
+    return sentenceOf(plainReasonWords(lead === undefined ? detail : detail.slice(lead.length)));
+}
+const stepWords = (text) => {
+    const plain = text?.trim().replace(/\s+/g, " ").replace(/[.\s]+$/, "") ?? "";
+    return plain === "" ? null : plain;
+};
+/** A live build's progress: the step in progress (else the first one not done) as "Step N of M: <step>"; a blocked
+ * step replaces it as "Stuck on step N of M: <why>" (its note, else the step itself). Null with no plan steps. */
+export function buildProgressOf(steps) {
+    if (steps == null || steps.length === 0)
+        return null;
+    const total = steps.length;
+    const blocked = steps.findIndex(one => one.state === "blocked");
+    if (blocked >= 0) {
+        const why = stepWords(steps[blocked].note) ?? stepWords(steps[blocked].description);
+        const line = `Stuck on step ${blocked + 1} of ${total}${why === null ? "" : `: ${why}`}.`;
+        return { step: blocked + 1, total, line, stuck: { step: blocked + 1, why, line } };
+    }
+    const current = steps.findIndex(one => one.state === "current");
+    const at = current >= 0 ? current : steps.findIndex(one => one.state !== "completed");
+    if (at < 0)
+        return { step: total, total, line: `All ${total} steps done. Finishing up.`, stuck: null };
+    const words = stepWords(steps[at].description);
+    return { step: at + 1, total, line: `Step ${at + 1} of ${total}${words === null ? "" : `: ${words}`}.`, stuck: null };
+}
+/** Earlier attempts that stopped before the one now running, in one quiet line. */
+export function earlierAttemptsWords(count) {
+    return `${count} earlier attempt${count === 1 ? "" : "s"} stopped`;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "toolroll",
-  "version": "0.9.13",
+  "version": "0.9.15",
   "description": "A control plane for unattended coding agents — queue tasks, walk away, come back to pull requests. Agents build in leased worktrees, never touch your default branch, and interrupt you only for decisions that need a human.",
   "directories": {
     "doc": "docs"