toolroll 0.9.15 → 0.9.16

package/dist/mate-tools.js

@@ -12,8 +12,10 @@ import { taskControlOf } from "./task-control.js";
 import { taskWorkSummaryOf } from "./work-summary.js";
 import { assignmentOf, assignmentBrief } from "./assignment.js";
 import { validateScopeText, validateTaskText, TASK_SCOPE_TEXT_SCHEMA } from "./task-text.js";
-import { conversationKnowledge } from "./project-knowledge.js";
+import { conversationKnowledge, knowledgeView } from "./project-knowledge.js";
+import { cancelCommitment, CHECK_RESULTS, conditionWords, latestResultRun, recordCommitment, RUN_OUTCOMES, TASK_STATES } from "./lead-commitments.js";
 import { searchMemory } from "./project-memory.js";
+import { integrationsNow, STATE_WORDS } from "./integrations.js";
 import { readChatResult, reviewInputProblem } from "./chat-review.js";
 import { RESULT_IMAGES_PER_TURN_CAP, selectResultImages } from "./chat-evidence.js";
 import { CHAT_CONTROLS, isChatControl } from "./chat-controls.js";
@@ -32,6 +34,7 @@ import { CHAT_TASK_ACTIONS, chatTaskRun, chatTaskStamp, isChatTaskAction } from
  * projects after scrubbing; full paths and arbitrary text remain redacted.
  */
 import { Buffer } from "node:buffer";
+import { MATE_ASK_OTHER } from "./store.js";
 import { hasDisguisedText, hasForbiddenControls } from "./decision.js";
 import { readVerifiedArtifact, readVerifiedReport, scanForSecrets } from "./evidence.js";
 import { parseAcceptanceCriteria, ACCEPTANCE_LIMITS, EVIDENCE_KINDS } from "./scope.js";
@@ -104,7 +107,7 @@ export function mateViewContextFor(store, who) {
 }
 /** Project names are deliberate display metadata, not a general basename
  * exemption. Invalid, sensitive or account-identifying labels stay opaque. */
-function projectLabelForMate(path, index, names) {
+export function projectLabelForMate(path, index, names) {
     const base = path.replace(/[\\/]+$/, "").split(/[\\/]/).pop() ?? "";
     const label = redactForMate(base, { repos: [], names });
     return honest(label, 80) && /^[\p{L}\p{N}][\p{L}\p{N} ._()-]*$/u.test(label)
@@ -786,7 +789,7 @@ export const MATE_TOOLS = [
     },
     {
         name: "get_flows",
-        description: "Read the flows in the operator's projects (each a process drawn as zones that cards move through): their steps in order and their cards — where each card is, what it waits on, whether it needs the operator, its task. flow reads one flow in full. Each card has its owner and latest comments; flow with card reads that card's whole discussion.",
+        description: "Read the flows in the operator's projects (each a process drawn as zones that cards move through): their steps in order and their cards — where each card is, what it waits on, whether it needs the operator, its task. flow reads one flow in full. Each card has its owner and latest comments; flow with card reads that card's whole discussion; read it before acting on what teammates said. Zones: Holding, Build and Research (each files an ordinary task), Person decides, Message, Done. Triggers start cards on their own: a button with questions, a schedule, GitHub (new issues, a label being added, new pull requests, failed checks), Linear, another flow's cards reaching a zone, email arriving in the operator's mailbox (optionally only from some senders or with words in the subject; reading mail is set up in Settings → Email), or a plane review (every morning, one card per problem from Toolroll's last 24 hours; a problem that comes back joins its card). A Slack, Discord or Teams channel feeds a flow when a paired approver sends 'flow <the flow's number>' in that channel (never from here); each message there becomes a card, and an 'update' step answers in its thread. Webhook addresses and the Linear key are set on the flow's Triggers panel, never in chat. Two steps run without a model: 'check' runs one of the project's scripts (named scripts in Python, Node or shell that belong to the project, not a flow) with the card as its input; what it prints is passed to later steps, a last line 'goto: <answer>' picks where the card goes, it can run in an empty folder or a copy of the card's work, and it takes the failure path if it fails; a schedule trigger can run a script and make a card of each item it prints. 'update' comments on the GitHub or Linear issue the card came from and can close it, or answers in the chat thread it came from. A Build whose project checks fail takes its failure path too. A 'sort' step has Jev (a fast decision model on the operator's OpenRouter account) read the card and send it where the answer it picks leads, or to its not-sure step, noting scores or yes/no answers too. A 'draft' step has Claude write a reply, summary or note from the card in seconds and sends nothing itself. 'request' calls a web address, 'email' sends mail from the operator's email account (answering the sender of a card that came from email keeps the reply in that thread), 'tool' uses one of the project's tools; their secrets are saved on the canvas or Tools page, never in chat. A 'wait' step after an 'email' step waits for the person to reply (the reply moves the card on and is kept for later steps; with none in time, the card takes its no-reply step), or just waits a set time. A 'pull-request' step opens a pull request for a Build's result and follows its CI (green moves on, red goes back to the build naming the failing check); it merges only when set to, and only after a person approved the card. AI teammates (get_teammates) are agents on the operator's team with a soul file (who they are, how they write, what they know, what they decide on their own, what they ask first, what they never do). They work flow cards within those rules: a teammate named on an approval step decides it (and hands hard ones to that step's person), and a 'teammate' step has one pick where the card goes and write what the next steps send. They never approve code tasks or merges. Each has a memory (what people told it and facts it kept from cards) and a desk (a flow): the operator can message it by name in their chat app ('@maya, …') and its answer goes back to whoever asked; its desk can send a card to a Build zone that files an ordinary task under the usual approvals. get_teammates with a teammate gives its week (what it did, cost, what the operator overrode). For where flows break, read get_flow_insights, and read a failed run's log before explaining it.",
         inputSchema: schema({ repo: REPO_ARG, flow: { type: "integer", minimum: 1 }, card: { type: "integer", minimum: 1 } }),
         handle: (ctx, args) => {
             const reachable = (repo) => ctx.who.repos.includes(repo) && ctx.store.accountCanAccess(ctx.who.name, repo);
@@ -872,7 +875,7 @@ export const MATE_TOOLS = [
     },
     {
         name: "propose_flow",
-        description: "Draft a flow change as a card the operator confirms. starter: switch on a starter flow in a project (repo, starter: ci-fix files a fix task when CI fails on the main branch, issue-task makes a task of each GitHub issue labelled toolroll, overnight holds cards added in the day until 22:00 and leaves results for the morning, plane-review reviews the plane's last 24 hours every morning and turns each problem worth fixing into a researched fix and a pull request) — its zones and trigger in one card; offer the matching one when the operator says to do something every time. kit: set up a starter kit in a project (repo, kit: support-desk, bug-triage, sales-follow-up or ops-requests) — a teammate, the flow it works and its buttons, in one card; prefer it when the operator wants a support desk, bug triage, sales follow-up or requests handled. create: a template, or the steps in order (each leads to the next; Done is added; instructions may be left out). 'request' calls a web address (method, url with its host written out, headers — {{secret.NAME}} uses a secret the operator saved on the step, never in chat — and body); 'email' sends mail (to, subject, body; {{card.email}} is the card's email address); 'tool' calls one of the project's tools (server: the tool's name from get_project_tools, tool: its function, args: an object). Put a decision before any of these when they send what a model wrote or what an outsider sent. A 'draft' step has Claude write something from the card (instructions: what to write); follow it with an approval step (decider 'owner' asks the flow's owner in their chat app, where they can approve, edit or send it back), then an 'update' or 'notify' step whose message is '{{stage.<draft id>}}'. A 'sort' step has Jev pick one of its answers; make it the first step (never a holding step before it, or new cards wait unsorted): question, answers (answer, means: a few words Jev reads, goesTo: a step), sureAt (percent, default 80), ifNotSure (a step; otherwise the card waits for a person), and up to 3 alsoNote (score with levels lowest first, or yes-no); a sort has no next, so give each branch's last step its own next. A 'pull-request' step opens a pull request for the card's built result and waits for CI: next when it passes, ifFails when it fails (only this step defaults it: to the build before it, as a revision carrying the failing check); merge ('squash', 'merge' or 'rebase') merges once checks pass, and needs an approval step before it on every path. waitFor 'hours' with from and until (like '22:00' and '06:00') holds cards until the clock is inside those hours. A 'wait' step, after an 'email' step, waits for a reply to that email from someone it went to (waitFor 'reply', the default): next is where a reply goes (the reply is {{stage.<wait id>}}), ifNoReply where the card goes when none comes within wait (like '3 days', up to 30 days); waitFor 'time' just waits, then next. Any step but wait and done can have remindAfter (like '2 days': whoever it waits on is reminded once; 'none' removes it) and, on holding and approval steps, thenMoveTo (a step the card moves to then). AI teammates (get_teammates): an approval step with teammate (its short name) is decided by that teammate within its rules, and it hands hard ones to the step's decider; a 'teammate' step (teammate, instructions, routes of answer and goesTo) has it read the card, pick where it goes and write what the next steps send (the email body is then {{stage.<id>}}), asking the flow's owner when its rules say to. edit: the full step list, keeping existing steps by id — what a kept step leaves out carries over. add_card (starts in the first zone unless zone is named), move_card, approve, send_back (needs a note), cancel_card, comment (note; @name pings that person), assign (owner: a name, 'me', or 'nobody'), follow, unfollow, save_script (repo, and script: name, about, language python|node|shell, and either body (short) or file (a path in the project, like scripts/enrich.py), and timeoutMinutes; scripts belong to the project, so no flow is needed; a 'check' step in any of its flows names it). A 'check' step runs its script with the card as JSON on stdin (and in $FLOW_INPUT); what it prints is its result for later steps ({{stage.<id>}}); runIn 'folder' (an empty folder: for scripts that work on data) or 'copy' (a copy of the card's work, after setup: for tests on code; the default); routes (answer, goesTo) that a last printed line 'goto: <answer>' picks; ifFails is where a failing script sends the card, such as back to the build (it has no default: without it the card waits there); secrets (names of saved secrets it gets as variables). add_trigger with settings (kind button: label, questions; schedule: schedule like 'daily 09:00 Europe/London', and title, or script (a saved script whose printed items — one per line, a title or JSON with title, description, key — each become a card, once) with secrets; github: repo owner/name, watch issues|pulls|checks, label, branch, from team|anyone; linear: team, state, label; flow: follow (another flow's id), when (its zone); email: folder (default INBOX), sender (addresses or domains), subject (words it must contain); plane-review: at (HH:MM, default 07:30), timeZone — every day it reads the plane's last 24 hours and makes one card per problem worth fixing, a returning problem joining its card); pause_trigger, resume_trigger, remove_trigger with trigger. Read get_flows first except to create.",
+        description: "Draft a flow change as a card the operator confirms. To make a flow, create with a template or the steps in plain names; leave instructions out unless the operator gave them, and use decider 'me' when they decide. To change one, edit with the whole step list, keeping existing steps by id. For cards use add_card, move_card, approve, send_back with the operator's note, or cancel_card; find the card by what it is about; comment (with @name to ping someone), assign and follow here too. For triage, spam, lead, effort or exception routing, start from the matching template, with the sort as the first step. Use remindAfter and thenMoveTo for follow-ups and decisions that stall. The Issues to PRs template runs GitHub issues labelled toolroll through build, approval, pull request and a comment on the issue. When the operator asks for something to happen every time (fix CI when it fails, turn labelled issues into tasks, queue work overnight, review what went wrong every morning), offer the matching starter; each is one yes, and none merges without a person. When someone new wants a support desk, bug triage, sales follow-up or requests handled, a kit sets up the teammate and its flow in one card. Teammates: propose_teammate adds one (from a template: support, sales, ops, triage), changes one rule section (edit_section), pauses, resumes or removes it, passes it a note, or answers its question for the operator; put it to work with a flow here. When the operator says something like 'Maya can approve refunds up to $100 now', change that section of her soul file; when it's for this week or a one-off, pass it as a note. Teammates use the project's tools under a rule per action (do it, ask first: the operator approves each exact call, never, or up to a limit on a number); propose_teammate use_tool, stop_tool and tool_rule change them, and when a rule has a limit also change the soul file so its words agree. forget or edit_memory when the operator says a teammate has something wrong; a rule change it suggests is a question for the operator, answered only as they say. propose_teammate add_routine puts a card on its desk on a schedule; propose_teammate undo undoes a tool call only when its action has an undo set (tool_rule undoWith). Actions: starter: switch on a starter flow in a project (repo, starter: ci-fix files a fix task when CI fails on the main branch, issue-task makes a task of each GitHub issue labelled toolroll, overnight holds cards added in the day until 22:00 and leaves results for the morning, plane-review reviews the plane's last 24 hours every morning and turns each problem worth fixing into a researched fix and a pull request) — its zones and trigger in one card; offer the matching one when the operator says to do something every time. kit: set up a starter kit in a project (repo, kit: support-desk, bug-triage, sales-follow-up or ops-requests) — a teammate, the flow it works and its buttons, in one card; prefer it when the operator wants a support desk, bug triage, sales follow-up or requests handled. create: a template, or the steps in order (each leads to the next; Done is added; instructions may be left out). 'request' calls a web address (method, url with its host written out, headers — {{secret.NAME}} uses a secret the operator saved on the step, never in chat — and body); 'email' sends mail (to, subject, body; {{card.email}} is the card's email address); 'tool' calls one of the project's tools (server: the tool's name from get_project_tools, tool: its function, args: an object). Put a decision before any of these when they send what a model wrote or what an outsider sent. A 'draft' step has Claude write something from the card (instructions: what to write); follow it with an approval step (decider 'owner' asks the flow's owner in their chat app, where they can approve, edit or send it back), then an 'update' or 'notify' step whose message is '{{stage.<draft id>}}'. A 'sort' step has Jev pick one of its answers; make it the first step (never a holding step before it, or new cards wait unsorted): question, answers (answer, means: a few words Jev reads, goesTo: a step), sureAt (percent, default 80), ifNotSure (a step; otherwise the card waits for a person), and up to 3 alsoNote (score with levels lowest first, or yes-no); a sort has no next, so give each branch's last step its own next. A 'pull-request' step opens a pull request for the card's built result and waits for CI: next when it passes, ifFails when it fails (only this step defaults it: to the build before it, as a revision carrying the failing check); merge ('squash', 'merge' or 'rebase') merges once checks pass, and needs an approval step before it on every path. waitFor 'hours' with from and until (like '22:00' and '06:00') holds cards until the clock is inside those hours. A 'wait' step, after an 'email' step, waits for a reply to that email from someone it went to (waitFor 'reply', the default): next is where a reply goes (the reply is {{stage.<wait id>}}), ifNoReply where the card goes when none comes within wait (like '3 days', up to 30 days); waitFor 'time' just waits, then next. Any step but wait and done can have remindAfter (like '2 days': whoever it waits on is reminded once; 'none' removes it) and, on holding and approval steps, thenMoveTo (a step the card moves to then). AI teammates (get_teammates): an approval step with teammate (its short name) is decided by that teammate within its rules, and it hands hard ones to the step's decider; a 'teammate' step (teammate, instructions, routes of answer and goesTo) has it read the card, pick where it goes and write what the next steps send (the email body is then {{stage.<id>}}), asking the flow's owner when its rules say to. edit: the full step list, keeping existing steps by id — what a kept step leaves out carries over. add_card (starts in the first zone unless zone is named), move_card, approve, send_back (needs a note), cancel_card, comment (note; @name pings that person), assign (owner: a name, 'me', or 'nobody'), follow, unfollow, save_script (repo, and script: name, about, language python|node|shell, and either body (short) or file (a path in the project, like scripts/enrich.py), and timeoutMinutes; scripts belong to the project, so no flow is needed; a 'check' step in any of its flows names it). A 'check' step runs its script with the card as JSON on stdin (and in $FLOW_INPUT); what it prints is its result for later steps ({{stage.<id>}}); runIn 'folder' (an empty folder: for scripts that work on data) or 'copy' (a copy of the card's work, after setup: for tests on code; the default); routes (answer, goesTo) that a last printed line 'goto: <answer>' picks; ifFails is where a failing script sends the card, such as back to the build (it has no default: without it the card waits there); secrets (names of saved secrets it gets as variables). add_trigger with settings (kind button: label, questions; schedule: schedule like 'daily 09:00 Europe/London', and title, or script (a saved script whose printed items — one per line, a title or JSON with title, description, key — each become a card, once) with secrets; github: repo owner/name, watch issues|pulls|checks, label, branch, from team|anyone; linear: team, state, label; flow: follow (another flow's id), when (its zone); email: folder (default INBOX), sender (addresses or domains), subject (words it must contain); plane-review: at (HH:MM, default 07:30), timeZone — every day it reads the plane's last 24 hours and makes one card per problem worth fixing, a returning problem joining its card); pause_trigger, resume_trigger, remove_trigger with trigger. Read get_flows first except to create.",
         inputSchema: schema({
             operation: { type: "string", enum: ["create", "edit", "add_card", "move_card", "approve", "send_back", "cancel_card", "comment", "assign", "follow", "unfollow", "save_script", "add_trigger", "pause_trigger", "resume_trigger", "remove_trigger", "kit", "starter"] },
             repo: REPO_ARG, flow: { type: "integer", minimum: 1 }, card: { type: "integer", minimum: 1 }, kit: { type: "string", enum: KITS.map(one => one.id) },
@@ -1279,6 +1282,195 @@ export const MATE_TOOLS = [
             return { ok: true, body: { task: root, title: family?.root.title ?? null, messages, notice: messages.length === limit ? "Only the most recent messages are shown." : null } };
         },
     },
+    {
+        name: "commit_to",
+        description: "Whenever you tell the operator you will follow up ('I'll tell you when the checks pass'), record it here in the same turn. when: task (reaching states), run (an attempt finishing), check (the next checks on a task, or an attempt's checks, passing or failing) or time (an ISO time). You report with one short line on the chat the promise was made on when it is met; promises lapse after 7 days.",
+        inputSchema: schema({ what: { type: "string", minLength: 3, maxLength: 240 }, when: { type: "string", enum: ["task", "run", "check", "time"] }, task: TASK_ARG, run: { type: "integer", minimum: 1 },
+            states: { type: "array", items: { type: "string", enum: [...TASK_STATES] }, minItems: 1, maxItems: 6 }, outcome: { type: "string", enum: [...RUN_OUTCOMES] },
+            result: { type: "string", enum: [...CHECK_RESULTS] }, at: { type: "string" }, checkAfter: { type: "string" } }, ["what", "when"]),
+        handle: (ctx, args) => {
+            if (ctx.thread === undefined)
+                return { ok: false, message: "Promises are kept in a conversation; this one cannot record them." };
+            if (!honest(args["what"], 240))
+                return { ok: false, message: "Say what you promised in one short sentence." };
+            const when = args["when"], taskArg = args["task"], runArg = args["run"];
+            if (args["checkAfter"] !== undefined && (typeof args["checkAfter"] !== "string" || !ISO_STAMP.test(args["checkAfter"])))
+                return { ok: false, message: "checkAfter is an ISO time in UTC." };
+            let condition, repo = null;
+            const taskOf = () => {
+                if (typeof taskArg !== "string")
+                    return null;
+                const ref = admittedRef(ctx, taskArg);
+                if (ref === null)
+                    return null;
+                repo = ref.repo;
+                return ctx.store.taskFamilyOf(taskArg, ctx.who.repos, false)?.root.id ?? taskArg;
+            };
+            const runOf = () => {
+                if (!Number.isSafeInteger(runArg))
+                    return null;
+                const run = ctx.store.getRun(Number(runArg)), ref = run === null ? null : ctx.store.refById(run.taskRef);
+                if (ref === null || ref.repo === null || !ctx.who.repos.includes(ref.repo) || !ctx.store.accountCanAccess(ctx.who.name, ref.repo))
+                    return null;
+                repo = ref.repo;
+                return Number(runArg);
+            };
+            if (when === "task") {
+                const task = taskOf();
+                if (task === null)
+                    return notFound();
+                const states = Array.isArray(args["states"]) && args["states"].length > 0 ? args["states"] : ["ready-to-check", "needs-decision", "complete"];
+                if (!states.every(one => TASK_STATES.includes(one)))
+                    return { ok: false, message: `states are ${TASK_STATES.join(", ")}` };
+                condition = { kind: "task", task, states: [...new Set(states)] };
+            }
+            else if (when === "run") {
+                const run = runOf();
+                if (run === null)
+                    return { ok: false, message: "Choose an attempt (run) of a task in your projects." };
+                condition = { kind: "run", run, outcome: RUN_OUTCOMES.includes(args["outcome"]) ? args["outcome"] : "finished" };
+            }
+            else if (when === "check") {
+                const result = CHECK_RESULTS.includes(args["result"]) ? args["result"] : "either";
+                if (taskArg !== undefined) {
+                    const task = taskOf();
+                    if (task === null)
+                        return notFound();
+                    condition = { kind: "check", task, result, afterRun: latestResultRun(ctx.store, task, ctx.who.repos, ctx.now) };
+                }
+                else {
+                    const run = runOf();
+                    if (run === null)
+                        return { ok: false, message: "Choose a task or an attempt (run) whose checks to wait for." };
+                    condition = { kind: "check", run, result };
+                }
+            }
+            else if (when === "time") {
+                if (typeof args["at"] !== "string" || !ISO_STAMP.test(args["at"]))
+                    return { ok: false, message: "at is an ISO time in UTC." };
+                condition = { kind: "time", at: new Date(args["at"]).toISOString() };
+            }
+            else
+                return { ok: false, message: "when is task, run, check or time." };
+            try {
+                const made = recordCommitment(ctx.store, { owner: ctx.who.name, repo, thread: ctx.thread, turn: ctx.turn ?? null, channel: ctx.channel ?? "chat", what: String(args["what"]), condition,
+                    checkAt: typeof args["checkAfter"] === "string" ? new Date(args["checkAfter"]).toISOString() : null }, ctx.now);
+                return { ok: true, body: { commitment: made.id, condition: conditionWords(ctx.store, made.condition), expires: made.expiresAt, report: ctx.channel === undefined || ctx.channel === "chat" ? "one short line in this conversation when it is met" : `one short line here on ${ctx.channel} when it is met` } };
+            }
+            catch (error) {
+                return { ok: false, message: error instanceof Error ? error.message : "That promise could not be recorded." };
+            }
+        },
+    },
+    {
+        name: "release_commitment",
+        description: "Stop following up on one of your open promises (listed in your catch-up) when a correction or change makes it wrong or unneeded. Say what you changed in your reply.",
+        inputSchema: schema({ commitment: { type: "integer", minimum: 1 }, reason: { type: "string", minLength: 3, maxLength: 240 } }, ["commitment", "reason"]),
+        handle: (ctx, args) => {
+            if (!Number.isSafeInteger(args["commitment"]) || !honest(args["reason"], 240))
+                return { ok: false, message: "Choose an open promise and say why it no longer applies." };
+            return cancelCommitment(ctx.store, ctx.who.name, Number(args["commitment"]), "lead", String(args["reason"]), ctx.now)
+                ? { ok: true, body: { commitment: Number(args["commitment"]), state: "cancelled" } }
+                : { ok: false, message: "That promise is not open." };
+        },
+    },
+    {
+        name: "remember",
+        description: "When the operator corrects you or states a lasting preference ('don't run full checks on this project'), propose it at once as a card: kind decision (a settled choice with its reason) or instruction (added to the project's standing instructions; pass the instructions revision from your catch-up, 0 when it has none). Once confirmed it is in your next turn's catch-up.",
+        inputSchema: schema({ repo: REPO_ARG, kind: { type: "string", enum: ["decision", "instruction"] }, text: { type: "string", minLength: 3, maxLength: 240 }, why: { type: "string", maxLength: 2000 }, source: { type: "string", maxLength: 200 },
+            revision: { type: "integer", minimum: 0 } }, ["repo", "kind", "text"]),
+        handle: (ctx, args) => {
+            const repo = repoPathOf(ctx.who, args["repo"]);
+            if (repo === null)
+                return { ok: false, message: "Choose a project from list_repos." };
+            if (!honest(args["text"], 240))
+                return { ok: false, message: "Say the correction in one sentence." };
+            const text = String(args["text"]).trim();
+            // One card per correction: a card still waiting in this conversation for the same change is the one to confirm.
+            const waiting = ctx.thread === undefined ? [] : ctx.store.listMateProposals(ctx.thread, ["drafting", "pending", "confirming"])
+                .filter(one => one.kind === "action" && one.payload["repo"] === repo);
+            const same = (words) => typeof words === "string" && words.trim().toLowerCase() === text.toLowerCase();
+            let operation, input;
+            if (args["kind"] === "decision") {
+                const twin = waiting.find(one => one.payload["operation"] === "decision_record" && same(one.payload["request"]?.["claim"]));
+                if (twin !== undefined)
+                    return { ok: false, message: `Card ${twin.id} already proposes this decision; it is waiting to be confirmed.` };
+                if (!honest(args["why"], 2000))
+                    return { ok: false, message: "A decision needs its reason (why)." };
+                operation = "decision_record";
+                input = { repo, claim: text, why: String(args["why"]).trim(), ...(typeof args["source"] === "string" && args["source"].trim() ? { source: args["source"].trim() } : {}) };
+            }
+            else if (args["kind"] === "instruction") {
+                const view = knowledgeView(ctx.store, repo, ctx.who.name), current = view.knowledge.instructions.trim();
+                // The card adds a line to the instructions the lead read; once they have changed it would replace someone else's edit.
+                if (!Number.isSafeInteger(args["revision"]))
+                    return { ok: false, message: "Pass the instructions revision from your catch-up (0 when the project has none)." };
+                if (args["revision"] !== view.revision)
+                    return { ok: false, message: `The project's instructions changed since you read them (now revision ${view.revision}). Read them again with get_project_knowledge before proposing.` };
+                const twin = waiting.find(one => one.payload["operation"] === "knowledge_instructions");
+                if (twin !== undefined)
+                    return { ok: false, message: `Card ${twin.id} already changes these instructions and is waiting to be confirmed; confirm or dismiss it first.` };
+                if (current.split("\n").some(line => line.replace(/^[-*]\s*/, "").trim() === text))
+                    return { ok: false, message: "The project's instructions already say this." };
+                const instructions = current === "" ? text : `${current}\n${text}`;
+                if (instructions.length > 4000)
+                    return { ok: false, message: "The project's instructions are full; propose knowledge_instructions with a shorter version." };
+                operation = "knowledge_instructions";
+                input = { repo, instructions };
+            }
+            else
+                return { ok: false, message: "kind is decision or instruction." };
+            let action;
+            try {
+                action = prepareSharedAction(ctx.store, ctx.who, operation, input, ctx.evidenceRoot, ctx.now);
+            }
+            catch (error) {
+                return { ok: false, message: error instanceof Error ? error.message : "That card could not be prepared." };
+            }
+            const id = ctx.draft("action", { ...action });
+            return id === null ? tooMany() : { ok: true, body: { proposal: id, label: action.title, awaiting: "confirmation", executed: false,
+                    next: "Once confirmed it is in your next catch-up. Then re-check the open proposals and promises it affects and say what you changed." } };
+        },
+    },
+    {
+        name: "get_integrations",
+        description: "Read which integrations work now (chat apps such as Telegram, Slack, Discord and Teams; email; GitHub; project tools; monitoring): Connected, Not set up or Broken, with the account, what uses each and the last error. Read before promising work that depends on one. Read-only; show_control integrations opens Settings → Integrations.",
+        inputSchema: schema({}),
+        handle: (ctx) => {
+            const list = ctx.integrations?.() ?? integrationsNow(integrationIoOf(ctx));
+            const integrations = list.map(one => ({
+                name: one.name, kind: one.group, state: STATE_WORDS[one.state], account: one.account, detail: one.detail, usedBy: one.usedBy,
+                lastSuccessAt: one.lastSuccessAt, lastError: one.lastError,
+                next: one.action.kind === "setup" ? "Not set up: open Settings → Integrations to set it up" : one.action.kind === "fix" ? `Fix: ${one.action.words}` : null,
+            }));
+            return { ok: true, body: { integrations, settings: "show_control integrations opens Settings → Integrations; never invent a link" } };
+        },
+    },
+    {
+        name: "ask_owner",
+        description: `Ask the owner one question as tappable buttons: 2-4 short options; "${MATE_ASK_OTHER}" is added. The tapped option comes back as their next message. Only when the answer changes the work; at most once per reply. Then finish with a short reply that leads into it; the question and buttons follow it.`,
+        inputSchema: schema({
+            question: { type: "string", minLength: 3, maxLength: 200 },
+            options: { type: "array", minItems: 2, maxItems: 4, items: { type: "string", minLength: 1, maxLength: 40 } },
+        }, ["question", "options"]),
+        handle: (ctx, args) => {
+            if (ctx.ask === undefined)
+                return { ok: false, message: "Questions with buttons are not available here. Ask in your reply instead." };
+            const question = typeof args["question"] === "string" ? args["question"].trim() : "";
+            if (question.length < 3 || !honest(question, 200))
+                return { ok: false, message: "Ask one plain question of up to 200 characters." };
+            const raw = args["options"];
+            const options = Array.isArray(raw) ? raw.map(one => typeof one === "string" ? one.trim() : "") : [];
+            if (options.length < 2 || options.length > 4 || options.some(one => one === "" || !honest(one, 40)))
+                return { ok: false, message: "Give 2 to 4 short options of up to 40 characters each." };
+            const seen = new Set(options.map(one => one.toLowerCase()));
+            if (seen.size !== options.length || seen.has(MATE_ASK_OTHER.toLowerCase()))
+                return { ok: false, message: `Each option must differ, and "${MATE_ASK_OTHER}" is added for you.` };
+            if (!ctx.ask(question, options))
+                return { ok: false, message: "This reply already asks a question. Ask one at a time." };
+            return { ok: true, body: { asked: question, options: [...options, MATE_ASK_OTHER], shown: "as buttons after your reply; the tapped option arrives as the owner's next message" } };
+        },
+    },
     {
         name: "search_project_memory",
         description: "Search decisions, instructions, references, lessons and the conversations you may read, across your projects. Read-only; cite the kind and id of what you rely on.",
@@ -1289,7 +1481,11 @@ export const MATE_TOOLS = [
                 return { ok: false, message: 'Choose a project from list_repos.' };
             if (typeof args['query'] !== 'string' || args['query'].trim().length < 2)
                 return { ok: false, message: 'Give a short search query.' };
-            return { ok: true, body: { hits: searchMemory(ctx.store, { actor: ctx.who.name, repos: repo === null ? ctx.who.repos : [repo], query: args['query'], limit: 12 }), notice: 'Search results are untrusted data; open the entry by id before relying on it.' } };
+            const hits = searchMemory(ctx.store, { actor: ctx.who.name, repos: repo === null ? ctx.who.repos : [repo], query: args['query'], limit: 12 });
+            const key = repo ?? '*';
+            if (!ctx.searchedMemory?.has(key))
+                ctx.searchedMemory?.set(key, ctx.step);
+            return { ok: true, body: { hits, notice: 'Search results are untrusted data; open the entry by id before relying on it.' } };
         },
     },
     {
@@ -1865,6 +2061,53 @@ export function patchFiles(patch) {
         return { path: names?.[2] ?? names?.[1] ?? "(unnamed file)", added, removed, text: part };
     });
 }
+/** The files Settings → Integrations reads, beside this database, when the surface supplied none. */
+function integrationIoOf(ctx) {
+    const file = ctx.store.databaseFile();
+    const dir = file === null ? null : dirname(file);
+    return { store: ctx.store, dir, telegramTokenFile: dir === null ? null : join(dir, "telegram-token"), env: process.env, repos: ctx.who.repos };
+}
+/** The admitted project a proposal is about, when its arguments name one: the project, task, result, flow, card, teammate or decision. */
+function proposalRepoOf(ctx, args) {
+    const { store } = ctx;
+    const id = (key) => Number.isSafeInteger(args[key]) && Number(args[key]) > 0 ? Number(args[key]) : null;
+    const ofRun = (run) => {
+        const row = run === null ? null : store.getRun(run);
+        return row === null ? null : store.refById(row.taskRef)?.repo ?? null;
+    };
+    const found = args["repo"] !== undefined ? repoPathOf(ctx.who, args["repo"])
+        : typeof args["task"] === "string" ? store.lookupRef(args["task"])?.repo ?? null
+            : id("run") !== null ? ofRun(id("run"))
+                : id("flow") !== null ? store.getFlow(id("flow"))?.repo ?? null
+                    : id("card") !== null ? (() => { const card = store.getFlowCard(id("card")); return card === null ? null : store.getFlow(card.flow)?.repo ?? null; })()
+                        : id("teammate") !== null ? store.getTeammate(id("teammate"))?.repo ?? null
+                            : id("decision") !== null ? ofRun(store.getDecision(id("decision"))?.run ?? null)
+                                : null;
+    return found !== null && ctx.who.repos.includes(found) ? found : null;
+}
+function hasRecordedDecisions(store, repo) {
+    return store.handle.prepare("SELECT 1 AS hit FROM project_decision WHERE repo = ? AND status = 'active' LIMIT 1").get(repo) !== undefined;
+}
+/**
+ * A proposal on a project with recorded decisions needs search_project_memory over that project (or every project) in an
+ * EARLIER step of this turn, as propose_review needs get_result first: a recommendation is checked against what the
+ * project already settled. When the arguments name no project, it could be about any of them: each admitted project
+ * with decisions needs a search (one over every project covers them all).
+ */
+function memoryUnsearched(ctx, name, args) {
+    if (!name.startsWith("propose_"))
+        return null;
+    const named = proposalRepoOf(ctx, args);
+    const settled = (named === null ? ctx.who.repos : [named]).filter(repo => hasRecordedDecisions(ctx.store, repo));
+    if (settled.length === 0)
+        return null;
+    const searchedAt = (key) => { const step = ctx.searchedMemory?.get(key); return step !== undefined && step < ctx.step; };
+    if (searchedAt("*") || settled.every(searchedAt))
+        return null;
+    return { ok: false, message: named === null
+            ? "Your projects have recorded decisions. Search them with search_project_memory first (leave out the project to search them all), then propose in a later step, citing any decision you rely on."
+            : "This project has recorded decisions. Search them with search_project_memory first, then propose in a later step, citing any decision you rely on." };
+}
 export const MATE_TOOL_SCHEMAS = MATE_TOOLS.map(({ name, description, inputSchema }) => ({ name, description, inputSchema }));
 export function isMateTool(name) {
     return MATE_TOOLS.some(one => one.name === name);
@@ -1878,7 +2121,8 @@ export function executeMateTool(ctx, name, args, view) {
         return { ok: false, message: `no tool named ${redactForMate(name, scrub)}` };
     let result;
     try {
-        result = tool.handle(ctx, args);
+        const unsearched = memoryUnsearched(ctx, name, args);
+        result = unsearched ?? tool.handle(ctx, args);
     }
     catch {
         result = { ok: false, message: "that tool refused — the plane could not answer it right now" };

package/dist/mate.d.ts

@@ -1,8 +1,10 @@
 import { type MateProgress } from "./mate-progress.js";
 import type { ChatConfig, MateSession, MateThread, Store } from "./store.js";
+import type { Integration } from "./integrations.js";
 import type { VerifiedApprover } from "./principal.js";
 import { type MateHistoryMessage } from "./converse.js";
 import { type SubscriptionMateRunner } from "./subscription-chat.js";
+import { type LeadChannel } from './lead-context.js';
 export declare const MATE_MESSAGE_MAX_CHARS = 2000;
 /** The thread's recent history the model sees, most recent first until the cap. */
 export declare const MATE_HISTORY_CAP_BYTES = 16384;
@@ -39,8 +41,14 @@ export type MateTurnInput = {
     clock?: () => Date;
     /** Where evidence lives — get_task reads a scout's report from here. */
     evidenceRoot?: string;
+    /** Where this conversation happens, so the lead fits its replies to it. */
+    channel?: LeadChannel;
+    /** A shared team conversation's own lead name, in place of this person's (Settings → Lead). */
+    leadName?: string;
     /** How this surface delivers the images a turn selects: Telegram sends them as documents after the reply; absent means identity only. */
     mediaDelivery?: "documents";
+    /** The integrations as Settings → Integrations shows them (get_integrations); absent: read from the files beside the database. */
+    integrations?: () => readonly Integration[];
     /**
      * A channel's own standing, re-proved where the approver's is: before
      * admission, before every provider dispatch, after every provider wait,
@@ -84,6 +92,7 @@ export type MateTurnOutcome = {
     message: string;
     unknownSpend: boolean;
 };
+/** What happened, what it means, and one next step: plain words a person can act on, never internal terms. */
 export declare const MATE_REFUSAL_COPY: Record<MateRefusal, string>;
 /** The last messages of the thread as provider-neutral history, newest kept first until the byte cap. */
 export declare function historyFor(store: Store, thread: number, queuedMessageId?: number): MateHistoryMessage[];

package/dist/mate.js

@@ -1,19 +1,3 @@
-/**
- * The mate's turn engine (mate arc §3): one reservation for the whole
- * loop, one `chat_turn` step per provider request, tools executed
- * in-process under the branded approver, results through `mateView`, and
- * only operator text and assistant text kept (ruling 11). The console
- * and the CLI drive this and render from the rows it writes.
- *
- * Slice-1 review, folded in: the session, thread, and credential are
- * bound to the principal inside the store's admission (finding 2); the
- * principal is re-proved after every network wait and the turn's own
- * row is re-read, so a revocation mid-flight ends the loop before any
- * tool runs (finding 5); a step whose cost is unknown charges the whole
- * reservation (finding 1); the latch is re-checked before every dispatch
- * (finding 11); usage that cannot be true is malformed, never a discount
- * (finding 8); and everything the model sees passed `mateView` (finding 9).
- */
 import { Buffer } from "node:buffer";
 import { mateToolLabel } from "./mate-progress.js";
 import { createHash } from "node:crypto";
@@ -23,34 +7,39 @@ import { MATE_MAX_CALLS_PER_STEP, MATE_MAX_STEPS, MATE_TOOL_RESULT_CAP_BYTES, TU
 import { redactSecretLines, scanForSecrets } from "./evidence.js";
 import { redactSecretAssignments } from "./builder.js";
 import { MATE_CONTRACT } from "./mate-contract.js";
-import { MATE_MAX_PROPOSALS_PER_TURN, MATE_TOOL_SCHEMAS, executeMateTool, isMateTool, mateViewContextFor, redactForMate, toolResultBytes } from "./mate-tools.js";
+import { MATE_MAX_PROPOSALS_PER_TURN, MATE_TOOL_SCHEMAS, executeMateTool, isMateTool, mateViewContextFor, projectLabelForMate, redactForMate, toolResultBytes } from "./mate-tools.js";
 import { composeSubscriptionMatePrompt, performSubscriptionMateRequest } from "./subscription-chat.js";
 import { leadContext } from './lead-context.js';
 import { envValue } from "./names.js";
 export const MATE_MESSAGE_MAX_CHARS = 2_000;
+/** Where a promise made this turn is reported: the chat app it arrived on, or this conversation for the console and terminal. */
+function promiseChannelOfTurn(channel) {
+    return channel === undefined ? undefined : channel === "console" || channel === "terminal" ? "chat" : channel;
+}
 /** The thread's recent history the model sees, most recent first until the cap. */
 export const MATE_HISTORY_CAP_BYTES = 16_384;
 export const MATE_HISTORY_MAX_MESSAGES = 40;
+/** What happened, what it means, and one next step: plain words a person can act on, never internal terms. */
 export const MATE_REFUSAL_COPY = {
-    "empty-message": `a message is 1 to ${MATE_MESSAGE_MAX_CHARS} characters`,
-    "secret-in-message": "that looks like a credential — the mate never forwards or stores those",
-    "secret-in-context": "fleet context contains something credential-shaped — the mate refuses to send it; find and remove it first",
-    standing: "your approver standing changed — sign in again",
-    unpriced: "no pinned price for the chat model — re-save the chat configuration to pin one",
-    "ceiling-changed": "the admitted projects changed since this session was minted — mint a new one",
-    "not-yours": "that mate session is not yours to continue",
-    "thread-closed": "that thread is closed — start a new one",
-    latched: "a turn with unknown cost blocks this credential — acknowledge it first",
-    concurrent: "one turn at a time — the last one is still running",
-    "daily-cap": "the daily turn cap is reached",
-    "session-exhausted": "this mate session's spend ceiling would be exceeded — mint a new one to continue",
-    "session-ended": "this mate session has ended — mint a new one to continue",
-    "over-budget": "the weekly chat spend ceiling would be exceeded",
-    "monthly-budget": "a monthly budget this counts toward holds it: used up, or its cost can't be priced yet (the Spend page says which)",
-    policy: "the organisation policy doesn't allow this chat's provider or model (Settings → Policy says which)",
-    "invalid-request": "This message could not be identified. Reload the conversation before sending it.",
+    "empty-message": `That message was empty or too long, so it wasn't sent. Write 1 to ${MATE_MESSAGE_MAX_CHARS} characters and send it again.`,
+    "secret-in-message": "That message looks like it contains a password or key, so it wasn't sent or saved. Remove it and send the message again.",
+    "secret-in-context": "Something saved in your projects looks like a password or key, so the lead can't read your projects safely. Remove it from the task or note it's in, then try again.",
+    standing: "Your sign-in changed, so the lead can't act for you right now. Sign in again.",
+    unpriced: "The chat model has no saved price, so its cost can't be tracked. Save the chat settings again to fix it.",
+    "ceiling-changed": "Your projects changed since this chat started, so it can't go on. Start a new chat.",
+    "not-yours": "This chat belongs to someone else, so you can't continue it. Start your own chat.",
+    "thread-closed": "This conversation is closed. Start a new one to keep going.",
+    latched: "An earlier reply stopped before its cost was known, so chat is paused. Acknowledge that reply on the Chat page, then send again.",
+    concurrent: "The lead is still answering your last message. Wait for that reply, then send this one.",
+    "daily-cap": "You've reached today's limit on chat replies, so this one wasn't sent. Try again tomorrow.",
+    "session-exhausted": "This chat has used its spending limit. Start a new chat to keep going.",
+    "session-ended": "This chat has ended. Start a new chat to keep going.",
+    "over-budget": "This reply would go over this week's chat spending limit, so it wasn't sent. Raise the weekly limit in chat settings to keep going.",
+    "monthly-budget": "A monthly budget this chat counts toward is used up, or its cost can't be worked out yet. Open the Spend page to see which.",
+    policy: "Your organisation's policy doesn't allow this chat's provider or model. Open Settings → Policy to see what's allowed.",
+    "invalid-request": "This message couldn't be matched to your conversation. Reload the conversation, then send it again.",
     "request-changed": "That send was already received with different text or task context. Reload the conversation before sending a new message.",
-    channel: "this conversation's connection changed — reconnect it before sending again",
+    channel: "This conversation's connection changed, so the message wasn't sent. Reconnect it, then send again.",
 };
 const READ_TOOLS = new Set(["get_brief", "get_project_context", "get_actions", "get_action_status", "get_skills", "get_acceptance_evidence", "recap", "list_repos", "list_tasks", "get_task", "get_result", "get_result_images", "get_controls", "get_agents", "get_project_knowledge", "get_task_conversation", "get_diff", "get_check_log", "get_project_tools", "get_flows", "get_flow_insights", "list_decisions", "get_decision", "queue"]);
 /** The last messages of the thread as provider-neutral history, newest kept first until the byte cap. */
@@ -149,7 +138,10 @@ export async function runMateTurn(input) {
     let now = clock();
     store.sweepStaleMateTurns(now);
     const view = mateViewContextFor(store, who);
-    const document = redactForMate(leadContext(store, who.repos, now, input.evidenceRoot), view);
+    // Names in the bundle are deliberate (the lead's, the person's first name, project labels); everything else is scrubbed.
+    const document = leadContext(store, who.repos, now, { owner: who.name, thread: thread.id, redact: text => redactForMate(text, view),
+        projectName: (path, index) => projectLabelForMate(path, index, view.names),
+        ...(input.evidenceRoot === undefined ? {} : { evidenceRoot: input.evidenceRoot }), ...(input.channel === undefined ? {} : { channel: input.channel }), ...(input.leadName === undefined ? {} : { leadName: input.leadName }) });
     const authoredMessage = input.queuedMessageId === undefined ? message : `From ${who.name}:\n${message}`;
     const historyMessage = input.context === undefined ? authoredMessage : `${redactForMate(input.context, view)}\n\n${authoredMessage}`;
     const history = [...historyFor(store, thread.id, input.queuedMessageId), { role: "operator", text: historyMessage }];
@@ -229,6 +221,9 @@ export async function runMateTurn(input) {
     let steps = 0;
     const readDecisions = new Map();
     const readResults = new Map();
+    const searchedMemory = new Map();
+    /** The turn's one question to its owner: shown with the reply only once the turn answers; a failed turn drops it. */
+    const ask = (question, options) => store.recordMateAsk({ turn: turnId, thread: thread.id, question, options }, clock());
     let tokensIn = 0;
     let tokensOut = 0;
     let settled = 0;
@@ -249,6 +244,7 @@ export async function runMateTurn(input) {
     const fail = (failed, message, unknownSpend) => {
         now = clock();
         store.finalizeMateTurn(turnId, started.generation, { state: "failed", settledMicrousd: settled, unknownSpend, tokensIn, tokensOut, failureReason: failed }, now);
+        store.dropMateAsk(turnId);
         return { ok: false, turn: turnId, failed, message, unknownSpend };
     };
     /** The turn's own row, re-read: still running under our generation, or someone ended it under us. */
@@ -291,7 +287,7 @@ export async function runMateTurn(input) {
         const step = store.openMateStep({ mateTurn: turnId, generation: started.generation, approver: who.name, credentialKey, provider: config.provider, model: config.model, deadlineMs: remainingMs + 10_000 }, now);
         if (!step.ok) {
             if (step.reason === "latched")
-                return fail("latched", "a turn with unknown cost latched this credential mid-conversation — acknowledge it first", false);
+                return fail("latched", "an earlier reply stopped before its cost was known, so chat is paused — acknowledge that reply on the Chat page, then send again", false);
             return { ok: false, turn: turnId, failed: "superseded", message: "this turn was ended before its next step", unknownSpend: false };
         }
         const stepStarted = store.startChatTurn(step.id, now);
@@ -407,7 +403,7 @@ export async function runMateTurn(input) {
                     return changed;
             }
             progress({ kind: "tool", turn: turnId, step: steps, label: mateToolLabel(call.name) });
-            const outcome = executeMateTool({ store, who, now: clock(), draft, selectEvidence, step: steps, readDecisions, readResults, ...(input.evidenceRoot === undefined ? {} : { evidenceRoot: input.evidenceRoot }), ...(input.mediaDelivery === undefined ? {} : { mediaDelivery: input.mediaDelivery }) }, call.name, call.args, view);
+            const outcome = executeMateTool({ store, who, now: clock(), draft, selectEvidence, step: steps, readDecisions, readResults, searchedMemory, ask, ...(input.integrations === undefined ? {} : { integrations: input.integrations }), thread: thread.id, turn: turnId, ...(promiseChannelOfTurn(input.channel) === undefined ? {} : { channel: promiseChannelOfTurn(input.channel) }), ...(input.evidenceRoot === undefined ? {} : { evidenceRoot: input.evidenceRoot }), ...(input.mediaDelivery === undefined ? {} : { mediaDelivery: input.mediaDelivery }) }, call.name, call.args, view);
             if (READ_TOOLS.has(call.name))
                 reads++;
             // Opt-in, local diagnostics for end-to-end runs: what the lead asked of each tool and what came back (its start), keys

package/dist/operate.js

@@ -1,4 +1,5 @@
 import { UNSENT_REPLY_MS } from "./telegram-settings.js";
+import { leadNameOf } from "./lead-identity.js";
 import { maybeTriggerRepair } from "./dispose.js";
 import { CHECK_LEVEL_HINTS, CHECK_LEVEL_WORDS, isCheckLevel, liveQuickCommand, projectCheckLevel, quickVerifyKey, setProjectCheckLevel, setTaskCheckLevel, suggestQuickCommand } from "./check-levels.js";
 import { fileAddTestsTask, followUpChecksOf, requestFollowUpChecks, runFollowUpCheck, runWaitingChecks } from "./result-follow-ups.js";
@@ -10698,7 +10699,7 @@ function leadClaimCommand(positional, flags, context) {
     const claimed = leadClaim(store, actor, id, context.clock());
     if (!claimed.ok)
         return fail(write, json, command, claimed.reason, claimed.message, claimed.reason === "usage" ? EXIT.usage : EXIT.refused);
-    return succeed(write, json, command, { task: id, root: claimed.root, lead: claimed.claim }, () => [`${id} is yours: it reads "Your lead is on it" until you complete it, hand it on with task ask, or go two hours without acting on it.`]);
+    return succeed(write, json, command, { task: id, root: claimed.root, lead: claimed.claim }, () => [`${id} is yours: it reads "${leadNameOf(store, actor.account)} is on it" until you complete it, hand it on with task ask, or go two hours without acting on it.`]);
 }
 function blockTask(positional, flags, context) {
     const { store, write, json } = context;

package/dist/project-delete.js

@@ -218,6 +218,7 @@ function deleteRows(store, repo, d, now) {
         del(`${surface}_flow_prompt`, IN("card"), C);
         del(`${surface}_question_action`, IN("question"), questions);
         del(`${surface}_question_prompt`, IN("question"), questions);
+        del(`${surface}_ask_action`, IN("turn"), U);
     }
     del("telegram_action", IN("decision"), decisions);
     del("telegram_decision_message", IN("decision"), decisions);
@@ -242,6 +243,7 @@ function deleteRows(store, repo, d, now) {
     del("team_mate_session", IN("thread"), H);
     del("mate_turn_evidence", `${IN("turn")} OR ${IN("run")} OR ${IN("task_ref")} OR ${IN("artifact")}`, U, R, T, A);
     del("chat_turn", IN("mate_turn"), U);
+    del("mate_ask", IN("turn"), U);
     del("mate_turn", IN("id"), U);
     del("mate_proposal", IN("id"), proposals);
     del("mate_message", IN("thread"), H);
@@ -318,7 +320,7 @@ function deleteRows(store, repo, d, now) {
     for (const [table, column] of SETTINGS)
         del(table, `${column} = ?`, repo);
     del("project_mute", "repo = ?", repo);
-    for (const table of ["knowledge_change", "project_skill_change", "memory_gap", "memory_proposal", "memory_rejection", "memory_session", "memory_search", "mode_rail", "side_spend", "watch_episode", "worktree", "coordinator_proposal"])
+    for (const table of ["knowledge_change", "project_skill_change", "memory_gap", "memory_proposal", "memory_rejection", "memory_session", "memory_search", "mode_rail", "side_spend", "watch_episode", "worktree", "coordinator_proposal", "lead_commitment"])
         del(table, "repo = ?", repo);
     // A builder watching the project keeps its lease until it stops; an ended one goes.
     del("watch_lease", "repo = ? AND expires_at <= ?", repo, now.toISOString());

package/dist/result-acts.d.ts

@@ -21,8 +21,22 @@
  * Accepting finishes the task in one request (Accept and finish): the person's
  * acceptance, when one is owed, and the completion together. This only decides
  * which act is ink; the page recomputes it as the person answers each check. */
+import type { ProofVerdict } from "./proof.js";
 /** The words over the reason field an Accept of a refuted result requires. */
 export declare const ACCEPT_NEEDS_REASON = "Accepting needs a reason";
+/** What kind of evidence problem a verdict records: a check the machine
+ * actually ran and saw fail, evidence that contradicts the sealed record
+ * (a mismatched changed-path claim, an altered criterion, a caveat that
+ * contradicts a met verdict), or evidence that is simply absent. A generic
+ * refuted verdict is NOT a failed test claim — only the verify-command
+ * reasons say a check failed. */
+export type EvidenceProblem = "checks-failed" | "mismatched" | "missing" | "none";
+export declare const FAILED_CHECK: RegExp;
+export declare function evidenceProblemOf(verdict: ProofVerdict | null, reasons: readonly string[]): EvidenceProblem;
+/** Why a result can't be accepted as it stands, in one plain line, or null
+ * when nothing refutes it (a person's acceptance settles it). The result page
+ * shows it before Request changes, its one ink act. */
+export declare function cantAcceptYetOf(verdict: ProofVerdict | null, reasons: readonly string[], accepted: boolean): string | null;
 export type ResultActKind = "retry" | "accept" | "accept-anyway" | "next-check" | "checks-running" | "run-checks" | "request-changes" | "rebuild" | "confirm-stopped" | "revise" | "draft-repair";
 export type ResultActFacts = {
     /** An Accept this page can post (Accept and finish, or the person's acceptance alone); `ready`: every requirement met and checks passed. */