toolroll 0.9.54 → 0.9.56

package/dist/{mate.d.ts → lead.d.ts}

@@ -1,19 +1,19 @@
-import { type MateProgress } from "./mate-progress.js";
-import type { ChatConfig, MateSession, MateThread, Store } from "./store.js";
+import { type LeadProgress } from "./lead-progress.js";
+import type { ChatConfig, LeadSession, LeadThread, 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 LeadHistoryMessage } from "./converse.js";
+import { type SubscriptionLeadRunner } from "./subscription-chat.js";
 import { type LeadChannel } from './lead-context.js';
-export declare const MATE_MESSAGE_MAX_CHARS = 2000;
+export declare const LEAD_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;
-export declare const MATE_HISTORY_MAX_MESSAGES = 40;
-export type MateTurnInput = {
+export declare const LEAD_HISTORY_CAP_BYTES = 16384;
+export declare const LEAD_HISTORY_MAX_MESSAGES = 40;
+export type LeadTurnInput = {
     store: Store;
     who: VerifiedApprover;
-    session: MateSession;
-    thread: MateThread;
+    session: LeadSession;
+    thread: LeadThread;
     /** The installation's chat configuration: provider, model, pinned price, caps. */
     config: ChatConfig;
     /** Direct API key; subscription providers use their cached harness login. */
@@ -33,11 +33,11 @@ export type MateTurnInput = {
     context?: string;
     fetcher?: typeof fetch;
     /** Injected by tests; production invokes the isolated local harness. */
-    subscriptionRunner?: SubscriptionMateRunner;
+    subscriptionRunner?: SubscriptionLeadRunner;
     /** Live progress for someone watching (chat streaming): the steps, the
      * tools in plain words, and the reply as it is written. Display only;
      * never called with text that looks like a secret. */
-    onProgress?: (event: MateProgress) => void;
+    onProgress?: (event: LeadProgress) => void;
     clock?: () => Date;
     /** Where evidence lives — get_task reads a scout's report from here. */
     evidenceRoot?: string;
@@ -62,14 +62,14 @@ export type MateTurnInput = {
         ok: true;
     } | {
         ok: false;
-        reason: MateChannelProblem;
+        reason: LeadChannelProblem;
     }>;
 };
-/** Why a chat's standing changed under a turn: each has its own plain words (MATE_CHANNEL_COPY). */
-export type MateChannelProblem = "unpaired" | "not-approver" | "projects-changed" | "projects-unreadable" | "member-changed" | "access-changed";
-export type MateRefusal = "empty-message" | "secret-in-message" | "secret-in-context" | "standing" | "unpriced" | "ceiling-changed" | "not-yours" | "thread-closed" | "latched" | "concurrent" | "daily-cap" | "session-exhausted" | "session-ended" | "over-budget" | "monthly-budget" | "policy" | "invalid-request" | "request-changed" | "channel";
-export type MateFailure = "provider-error" | "timeout" | "malformed-reply" | "secret-refused" | "latched" | "revoked" | "superseded";
-export type MateTurnOutcome = {
+/** Why a chat's standing changed under a turn: each has its own plain words (LEAD_CHANNEL_COPY). */
+export type LeadChannelProblem = "unpaired" | "not-approver" | "projects-changed" | "projects-unreadable" | "member-changed" | "access-changed";
+export type LeadRefusal = "empty-message" | "secret-in-message" | "secret-in-context" | "standing" | "unpriced" | "ceiling-changed" | "not-yours" | "thread-closed" | "latched" | "concurrent" | "daily-cap" | "session-exhausted" | "session-ended" | "over-budget" | "monthly-budget" | "policy" | "invalid-request" | "request-changed" | "channel";
+export type LeadFailure = "provider-error" | "timeout" | "malformed-reply" | "secret-refused" | "latched" | "revoked" | "superseded";
+export type LeadTurnOutcome = {
     ok: true;
     replayed?: false;
     turn: number;
@@ -85,22 +85,22 @@ export type MateTurnOutcome = {
     turn: number;
 } | {
     ok: false;
-    refused: MateRefusal;
+    refused: LeadRefusal;
     message: string;
 } | {
     ok: false;
     turn: number;
-    failed: MateFailure;
+    failed: LeadFailure;
     message: string;
     unknownSpend: boolean;
     saved?: 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>;
+export declare const LEAD_REFUSAL_COPY: Record<LeadRefusal, string>;
 /** A turn stopped because its chat's standing changed: what happened, what it means, one next step. */
-export declare const MATE_CHANNEL_COPY: Record<MateChannelProblem, string>;
+export declare const LEAD_CHANNEL_COPY: Record<LeadChannelProblem, string>;
 /** Why a reply did not finish, in the same three parts: what happened, what it means, one next step. */
-export declare const MATE_FAILURE_COPY: {
+export declare const LEAD_FAILURE_COPY: {
     readonly stopped: "This reply was stopped before it finished, from another window or by a newer message. Nothing it proposed was kept. Send your message again if you still need an answer.";
     readonly ended: "Your sign-in or this conversation ended while the lead was answering. Nothing it proposed was kept. Sign in again or start a new chat, then send your message again.";
     readonly tooLong: string;
@@ -119,12 +119,12 @@ export declare const MATE_FAILURE_COPY: {
     readonly unusable: "The lead's answer couldn't be used, so it was thrown away. Nothing was kept. Send your message again.";
 };
 /** A failed turn's saved reason as plain words, for a surface that reads the turn back later (a restart, a delivery retry). */
-export declare function mateFailureText(reason: string | null): string;
+export declare function leadFailureText(reason: string | null): string;
 /** How long a provider that ignored its abort at the turn's deadline is waited for before the turn ends without it.
  * Its process group was already killed at the deadline; this only bounds the wait for the transport to say so. */
-export declare const MATE_ABORT_GRACE_MS = 5000;
+export declare const LEAD_ABORT_GRACE_MS = 5000;
 /** 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[];
+export declare function historyFor(store: Store, thread: number, queuedMessageId?: number): LeadHistoryMessage[];
 /** "read 3 · proposed 1 · 2 steps" — counts only, never results (ruling 11). */
 export declare function activitySummary(reads: number, proposals: number, steps: number): string;
-export declare function runMateTurn(input: MateTurnInput): Promise<MateTurnOutcome>;
+export declare function runLeadTurn(input: LeadTurnInput): Promise<LeadTurnOutcome>;

package/dist/{mate.js → lead.js}

@@ -1,30 +1,30 @@
 import { Buffer } from "node:buffer";
-import { mateToolFailureReason, mateToolLabel } from "./mate-progress.js";
+import { leadToolFailureReason, leadToolLabel } from "./lead-progress.js";
 import { createHash } from "node:crypto";
-import { mateTimeoutNotice } from "./store.js";
+import { leadTimeoutNotice } from "./store.js";
 import { RESULT_IMAGES_PER_TURN_CAP } from "./chat-evidence.js";
 import { isVerifiedApprover, reproveApprover } from "./principal.js";
-import { MATE_MAX_CALLS_PER_STEP, MATE_MAX_STEPS, MATE_TOOL_RESULT_CAP_BYTES, TURN_WALL_CLOCK_MS, composeMateRequest, credentialKeyOf, isDirectChatProvider, mateWorstCaseForPrice, performMateRequest, priceForConfig, settleForPrice, subscriptionCredentialKey, } from "./converse.js";
+import { LEAD_MAX_CALLS_PER_STEP, LEAD_MAX_STEPS, LEAD_TOOL_RESULT_CAP_BYTES, TURN_WALL_CLOCK_MS, composeLeadRequest, credentialKeyOf, isDirectChatProvider, leadWorstCaseForPrice, performLeadRequest, priceForConfig, settleForPrice, subscriptionCredentialKey, } from "./converse.js";
 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, projectLabelForMate, redactForMate, toolResultBytes } from "./mate-tools.js";
-import { composeSubscriptionMatePrompt, performSubscriptionMateRequest } from "./subscription-chat.js";
+import { LEAD_CONTRACT } from "./lead-contract.js";
+import { LEAD_MAX_PROPOSALS_PER_TURN, LEAD_TOOL_SCHEMAS, executeLeadTool, isLeadTool, leadViewContextFor, projectLabelForLead, redactForLead, toolResultBytes } from "./lead-tools.js";
+import { composeSubscriptionLeadPrompt, performSubscriptionLeadRequest } from "./subscription-chat.js";
 import { LEAD_REPLY_LIMITS, leadContext } from './lead-context.js';
 import { shortenAsk } from './text-limits.js';
 import { envValue } from "./names.js";
 import { deliverableClaim, deliverableRepair, dropDeliverableClaims, replyCarriesDeliverable } from "./reply-shape.js";
-export const MATE_MESSAGE_MAX_CHARS = 2_000;
+export const LEAD_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;
+export const LEAD_HISTORY_CAP_BYTES = 16_384;
+export const LEAD_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": `That message was empty or too long, so it wasn't sent. Write 1 to ${MATE_MESSAGE_MAX_CHARS} characters and send it again.`,
+export const LEAD_REFUSAL_COPY = {
+    "empty-message": `That message was empty or too long, so it wasn't sent. Write 1 to ${LEAD_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.",
@@ -45,7 +45,7 @@ export const MATE_REFUSAL_COPY = {
     channel: "This conversation's connection changed, so the message wasn't sent. Reconnect it, then send again.",
 };
 /** A turn stopped because its chat's standing changed: what happened, what it means, one next step. */
-export const MATE_CHANNEL_COPY = {
+export const LEAD_CHANNEL_COPY = {
     unpaired: "This chat is no longer connected to your account, so the reply was stopped. Nothing it proposed was kept. Connect the chat again in Settings, then send your message again.",
     "not-approver": "Your account can no longer approve work here, so the reply was stopped. Nothing it proposed was kept. Ask an owner to restore your access, then send your message again.",
     "projects-changed": "The projects this chat can see changed while the lead was answering, so the reply was stopped. Nothing it proposed was kept. Send your message again.",
@@ -54,10 +54,10 @@ export const MATE_CHANNEL_COPY = {
     "access-changed": "This chat's access changed while the lead was answering, so the reply was stopped. Nothing it proposed was kept. Reconnect the chat, then send your message again.",
 };
 /** Why a reply did not finish, in the same three parts: what happened, what it means, one next step. */
-export const MATE_FAILURE_COPY = {
+export const LEAD_FAILURE_COPY = {
     stopped: "This reply was stopped before it finished, from another window or by a newer message. Nothing it proposed was kept. Send your message again if you still need an answer.",
     ended: "Your sign-in or this conversation ended while the lead was answering. Nothing it proposed was kept. Sign in again or start a new chat, then send your message again.",
-    tooLong: mateTimeoutNotice(false),
+    tooLong: leadTimeoutNotice(false),
     secretRead: "Something the lead read looked like a password or key, so it stopped before sending it anywhere. Nothing was kept. Remove the password or key from that task or note, then ask again.",
     secretReply: "The lead's reply contained something that looked like a password or key, so it was thrown away. Nothing was kept. Ask again, without asking for a password or key.",
     paused: "An earlier reply stopped before its cost was known, so chat is paused. This message wasn't answered. Confirm that earlier reply on the Chat page, then send again.",
@@ -66,29 +66,29 @@ export const MATE_FAILURE_COPY = {
     unreadable: "The chat provider sent back an answer that couldn't be read, so it was thrown away. Nothing was kept. Send your message again.",
     signIn: "The chat provider couldn't answer; its sign-in may have expired. Nothing was kept. Sign in to it again on this computer, then send your message again.",
     refused: "The chat provider turned the request down. Nothing was kept or charged. Try again in a minute; if it keeps happening, check the provider in Settings → Lead.",
-    tooLongUnknownCost: mateTimeoutNotice(false, true),
+    tooLongUnknownCost: leadTimeoutNotice(false, true),
     lostUnknownCost: "The chat provider stopped responding partway through, and the cost isn't known, so chat is paused. Nothing it proposed was kept. Confirm the cost on the Chat page to turn chat back on.",
     unreadableUnknownCost: "The chat provider sent back an answer that couldn't be read, and its cost isn't known, so chat is paused. Nothing it proposed was kept. Confirm the cost on the Chat page to turn chat back on.",
     empty: "The lead sent back an empty answer. Nothing was kept. Send your message again.",
     unusable: "The lead's answer couldn't be used, so it was thrown away. Nothing was kept. Send your message again.",
 };
 /** A failed turn's saved reason as plain words, for a surface that reads the turn back later (a restart, a delivery retry). */
-export function mateFailureText(reason) {
+export function leadFailureText(reason) {
     switch (reason) {
         case "timeout":
-        case "crashed": return MATE_FAILURE_COPY.tooLong;
-        case "malformed-reply": return MATE_FAILURE_COPY.unreadable;
-        case "secret-refused": return MATE_FAILURE_COPY.secretReply;
-        case "latched": return MATE_FAILURE_COPY.paused;
-        case "revoked": return MATE_FAILURE_COPY.ended;
-        case "superseded": return MATE_FAILURE_COPY.stopped;
-        case "provider-error": return MATE_FAILURE_COPY.refused;
+        case "crashed": return LEAD_FAILURE_COPY.tooLong;
+        case "malformed-reply": return LEAD_FAILURE_COPY.unreadable;
+        case "secret-refused": return LEAD_FAILURE_COPY.secretReply;
+        case "latched": return LEAD_FAILURE_COPY.paused;
+        case "revoked": return LEAD_FAILURE_COPY.ended;
+        case "superseded": return LEAD_FAILURE_COPY.stopped;
+        case "provider-error": return LEAD_FAILURE_COPY.refused;
         default: return "The lead's reply didn't finish. Nothing it proposed was kept. Send your message again.";
     }
 }
 /** How long a provider that ignored its abort at the turn's deadline is waited for before the turn ends without it.
  * Its process group was already killed at the deadline; this only bounds the wait for the transport to say so. */
-export const MATE_ABORT_GRACE_MS = 5_000;
+export const LEAD_ABORT_GRACE_MS = 5_000;
 const LATE = Symbol("late");
 /** The work's own result, or LATE once `ms` passes: the turn's clock, not the work, decides when the person hears back. */
 function settleBy(work, ms) {
@@ -99,7 +99,7 @@ function settleBy(work, ms) {
 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. */
 export function historyFor(store, thread, queuedMessageId) {
-    const rows = store.listMateMessages(thread, MATE_HISTORY_MAX_MESSAGES);
+    const rows = store.listLeadMessages(thread, LEAD_HISTORY_MAX_MESSAGES);
     const kept = [];
     let bytes = 0;
     for (let index = rows.length - 1; index >= 0; index--) {
@@ -109,9 +109,9 @@ export function historyFor(store, thread, queuedMessageId) {
         if (queuedMessageId !== undefined && (row.id === queuedMessageId || row.role === 'operator' && row.turn === null))
             continue;
         bytes += Buffer.byteLength(row.text, "utf8");
-        if (bytes > MATE_HISTORY_CAP_BYTES)
+        if (bytes > LEAD_HISTORY_CAP_BYTES)
             break;
-        const author = queuedMessageId !== undefined && row.role === 'operator' && row.turn !== null ? store.getMateTurn(row.turn)?.approver : undefined;
+        const author = queuedMessageId !== undefined && row.role === 'operator' && row.turn !== null ? store.getLeadTurn(row.turn)?.approver : undefined;
         kept.unshift(row.role === "operator" ? { role: "operator", text: author ? `From ${author}:\n${row.text}` : row.text } : { role: "assistant", text: row.text, calls: [] });
     }
     // A history must open with the operator: a leading assistant reply without its question is dropped.
@@ -126,17 +126,17 @@ export function activitySummary(reads, proposals, steps) {
 /** A tool result as the model sees it, measured as embedded; over the cap it becomes a typed refusal. */
 function capped(value) {
     const text = JSON.stringify(value);
-    if (toolResultBytes(text) <= MATE_TOOL_RESULT_CAP_BYTES)
+    if (toolResultBytes(text) <= LEAD_TOOL_RESULT_CAP_BYTES)
         return text;
     return JSON.stringify({ ok: false, message: "that result is over the size cap — ask for less: one project, one state, or a smaller limit" });
 }
-export async function runMateTurn(input) {
+export async function runLeadTurn(input) {
     const { store, who, session, thread, config } = input;
     const clock = input.clock ?? (() => new Date());
     const fetcher = input.fetcher ?? fetch;
-    const refuse = (refused) => ({ ok: false, refused, message: MATE_REFUSAL_COPY[refused] });
+    const refuse = (refused) => ({ ok: false, refused, message: LEAD_REFUSAL_COPY[refused] });
     const message = input.message.trim();
-    if (message === "" || message.length > MATE_MESSAGE_MAX_CHARS)
+    if (message === "" || message.length > LEAD_MESSAGE_MAX_CHARS)
         return refuse("empty-message");
     // Secrets refuse BEFORE any row or request exists — nothing stored, nothing sent.
     if (scanForSecrets(message).length > 0)
@@ -170,8 +170,8 @@ export async function runMateTurn(input) {
         return refuse("invalid-request");
     // Replays are read-only, but still require today's authority, not the
     // session/thread snapshots supplied by a previous browser page.
-    const liveSession = store.getMateSession(session.id);
-    const liveThread = store.getMateThread(thread.id);
+    const liveSession = store.getLeadSession(session.id);
+    const liveThread = store.getLeadThread(thread.id);
     const sharedThread = liveThread !== null && store.canUseTeamMateThread(who.name, who.generation, liveThread.id);
     if (liveSession?.approver !== who.name || (liveThread?.approver !== who.name && !sharedThread) || liveSession.credentialKey !== credentialKey)
         return refuse("not-yours");
@@ -184,28 +184,28 @@ export async function runMateTurn(input) {
     if (liveSession.ceilingDigest !== who.ceilingDigest || liveThread.ceilingDigest !== who.ceilingDigest)
         return refuse("ceiling-changed");
     const digest = createHash("sha256").update(JSON.stringify([thread.id, message, input.context ?? null])).digest("hex");
-    const receipt = request === undefined ? null : store.mateRequestReceipt(session.id, request);
+    const receipt = request === undefined ? null : store.leadRequestReceipt(session.id, request);
     if (receipt !== null)
         return receipt.digest === digest ? { ok: true, replayed: true, turn: receipt.turn } : refuse("request-changed");
     // The channel's standing, proved before anything is admitted or sent.
     if (input.revalidate !== undefined && !(await input.revalidate()).ok)
         return refuse("channel");
     let now = clock();
-    store.sweepStaleMateTurns(now);
-    const view = mateViewContextFor(store, who);
+    store.sweepStaleLeadTurns(now);
+    const view = leadViewContextFor(store, who);
     // 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),
+    const document = leadContext(store, who.repos, now, { owner: who.name, thread: thread.id, redact: text => redactForLead(text, view),
+        projectName: (path, index) => projectLabelForLead(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 historyMessage = input.context === undefined ? authoredMessage : `${redactForLead(input.context, view)}\n\n${authoredMessage}`;
     const history = [...historyFor(store, thread.id, input.queuedMessageId), { role: "operator", text: historyMessage }];
     const composeDirect = (key) => {
         if (!direct)
             throw new Error("not a direct chat provider");
-        return composeMateRequest({ provider: directProvider, model: config.model, key, system: MATE_CONTRACT, dataDocument: document, history, tools: MATE_TOOL_SCHEMAS });
+        return composeLeadRequest({ provider: directProvider, model: config.model, key, system: LEAD_CONTRACT, dataDocument: document, history, tools: LEAD_TOOL_SCHEMAS });
     };
-    const composeSubscription = () => composeSubscriptionMatePrompt({ system: MATE_CONTRACT, dataDocument: document, history, tools: MATE_TOOL_SCHEMAS });
+    const composeSubscription = () => composeSubscriptionLeadPrompt({ system: LEAD_CONTRACT, dataDocument: document, history, tools: LEAD_TOOL_SCHEMAS });
     // The exact outbound base is scanned whole. Only direct API traffic needs
     // a worst-case dollar reservation; subscription traffic records zero.
     const base = direct ? composeDirect("").body : composeSubscription();
@@ -214,9 +214,9 @@ export async function runMateTurn(input) {
     // Fit the bounded tool loop to the already-authorized remaining allowance.
     // Context/history growth must not demand a larger budget for a simple reply.
     // Each chosen step retains the same worst-case call/output accounting.
-    let maxSteps = MATE_MAX_STEPS;
+    let maxSteps = LEAD_MAX_STEPS;
     const baseBytes = Buffer.byteLength(base, "utf8");
-    const reserveFor = (steps) => direct ? mateWorstCaseForPrice(price, baseBytes, { steps }) : 0;
+    const reserveFor = (steps) => direct ? leadWorstCaseForPrice(price, baseBytes, { steps }) : 0;
     if (direct) {
         const remaining = Math.min(liveSession.ceilingMicrousd - liveSession.spentMicrousd, config.weeklyCeilingMicrousd - store.chatWeeklySpendMicrousd(credentialKey, now));
         while (maxSteps > 1 && reserveFor(maxSteps) > remaining)
@@ -224,12 +224,12 @@ export async function runMateTurn(input) {
     }
     const reserved = reserveFor(maxSteps);
     const admitted = store.transact(() => {
-        const existing = request === undefined ? null : store.mateRequestReceipt(session.id, request);
+        const existing = request === undefined ? null : store.leadRequestReceipt(session.id, request);
         if (existing !== null)
             return existing.digest === digest
                 ? { ok: true, replayed: true, turnId: existing.turn }
                 : { ok: false, reason: "request-changed" };
-        const opened = store.openMateTurn({
+        const opened = store.openLeadTurn({
             approver: who.name,
             session: session.id,
             thread: thread.id,
@@ -243,13 +243,13 @@ export async function runMateTurn(input) {
         if (!opened.ok)
             return opened;
         const turnId = opened.id;
-        const started = store.startMateTurn(turnId, now);
+        const started = store.startLeadTurn(turnId, now);
         if (!started.ok)
-            throw new Error("new mate turn could not start");
+            throw new Error("new lead turn could not start");
         if (input.queuedMessageId === undefined)
-            store.appendMateMessage({ thread: thread.id, turn: turnId, role: "operator", text: message }, now);
+            store.appendLeadMessage({ thread: thread.id, turn: turnId, role: "operator", text: message }, now);
         else {
-            const bound = store.handle.prepare("UPDATE mate_message SET turn=? WHERE id=? AND thread=? AND role='operator' AND turn IS NULL AND text=?")
+            const bound = store.handle.prepare("UPDATE lead_message SET turn=? WHERE id=? AND thread=? AND role='operator' AND turn IS NULL AND text=?")
                 .run(turnId, input.queuedMessageId, thread.id, message);
             if (Number(bound.changes) !== 1)
                 throw new Error('The queued message changed before admission.');
@@ -279,63 +279,63 @@ export async function runMateTurn(input) {
     const searchedMemory = new Map();
     const checkedCapabilities = 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());
+    const ask = (question, options) => store.recordLeadAsk({ turn: turnId, thread: thread.id, question, options }, clock());
     let tokensIn = 0;
     let tokensOut = 0;
     let settled = 0;
     const draft = (kind, payload) => {
-        if (proposals >= MATE_MAX_PROPOSALS_PER_TURN)
+        if (proposals >= LEAD_MAX_PROPOSALS_PER_TURN)
             return null;
         proposals++;
-        return store.draftMateProposal({ thread: thread.id, turn: turnId, kind, payload, ceilingDigest: who.ceilingDigest }, clock());
+        return store.draftLeadProposal({ thread: thread.id, turn: turnId, kind, payload, ceilingDigest: who.ceilingDigest }, clock());
     };
     /** The screenshots a tool selected, kept under THIS turn: a failed turn deletes them with its drafts; a channel plans sends only from an answered turn. */
     const selectEvidence = (rows) => {
-        store.recordMateTurnEvidence(turnId, rows, RESULT_IMAGES_PER_TURN_CAP, clock());
-        if (store.getMateTurn(turnId)?.state !== "running")
+        store.recordLeadTurnEvidence(turnId, rows, RESULT_IMAGES_PER_TURN_CAP, clock());
+        if (store.getLeadTurn(turnId)?.state !== "running")
             return [];
-        return store.listMateTurnEvidence(turnId).map(one => one.artifact);
+        return store.listLeadTurnEvidence(turnId).map(one => one.artifact);
     };
     /** The turn ends failed: its drafts are deleted, its cost settled — the whole reservation when any of it is unknown. */
     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);
+        store.finalizeLeadTurn(turnId, started.generation, { state: "failed", settledMicrousd: settled, unknownSpend, tokensIn, tokensOut, failureReason: failed }, now);
+        store.dropLeadAsk(turnId);
         return { ok: false, turn: turnId, failed, message, unknownSpend };
     };
     /** The turn stopped at its deadline: the notice is saved in the thread with whatever its completed tool calls proposed, in
      * the same write that ends the turn, so a refresh, another device or a restart shows the same outcome. */
     const timedOut = (unknownSpend) => {
         now = clock();
-        const message = mateTimeoutNotice(proposals > 0, unknownSpend);
-        const saved = store.finalizeMateTurn(turnId, started.generation, { state: "failed", settledMicrousd: settled, unknownSpend, tokensIn, tokensOut, failureReason: "timeout", keepProposals: true, message: { text: message, activity: activitySummary(reads, proposals, steps) } }, now);
-        store.dropMateAsk(turnId);
+        const message = leadTimeoutNotice(proposals > 0, unknownSpend);
+        const saved = store.finalizeLeadTurn(turnId, started.generation, { state: "failed", settledMicrousd: settled, unknownSpend, tokensIn, tokensOut, failureReason: "timeout", keepProposals: true, message: { text: message, activity: activitySummary(reads, proposals, steps) } }, now);
+        store.dropLeadAsk(turnId);
         if (!saved)
-            return { ok: false, turn: turnId, failed: "superseded", message: MATE_FAILURE_COPY.stopped, unknownSpend: false };
+            return { ok: false, turn: turnId, failed: "superseded", message: LEAD_FAILURE_COPY.stopped, unknownSpend: false };
         return { ok: false, turn: turnId, failed: "timeout", message, unknownSpend, saved: true };
     };
     const deadlineLeft = () => TURN_WALL_CLOCK_MS - (clock().getTime() - turnStartedAt);
     /** The channel's standing, bounded by the turn's deadline: a lookup that never answers cannot hold the turn open. */
-    const revalidated = async () => input.revalidate === undefined ? { ok: true } : settleBy(input.revalidate(), deadlineLeft() + MATE_ABORT_GRACE_MS);
+    const revalidated = async () => input.revalidate === undefined ? { ok: true } : settleBy(input.revalidate(), deadlineLeft() + LEAD_ABORT_GRACE_MS);
     /** The turn's own row, re-read: still running under our generation, or someone ended it under us. */
     const stillOurs = () => {
-        const row = store.getMateTurn(turnId);
+        const row = store.getLeadTurn(turnId);
         return row !== null && row.state === "running" && row.generation === started.generation;
     };
     // The channel lookup can await external state. Re-read all local authority
     // AFTER it resolves, immediately before sending context or using a tool.
     const guard = (channel) => {
         if (!stillOurs())
-            return { ok: false, turn: turnId, failed: "superseded", message: MATE_FAILURE_COPY.stopped, unknownSpend: false };
+            return { ok: false, turn: turnId, failed: "superseded", message: LEAD_FAILURE_COPY.stopped, unknownSpend: false };
         if (channel === LATE)
             return timedOut(false);
         if (!channel.ok)
-            return fail("revoked", MATE_CHANNEL_COPY[channel.reason] ?? MATE_CHANNEL_COPY["access-changed"], false);
+            return fail("revoked", LEAD_CHANNEL_COPY[channel.reason] ?? LEAD_CHANNEL_COPY["access-changed"], false);
         const standing = reproveApprover(store, who);
-        const liveSession = store.getMateSession(session.id);
-        const liveThread = store.getMateThread(thread.id);
+        const liveSession = store.getLeadSession(session.id);
+        const liveThread = store.getLeadThread(thread.id);
         if (!standing.ok || liveSession === null || liveSession.endedAt !== null || liveThread === null || liveThread.closedAt !== null) {
-            return fail("revoked", MATE_FAILURE_COPY.ended, false);
+            return fail("revoked", LEAD_FAILURE_COPY.ended, false);
         }
         return null;
     };
@@ -351,7 +351,7 @@ export async function runMateTurn(input) {
     const replyLimit = input.channel === undefined ? null : LEAD_REPLY_LIMITS[input.channel];
     const unbacked = (text) => {
         const claim = deliverableClaim(text);
-        if (claim === null || shownControl || replyCarriesDeliverable(text) || store.listMateTurnEvidence(turnId).length > 0)
+        if (claim === null || shownControl || replyCarriesDeliverable(text) || store.listLeadTurnEvidence(turnId).length > 0)
             return null;
         return claim;
     };
@@ -367,42 +367,42 @@ export async function runMateTurn(input) {
         // Tool results join the outbound body: scanned again before every dispatch.
         const outbound = typeof request === "string" ? request : request.body;
         if (scanForSecrets(outbound).length > 0) {
-            return fail("secret-refused", MATE_FAILURE_COPY.secretRead, false);
+            return fail("secret-refused", LEAD_FAILURE_COPY.secretRead, false);
         }
-        const step = store.openMateStep({ mateTurn: turnId, generation: started.generation, approver: who.name, credentialKey, provider: config.provider, model: config.model, deadlineMs: remainingMs + 10_000 }, now);
+        const step = store.openLeadStep({ leadTurn: 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", MATE_FAILURE_COPY.paused, false);
-            return { ok: false, turn: turnId, failed: "superseded", message: MATE_FAILURE_COPY.stopped, unknownSpend: false };
+                return fail("latched", LEAD_FAILURE_COPY.paused, false);
+            return { ok: false, turn: turnId, failed: "superseded", message: LEAD_FAILURE_COPY.stopped, unknownSpend: false };
         }
         const stepStarted = store.startChatTurn(step.id, now);
         if (!stepStarted.ok)
-            return fail("provider-error", MATE_FAILURE_COPY.notStarted, false);
+            return fail("provider-error", LEAD_FAILURE_COPY.notStarted, false);
         steps++;
         progress({ kind: "step", turn: turnId, step: steps });
         const requestBytes = Buffer.byteLength(outbound, "utf8");
         let result;
         // The turn owns its deadline (lead-stall, release check 2438): at the deadline the request is aborted, which ends a
-        // harness's whole process group, and a provider that still has not settled MATE_ABORT_GRACE_MS later is left behind.
+        // harness's whole process group, and a provider that still has not settled LEAD_ABORT_GRACE_MS later is left behind.
         // Whatever it says after that is never read; the turn has already ended with its notice.
         const controller = new AbortController();
         const abortAt = setTimeout(() => controller.abort(), remainingMs);
-        const settle = (work) => settleBy(work, remainingMs + MATE_ABORT_GRACE_MS)
+        const settle = (work) => settleBy(work, remainingMs + LEAD_ABORT_GRACE_MS)
             .then(value => value === LATE || controller.signal.aborted ? { ok: false, problem: "timeout" } : value)
             .finally(() => clearTimeout(abortAt));
         if (direct) {
-            result = await settle(performMateRequest(request, directProvider, controller.signal, fetcher)
+            result = await settle(performLeadRequest(request, directProvider, controller.signal, fetcher)
                 .catch(() => ({ ok: false, problem: "network" })));
         }
         else {
-            const runner = input.subscriptionRunner ?? performSubscriptionMateRequest;
+            const runner = input.subscriptionRunner ?? performSubscriptionLeadRequest;
             result = await settle((async () => runner({
                 provider: subscriptionProvider,
                 model: config.model,
-                system: MATE_CONTRACT,
+                system: LEAD_CONTRACT,
                 dataDocument: document,
                 history,
-                tools: MATE_TOOL_SCHEMAS,
+                tools: LEAD_TOOL_SCHEMAS,
                 timeoutMs: remainingMs,
                 signal: controller.signal,
                 // The reply as it is written; text that looks like a secret is
@@ -417,12 +417,12 @@ export async function runMateTurn(input) {
             if (!direct) {
                 finishStep({ state: "failed", failureReason: result.problem === "timeout" ? "timeout" : result.problem === "malformed-reply" ? "malformed-reply" : "provider-error", settledMicrousd: 0 });
                 const message = result.problem === "not-found"
-                    ? MATE_FAILURE_COPY.notInstalled
+                    ? LEAD_FAILURE_COPY.notInstalled
                     : result.problem === "timeout"
-                        ? MATE_FAILURE_COPY.tooLong
+                        ? LEAD_FAILURE_COPY.tooLong
                         : result.problem === "malformed-reply"
-                            ? MATE_FAILURE_COPY.unreadable
-                            : MATE_FAILURE_COPY.signIn;
+                            ? LEAD_FAILURE_COPY.unreadable
+                            : LEAD_FAILURE_COPY.signIn;
                 if (result.problem === "timeout")
                     return timedOut(false);
                 return fail(result.problem === "malformed-reply" ? "malformed-reply" : "provider-error", message, false);
@@ -430,7 +430,7 @@ export async function runMateTurn(input) {
             if (result.problem.startsWith("status-")) {
                 // The provider ANSWERED with an error: nothing billed for this step.
                 finishStep({ state: "failed", failureReason: "provider-error", settledMicrousd: 0 });
-                return fail("provider-error", MATE_FAILURE_COPY.refused, false);
+                return fail("provider-error", LEAD_FAILURE_COPY.refused, false);
             }
             if (result.problem === "timeout") {
                 finishStep({ state: "failed", failureReason: "timeout", settledMicrousd: null, unknownSpend: true });
@@ -438,17 +438,17 @@ export async function runMateTurn(input) {
             }
             if (result.problem === "network") {
                 finishStep({ state: "failed", failureReason: "provider-error", settledMicrousd: null, unknownSpend: true });
-                return fail("provider-error", MATE_FAILURE_COPY.lostUnknownCost, true);
+                return fail("provider-error", LEAD_FAILURE_COPY.lostUnknownCost, true);
             }
             finishStep({ state: "failed", failureReason: "malformed-reply", settledMicrousd: null, unknownSpend: true });
-            return fail("malformed-reply", MATE_FAILURE_COPY.unreadableUnknownCost, true);
+            return fail("malformed-reply", LEAD_FAILURE_COPY.unreadableUnknownCost, true);
         }
         const answer = result.answer;
         // Usage that cannot be true — more input tokens than bytes sent — is a
         // malformed reply with unknown cost, never a number to settle by.
         if (direct && answer.tokensIn > requestBytes) {
             finishStep({ state: "failed", failureReason: "malformed-reply", settledMicrousd: null, unknownSpend: true });
-            return fail("malformed-reply", MATE_FAILURE_COPY.unreadableUnknownCost, true);
+            return fail("malformed-reply", LEAD_FAILURE_COPY.unreadableUnknownCost, true);
         }
         // The pinned math, or the provider's own reported charge when HIGHER.
         const stepSettled = direct
@@ -467,7 +467,7 @@ export async function runMateTurn(input) {
             return changed;
         if (answer.calls.length === 0) {
             if (answer.text.trim() === "")
-                return fail("malformed-reply", MATE_FAILURE_COPY.empty, false);
+                return fail("malformed-reply", LEAD_FAILURE_COPY.empty, false);
             // "Here's the screenshot" with nothing attached or linked: one repair step to attach it or drop the claim; never the claim alone.
             const claim = unbacked(answer.text);
             if (claim !== null && !repaired && steps < maxSteps) {
@@ -486,11 +486,11 @@ export async function runMateTurn(input) {
             reply = candidate;
             break;
         }
-        if (answer.calls.length > MATE_MAX_CALLS_PER_STEP)
-            return fail("malformed-reply", MATE_FAILURE_COPY.unusable, false);
+        if (answer.calls.length > LEAD_MAX_CALLS_PER_STEP)
+            return fail("malformed-reply", LEAD_FAILURE_COPY.unusable, false);
         for (const call of answer.calls) {
-            if (!isMateTool(call.name))
-                return fail("malformed-reply", MATE_FAILURE_COPY.unusable, false);
+            if (!isLeadTool(call.name))
+                return fail("malformed-reply", LEAD_FAILURE_COPY.unusable, false);
         }
         history.push({ role: "assistant", text: answer.text, calls: answer.calls });
         for (const [index, call] of answer.calls.entries()) {
@@ -501,13 +501,13 @@ export async function runMateTurn(input) {
             }
             // Position within this turn is unique even if a provider reuses call ids.
             const progressId = `${turnId}:${steps}:${index}`;
-            progress({ kind: "tool", turn: turnId, step: steps, id: progressId, label: mateToolLabel(call.name) });
-            const outcome = executeMateTool({ store, who, now: clock(), draft, selectEvidence, step: steps, readDecisions, readResults, searchedMemory, checkedCapabilities, 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);
+            progress({ kind: "tool", turn: turnId, step: steps, id: progressId, label: leadToolLabel(call.name) });
+            const outcome = executeLeadTool({ store, who, now: clock(), draft, selectEvidence, step: steps, readDecisions, readResults, searchedMemory, checkedCapabilities, 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);
             let displayOutcome = { state: "succeeded" };
             if (!outcome.ok) {
-                const reason = mateToolFailureReason(call.name, outcome.message);
+                const reason = leadToolFailureReason(call.name, outcome.message);
                 displayOutcome = { state: "failed", reason: scanForSecrets(reason).length === 0
-                        ? reason : `That step didn't work (${mateToolLabel(call.name)}).` };
+                        ? reason : `That step didn't work (${leadToolLabel(call.name)}).` };
             }
             progress({ kind: "tool-result", turn: turnId, step: steps, id: progressId, outcome: displayOutcome });
             if (READ_TOOLS.has(call.name))
@@ -516,7 +516,7 @@ export async function runMateTurn(input) {
                 shownControl = true;
             // Opt-in, local diagnostics for end-to-end runs: what the lead asked of each tool and what came back (its start), keys
             // blanked. Each line stays whole JSON so a run can assert on what a tool returned rather than on the model's words.
-            if (envValue(process.env, "MATE_TRACE") === "1") {
+            if (envValue(process.env, "LEAD_TRACE") === "1" || envValue(process.env, "MATE_TRACE") === "1") { // MATE_TRACE: the name before D5
                 const blanked = (_, value) => typeof value === "string" ? redactSecretAssignments(redactSecretLines(value, scanForSecrets(value))) : value;
                 const args = JSON.stringify(call.args, blanked).slice(0, 1500);
                 const result = JSON.stringify(outcome.ok ? outcome.body : null, blanked)?.slice(0, 2000) ?? null;
@@ -528,16 +528,16 @@ export async function runMateTurn(input) {
     if (reply === null) {
         stoppedAtCap = true;
         const last = lastText.trim() === "" || unbacked(lastText) === null ? lastText.trim() : dropDeliverableClaims(lastText);
-        reply = `${last === "" ? "" : `${last}\n\n`}(I stopped here: this answer needed more steps than ${maxSteps < MATE_MAX_STEPS ? "this conversation's remaining spending allows" : "one reply allows"}. Ask me to carry on.)`;
+        reply = `${last === "" ? "" : `${last}\n\n`}(I stopped here: this answer needed more steps than ${maxSteps < LEAD_MAX_STEPS ? "this conversation's remaining spending allows" : "one reply allows"}. Ask me to carry on.)`;
     }
     // Ruling 11: model text is scanned before it becomes durable.
     if (scanForSecrets(reply).length > 0)
-        return fail("secret-refused", MATE_FAILURE_COPY.secretReply, false);
+        return fail("secret-refused", LEAD_FAILURE_COPY.secretReply, false);
     now = clock();
     const activity = activitySummary(reads, proposals, steps);
     // One write (finding 12): settle, debit, promote the drafts, append the assistant text.
-    const finalized = store.finalizeMateTurn(turnId, started.generation, { state: "answered", settledMicrousd: settled, tokensIn, tokensOut, message: { text: reply, activity } }, now);
+    const finalized = store.finalizeLeadTurn(turnId, started.generation, { state: "answered", settledMicrousd: settled, tokensIn, tokensOut, message: { text: reply, activity } }, now);
     if (!finalized)
-        return { ok: false, turn: turnId, failed: "superseded", message: MATE_FAILURE_COPY.stopped, unknownSpend: false };
+        return { ok: false, turn: turnId, failed: "superseded", message: LEAD_FAILURE_COPY.stopped, unknownSpend: false };
     return { ok: true, turn: turnId, reply, activity, proposals, steps, stoppedAtCap, settledMicrousd: settled };
 }