toolroll 0.9.94 → 0.9.95

package/dist/scope.d.ts

@@ -205,6 +205,7 @@ export declare function canonicalProfileJson(profile: ExecutionProfile): string;
  * same 128 bits every other safety digest here uses (finding 21). */
 export declare function profileDigestOf(profile: ExecutionProfile): string;
 export declare const CHAIN_DIGEST_VERSION = 1;
+export declare const LIVE_CHAIN_VERSION = 2;
 /** One entry of an approved fallback chain: the WHOLE execution profile
  * (so a claude->codex switch cannot inherit one provider's repair config)
  * and the auth mode it runs under. Order is authority. */
@@ -214,15 +215,15 @@ export type ChainEntry = {
 };
 /** The stored snapshot bytes for a chain: the version rides IN the
  * snapshot, exactly like a single profile's. */
-export declare function canonicalChainJson(entries: readonly ChainEntry[]): string;
+export declare function canonicalChainJson(entries: readonly ChainEntry[], version?: number): string;
 /** sha256 over a domain-separated canonical chain encoding — a DIFFERENT
  * domain from a single profile ("standing-orders:chain:" vs
  * ":profile:"), so a chain digest can never collide with a profile
  * digest, truncated to the same 128 bits. */
-export declare function chainDigestOf(entries: readonly ChainEntry[]): string;
+export declare function chainDigestOf(entries: readonly ChainEntry[], version?: number): string;
 /** Strict re-hydration of a stored chain — every entry proved through the
  * single-profile rehydrator; anything unexpected is null. */
-export declare function chainFromJson(json: string | null): ChainEntry[] | null;
+export declare function chainFromJson(json: string | null, version?: number): ChainEntry[] | null;
 /**
  * THE STRICT RAW TERMS READ (raw authority repair): the stored columns of
  * a scope or a standing order, proved EXACTLY — a JSON list is a list of
@@ -499,6 +500,7 @@ export declare function digestOf(scope: Pick<Scope, "goal" | "outOfScope" | "tou
     releaseCheck?: ReleaseCheckPurpose | null;
 }, target?: ExecutionProfile | null | {
     chain: readonly ChainEntry[];
+    version?: number;
 }, route?: PhaseRoute | null): string;
 export declare function propose(store: Store, input: ScopeInput): Scope;
 export type GuardedProposeResult = {
@@ -798,6 +800,17 @@ export declare function approve(store: Store, taskId: string, by: string, now: D
 fastStart?: {
     rule: string;
     at: string;
+}, 
+/** A person's own yes in chat (owner's decision, docs/plans/toolroll-cards.md): their tap or signed-in click stands in
+ * for a password, so `token` is unused. Every rule below still applies. The caller has proved the person is the one
+ * tapping. `shown` is what a card that showed its terms whole showed: those words, and the digest kept when it was
+ * made. Null when the card showed less: the seal then opens none of the walls a person's reading opens. */
+chat?: {
+    modeDigest: string;
+    shown: {
+        expect: string;
+        terms: string;
+    } | null;
 }): ApproveResult;
 /** The ledger act that records how an approval's person was proved (password-now, sso-now, fresh-password, fresh-sso). */
 export declare const APPROVAL_PROOF = "approval proved";
@@ -840,6 +853,7 @@ export type ScopeAuthority = {
     route: PhaseRoute;
     digest: string;
     authMode: AuthMode | null;
+    chain?: ChainEntry[];
 } | {
     ok: false;
     reason: "terms" | "unrouted" | "unresolved" | "profile" | "chain" | "route" | "parity" | "digest" | "auth-mode";
@@ -1036,3 +1050,8 @@ export declare function localApprovalEligible(store: Store, by: string, taskId:
     reason: LocalApprovalRefusal;
     message: string;
 };
+/** A chain that may dispatch: version 2, a base and at least one fallback. An older chain is history, never this. */
+export declare function liveChainFromJson(json: string | null): ChainEntry[] | null;
+/** The chain in full, the words a yes agrees to: order, agent, model, how it bills, what it may do, and whether Toolroll
+ * can see it run out. Every approval surface shows these lines; empty for a scope with no chain. */
+export declare function chainTermsLines(scope: Pick<Scope, "proposedChainJson">): string[];

package/dist/scope.js

@@ -1,5 +1,6 @@
 // The rubric's vocabulary loads before anything that reaches the plan contract (see contracts/acceptance-terms.ts).
 export { ACCEPTANCE_LIMITS, EVIDENCE_KINDS } from "./contracts/acceptance-terms.js";
+import { cardShowsScope, cardTermsDigest } from "./chat-terms.js";
 import { mintSecret } from "./secret-mint.js";
 import { passwordlessOn } from "./passwordless.js";
 import { routeChangeProblem } from "./route-change-check.js";
@@ -154,29 +155,30 @@ export function profileDigestOf(profile) {
         .digest("hex")
         .slice(0, 32);
 }
-// ---- fallback chains (v30-v114; removed in v115) --------------------------
-// History only: an approval sealed over a fallback chain still decodes and
-// its digest still re-derives, so old tasks verify and render. Nothing
-// files, seals, or dispatches a chain any more.
+// ---- fallback chains (fallback.ts, docs/plans/fallback-chains.md) ----------
+// Version 1 is history (v30-v114): an old approval still decodes and its digest
+// still re-derives, so old tasks verify and render, and it holds no authority.
+// Version 2 is what filing writes now: only it dispatches.
 export const CHAIN_DIGEST_VERSION = 1;
+export const LIVE_CHAIN_VERSION = 2;
 /** The stored snapshot bytes for a chain: the version rides IN the
  * snapshot, exactly like a single profile's. */
-export function canonicalChainJson(entries) {
-    return canonicalJson({ digestVersion: CHAIN_DIGEST_VERSION, chain: entries });
+export function canonicalChainJson(entries, version = CHAIN_DIGEST_VERSION) {
+    return canonicalJson({ digestVersion: version, chain: entries });
 }
 /** sha256 over a domain-separated canonical chain encoding — a DIFFERENT
  * domain from a single profile ("standing-orders:chain:" vs
  * ":profile:"), so a chain digest can never collide with a profile
  * digest, truncated to the same 128 bits. */
-export function chainDigestOf(entries) {
+export function chainDigestOf(entries, version = CHAIN_DIGEST_VERSION) {
     return createHash("sha256")
-        .update(`standing-orders:chain:v${CHAIN_DIGEST_VERSION}:${canonicalChainJson(entries)}`, "utf8")
+        .update(`standing-orders:chain:v${version}:${canonicalChainJson(entries, version)}`, "utf8")
         .digest("hex")
         .slice(0, 32);
 }
 /** Strict re-hydration of a stored chain — every entry proved through the
  * single-profile rehydrator; anything unexpected is null. */
-export function chainFromJson(json) {
+export function chainFromJson(json, version = CHAIN_DIGEST_VERSION) {
     if (json === null)
         return null;
     let parsed;
@@ -189,7 +191,7 @@ export function chainFromJson(json) {
     if (parsed === null || typeof parsed !== "object")
         return null;
     const wrapper = parsed;
-    if (wrapper.digestVersion !== CHAIN_DIGEST_VERSION)
+    if (wrapper.digestVersion !== version)
         return null;
     // Exact keys on the wrapper and on every entry (v48 integrity): a
     // snapshot carrying anything this code never writes is not one it wrote.
@@ -602,7 +604,7 @@ route) {
     const innerDigest = target == null
         ? null
         : "chain" in target
-            ? chainDigestOf(target.chain)
+            ? chainDigestOf(target.chain, target.version)
             : profileDigestOf(target);
     return createHash("sha256")
         .update(JSON.stringify({
@@ -1074,7 +1076,12 @@ export function fileAndSealUnderMode(store, input) {
 }
 export function approve(store, taskId, by, now, sawDigest, token, mutation = {}, 
 /** A fast start (fast-start.ts): Build is this same yes, with its marker in the proof. Only that road passes it. */
-fastStart) {
+fastStart, 
+/** A person's own yes in chat (owner's decision, docs/plans/toolroll-cards.md): their tap or signed-in click stands in
+ * for a password, so `token` is unused. Every rule below still applies. The caller has proved the person is the one
+ * tapping. `shown` is what a card that showed its terms whole showed: those words, and the digest kept when it was
+ * made. Null when the card showed less: the seal then opens none of the walls a person's reading opens. */
+chat) {
     // Read and write in one transaction, re-reading inside it — the credential
     // check included, so a token rotated between authentication and the write
     // cannot leave an approval signed by an authority that no longer exists.
@@ -1082,7 +1089,14 @@ fastStart) {
     // this approval — which would resurrect the old wording *and* mark it
     // agreed, the precise opposite of what the digest is for.
     return store.transact(() => {
-        const authenticated = authenticateApprover(store, by, token, store.lookupRef(taskId)?.repo ?? null);
+        const repoNow = store.lookupRef(taskId)?.repo ?? null;
+        const account = chat === undefined ? null : store.accountOf(by);
+        // A machine never reaches this road, and the person's role and reach are read here, in the seal's transaction.
+        if (chat !== undefined && machineActing())
+            return { ok: false, reason: "machine-proof" };
+        if (chat !== undefined && (account === null || account.revokedAt !== null || account.role !== "approver" || repoNow === null || !store.accountCanAccess(by, repoNow)))
+            return { ok: false, reason: "not-an-approver" };
+        const authenticated = chat !== undefined ? { ok: true, method: "chat", at: now.getTime() } : authenticateApprover(store, by, token, repoNow);
         if (!authenticated.ok)
             return authenticated;
         // ONLY A PERSON APPROVES (docs/plans/approval-policy.md, phase 1): a lead token or a remote API token proves the
@@ -1110,6 +1124,10 @@ fastStart) {
         // the new one in silence — which is the whole failure this guards.
         if (sawDigest !== scope.digest)
             return { ok: false, reason: "changed" };
+        // What the card showed when it was made is what this yes is to: other words, or words leaving out a widening, aren't.
+        const shown = chat?.shown ?? null;
+        if (shown !== null && (cardTermsDigest(shown.terms) !== shown.expect || !cardShowsScope(scope, shown.terms)))
+            return { ok: false, reason: "changed" };
         // The "what changed" line a person read describes this exact route, or this yes isn't to what they read (route-change.ts).
         if (routeChangeProblem(store, taskId, scope))
             return { ok: false, reason: "changed" };
@@ -1174,7 +1192,8 @@ fastStart) {
                 // profile — the exact bytes the digest the approver signed was bound
                 // to. Routing saveScope here would re-run resolution and could sign a
                 // profile nobody saw.
-                const sealed = store.sealScopeApproval(taskId, by, now, mutation);
+                const sealed = chat === undefined ? store.sealScopeApproval(taskId, by, now, mutation)
+                    : store.sealScopeApproval(taskId, by, now, mutation, { kind: "chat", modeDigest: chat.modeDigest, ...(shown === null ? {} : { card: "shown", cardDigest: shown.expect, shownTerms: shown.terms }) }, "person");
                 const approved = sealed ? store.getScope(taskId) : null;
                 if (!sealed || approved === null) {
                     refused.result = { ok: false, reason: sealed ? "no-scope" : "changed" };
@@ -1294,10 +1313,11 @@ export function scopeAuthorityOf(scope, env = {}) {
     if (profile === null) {
         return { ok: false, reason: "profile", problem: profileJson === null ? "the scope carries no agent profile" : "the scope's agent profile cannot be read exactly (unknown keys, an unsafe number, or a clock no timer can hold)" };
     }
-    // A scope filed with fallback agents (v30-v114) holds no authority now
-    // that fallback chains are gone: saving it again chooses its agents.
-    if (scope.proposedChainJson != null) {
-        return { ok: false, reason: "chain", problem: "this scope named fallback agents, which Toolroll no longer uses — save the scope again to choose its agents" };
+    // Fallback agents: a current chain whose base IS this profile. An older
+    // chain (v30-v114) holds no authority: saving the scope again re-files it.
+    const chain = scope.proposedChainJson == null ? null : liveChainFromJson(scope.proposedChainJson);
+    if (scope.proposedChainJson != null && (chain === null || profileDigestOf(chain[0].profile) !== profileDigestOf(profile))) {
+        return { ok: false, reason: "chain", problem: "this scope named fallback agents from an older version, or they can't be read — save the scope again to choose its agents" };
     }
     const routeJson = scope.proposedRouteJson ?? null;
     const route = routeFromJson(routeJson);
@@ -1307,7 +1327,7 @@ export function scopeAuthorityOf(scope, env = {}) {
     const parity = routeParityProblem(route, profile, { riskLevel: scope.riskLevel ?? "routine", qualityMode: scope.qualityMode ?? "default" });
     if (parity !== null)
         return { ok: false, reason: "parity", problem: parity };
-    const digest = digestOf({ goal: scope.goal, outOfScope: scope.outOfScope, touches: scope.touches, budgetMicrousd: scope.budgetMicrousd, acceptance: scope.acceptance, candidate: scope.candidate ?? null, qualityMode: scope.qualityMode ?? "default", releaseTerms: scope.releaseTerms ?? null, releaseCheck: scope.releaseCheck ?? null }, profile, route);
+    const digest = digestOf({ goal: scope.goal, outOfScope: scope.outOfScope, touches: scope.touches, budgetMicrousd: scope.budgetMicrousd, acceptance: scope.acceptance, candidate: scope.candidate ?? null, qualityMode: scope.qualityMode ?? "default", releaseTerms: scope.releaseTerms ?? null, releaseCheck: scope.releaseCheck ?? null }, chain === null ? profile : { chain, version: LIVE_CHAIN_VERSION }, route);
     if (digest !== scope.digest) {
         return { ok: false, reason: "digest", problem: "the scope's reference does not re-derive from its own terms, agents, and route — file it again" };
     }
@@ -1323,8 +1343,11 @@ export function scopeAuthorityOf(scope, env = {}) {
         if (!read.ok)
             return { ok: false, reason: "auth-mode", problem: read.problem };
         authMode = read.mode;
+        // The base was filed under one credential; a yes on another isn't a yes to these terms.
+        if (chain !== null && chain[0].authMode !== authMode)
+            return { ok: false, reason: "auth-mode", problem: "the agent's sign-in changed since this was filed — save the scope again" };
     }
-    return { ok: true, profile, route, digest, authMode };
+    return { ok: true, profile, route, digest, authMode, ...(chain === null ? {} : { chain }) };
 }
 /** The rubric's approval-card lines (v39): one per criterion, the id in
  * front (the exact string a proof must answer by) and its required
@@ -1363,6 +1386,7 @@ evidence = null) {
         // leg with its reason and readiness — before anyone signs.
         ...scopeRouteWords(scope, readiness),
         ...(evidence === null ? [] : [`  why model    ${evidence.replace(/^Why this model: /, "")}`]),
+        ...chainTermsLines(scope).map((line, at) => at === 0 ? `  fallback     ${line}` : `               ${line}`),
         // What the build may reach (egress.ts), part of what the yes agrees to.
         ...(scope.profile === null || scope.profile === undefined ? [] : [`  network      ${networkWords(scope.profile.network ?? null).replace(/^Network: /, "")}`]),
         ...(scope.profile === null || scope.profile === undefined ? [] : [`  writes       ${writesWords(scope.profile.writes)}`]),
@@ -1414,6 +1438,9 @@ function describeApproval(approval) {
 // ---- Only a person approves (docs/plans/approval-policy.md, phase 1). Kept last: the freshness tripwire pins places.
 export { personProof } from "./person-proof.js";
 import { personProof } from "./person-proof.js";
+import { permissionPlainWords } from "./chat-terms.js";
+import { limitRecognised } from "./exhaustion.js";
+import { SUBSCRIPTION_CAPABLE } from "./keys.js";
 import { releaseCheckPurposeDigest, releaseTermsDigest } from "./contracts/release-terms.js";
 import { CHECK_ACCESS_WIDTH, autoEvidenceOf, carriesUnsandboxed, newestReleaseGeneration, releaseAuthorityOfTask, releaseAutoApproves, releaseSealProblem } from "./release-authority.js";
 /** Whether the command running now is a machine's: the lead (its token) or a remote API run. Trusted context only. */
@@ -1703,3 +1730,27 @@ export function localApprovalEligible(store, by, taskId) {
         return no("unsandboxed");
     return { ok: true };
 }
+// ---- Fallback chains (fallback.ts). Kept last too.
+/** A chain that may dispatch: version 2, a base and at least one fallback. An older chain is history, never this. */
+export function liveChainFromJson(json) {
+    const chain = chainFromJson(json, LIVE_CHAIN_VERSION);
+    return chain === null || chain.length < 2 ? null : chain;
+}
+// The chain's four providers by name, here rather than provider-auth.ts: this file sits under the contracts, and that one
+// loads every adapter.
+const CHAIN_AGENT_NAMES = { claude: "Claude", codex: "Codex", gemini: "Gemini", openrouter: "OpenRouter" };
+/** The chain in full, the words a yes agrees to: order, agent, model, how it bills, what it may do, and whether Toolroll
+ * can see it run out. Every approval surface shows these lines; empty for a scope with no chain. */
+export function chainTermsLines(scope) {
+    const chain = liveChainFromJson(scope.proposedChainJson ?? null);
+    if (chain === null)
+        return [];
+    return [
+        "If an agent runs out of its plan, the work moves to the next one here:",
+        ...chain.map((entry, at) => {
+            const paid = entry.authMode === "api-key" || SUBSCRIPTION_CAPABLE[entry.profile.provider] !== true;
+            const last = at === chain.length - 1;
+            return `${at + 1}. ${CHAIN_AGENT_NAMES[entry.profile.provider] ?? entry.profile.provider} ${entry.profile.model}, ${paid ? "on an API key, which spends money, and only while the project allows paid fallback" : "its plan"}; ${permissionPlainWords(entry.profile) ?? "agent permissions not known"}. ${last ? "Last in the chain." : limitRecognised(entry.profile.provider, entry.authMode) ? "Moves on when its plan runs out." : "Won't move on: Toolroll can't yet recognise this agent running out."}`;
+        }),
+    ];
+}

package/dist/scout.d.ts

@@ -2,7 +2,7 @@ import type { ProviderId } from "./contracts/provider.js";
 import type { Store } from "./store.js";
 import { type ParsedDecision, type Problem } from "./decision.js";
 import { type ParsedReport, type ReportProblem } from "./scout-report.js";
-import type { Runner } from "./builder.js";
+import { type Runner } from "./builder.js";
 import * as browserCheck from "./scout-browser.js";
 /** The scout's own headless browser: the pinned Playwright tool, saving its
  * screenshots straight into the run's image folder. */

package/dist/scout.js

@@ -27,6 +27,7 @@ import { scoutHandbackSchema } from "./contracts/scout-report.js";
 import { parseReport, REPORT_IMAGE_FILE, REPORT_LIMITS, REPORT_VERSION, SCOUT_OUTPUT_JSON_SCHEMA } from "./scout-report.js";
 import { TOKEN_ENVS as TELEGRAM_TOKEN_ENVS } from "./telegram.js";
 import { evidenceRoot, mailboxName, quarantineMailboxes, readMailbox, reportFileName, SCREENSHOT_BYTE_CAP, storeEvidence, validateScreenshotBytes, writeEvidenceFile, } from "./evidence.js";
+import { gitFailureWords } from "./builder.js";
 import { MARKER as LEASE_MARKER } from "./worktree.js";
 import { liveLogContext } from "./live-detail.js";
 import { openLiveLog } from "./live.js";
@@ -251,7 +252,7 @@ async function scoutWith(store, request, outputDir) {
     }
     const revision = await git(GIT, ["--no-optional-locks", "rev-parse", "HEAD"], { cwd: worktree });
     if (revision.code !== 0) {
-        return { ok: false, kind: "failure", reason: "git", message: `could not read the base revision in ${worktree}` };
+        return { ok: false, kind: "failure", reason: "git", message: `could not read the base revision in ${worktree} (${gitFailureWords(revision)})` };
     }
     const baseRevision = revision.stdout.trim();
     store.stampRun(request.runId, { baseRevision });

package/dist/serve.js

@@ -1,4 +1,5 @@
 import { secretFolder } from "./tool-secret-store.js";
+import { fallbackSettingOf } from "./fallback.js";
 import { acceptedIdentities, recoverLearning } from "./project-learning.js";
 import { consoleFolderGate, syncProjectIdentities } from "./project-identity.js";
 import { inFolderScope } from "./folder-gate.js";
@@ -507,6 +508,7 @@ export function createDecisionServer(options) {
         builds: projectBuildsOf(repo, who),
         access: projectAccessOf(repo),
         network: { setting: store.projectNetwork(repo), canChange: who.via === "cookie" && who.role === "approver" && !store.isDemo() && store.accountCanAccess(who.name, repo) },
+        fallback: { setting: fallbackSettingOf(store, repo), canChange: who.via === "cookie" && who.role === "approver" && !store.isDemo() && store.accountCanAccess(who.name, repo) },
         writes: { setting: store.projectWrites(repo), canChange: who.via === "cookie" && who.role === "approver" && !store.isDemo() && store.accountCanAccess(who.name, repo) },
         sandbox: { setting: store.projectSandbox(repo), canChange: who.via === "cookie" && who.role === "approver" && !store.isDemo() && store.accountCanAccess(who.name, repo) },
         checkAccess: {

package/dist/server/chat.js

@@ -790,7 +790,7 @@ export function createChatHandlers(runtime) {
         }
         // A scope approval's re-check is spent only if the whole confirmation commits (one transaction: the proposal's
         // settlement included). Any other action spends it whatever comes of it (its effects aren't all in the database).
-        const confirmIt = () => confirmLeadProposal(store, principal, id, now, { authority: who.authority, chatProvider: teamChatProvider, confirm: body.get("confirm") === "yes", via: "web", evidenceRoot, ...(body.has("nonce") ? { actionReview: { nonce: body.get("nonce") ?? "", password: body.get("token") ?? "" } } : {}) });
+        const confirmIt = () => confirmLeadProposal(store, principal, id, now, { authority: who.authority, chatProvider: teamChatProvider, confirm: body.get("confirm") === "yes", via: "web", person: who.via === "cookie", evidenceRoot, ...(body.has("nonce") ? { actionReview: { nonce: body.get("nonce") ?? "", password: body.get("token") ?? "" } } : {}) });
         const proposed = store.getLeadProposal(id);
         const approving = proposed?.kind === "action" && sharedActionPayload(proposed.payload)?.operation === "scope_approve";
         const outcome = approving ? spendingOnlyOnSuccess(confirmIt, result => !result.ok || ("already" in result && result.already === true)) : confirmIt();
@@ -832,7 +832,7 @@ export function createChatHandlers(runtime) {
         }
         if (outcome.ok && outcome.kind === "task_action" && outcome.taskId !== null) {
             const proposal = store.getLeadProposal(id);
-            if (proposal.payload["operation"] === "resume") {
+            if (proposal.payload["operation"] === "resume" && who.via !== "cookie") {
                 return armTaskResume(response, who, outcome.taskId, String(proposal.payload["run"]), "chat", now);
             }
             return redirect(response, `${proposalTaskHref(outcome.taskId)}#task-chat-live`);

package/dist/server/console.css

@@ -2816,3 +2816,53 @@ html.so-swap::view-transition-old(*):only-child { animation: so-card-out 160ms e
   .flaky-rows .k-row-a { grid-column: 4; grid-row: 1 / span 2; }
   .flaky-rows .k-row-c { grid-row: 1 / span 2; }
 }
+
+/* A Toolroll card (card-render.ts): tables, charts and key facts in chat, on the console's own tokens. */
+.tc-card { display: grid; gap: var(--so-space-sm); min-width: 0; font-size: 13px; line-height: 1.45; color: var(--so-ink); }
+.tc-part { display: grid; gap: 6px; min-width: 0; }
+.tc-part h4 { margin: 0; font-size: 12.5px; font-weight: 600; }
+.tc-text { margin: 0; }
+/* The lead's own words in a card: set apart from the records, never styled as one. */
+.tc-lead { display: grid; gap: 2px; padding-left: var(--so-space-sm); border-left: 2px solid var(--so-line); font-style: italic; }
+.tc-lead .tc-note { font-style: normal; }
+.tc-note { margin: 0; font-size: 11.5px; color: var(--so-muted); }
+.tc-rule { width: 100%; margin: 0; border: 0; border-top: 1px solid var(--so-line); }
+.tc-facts { display: grid; grid-template-columns: repeat(auto-fit, minmax(96px, 1fr)); gap: var(--so-space-sm); margin: 0; }
+.tc-facts > div { display: grid; gap: 1px; min-width: 0; }
+.tc-facts dt { font-size: 11.5px; color: var(--so-muted); }
+.tc-facts dd { margin: 0; font-weight: 600; font-variant-numeric: tabular-nums; overflow-wrap: anywhere; }
+.tc-scroll { max-width: 100%; overflow-x: auto; }
+.tc-table { width: 100%; border-collapse: collapse; }
+.tc-table th { font-size: 11.5px; font-weight: 500; color: var(--so-muted); text-align: left; white-space: nowrap; }
+.tc-table th, .tc-table td { padding: 5px var(--so-space-md) 5px 0; border-bottom: 1px solid var(--so-line); vertical-align: top; }
+/* Cells break between words, never inside one: a narrow screen scrolls the table (.tc-scroll) instead. */
+.tc-table td { overflow-wrap: break-word; }
+.tc-table tr:last-child td { border-bottom: 0; }
+.tc-table .tc-num { text-align: right; font-variant-numeric: tabular-nums; white-space: nowrap; }
+.tc-bars { display: grid; gap: 6px; margin: 0; padding: 0; list-style: none; }
+.tc-bars li { display: grid; grid-template-columns: minmax(0, 8rem) minmax(0, 1fr) auto; gap: var(--so-space-sm); align-items: center; }
+.tc-bar-label { overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+.tc-bar-track { height: 8px; border-radius: 4px; background: var(--so-raised); }
+.tc-bar-fill { display: block; height: 100%; border-radius: 4px; background: var(--so-ink); }
+.tc-bar-value { font-variant-numeric: tabular-nums; }
+.tc-pie { display: flex; flex-wrap: wrap; align-items: center; gap: var(--so-space-md); }
+.tc-pie svg { flex: none; width: 88px; height: 88px; }
+.tc-legend { display: grid; flex: 1 1 140px; gap: 3px; margin: 0; padding: 0; list-style: none; }
+.tc-legend li { display: flex; align-items: center; gap: 6px; min-width: 0; }
+.tc-legend strong { margin-left: auto; font-weight: 600; font-variant-numeric: tabular-nums; }
+.tc-key { flex: none; width: 9px; height: 9px; border-radius: 2px; background: currentColor; }
+.tc-c0 { color: var(--so-ink); stroke: var(--so-ink); }
+.tc-c1 { color: var(--so-info); stroke: var(--so-info); }
+.tc-c2 { color: var(--so-success); stroke: var(--so-success); }
+.tc-c3 { color: var(--so-warning); stroke: var(--so-warning); }
+.tc-c4 { color: var(--so-danger); stroke: var(--so-danger); }
+.tc-c5 { color: var(--so-muted); stroke: var(--so-muted); }
+.tc-line { margin: 0; display: grid; gap: var(--so-space-xs); }
+.tc-line svg { width: 100%; height: 90px; }
+.tc-line figcaption { font-size: 11.5px; color: var(--so-muted); }
+.tc-stroke { stroke: var(--so-ink); stroke-width: 1.5; }
+.tc-area { fill: var(--so-raised); }
+.tc-notes { display: grid; gap: var(--so-space-xs); margin: 0; padding-left: var(--so-space-md); overflow-wrap: anywhere; }
+
+/* The handover note wraps on a narrow screen rather than scrolling sideways. */
+.handover-note { white-space: pre-wrap; }

package/dist/server/render-chat.js

@@ -2,6 +2,8 @@ import { parseFeedbackImage } from "../result-review.js";
 import { assignmentSummaryHtml } from "../assignment-ui.js";
 import {} from "../assignment.js";
 import {} from "../browser-workspace.js";
+import { webCardHtml } from "../card-render.js";
+import { cardOfProposal, cardPlainOf, cardsFirst, isCardProposal } from "../chat-card.js";
 import { closedQuestionReason } from "../decision.js";
 import { CHAT_ACTIONS, sharedActionNeedsReview, sharedActionPayload, sharedActionReviewPath } from "../chat-actions.js";
 import { CHAT_CONTINUITY_SCRIPT } from "../chat-continuity.js";
@@ -544,6 +546,17 @@ export function proposalCardParts(view, inert, decision, returnTo = null) {
             card: { id: view.id, kind: view.kind, label: "Question closed", state: view.state, body: htmlString(body), said: null, links: [], primary: null, dismissable: false, note: null },
         };
     }
+    // A Toolroll card: data to read, with its fixed links. It confirms nothing, so it waits on nobody.
+    if (isCardProposal(view)) {
+        const shown = cardOfProposal(view);
+        const body = shown === null ? html `<p>${cardPlainOf(view)}</p>` : webCardHtml(shown);
+        const links = shown?.buttons.map(one => ({ label: one.label, href: one.path })) ?? [];
+        const label = shown?.title ?? "Card";
+        return {
+            html: html `<article class="card proposal proposal-data" data-card-kind="data"><div class="proposal-body"><h3>${label}</h3>${body}</div>${links.length === 0 ? "" : html `<footer class="proposal-actions">${joinHtml(links.map(one => html `<a class="button-link" href="${one.href}">${one.label}</a>`))}</footer>`}</article>`,
+            card: { id: view.id, kind: view.kind, label, state: "pending", body: htmlString(body), said: null, links, primary: null, dismissable: false, note: null, data: true },
+        };
+    }
     const presentations = {
         task: { label: payload["report"] === true ? "Scout investigation" : "New task", action: "file task", icon: html `<path d="M12 5v14"/><path d="M5 12h14"/>` },
         next: { label: "Queue priority", action: "move to front", icon: html `<path d="M12 19V5"/><path d="m5 12 7-7 7 7"/>` },
@@ -855,7 +868,7 @@ export function leadBrowserMessages(rows, back, target = { task: null, project:
         activity: message.activity, createdAt: message.createdAt,
         ...(() => {
             // Under the lead's message only, as the server-rendered thread does: the person's message shares the turn.
-            const parts = message.turn === null || message.role === 'operator' ? [] : rows.proposals.filter(one => one.turn === message.turn)
+            const parts = message.turn === null || message.role === 'operator' ? [] : cardsFirst(rows.proposals.filter(one => one.turn === message.turn))
                 .map(one => leadProposalCardParts(one, rows.pending !== null, rows.decisions.get(typeof one.payload['decision'] === 'number' ? one.payload['decision'] : -1) ?? null, back));
             return { cardsHtml: htmlString(joinHtml(parts.map(one => one.html))), cards: parts.map(one => one.card) };
         })(),

package/dist/server/render-follow-through.d.ts

@@ -0,0 +1,11 @@
+import { type Html } from "../html.js";
+import type { Store } from "../store.js";
+export type FollowThroughView = {
+    findings: Html | "";
+    findingCount: number;
+    openFindings: number;
+    repairs: Html | "";
+    evidence: Html | "";
+    handover: Html | "";
+};
+export declare function followThroughView(store: Store, root: string, taskId: string, taskHref: string, canAct: boolean, now: Date): FollowThroughView;

package/dist/server/render-follow-through.js

@@ -0,0 +1,68 @@
+/** The task page's follow-through sections (docs/plans/fleet-follow-through.md): findings, failed checks, before and after,
+ * and the handover note. All of a finding's text is model output or repository text: it renders as text, in `html`'s
+ * escaping, and no action here is reachable from it. Every form posts to the one action in tasks.ts. */
+import { checkRepairsOfTask, checkRepairWords } from "../check-repair.js";
+import { evidencePairsOf, evidenceWords, failingFirstOf, failingFirstWords } from "../evidence-pair.js";
+import { findingLine, findingFromWords, findingsOfTask, findingStandingWords } from "../findings.js";
+import { handoverLines, handoverNoteOf } from "../handover-note.js";
+import { html, joinHtml, postForm } from "../html.js";
+import { providerCaptures } from "../provider-capture.js";
+import { btn, disclose, field, input, note, textarea } from "./kit.js";
+const act = (taskHref, name, label, hidden = {}, variant = "outline") => postForm(`${taskHref}/follow-through`, joinHtml([
+    html `<input type="hidden" name="act" value="${name}">`,
+    ...Object.entries(hidden).map(([key, value]) => html `<input type="hidden" name="${key}" value="${String(value)}">`),
+    btn(label, { variant, type: "submit" }),
+]));
+function findingRow(one, taskHref, canAct) {
+    const answered = one.state === "accepted" || one.state === "rejected";
+    const closing = canAct && one.state !== "closed" ? disclose("Close it", postForm(`${taskHref}/follow-through`, joinHtml([
+        html `<input type="hidden" name="act" value="close"><input type="hidden" name="finding" value="${String(one.id)}">`,
+        field({ id: `finding-close-${one.id}`, label: "Why it can close", control: input({ id: `finding-close-${one.id}`, name: "note" }) }),
+        btn("Close finding", { variant: "outline", type: "submit" }),
+    ]))) : "";
+    return html `<li data-finding="${one.state}"><p>${findingLine(one)}</p><p class="meta">${findingStandingWords(one)}</p><p class="meta">From ${findingFromWords(one)}. Requested: ${one.action}</p>${canAct && answered ? act(taskHref, "resend", "Send it back", { finding: one.id }) : ""}${closing}</li>`;
+}
+function sendForm(taskHref) {
+    return disclose("Send a finding", postForm(`${taskHref}/follow-through`, joinHtml([
+        html `<input type="hidden" name="act" value="send">`,
+        field({ id: "finding-note", label: "What's wrong", control: textarea({ id: "finding-note", name: "note", rows: 3 }) }),
+        field({ id: "finding-file", label: "File, if there is one", control: input({ id: "finding-file", name: "file" }) }),
+        field({ id: "finding-line", label: "Line", control: input({ id: "finding-line", name: "line", type: "number" }) }),
+        btn("Send to the agent", { variant: "outline", type: "submit" }),
+    ])));
+}
+const captureRow = (one, taskHref, canAct) => html `<li><p class="meta">${one.provider}, build #${one.run}${one.label === null ? "" : `, marked ${one.label}`}</p><p class="mono">${one.text.slice(0, 500)}</p>${canAct && one.label === null ? joinHtml([act(taskHref, "mark", "Used-up plan", { capture: one.id, label: "exhausted" }), act(taskHref, "mark", "Something else", { capture: one.id, label: "not-exhausted" })]) : ""}</li>`;
+export function followThroughView(store, root, taskId, taskHref, canAct, now) {
+    const findings = findingsOfTask(store, taskId);
+    const open = findings.filter(one => one.state === "open" || one.state === "with-person").length;
+    const repairs = checkRepairsOfTask(store, taskId).filter(one => one.state !== "closed");
+    const pairs = evidencePairsOf(store, root, taskId, now);
+    const step = failingFirstOf(store, taskId);
+    const stepWords = failingFirstWords(step);
+    const hasRun = store.lookupRef(taskId) !== null && store.runsFor(store.lookupRef(taskId).id).some(one => one.role === "builder" && one.finishedAt !== null);
+    const family = store.taskFamilyOf(taskId, null, true);
+    const familyRuns = new Set((family?.versions.map(one => one.id) ?? [taskId]).flatMap(id => { const ref = store.lookupRef(id); return ref === null ? [] : store.runsFor(ref.id).map(run => run.id); }));
+    const captures = providerCaptures(store, null, 200).filter(one => familyRuns.has(one.run)).slice(0, 5);
+    const latestFailed = repairs.find(one => one.state !== "fixed");
+    const note1 = handoverNoteOf(store, root, taskId, now);
+    return {
+        findingCount: findings.length, openFindings: open,
+        findings: findings.length === 0 && !canAct ? "" : joinHtml([
+            findings.length === 0 ? "" : html `<ul class="result-changes">${findings.map(one => findingRow(one, taskHref, canAct))}</ul>`,
+            canAct ? sendForm(taskHref) : "",
+        ]),
+        repairs: repairs.length === 0 ? "" : html `<ul class="result-changes">${repairs.map(one => html `<li data-check-repair="${one.state}"><p>${checkRepairWords(one)}</p>${one.repairTask === null ? "" : html `<p class="meta"><a class="k-link" href="/t/${encodeURIComponent(one.repairTask)}">Open the repair</a></p>`}${canAct && one.repairTask === null && (one.state === "waiting" || one.state === "parked") ? act(taskHref, "repair", "Start a repair", { run: one.sourceRun }, "primary") : ""}</li>`)}</ul>`,
+        evidence: pairs.length === 0 && stepWords === null && captures.length === 0 && !(canAct && hasRun) ? "" : joinHtml([
+            pairs.length === 0 ? "" : html `<ul class="result-changes">${pairs.map(one => html `<li data-evidence="${one.reading}"><p>${evidenceWords(one)}</p><p class="meta"><a class="k-link" href="/r/${String(one.before.run)}">Before</a>${one.after === null ? "" : html ` · <a class="k-link" href="/r/${String(one.after.run)}">After</a>`}${one.before.screenshots.length + (one.after?.screenshots.length ?? 0) === 0 ? "" : ` · ${one.before.screenshots.length + (one.after?.screenshots.length ?? 0)} screenshots`}</p></li>`)}</ul>`,
+            stepWords === null ? "" : note(stepWords),
+            step?.output == null ? "" : html `<p class="mono">${step.output}</p>`,
+            canAct && hasRun ? html `<div class="k-acts">${joinHtml([
+                ...(latestFailed === undefined ? [] : [act(taskHref, "save-evidence", "Save the failing result", { run: latestFailed.sourceRun })]),
+                ...(pairs.length === 0 ? [] : [act(taskHref, "rerun-evidence", "Run the same check again")]),
+            ])}</div>` : "",
+            canAct ? act(taskHref, step === null ? "failing-first-on" : "failing-first-off", step === null ? "Ask for a failing test first" : "Turn off failing test first") : "",
+            captures.length === 0 ? "" : disclose("What the provider said", html `<ul class="result-changes">${captures.map(one => captureRow(one, taskHref, canAct))}</ul>`),
+        ]),
+        handover: note1 === null ? "" : html `<pre class="mono handover-note">${handoverLines(note1).join("\n")}</pre>`,
+    };
+}

package/dist/server/render-results.js

@@ -1698,7 +1698,7 @@ export function resultPanelParts(detail, o) {
         summaryParts.push(html `<details class="result-notes" data-result-notes-agent><summary>What the agent reported</summary>${agentAccount}</details>`);
     // MEDIUM and LOW never block: suggested follow-ups, on request.
     if (automatic !== null && automatic.followUps.length > 0) {
-        summaryParts.push(html `<details class="result-notes" data-review-followups="${automatic.followUps.length}"><summary>Suggested follow-ups · ${automatic.followUps.length}</summary><ul class="result-changes">${automatic.followUps.map(one => html `<li><span class="badge">${one.severity === "MEDIUM" ? "Medium" : "Low"}</span> <span class="mono">${`${one.file}:${one.line}`}</span> ${one.scenario}</li>`)}</ul></details>`);
+        summaryParts.push(html `<details class="result-notes" data-review-followups="${automatic.followUps.length}"><summary>Suggested follow-ups · ${automatic.followUps.length}</summary><ul class="result-changes">${automatic.followUps.map((one, index) => html `<li><span class="badge">${one.severity === "MEDIUM" ? "Medium" : "Low"}</span> <span class="mono">${`${one.file}:${one.line}`}</span> ${one.scenario}${o.csrf === "" ? "" : postForm(`${taskHref(detail.taskId)}/follow-through`, html `<input type="hidden" name="act" value="send"><input type="hidden" name="pointer" value="${`${automatic.run}:${automatic.high.length + index + 1}`}"><button type="submit" class="secondary">Send to the agent</button>`)}</li>`)}</ul></details>`);
     }
     const evidenceSources = [
         ...(report !== null ? [report.ok ? `verified report${report.truncated ? " (shortened)" : ""}` : "report (unverifiable)"] : []),

package/dist/server/render-tasks.d.ts

@@ -9,6 +9,7 @@ import { type FormView } from "../contracts/console-api.js";
 import { type DispatchDiagnosis } from "../dispatch.js";
 import { type ReportView } from "../evidence.js";
 import { type Gap } from "../gaps.js";
+import type { FollowThroughView } from "./render-follow-through.js";
 import { type FailureExplanation } from "../needs-you.js";
 import { type RouteOverride, type RouteProjection } from "../phase-routing.js";
 import { type MilestoneState } from "../plan.js";
@@ -572,6 +573,8 @@ export declare function taskBodyParts(data: {
     routeChange?: string | null;
     /** A fast start's result grew past a small change (fast-start.ts): its sentence, and the one act on. */
     fastGrown?: string | null;
+    /** Findings, failed checks, before and after, and the handover note (render-follow-through.ts). */
+    followThrough?: FollowThroughView | null;
     /** Easy-start C5: the viewer is a laptop's local owner — whether this plan is one it approves without a password. */
     approvalLocal?: LocalApprovalView | null;
     /** Cockpit B2: how the current approval's person was proved (approval proved ledger), when it was a remembered one. */