toolroll 0.9.5 → 0.9.7

package/dist/task-status.js

@@ -0,0 +1,335 @@
+/** A cancelled task with a successor reads "Replaced by <id>" everywhere, never "Cancelled". */
+export const replacedWords = (successor) => `Replaced by ${successor}`;
+const REPLACED = /^Replaced by \S+/;
+export const HEADLINES = ["Queued", "Planning", "Needs you", "Building", "Ready for review", "Complete", "Failed", "Stopped"];
+export const HEADLINE_TONE = {
+    Queued: "neutral", Planning: "live", "Needs you": "attention", Building: "live",
+    "Ready for review": "ready", Complete: "success", Failed: "danger", Stopped: "neutral",
+};
+const short = (sha) => sha !== null && /^[a-f0-9]{7,40}$/.test(sha) ? sha.slice(0, 7) : null;
+export function headlineOf(facts) {
+    switch (facts.stage) {
+        case "queued": return "Queued";
+        case "planning": return "Planning";
+        case "needs-you": return "Needs you";
+        case "building":
+        case "checking": return "Building";
+        case "finished":
+            if (facts.report)
+                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.
+            return "Ready for review";
+        case "complete": return "Complete";
+        case "failed": return "Failed";
+        case "stopped": return "Stopped";
+    }
+}
+function sentenceOf(headline, facts) {
+    const reason = facts.reason?.trim() || null;
+    const sha = short(facts.checks?.head ?? null);
+    switch (headline) {
+        case "Queued": return reason ?? "Waiting for a worker.";
+        case "Planning": return reason ?? "The lead is writing the plan.";
+        // An approval always reads the same way; the plan itself names the work.
+        case "Needs you": return facts.need === "approval" ? "Review the plan and approve it to start." : reason ?? (facts.need === "answer" ? "Answer the question so the work can continue."
+            : facts.need === "sign-in" ? "Sign in again; the task starts on its own after."
+                : "Something needs your decision before the work can continue.");
+        case "Building": return facts.stage === "checking" ? "Checks are running on the change." : 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 (facts.checks?.level === "off" && facts.checks.status !== "passed")
+                return "Checks are off for this project. Review the change, then mark it complete.";
+            if (facts.checks?.status === "passed")
+                return `${facts.checks.level === "quick" ? "Quick checks" : "Checks"} passed${sha === null ? "" : ` on ${sha}`}. Review the change, then mark it complete.`;
+            // Never claim a check that isn't known to have passed.
+            if (facts.checks == null)
+                return "Review the change, then mark it complete.";
+            return "Built without a passing project check. Review the change, then mark it complete.";
+        case "Complete": {
+            const by = facts.completedBy ? `Marked complete by ${facts.completedBy}.` : "Marked complete.";
+            const pr = facts.pullRequest;
+            return pr?.state === "merged" ? `${by} ${pr.number === null ? "Its pull request" : `Pull request #${pr.number}`} merged.` : by;
+        }
+        case "Failed":
+            if (facts.checks?.status === "failed")
+                return `${facts.checks.level === "quick" ? "Quick checks" : "Checks"} failed${sha === null ? "" : ` on ${sha}`}. See what broke, then retry or ask for changes.`;
+            return reason ?? "The last attempt stopped before it finished. Review it, then retry.";
+        case "Stopped": return reason ?? "Stopped by a person. The work so far is kept.";
+    }
+}
+/** A detail problem: red only under Failed, otherwise an amber note. */
+const problem = (headline) => headline === "Failed" ? "failed" : "note";
+function detailsOf(headline, facts) {
+    const rows = [];
+    const row = (key, label, text, mark, extra = {}) => rows.push({ key, label, text, mark, href: extra.href ?? null, action: extra.action ?? null, why: extra.why ?? null });
+    const checks = facts.checks;
+    if (checks != null && !facts.report) {
+        const sha = short(checks.head);
+        const checksHref = facts.links?.checks ?? facts.links?.result ?? null;
+        const runChecks = facts.links?.runChecks === undefined ? null : { label: "Run checks", href: facts.links.runChecks };
+        const quick = checks.level === "quick";
+        if (checks.running != null)
+            row("checks", "Checks", `${checks.running === "quick" ? "Quick" : "Full"} checks running`, "running", { href: checksHref });
+        else if (checks.status === "passed")
+            row("checks", "Checks", `${quick ? "Quick checks passed" : "Passed"}${sha === null ? "" : ` on ${sha}`}`, "ok", quick && runChecks !== null && headline !== "Complete" ? { href: checksHref, action: { label: "Run full checks", href: runChecks.href } } : { href: checksHref });
+        else if (checks.status === "failed")
+            row("checks", "Checks", `${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", "Running", "running");
+        else if (checks.level === "off")
+            row("checks", "Checks", "Off for this project", "none", runChecks === null ? {} : { action: runChecks });
+        else if (checks.status === "not-run")
+            row("checks", "Checks", "Didn't run", "none", runChecks === null ? {} : { action: runChecks });
+        else
+            row("checks", "Checks", "Couldn't be read", "note", { action: { label: "Open the result", href: facts.links?.result ?? null } });
+    }
+    const pr = facts.pullRequest;
+    if (pr != null) {
+        const name = pr.number === null ? "Pull request" : `#${pr.number}`;
+        const github = pr.url !== null && /^https:\/\/github\.com\//.test(pr.url) ? pr.url : null;
+        if (pr.state === "none")
+            row("pull-request", "Pull request", "None", "none");
+        else if (pr.state === "opening")
+            row("pull-request", "Pull request", "Opening…", "running", { why: pr.error });
+        else if (pr.state === "merged")
+            row("pull-request", "Pull request", `${name} merged`, "ok", { href: github, why: pr.note ?? null });
+        else if (pr.state === "closed")
+            row("pull-request", "Pull request", `${name} closed without merging`, "none", { href: github });
+        else if (pr.state === "failed")
+            row("pull-request", "Pull request", "Couldn't open", "note", { action: pr.compareUrl ? { label: "Open it on GitHub", href: pr.compareUrl } : { label: "See why", href: facts.links?.pullRequest ?? null }, why: pr.error === null ? "Publishing gave up. The commit is safe locally." : `${pr.error} The commit is safe locally.` });
+        else if (pr.ci === "running")
+            row("pull-request", "Pull request", `${name} open, CI running`, "running", { href: github });
+        else if (pr.ci === "passing")
+            row("pull-request", "Pull request", `${name} open, CI passed`, "ok", { href: github });
+        else if (pr.ci === "failing")
+            row("pull-request", "Pull request", `${name} open, CI failing`, "note", { action: { label: "Open it on GitHub", href: github } });
+        else
+            row("pull-request", "Pull request", `${name} open`, "none", { href: github });
+    }
+    const req = facts.requirements;
+    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}` : ""}`;
+        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;
+    if (evidence != null) {
+        const action = { label: "See what was kept", href: facts.links?.result ?? null };
+        if (evidence.damaged > 0)
+            row("evidence", "Saved evidence", "Some saved files changed", problem(headline), headline === "Failed" ? {} : { action });
+        else if (evidence.missing > 0)
+            row("evidence", "Saved evidence", "Some saved files are missing", problem(headline), headline === "Failed" ? {} : { action });
+        else if (evidence.shortened > 0)
+            row("evidence", "Saved evidence", "Some output shortened", "note", { action });
+        else
+            row("evidence", "Saved evidence", "Complete", "ok");
+    }
+    return rows;
+}
+export function taskStatusOf(facts) {
+    const headline = headlineOf(facts);
+    return { headline, tone: HEADLINE_TONE[headline], sentence: sentenceOf(headline, facts), details: detailsOf(headline, facts),
+        primaryAction: facts.action ?? null, why: [...new Set(facts.why ?? [])].filter(one => one.trim() !== "") };
+}
+// ---- 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. */
+const CODE_STAGE = {
+    queued: ["queued"], ready: ["queued"], "worker-at-capacity": ["queued"], "retry-scheduled": ["queued"], updating: ["queued"],
+    "waiting-dependency": ["queued"], "scouting-ready": ["queued"], "planning-ready": ["queued"], "provider-quota": ["queued"], "planner-source": ["queued"],
+    running: ["building"], reviewing: ["building"], "review-pending": ["building"],
+    "signed-out": ["needs-you", "sign-in"],
+    "needs-approval": ["needs-you", "approval"],
+    "waiting-decision": ["needs-you", "answer"], "decision-queue": ["needs-you", "answer"],
+    stopping: ["stopped"], stopped: ["stopped"], paused: ["stopped"], cancelled: ["stopped"],
+    failed: ["failed"], "waiting-incident": ["failed"], "checks-failed": ["failed"],
+    "ready-to-check": ["finished"], "ready-to-review": ["finished"], "report-ready": ["finished"], "no-change": ["finished"],
+    "pr-opened": ["finished"], "merge-observed": ["finished"], "pr-closed": ["finished"], "agent-attested": ["finished"], "accepted-exception": ["finished"],
+    complete: ["complete"],
+};
+/** Queue reasons worth a sentence of their own; any other queued or
+ * building reason is scheduler wording, and the default sentence is plainer. */
+const QUEUED_REASONS = new Set(["worker-at-capacity", "waiting-dependency", "retry-scheduled", "updating", "planning-ready", "scouting-ready", "provider-quota"]);
+export function plainReasonOf(stage, code, detail) {
+    if (stage === "building" || stage === "checking" || stage === "planning")
+        return null;
+    if (stage === "queued")
+        return QUEUED_REASONS.has(code) ? detail ?? null : null;
+    return detail ?? null;
+}
+export function stageOfCode(code, options = {}) {
+    if (code === "running" && options.planning)
+        return { stage: "planning" };
+    if (code === "held")
+        return options.operatorHold === false ? { stage: "needs-you", need: "other" } : { stage: "stopped" };
+    const known = CODE_STAGE[code];
+    if (known !== undefined)
+        return known[1] === undefined ? { stage: known[0] } : { stage: known[0], need: known[1] };
+    return options.needsPerson === false ? { stage: "queued" } : { stage: "needs-you", need: "other" };
+}
+/** The pull request as the task page's follower reports it, or the bare publication row. */
+export function pullRequestFactOf(publication) {
+    if (publication === null)
+        return null;
+    const safe = (part) => part !== undefined && /^[A-Za-z0-9_.\/-]+$/.test(part) && !part.includes("..") ? part : null;
+    const repo = safe(publication.githubRepo), from = safe(publication.base), to = safe(publication.head);
+    const compareUrl = repo !== null && /^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+$/.test(repo) && from !== null && to !== null ? `https://github.com/${repo}/compare/${from}...${to}?expand=1` : null;
+    const seen = publication.lastCheckState;
+    const ci = seen === "running" || seen === "passing" || seen === "failing" ? seen : null;
+    const fromUrl = /\/pull\/(\d+)$/.exec(publication.prUrl ?? "");
+    const number = publication.prNumber ?? (fromUrl === null ? null : Number(fromUrl[1]));
+    const base = { number, url: publication.prUrl, ci, error: publication.lastError ?? null, compareUrl };
+    if (publication.merged === true || publication.remoteState === "MERGED")
+        return { ...base, state: "merged" };
+    if (publication.remoteState === "CLOSED")
+        return { ...base, state: "closed" };
+    if (publication.state === "failed")
+        return { ...base, state: "failed" };
+    if (publication.state === "opened")
+        return { ...base, state: "open" };
+    return { ...base, state: "opening" };
+}
+/** The assignment's stage. The work status, when the caller read one, names
+ * the exact reason (a running planner, a pause, a failed attempt, a sign-in). */
+export function assignmentStageOf(assignment, work, planning = false) {
+    switch (assignment.state) {
+        case "cancelled": return { stage: "stopped" };
+        case "complete": return { stage: "complete" };
+        case "ready-to-check": return { stage: "finished" };
+        case "checking": return { stage: "checking" };
+        case "working": {
+            const token = work?.token ?? "running";
+            const read = stageOfCode(token, { needsPerson: work?.views?.includes("needs-you") ?? false, planning });
+            return read.stage === "finished" || read.stage === "complete" ? { stage: "building" } : read;
+        }
+        case "needs-decision": {
+            const action = assignment.primaryAction?.code;
+            if (action === "approve-scope")
+                return { stage: "needs-you", need: "approval" };
+            if (action === "answer-decision" || action === "inspect-decisions")
+                return { stage: "needs-you", need: "answer" };
+            const token = work?.token ?? "";
+            // A failed attempt is Failed. A saved result that still needs a decision
+            // (its scope, a hold, a process exit) is Needs you, even if its checks
+            // failed: the decision is the next step, and the Checks row says the rest.
+            if (token === "failed" || token === "waiting-incident")
+                return { stage: "failed" };
+            const read = stageOfCode(token, { needsPerson: true, operatorHold: action === "unhold" });
+            return read.stage === "stopped" ? read : { stage: "needs-you", need: read.need ?? "other" };
+        }
+    }
+}
+/** Requirements from the stored matrix: met, the ones only a person confirms, and the total. */
+export function requirementsOf(matrix) {
+    if (!matrix || matrix.length === 0)
+        return null;
+    // Evidence that passed and only awaits the retired assessment step is met.
+    const met = (row) => row.state === "pass" || (row.assessment?.evidenceState === "pass" && (row.review ?? null) === null);
+    return { met: matrix.filter(met).length, total: matrix.length, yours: matrix.filter(row => !met(row) && row.state === "manual-review").length };
+}
+/** Saved evidence health from the receipt's artifact list and its caveats. */
+export function evidenceOf(receipt, problems = receipt?.caveats ?? []) {
+    if (receipt === null)
+        return null;
+    const shortened = receipt.artifacts.filter(one => !one.complete).length + problems.filter(one => /shortened|cut short/.test(one)).length;
+    const damaged = problems.filter(one => /unavailable or changed|no longer verif|cannot be read|could not be read|failed capture|altered|damaged/i.test(one)).length;
+    const missing = problems.filter(one => /missing|ambiguous|no longer exists/i.test(one) && !/unavailable or changed/.test(one)).length;
+    return { shortened, missing, damaged };
+}
+/** The status facts of one assignment, as every surface reads them. */
+export function assignmentStatusFacts(assignment, options = {}) {
+    const { stage, need } = assignmentStageOf(assignment, options.work ?? null, options.planning ?? false);
+    const receipt = assignment.receipt;
+    const finished = stage === "finished" || stage === "complete";
+    // A saved result's rows show whenever it is the reason a person is needed, too.
+    const withResult = finished || stage === "failed" || (stage === "needs-you" && receipt !== null);
+    const report = receipt?.completionKind === "research-report";
+    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 }) };
+    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)
+            : pullRequestFactOf(publication);
+    // Ready, Complete and Failed speak for themselves; every other stage keeps its recorded reason.
+    const reason = stage === "needs-you" || stage === "stopped" || stage === "queued" || (stage === "failed" && checks?.status !== "failed")
+        ? stage === "stopped" && assignment.state === "cancelled" ? REPLACED.test(assignment.detail) ? assignment.detail : "Cancelled. Nothing else will run." : plainReasonOf(stage, options.work?.token ?? "", options.work?.detail ?? assignment.detail)
+        : null;
+    return {
+        stage, ...(need === undefined ? {} : { need }), reason, report,
+        checks,
+        pullRequest: withResult ? pullRequest : null,
+        requirements: withResult ? requirementsOf(receipt?.proof?.matrix) : null,
+        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,
+        ...(options.links === undefined ? {} : { links: options.links }),
+        why: options.why ?? [],
+    };
+}
+// ---- rendering helpers shared by the server pages and chat cards ------------
+/** The legacy work tone each headline wears where a surface still keys off StatusTone. */
+export function workToneOf(headline) {
+    switch (headline) {
+        case "Needs you": return "attention";
+        case "Failed": return "problem";
+        case "Building":
+        case "Planning": return "live";
+        case "Ready for review": return "ready";
+        case "Complete": return "done";
+        default: return "muted";
+    }
+}
+/** One plain-text line per detail for chat cards: an icon, the label, the words. */
+export function statusDetailLines(status) {
+    const icon = { ok: "✓", running: "●", none: "○", note: "⚠", failed: "✕" };
+    return status.details.map(one => `${icon[one.mark]} ${one.label} · ${one.text}${one.action === null ? "" : ` — ${one.action.label}`}`);
+}
+/** The headline's emoji for chat cards (colour is never the only signal: the words follow). */
+export function headlineEmoji(headline) {
+    return { Queued: "🕓", Planning: "📝", "Needs you": "👋", Building: "⏳", "Ready for review": "✅", Complete: "✅", Failed: "❌", Stopped: "⏹" }[headline];
+}
+const escapeHtml = (value) => value.replace(/[&<>"']/g, char => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" })[char]);
+const ICON_PATHS = {
+    ok: `<path d="M20 6 9 17l-5-5"/>`,
+    running: `<circle cx="12" cy="12" r="4"/>`,
+    none: `<circle cx="12" cy="12" r="3"/>`,
+    note: `<path d="M12 8v5"/><path d="M12 16.5h.01"/><path d="M10.3 3.9 2.4 18a2 2 0 0 0 1.7 3h15.8a2 2 0 0 0 1.7-3L13.7 3.9a2 2 0 0 0-3.4 0z"/>`,
+    failed: `<path d="M18 6 6 18M6 6l12 12"/>`,
+};
+export const statusIconSvg = (mark) => `<svg class="status-icon status-icon--${mark}" viewBox="0 0 24 24" width="14" height="14" fill="none" stroke="currentColor" stroke-width="2.25" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true">${ICON_PATHS[mark]}</svg>`;
+/** The detail rows as server HTML: quiet rows, colour only on the icon. */
+export function statusDetailsHtml(status) {
+    if (status.details.length === 0)
+        return "";
+    return `<ul class="status-details" aria-label="Details">` + status.details.map(one => {
+        const text = one.href === null ? escapeHtml(one.text) : `<a href="${escapeHtml(one.href)}">${escapeHtml(one.text)}</a>`;
+        const action = one.action === null ? "" : one.action.href === null ? `<span class="status-detail-act">${escapeHtml(one.action.label)}</span>` : `<a class="status-detail-act" href="${escapeHtml(one.action.href)}">${escapeHtml(one.action.label)}</a>`;
+        return `<li class="status-detail status-detail--${one.mark}" data-status-detail="${one.key}" data-mark="${one.mark}">${statusIconSvg(one.mark)}<span class="status-detail-label">${escapeHtml(one.label)}</span><span class="status-detail-text"><span>${text}</span>${action}</span></li>`;
+    }).join("") + `</ul>`;
+}
+/** The technical reasons, one tap away. */
+export function statusWhyHtml(status, extra = [], diagnostics = []) {
+    const lines = [...new Set([...status.details.flatMap(one => one.why === null ? [] : [`${one.label}: ${one.why}`]), ...status.why, ...extra])];
+    if (lines.length === 0 && diagnostics.length === 0)
+        return "";
+    return `<details class="status-why"><summary>Details</summary>${lines.map(one => `<p class="meta">${escapeHtml(one)}</p>`).join("")}` +
+        diagnostics.map(one => `<p class="meta" data-work-diagnostic="${escapeHtml(one.token)}">${escapeHtml(one.label)} · ${escapeHtml(one.detail)}</p>`).join("") + `</details>`;
+}
+/** Shared CSS for the server-rendered status: neutral rows, coloured icons. */
+export const TASK_STATUS_CSS = `.status-headline{display:flex;align-items:center;gap:.6rem;margin:0;font-size:1.125rem;font-weight:600;color:var(--foreground)}.status-headline i{width:.625rem;height:.625rem;border-radius:999px;flex-shrink:0;background:var(--muted-foreground)}[data-headline-tone=live] .status-headline i{background:var(--so-info,#0d74ce)}[data-headline-tone=attention] .status-headline i{background:var(--so-attention,var(--attention))}[data-headline-tone=ready] .status-headline i{background:transparent;box-shadow:inset 0 0 0 2px var(--so-success,#218358)}[data-headline-tone=success] .status-headline i{background:var(--so-success,#218358)}[data-headline-tone=danger] .status-headline i{background:var(--so-danger,#c4320a)}.status-sentence{margin:.35rem 0 0;color:var(--muted-foreground)}.status-details{list-style:none;margin:.75rem 0 0;padding:.25rem 0 0;border-top:1px solid var(--so-line,var(--border))}.status-detail{display:grid;grid-template-columns:14px 7.5rem minmax(0,1fr);align-items:center;gap:.6rem;padding:.4rem 0;font-size:.8125rem;color:var(--foreground)}.status-detail .status-icon{align-self:center;color:var(--muted-foreground)}.status-detail--ok .status-icon{color:var(--so-success,#218358)}.status-detail--running .status-icon{color:var(--so-info,#0d74ce)}.status-detail--note .status-icon{color:var(--so-warning,#ab6400)}.status-detail--failed .status-icon{color:var(--so-danger,#c4320a)}.status-detail-label{color:var(--muted-foreground)}.status-detail-text{display:flex;flex-wrap:wrap;align-items:baseline;gap:0 .6rem;min-width:0;overflow-wrap:anywhere}.status-detail-text a{color:inherit}.status-detail-act{font-weight:600;white-space:nowrap}.status-detail--note .status-detail-act{color:var(--so-warning,#ab6400)}@media(max-width:480px){.status-detail{grid-template-columns:14px 6.5rem minmax(0,1fr);min-height:2.75rem;padding:.25rem 0}.status-detail-text a{display:inline-block;padding:.75rem 0;margin:-.75rem 0}}.status-why{border:0;padding:0;margin:.25rem 0 0;background:transparent;box-shadow:none}.status-why>summary{cursor:pointer;min-height:2.75rem;display:list-item;align-content:center;font-size:.8125rem;color:var(--muted-foreground)}.status-why p{margin:.25rem 0 .5rem}.receipt-note{display:flex;align-items:center;gap:.45rem;font-size:.8125rem;color:var(--foreground)}.receipt-note .status-icon{color:var(--so-warning,#ab6400)}`;
+/** A dispatch diagnosis as its stage, for the phone and CLI reads that hold
+ * no assignment. A done task is Complete once a person marked its result;
+ * a refuted result whose project check failed is Failed. */
+export function stageOfDispatch(d, options = {}) {
+    if (d.code === "complete" || d.code.startsWith("review-") || d.code === "reviewing")
+        return { stage: options.completed ? "complete" : "finished" };
+    if (d.code === "proof-refuted")
+        return /approved check failed|checks failed/i.test(d.detail ?? "") ? { stage: "failed" } : { stage: "needs-you", need: "other" };
+    if (d.code === "needs-verification")
+        return { stage: "needs-you", need: "other" };
+    return stageOfCode(d.code, { needsPerson: d.condition === "waiting" && d.action !== null, planning: d.condition === "running" && d.role === "planner", operatorHold: d.action === "unhold" });
+}

package/dist/team-cli.js

@@ -305,6 +305,9 @@ function render(reply, listing) {
 /** null means preserve the existing local command path. Nothing here opens a database. */
 export async function maybeRunTeamCommand(argv, write, options = {}) {
     const command = argv[0];
+    // `lead token` is local: the credential a lead agent acts with on this computer.
+    if (command === 'lead' && argv[1] === 'token')
+        return null;
     if (!['connect', 'lead', 'conversation', 'chat', 'brief'].includes(command ?? '') && !argv.includes('--profile'))
         return null;
     const json = argv.includes('--json');

package/dist/telegram-progress.js

@@ -1,12 +1,15 @@
 /** A compact projection of saved work, never a percentage or an ETA. The
- * words come from the same assignment record the console and the CLI show:
- * a finished build is Ready once its saved result can be inspected, and
- * Complete once the lead or a person has marked that exact result. No model
- * reviewer is waited for or announced. */
-import { manualReviewOnly } from "./proof.js";
+ * headline, sentence and detail rows come from the shared task status
+ * (task-status.ts), read from the same assignment record the console and the
+ * CLI show: Ready for review once the saved result can be inspected, Complete
+ * once the lead or a person has marked that exact result. Slack, Discord and
+ * Teams send this same card. */
 import { assignmentOf } from "./assignment.js";
 import { chatResultHref, chatControlHref } from "./chat-controls.js";
 import { phoneText, projectLabel } from "./telegram-status.js";
+import { assignmentStatusFacts, headlineEmoji, pullRequestFactOf, requirementsOf, statusDetailLines, taskStatusOf } from "./task-status.js";
+import { manualReviewOnly } from "./proof.js";
+import { failedCheckExit } from "./workspace-ui.js";
 /** The saved assignment for this exact result, or null when the run is not
  * the family's current result (an older attempt keeps its own plain words). */
 function assignmentFor(store, run, taskId, project, now, root) {
@@ -19,111 +22,70 @@ function assignmentFor(store, run, taskId, project, now, root) {
     }
 }
 export function telegramProgressCard(store, run, taskId, project, now = new Date(), root) {
-    const proof = store.proofVerdictFor(run.id);
-    const rows = proof?.matrix ?? [];
-    const direct = rows.length > 0 && rows.every(row => row.assessment !== undefined);
-    const passed = rows.filter(row => row.state === "pass").length;
-    const human = manualReviewOnly(proof);
-    const accepted = store.proofAcceptance(run.id) !== null;
     const built = run.finishedAt !== null && (run.outcome === "built" || run.outcome === "no-change");
     const assignment = built ? assignmentFor(store, run, taskId, project, now, root) : null;
-    const checksFailed = assignment?.receipt?.checks.status === "failed";
-    let status = "Working";
-    let icon = "⏳";
-    let next = "";
-    let build = built ? "✓ Build saved" : "● Build in progress";
-    let checks = rows.length ? `${passed === rows.length ? "✓" : "○"} Checks · ${passed}/${rows.length} requirements` : "○ Checks pending";
-    if (direct)
-        checks = proof?.machineVerdict === "verified" ? "✓ Checks passed" : proof?.machineVerdict === "attested" ? "○ Checks not configured" : "! Checks need attention";
-    let label = built ? "Open result" : "Open task";
-    if (run.outcome === null && run.phase !== null && run.phase !== "agent-running") {
-        status = "Checking the result";
-        build = "✓ Draft prepared";
-        checks = "● Checks in progress";
-    }
-    if (built) {
-        status = run.committed === false ? "Finished without a commit" : "Result saved";
-        if (proof === null)
-            checks = "○ Checks not recorded";
-        const recorded = assignment?.receipt?.checks;
-        if (recorded !== undefined && recorded.status !== "unavailable") {
-            checks = recorded.status === "passed" ? "✓ Checks passed"
-                : recorded.status === "failed" ? `! Checks failed${recorded.exitCode === null ? "" : ` (exit ${recorded.exitCode})`}`
-                    : "○ Checks did not run";
-        }
-        if (assignment?.state === "ready-to-check") {
-            status = "Ready";
-            icon = checksFailed ? "⚠️" : "✅";
-            next = checksFailed ? "Next: inspect the failed check, then mark it complete or request changes." : "Next: open the result, then mark it complete or request changes.";
-        }
-        else if (assignment?.state === "complete") {
-            status = "Complete";
-            icon = "✅";
-            next = phoneText(assignment.detail, 200);
-        }
-        else if (assignment?.state === "needs-decision") {
-            status = "Needs your decision";
-            icon = "💬";
-            next = phoneText(assignment.detail, 200);
-        }
-        else if (assignment?.state === "cancelled") {
-            status = "Cancelled";
-            icon = "⏹";
-        }
-        else if (assignment !== null) {
-            next = phoneText(assignment.detail, 200);
-        }
-        else if (run.committed !== false) {
-            next = "Open the task for its current status.";
-        }
-    }
-    else if (run.outcome !== null) {
-        status = run.outcome === "parked" ? "Decision needed" : run.outcome === "interrupted" || run.reason === "interrupted" ? "Stopped" : "Build needs attention";
-        icon = run.outcome === "parked" ? "💬" : "⏸";
-        build = "! Build unfinished";
-        next = "Next: inspect the blocker.";
-        label = "Open task";
-    }
+    const publication = store.publicationForRun(run.id);
+    const pullRequest = publication === null ? undefined : pullRequestFactOf(publication);
     const stop = store.stopOf(run.id);
-    if (run.outcome === null && stop !== null && stop.resumedAt === null) {
-        status = stop.settledAt === null ? "Stopping" : "Stopped";
-        icon = "⏸";
-        build = stop.settledAt === null ? "● Build stopping" : "! Build stopped";
-        next = stop.settledAt === null ? "Waiting for the running process to stop." : "Next: inspect the saved work, then resume.";
-    }
     const holds = store.activeHolds(run.taskRef, now);
     const operatorHold = holds.find(hold => hold.ownerKind === "operator");
     const accessBlocked = run.reason === "retryable-infra" && /^could not re-read (?:the branch|HEAD) in /i.test(run.handoff ?? "");
-    if (accessBlocked) {
-        status = "Worker needs project access";
-        icon = "⏸";
-        next = "Next: restore the worker’s folder access, then resume.";
-        label = "Open task";
+    // The one shared status: the same headline, sentence and rows as the console.
+    let facts;
+    if (assignment !== null && assignment.state !== "working" && assignment.state !== "checking") {
+        facts = assignmentStatusFacts(assignment, pullRequest === undefined ? {} : { pullRequest });
     }
-    if (operatorHold) {
-        icon = "⏸";
-        if (!accessBlocked) {
-            status = run.outcome === null ? "Working · Next attempt paused" : "Paused";
-            next = phoneText(operatorHold.reason, 150);
-        }
-        label = "Open task";
+    else if (built) {
+        // A saved result is Ready even in the moment before its worker lets go of
+        // the task. Without its receipt yet, the stored machine verdict speaks.
+        const recorded = assignment?.receipt?.checks ?? null;
+        const proof = store.proofVerdictFor(run.id);
+        const machine = proof?.machineVerdict ?? proof?.verdict ?? null;
+        const exit = failedCheckExit(proof?.reasons ?? []);
+        const checks = recorded !== null ? { status: recorded.status, exitCode: recorded.exitCode, head: run.headRevision }
+            : exit !== null ? { status: "failed", exitCode: exit, head: run.headRevision }
+                : machine === "verified" ? { status: "passed", exitCode: null, head: run.headRevision }
+                    : machine === "attested" ? { status: "not-run", exitCode: null, head: null } : null;
+        facts = { stage: "finished", report: run.role === "scout", checks, requirements: requirementsOf(proof?.matrix),
+            ...(pullRequest === undefined ? {} : { pullRequest }) };
     }
-    else if (accessBlocked && holds.some(hold => hold.ownerKind === "backoff")) {
-        next = "The worker will retry after a short pause. Check its folder access.";
+    else if (accessBlocked) {
+        facts = { stage: "needs-you", need: "other", reason: holds.some(hold => hold.ownerKind === "backoff")
+                ? "The worker can't read the project folder. It retries after a short pause; check its folder access."
+                : "The worker can't read the project folder. Restore its access, then resume." };
     }
+    else if (run.outcome === null && stop !== null && stop.resumedAt === null) {
+        facts = { stage: "stopped", reason: stop.settledAt === null ? "Stopping. Waiting for the running process to end." : "Paused by a person. Inspect the saved work, then resume." };
+    }
+    else if (operatorHold) {
+        facts = { stage: "stopped", reason: `On hold: ${phoneText(operatorHold.reason, 150)}` };
+    }
+    else if (run.outcome === null) {
+        facts = { stage: run.phase !== null && run.phase !== "agent-running" ? "checking" : run.role === "planner" ? "planning" : "building" };
+    }
+    else if (run.outcome === "parked") {
+        facts = { stage: "needs-you", need: "answer" };
+    }
+    else if (run.outcome === "interrupted" || run.reason === "interrupted") {
+        facts = { stage: "stopped", reason: "The attempt was interrupted. Inspect the saved work, then resume." };
+    }
+    else {
+        facts = { stage: "failed", reason: "The build stopped before it finished. Inspect the blocker, then retry." };
+    }
+    const status = taskStatusOf(facts);
     const checkProgress = store.checkProgress(run.id);
-    if (checkProgress !== null)
-        checks = checkProgress.line;
-    const publication = store.publicationForRun(run.id);
-    const delivery = publication?.remoteState === "MERGED" ? "Merged · Installation not confirmed" : publication?.remoteState === "CLOSED" ? "Pull request closed without merging" : publication?.state === "opened" ? "Pull request open · Not merged" : publication?.state === "pushed" ? "Branch pushed · Pull request pending" : publication?.state === "intended" ? "Publication queued" : publication?.state === "failed" ? "Publication failed · Local result preserved" : built ? "Saved locally · Not published" : null;
-    const acceptance = accepted ? (human ? "Accepted by a person · Recorded checks unchanged" : "Accepted with an exception · Recorded checks unchanged") : null;
+    const progress = status.headline === "Building" && checkProgress !== null ? [`● ${checkProgress.line}`] : [];
     const title = phoneText(store.getTask(taskId)?.title ?? taskId, 88);
-    const heading = `${icon} ${status}`;
-    const text = [title, heading, "", build, checks,
-        ...(next ? ["", next] : []),
-        ...(acceptance === null ? [] : [acceptance]),
-        ...(delivery === null ? [] : ["", delivery]), "", `${projectLabel(project)} · #${run.id}`].join("\n");
+    const heading = `${headlineEmoji(status.headline)} ${status.headline}`;
+    const next = phoneText(status.sentence, 200);
+    // A person's acceptance is its own recorded decision; it never changes a check.
+    const acceptance = store.proofAcceptance(run.id) === null ? [] : [manualReviewOnly(store.proofVerdictFor(run.id))
+            ? "Accepted by a person · Recorded checks unchanged" : "Accepted with an exception · Recorded checks unchanged"];
+    const rows = [...statusDetailLines(status), ...progress, ...acceptance];
+    const text = [title, heading, next, ...(rows.length === 0 ? [] : ["", ...rows]), "", `${projectLabel(project)} · #${run.id}`].join("\n");
+    const failedChecks = status.details.some(one => one.key === "checks" && (one.mark === "failed" || one.mark === "note"));
+    const recovery = operatorHold !== undefined || accessBlocked || (!built && run.outcome !== null);
     return { text, next, entities: [{ type: "bold", offset: 0, length: title.length }, { type: "bold", offset: title.length + 1, length: heading.length }],
-        link: { label, path: operatorHold || accessBlocked || (!built && run.outcome !== null)
-                ? chatControlHref("recovery", taskId) : built ? chatResultHref(taskId, run.id, checksFailed ? "checks" : "summary") : chatControlHref("task", taskId) } };
+        link: { label: built ? "Open result" : "Open task", path: recovery
+                ? chatControlHref("recovery", taskId) : built ? chatResultHref(taskId, run.id, failedChecks ? "checks" : "summary") : chatControlHref("task", taskId) } };
 }