toolroll 0.9.55 → 0.9.56

package/dist/chat-ask.js

@@ -1,8 +1,8 @@
 import { chatHash, partContent, savedChatPart } from "./chat-delivery-state.js";
-import { MATE_ASK_OTHER } from "./store.js";
+import { LEAD_ASK_OTHER } from "./store.js";
 /** The question as text with its options, where no buttons are drawn. */
 export function chatAskText(ask) {
-    return [ask.question, ...ask.options.map(one => `• ${one}`), `• ${MATE_ASK_OTHER}: say it in your own words`].join("\n");
+    return [ask.question, ...ask.options.map(one => `• ${one}`), `• ${LEAD_ASK_OTHER}: say it in your own words`].join("\n");
 }
 /** The live buttons on one part, in the order they were minted: the options, then "Something else". None when the part
  * is not in its owner's own chat with Toolroll (a room), where a tap could not be their message. */
@@ -16,7 +16,7 @@ export function chatAskButtons(state, part, now) {
     const options = content.ask?.options ?? [];
     return state.prepare("SELECT token,choice FROM chat_ask_action WHERE provider=:provider AND part=? AND consumed IS NULL AND expires>? ORDER BY rowid").all(part, now.toISOString())
         .map(one => {
-        const label = one.choice === null ? MATE_ASK_OTHER : options[Number(one.choice)] ?? null;
+        const label = one.choice === null ? LEAD_ASK_OTHER : options[Number(one.choice)] ?? null;
         return label === null ? null : { token: String(one.token), label: label.slice(0, 75), words: one.choice === null };
     })
         .filter((one) => one !== null);
@@ -51,12 +51,12 @@ export function applyChatAskTap(options, event, binding, token, now) {
     }
     const turn = Number(action["turn"]), part = Number(action["part"]);
     // Only the person the lead asked answers it: anyone else's tap changes nothing and says nothing.
-    const asker = store.getMateTurn(turn)?.approver;
+    const asker = store.getLeadTurn(turn)?.approver;
     if (asker !== undefined && asker !== binding.approver) {
         state.finish(event.id);
         return true;
     }
-    const found = asker === undefined ? { state: "expired" } : store.mateAskState(turn, now);
+    const found = asker === undefined ? { state: "expired" } : store.leadAskState(turn, now);
     const expired = found.state === "expired" || String(action["expires"]) <= now.toISOString();
     // A question already settled was shown so once (or is being): a later tap says nothing more.
     if (action["consumed"] !== null) {

package/dist/chat-channel.d.ts

@@ -1,12 +1,12 @@
-import type { DoorOutcome } from "./mate-doors.js";
+import type { DoorOutcome } from "./lead-doors.js";
 import { type VerifiedApprover } from "./principal.js";
-import type { ChatConfig, MateProposal, MateSession, MateThread, Store, SubscriptionChatProviderId } from "./store.js";
+import type { ChatConfig, LeadProposal, LeadSession, LeadThread, Store, SubscriptionChatProviderId } from "./store.js";
 export declare function channelRepos(store: Store, approver: string, registry: readonly string[]): string[];
-export type ResolvedMate = {
+export type ResolvedLead = {
     ok: true;
     who: VerifiedApprover;
-    session: MateSession;
-    thread: MateThread;
+    session: LeadSession;
+    thread: LeadThread;
     config: ChatConfig & {
         provider: SubscriptionChatProviderId;
     };
@@ -25,10 +25,10 @@ export type ResolvedMate = {
  * always gets an answer — except while a turn is still running there,
  * which is "busy": the message waits its turn instead of ending it.
  */
-export declare function resolveChannelMate(store: Store, binding: {
+export declare function resolveChannelLead(store: Store, binding: {
     approver: string;
     approverGeneration: number;
-}, repos: readonly string[], now: Date): ResolvedMate;
+}, repos: readonly string[], now: Date): ResolvedLead;
 /** A phone exchange about one task (a reply to that task's or result's
  * message) stays in the lead conversation, and is kept in the task's own
  * chat as well, so the task shows everything asked of it wherever it was
@@ -65,10 +65,10 @@ export declare function taskInCeiling(store: Store, taskId: string, repos: reado
 export type ChatChannelName = "telegram" | "slack" | "discord" | "teams";
 /** The card text once its challenge is armed: an irreversible answer or a
  * challenge action, in the same words on every channel. */
-export declare function armedCardText(proposal: MateProposal, previewText: string): string;
+export declare function armedCardText(proposal: LeadProposal, previewText: string): string;
 /** The "yes" button's label for an armed card. */
-export declare function armedYesLabel(proposal: MateProposal): string;
-export declare function proposalLink(store: Store, proposal: MateProposal, repos: readonly string[], channel?: ChatChannelName | null): PhoneLink | null;
+export declare function armedYesLabel(proposal: LeadProposal): string;
+export declare function proposalLink(store: Store, proposal: LeadProposal, repos: readonly string[], channel?: ChatChannelName | null): PhoneLink | null;
 /**
  * The link a CONFIRMED card carries: the exact recorded task the outcome
  * names, where its remaining step lives — the approval control while the
@@ -76,17 +76,17 @@ export declare function proposalLink(store: Store, proposal: MateProposal, repos
  * automatic approval, a staged resume). Kinds whose outcome is complete
  * carry none.
  */
-export declare function confirmedLink(store: Store, outcome: DoorOutcome, proposal: MateProposal, repos: readonly string[]): PhoneLink | null;
+export declare function confirmedLink(store: Store, outcome: DoorOutcome, proposal: LeadProposal, repos: readonly string[]): PhoneLink | null;
 /** The card: plain words for what confirming does, the exact terms it binds to, and whether a button belongs on it. */
-export declare function proposalPreview(store: Store, proposal: MateProposal, repos: readonly string[], channel?: ChatChannelName | null): {
+export declare function proposalPreview(store: Store, proposal: LeadProposal, repos: readonly string[], channel?: ChatChannelName | null): {
     text: string;
     buttons: boolean;
 };
 /** The card after it resolves, from the recorded outcome — the same words every surface shows. */
-export declare function proposalOutcomeText(proposal: MateProposal): string;
+export declare function proposalOutcomeText(proposal: LeadProposal): string;
 export type ParitySupport = "direct" | "handoff" | "missing";
 /**
- * One row per mate tool: how the paired phone reaches it. `direct` means
+ * One row per lead tool: how the paired phone reaches it. `direct` means
  * the same engine tool or the same confirm door runs from Telegram;
  * `handoff` means the phone shows where the existing authenticated
  * control lives and does nothing itself; `missing` means no phone path
@@ -108,4 +108,4 @@ export declare function handoffCardText(text: string, note: string | null): stri
  * the console on the computer when no link exists). A scope approved under
  * a signed mode asks for nothing more. A staged resume says what remains.
  */
-export declare function confirmedCardText(store: Store, outcome: DoorOutcome, proposal: MateProposal, note: string | null): string;
+export declare function confirmedCardText(store: Store, outcome: DoorOutcome, proposal: LeadProposal, note: string | null): string;

package/dist/chat-channel.js

@@ -3,8 +3,8 @@ import { FLOW_HREF } from "./flow-engine.js";
 import { createHash } from "node:crypto";
 import { sharedActionPayload, sharedActionNeedsReview, sharedActionReviewPath, sharedActionAllowsChallenge, CHAT_ACTIONS, } from "./chat-actions.js";
 import { isDirectChatProvider, subscriptionCredentialKey } from "./converse.js";
-import { MATE_MESSAGE_MAX_CHARS } from "./mate.js";
-import { MATE_TOOL_SCHEMAS } from "./mate-tools.js";
+import { LEAD_MESSAGE_MAX_CHARS } from "./lead.js";
+import { LEAD_TOOL_SCHEMAS } from "./lead-tools.js";
 import { verifyApproverStanding } from "./principal.js";
 import { canonicalProject } from "./project.js";
 import { phoneText, projectLabel } from "./telegram-status.js";
@@ -32,7 +32,7 @@ export function channelRepos(store, approver, registry) {
  * always gets an answer — except while a turn is still running there,
  * which is "busy": the message waits its turn instead of ending it.
  */
-export function resolveChannelMate(store, binding, repos, now) {
+export function resolveChannelLead(store, binding, repos, now) {
     const config = store.getChatConfig();
     if (config === null) {
         return {
@@ -60,21 +60,21 @@ export function resolveChannelMate(store, binding, repos, now) {
         return { ok: false, reason: "unpaired", said: null };
     const who = verified.who;
     const credentialKey = subscriptionCredentialKey(config.provider);
-    let session = store.activeMateSession(who.name);
-    const liveThread = store.liveMateThreadFor(who.name);
+    let session = store.activeLeadSession(who.name);
+    const liveThread = store.liveLeadThreadFor(who.name);
     const sessionMismatch = session !== null &&
         (session.approverGeneration !== who.generation ||
             session.credentialKey !== credentialKey ||
             session.ceilingDigest !== who.ceilingDigest);
     const threadMismatch = liveThread !== null && liveThread.ceilingDigest !== who.ceilingDigest;
     // Replacing either would end a turn still running on the computer.
-    if ((sessionMismatch || threadMismatch) && store.liveMateTurnFor(who.name) !== null)
+    if ((sessionMismatch || threadMismatch) && store.liveLeadTurnFor(who.name) !== null)
         return { ok: false, reason: "busy", said: null };
     if (session === null || sessionMismatch) {
         const termsDigest = createHash("sha256")
             .update(`0\n${who.ceilingDigest}`)
             .digest("hex");
-        const id = store.mintMateSession({
+        const id = store.mintLeadSession({
             approver: who.name,
             approverGeneration: who.generation,
             credentialKey,
@@ -82,13 +82,13 @@ export function resolveChannelMate(store, binding, repos, now) {
             ceilingDigest: who.ceilingDigest,
             termsDigest,
         }, now);
-        session = store.getMateSession(id);
+        session = store.getLeadSession(id);
         if (session === null)
             return { ok: false, reason: "no-session", said: couldNotAnswerText("a new chat session couldn't be started") };
     }
-    // openMateThread closes a thread kept under another ceiling.
+    // openLeadThread closes a thread kept under another ceiling.
     const thread = threadMismatch || liveThread === null
-        ? store.openMateThread(who.name, who.ceilingDigest, now).thread
+        ? store.openLeadThread(who.name, who.ceilingDigest, now).thread
         : liveThread;
     return {
         ok: true,
@@ -107,9 +107,9 @@ export function mirrorToTaskChat(store, who, taskId, surface, message, reply, no
         const root = store.taskFamilyOf(taskId, who.repos, false)?.root.id ?? taskId;
         if (!taskInCeiling(store, root, who.repos))
             return;
-        const thread = store.openMateThread(who.name, who.ceilingDigest, now, { kind: "task", key: root }).thread;
-        store.appendMateMessage({ thread: thread.id, turn: null, role: "operator", text: `From ${surface}: ${message}` }, now);
-        store.appendMateMessage({ thread: thread.id, turn: null, role: "assistant", text: reply }, now);
+        const thread = store.openLeadThread(who.name, who.ceilingDigest, now, { kind: "task", key: root }).thread;
+        store.appendLeadMessage({ thread: thread.id, turn: null, role: "operator", text: `From ${surface}: ${message}` }, now);
+        store.appendLeadMessage({ thread: thread.id, turn: null, role: "assistant", text: reply }, now);
     }
     catch {
         // The task chat is a copy; the phone's own conversation already has it.
@@ -120,7 +120,7 @@ export function couldNotAnswerText(reason) {
     return `I couldn't answer that just now: ${reason.replace(/\.$/, "")}. Ask again, or open the console.`;
 }
 export function tooLongText(length) {
-    return `That message is ${length.toLocaleString("en-US")} characters; chat takes up to ${MATE_MESSAGE_MAX_CHARS.toLocaleString("en-US")}. Nothing was sent to the assistant. Send it in shorter parts, or say which part matters most.`;
+    return `That message is ${length.toLocaleString("en-US")} characters; chat takes up to ${LEAD_MESSAGE_MAX_CHARS.toLocaleString("en-US")}. Nothing was sent to the assistant. Send it in shorter parts, or say which part matters most.`;
 }
 /** A reply to a message about several tasks is never guessed: it names them and says how to choose. */
 export function whichTaskText(titles) {
@@ -459,7 +459,7 @@ export function proposalOutcomeText(proposal) {
     }
 }
 /**
- * One row per mate tool: how the paired phone reaches it. `direct` means
+ * One row per lead tool: how the paired phone reaches it. `direct` means
  * the same engine tool or the same confirm door runs from Telegram;
  * `handoff` means the phone shows where the existing authenticated
  * control lives and does nothing itself; `missing` means no phone path
@@ -518,14 +518,14 @@ export const CHAT_ACTION_PARITY = {
     get_project_tools: { support: "direct", how: "Read during a turn: a project's tools, the common tools list and servers found on the computer. Adding one is a secure-review card; secrets are set only on the console's Tools page.", gap: null },
     get_task_conversation: { support: "direct", how: "Read during a turn: what the person and the lead said in one task's own chat, including what was confirmed there.", gap: null },
     get_flows: { support: "direct", how: "Read during a turn: a person's flows, each one's steps in order and its cards — where each card is, what it waits on, whether it needs them, its owner and its discussion.", gap: null },
-    get_teammates: { support: "direct", how: "Read during a turn: the project's AI teammates, their soul files, the zones they work, what they did today and the questions they're waiting on.", gap: null },
-    propose_teammate: { support: "direct", how: "Adds a teammate from a template or a soul file, changes one section of its soul file (or the whole short file), pauses, resumes or removes it, passes it a note, or answers its question for the person asked, through the shared confirm door.", gap: "Soul files longer than one message are edited on the console's teammate page; the phone changes one section at a time." },
+    get_subagents: { support: "direct", how: "Read during a turn: the project's subagents, their soul files, the zones they work, what they did today and the questions they're waiting on.", gap: null },
+    propose_subagent: { support: "direct", how: "Asks a subagent to do something for you (the lead delegates; its answer comes back here), adds one from a template or a soul file, changes one section of its soul file (or the whole short file), pauses, resumes or removes it, passes it a note, or answers its question for the person asked, through the shared confirm door.", gap: "Soul files longer than one message are edited on the console's subagent page; the phone changes one section at a time." },
     get_flow_insights: { support: "direct", how: "Read during a turn: where each flow's cards pass, fail or are sent back, how long they wait, how its scripts did, and a run's log.", gap: null },
     propose_flow: { support: "direct", how: "Creates or changes a flow, adds, moves, approves, sends back or cancels its cards, comments on them (@name pings that person), sets their owner, follows them, saves the project's scripts, and adds, pauses or removes its triggers, through the shared confirm door; a long drawing opens the secure review. Work a card files is an ordinary task under the usual approvals.", gap: "The flow canvas itself is on the console; the phone confirms cards but draws nothing. Webhook addresses and the Linear key are set on the console's Triggers panel." },
     commit_to: { support: "direct", how: "Records what the lead promised to follow up on (a task, attempt, check or time; 7 days at most). The follow pass says one line when it is met, in the shared conversation and on the chat the promise was made on.", gap: null },
     release_commitment: { support: "direct", how: "Stops following up on one of the person's open promises, with the reason.", gap: null },
     remember: { support: "direct", how: "Proposes a correction or lasting preference as a decision, project instruction or about-you card, through the shared confirm door; an about-you card shows the line it replaces.", gap: null },
-    get_person: { support: "direct", how: "Read during a turn: one person, AI teammate or team chat in full, with their open tasks.", gap: null },
+    get_person: { support: "direct", how: "Read during a turn: one person, subagent or team chat in full, with their open tasks.", gap: null },
     get_integrations: { support: "direct", how: "Read during a turn: which chat apps, email, GitHub, project tools and monitoring are Connected, Not set up or Broken, as Settings → Integrations shows them.", gap: null },
     get_capabilities: { support: "direct", how: "Read during a turn: which agents are signed in, which workers are online, which tools and skills work, which integrations are connected and what checks the project runs, each with its next step and settings link.", gap: null },
     ask_owner: { support: "direct", how: "One question with 2-4 options and Something else, drawn as buttons under the reply; the tapped option is sent as the person's next message.", gap: null },
@@ -568,7 +568,7 @@ export const CHAT_ACTION_PARITY = {
     },
     propose_task: {
         support: "direct",
-        how: "Card with Confirm/Dismiss through confirmMateProposal (filed as a mate proposal, via telegram). The confirmed card links Review & start for the filed task while its scope waits; under a signed automatic mode it says the scope is approved and links the task.",
+        how: "Card with Confirm/Dismiss through confirmLeadProposal (filed as a lead proposal, via telegram). The confirmed card links Review & start for the filed task while its scope waits; under a signed automatic mode it says the scope is approved and links the task.",
         gap: "Under manual approval the password step happens in the console, reached from the card's button.",
     },
     propose_scope: {
@@ -634,7 +634,7 @@ export const CHAT_ACTION_PARITY = {
 };
 /** Every tool the model can call, mapped; a new tool must name its phone road. */
 export function parityGaps() {
-    return MATE_TOOL_SCHEMAS.map((tool) => tool.name).filter((name) => CHAT_ACTION_PARITY[name] === undefined);
+    return LEAD_TOOL_SCHEMAS.map((tool) => tool.name).filter((name) => CHAT_ACTION_PARITY[name] === undefined);
 }
 export function handoffCardText(text, note) {
     return note === null ? text : `${text}\n\n${note}`;

package/dist/chat-controls.d.ts

@@ -38,10 +38,6 @@ export declare const CHAT_CONTROLS: {
         readonly label: "Manage projects";
         readonly href: "/projects";
     };
-    readonly code: {
-        readonly label: "Open coding workspace";
-        readonly href: "/code";
-    };
     readonly flows: {
         readonly label: "Open flows";
         readonly href: "/flows";

package/dist/chat-controls.js

@@ -11,7 +11,6 @@ export const CHAT_CONTROLS = {
     acceptance: { label: "Inspect result", target: "task" },
     publish: { label: "Review publication", target: "task" },
     projects: { label: "Manage projects", href: "/projects" },
-    code: { label: "Open coding workspace", href: "/code" },
     flows: { label: "Open flows", href: "/flows" },
     recipes: { label: "Browse workflows", href: "/recipes" },
     workers: { label: "Manage workers", href: "/fleet" },

package/dist/chat-core.js

@@ -183,7 +183,7 @@ export class ChatCore {
             const thread = this.db.prepare("SELECT thread FROM team_conversation WHERE id = ?").get(args.conversation);
             if (thread === undefined)
                 throw new Error("no such team conversation");
-            const cursor = Number(this.db.prepare("SELECT COALESCE(MAX(id), 0) AS n FROM mate_message WHERE thread = ?").get(Number(thread["thread"]))?.["n"] ?? 0);
+            const cursor = Number(this.db.prepare("SELECT COALESCE(MAX(id), 0) AS n FROM lead_message WHERE thread = ?").get(Number(thread["thread"]))?.["n"] ?? 0);
             this.prepare("INSERT INTO chat_room (provider, id, installation, chat, kind, conversation, binding, bound_by, bound, cursor) VALUES (:provider, ?, ?, ?, ?, ?, ?, ?, ?, ?)")
                 .run(this.nextId("chat_room"), args.installation, args.chat, args.kind, args.conversation, args.binding, args.by, stamp, cursor);
             return { ok: true, room: this.room(args.installation, args.chat) };

package/dist/chat-delivery-state.js

@@ -1,6 +1,6 @@
 /** Durable chat receipts on the shared chat core: what each app's chats sent us and what we plan to send them. */
 import { randomBytes } from "node:crypto";
-import { MATE_ASK_TTL_MS } from "./store.js";
+import { LEAD_ASK_TTL_MS } from "./store.js";
 import { ChatCore, chatHash } from "./chat-core.js";
 import { ChatMessages } from "./chat-messages.js";
 import { readChatPart, savedChatEventBody, savedChatPart } from "./contracts/chat-content.js";
@@ -80,7 +80,7 @@ export class ChatState extends ChatMessages {
                 if (part.ask)
                     for (const choice of [...part.ask.options.map((_, index) => index), null])
                         this.prepare("INSERT INTO chat_ask_action (provider, token, part, turn, choice, expires) VALUES (:provider, ?, ?, ?, ?, ?)")
-                            .run(token(), id, part.ask.turn, choice, new Date(now.getTime() + MATE_ASK_TTL_MS).toISOString());
+                            .run(token(), id, part.ask.turn, choice, new Date(now.getTime() + LEAD_ASK_TTL_MS).toISOString());
                 if (part.choose)
                     for (const one of part.choose.options)
                         this.prepare("INSERT INTO chat_flow_choice (provider, token, part, card, entry, choice, label, created, expires) VALUES (:provider, ?, ?, ?, ?, ?, ?, ?, ?)")

package/dist/chat-delivery.d.ts

@@ -1,7 +1,7 @@
 import { type WarmHooks } from "./chat-warmth.js";
 import { ChatState, type ChatBinding, type ChatContent, type ChatEvent, type ChatIdentity } from "./chat-delivery-state.js";
 import { type Store } from "./store.js";
-import type { SubscriptionMateRunner } from "./subscription-chat.js";
+import type { SubscriptionLeadRunner } from "./subscription-chat.js";
 import { type ChatMerge } from "./chat-decide.js";
 export declare const chatObject: (v: unknown) => Record<string, unknown>;
 export type ChatDeliveryOptions = {
@@ -15,7 +15,7 @@ export type ChatDeliveryOptions = {
     evidenceRoot: string;
     current: () => boolean;
     origin: () => string | null;
-    subscriptionRunner?: SubscriptionMateRunner;
+    subscriptionRunner?: SubscriptionLeadRunner;
     canNotify?: () => boolean;
     clock?: () => Date;
     partSize?: number;

package/dist/chat-delivery.js

@@ -1,11 +1,11 @@
 /** Shared saved replies, explicit confirmations and progress for private chat transports. */
-import { answerChatQuestionPrompt, applyChatQuestionTap, questionParts } from "./teammate-question.js";
+import { answerChatQuestionPrompt, applyChatQuestionTap, questionParts } from "./subagent-question.js";
 import { applyChatAskTap, chatAskText } from "./chat-ask.js";
-import { channelRepos, resolveChannelMate, proposalPreview, proposalOutcomeText, confirmedLink, confirmedCardText, replyContextFor, mirrorToTaskChat, focusContextFor, taskInCeiling, tooLongText, } from "./chat-channel.js";
-import { MATE_MESSAGE_MAX_CHARS, mateFailureText, runMateTurn } from "./mate.js";
+import { channelRepos, resolveChannelLead, proposalPreview, proposalOutcomeText, confirmedLink, confirmedCardText, replyContextFor, mirrorToTaskChat, focusContextFor, taskInCeiling, tooLongText, } from "./chat-channel.js";
+import { LEAD_MESSAGE_MAX_CHARS, leadFailureText, runLeadTurn } from "./lead.js";
 import { shapeReplyParts } from "./reply-shape.js";
 import { warmTurn } from "./chat-warmth.js";
-import { confirmMateProposal, dismissMateProposal, } from "./mate-doors.js";
+import { confirmLeadProposal, dismissLeadProposal, } from "./lead-doors.js";
 import { ceilingDigestOf, verifyApproverStanding } from "./principal.js";
 import { ChatState, ChatDeliveryError, chatHash, savedChatPart, } from "./chat-delivery-state.js";
 import { readChatActionBody, readChatMessageBody, readChatPairBody, readChatPart } from "./contracts/chat-content.js";
@@ -23,7 +23,6 @@ import { phoneText, PHONE_HELP, phoneCommand, phoneStatus, phoneTaskView, phoneT
 import { applyRoomInbound, conversationRow, roomCardApprover, roomCommand, roomGrantAllowed, roomMessagesAfter, roomMessageText, teamDomain } from "./chat-rooms.js";
 import { isTelegramProgressNotification, proposalTaskOf } from "./store.js";
 import { isShotsKind, resultShotsFor } from "./result-shots.js";
-import { messageTeammate } from "./teammate-desk.js";
 import { CHAT_APP_NAMES } from "./flow-triggers.js";
 import { answersPrompt, applyDecideFeedback, applyDecideTap, decideFallbackLink, decideOffer, decideTargetOf, hasLiveDecideTokens, linksFor, mergedText, mintDecideButtons, offerFingerprint, openPromptFor, recordChatMerge } from "./chat-decide.js";
 import { mergePullRequest } from "./pull-request-flow.js";
@@ -198,7 +197,7 @@ export async function processChatEvent(options) {
             return true;
         }
         const text = String(input.text ?? "");
-        // A teammate's question asked for this person's next message (v93): it is the answer.
+        // A subagent's question asked for this person's next message (v93): it is the answer.
         if (answerChatQuestionPrompt({ store, state, label: options.label }, event, binding, { text, ...(typeof input.originalLength === "number" ? { originalLength: input.originalLength } : {}) }, nowOf(options)))
             return true;
         // A flow decision asked for this person's next message (Edit, Send back): it is the draft or the note.
@@ -217,14 +216,8 @@ export async function processChatEvent(options) {
         // A "Person chooses" notice's thread reply is the note; the first other message after it is asked about (chat-flow.ts).
         if (answerChoiceMessage({ store, state, label: options.label }, event, binding, { text, ...(typeof input.originalLength === "number" ? { originalLength: input.originalLength } : {}), lead: input.lead === true }, nowOf(options), repos))
             return true;
-        // A message to a teammate by name (v96), in someone's own chat with Toolroll: a card on its desk.
-        if (event.channel === binding.channel) {
-            const handed = messageTeammate(store, { who: binding.approver, repos, via: CHAT_APP_NAMES[state.provider] ?? "Chat" }, text, nowOf(options));
-            if (handed !== null) {
-                state.plan(event.id, [{ text: handed.said, ...(handed.link === undefined ? {} : { link: handed.link }) }], nowOf(options));
-                return true;
-            }
-        }
+        // D5: a message naming a subagent ("@rosa …") is the lead's to read like any other: it asks the subagent for its
+        // person with a card they confirm (propose_subagent ask), never by the transport passing it on unseen.
         // The task this message's turn is about, once chosen (kept on the event,
         // so a reply planned after a restart names the same task).
         let about = typeof object(input.about).task === "string" ? { task: String(object(input.about).task), run: typeof object(input.about).run === "number" ? Number(object(input.about).run) : null } : null;
@@ -280,7 +273,7 @@ export async function processChatEvent(options) {
                 return true;
             }
         }
-        if (text.length > MATE_MESSAGE_MAX_CHARS) {
+        if (text.length > LEAD_MESSAGE_MAX_CHARS) {
             state.plan(event.id, [
                 {
                     text: tooLongText(input.originalLength || text.length),
@@ -291,7 +284,7 @@ export async function processChatEvent(options) {
         const request = chatHash(`${options.state.provider}:${binding.id}:${event.id}`).slice(0, 32);
         let receipt = event.session === null
             ? null
-            : store.mateRequestReceipt(event.session, request);
+            : store.leadRequestReceipt(event.session, request);
         if (!receipt) {
             if (new Date(event.created).getTime() + 600_000 < now.getTime()) {
                 state.plan(event.id, [
@@ -301,7 +294,7 @@ export async function processChatEvent(options) {
                 ], now);
                 return true;
             }
-            const resolved = resolveChannelMate(store, { approver: binding.approver, approverGeneration: binding.generation }, repos, now);
+            const resolved = resolveChannelLead(store, { approver: binding.approver, approverGeneration: binding.generation }, repos, now);
             if (!resolved.ok && resolved.reason === "busy") {
                 state.defer(event.id, "Assistant is answering another message", new Date(now.getTime() + 5000));
                 return true;
@@ -332,7 +325,7 @@ export async function processChatEvent(options) {
                 .map((c) => {
                 if (c.task || c.proposal === undefined)
                     return c;
-                const about = proposalTaskOf(store.getMateProposal(c.proposal));
+                const about = proposalTaskOf(store.getLeadProposal(c.proposal));
                 return about === null ? c : { ...c, task: about.task, ...(about.run === null ? {} : { run: about.run }) };
             });
             const targets = [
@@ -363,7 +356,7 @@ export async function processChatEvent(options) {
             // Only ever the owner's own message in their own chat: never the bot's, never a room.
             const warm = warmTurn(options.warm !== undefined && event.kind === "message" && event.member !== identity.bot && event.member === binding.member && event.channel === binding.channel
                 ? options.warm(event, binding) : {});
-            const outcome = await runMateTurn({
+            const outcome = await runLeadTurn({
                 store,
                 who: resolved.who,
                 session: resolved.session,
@@ -407,7 +400,7 @@ export async function processChatEvent(options) {
                 state.defer(event.id, "Assistant is answering another message", new Date(nowOf(options).getTime() + 5000));
                 return true;
             }
-            receipt = store.mateRequestReceipt(resolved.session.id, request);
+            receipt = store.leadRequestReceipt(resolved.session.id, request);
             if (!receipt) {
                 state.plan(event.id, [
                     {
@@ -419,8 +412,8 @@ export async function processChatEvent(options) {
                 return true;
             }
         }
-        store.sweepStaleMateTurns(nowOf(options));
-        const turn = store.getMateTurn(receipt.turn);
+        store.sweepStaleLeadTurns(nowOf(options));
+        const turn = store.getLeadTurn(receipt.turn);
         if (turn?.state === "running" || turn?.state === "queued") {
             state.defer(event.id, "Reply is still running", new Date(nowOf(options).getTime() + 5000));
             return true;
@@ -428,19 +421,19 @@ export async function processChatEvent(options) {
         if (turn?.state !== "answered") {
             state.plan(event.id, [
                 {
-                    text: mateFailureText(turn?.failureReason ?? null),
+                    text: leadFailureText(turn?.failureReason ?? null),
                 },
             ], nowOf(options));
             return true;
         }
-        const session = store.getMateSession(turn.session);
+        const session = store.getLeadSession(turn.session);
         if (!session) {
             state.finish(event.id, true);
             return true;
         }
         await channelAccess(options, binding, session.ceilingDigest);
         const reply = store
-            .listMateMessages(turn.thread, 200)
+            .listLeadMessages(turn.thread, 200)
             .find((message) => message.turn === turn.id && message.role === "assistant")?.text ?? "The reply is no longer in the saved thread.";
         // The lead's answer about one task names it: a reply to it stays on that task.
         // Split as written, then shape each part: no cut ever lands inside a link, code or a bold anchor.
@@ -448,11 +441,11 @@ export async function processChatEvent(options) {
         const parts = (shapedParts.length > 0 ? shapedParts : splitChatText("")).map((text) => (about === null ? { text, voice: true } : { text, voice: true, task: about.task, ...(about.run === null ? {} : { run: about.run }) }));
         // The lead's question to its owner: its options as buttons, then "Something else", in their own chat (any thread);
         // in a room a tap is not their message, so the question and its options go out as text.
-        const ask = store.mateAsk(turn.id);
+        const ask = store.leadAsk(turn.id);
         if (ask !== null)
             parts.push({ ...(event.channel === binding.channel ? { text: phoneText(ask.question, 1000), ask: { turn: ask.turn, options: ask.options } } : { text: phoneText(chatAskText(ask), 1000) }),
                 ...(about === null ? {} : { task: about.task, ...(about.run === null ? {} : { run: about.run }) }) });
-        for (const image of store.listMateTurnEvidence(turn.id))
+        for (const image of store.listLeadTurnEvidence(turn.id))
             parts.push({
                 text: image.caption,
                 image: {
@@ -465,7 +458,7 @@ export async function processChatEvent(options) {
                 run: image.run,
             });
         for (const proposal of store
-            .listMateProposals(turn.thread, ["pending"])
+            .listLeadProposals(turn.thread, ["pending"])
             .filter((p) => p.turn === turn.id))
             parts.push({ text: "", proposal: proposal.id });
         state.plan(event.id, parts, nowOf(options));
@@ -565,7 +558,7 @@ export function applyChatAction(options, event, binding, repos) {
         // A flow decision's button (v88) is answered by the flow's own door.
         if (applyChatFlowTap({ store, state, label: options.label }, event, binding, token, repos, now))
             return;
-        // A teammate's question's button (v93) is answered by the question's own door.
+        // A subagent's question's button (v93) is answered by the question's own door.
         if (applyChatQuestionTap({ store, state, label: options.label }, event, binding, token, now))
             return;
         // The lead's question to its owner: the tapped option becomes their next message.
@@ -592,7 +585,7 @@ export function applyChatAction(options, event, binding, repos) {
             ], now);
             return;
         }
-        const proposal = store.getMateProposal(action.proposal);
+        const proposal = store.getLeadProposal(action.proposal);
         const verified = verifyApproverStanding(store, binding.approver, binding.generation, repos);
         if (!proposal || !verified.ok) {
             state.finish(event.id, true);
@@ -614,7 +607,7 @@ export function applyChatAction(options, event, binding, repos) {
             state.tokens(action.part, proposal.id, ["confirm", "dismiss"], now);
         }
         else if (phase === "dismiss") {
-            const dismissed = dismissMateProposal(store, verified.who, proposal.id, now);
+            const dismissed = dismissLeadProposal(store, verified.who, proposal.id, now);
             content = {
                 text: dismissed
                     ? "Dismissed."
@@ -629,7 +622,7 @@ export function applyChatAction(options, event, binding, repos) {
             state.tokens(action.part, proposal.id, ["yes", "cancel"], now);
         }
         else {
-            const outcome = confirmMateProposal(store, verified.who, proposal.id, now, {
+            const outcome = confirmLeadProposal(store, verified.who, proposal.id, now, {
                 via: options.state.provider,
                 evidenceRoot: options.evidenceRoot,
                 confirm: phase === "yes",
@@ -716,7 +709,7 @@ export async function planRoomMessages(options) {
                     parts.push({ text, channel: room.chat });
             }
             if (message.role === "assistant" && message.turn !== null)
-                for (const proposal of store.listMateProposals(row.thread, ["pending"]).filter(one => one.turn === message.turn))
+                for (const proposal of store.listLeadProposals(row.thread, ["pending"]).filter(one => one.turn === message.turn))
                     parts.push({ text: "", proposal: proposal.id, channel: room.chat });
             const id = chatHash(`${state.provider}:room:${room.id}:${message.id}`);
             const target = carrier;
@@ -998,7 +991,7 @@ function offerNotice(options, notification, binding, registry) {
                 state.plan(id, flowSendParts(store, notification, state.provider), now);
             }
             else if (notification.kind === "flow-card" && questionParts(store, notification, binding) !== null) {
-                // A teammate's question (v93): its options and "Answer in words" on the notice, for the person it asks.
+                // A subagent's question (v93): its options and "Answer in words" on the notice, for the person it asks.
                 state.enqueue({ id, installation: identity.installation, binding: binding.id, kind: "notice", channel: binding.channel, member: binding.member,
                     ts: "", thread: "", payload: {}, created: now.toISOString() });
                 state.plan(id, questionParts(store, notification, binding), now);

package/dist/chat-flow.js

@@ -5,7 +5,7 @@ import { chooseFlowCard, flowChoiceAt, flowSendPaths, flowSendTail, FLOW_CHOOSE_
 import { cleanFlowMessage, fitFlowMessage } from "./flow-items.js";
 import { renderReply } from "./reply-shape.js";
 import { deciderOf, replyTarget } from "./flows.js";
-import { MATE_MESSAGE_MAX_CHARS } from "./mate.js";
+import { LEAD_MESSAGE_MAX_CHARS } from "./lead.js";
 import { verifyApproverStanding } from "./principal.js";
 import { chatHash, partContent, savedChatPart } from "./chat-delivery-state.js";
 import { readHeldWords } from "./contracts/chat-content.js";
@@ -235,7 +235,7 @@ function replyAsNote(options, binding, said, cutShort, visit, repos, now) {
     if (said === "")
         return { ok: false, said: "Say what you'd change." };
     if (cutShort || said.length > LIMITS.note)
-        return { ok: false, said: `That's too long to take from here. Keep it to ${Math.min(LIMITS.note, MATE_MESSAGE_MAX_CHARS).toLocaleString("en-US")} characters, or reply in Toolroll.` };
+        return { ok: false, said: `That's too long to take from here. Keep it to ${Math.min(LIMITS.note, LEAD_MESSAGE_MAX_CHARS).toLocaleString("en-US")} characters, or reply in Toolroll.` };
     if (!verifyApproverStanding(store, binding.approver, binding.generation, repos).ok)
         return null;
     const chosen = chooseFlowCard(store, { card: visit.card, entry: visit.entry, choice: null, note: said, actor: binding.approver, where: options.label, repos }, now);
@@ -390,7 +390,7 @@ export function answerChatFlowPrompt(options, event, binding, input, repos, now)
         // An edit is a draft (DRAFT_LIMIT); a send-back is a note (LIMITS.note). Over it is refused with the limit, never cut.
         const cutShort = (input.originalLength ?? 0) > input.text.length;
         const most = mode === "edit" ? DRAFT_LIMIT : LIMITS.note;
-        const limit = cutShort ? Math.min(MATE_MESSAGE_MAX_CHARS, most) : most;
+        const limit = cutShort ? Math.min(LEAD_MESSAGE_MAX_CHARS, most) : most;
         if (cutShort || said.length > most) {
             say(`That's too long to take from here. Keep it to ${limit.toLocaleString("en-US")} characters, or ${mode === "edit" ? "change it" : "send it back"} in Toolroll.`);
             return true;

package/dist/chat-messages.d.ts

@@ -181,7 +181,7 @@ export declare class ChatMessages extends ChatCore {
     /**
      * Claim the oldest message that still needs a turn: queued, or running
      * under a claim that lapsed (a crash mid-turn), and not deferred past now.
-     * One at a time per bot — the mate runs one turn per approver anyway.
+     * One at a time per bot — the lead runs one turn per approver anyway.
      */
     claimMessage(botId: string, owner: string, ttlMs: number, now: Date, only?: "turns" | "replies"): TelegramConversation | null;
     /** Extend a held claim; false means it lapsed and somebody else may hold the row. */

package/dist/chat-messages.js

@@ -394,7 +394,7 @@ export class ChatMessages extends ChatCore {
     /**
      * Claim the oldest message that still needs a turn: queued, or running
      * under a claim that lapsed (a crash mid-turn), and not deferred past now.
-     * One at a time per bot — the mate runs one turn per approver anyway.
+     * One at a time per bot — the lead runs one turn per approver anyway.
      */
     claimMessage(botId, owner, ttlMs, now, only) {
         return this.store.transact(() => {
@@ -525,7 +525,7 @@ export class ChatMessages extends ChatCore {
     }
     replyParts(conversation) {
         return this
-            .prepare(`SELECT p.*, EXISTS (SELECT 1 FROM mate_proposal mp WHERE mp.id = json_extract(p.payload, '$.proposal')) AS proposal_live
+            .prepare(`SELECT p.*, EXISTS (SELECT 1 FROM lead_proposal mp WHERE mp.id = json_extract(p.payload, '$.proposal')) AS proposal_live
         FROM chat_part p WHERE p.provider = :provider AND p.event = ? ORDER BY p.ordinal`)
             .all(`m${conversation}`).map(row => readTelegramConversationPart(row, conversation));
     }
@@ -596,7 +596,7 @@ export class ChatMessages extends ChatCore {
         }));
         // Every sent part of this bot's replies on that message, oldest first: images, the lead's replies and its cards.
         const parts = chat
-            .prepare(`SELECT p.*, c.payload AS asked, EXISTS (SELECT 1 FROM mate_proposal mp WHERE mp.id = json_extract(p.payload, '$.proposal')) AS proposal_live
+            .prepare(`SELECT p.*, c.payload AS asked, EXISTS (SELECT 1 FROM lead_proposal mp WHERE mp.id = json_extract(p.payload, '$.proposal')) AS proposal_live
           FROM chat_part p JOIN chat_event c ON c.provider = p.provider AND c.id = p.event
           WHERE p.provider = :provider AND c.kind = 'message' AND c.binding = ? AND c.channel = ? AND p.message = ? AND p.state = 'sent'
           ORDER BY CAST(substr(p.event, 2) AS INTEGER), p.ordinal`)
@@ -610,7 +610,7 @@ export class ChatMessages extends ChatCore {
         // The lead's own messages: a reply from a turn that was about one task,
         // and a card, which names its task (or, once it filed one, the new task).
         const lead = parts.filter(one => one.part.kind !== "image").map(({ part, asked }) => part.kind === "card"
-            ? proposalTaskOf(part.proposal === null ? null : this.store.getMateProposal(part.proposal))
+            ? proposalTaskOf(part.proposal === null ? null : this.store.getLeadProposal(part.proposal))
             : asked.ok && asked.value.about !== undefined ? { task: asked.value.about.task, run: asked.value.about.run } : null);
         const shown = chat
             .prepare("SELECT task_id, run FROM chat_message_ref WHERE provider = :provider AND kind = 'task' AND binding = ? AND chat = ? AND message = ?")