toolroll 0.9.94 → 0.9.95

package/dist/card-render.js

@@ -0,0 +1,223 @@
+import { html, joinHtml } from "./html.js";
+const noteLines = (block) => [...block.items.map(one => `• ${one}`), ...(block.more > 0 ? [moreWords(block.more)] : [])];
+const fit = (text, width) => text.length <= width ? text : `${text.slice(0, Math.max(1, width - 1))}…`;
+/** Only parts filled from a named source are Toolroll's records; the line says so only when a card has one, and says
+ * which parts, so the lead's own words beside them never borrow that standing. */
+const sourced = (card) => card.blocks.some(one => one.kind !== "text" && one.kind !== "divider");
+/** A part marked as not Toolroll's records: the lead's note, or words an agent reported. */
+const marked = (card) => card.blocks.some(one => one.kind === "text" || ((one.kind === "table" || one.kind === "notes") && one.origin === "report"));
+const asOfWords = (card) => `${marked(card) ? "Parts not marked otherwise are from Toolroll's records" : "From Toolroll's records"} · ${card.asOf.slice(0, 16).replace("T", " ")} UTC`;
+const footWords = (card) => sourced(card) ? [asOfWords(card)] : [];
+const reportWords = "Reported by the agent, not Toolroll's records";
+/** A Text part is the lead's (a model's) words: always labelled as such, on every app, never as a record. */
+export const LEAD_NOTE_WORDS = "The lead's note, not Toolroll's records";
+const moreWords = (more) => `and ${more} more`;
+/** A part's heading, unless it only repeats the card's title. */
+const headOf = (card, heading) => heading === card.title ? [] : [heading];
+/** A table as aligned lines, narrow enough for a phone. */
+function tableLines(block, maxWidth = 58) {
+    const widths = block.columns.map((column, at) => Math.max(column.label.length, ...block.rows.map(row => row[at].length)));
+    const budget = maxWidth - 2 * (widths.length - 1);
+    while (widths.reduce((a, b) => a + b, 0) > budget && Math.max(...widths) > 6)
+        widths[widths.indexOf(Math.max(...widths))] -= 1;
+    const line = (cells) => cells.map((one, at) => {
+        const shown = fit(one, widths[at]);
+        return block.columns[at].numeric ? shown.padStart(widths[at]) : shown.padEnd(widths[at]);
+    }).join("  ").trimEnd();
+    return [line(block.columns.map(one => one.label)), ...block.rows.map(line), ...(block.more > 0 ? [moreWords(block.more)] : [])];
+}
+/** A chart as bars of text: every number stays readable. */
+function chartLines(block) {
+    const top = Math.max(...block.points.map(one => one.value), 0);
+    const name = Math.min(18, Math.max(...block.points.map(one => one.label.length)));
+    return block.points.map(one => `${fit(one.label, name).padEnd(name)} ${"█".repeat(top === 0 ? 0 : Math.round(one.value / top * 14)).padEnd(14)} ${one.shown}`);
+}
+/** The whole card as plain text: the version every app can show. */
+export function cardPlainText(card) {
+    const parts = card.blocks.flatMap((block) => {
+        switch (block.kind) {
+            case "text": return [`${LEAD_NOTE_WORDS}:\n${block.text}`];
+            case "divider": return [];
+            case "facts": return [block.items.map(one => `${one.label}: ${one.value}`).join("\n")];
+            case "table": return [[...headOf(card, block.heading), ...(block.origin === "report" ? [reportWords] : []), ...tableLines(block)].join("\n")];
+            case "notes": return [[...headOf(card, block.heading), ...(block.origin === "report" ? [reportWords] : []), ...noteLines(block)].join("\n")];
+            case "chart": return [[...headOf(card, block.heading), ...chartLines(block)].join("\n")];
+        }
+    });
+    const under = card.actions.length === 0 ? [] : [`Confirm below: ${card.actions.map(one => one.label).join(", ")}`];
+    return [card.title, ...parts, ...footWords(card), ...under].join("\n\n");
+}
+// ---- Slack ---------------------------------------------------------------------------------------------------------
+/** In a Slack code block only these need care: nothing inside can become a mention or a link, and it can't close early. */
+const slackCode = (text) => text.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll("`", "'");
+const SLACK_CHART_LABEL = 20;
+const SLACK_CHART_TITLE = 50;
+function slackChart(block) {
+    const unique = new Set(block.points.map(one => one.label)).size === block.points.length;
+    if (block.heading.length > SLACK_CHART_TITLE || !unique || block.points.some(one => one.label.length > SLACK_CHART_LABEL))
+        return null;
+    if (block.chart === "pie") {
+        if (block.points.some(one => one.value <= 0))
+            return null;
+        return { type: "data_visualization", title: block.heading, chart: { type: "pie", segments: block.points.map(({ label, value }) => ({ label, value })) } };
+    }
+    return { type: "data_visualization", title: block.heading, chart: { type: block.chart, series: [{ name: block.heading.slice(0, SLACK_CHART_LABEL), data: block.points.map(({ label, value }) => ({ label, value })) }], axis_config: { categories: block.points.map(one => one.label) } } };
+}
+/** The card as Block Kit, native where Slack has it: one data table and two charts a message, the rest as code blocks. */
+export function slackCardBlocks(card, buttons) {
+    const out = [{ type: "header", text: { type: "plain_text", text: fit(card.title, 150), emoji: false } }];
+    const code = (lines) => ({ type: "section", text: { type: "mrkdwn", text: `\`\`\`${slackCode(lines.join("\n")).slice(0, 2900)}\`\`\``, verbatim: true } });
+    let tables = 0, charts = 0;
+    for (const block of card.blocks) {
+        if (block.kind === "text") {
+            out.push({ type: "context", elements: [{ type: "plain_text", text: LEAD_NOTE_WORDS, emoji: false }] });
+            out.push({ type: "section", text: { type: "plain_text", text: block.text, emoji: false } });
+        }
+        else if (block.kind === "divider")
+            out.push({ type: "divider" });
+        else if (block.kind === "notes") {
+            if (block.origin === "report")
+                out.push({ type: "context", elements: [{ type: "plain_text", text: reportWords, emoji: false }] });
+            out.push({ type: "section", text: { type: "plain_text", text: noteLines(block).join("\n").slice(0, 2900), emoji: false } });
+        }
+        else if (block.kind === "facts")
+            out.push({ type: "section", fields: block.items.map(one => ({ type: "plain_text", text: `${one.label}: ${one.value || " "}`, emoji: false })) });
+        else if (block.kind === "table") {
+            if (block.origin === "report")
+                out.push({ type: "context", elements: [{ type: "plain_text", text: reportWords, emoji: false }] });
+            if (tables === 0 && block.rows.length > 0) {
+                tables++;
+                const cell = (text) => ({ type: "raw_text", text: text === "" ? " " : text });
+                out.push({ type: "data_table", caption: block.heading, rows: [block.columns.map(one => cell(one.label)), ...block.rows.map(row => row.map(cell))] });
+                if (block.more > 0)
+                    out.push({ type: "context", elements: [{ type: "plain_text", text: moreWords(block.more), emoji: false }] });
+            }
+            else
+                out.push(code([...headOf(card, block.heading), ...tableLines(block)]));
+        }
+        else {
+            const native = charts < 2 ? slackChart(block) : null;
+            if (native !== null) {
+                charts++;
+                out.push(native);
+            }
+            else
+                out.push(code([...headOf(card, block.heading), ...chartLines(block)]));
+        }
+    }
+    const under = card.actions.length === 0 ? "" : ` · Confirm below: ${card.actions.map(one => one.label).join(", ")}`;
+    const foot = `${footWords(card).join("")}${under}`.replace(/^ · /, "");
+    if (foot !== "")
+        out.push({ type: "context", elements: [{ type: "plain_text", text: fit(foot, 300), emoji: false }] });
+    if (buttons.length > 0)
+        out.push({ type: "actions", elements: buttons });
+    return out;
+}
+// ---- Discord -------------------------------------------------------------------------------------------------------
+const discordCode = (text) => text.replaceAll("`", "'");
+/** The card as one embed: facts as fields, tables and charts as code blocks. `plain` escapes Discord's own syntax. */
+export function discordCardEmbed(card, plain) {
+    const fields = [];
+    const text = [];
+    for (const block of card.blocks) {
+        if (block.kind === "text")
+            text.push(`${plain(LEAD_NOTE_WORDS)}:\n${plain(block.text)}`);
+        else if (block.kind === "facts")
+            fields.push(...block.items.map(one => ({ name: plain(one.label), value: plain(one.value) || "​", inline: true })));
+        else if (block.kind === "notes")
+            fields.push({ name: plain(block.heading), value: `${block.origin === "report" ? `${reportWords}\n` : ""}${plain(noteLines(block).join("\n")).slice(0, 960)}` });
+        else if (block.kind === "table" || block.kind === "chart") {
+            const lines = block.kind === "table" ? tableLines(block, 50) : chartLines(block);
+            const origin = block.kind === "table" && block.origin === "report" ? `${reportWords}\n` : "";
+            fields.push({ name: plain(block.heading), value: `${origin}\`\`\`\n${discordCode(lines.join("\n")).slice(0, 960)}\n\`\`\`` });
+        }
+    }
+    const under = card.actions.length === 0 ? "" : ` · Confirm below: ${card.actions.map(one => one.label).join(", ")}`;
+    const foot = `${footWords(card).join("")}${under}`.replace(/^ · /, "");
+    return { title: plain(card.title).slice(0, 256), ...(text.length === 0 ? {} : { description: text.join("\n\n").slice(0, 4096) }), fields: fields.slice(0, 25), ...(foot === "" ? {} : { footer: { text: foot.slice(0, 2048) } }), color: 0x297b70 };
+}
+// ---- Telegram ------------------------------------------------------------------------------------------------------
+/** The card as one Telegram message: plain words, tables and charts as `pre` entities, so nothing in a value is parsed. */
+export function telegramCardMessage(card) {
+    const entities = [];
+    let text = "";
+    const add = (words, type) => {
+        if (text !== "")
+            text += "\n\n";
+        if (type !== undefined)
+            entities.push({ type, offset: text.length, length: words.length });
+        text += words;
+    };
+    add(card.title, "bold");
+    for (const block of card.blocks) {
+        if (block.kind === "text") {
+            add(LEAD_NOTE_WORDS, "bold");
+            add(block.text);
+        }
+        else if (block.kind === "facts")
+            add(block.items.map(one => `${one.label}: ${one.value}`).join("\n"));
+        else if (block.kind === "notes") {
+            for (const one of headOf(card, block.heading))
+                add(one, "bold");
+            if (block.origin === "report")
+                add(reportWords);
+            add(noteLines(block).join("\n"));
+        }
+        else if (block.kind === "table") {
+            for (const one of headOf(card, block.heading))
+                add(one, "bold");
+            if (block.origin === "report")
+                add(reportWords);
+            add(tableLines(block, 40).join("\n"), "pre");
+        }
+        else if (block.kind === "chart") {
+            for (const one of headOf(card, block.heading))
+                add(one, "bold");
+            add(chartLines(block).join("\n"), "pre");
+        }
+    }
+    for (const one of footWords(card))
+        add(one);
+    if (card.actions.length > 0)
+        add(`Confirm below: ${card.actions.map(one => one.label).join(", ")}`);
+    // Telegram's own limit: past it, the whole plain version, cut, with no entities that could point past the end.
+    return text.length <= 4000 ? { text, entities } : { text: cardPlainText(card).slice(0, 4000), entities: [] };
+}
+// ---- web chat ------------------------------------------------------------------------------------------------------
+const CHART_COLORS = 6;
+function webChart(block) {
+    const top = Math.max(...block.points.map(one => one.value), 0) || 1;
+    const summary = block.points.map(one => `${one.label}: ${one.shown}`).join(", ");
+    if (block.chart === "bar") {
+        return html `<ul class="tc-bars" aria-label="${block.heading}">${joinHtml(block.points.map(one => html `<li><span class="tc-bar-label">${one.label}</span><span class="tc-bar-track"><span class="tc-bar-fill" style="width:${Math.max(1, Math.round(one.value / top * 100))}%"></span></span><span class="tc-bar-value">${one.shown}</span></li>`))}</ul>`;
+    }
+    if (block.chart === "pie") {
+        const total = block.points.reduce((sum, one) => sum + one.value, 0) || 1;
+        let at = 0;
+        const slices = block.points.map((one, index) => {
+            const share = one.value / total * 100, from = at;
+            at += share;
+            return html `<circle class="tc-slice tc-c${index % CHART_COLORS}" r="15.915" cx="20" cy="20" fill="none" stroke-width="7" pathLength="100" stroke-dasharray="${share.toFixed(3)} ${(100 - share).toFixed(3)}" stroke-dashoffset="${(25 - from).toFixed(3)}"></circle>`;
+        });
+        return html `<div class="tc-pie"><svg viewBox="0 0 40 40" role="img" aria-label="${`${block.heading}. ${summary}`}">${joinHtml(slices)}</svg><ul class="tc-legend">${joinHtml(block.points.map((one, index) => html `<li><span class="tc-key tc-c${index % CHART_COLORS}"></span>${one.label}<strong>${one.shown}</strong></li>`))}</ul></div>`;
+    }
+    const width = 300, height = 90, step = block.points.length > 1 ? width / (block.points.length - 1) : 0;
+    const xy = block.points.map((one, index) => [Math.round(index * step), Math.round(height - one.value / top * (height - 6) - 2)]);
+    const line = xy.map(([x, y]) => `${x},${y}`).join(" ");
+    return html `<figure class="tc-line"><svg viewBox="0 0 ${width} ${height}" preserveAspectRatio="none" role="img" aria-label="${`${block.heading}. ${summary}`}">${block.chart === "area" ? html `<polygon class="tc-area" points="0,${height} ${line} ${width},${height}"></polygon>` : ""}<polyline class="tc-stroke" points="${line}" fill="none" vector-effect="non-scaling-stroke"></polyline></svg><figcaption>${summary}</figcaption></figure>`;
+}
+const partHead = (card, heading) => joinHtml(headOf(card, heading).map(one => html `<h4>${one}</h4>`));
+/** The card as the web chat's own markup; every value is escaped by `html`. */
+export function webCardHtml(card) {
+    const blocks = card.blocks.map(block => {
+        switch (block.kind) {
+            case "text": return html `<div class="tc-lead"><p class="tc-note">${LEAD_NOTE_WORDS}</p><p class="tc-text">${block.text}</p></div>`;
+            case "divider": return html `<hr class="tc-rule">`;
+            case "facts": return html `<dl class="tc-facts">${joinHtml(block.items.map(one => html `<div><dt>${one.label}</dt><dd>${one.value}</dd></div>`))}</dl>`;
+            case "table": return html `<div class="tc-part">${partHead(card, block.heading)}${block.origin === "report" ? html `<p class="tc-note">${reportWords}</p>` : ""}<div class="tc-scroll"><table class="tc-table"><thead><tr>${joinHtml(block.columns.map(one => html `<th scope="col" class="${one.numeric ? "tc-num" : ""}">${one.label}</th>`))}</tr></thead><tbody>${joinHtml(block.rows.map(row => html `<tr>${joinHtml(row.map((one, at) => html `<td class="${block.columns[at].numeric ? "tc-num" : ""}">${one}</td>`))}</tr>`))}</tbody></table></div>${block.more > 0 ? html `<p class="tc-note">${moreWords(block.more)}</p>` : ""}</div>`;
+            case "notes": return html `<div class="tc-part">${partHead(card, block.heading)}${block.origin === "report" ? html `<p class="tc-note">${reportWords}</p>` : ""}<ul class="tc-notes">${joinHtml(block.items.map(one => html `<li>${one}</li>`))}</ul>${block.more > 0 ? html `<p class="tc-note">${moreWords(block.more)}</p>` : ""}</div>`;
+            case "chart": return html `<div class="tc-part">${partHead(card, block.heading)}${webChart(block)}</div>`;
+        }
+    });
+    return html `<div class="tc-card">${joinHtml(blocks)}${joinHtml(footWords(card).map(one => html `<p class="tc-note">${one}</p>`))}</div>`;
+}

package/dist/card-sources.d.ts

@@ -0,0 +1,68 @@
+import type { CardSourceName } from "./card-catalog.js";
+import type { Integration } from "./integrations.js";
+import { type Store } from "./store.js";
+export type CardReader = {
+    store: Store;
+    now: Date;
+    who: {
+        name: string;
+        repos: readonly string[];
+    };
+    /** Where saved evidence lives; absent, the handover note can't be read here. */
+    evidenceRoot?: string;
+    /** Reads a chat turn already has; absent, the source says it can't be read here. */
+    integrations?: () => readonly Integration[];
+    providers?: (repos: readonly string[]) => readonly {
+        project: string;
+        provider: string;
+        model: string;
+        roles: readonly string[];
+        state: string;
+    }[];
+    workers?: (repos: readonly string[]) => readonly {
+        name: string;
+        state: string;
+        capacity: number;
+        running: number;
+    }[];
+};
+export type CardQuery = {
+    repo: string | null;
+    task?: string;
+    state?: string;
+    limit?: number;
+    flow?: number;
+    days?: number;
+};
+export type CardColumn = {
+    id: string;
+    label: string;
+    numeric?: true;
+};
+export type CardFact = {
+    id: string;
+    label: string;
+    value: string;
+};
+export type CardPoint = {
+    label: string;
+    value: number;
+    shown: string;
+};
+export type CardData = {
+    heading: string; /** `report`: saved model or repository words, shown as such. */
+    origin?: "records" | "report";
+    notes?: readonly string[];
+    repos: readonly string[];
+    columns: readonly CardColumn[];
+    rows: readonly Record<string, string>[];
+    more: number;
+    facts: readonly CardFact[];
+    points: readonly CardPoint[];
+};
+type Read = CardData | {
+    problem: string;
+};
+/** One source, read now as this person. */
+export declare function readCardSource(reader: CardReader, name: CardSourceName, query: CardQuery): Read;
+export {};

package/dist/card-sources.js

@@ -0,0 +1,234 @@
+/**
+ * The named data a card can show (docs/plans/toolroll-cards.md): Toolroll fills these from its own records, with the same
+ * reach as the page or lead tool each one mirrors, so a model chooses what to show and never what it says.
+ *
+ * Every value goes through publicChatText here, once, before it can reach any platform.
+ */
+import { basename } from "node:path";
+import { publicChatText } from "./chat-display.js";
+import { CARD_LIMITS } from "./contracts/chat-card.js";
+import { familyInReach, findingLine, findingsInReach, findingSourceWords, findingStandingWords } from "./findings.js";
+import { flowInsights } from "./flow-insights.js";
+import { handoverLines, handoverNoteOf } from "./handover-note.js";
+import { projectOutcomes } from "./project-outcomes.js";
+import { monthOf } from "./spend.js";
+import { spendReport, spendRows } from "./spend-report.js";
+import { refArchived } from "./store.js";
+const clean = (value, cap = CARD_LIMITS.cell) => publicChatText(String(value), cap);
+const dollars = (micro) => `$${(micro / 1_000_000).toFixed(2)}`;
+const ago = (from, now) => {
+    const hours = Math.max(0, Math.round((now.getTime() - Date.parse(from)) / 3_600_000));
+    return hours < 48 ? `${hours}h` : `${Math.round(hours / 24)}d`;
+};
+const projectName = (repo) => repo === null ? "Toolroll" : clean(basename(repo), 40);
+/** An account limited to some projects sees the instance-wide pages' data no more than the console shows it. */
+const instanceWide = (reader) => reader.store.accountOf(reader.who.name)?.projects === null;
+const INSTANCE_ONLY = { problem: "That needs an account with access to every project, as the page does." };
+const count = (points) => points.filter(([, value]) => value > 0).slice(0, CARD_LIMITS.points).map(([label, value]) => ({ label: clean(label, CARD_LIMITS.label), value, shown: String(value) }));
+const reposOf = (reader, query) => query.repo === null ? reader.who.repos : [query.repo];
+function tasks(reader, query) {
+    const { store } = reader, repos = reposOf(reader, query), limit = query.limit ?? 10;
+    const states = query.state === undefined ? {} : { states: [query.state] };
+    const all = store.taskFamiliesAdmitted(repos, false, { limit: 500, order: "created", ...states }).filter(one => !refArchived(store, one.current.refId));
+    const counts = new Map();
+    for (const one of all)
+        counts.set(one.current.state, (counts.get(one.current.state) ?? 0) + 1);
+    const shownCount = all.length >= 500 ? "Latest 500 tasks" : "Tasks";
+    return {
+        heading: query.state === undefined ? shownCount : `${query.state.charAt(0).toUpperCase()}${query.state.slice(1)} tasks`, repos,
+        columns: [{ id: "title", label: "Task" }, { id: "state", label: "State" }, { id: "project", label: "Project" }, { id: "age", label: "Updated" }, { id: "strikes", label: "Failed attempts", numeric: true }],
+        rows: all.slice(0, limit).map(one => ({ title: clean(one.root.title), state: clean(one.current.state), project: projectName(one.current.repo), age: `${ago(one.current.updatedAt, reader.now)} ago`, strikes: String(store.lookupRef(one.current.id)?.strikes ?? 0) })),
+        more: Math.max(0, all.length - limit),
+        facts: [{ id: "total", label: "Total", value: String(all.length) }, ...[...counts].map(([state, value]) => ({ id: state, label: `${state.charAt(0).toUpperCase()}${state.slice(1)}`, value: String(value) }))],
+        points: count([...counts].sort((a, b) => b[1] - a[1])),
+    };
+}
+function results(reader, query) {
+    const repos = reposOf(reader, query).slice(0, 8), limit = query.limit ?? 10;
+    const access = { principal: "operator", repos: [...reader.who.repos] };
+    const reports = repos.map(repo => ({ repo, report: projectOutcomes(reader.store, repo, reader.now, access) }));
+    const rows = reports.flatMap(({ repo, report }) => report.families.map(one => ({ one, repo }))).sort((a, b) => (b.one.finishedAt ?? "").localeCompare(a.one.finishedAt ?? ""));
+    const sum = (read) => reports.reduce((total, one) => total + read(one.report), 0);
+    const recorded = reports.flatMap(one => one.report.cost.recordedUsd === null ? [] : [one.report.cost.recordedUsd]);
+    const ready = sum(report => report.ready.count), done = sum(report => report.completed.count), revisions = sum(report => report.revisions.count);
+    return {
+        heading: "Results, last 60 days", repos,
+        columns: [{ id: "title", label: "Task" }, { id: "state", label: "State" }, { id: "checks", label: "Checks" }, { id: "project", label: "Project" }, { id: "cost", label: "Cost", numeric: true }],
+        rows: rows.slice(0, limit).map(({ one, repo }) => ({ title: clean(one.title), state: clean(one.state), checks: clean(one.checks), project: projectName(repo), cost: one.totalUsd === null ? "not recorded" : `$${one.totalUsd.toFixed(2)}` })),
+        more: Math.max(0, rows.length - limit),
+        facts: [{ id: "ready", label: "Ready", value: String(ready) }, { id: "completed", label: "Completed", value: String(done) }, { id: "revisions", label: "Revisions", value: String(revisions) },
+            ...(recorded.length === 0 ? [] : [{ id: "cost", label: "Recorded cost", value: `$${recorded.reduce((a, b) => a + b, 0).toFixed(2)}` }])],
+        points: count([["Ready", ready], ["Completed", done]]),
+    };
+}
+function flows(reader, query) {
+    const { store } = reader, repos = reposOf(reader, query), limit = query.limit ?? 10;
+    const list = store.listFlows(repos).filter(one => one.state === "active" && reader.who.repos.includes(one.repo) && store.accountCanAccess(reader.who.name, one.repo));
+    const seen = list.map(flow => { const cards = store.flowCards(flow.id, true); return { flow, active: cards.filter(one => one.state === "active").length, finished: cards.filter(one => one.state !== "active").length }; });
+    return {
+        heading: "Flows", repos,
+        columns: [{ id: "name", label: "Flow" }, { id: "project", label: "Project" }, { id: "active", label: "Active cards", numeric: true }, { id: "finished", label: "Finished cards", numeric: true }],
+        rows: seen.slice(0, limit).map(one => ({ name: clean(one.flow.name), project: projectName(one.flow.repo), active: String(one.active), finished: String(one.finished) })),
+        more: Math.max(0, seen.length - limit),
+        facts: [{ id: "flows", label: "Flows", value: String(seen.length) }, { id: "active", label: "Active cards", value: String(seen.reduce((sum, one) => sum + one.active, 0)) }],
+        points: count(seen.map(one => [one.flow.name, one.active])),
+    };
+}
+function flowZones(reader, query) {
+    const { store } = reader, days = query.days ?? 30;
+    if (query.flow === undefined)
+        return { problem: "Name the flow: flow_zones needs flow, its number from get_flows." };
+    const flow = store.getFlow(query.flow);
+    if (flow === null || flow.state !== "active" || !reader.who.repos.includes(flow.repo) || !store.accountCanAccess(reader.who.name, flow.repo))
+        return { problem: "No such flow in your projects." };
+    const seen = flowInsights(store, flow, reader.now, days), limit = query.limit ?? CARD_LIMITS.rows;
+    return {
+        heading: clean(`${flow.name}, last ${days} days`, CARD_LIMITS.heading), repos: [flow.repo],
+        columns: [{ id: "step", label: "Step" }, { id: "entered", label: "Arrived", numeric: true }, { id: "failed", label: "Failed", numeric: true }, { id: "sentBack", label: "Sent back", numeric: true }, { id: "here", label: "Here now", numeric: true }, { id: "typical", label: "Typical stay", numeric: true }],
+        rows: seen.zones.slice(0, limit).map(one => ({ step: clean(one.title), entered: String(one.entered), failed: String(one.failed), sentBack: String(one.sentBack), here: String(one.here), typical: one.typicalMinutes === null ? "none yet" : `${Math.round(one.typicalMinutes)} min` })),
+        more: Math.max(0, seen.zones.length - limit),
+        facts: [{ id: "started", label: "Started", value: String(seen.cards.started) }, { id: "finished", label: "Finished", value: String(seen.cards.finished) }, { id: "active", label: "Active", value: String(seen.cards.active) }],
+        points: count(seen.zones.map(one => [one.title, one.entered])),
+    };
+}
+function spend(reader, query) {
+    const { store, now } = reader;
+    // As /spend: an instance operator's page.
+    if (!store.isInstanceOperator(reader.who.name))
+        return { problem: "Only an instance operator sees spend." };
+    const month = monthOf(now), report = spendReport(spendRows(store.handle, month.from, month.to)), limit = query.limit ?? 10;
+    const cost = (line) => line.apiMicrousd + line.estimatedMicrousd;
+    const lines = [...report.byProject].filter(one => query.repo === null || one.key === query.repo).sort((a, b) => cost(b) - cost(a));
+    return {
+        heading: clean(`Spend, ${month.name}`, CARD_LIMITS.heading), repos: reader.who.repos,
+        columns: [{ id: "project", label: "Project" }, { id: "api", label: "API dollars", numeric: true }, { id: "estimated", label: "Estimated", numeric: true }, { id: "work", label: "Pieces of work", numeric: true }],
+        rows: lines.slice(0, limit).map(one => ({ project: projectName(one.key), api: dollars(one.apiMicrousd), estimated: dollars(one.estimatedMicrousd), work: String(one.count) })),
+        more: Math.max(0, lines.length - limit),
+        facts: [{ id: "api", label: "API dollars", value: dollars(report.totals.apiMicrousd) }, { id: "estimated", label: "Estimated", value: dollars(report.totals.estimatedMicrousd) }, { id: "work", label: "Pieces of work", value: String(report.totals.count) }],
+        points: lines.filter(one => cost(one) > 0).slice(0, CARD_LIMITS.points).map(one => ({ label: projectName(one.key), value: cost(one) / 1_000_000, shown: dollars(cost(one)) })),
+    };
+}
+function projects(reader, query) {
+    const { store, now } = reader, repos = reposOf(reader, query), limit = query.limit ?? 10;
+    const seen = repos.map(repo => {
+        const families = store.taskFamiliesAdmitted([repo], false, { limit: 500, order: "created" }).filter(one => !refArchived(store, one.current.refId));
+        const of = (state) => families.filter(one => one.current.state === state).length;
+        return { repo, running: of("running"), queued: of("queued"), failed: of("failed"), mode: store.activeMode(repo, now)?.name ?? "none" };
+    });
+    return {
+        heading: "Projects", repos,
+        columns: [{ id: "project", label: "Project" }, { id: "running", label: "Running", numeric: true }, { id: "queued", label: "Queued", numeric: true }, { id: "failed", label: "Failed", numeric: true }, { id: "mode", label: "Automatic approvals" }],
+        rows: seen.slice(0, limit).map(one => ({ project: projectName(one.repo), running: String(one.running), queued: String(one.queued), failed: String(one.failed), mode: clean(one.mode) })),
+        more: Math.max(0, seen.length - limit),
+        facts: [{ id: "projects", label: "Projects", value: String(seen.length) }, { id: "running", label: "Running", value: String(seen.reduce((sum, one) => sum + one.running, 0)) }, { id: "failed", label: "Failed", value: String(seen.reduce((sum, one) => sum + one.failed, 0)) }],
+        points: count(seen.map(one => [projectName(one.repo), one.running + one.queued])),
+    };
+}
+function builders(reader, query) {
+    if (!instanceWide(reader))
+        return INSTANCE_ONLY;
+    if (reader.workers === undefined)
+        return { problem: "Builders can't be read here." };
+    const repos = reposOf(reader, query), limit = query.limit ?? 10, list = reader.workers(repos);
+    return {
+        heading: "Builders", repos,
+        columns: [{ id: "name", label: "Builder" }, { id: "state", label: "State" }, { id: "capacity", label: "Capacity", numeric: true }, { id: "running", label: "Running", numeric: true }],
+        rows: list.slice(0, limit).map(one => ({ name: clean(one.name), state: clean(one.state), capacity: String(one.capacity), running: String(one.running) })),
+        more: Math.max(0, list.length - limit),
+        facts: [{ id: "builders", label: "Builders", value: String(list.length) }, { id: "capacity", label: "Capacity", value: String(list.reduce((sum, one) => sum + one.capacity, 0)) }],
+        points: count(list.map(one => [one.name, one.running])),
+    };
+}
+function mode(reader, query) {
+    if (!instanceWide(reader))
+        return INSTANCE_ONLY;
+    const { store, now } = reader, repos = reposOf(reader, query), limit = query.limit ?? 10;
+    const seen = repos.map(repo => ({ repo, mode: store.activeMode(repo, now) }));
+    return {
+        heading: "Automatic approvals", repos,
+        columns: [{ id: "project", label: "Project" }, { id: "mode", label: "Mode" }, { id: "by", label: "Signed by" }, { id: "until", label: "Ends" }],
+        rows: seen.slice(0, limit).map(one => ({ project: projectName(one.repo), mode: clean(one.mode?.name ?? "none"), by: clean(one.mode?.signedBy ?? ""), until: one.mode === null ? "" : clean(one.mode.absoluteExpiry.slice(0, 10)) })),
+        more: Math.max(0, seen.length - limit),
+        facts: [{ id: "on", label: "Projects with a mode", value: String(seen.filter(one => one.mode !== null).length) }, { id: "off", label: "Without", value: String(seen.filter(one => one.mode === null).length) }],
+        points: [],
+    };
+}
+function integrations(reader, query) {
+    if (!instanceWide(reader))
+        return INSTANCE_ONLY;
+    if (reader.integrations === undefined)
+        return { problem: "Integrations can't be read here." };
+    const list = reader.integrations(), limit = query.limit ?? CARD_LIMITS.rows;
+    const counts = new Map();
+    for (const one of list)
+        counts.set(one.state, (counts.get(one.state) ?? 0) + 1);
+    return {
+        heading: "Integrations", repos: reader.who.repos,
+        columns: [{ id: "name", label: "Integration" }, { id: "kind", label: "Kind" }, { id: "state", label: "State" }, { id: "account", label: "Account" }],
+        rows: list.slice(0, limit).map(one => ({ name: clean(one.name), kind: clean(one.group), state: clean(one.state), account: clean(one.account ?? "") })),
+        more: Math.max(0, list.length - limit),
+        facts: [...counts].slice(0, CARD_LIMITS.facts).map(([state, value]) => ({ id: state, label: clean(state, CARD_LIMITS.label), value: String(value) })),
+        points: count([...counts]),
+    };
+}
+function providers(reader, query) {
+    if (reader.providers === undefined)
+        return { problem: "Providers can't be read here." };
+    const repos = reposOf(reader, query).slice(0, 8), limit = query.limit ?? 10, list = reader.providers(repos);
+    return {
+        heading: "Agents and sign-ins", repos,
+        columns: [{ id: "provider", label: "Provider" }, { id: "model", label: "Model" }, { id: "roles", label: "Roles" }, { id: "state", label: "State" }, { id: "project", label: "Project" }],
+        rows: list.slice(0, limit).map(one => ({ provider: clean(one.provider), model: clean(one.model), roles: clean(one.roles.join(", ")), state: clean(one.state), project: projectName(one.project) })),
+        more: Math.max(0, list.length - limit),
+        facts: [{ id: "agents", label: "Agents", value: String(list.length) }],
+        points: [],
+    };
+}
+/** A finding's state as a person reads it in a card (never the stored token). */
+const FINDING_STATE_WORDS = { open: "With the agent", accepted: "Accepted", rejected: "Rejected", "with-person": "Needs you", closed: "Closed" };
+function findings(reader, query) {
+    const limit = query.limit ?? 10;
+    const list = findingsInReach(reader.store, reader.who, { ...(query.task === undefined ? {} : { task: query.task }), repos: reposOf(reader, query) });
+    if (list === null)
+        return { problem: "No such task in your projects." };
+    const counts = new Map();
+    for (const one of list)
+        counts.set(one.state, (counts.get(one.state) ?? 0) + 1);
+    return {
+        heading: query.task === undefined ? "Findings waiting" : "Findings", origin: "report", repos: [...new Set(list.map(one => one.repo))],
+        columns: [{ id: "id", label: "Finding", numeric: true }, { id: "where", label: "Where" }, { id: "state", label: "State" }, { id: "from", label: "From" }, { id: "task", label: "Task" }],
+        rows: list.slice(0, limit).map(one => ({ id: String(one.id), where: clean(one.file === null ? "" : `${one.file}${one.line === null ? "" : `:${one.line}`}`), state: FINDING_STATE_WORDS[one.state] ?? clean(one.state), from: clean(findingSourceWords(one.source)), task: clean(one.taskId) })),
+        more: Math.max(0, list.length - limit),
+        notes: list.map(one => clean(`${findingLine(one)} (${findingStandingWords(one)})`, CARD_LIMITS.note)),
+        facts: [{ id: "total", label: "Findings", value: String(list.length) }, ...[...counts].map(([state, value]) => ({ id: state, label: clean(state, CARD_LIMITS.label), value: String(value) }))],
+        points: count([...counts]),
+    };
+}
+function handover(reader, query) {
+    if (query.task === undefined)
+        return { problem: "Name the task: handover needs task." };
+    const repos = familyInReach(reader.store, reader.who, query.task);
+    if (repos === null)
+        return { problem: "No such task in your projects." };
+    if (reader.evidenceRoot === undefined)
+        return { problem: "The handover note can't be read here. Use toolroll task handover." };
+    const note = handoverNoteOf(reader.store, reader.evidenceRoot, query.task, reader.now);
+    if (note === null)
+        return { problem: "No such task in your projects." };
+    return {
+        heading: clean(`Handover: ${query.task}`, CARD_LIMITS.heading), origin: "report", repos,
+        columns: [{ id: "what", label: "Part" }, { id: "count", label: "Count", numeric: true }],
+        rows: [["Accepted decisions", note.acceptedDecisions.length], ["Rejected approaches", note.rejectedApproaches.length], ["Open findings", note.openFindings.length], ["Checks", note.verification.length]].map(([what, value]) => ({ what: String(what), count: String(value) })),
+        more: 0,
+        notes: handoverLines(note).map(one => clean(one, CARD_LIMITS.note)).filter(one => one !== ""),
+        facts: [{ id: "revision", label: "Revision", value: note.revision === null ? "none yet" : clean(note.revision.head.slice(0, 12)) }, { id: "next", label: "Next", value: clean(note.nextAction) }],
+        points: [],
+    };
+}
+const READERS = { tasks, results, flows, flow_zones: flowZones, spend, projects, builders, mode, integrations, providers, findings, handover };
+/** One source, read now as this person. */
+export function readCardSource(reader, name, query) {
+    if (query.repo !== null && !reader.who.repos.includes(query.repo))
+        return { problem: "That project is outside your access." };
+    return READERS[name](reader, query);
+}