toolroll 0.9.56 → 0.9.57

package/dist/task-status.js

@@ -27,6 +27,17 @@ export const CHECKS_LABEL = "Project checks";
 export const PR_CI_LABEL = "PR CI";
 /** The one verb for opening a saved result, on every surface. */
 export const OPEN_RESULT = "Open result";
+export const CHECKED_AT_RELEASE = "Checked at release";
+export function releaseStateOf(checks) {
+    if (checks?.level !== "off" || checks.status === "passed" || checks.status === "failed")
+        return undefined;
+    return checks.release != null ? "covered" : "pending";
+}
+/** How the project check stands for requirements that rest on it, read now: `covered` once a check passed on this
+ * commit (its own, a follow-up, or a release check containing it), `pending` while checks Off wait for a release. */
+export function checkBackingOf(checks) {
+    return checks?.status === "passed" ? "covered" : checksUnderway(checks) ? "running" : releaseStateOf(checks);
+}
 /** "T2", "T2 and T3", "T2, T3 and 2 more": short enough for one line. The full list is on the result. */
 export function peerWords(peers, shown = 2) {
     if (peers.length <= shown)
@@ -43,6 +54,23 @@ const BATCH_WHY = {
     conflict: "It conflicted with another result when merged for a batch check, so it was checked on its own.",
 };
 const short = (sha) => sha !== null && /^[a-f0-9]{7,40}$/.test(sha) ? sha.slice(0, 7) : null;
+/** A check waiting for its batch or running on this commit: the result reads Ready meanwhile, not Needs you. */
+const checksUnderway = (checks) => checks?.batch?.state === "waiting" || checks?.running != null;
+/** A finished result a person still has to act on before it can be complete: an unresolved HIGH finding or unmet
+ * requirement, a missing check, or a requirement only they can confirm. Failed checks read Failed instead. */
+function resultAsk(facts) {
+    if (facts.report || facts.checks?.status === "failed")
+        return null;
+    const blocker = facts.blockers?.find(one => one.key !== "check-failed" && !(one.key === "check-missing" && checksUnderway(facts.checks)));
+    if (blocker !== undefined)
+        return blocker.message;
+    const req = facts.requirements;
+    if (req == null || facts.accepted === true || req.unverified === true)
+        return null;
+    if ((req.yours > 0 || (req.unshown ?? 0) > 0) && req.ask != null)
+        return req.ask;
+    return null;
+}
 export function headlineOf(facts) {
     switch (facts.stage) {
         case "queued": return "Queued";
@@ -57,7 +85,10 @@ export function headlineOf(facts) {
                 return "Ready for review";
             if (facts.checks?.status === "failed")
                 return "Failed";
-            // Off: ready like any build; the sentence and the Checks row say no check ran.
+            // A requirement a person checks, a missing screenshot, an unmet requirement or a HIGH finding: Needs you, with the ask.
+            if (resultAsk(facts) !== null)
+                return "Needs you";
+            // Off: ready like any build; the sentence and the Checks row say it is checked at release.
             return "Ready for review";
         case "complete": return "Complete";
         case "failed": return "Failed";
@@ -71,15 +102,17 @@ function sentenceOf(headline, facts) {
         case "Queued": return reason ?? "Waiting for a worker.";
         case "Planning": return reason ?? "The lead is writing the plan.";
         // One plain sentence per need (needs-you.ts); a recorded reason only where the need keeps one.
-        case "Needs you": return needSentence(facts.need ?? "other", reason, facts.needContext);
+        case "Needs you": return facts.stage === "finished" ? resultAsk(facts) ?? needSentence("review-result", reason, facts.needContext) : needSentence(facts.need ?? "other", reason, facts.needContext);
         case "Waiting": return waitSentence(facts.wait, reason, facts.needContext);
         case "Building": return facts.stage === "checking" ? "Checks are running on the change."
             : facts.stage === "reviewing" ? "Reviewing the change before it reaches you." : reason ?? "An agent is working on it.";
         case "Ready for review":
             if (facts.report)
                 return "The report is ready to read. Read it, then mark it complete.";
+            if (releaseStateOf(facts.checks) === "covered")
+                return `Checked at release on ${short(facts.checks.release.head) ?? "its release"}. Review the change, then mark it complete.`;
             if (facts.checks?.level === "off" && facts.checks.status !== "passed")
-                return "Checks are off for this project. Review the change, then mark it complete.";
+                return "Checked at release. Review the change, then mark it complete.";
             if (facts.checks?.status === "passed") {
                 // The Checks row names the others and the batch commit; the sentence doesn't repeat them.
                 const peers = facts.checks.batch?.state === "together" ? facts.checks.batch.peers.length : 0;
@@ -135,8 +168,10 @@ function detailsOf(headline, facts) {
             row("checks", CHECKS_LABEL, `${quick ? "Quick checks failed" : "Failed"}${checks.exitCode === null ? "" : ` (exit ${checks.exitCode})`}`, problem(headline), headline === "Failed" ? { href: checksHref } : { action: { label: "See what failed", href: checksHref } });
         else if (checks.status === "running")
             row("checks", CHECKS_LABEL, "Running", "running");
+        else if (checks.level === "off" && checks.release != null)
+            row("checks", CHECKS_LABEL, `Passed at release on ${short(checks.release.head) ?? `build #${checks.release.run}`}`, "ok", { href: checksHref });
         else if (checks.level === "off")
-            row("checks", CHECKS_LABEL, "Off for this project", "none", runChecks === null ? {} : { action: runChecks });
+            row("checks", CHECKS_LABEL, CHECKED_AT_RELEASE, "none", runChecks === null ? {} : { action: runChecks });
         else if (checks.status === "not-run")
             row("checks", CHECKS_LABEL, "Didn't run", "none", runChecks === null ? {} : { action: runChecks });
         // A saved check that can't be read is run again where that is possible.
@@ -173,8 +208,9 @@ function detailsOf(headline, facts) {
     else if (req != null && req.total > 0 && req.unverified === true)
         row("requirements", "Requirements", "Unverified", "none");
     else if (req != null && req.total > 0) {
-        const unmet = req.total - req.met - req.yours;
-        const text = `${req.met} of ${req.total} met${req.yours > 0 ? ` · You check ${req.yours}` : ""}`;
+        const atRelease = req.atRelease ?? 0;
+        const unmet = req.total - req.met - req.yours - atRelease;
+        const text = `${req.met} of ${req.total} met${atRelease > 0 ? ` · ${atRelease} at release` : ""}${req.yours > 0 ? ` · You check ${req.yours}` : ""}`;
         row("requirements", "Requirements", text, unmet > 0 ? problem(headline) : req.met === req.total ? "ok" : "none", unmet > 0 && headline !== "Failed" ? { action: { label: "See which", href: facts.links?.checks ?? facts.links?.result ?? null } } : {});
     }
     const evidence = facts.evidence;
@@ -203,19 +239,23 @@ function leadSentence(headline, facts) {
         return `${facts.checks.level === "quick" ? "Quick checks" : "Checks"} failed${sha === null ? "" : ` on ${sha}`}. ${leadOnIt(facts.leadName)}`;
     return leadOnIt(facts.leadName);
 }
-export function taskStatusOf(facts) {
+/** The one status every surface shows (console list, task and result pages, CLI, chat, phone, `status`). */
+export function statusOf(facts) {
     const read = headlineOf(facts);
     const lead = facts.lead != null && LEAD_HEADLINES.has(read) ? facts.lead : null;
     // The lead has it: nothing waits on the person, so a Needs you reads Waiting.
     const headline = lead === "on-it" && read === "Needs you" ? "Waiting" : read;
-    // Every Needs you carries the one action that resolves it, worded the same everywhere.
-    const need = headline === "Needs you" ? { key: facts.need ?? "other", action: NEEDS[facts.need ?? "other"].action } : null;
+    // Every Needs you carries the one action that resolves it, worded the same everywhere; a finished result's is Open result.
+    const needKey = facts.stage === "finished" ? "review-result" : facts.need ?? "other";
+    const need = headline === "Needs you" ? { key: needKey, action: NEEDS[needKey].action } : null;
     const ownWords = need !== null && (need.key === "other" || need.key === "review-result") && facts.action != null;
     const primaryAction = need === null || ownWords ? facts.action ?? null : { label: need.action.label, href: facts.action?.href ?? null };
     const sentence = lead === "on-it" ? leadSentence(headline, facts) : lead === "lapsed" ? `${leadLapsed(facts.leadName)} ${sentenceOf(headline, facts)}` : sentenceOf(headline, facts);
     return { headline, tone: HEADLINE_TONE[headline], sentence, details: detailsOf(headline, facts),
         primaryAction, why: [...new Set(facts.why ?? [])].filter(one => one.trim() !== ""), need };
 }
+/** The name most surfaces already import. */
+export const taskStatusOf = statusOf;
 // ---- reading the existing projections ----------------------------------------
 /** Every dispatch or work-index code, as the stage it means. Unknown codes that
  * wait on a person stay Needs you; everything else waits in the queue. */
@@ -316,19 +356,93 @@ export function assignmentStageOf(assignment, work, planning = false) {
 }
 /** Evidence that passed and only awaits the retired assessment step is met. */
 const requirementMet = (row) => row.state === "pass" || (row.assessment?.evidenceState === "pass" && (row.review ?? null) === null);
-export function requirementWordOf(row, verdict) {
+/** A requirement whose only gap is the project check: every other kind it needs was shown, none is a person's check. */
+const onlyCheckMissing = (row) => {
+    const needs = row.requiredEvidence ?? [];
+    const answered = new Set((row.answered ?? []).map(one => one.kind));
+    if (row.state !== "missing" || row.review != null || row.assessment?.evidenceState === "failed" ||
+        !needs.includes("check") || needs.includes("manual-review") || !needs.every(kind => kind === "check" || answered.has(kind)))
+        return false;
+    // `answered` contains claims, not validated evidence. In legacy matrices a missing
+    // check takes precedence over an invalid screenshot/changed path in `state`.
+    // Only the stored validator's check-only gaps establish that every other
+    // reference resolved. Direct assessment keeps these outcomes in its own detail.
+    const detail = row.assessment?.detail ?? row.detail ?? [];
+    const checkGaps = new Set([
+        `criterion "${row.id}" requires check evidence, which the proof does not reference`,
+        `criterion "${row.id}" is waiting for the final check`,
+        `criterion "${row.id}" needs a passing approved project check`,
+    ]);
+    return (needs.every(kind => kind === "check") || detail.length > 0) && detail.every(one => checkGaps.has(one));
+};
+/** A required screenshot nobody captured. */
+const screenshotMissing = (row) => (row.requiredEvidence ?? []).includes("screenshot") && !(row.answered ?? []).some(one => one.kind === "screenshot");
+export function requirementWordOf(row, verdict, release) {
     if (verdict === "refuted")
         return "Unverified";
     if (requirementMet(row))
         return "Met";
-    return row.state === "manual-review" ? "You check" : row.state === "missing" ? "Not shown yet" : "Not met";
+    if (release !== undefined && onlyCheckMissing(row))
+        return release === "covered" ? "Met" : release === "running" ? "Waiting for checks" : CHECKED_AT_RELEASE;
+    if (row.state === "manual-review")
+        return "You check";
+    return row.state === "missing" || screenshotMissing(row) ? "Not shown yet" : "Not met";
+}
+const ASK_STATEMENT = 140;
+const quoted = (statement) => {
+    const one = (statement ?? "").replace(/\s+/g, " ").trim();
+    return one.length > ASK_STATEMENT ? `${one.slice(0, ASK_STATEMENT - 1)}…` : one;
+};
+/** The ask for one unresolved requirement: what is wrong with it, and the two ways on. */
+function unresolvedAsk(row, word) {
+    const what = word === "Not shown yet" && screenshotMissing(row) ? "A screenshot is missing for"
+        : word === "Not shown yet" ? "Nothing shows this requirement is met" : word === "Unverified" ? "This requirement couldn't be verified" : "This requirement isn't met";
+    return `${what}: ${quoted(row.statement) || row.id || "a requirement"}. Ask for changes, or accept the result with a reason.`;
 }
 /** Requirements from the stored matrix: met, the ones only a person confirms, and the total. */
-export function requirementsOf(matrix) {
+export function requirementsOf(matrix, release) {
     if (!matrix || matrix.length === 0)
         return null;
-    return { met: matrix.filter(requirementMet).length, total: matrix.length, yours: matrix.filter(row => requirementWordOf(row) === "You check").length,
-        missed: matrix.filter(row => !requirementMet(row) && (row.state === "failed" || row.state === "missing")).length };
+    const words = matrix.map(row => requirementWordOf(row, null, release));
+    const yours = matrix.find((_, index) => words[index] === "You check");
+    const unshown = matrix.filter((row, index) => words[index] === "Not shown yet" && screenshotMissing(row));
+    const ask = yours !== undefined ? `Check this requirement yourself, then mark it complete: ${quoted(yours.statement)}`
+        : unshown.length > 0 ? unresolvedAsk(unshown[0], "Not shown yet") : null;
+    return { met: words.filter(word => word === "Met").length, total: matrix.length, yours: words.filter(word => word === "You check").length,
+        missed: words.filter(word => word === "Not met" || word === "Not shown yet").length,
+        ...(release !== "pending" ? {} : { atRelease: words.filter(word => word === CHECKED_AT_RELEASE).length }),
+        ...(unshown.length === 0 ? {} : { unshown: unshown.length }),
+        ...(ask === null ? {} : { ask }) };
+}
+/** What refuses Complete, for `task complete`, the console and chat completion and deploy-candidate alike: a failed
+ * check; a required check that is missing (checks deliberately Off are not missing: they are checked at release);
+ * an unresolved requirement (a person's own check is theirs to give by completing; a recorded acceptance resolves
+ * the rest); an unresolved HIGH review finding. A release check that covers the commit counts as passed. */
+export function completionBlockersOf(f) {
+    const blockers = [];
+    const release = releaseStateOf(f.checks);
+    const backing = checkBackingOf(f.checks);
+    if (!f.report && f.checks?.status === "failed") {
+        blockers.push({ key: "check-failed", message: `Checks failed${f.checks.exitCode === null ? "" : ` (exit ${f.checks.exitCode})`}. Fix them and run checks again, or ask for changes.` });
+    }
+    else if (!f.report && f.checkRequired && f.checks?.status !== "passed" && release === undefined) {
+        blockers.push({ key: "check-missing", message: checksUnderway(f.checks) ? "Its project check hasn't finished yet. Mark it complete once it passes."
+                : "No passing project check is recorded for this result. Run checks on it, then mark it complete." });
+    }
+    if (!f.accepted && f.checks?.status !== "failed") {
+        const refuted = f.verdict === "refuted";
+        const unresolved = (f.matrix ?? []).map(row => ({ row, word: requirementWordOf(row, refuted ? "refuted" : null, backing) }))
+            .filter(one => one.word === "Not met" || one.word === "Not shown yet" || one.word === "Unverified");
+        if (unresolved.length === 1)
+            blockers.push({ key: "criteria", message: unresolvedAsk(unresolved[0].row, unresolved[0].word) });
+        else if (unresolved.length > 1) {
+            const ids = unresolved.map(one => one.row.id ?? "?");
+            blockers.push({ key: "criteria", message: `${unresolved.length} requirements ${unresolved.every(one => one.word === "Unverified") ? "couldn't be verified" : "aren't met yet"} (${ids.slice(0, 6).join(", ")}${ids.length > 6 ? ", …" : ""}). Ask for changes, or accept the result with a reason.` });
+        }
+    }
+    if (f.high > 0)
+        blockers.push({ key: "high", message: `The automatic review found ${f.high === 1 ? "a high-severity problem" : `${f.high} high-severity problems`}. Ask for changes before marking it complete.` });
+    return blockers;
 }
 /** A refuted report verifies none of its requirements, whatever it marked met (a person's acceptance doesn't change that). */
 export function unverifiedWhenRefuted(requirements, verdict) {
@@ -355,7 +469,7 @@ export function assignmentStatusFacts(assignment, options = {}) {
     const checks = receipt === null || !withResult ? null
         : { status: receipt.checks.status, exitCode: receipt.checks.exitCode, head: receipt.head,
             ...(receipt.checks.level == null ? {} : { level: receipt.checks.level }), ...(receipt.checks.running == null ? {} : { running: receipt.checks.running }),
-            ...(receipt.checks.batch == null ? {} : { batch: receipt.checks.batch }) };
+            ...(receipt.checks.batch == null ? {} : { batch: receipt.checks.batch }), ...(receipt.checks.release == null ? {} : { release: receipt.checks.release }) };
     const publication = assignment.publication;
     const pullRequest = options.pullRequest !== undefined ? options.pullRequest
         : publication === null ? (withResult && !report ? { state: "none", number: null, url: null, ci: null, error: null } : null)
@@ -368,7 +482,9 @@ export function assignmentStatusFacts(assignment, options = {}) {
         stage, ...(need === undefined ? {} : { need }), ...(wait === undefined ? {} : { wait }), ...(build === null ? {} : { needContext: { build } }), reason, report,
         checks,
         pullRequest: withResult ? pullRequest : null,
-        requirements: withResult ? unverifiedWhenRefuted(requirementsOf(receipt?.proof?.matrix), receipt?.proof?.verdict) : null,
+        requirements: withResult ? unverifiedWhenRefuted(requirementsOf(receipt?.proof?.matrix, checkBackingOf(checks)), assignment.readiness?.verdict ?? receipt?.proof?.verdict) : null,
+        ...(withResult && receipt?.proofAcceptance != null ? { accepted: true } : {}),
+        ...(withResult && (assignment.readiness?.blockers.length ?? 0) > 0 ? { blockers: assignment.readiness.blockers } : {}),
         evidence: withResult ? options.evidence ?? evidenceOf(receipt, [...(receipt?.caveats ?? []), ...assignment.attention]) : null,
         completedBy: assignment.completion === null ? null : assignment.completion.lead === true ? "the lead" : assignment.completion.actor.replace(/^(?:operator|coordinator|lead):/, ""),
         action: options.action ?? null,

package/dist/team-runtime.js

@@ -58,7 +58,7 @@ export function createTeamRuntime(options) {
         const previous = pages.get(key);
         if (revision && previous?.revision === revision && previous.expires > now.getTime())
             return previous.page;
-        const page = workIndexPage(store, now, { principal: 'operator', repos: selected.projects }, { leadId: selected.leadId, limit: 40 });
+        const page = workIndexPage(store, now, { principal: 'operator', repos: selected.projects }, { leadId: selected.leadId, limit: 40, root: options.evidenceRoot });
         if (revision && options.workspaceRevision) {
             if (pages.size >= 64)
                 pages.delete(pages.keys().next().value);

package/dist/telegram-status.d.ts

@@ -17,9 +17,16 @@ export declare const PHONE_HELP: string;
 /** The same display scrub for every phone-bound string a person or a model authored. */
 export declare const phoneText: typeof publicChatText;
 export declare function projectLabel(repo: string): string;
+/** The phone's reading of saved results: `root` lets a finished result read its saved checks, requirements and
+ * review exactly as the console does. Without it, the dispatch diagnosis speaks. */
+export type PhoneRead = {
+    root?: string | undefined;
+    now?: Date;
+    repos?: readonly string[];
+};
 /** repos is the transport's explicit enrollment ceiling, never opened-project
  * history. This snapshot is intentionally bounded and advertises that bound. */
-export declare function phoneStatus(store: Store, repos: readonly string[], now: Date, focused?: string | null): string;
+export declare function phoneStatus(store: Store, repos: readonly string[], now: Date, focused?: string | null, root?: string): string;
 /** One task a person can pick to talk about from a chat app. */
 export type PhoneTaskChoice = {
     id: string;
@@ -31,7 +38,7 @@ export type PhoneTaskChoice = {
  * then work in progress, waiting work and recent results; one entry per
  * task (its revisions share it), optionally narrowed by words in the id or
  * title. Bounded, within the chat's own project ceiling. */
-export declare function phoneTaskChoices(store: Store, repos: readonly string[], now: Date, query?: string | null, limit?: number): PhoneTaskChoice[];
+export declare function phoneTaskChoices(store: Store, repos: readonly string[], now: Date, query?: string | null, limit?: number, root?: string): PhoneTaskChoice[];
 /** `id` keys the chat's choice (the task's first version, where its chat
  * lives); `view` is what to show: the exact version named, else the current one. */
 export type PhoneTaskPick = {
@@ -63,10 +70,10 @@ export type PhoneTaskLink = {
 };
 /** Where the rest lives when no button can say so: the closing line of an unlinked `/task`. */
 export declare const PHONE_CONSOLE_FOOTER = "Read-only status. Saved files and full actions are in the console.";
-export declare function phoneTask(store: Store, repos: readonly string[], id: string, now: Date): string;
+export declare function phoneTask(store: Store, repos: readonly string[], id: string, now: Date, root?: string): string;
 /** One task's status for a chat app: the words, its one console link, and
  * the saved result it shows (a reply to it is about that result). */
-export declare function phoneTaskView(store: Store, repos: readonly string[], id: string, now: Date): {
+export declare function phoneTaskView(store: Store, repos: readonly string[], id: string, now: Date, root?: string): {
     text: string;
     link: PhoneTaskLink | null;
     run: number | null;

package/dist/telegram-status.js

@@ -4,7 +4,8 @@ import { manualReviewOnly } from "./proof.js";
  * No provider calls, repository access, new workflow state, or inferred success. */
 import { diagnoseTaskDispatch, withDispatchDiagnoses } from "./dispatch.js";
 import { familyCompleted } from "./result-completion.js";
-import { plainReasonOf, stageOfDispatch, taskStatusOf } from "./task-status.js";
+import { assignmentStatusFacts, plainReasonOf, stageOfDispatch, taskStatusOf } from "./task-status.js";
+import { assignmentOf } from "./assignment.js";
 import { CHAT_CONTROLS, chatControlHref, chatResultHref } from "./chat-controls.js";
 export function phoneCommand(text) {
     // Slash forms everywhere; the bare words too, because Slack and Discord
@@ -53,10 +54,16 @@ export function projectLabel(repo) {
     return plain(repo.split(/[\\/]/).filter(Boolean).pop() ?? "project", 48);
 }
 /** The shared headline (task-status.ts) for a dispatch diagnosis on the phone. */
-function headlineFor(store, id, d) {
+function headlineFor(store, id, d, read_ = {}) {
     // Any version of a completed family reads Complete, as taskWaitSnapshot says.
     const completed = d.code === "complete" && familyCompleted(store, id);
     const read = stageOfDispatch(d, { completed });
+    // A finished result reads the console's own facts: its requirements, checks Off at release, and what holds it back.
+    if (read.stage === "finished" && read_.root !== undefined && read_.now !== undefined && read_.repos !== undefined) {
+        const assignment = assignmentOf(store, id, read_.now, { principal: "operator", repos: read_.repos }, read_.root);
+        if (assignment !== null && assignment.state === "ready-to-check")
+            return taskStatusOf(assignmentStatusFacts(assignment));
+    }
     const finished = read.stage === "finished" || read.stage === "complete" || read.stage === "failed";
     return taskStatusOf({ stage: read.stage, ...(read.need === undefined ? {} : { need: read.need }), reason: finished ? null : plainReasonOf(read.stage, d.code, d.detail),
         checks: read.stage === "failed" && d.code === "proof-refuted" ? { status: "failed", exitCode: null, head: null } : null });
@@ -95,7 +102,7 @@ function nextStep(d) {
 }
 /** repos is the transport's explicit enrollment ceiling, never opened-project
  * history. This snapshot is intentionally bounded and advertises that bound. */
-export function phoneStatus(store, repos, now, focused = null) {
+export function phoneStatus(store, repos, now, focused = null, root) {
     if (repos.length === 0)
         return "No connected projects are available to this bridge. Add a project in Toolroll, then send /status again.";
     return store.transact(() => {
@@ -111,7 +118,7 @@ export function phoneStatus(store, repos, now, focused = null) {
                 continue;
             lines.push(`${group} · ${rows.length}${snapshot.tasksSaturated ? " in this snapshot" : ""}`);
             for (const task of rows.slice(0, 2)) {
-                lines.push(`${plain(task.id, 64)} · ${projectLabel(repos[task.repoIndex])}`, `  ${plain(task.title, 64)} — ${headlineFor(store, task.id, task.dispatch).headline}`);
+                lines.push(`${plain(task.id, 64)} · ${projectLabel(repos[task.repoIndex])}`, `  ${plain(task.title, 64)} — ${headlineFor(store, task.id, task.dispatch, { root, now, repos }).headline}`);
             }
             if (rows.length > 2)
                 lines.push(`  +${rows.length - 2} more in the console`);
@@ -126,7 +133,7 @@ const PICK_GROUPS = ["Needs attention", "Working", "Waiting / next up", "Finishe
  * then work in progress, waiting work and recent results; one entry per
  * task (its revisions share it), optionally narrowed by words in the id or
  * title. Bounded, within the chat's own project ceiling. */
-export function phoneTaskChoices(store, repos, now, query = null, limit = 8) {
+export function phoneTaskChoices(store, repos, now, query = null, limit = 8, root) {
     if (repos.length === 0)
         return [];
     return store.transact(() => {
@@ -142,7 +149,7 @@ export function phoneTaskChoices(store, repos, now, query = null, limit = 8) {
             if (seen.has(id) || !words.every(word => `${id} ${row.title}`.toLowerCase().includes(word)))
                 continue;
             seen.add(id);
-            choices.push({ id, title: plain(row.title, 64), label: headlineFor(store, row.id, row.dispatch).headline, group: groupOf(row.dispatch) });
+            choices.push({ id, title: plain(row.title, 64), label: headlineFor(store, row.id, row.dispatch, { root, now, repos }).headline, group: groupOf(row.dispatch) });
             if (choices.length >= limit)
                 break;
         }
@@ -210,12 +217,12 @@ function taskLinkFor(id, d, result) {
         default: return control("task");
     }
 }
-export function phoneTask(store, repos, id, now) {
-    return phoneTaskView(store, repos, id, now).text;
+export function phoneTask(store, repos, id, now, root) {
+    return phoneTaskView(store, repos, id, now, root).text;
 }
 /** One task's status for a chat app: the words, its one console link, and
  * the saved result it shows (a reply to it is about that result). */
-export function phoneTaskView(store, repos, id, now) {
+export function phoneTaskView(store, repos, id, now, root) {
     return store.transact(() => {
         const ref = store.lookupRef(id);
         // Check admission before reading a title, run, proof, or diagnosis.
@@ -225,7 +232,7 @@ export function phoneTaskView(store, repos, id, now) {
         const d = diagnoseTaskDispatch(store, id, now);
         if (d === null)
             return { text: "This task's status is unavailable. Open it in the console before retrying.", link: null, run: null };
-        const shared = headlineFor(store, id, d);
+        const shared = headlineFor(store, id, d, { root, now, repos });
         const lines = [plain(task.title, 140), `${plain(id, 64)} · ${projectLabel(ref.repo)}`, `As of ${now.toISOString().replace("T", " ").slice(0, 19)} UTC`, "", shared.headline];
         const blocker = d.blockerTaskId === null ? null : store.lookupRef(d.blockerTaskId);
         const hiddenDependency = blocker !== null && (blocker.repo === null || !repos.includes(blocker.repo));

package/dist/telegram.js

@@ -1884,9 +1884,9 @@ function applyPhoneRead(context, update, effects) {
                 const repos = telegramConversationRepos(store, binding.approver, registry);
                 const focused = focusedTitle(store, binding);
                 if (command.kind === "status")
-                    response = phoneStatus(store, repos, clock(), focused?.title ?? null);
+                    response = phoneStatus(store, repos, clock(), focused?.title ?? null, context.conversation?.evidenceRoot);
                 else if (command.kind === "tasks") {
-                    const choices = phoneTaskChoices(store, repos, clock());
+                    const choices = phoneTaskChoices(store, repos, clock(), null, 8, context.conversation?.evidenceRoot);
                     response = choices.length === 0 ? phoneTaskListText([], null) : `${focused === null ? "" : `Talking about: ${focused.title}\n\n`}Pick a task to talk about:`;
                     if (choices.length > 0)
                         keyboard = pickKeyboard(store, choices, focused !== null);
@@ -1901,7 +1901,7 @@ function applyPhoneRead(context, update, effects) {
                         response = PHONE_NO_MATCH;
                     else {
                         store.setChatFocus("telegram", binding.id, pick.id, clock());
-                        const view = phoneTaskView(store, repos, pick.view, clock());
+                        const view = phoneTaskView(store, repos, pick.view, clock(), context.conversation?.evidenceRoot);
                         shown = { task: pick.view, run: view.run };
                         button = phoneLinkButton(context.conversation?.phoneOrigin?.() ?? null, view.link);
                         // A destination with no trusted origin to carry it: the words say where instead.
@@ -2124,7 +2124,7 @@ function applyCallback(context, update, effects) {
         store.setChatFocus("telegram", binding.id, id, clock());
         ack(`Talking about: ${title}`.slice(0, 190));
         const current = store.taskFamilyOf(taskId, repos, false)?.current.id ?? id;
-        const view = phoneTaskView(store, repos, current, clock());
+        const view = phoneTaskView(store, repos, current, clock(), context.conversation?.evidenceRoot);
         store.recordTelegramTaskMessage(binding, String(message.message_id), current, view.run, clock());
         editText(phoneFocusText(view.text), [[telegramButton("Back to the lead", "pick:lead")]]);
         return;

package/dist/work-index.d.ts

@@ -1,5 +1,5 @@
 import { type Store, type TaskState } from './store.js';
-import type { AssignmentSnapshot } from './assignment.js';
+import { type AssignmentSnapshot } from './assignment.js';
 import type { WorkAction, WorkSummaryAccess } from './work-summary.js';
 import type { WorkStatus, WorkView } from './workspace-ui.js';
 import { type Ask, type AskChip } from './needs-you.js';
@@ -37,6 +37,7 @@ export type WorkIndexItem = {
     /** The viewer's own lead took it on (lead-voice.ts): "<name> is on it.", by the name they gave it, read now. */
     lead?: string;
 };
+/** `root`: the evidence root, so a result whose checks were Off can read the release check that covers it. */
 export type WorkIndexOptions = {
     view?: WorkView;
     limit?: number;
@@ -44,6 +45,7 @@ export type WorkIndexOptions = {
     project?: string | null;
     state?: TaskState;
     leadId?: string;
+    root?: string;
 };
 /** How the list is grouped: the Needs you rows by their ask, then building, then the rest. */
 export type WorkIndexGroup = Ask | 'building' | 'rest';
@@ -78,6 +80,9 @@ export declare class WorkIndexCursorError extends Error {
  * Project counters share the page's admitted project/state filter.
  * Cursors bind the admitted scope, project and view, never broaden access. */
 export declare function workIndexPage(store: Store, now: Date, access: WorkSummaryAccess, options?: WorkIndexOptions): WorkIndexPage;
+/** An exact family lookup through the list's saved-fact projection. It remains
+ * permission-bound and bypasses pagination, never action-time verification. */
+export declare function workIndexTask(store: Store, taskId: string, now: Date, access: WorkSummaryAccess, root?: string): WorkIndexItem | null;
 export declare function workCountsByProject(store: Store, now: Date, access: WorkSummaryAccess): WorkProjectCounts[];
 /** Families whose headline is Ready for review, newest first: the Tasks
  * list's own rows, so a completed family (root or any revision), a failed

package/dist/work-index.js

@@ -8,8 +8,12 @@ import { join } from 'node:path';
 import { readProjectAccess } from './project-access.js';
 import { pauseOnTaskProviders, providerName, signInReason } from './provider-auth.js';
 import { scopeTermsProblem, stopFactOf } from './store.js';
-import { leadOnIt, plainReasonOf, replacedWords, stageOfCode, taskStatusOf, workToneOf } from './task-status.js';
-import { isCheckLevel } from './check-levels.js';
+import { assignmentChecksForRun } from './assignment.js';
+import { checkBackingOf, completionBlockersOf, leadOnIt, plainReasonOf, replacedWords, requirementsOf, stageOfCode, taskStatusOf, unverifiedWhenRefuted, workToneOf } from './task-status.js';
+import { releaseCoverageOf } from './release-coverage.js';
+import { buildReviewOf } from './review-switch.js';
+import { shownVerdictOf } from './proof.js';
+import { isCheckLevel, requiredCheckCommandFor } from './check-levels.js';
 import { MARKER } from './worktree.js';
 import { withFollowUps } from './result-follow-ups.js';
 import { ASKS, NEED_ASK, NEEDS, askChipOf, failedAttemptSentence, processNeedOf, resultHoldUpSentence } from './needs-you.js';
@@ -359,6 +363,14 @@ function readCursor(value, scope) {
  * Project counters share the page's admitted project/state filter.
  * Cursors bind the admitted scope, project and view, never broaden access. */
 export function workIndexPage(store, now, access, options = {}) {
+    return readWorkIndexPage(store, now, access, options);
+}
+/** An exact family lookup through the list's saved-fact projection. It remains
+ * permission-bound and bypasses pagination, never action-time verification. */
+export function workIndexTask(store, taskId, now, access, root) {
+    return readWorkIndexPage(store, now, access, { limit: 1, ...(root === undefined ? {} : { root }) }, taskId).items[0] ?? null;
+}
+function readWorkIndexPage(store, now, access, options, taskId = null) {
     const projection = registerValidators(store);
     const custody = custodyReadings(store);
     const view = VIEWS.includes(options.view ?? 'all') ? options.view ?? 'all' : 'all';
@@ -366,7 +378,7 @@ export function workIndexPage(store, now, access, options = {}) {
     const scope = cursorScope(access, options, view), cursor = readCursor(options.cursor, scope);
     const filter = view === 'needs-you' ? 'needs=1' : view === 'running' ? 'family_running=1' : view === 'completed' ? "code='complete'" : '1';
     const rows = prepared(store, `${projection}, selected_page AS MATERIALIZED (
-    SELECT * FROM ranked WHERE ${filter} AND ($cursorRoot=0 OR
+    SELECT * FROM ranked WHERE ${filter} AND ($taskId IS NULL OR root_ref IN (SELECT root_ref FROM members WHERE id=$taskId)) AND ($cursorRoot=0 OR
       ${ORDER}>$cursorRank OR (${ORDER}=$cursorRank AND (sort_at<$cursorAt OR (sort_at=$cursorAt AND root_ref<$cursorRoot))))
     ORDER BY ${ORDER},sort_at DESC,root_ref DESC LIMIT $limit
   ), page AS (SELECT p.*,COALESCE(p.result_id,(SELECT id FROM run WHERE task_ref=p.ref_id AND finished_at IS NOT NULL AND role IN ('builder','scout') ORDER BY id DESC LIMIT 1)) page_result_id FROM selected_page p), totals AS (SELECT ${TOTALS},${GROUP_TOTALS} FROM ranked), project_totals AS (
@@ -379,7 +391,7 @@ export function workIndexPage(store, now, access, options = {}) {
     'state',state,'created_at',created_at,'family_updated',family_updated,'version_count',version_count,'earlier_active',earlier_active,
     'earlier_id',earlier_id,'broken',broken,'live_run',live_run,'result_id',page_result_id,'result_outcome',(SELECT outcome FROM run WHERE id=page_result_id),'attempt_reason',(SELECT substr(reason,1,1000) FROM run WHERE task_ref IN (SELECT ref_id FROM members WHERE root_ref=page.root_ref) AND (finished_at IS NOT NULL OR outcome IS NOT NULL) AND role NOT IN ('planner','reviewer') ORDER BY id DESC LIMIT 1),
     'publication_url',(SELECT pr_url FROM publication WHERE run=page_result_id),
-    'result_role',(SELECT role FROM run WHERE id=page_result_id),'live_role',(SELECT role FROM run WHERE id=page.live_run),
+    'result_role',(SELECT role FROM run WHERE id=page_result_id),'result_head',(SELECT head_revision FROM run WHERE id=page_result_id),'live_role',(SELECT role FROM run WHERE id=page.live_run),
     'check_status',(SELECT status FROM run_check WHERE run=page_result_id),
     'check_level',(SELECT outcome FROM action_ledger WHERE repo IS page.repo AND run_id=page_result_id AND action='checks used' ORDER BY id DESC LIMIT 1),
     'check_follows',(SELECT json_group_array(q.outcome||' '||COALESCE((SELECT substr(f.outcome,instr(f.outcome,':')+1) FROM action_ledger f WHERE f.repo IS page.repo AND f.run_id=page_result_id
@@ -392,7 +404,7 @@ export function workIndexPage(store, now, access, options = {}) {
     'question_run',(SELECT run FROM decision WHERE id=page.question_id),'replaced_by',(SELECT successor FROM task_replacement WHERE task_ref=page.ref_id),
     'completed_by_lead',(SELECT lead FROM task_act WHERE task_ref=page.root_ref AND act='completed' ORDER BY id DESC LIMIT 1),
     'question_task',(SELECT r.external_id FROM decision d JOIN run ON run.id=d.run JOIN task_ref r ON r.id=run.task_ref WHERE d.id=page.question_id)) FROM page`)
-        .all({ ...parameters(now, access, options, custody), $cursorRoot: cursor?.root ?? 0, $cursorRank: cursor?.rank ?? 0, $cursorAt: cursor?.at ?? '', $limit: limit + 1, $recent: new Date(now.getTime() - 86_400_000).toISOString() });
+        .all({ ...parameters(now, access, options, custody), $taskId: taskId, $cursorRoot: cursor?.root ?? 0, $cursorRank: cursor?.rank ?? 0, $cursorAt: cursor?.at ?? '', $limit: limit + 1, $recent: new Date(now.getTime() - 86_400_000).toISOString() });
     const selected = rows.slice(1).map(row => JSON.parse(String(row['row_json'])));
     const page = selected.slice(0, limit), last = page.at(-1);
     const nextCursor = selected.length > limit && last !== undefined ? Buffer.from(JSON.stringify({ version: 2, scope,
@@ -405,7 +417,11 @@ export function workIndexPage(store, now, access, options = {}) {
     };
     // A claimed row says the viewer's own name for their lead.
     const leadName = page.some(row => n(row, 'lead_claim') !== 0) && access.principal === 'operator' && access.viewer != null ? leadNameOf(store, access.viewer) : undefined;
-    return { items: page.map(row => itemOf(row, access.principal, probe, leadName)), projects, totals: rows[0] === undefined ? { ...EMPTY } : counts(rows[0]),
+    // A finished result reads the same readiness the task page does (task-status.ts): its requirements, acceptance,
+    // automatic review and, with checks Off, the release check that covers it.
+    const memo = new Map();
+    const readiness = (row, checks) => resultReadinessFacts(store, now, options.root, row, checks, memo);
+    return { items: page.map(row => itemOf(row, access.principal, probe, leadName, readiness)), projects, totals: rows[0] === undefined ? { ...EMPTY } : counts(rows[0]),
         groups: rows[0] === undefined ? { ...NO_GROUPS } : groupCounts(rows[0]), nextCursor, limit, view };
 }
 export function workCountsByProject(store, now, access) {
@@ -451,7 +467,30 @@ function listChecksOf(own, level, follows) {
         return null;
     return { status: read.status, exitCode: null, head: null, level: read.level, running: read.running };
 }
-function itemOf(row, principal, probe, leadName) {
+/** A ready result's requirements, acceptance and completion blockers from its saved records, as assignmentOf reads them. */
+function resultReadinessFacts(store, now, root, row, recorded, memo) {
+    const run = n(row, 'result_id'), repo = s(row, 'repo');
+    if (!run)
+        return { checks: recorded };
+    const report = s(row, 'result_role') === 'scout';
+    // No recorded check result (a build from before results were recorded, or none ran): read its saved receipt, as the page does.
+    const saved = root !== undefined && (recorded === null || recorded.status === 'not-run') ? assignmentChecksForRun(store, root, run, now) : null;
+    const listed = saved === null ? recorded : { status: saved.status, exitCode: saved.exitCode, head: s(row, 'result_head'),
+        ...(saved.level == null ? {} : { level: saved.level }), ...(saved.running == null ? {} : { running: saved.running }), ...(saved.batch == null ? {} : { batch: saved.batch }) };
+    const checks = listed?.level === 'off' && listed.status !== 'passed' && listed.status !== 'failed'
+        ? { ...listed, release: releaseCoverageOf(store, root, repo, s(row, 'result_head'), { memo }) } : listed;
+    const proof = store.proofVerdictFor(run), accepted = store.proofAcceptance(run) !== null;
+    const review = buildReviewOf(store, run);
+    const high = review === null || review.sentBackAs !== null || review.state !== 'reviewed' ? 0 : review.high.length;
+    const checkRequired = requiredCheckCommandFor(store, repo, String(row['id']), checks?.level) !== null;
+    const backing = checkBackingOf(checks);
+    const requirements = requirementsOf(proof?.matrix, backing);
+    const verdict = shownVerdictOf(proof?.verdict ?? null, { checkFailed: !report && checks?.status === 'failed', highFindings: high, reviewPending: review?.state === 'pending',
+        criteriaPassed: requirements === null || requirements.met === requirements.total });
+    const blockers = completionBlockersOf({ report, checks, checkRequired, matrix: proof?.matrix, verdict: proof?.verdict ?? null, accepted, high });
+    return { checks, requirements: unverifiedWhenRefuted(requirements, verdict), ...(accepted ? { accepted } : {}), ...(blockers.length === 0 ? {} : { blockers }) };
+}
+function itemOf(row, principal, probe, leadName, readiness) {
     const code = String(row['code']), id = String(row['id']);
     const custody = code === 'process-needs-attention' || (code === 'result-needs-attention' && n(row, 'custody_unresolved') === 1);
     const process = custody && probe !== undefined ? processNeedOf(probe(id)) : null;
@@ -564,10 +603,13 @@ function itemOf(row, principal, probe, leadName) {
     const checkStatus = s(row, 'check_status'), verdict = s(row, 'proof_verdict');
     const finished = reading.stage === 'finished' || reading.stage === 'complete';
     const own = checkStatus === 'failed' || n(row, 'proof_failed_check') === 1 ? 'failed' : checkStatus === 'passed' || verdict === 'verified' ? 'passed' : null;
+    const listedChecks = !finished ? null : listChecksOf(own, s(row, 'check_level'), row['check_follows']);
+    const ready = reading.stage === 'finished' && readiness !== undefined ? readiness(row, listedChecks) : null;
     const shared = taskStatusOf({ stage: reading.stage, ...(reading.need === undefined ? {} : { need: reading.need }), ...(reading.wait === undefined ? {} : { wait: reading.wait }),
         ...(process === null ? {} : { needContext: { build: process.build } }),
         reason: finished ? null : plainReasonOf(reading.stage, code, detail || null), report: s(row, 'result_role') === 'scout',
-        checks: !finished ? null : listChecksOf(own, s(row, 'check_level'), row['check_follows']),
+        checks: ready?.checks ?? listedChecks,
+        ...(ready === null ? {} : { requirements: ready.requirements ?? null, ...(ready.accepted ? { accepted: true } : {}), ...(ready.blockers === undefined ? {} : { blockers: ready.blockers }) }),
         completedBy: code !== 'complete' ? null : n(row, 'completed_by_lead') === 1 ? 'the lead' : String(row['checked_actor']).replace(/^(?:operator|coordinator|lead):/, ''),
         ...(lead === null ? {} : { lead, ...(leadName === undefined ? {} : { leadName }) }) });
     label = shared.headline;

package/dist/workspace-ui.js

@@ -395,7 +395,8 @@ export function acceptWordsOf(facts) {
     const plural = (n, one, many) => `${n} ${n === 1 ? one : many}`;
     const parts = [
         ...(facts.proof ? [] : ["nothing on record says what was met"]),
-        ...(facts.checks === "passed" ? [] : [facts.checks === "failed" ? "checks failed" : facts.checks === "off" ? "checks are off for this project"
+        // Checks deliberately Off are checked at release (task-status.ts): not a gap here.
+        ...(facts.checks === "passed" || facts.checks === "off" ? [] : [facts.checks === "failed" ? "checks failed"
                 : 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`] : []),
     ];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "toolroll",
-  "version": "0.9.56",
+  "version": "0.9.57",
   "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"