toolroll 0.9.15 → 0.9.17

package/dist/chat-voice.d.ts

@@ -1,8 +1,3 @@
-/** How chat sounds: a teammate talking. One or two short sentences, outcome
- * first, plain words, one action at most. Every chat (Telegram, Slack,
- * Discord, Teams) takes its titles and its finished-work lines from here, so a
- * task id, a "— revision" suffix or a person's own act never reaches a chat.
- * The console keeps every exact name and fact. */
 import type { TelegramTransport } from "./telegram.js";
 import type { Store } from "./store.js";
 /** The bot's display name in every chat app. */
@@ -34,8 +29,10 @@ export type FinishedFact = {
         words: string;
         phrase: string;
     } | null;
-    /** The person's lead took it on (lead-voice.ts): "Your lead is on it", never "It waits for you". */
+    /** The person's lead took it on (lead-voice.ts): "<name> is on it", never "It waits for you". */
     leadOnIt?: boolean;
+    /** What the person calls their lead (Settings → Lead); "Lead" when unnamed. */
+    leadName?: string;
 };
 /** The two buttons under a result ready for a person: the real next step, then a look first. */
 export declare const READY_ACTIONS: {

package/dist/chat-voice.js

@@ -1,3 +1,9 @@
+/** How chat sounds: a teammate talking. One or two short sentences, outcome
+ * first, plain words, one action at most. Every chat (Telegram, Slack,
+ * Discord, Teams) takes its titles and its finished-work lines from here, so a
+ * task id, a "— revision" suffix or a person's own act never reaches a chat.
+ * The console keeps every exact name and fact. */
+import { leadOnIt } from "./task-status.js";
 import { phoneText } from "./telegram-status.js";
 /** The bot's display name in every chat app. */
 export const BOT_NAME = "Toolroll";
@@ -55,7 +61,7 @@ export function finishedLine(fact) {
     const ready = fact.lead === true ? `I finished ${lower}` : `${name} is ready`;
     // What waited on the person and the lead has taken on (Needs you reads Waiting then).
     if (fact.leadOnIt === true && (fact.headline === "Needs you" || fact.headline === "Waiting" || fact.headline === "Stopped"))
-        return `${name}: your lead is on it.`;
+        return `${name}: ${leadOnIt(fact.leadName)}`;
     switch (fact.headline) {
         case "Ready for review":
             if (fact.report)
@@ -67,7 +73,7 @@ export function finishedLine(fact) {
             return `${ready}, but no tests ran. Look it over first.`;
         case "Failed":
             if (fact.leadOnIt === true)
-                return fact.checks === "failed" ? `${name} is built, but its tests failed. Your lead is on it.` : `${name} stopped before it finished. Your lead is on it.`;
+                return fact.checks === "failed" ? `${name} is built, but its tests failed. ${leadOnIt(fact.leadName)}` : `${name} stopped before it finished. ${leadOnIt(fact.leadName)}`;
             if (fact.checks === "failed")
                 return fact.lead === true
                     ? `I built ${lower}, but its tests failed. It waits for you: retry or ask for changes.`

package/dist/chat-warmth.d.ts

@@ -0,0 +1,21 @@
+/** Small warm touches while the lead works on a chat app: once a turn will take more than a few seconds (its first tool
+ * step starts), a 👍 on the owner's message and the app's typing indicator until the turn ends. Best effort only: an
+ * app or permission that does not allow it is skipped silently, and nothing here can fail, delay or change the turn. */
+import type { MateProgress } from "./mate-progress.js";
+export declare const WARM_EMOJI = "\uD83D\uDC4D";
+/** Telegram and Teams show typing for about five seconds, Discord for ten: refreshed inside the shorter window. */
+export declare const TYPING_REFRESH_MS = 4000;
+export type WarmHooks = {
+    /** React to the owner's own message. Absent: the app (or this bot's permission) has no reactions. */
+    react?: () => Promise<unknown>;
+    /** Show the app's typing indicator once. Absent: the app has none for bots. */
+    typing?: () => Promise<unknown>;
+};
+export type WarmTurn = {
+    onProgress: (event: MateProgress) => void;
+    stop: () => void;
+};
+/** The turn's progress listener: on the first tool step, react once and keep typing shown until `stop`. */
+export declare function warmTurn(hooks: WarmHooks, options?: {
+    refreshMs?: number;
+}): WarmTurn;

package/dist/chat-warmth.js

@@ -0,0 +1,36 @@
+export const WARM_EMOJI = "👍";
+/** Telegram and Teams show typing for about five seconds, Discord for ten: refreshed inside the shorter window. */
+export const TYPING_REFRESH_MS = 4_000;
+/** The turn's progress listener: on the first tool step, react once and keep typing shown until `stop`. */
+export function warmTurn(hooks, options = {}) {
+    let started = false;
+    let stopped = false;
+    let timer = null;
+    const quietly = (call) => {
+        if (call === undefined || stopped)
+            return;
+        try {
+            void call().catch(() => undefined);
+        }
+        catch { /* skipped silently */ }
+    };
+    return {
+        onProgress: event => {
+            if (stopped || event.kind !== "tool" || started)
+                return;
+            started = true;
+            quietly(hooks.react);
+            quietly(hooks.typing);
+            if (hooks.typing !== undefined) {
+                timer = setInterval(() => quietly(hooks.typing), options.refreshMs ?? TYPING_REFRESH_MS);
+                timer.unref?.();
+            }
+        },
+        stop: () => {
+            stopped = true;
+            if (timer !== null)
+                clearInterval(timer);
+            timer = null;
+        },
+    };
+}

package/dist/discord-api.d.ts

@@ -5,7 +5,7 @@ export declare const discordId: (v: unknown) => v is string;
 export type DiscordCredentials = ChatIdentity & {
     botToken: string;
 };
-export type DiscordApi = (method: "GET" | "POST" | "PATCH", path: string, body?: Record<string, unknown>, file?: {
+export type DiscordApi = (method: "GET" | "POST" | "PATCH" | "PUT", path: string, body?: Record<string, unknown>, file?: {
     bytes: Uint8Array;
     name: string;
 }) => Promise<Record<string, unknown>>;

package/dist/discord-api.js

@@ -11,7 +11,7 @@ export class DiscordError extends ChatDeliveryError {
 export function discordApi(token, fetcher = fetch) {
     return async (method, path, body, file) => {
         // Only relative API routes; never send the bot credential to supplied URLs.
-        if (!/^\/(?:users\/@me|users\/[0-9]+|oauth2\/applications\/@me|channels\/[0-9]+(?:\/messages(?:\/[0-9]+)?(?:\?limit=100)?)?|interactions\/[0-9]+\/[A-Za-z0-9._-]+\/callback)$/.test(path))
+        if (!/^\/(?:users\/@me|users\/[0-9]+|oauth2\/applications\/@me|channels\/[0-9]+(?:\/typing|\/messages\/[0-9]+\/reactions\/%F0%9F%91%8D\/@me|\/messages(?:\/[0-9]+)?(?:\?limit=100)?)?|interactions\/[0-9]+\/[A-Za-z0-9._-]+\/callback)$/.test(path))
             throw new DiscordError("Invalid Discord request");
         let response;
         const headers = { Authorization: `Bot ${token}` };

package/dist/discord-chat.d.ts

@@ -1,5 +1,6 @@
 import { ChatState, type ChatIdentity } from "./chat-delivery-state.js";
 import { type ChatDeliveryOptions } from "./chat-delivery.js";
+import { discordPlain } from "./reply-shape.js";
 import { type DiscordApi } from "./discord-api.js";
 export type DiscordChatOptions = Omit<ChatDeliveryOptions, "state" | "label" | "member" | "partSize" | "maxProposal"> & {
     api: DiscordApi;
@@ -11,6 +12,6 @@ export declare const planDiscordNotifications: (options: DiscordChatOptions) =>
 /** Save only normalized input. Interaction credentials and pairing codes never enter SQLite. */
 export declare function receiveDiscord(state: ChatState, identity: ChatIdentity, type: string, raw: unknown, now: Date): boolean;
 /** Escape Discord's presentation syntax; allowed_mentions also prevents actual pings. */
-export declare const discordPlain: (text: string) => string;
-export declare function discordCard(text: string, buttons?: Record<string, unknown>[]): Record<string, unknown>;
+export { discordPlain };
+export declare function discordCard(text: string, buttons?: Record<string, unknown>[], voice?: boolean): Record<string, unknown>;
 export declare function deliverDiscordPart(options: DiscordChatOptions): Promise<boolean>;

package/dist/discord-chat.js

@@ -1,5 +1,6 @@
 /** Discord messages and buttons transport the shared assistant's saved actions. */
 import { chatQuestionButtons } from "./teammate-question.js";
+import { chatAskButtons } from "./chat-ask.js";
 import { chatFlowButtons } from "./chat-flow.js";
 import { channelInbox } from "./chat-inbox.js";
 import { roomCommand } from "./chat-rooms.js";
@@ -7,6 +8,8 @@ import { ChatState, ChatDeliveryError, chatHash, } from "./chat-delivery-state.j
 import { processChatEvent, planChatNotifications, channelAccess, chatObject as object, planRoomMessages, } from "./chat-delivery.js";
 import { chatResultHref } from "./chat-controls.js";
 import { MATE_MESSAGE_MAX_CHARS } from "./mate.js";
+import { discordPlain, renderReply } from "./reply-shape.js";
+import { WARM_EMOJI } from "./chat-warmth.js";
 import { proposalPreview, proposalLink, proposalOutcomeText, armedCardText, armedYesLabel, } from "./chat-channel.js";
 import { resultImageFileName, safeResultImageCaption, verifyResultImage, } from "./chat-evidence.js";
 import { discordId, discordMember, DiscordError, } from "./discord-api.js";
@@ -15,6 +18,11 @@ export const discordDelivery = (options) => ({
     state: new ChatState(options.store, "discord"),
     label: "Discord",
     member: (member, channel) => discordMember(options.api, member, channel),
+    // A 👍 on the owner's message and "typing…" while the lead works; a missing permission is skipped silently.
+    warm: (event) => ({
+        react: () => options.api("PUT", `/channels/${event.channel}/messages/${event.ts}/reactions/${encodeURIComponent(WARM_EMOJI)}/@me`),
+        typing: () => options.api("POST", `/channels/${event.channel}/typing`),
+    }),
     partSize: 1800,
     maxProposal: 3400,
 });
@@ -139,8 +147,16 @@ function link(origin, target) {
     }
 }
 /** Escape Discord's presentation syntax; allowed_mentions also prevents actual pings. */
-export const discordPlain = (text) => text.replace(/([\\`*_~|>#\[\]])/g, "\\$1").replace(/@/g, "@\u200b");
-export function discordCard(text, buttons = []) {
+export { discordPlain };
+export function discordCard(text, buttons = [], voice = false) {
+    // The lead's own reply: one description in Discord's Markdown (bold anchors, labelled links), no title line promoted to a header.
+    if (voice)
+        return {
+            content: "",
+            embeds: [{ description: renderReply(text, "discord").slice(0, 4096), color: 0x297b70 }],
+            components: Array.from({ length: Math.min(5, Math.ceil(buttons.length / 5)) }, (_, row) => ({ type: 1, components: buttons.slice(row * 5, row * 5 + 5) })),
+            allowed_mentions: { parse: [], replied_user: false },
+        };
     const lines = text.split("\n"), first = lines[0] ?? "Toolroll", title = discordPlain(first).length <= 256 &&
         first.length <= 150 &&
         lines.length > 1
@@ -272,6 +288,15 @@ export async function deliverDiscordPart(options) {
                         custom_id: `so_${one.token}`,
                     }))
                     : []),
+                // The lead's question to its owner: its options, then "Something else".
+                ...(content.ask
+                    ? chatAskButtons(state, row.id, now).map((one) => ({
+                        type: 2,
+                        style: one.words ? 2 : 1,
+                        label: one.label.slice(0, 80),
+                        custom_id: `so_${one.token}`,
+                    }))
+                    : []),
                 ...link(options.origin(), content.link),
                 ...(content.also ?? []).flatMap(one => link(options.origin(), one)),
             ];
@@ -326,7 +351,7 @@ export async function deliverDiscordPart(options) {
                 throw new DiscordError("Screenshot evidence changed before upload");
             file.bytes = fresh.bytes;
         }
-        const args = discordCard(text, buttons);
+        const args = discordCard(text, buttons, content.voice === true && !content.proposal && !content.image);
         if (file)
             args.attachments = [
                 { id: 0, filename: file.name, description: text.slice(0, 1024) },

package/dist/lead-about.d.ts

@@ -0,0 +1,35 @@
+/** What your lead knows about you (Settings → Lead): a short list of the owner's own lasting preferences, the same
+ * across projects ("keep copy terse", "I test myself"). Stored beside the lead's name and persona; only lines the
+ * owner confirmed (a remember about-you card) or wrote themselves are kept, never a guess. */
+import type { Store } from "./store.js";
+export declare const ABOUT_YOU_MAX_LINES = 20;
+/** Each line is under 200 characters. */
+export declare const ABOUT_YOU_LINE_MAX = 199;
+/** This person's confirmed lines; an older store reads as none. */
+export declare function aboutYouOf(store: Store, account: string | null | undefined): string[];
+/** One line as it is saved, or the problem with it. */
+export declare function checkAboutYouLine(value: unknown): {
+    ok: true;
+    line: string;
+} | {
+    ok: false;
+    message: string;
+};
+/** The Settings form's text, one line each: the saved list, or the problem with it. Blank lines and repeats go. */
+export declare function checkAboutYou(text: string): {
+    ok: true;
+    lines: string[];
+} | {
+    ok: false;
+    message: string;
+};
+/** Save the whole list for this person (already checked). Their lead's name and persona are left as they are. */
+export declare function saveAboutYou(store: Store, account: string, lines: readonly string[], now: Date): void;
+/** The list once a confirmed line is added, or once it replaces line `replaces` (1-based). */
+export declare function withAboutYouLine(lines: readonly string[], line: string, replaces: number): {
+    ok: true;
+    lines: string[];
+} | {
+    ok: false;
+    message: string;
+};

package/dist/lead-about.js

@@ -0,0 +1,62 @@
+import { scanForSecrets } from "./evidence.js";
+export const ABOUT_YOU_MAX_LINES = 20;
+/** Each line is under 200 characters. */
+export const ABOUT_YOU_LINE_MAX = 199;
+/** This person's confirmed lines; an older store reads as none. */
+export function aboutYouOf(store, account) {
+    if (account == null || account === "")
+        return [];
+    try {
+        return store.leadAbout(account);
+    }
+    catch {
+        return [];
+    }
+}
+/** One line as it is saved, or the problem with it. */
+export function checkAboutYouLine(value) {
+    const line = typeof value === "string" ? value.replace(/^\s*[-*•]\s*/, "").replace(/\s+/g, " ").trim() : "";
+    if (line.length < 2)
+        return { ok: false, message: "Say it in a few words." };
+    if (line.length > ABOUT_YOU_LINE_MAX)
+        return { ok: false, message: `Keep each line under ${ABOUT_YOU_LINE_MAX + 1} characters.` };
+    if (/[\u0000-\u001f\u007f​-‏‪-‮⁦-⁩�]/.test(line) || scanForSecrets(line).length > 0)
+        return { ok: false, message: "Use plain words, with no passwords or keys." };
+    return { ok: true, line };
+}
+/** The Settings form's text, one line each: the saved list, or the problem with it. Blank lines and repeats go. */
+export function checkAboutYou(text) {
+    const lines = [];
+    // A problem names the line as the person sees it in the box, blank lines and repeats counted.
+    for (const [index, raw] of text.replace(/\r\n?/g, "\n").split("\n").entries()) {
+        if (raw.trim() === "")
+            continue;
+        const checked = checkAboutYouLine(raw);
+        if (!checked.ok)
+            return { ok: false, message: `Line ${index + 1}: ${checked.message}` };
+        if (!lines.some(one => one.toLowerCase() === checked.line.toLowerCase()))
+            lines.push(checked.line);
+    }
+    if (lines.length > ABOUT_YOU_MAX_LINES)
+        return { ok: false, message: `Keep it to ${ABOUT_YOU_MAX_LINES} lines.` };
+    return { ok: true, lines };
+}
+/** Save the whole list for this person (already checked). Their lead's name and persona are left as they are. */
+export function saveAboutYou(store, account, lines, now) {
+    store.setLeadAbout(account, lines, now);
+}
+/** The list once a confirmed line is added, or once it replaces line `replaces` (1-based). */
+export function withAboutYouLine(lines, line, replaces) {
+    if (replaces > 0) {
+        if (replaces > lines.length)
+            return { ok: false, message: "That line is no longer in what your lead knows about you." };
+        const next = [...lines];
+        next[replaces - 1] = line;
+        return { ok: true, lines: next.filter((one, index) => index === replaces - 1 || one.toLowerCase() !== line.toLowerCase()) };
+    }
+    if (lines.some(one => one.toLowerCase() === line.toLowerCase()))
+        return { ok: false, message: "Your lead already knows this." };
+    if (lines.length >= ABOUT_YOU_MAX_LINES)
+        return { ok: false, message: `What your lead knows about you is full (${ABOUT_YOU_MAX_LINES} lines). Replace a line, or tidy it in Settings → Lead.` };
+    return { ok: true, lines: [...lines, line] };
+}

package/dist/lead-capabilities.d.ts

@@ -0,0 +1,64 @@
+/**
+ * What the lead can rely on right now, in one read (get_capabilities): the agents a project's route would run, the
+ * workers that would run them, the project's tools and skills, the integrations, and the project's checks. Every entry
+ * says what it lets the lead do and, when it can't, the one next step and the settings control (show_control) that
+ * takes the owner there. Everything here reads what is already recorded — runner readiness reports, sign-in pauses,
+ * plan-limit readings, tool tests, skill tests, integration checks — and never probes anything that spends.
+ */
+import type { Store } from "./store.js";
+import type { ChatControl } from "./chat-controls.js";
+import type { ProviderId } from "./provider.js";
+import { type AuthMode } from "./keys.js";
+import { type Integration } from "./integrations.js";
+/** One thing the lead may depend on: its state in a few words, what it lets the lead do, and when it can't, the next step. */
+export type Capability = {
+    name: string;
+    state: string;
+    ok: boolean;
+    lets: string;
+    next: string | null;
+    link: ChatControl | null;
+};
+export type ProjectCapabilities = {
+    repo: string;
+    agents: (Capability & {
+        provider: string;
+        model: string;
+        roles: string[];
+    })[];
+    agentsProblem: Capability | null;
+    tools: Capability[];
+    skills: Capability[];
+    checks: Capability & {
+        level: string;
+        quickCheck: boolean;
+        releaseCheck: boolean;
+    };
+};
+export type Capabilities = {
+    projects: ProjectCapabilities[];
+    workers: (Capability & {
+        online: boolean;
+        capacity: number;
+        running: string[];
+    })[];
+    integrations: (Capability & {
+        kind: string;
+        account: string | null;
+        usedBy: string[];
+        lastError: string | null;
+    })[];
+};
+/** The integrations exactly as get_integrations reads them, with what each lets the lead do and the next step. */
+export declare function integrationCapabilities(list: readonly Integration[]): Capabilities["integrations"];
+/** Every capability, for one project or every admitted one. Read-only and spends nothing. */
+export declare function capabilitiesOf(store: Store, input: {
+    repos: readonly string[];
+    admitted: readonly string[];
+    actor: string;
+    integrations: readonly Integration[];
+    authMode?: (provider: ProviderId) => AuthMode;
+    now: Date;
+}): Capabilities;
+export declare function needsCapabilities(name: string, args: Record<string, unknown>, channel: string | undefined): boolean;
+export declare const CAPABILITIES_UNREAD = "This depends on an agent, a worker or an integration. Read get_capabilities first, then propose or promise in a later step; if something it needs can't work, say so plainly with its next step and show_control link instead.";

package/dist/lead-capabilities.js

@@ -0,0 +1,199 @@
+import { resolveRouteCandidates } from "./agentconfig.js";
+import { authPauseOf, messageCommand, providerName } from "./provider-auth.js";
+import { readAuthMode, SUBSCRIPTION_CAPABLE } from "./keys.js";
+import { DEFAULT_LIVENESS_MS } from "./runner.js";
+import { projectToolsOf, secretsSetFor, toolStanding } from "./project-tools.js";
+import { conversationSkills } from "./project-skills.js";
+import { CHECK_LEVEL_WORDS, liveQuickCommand, projectCheckLevel } from "./check-levels.js";
+import { STATE_WORDS } from "./integrations.js";
+const ROLE_WORDS = { plan: "plan", build: "build", repair: "fix failed checks", review: "review" };
+const MAX_LISTED = 12;
+/** The exact provider and model pairs a project's route would use, with the roles each would play. */
+function routePairs(store, repo) {
+    const pairs = new Map();
+    const resolved = resolveRouteCandidates(store, repo);
+    if (!resolved.ok)
+        return { pairs, problem: resolved.problem };
+    const add = (phase, candidate) => {
+        if (candidate === null)
+            return;
+        const key = `${candidate.provider} ${candidate.model}`;
+        const pair = pairs.get(key) ?? { provider: candidate.provider, model: candidate.model, roles: [] };
+        if (!pair.roles.includes(ROLE_WORDS[phase]))
+            pair.roles.push(ROLE_WORDS[phase]);
+        pairs.set(key, pair);
+    };
+    for (const phase of ["plan", "build", "repair", "review"]) {
+        const leg = resolved.candidates[phase];
+        add(phase, leg.routine ?? (phase === "repair" ? resolved.candidates.build.routine : null));
+        add(phase, leg.strong);
+    }
+    return { pairs, problem: null };
+}
+/** A provider's plan or quota running out, from the last readings (provider_limit and the runners' quota rows). */
+function outOfBudget(store, provider, now) {
+    const stamp = now.toISOString();
+    const window = store.providerLimits().find(one => one.provider === provider && one.reached && (one.resetsAt === null || one.resetsAt > stamp));
+    if (window !== undefined)
+        return { until: window.resetsAt };
+    const quota = store.handle.prepare("SELECT reset_at FROM quota WHERE provider = ? AND state = 'exhausted' AND (reset_at IS NULL OR reset_at > ?) ORDER BY reset_at DESC LIMIT 1").get(provider, stamp);
+    return quota === undefined ? null : { until: quota["reset_at"] == null ? null : String(quota["reset_at"]) };
+}
+function agentsOf(store, repo, now, authMode) {
+    const { pairs, problem } = routePairs(store, repo);
+    if (problem !== null) {
+        return { agents: [], agentsProblem: { name: "Agents", state: "Not set up", ok: false, lets: "plan and build this project's tasks", next: `Choose an exact model for each role: ${problem}`, link: "providers" } };
+    }
+    const readiness = store.readinessLookupFor(repo, null, now);
+    const agents = [...pairs.values()].map(pair => {
+        const name = `${providerName(pair.provider)} · ${pair.model}`;
+        const lets = `${pair.roles.join(", ")} this project's tasks`;
+        const base = { provider: pair.provider, model: pair.model, roles: pair.roles, name, lets };
+        // Signed out only on a real sign-in failure: a sign-in pause from a run, the worker's login check saying not logged
+        // in, or the key a key-only provider needs missing. A provider on an API key gets the key step, never the sign-in.
+        const pause = authPauseOf(store, pair.provider);
+        const mode = pause?.authMode ?? (SUBSCRIPTION_CAPABLE[pair.provider] ? authMode(pair.provider) : "api-key");
+        const key = mode === "api-key";
+        const outWords = key ? "Needs a working API key" : "Signed out";
+        const outNext = (detail) => key ? `Save a working API key: run \`${messageCommand({ provider: pair.provider, authMode: "api-key" })}\` on this computer${detail}.` : `Sign in: run \`${messageCommand({ provider: pair.provider, authMode: "subscription" })}\` on this computer${detail}.`;
+        if (pause !== null)
+            return { ...base, state: outWords, ok: false, next: outNext("; its tasks start again on their own"), link: "providers" };
+        const seen = readiness(pair.provider);
+        const authFailed = seen?.state === "unavailable" && (seen.probe === "key" || (seen.probe === "identity" && !key));
+        if (authFailed)
+            return { ...base, state: outWords, ok: false, next: outNext(""), link: "providers" };
+        if (seen?.state === "unavailable" && seen.probe !== "identity") {
+            return { ...base, state: `Not available: ${seen.reason}`, ok: false, next: `Fix it on the worker: ${seen.reason}.`, link: "providers" };
+        }
+        const spent = outOfBudget(store, pair.provider, now);
+        if (spent !== null)
+            return { ...base, state: "Out of plan budget", ok: false, next: spent.until === null ? "Wait for the plan to reset, or choose another agent." : `Wait until ${spent.until}, when the plan resets, or choose another agent.`, link: "providers" };
+        if (seen === null)
+            return { ...base, state: "Not checked yet", ok: false, next: "No worker has reported this agent yet: start a worker for this project.", link: "workers" };
+        // On an API key, only a key check speaks for it: a CLI login check (passed or not) says nothing about the key.
+        if (seen.state !== "ready" || (key && seen.probe !== "key")) {
+            return { ...base, state: "Not checked yet", ok: false, next: key ? "Its API key has not been checked without spending; the first task shows whether it works." : "A worker could not check it without spending; the first task shows whether it works.", link: "providers" };
+        }
+        return { ...base, state: key ? "API key set" : "Signed in", ok: true, next: null, link: null };
+    });
+    return { agents, agentsProblem: null };
+}
+function toolsOf(store, repo) {
+    return projectToolsOf(store, repo).slice(0, MAX_LISTED).map(tool => {
+        let set = [];
+        try {
+            set = secretsSetFor(repo, tool.spec);
+        }
+        catch {
+            set = [];
+        }
+        const standing = toolStanding(tool, set);
+        const state = standing.words;
+        const lets = `builds in this project can use ${tool.name}${tool.spec.about ? ` (${tool.spec.about})` : ""}`;
+        if (state.startsWith("Needs"))
+            return { name: tool.name, state, ok: false, lets, next: `Add ${state.slice("Needs ".length)} on the Tools page; never in chat.`, link: "tools" };
+        if (state === "Last test failed")
+            return { name: tool.name, state, ok: false, lets, next: `Fix it and test it again on the Tools page${tool.lastTest?.problem ? `: ${tool.lastTest.problem}` : ""}.`, link: "tools" };
+        if (state === "Not tested yet")
+            return { name: tool.name, state, ok: true, lets, next: "Test it on the Tools page to be sure it works.", link: "tools" };
+        return { name: tool.name, state: "Working", ok: true, lets, next: null, link: null };
+    });
+}
+/** The newest test of one skill version in a project: passed, failed or still running; null when never tested. */
+function lastSkillTest(store, repo, sha) {
+    const row = store.handle.prepare("SELECT skill_test.task_ref AS ref FROM skill_test JOIN task_ref ON task_ref.id = skill_test.task_ref WHERE task_ref.repo = ? AND skill_test.package = ? ORDER BY skill_test.task_ref DESC LIMIT 1").get(repo, sha);
+    if (row === undefined)
+        return null;
+    const run = store.runsFor(Number(row["ref"]))[0];
+    if (run === undefined || run.outcome === null)
+        return "running";
+    return run.outcome === "built" || run.outcome === "no-change" ? "passed" : "failed";
+}
+function skillsOf(store, repo, actor) {
+    let skills;
+    try {
+        skills = conversationSkills(store, repo, actor).skills;
+    }
+    catch {
+        return [];
+    }
+    return skills.filter(one => one.enabled).slice(0, MAX_LISTED).map(skill => {
+        const lets = `builds in this project are given the ${skill.name} skill${skill.description ? ` (${skill.description.slice(0, 120)})` : ""}`;
+        const test = lastSkillTest(store, repo, skill.sha);
+        if (test === "failed")
+            return { name: skill.name, state: "Last test failed", ok: false, lets, next: "Read it with get_skills, then fix and test it again on the Skills page.", link: "skills" };
+        const needs = skill.requirements.trim();
+        if (needs !== "" && test !== "passed")
+            return { name: skill.name, state: `Needs ${needs.slice(0, 120)}`, ok: false, lets, next: "Make sure what it needs is set up, then test it on the Skills page.", link: "skills" };
+        return { name: skill.name, state: test === "running" ? "Working · test running" : "Working", ok: true, lets, next: null, link: null };
+    });
+}
+function checksOf(store, repo) {
+    const level = projectCheckLevel(store, repo).level;
+    const releaseCheck = store.liveVerifyCommand(repo) !== null, quickCheck = liveQuickCommand(store, repo) !== null;
+    const base = { name: "Checks", level: CHECK_LEVEL_WORDS[level], quickCheck, releaseCheck, lets: "say whether a result's checks passed before you call it done" };
+    if (level === "off")
+        return { ...base, state: "Off", ok: false, next: "Builds are not checked. Turn checks on for the project if results need them.", link: "projects" };
+    if (!releaseCheck)
+        return { ...base, state: `${CHECK_LEVEL_WORDS[level]} · no release check`, ok: false, next: "No release check is set up, so no result can show a passing check. Set one for the project.", link: "projects" };
+    return { ...base, state: level === "quick" && !quickCheck ? "Quick · runs the release check" : `${CHECK_LEVEL_WORDS[level]} · release check set`, ok: true, next: null, link: null };
+}
+function workersOf(store, repos, now) {
+    const live = store.handle.prepare(`SELECT ref.external_id AS task, ref.repo AS repo FROM claim JOIN task_ref AS ref ON ref.id = claim.task_ref
+    WHERE claim.runner = ? AND claim.released_at IS NULL AND claim.expires_at > ?
+      AND claim.lease_generation = (SELECT MAX(newest.lease_generation) FROM claim AS newest WHERE newest.task_ref = claim.task_ref)`);
+    const workers = store.listRunners()
+        .filter(one => one.retiredAt === null && one.repos.some(repo => repos.includes(repo)))
+        .slice(0, MAX_LISTED)
+        .map(runner => {
+        const online = now.getTime() - Date.parse(runner.heartbeatAt) <= DEFAULT_LIVENESS_MS;
+        const held = live.all(runner.name, now.toISOString());
+        const running = held.filter(row => repos.includes(String(row["repo"]))).map(row => String(row["task"]));
+        const busy = store.liveClaimCount(runner.name, now);
+        const lets = `run tasks for ${runner.repos.filter(repo => repos.includes(repo)).length} of your projects, ${runner.capacity} at a time`;
+        if (!online)
+            return { name: runner.name, state: `Offline since ${runner.heartbeatAt}`, ok: false, online, capacity: runner.capacity, running, lets,
+                next: `Start that computer, or reinstall its background worker there: \`toolroll daemon install --runner ${runner.name}\`.`, link: "workers" };
+        const full = busy >= runner.capacity;
+        return { name: runner.name, state: full ? `Online · full (${busy} of ${runner.capacity})` : `Online · ${busy} of ${runner.capacity} busy`, ok: true, online, capacity: runner.capacity, running, lets,
+            next: full ? "New work waits for a free slot; raise its capacity on the Workers page if it should run more at once." : null, link: full ? "workers" : null };
+    });
+    if (workers.length === 0) {
+        return [{ name: "No worker", state: "None for your projects", ok: false, online: false, capacity: 0, running: [], lets: "run any task",
+                next: "Add a worker for the project: run `toolroll daemon install` on the computer that should do the work.", link: "workers" }];
+    }
+    return workers;
+}
+const INTEGRATION_LINK = { slack: "slack", discord: "discord" };
+/** The integrations exactly as get_integrations reads them, with what each lets the lead do and the next step. */
+export function integrationCapabilities(list) {
+    return list.map(one => {
+        const link = one.group === "agents" ? "providers" : one.group === "tools" ? "tools" : INTEGRATION_LINK[one.key.replace(/^.*:/, "").toLowerCase()] ?? INTEGRATION_LINK[one.name.toLowerCase()] ?? "integrations";
+        const lets = one.usedBy.length > 0 ? `use ${one.name} for ${one.usedBy.join(", ")}` : `use ${one.name}`;
+        const next = one.action.kind === "setup" ? `Not set up: set up ${one.name} in Settings` : one.action.kind === "fix" ? `Fix: ${one.action.words}` : null;
+        return { name: one.name, kind: one.group, state: STATE_WORDS[one.state], ok: one.state === "connected", account: one.account, usedBy: one.usedBy, lastError: one.lastError, lets, next, link: next === null ? null : link };
+    });
+}
+/** Every capability, for one project or every admitted one. Read-only and spends nothing. */
+export function capabilitiesOf(store, input) {
+    const authMode = input.authMode ?? (provider => readAuthMode(provider));
+    return {
+        projects: input.repos.map(repo => ({ repo, ...agentsOf(store, repo, input.now, authMode), tools: toolsOf(store, repo), skills: skillsOf(store, repo, input.actor), checks: checksOf(store, repo) })),
+        workers: workersOf(store, input.admitted, input.now),
+        integrations: integrationCapabilities(input.integrations),
+    };
+}
+/** Whether a call depends on an agent, a worker or an integration, and so needs get_capabilities read first this turn:
+ * a task always does (a worker runs it with an agent); a flow change that sets up or starts work does; a promise to
+ * report on a task, attempt or check does (crew work must run), and a timed one does when it is reported on a chat app. */
+const FLOW_WORK = new Set(["create", "edit", "kit", "starter", "add_trigger", "resume_trigger", "add_card"]);
+export function needsCapabilities(name, args, channel) {
+    if (name === "propose_task")
+        return true;
+    if (name === "propose_flow")
+        return FLOW_WORK.has(String(args["operation"]));
+    if (name === "commit_to")
+        return args["when"] === "time" ? channel !== undefined && channel !== "chat" : true;
+    return false;
+}
+export const CAPABILITIES_UNREAD = "This depends on an agent, a worker or an integration. Read get_capabilities first, then propose or promise in a later step; if something it needs can't work, say so plainly with its next step and show_control link instead.";