toolroll 0.9.14 → 0.9.16

package/dist/needs-you.d.ts

@@ -35,6 +35,30 @@ export declare const NEEDS: Readonly<Record<NeedKey, Need>>;
 export type Ask = "decide" | "review" | "unblock";
 export declare const ASKS: readonly Ask[];
 export declare const ASK_LABEL: Readonly<Record<Ask, string>>;
+/** A waiting row's chip: the specific thing asked, never its group's own word (no "Decide" chip under Decide).
+ * Null: the group heading and the row's sentence already say it, so the row wears no chip. */
+export type AskChip = "Plan" | "Result" | "Mismatch" | "Plan changed" | "Failed" | "Builder offline";
+/** `mismatch`: the saved report doesn't match its changes; `planChanged`: the plan changed after it was built. */
+export declare function askChipOf(read: {
+    headline: string;
+    need?: NeedKey | null;
+    mismatch?: boolean;
+    planChanged?: boolean;
+    ask?: Ask | null;
+}): AskChip | null;
+/** Why a saved result can't simply be accepted yet, in its own words (each Review row says its own reason,
+ * never a boilerplate line). The facts are the ones the Tasks list and the task page both read. */
+export type ResultHoldUp = {
+    hold: string | null;
+    planChanged: boolean;
+    unapproved: boolean;
+    running: boolean;
+    unfinished: boolean;
+    noCommit: boolean;
+    question: boolean;
+    report: boolean;
+};
+export declare function resultHoldUpSentence(facts: Partial<ResultHoldUp>): string;
 export declare const NEED_ASK: Readonly<Record<NeedKey, Ask>>;
 export declare const WAITS: Readonly<Record<WaitKey, (context: NeedContext) => string>>;
 /** Words that name the machine's internals; no Needs you or Waiting sentence carries them. */
@@ -83,4 +107,28 @@ export declare function isInternalErrorReason(reason: string | null | undefined)
 /** A failed attempt in one plain line: its recorded reason in words (first line only, about 140 characters at most),
  * that it stopped with an internal error when the reason is machine output, or that none was recorded. */
 export declare function failedAttemptSentence(reason: string | null | undefined): string;
+export declare const GENERAL_SUGGESTION = "Say what to do differently this time.";
+export declare function stopSuggestionOf(reason: string | null | undefined): string;
+/** The suggestion for a requirement the result missed: make sure of it before handing off. */
+export declare function missedRequirementSuggestion(statement: string): string;
+/** The suggestion for a check that failed on the result: make it pass, starting with the line it ended on. */
+export declare function failingCheckSuggestion(line: string): string;
+/** What a failed attempt missed, in plain words: what failed (the missed requirement, the failing check's line or the
+ * stop reason), the evidence line behind it, and one suggestion of what to change (Retry's note starts with it). */
+export type FailureExplanation = {
+    kind: "requirement" | "check" | "reason";
+    line: string;
+    evidence: string | null;
+    suggestion: string;
+    link: {
+        label: string;
+        href: string;
+    } | null;
+};
+/** The line for a missed requirement: “Missed: <statement>”, cut to one line. */
+export declare function missedRequirementLine(statement: string): string;
+/** The longest note Retry's field takes. */
+export declare const RETRY_NOTE_LIMIT = 500;
+/** Retry's note, prefilled with the suggestion: cut to what the field takes, at a word, so the form always posts. */
+export declare function retryNoteOf(suggestion: string): string;
 export {};

package/dist/needs-you.js

@@ -28,7 +28,7 @@ export const NEEDS = {
     "connect-builder": { sentence: () => "No builder works on this project yet. Connect one so the task can start.", action: { code: "start-worker", label: "Connect a builder" } },
     "start-builder": { sentence: () => "The builder for this project is offline. Start it and the task begins on its own.", action: { code: "start-worker", label: "Start the builder" } },
     vanished: { sentence: context => `${Build(context)} stopped without finishing. Check it, then retry.`, action: { code: "reconcile-run", label: "Check the build" } },
-    "review-result": { sentence: () => "Check the result, then accept it or ask for changes.", action: { code: "open-result", label: "Review result" } },
+    "review-result": { sentence: () => "Check the result, then accept it or ask for changes.", action: { code: "open-result", label: "Open result" } },
     // Accepting it would not help: it was built to terms that are no longer the plan.
     rebuild: { sentence: context => `${Build(context)} was made to an earlier plan. Build it again to the current plan.`, action: { code: "retry-task", label: "Build again" } },
     "earlier-version": { sentence: () => "An earlier version of this task still needs you. Finish it first.", action: { code: "inspect-task", label: "Open earlier version" } },
@@ -36,6 +36,41 @@ export const NEEDS = {
 };
 export const ASKS = ["decide", "review", "unblock"];
 export const ASK_LABEL = { decide: "Decide", review: "Review", unblock: "Unblock" };
+/** `mismatch`: the saved report doesn't match its changes; `planChanged`: the plan changed after it was built. */
+export function askChipOf(read) {
+    if (read.headline === "Failed")
+        return "Failed";
+    if (read.planChanged === true || read.need === "rebuild")
+        return "Plan changed";
+    if (read.mismatch === true)
+        return "Mismatch";
+    if (read.headline === "Ready for review" || read.need === "review-result" || read.ask === "review")
+        return "Result";
+    if (read.need === "approval")
+        return "Plan";
+    if (read.need === "start-builder" || read.need === "connect-builder")
+        return "Builder offline";
+    return null;
+}
+export function resultHoldUpSentence(facts) {
+    if (facts.hold != null && facts.hold.trim() !== "" && !hasInternalWords(facts.hold))
+        return `On hold: ${facts.hold.trim().replace(/[.\s]*$/, "")}. Release the hold to accept it.`;
+    if (facts.hold != null)
+        return "A hold is on this result. Release it to accept the result.";
+    if (facts.planChanged)
+        return "The plan changed after this was built. Build it again to the current plan.";
+    if (facts.unapproved)
+        return "The current plan isn't approved. Approve it, then review the result.";
+    if (facts.question)
+        return "A question is still open. Answer it, then review the result.";
+    if (facts.running)
+        return "A build is still running on this task.";
+    if (facts.unfinished)
+        return "An earlier attempt never finished. Check it, then review the result.";
+    if (facts.noCommit)
+        return facts.report ? "The report is missing or incomplete. Open it to see what was saved." : "The build saved no commit to review. Open the result to see what was kept.";
+    return "Open the result to see what it needs before you can accept it.";
+}
 export const NEED_ASK = {
     approval: "decide", card: "decide", answer: "decide", questions: "decide", "choose-project": "decide", "define-task": "decide",
     "fix-request": "decide", "choose-agent": "decide",
@@ -138,6 +173,7 @@ export const RUN_REASON_WORDS = {
     "reviewer-error": "the review failed",
     "malformed-report": "the scout's report was malformed",
     "attempts-exhausted": "it failed too many times in a row",
+    "plan-revised": "the plan changed, so a fresh attempt took over",
 };
 /** A run's recorded reason in words. A recorded code is never shown as it is
  * stored: one with no words of its own reads as an unexpected stop; a reason
@@ -190,3 +226,59 @@ export function failedAttemptSentence(reason) {
         : `${words.slice(0, REASON_LINE_LIMIT - 1).replace(/\s+\S*$/, "").replace(/[,;:\s]+$/, "")}…`;
     return `${line.charAt(0).toUpperCase()}${line.slice(1)}${line.endsWith("…") ? "" : "."}`;
 }
+/** What to change before the next attempt, by a stopped run's recorded reason: one plain suggestion, the note Retry
+ * starts with. A reason with no suggestion of its own gets the general one. */
+const STOP_SUGGESTIONS = {
+    acceptance: "Before handing off, check each signed requirement against the changes.",
+    timeout: "Split the work into smaller steps, or name the one part to finish first.",
+    "no-op": "Say exactly which files or behaviour should change.",
+    agent: "Say what to do differently this time, or name the part to try first.",
+    "agent-reported": "Answer what the agent said it was missing, or narrow the task.",
+    "provider-init": "Check the agent is signed in and installed, then retry.",
+    "spawn-failed": "Check the agent is signed in and installed, then retry.",
+    "auth-expired": "Sign the agent in again, then retry.",
+    "provider-protocol": "Retry as it is; if it stops the same way, try another agent.",
+    setup: "Fix the project's setup step, then retry.",
+    git: "Make sure the project's branch is clean and reachable, then retry.",
+    "commit-failure": "Make sure the project's commit hooks pass, then retry.",
+    "moved-head": "Retry: the next attempt starts from where the branch is now.",
+    "moved-branch": "Retry: the next attempt starts from where the branch is now.",
+    "retryable-infra": "Retry as it is.",
+    interrupted: "Retry as it is.",
+    orphaned: "Retry as it is.",
+    capability: "Add what the project is missing, then retry.",
+    "attempts-exhausted": "Say what to do differently this time, or narrow the task.",
+};
+export const GENERAL_SUGGESTION = "Say what to do differently this time.";
+export function stopSuggestionOf(reason) {
+    const code = reason?.trim() ?? "";
+    return STOP_SUGGESTIONS[code] ?? GENERAL_SUGGESTION;
+}
+/** A signed requirement in the middle of a sentence: its first letter lowered unless it starts a name or an acronym. */
+function inSentence(statement) {
+    const plain = statement.trim().replace(/[.\s]+$/, "");
+    return /^[A-Z][a-z]/.test(plain) ? `${plain.charAt(0).toLowerCase()}${plain.slice(1)}` : plain;
+}
+/** The suggestion for a requirement the result missed: make sure of it before handing off. */
+export function missedRequirementSuggestion(statement) {
+    return `Before handing off, make sure ${inSentence(statement)}.`;
+}
+/** The suggestion for a check that failed on the result: make it pass, starting with the line it ended on. */
+export function failingCheckSuggestion(line) {
+    return `Make the check pass. It ended on: ${line.replace(/[.\s]+$/, "")}.`;
+}
+/** The line for a missed requirement: “Missed: <statement>”, cut to one line. */
+export function missedRequirementLine(statement) {
+    const plain = statement.trim().replace(/\s+/g, " ").replace(/[.\s]+$/, "");
+    const cut = plain.length <= REASON_LINE_LIMIT - 10 ? plain : `${plain.slice(0, REASON_LINE_LIMIT - 11).replace(/\s+\S*$/, "")}…`;
+    return `Missed a requirement: ${cut}${cut.endsWith("…") ? "" : "."}`;
+}
+/** The longest note Retry's field takes. */
+export const RETRY_NOTE_LIMIT = 500;
+/** Retry's note, prefilled with the suggestion: cut to what the field takes, at a word, so the form always posts. */
+export function retryNoteOf(suggestion) {
+    const plain = suggestion.trim();
+    if (plain.length <= RETRY_NOTE_LIMIT)
+        return plain;
+    return `${plain.slice(0, RETRY_NOTE_LIMIT - 1).replace(/\s+\S*$/, "").replace(/[,;:\s]+$/, "")}…`;
+}

package/dist/operate.js

@@ -1,4 +1,5 @@
 import { UNSENT_REPLY_MS } from "./telegram-settings.js";
+import { leadNameOf } from "./lead-identity.js";
 import { maybeTriggerRepair } from "./dispose.js";
 import { CHECK_LEVEL_HINTS, CHECK_LEVEL_WORDS, isCheckLevel, liveQuickCommand, projectCheckLevel, quickVerifyKey, setProjectCheckLevel, setTaskCheckLevel, suggestQuickCommand } from "./check-levels.js";
 import { fileAddTestsTask, followUpChecksOf, requestFollowUpChecks, runFollowUpCheck, runWaitingChecks } from "./result-follow-ups.js";
@@ -10698,7 +10699,7 @@ function leadClaimCommand(positional, flags, context) {
     const claimed = leadClaim(store, actor, id, context.clock());
     if (!claimed.ok)
         return fail(write, json, command, claimed.reason, claimed.message, claimed.reason === "usage" ? EXIT.usage : EXIT.refused);
-    return succeed(write, json, command, { task: id, root: claimed.root, lead: claimed.claim }, () => [`${id} is yours: it reads "Your lead is on it" until you complete it, hand it on with task ask, or go two hours without acting on it.`]);
+    return succeed(write, json, command, { task: id, root: claimed.root, lead: claimed.claim }, () => [`${id} is yours: it reads "${leadNameOf(store, actor.account)} is on it" until you complete it, hand it on with task ask, or go two hours without acting on it.`]);
 }
 function blockTask(positional, flags, context) {
     const { store, write, json } = context;

package/dist/project-delete.js

@@ -218,6 +218,7 @@ function deleteRows(store, repo, d, now) {
         del(`${surface}_flow_prompt`, IN("card"), C);
         del(`${surface}_question_action`, IN("question"), questions);
         del(`${surface}_question_prompt`, IN("question"), questions);
+        del(`${surface}_ask_action`, IN("turn"), U);
     }
     del("telegram_action", IN("decision"), decisions);
     del("telegram_decision_message", IN("decision"), decisions);
@@ -242,6 +243,7 @@ function deleteRows(store, repo, d, now) {
     del("team_mate_session", IN("thread"), H);
     del("mate_turn_evidence", `${IN("turn")} OR ${IN("run")} OR ${IN("task_ref")} OR ${IN("artifact")}`, U, R, T, A);
     del("chat_turn", IN("mate_turn"), U);
+    del("mate_ask", IN("turn"), U);
     del("mate_turn", IN("id"), U);
     del("mate_proposal", IN("id"), proposals);
     del("mate_message", IN("thread"), H);
@@ -318,7 +320,7 @@ function deleteRows(store, repo, d, now) {
     for (const [table, column] of SETTINGS)
         del(table, `${column} = ?`, repo);
     del("project_mute", "repo = ?", repo);
-    for (const table of ["knowledge_change", "project_skill_change", "memory_gap", "memory_proposal", "memory_rejection", "memory_session", "memory_search", "mode_rail", "side_spend", "watch_episode", "worktree", "coordinator_proposal"])
+    for (const table of ["knowledge_change", "project_skill_change", "memory_gap", "memory_proposal", "memory_rejection", "memory_session", "memory_search", "mode_rail", "side_spend", "watch_episode", "worktree", "coordinator_proposal", "lead_commitment"])
         del(table, "repo = ?", repo);
     // A builder watching the project keeps its lease until it stops; an ended one goes.
     del("watch_lease", "repo = ? AND expires_at <= ?", repo, now.toISOString());

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,33 @@
  *                                         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. */
+import type { ProofVerdict } from "./proof.js";
 /** 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";
+/** What kind of evidence problem a verdict records: a check the machine
+ * actually ran and saw fail, evidence that contradicts the sealed record
+ * (a mismatched changed-path claim, an altered criterion, a caveat that
+ * contradicts a met verdict), or evidence that is simply absent. A generic
+ * refuted verdict is NOT a failed test claim — only the verify-command
+ * reasons say a check failed. */
+export type EvidenceProblem = "checks-failed" | "mismatched" | "missing" | "none";
+export declare const FAILED_CHECK: RegExp;
+export declare function evidenceProblemOf(verdict: ProofVerdict | null, reasons: readonly string[]): EvidenceProblem;
+/** Why a result can't be accepted as it stands, in one plain line, or 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;
+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 +55,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 +75,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,43 @@
  *                                         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 const FAILED_CHECK = /^the repository's approved verification command exited (-?[0-9]+)/;
+export function evidenceProblemOf(verdict, reasons) {
+    if (verdict === "verified" || verdict === "attested")
+        return "none";
+    if (verdict === "refuted")
+        return reasons.some(reason => FAILED_CHECK.test(reason)) ? "checks-failed" : "mismatched";
+    return "missing";
+}
+/** Why a result can't be accepted as it stands, in one plain line, or null
+ * when nothing refutes it (a person's acceptance settles it). The result page
+ * shows it before Request changes, its one ink act. */
+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."
+        : ACCEPT_NEEDS_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 +57,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 +72,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/retention.js

@@ -263,11 +263,17 @@ export function sweepRetention(store, evidenceRoot, now, actor = "worker") {
         if (periods.chat !== null) {
             const team = db.prepare("DELETE FROM team_message WHERE message = ? AND status NOT IN ('queued', 'running', 'uncertain')");
             const message = db.prepare("DELETE FROM mate_message WHERE id = ? AND NOT EXISTS (SELECT 1 FROM team_message WHERE message = ?)");
+            const asked = db.prepare("SELECT turn FROM mate_message WHERE id = ? AND role = 'assistant' AND turn IS NOT NULL");
+            // The lead's question goes with the reply that asked it; its buttons then say it expired.
+            const ask = db.prepare("DELETE FROM mate_ask WHERE turn = ? AND NOT EXISTS (SELECT 1 FROM mate_message WHERE turn = ? AND role = 'assistant')");
             for (const one of plan.items.chat) {
                 team.run(one.id);
+                const turn = asked.get(one.id)?.["turn"];
                 if (Number(message.run(one.id, one.id).changes) === 1) {
                     done.chat.count++;
                     done.chat.bytes += one.bytes;
+                    if (turn !== undefined && turn !== null)
+                        ask.run(Number(turn), Number(turn));
                 }
             }
         }

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