toolroll 0.9.55 → 0.9.57

package/dist/guides.js

@@ -318,7 +318,7 @@ ${AUTHORITY_LINE}
   transcripts following.
 - **projects** (\`/projects\`): enrol, open, or switch repositories; the
   project name in the header is the one-tap switcher on every screen.
-- **chat** (\`/chat\`): the mate — a conversation across every project
+- **chat** (\`/chat\`): the lead — a conversation across every project
   that only PROPOSES (file, reorder, reserve, hold, rewrite a scope,
   cancel, answer a decision); each proposal is a card the person
   confirms. Coordinators over the MCP gateway propose the same way, and
@@ -340,7 +340,7 @@ ${AUTHORITY_LINE}
 - \`toolroll peek\`: one pane per live agent (digits focus, \`q\`
   leaves); \`peek <run>\` follows one; \`peek --tmux\` opens a tmux window
   per run.
-- \`toolroll chat\`: the mate in the terminal (\`--say "…"\` for one
+- \`toolroll chat\`: the lead in the terminal (\`--say "…"\` for one
   turn); \`toolroll proposals\` lists and confirms coordinator
   proposals.
 - \`toolroll task add "<title>" --report\`: a SCOUT task — a
@@ -359,7 +359,8 @@ needs you · queued · waiting · building · done · failed; a *scope* is the
 contract a person approves; a *decision* is a typed question an agent
 parked; a *hold* pauses the next attempt; a *stale approval* means the
 approval no longer matches how builds are routed — approving again fixes
-it; a *scout* delivers a report; the *mate* proposes and never acts.
+it; a *scout* delivers a report; the *lead* proposes and never acts, and
+its *subagents* work within the rules you write for them.
 `,
 };
 const knowledge = {

package/dist/invoke.js

@@ -353,7 +353,7 @@ export async function invokeAgent(store, runId, spec, invocation, options) {
     const evidence = spec.provider === "claude" ? claudeBillingFrom(billingSeen)
         // Codex signed in with ChatGPT is its plan, unless its plan is itself billed by use (seen by the console's probe).
         : codexLogin === "subscription" ? seenBilling(store.handle, "codex") ?? "subscription" : codexLogin;
-    // What this computer's Claude does with no key from us (teammates and drafts bill the same way): learnt only from a
+    // What this computer's Claude does with no key from us (subagents and drafts bill the same way): learnt only from a
     // run we gave no key that got as far as an answer.
     if (spec.provider === "claude" && managedKey === null && authMode === "subscription" && billingSeen.answered && evidence !== null) {
         store.recordProviderBilling("claude", evidence, new Date());

package/dist/kits-ui.js

@@ -1,5 +1,5 @@
 import { kitChecklist, kitInstalled, KITS } from "./kits.js";
-import { TEAMMATE_TEMPLATES } from "./teammates.js";
+import { SUBAGENT_TEMPLATES } from "./subagents.js";
 import { html, postForm } from "./html.js";
 const CHECK = html `<svg viewBox="0 0 24 24" aria-hidden="true"><path d="M20 6 9 17l-5-5"/></svg>`;
 const RING = html `<svg viewBox="0 0 24 24" aria-hidden="true"><circle cx="12" cy="12" r="8"/></svg>`;
@@ -12,21 +12,21 @@ export const KITS_CSS = `.kits{max-width:960px;min-width:0}.kits-lede{color:var(
     `.kit-steps .kit-step-said{flex:1;min-width:0}.kit-steps li[data-done="true"] .kit-step-said{color:var(--so-muted)}.kit-steps form{margin:0}.kit-steps button,.kit-steps .kit-step-go{min-height:40px;white-space:nowrap}` +
     `.kit-steps .kit-step-go{display:inline-flex;align-items:center;padding:0 12px;border:1px solid var(--so-line);border-radius:8px;text-decoration:none;font-size:.9rem}` +
     `@media(max-width:600px){.kit-steps li{flex-wrap:wrap}.kit-steps .kit-step-said{flex-basis:calc(100% - 40px)}.kit form select{font-size:16px}}`;
-const teammateWords = (kit) => { const template = TEAMMATE_TEMPLATES.find(one => one.id === kit.teammate.template); return template === undefined ? kit.teammate.handle : template.label.toLowerCase(); };
+const subagentWords = (kit) => { const template = SUBAGENT_TEMPLATES.find(one => one.id === kit.subagent.template); return template === undefined ? kit.subagent.handle : template.label.toLowerCase(); };
 /** The gallery: every kit, set up in a project with one button (or opened, when it's already there). */
 export function kitsGalleryHtml(store, projects, projectName, canSetUp, notice) {
     const cards = KITS.map(kit => {
         const here = projects.filter(repo => kitInstalled(store, kit, repo) !== null);
         const open = projects.length === 1 && here.length === 1;
-        const name = kit.teammate.handle.charAt(0).toUpperCase() + kit.teammate.handle.slice(1);
-        const gets = `${name} (${teammateWords(kit)}) · the ${kit.flowName} flow${kit.tools.length === 0 ? "" : ` · works with ${kit.tools.map(one => one.label).join(" and ")}`}`;
+        const name = kit.subagent.handle.charAt(0).toUpperCase() + kit.subagent.handle.slice(1);
+        const gets = `${name} (${subagentWords(kit)}) · the ${kit.flowName} flow${kit.tools.length === 0 ? "" : ` · works with ${kit.tools.map(one => one.label).join(" and ")}`}`;
         const action = open ? html `<a class="kit-open" href="/kits/${kit.id}?repo=${encodeURIComponent(projects[0])}">Open ${kit.name} →</a>`
             : !canSetUp || projects.length === 0 ? ""
                 : postForm(`/kits/${kit.id}/setup`, html `${projects.length === 1 ? ""
                     : html `<label>Project<select name="repo">${projects.map(repo => html `<option value="${repo}">${projectName(repo)}${here.includes(repo) ? " (set up)" : ""}</option>`)}</select></label>`}<button>Set it up</button>`, { hidden: { repo: projects.length === 1 ? projects[0] : null } });
         return html `<article class="kit" data-kit="${kit.id}"><h2>${kit.name}</h2><p class="kit-promise">${kit.promise}</p><p class="kit-gets">${gets}</p>${action}</article>`;
     });
-    return html `<section class="kits">${notice.problem ? html `<p class="problem" role="alert">${notice.problem}</p>` : ""}<p class="kits-lede">A working setup in one click: an AI teammate, the flow it works, and what to connect next. Nothing goes out without you approving it.</p><div class="kit-grid">${cards}</div></section>`;
+    return html `<section class="kits">${notice.problem ? html `<p class="problem" role="alert">${notice.problem}</p>` : ""}<p class="kits-lede">A working setup in one click: a subagent, the flow it works, and what to connect next. Nothing goes out without you approving it.</p><div class="kit-grid">${cards}</div></section>`;
 }
 /** A kit's own page: what's set up, and the next step on each line. */
 export function kitPageHtml(store, kit, repo, dir, canSetUp, notice) {

package/dist/kits.d.ts

@@ -1,7 +1,7 @@
 import { type FlowStepInput } from "./flows.js";
-import type { FlowRow, Store, TeammateRow } from "./store.js";
-import { type ToolIo } from "./teammate-tools.js";
-/** A tool a kit's teammate works better with: the catalog entry that connects it, and why. */
+import type { FlowRow, Store, SubagentRow } from "./store.js";
+import { type ToolIo } from "./subagent-tools.js";
+/** A tool a kit's subagent works better with: the catalog entry that connects it, and why. */
 export type KitTool = {
     tool: string;
     label: string;
@@ -11,8 +11,8 @@ export type Kit = {
     id: string;
     name: string;
     promise: string;
-    /** The teammate it hires: a template, and the name it starts with. */
-    teammate: {
+    /** The subagent it hires: a template, and the name it starts with. */
+    subagent: {
         template: string;
         handle: string;
     };
@@ -38,23 +38,23 @@ type Done = {
     ok: true;
     said: string;
     flow: number;
-    teammate: number;
+    subagent: number;
 } | {
     ok: false;
     said: string;
 };
-/** A kit set up in a project: its flow (by name) and its teammate, when both are there. */
+/** A kit set up in a project: its flow (by name) and its subagent, when both are there. */
 export declare function kitInstalled(store: Store, kit: Kit, repo: string): {
     flow: FlowRow;
-    mate: TeammateRow;
+    mate: SubagentRow;
 } | null;
 /**
- * Set a kit up: its teammate (kept if one of that name is already there), its
- * flow, and its button triggers; then its teammate may use whichever of the
+ * Set a kit up: its subagent (kept if one of that name is already there), its
+ * flow, and its button triggers; then its subagent may use whichever of the
  * kit's tools the project already has (reading free, writing asking first).
  */
 export declare function setUpKit(store: Store, kit: Kit, repo: string, by: string, now: Date, dir: string | null, io?: ToolIo): Promise<Done>;
-/** The same, all at once (a chat confirmation can't wait on a tool): its teammate is given the kit's connected tools by the names their last test found, and each is listed properly on its first turn. */
+/** The same, all at once (a chat confirmation can't wait on a tool): its subagent is given the kit's connected tools by the names their last test found, and each is listed properly on its first turn. */
 export declare function setUpKitNow(store: Store, kit: Kit, repo: string, by: string, now: Date, dir: string | null, grantByName?: boolean): Done;
 /** One line of a kit's checklist: done, or the next step with where to take it. */
 export type KitStep = {
@@ -67,7 +67,7 @@ export type KitStep = {
 };
 /** What's set up and what's left, read fresh each time. */
 export declare function kitChecklist(store: Store, kit: Kit, repo: string, dir: string | null): KitStep[];
-/** A sample card in the kit's first zone, so its teammate starts on it at once. */
+/** A sample card in the kit's first zone, so its subagent starts on it at once. */
 export declare function addKitSample(store: Store, kit: Kit, repo: string, by: string, now: Date): {
     ok: true;
     href: string;

package/dist/kits.js

@@ -1,8 +1,8 @@
 /**
- * Starter kits: a working setup in one click — an AI teammate, the flow
+ * Starter kits: a working setup in one click — a subagent, the flow
  * it works, and the triggers that are safe to add straight away — plus a
  * checklist of what's left (connect email, connect a tool) and a sample card
- * that shows the teammate at work within seconds.
+ * that shows the subagent at work within seconds.
  *
  * A kit adds nothing a person couldn't add by hand, and nothing that acts
  * outside: replies go out only after you approve them, a code change is filed
@@ -16,17 +16,17 @@ import { googleConnected } from "./google-mail.js";
 import { readEmailSettings } from "./email-settings.js";
 import { mailboxReady } from "./mailbox.js";
 import { projectToolsOf } from "./project-tools.js";
-import { createTeammateFrom, nameOf } from "./teammate-admin.js";
-import { grantListed, grantTool } from "./teammate-tools.js";
-import { TEAMMATE_TEMPLATES } from "./teammates.js";
+import { createSubagentFrom, nameOf } from "./subagent-admin.js";
+import { grantListed, grantTool } from "./subagent-tools.js";
+import { SUBAGENT_TEMPLATES } from "./subagents.js";
 export const KITS = [
     {
         id: "support-desk", name: "Support desk",
         promise: "Maya answers customer emails, looks orders up and refunds within limits you set. You approve each reply before it goes out.",
-        teammate: { template: "support", handle: "maya" },
+        subagent: { template: "support", handle: "maya" },
         flowName: "Support desk",
         steps: [
-            { id: "answer", title: "Maya answers", kind: "teammate", teammate: "maya",
+            { id: "answer", title: "Maya answers", kind: "subagent", subagent: "maya",
                 instructions: "Read the customer's message. Look things up (and refund, within your rules) with your tools when it helps. Write the reply we'd send in \"text\". Pick Reply when it's ready for the customer, or Needs a person when your rules say to ask first or you can't help.",
                 routes: [{ answer: "Reply", goesTo: "You check the reply" }, { answer: "Needs a person", goesTo: "For you" }], ifFails: "For you" },
             { id: "check", title: "You check the reply", kind: "approval", decider: "owner", next: "Send it", ifFails: "Maya answers" },
@@ -44,10 +44,10 @@ export const KITS = [
     {
         id: "bug-triage", name: "Bug triage",
         promise: "Theo reads every new issue, says what it is and how urgent, answers questions, and turns real bugs into fixes you approve.",
-        teammate: { template: "triage", handle: "theo" },
+        subagent: { template: "triage", handle: "theo" },
         flowName: "Bug triage",
         steps: [
-            { id: "sort", title: "Theo sorts it", kind: "teammate", teammate: "theo",
+            { id: "sort", title: "Theo sorts it", kind: "subagent", subagent: "theo",
                 instructions: "Read the report. In \"text\", say in one or two sentences what it is and how urgent (for a bug, add what you'd check first; for a question, write the answer). Pick Bug for something broken in this project's code, Question for someone asking how something works, or Duplicate or noise for anything else, saying why.",
                 routes: [{ answer: "Bug", goesTo: "Fix it" }, { answer: "Question", goesTo: "Answered" }, { answer: "Duplicate or noise", goesTo: "Closed" }], ifFails: "For you" },
             { id: "fix", title: "Fix it", kind: "task", planning: "auto", instructions: "Fix the bug this card reports. Theo's notes on it: {{stage.sort}}", next: "You review the fix" },
@@ -67,10 +67,10 @@ export const KITS = [
     {
         id: "sales-follow-up", name: "Sales follow-up",
         promise: "Leo writes back to every new lead within minutes, you approve the email, and it waits for their answer, so no lead goes cold.",
-        teammate: { template: "sales", handle: "leo" },
+        subagent: { template: "sales", handle: "leo" },
         flowName: "Sales follow-up",
         steps: [
-            { id: "write", title: "Leo writes back", kind: "teammate", teammate: "leo",
+            { id: "write", title: "Leo writes back", kind: "subagent", subagent: "leo",
                 instructions: "Read the lead. In \"text\", write a short, friendly first reply that answers what they asked and suggests one clear next step. Pick Write back, or Not a fit (say why).",
                 routes: [{ answer: "Write back", goesTo: "You check it" }, { answer: "Not a fit", goesTo: "Not a fit" }], ifFails: "Not a fit" },
             { id: "check", title: "You check it", kind: "approval", decider: "owner", next: "Send it", ifFails: "Leo writes back" },
@@ -87,10 +87,10 @@ export const KITS = [
     {
         id: "ops-requests", name: "Ops requests",
         promise: "Ada approves routine requests under $200 without you and brings you everything else, so the team gets answers the same day.",
-        teammate: { template: "ops", handle: "ada" },
+        subagent: { template: "ops", handle: "ada" },
         flowName: "Ops requests",
         steps: [
-            { id: "decide", title: "Ada decides", kind: "approval", teammate: "ada", decider: "owner", next: "Tell the team", ifFails: "Needs more" },
+            { id: "decide", title: "Ada decides", kind: "approval", subagent: "ada", decider: "owner", next: "Tell the team", ifFails: "Needs more" },
             { id: "tell", title: "Tell the team", kind: "notify", message: "Approved: {{card.title}}", next: "Done" },
             { id: "more", title: "Needs more", kind: "inbox" },
             { id: "done", title: "Done", kind: "done" },
@@ -104,22 +104,22 @@ export const KITS = [
     },
 ];
 export const kitOf = (id) => KITS.find(one => one.id === id) ?? null;
-/** A kit set up in a project: its flow (by name) and its teammate, when both are there. */
+/** A kit set up in a project: its flow (by name) and its subagent, when both are there. */
 export function kitInstalled(store, kit, repo) {
-    const mate = store.teammateByHandle(repo, kit.teammate.handle);
+    const mate = store.subagentByHandle(repo, kit.subagent.handle);
     const flow = store.listFlows([repo]).find(one => one.name === kit.flowName && one.state === "active") ?? null;
     return mate === null || flow === null ? null : { flow, mate };
 }
 /**
- * Set a kit up: its teammate (kept if one of that name is already there), its
- * flow, and its button triggers; then its teammate may use whichever of the
+ * Set a kit up: its subagent (kept if one of that name is already there), its
+ * flow, and its button triggers; then its subagent may use whichever of the
  * kit's tools the project already has (reading free, writing asking first).
  */
 export async function setUpKit(store, kit, repo, by, now, dir, io = {}) {
     const made = setUpKitNow(store, kit, repo, by, now, dir);
     if (!made.ok || made.said.endsWith("already set up here."))
         return made;
-    const mate = store.getTeammate(made.teammate);
+    const mate = store.getSubagent(made.subagent);
     const present = new Set(projectToolsOf(store, repo).map(one => one.name));
     for (const tool of kit.tools.filter(one => present.has(one.tool))) {
         try {
@@ -129,20 +129,20 @@ export async function setUpKit(store, kit, repo, by, now, dir, io = {}) {
     }
     return made;
 }
-/** The same, all at once (a chat confirmation can't wait on a tool): its teammate is given the kit's connected tools by the names their last test found, and each is listed properly on its first turn. */
+/** The same, all at once (a chat confirmation can't wait on a tool): its subagent is given the kit's connected tools by the names their last test found, and each is listed properly on its first turn. */
 export function setUpKitNow(store, kit, repo, by, now, dir, grantByName = false) {
     const had = kitInstalled(store, kit, repo);
     if (had !== null)
-        return { ok: true, said: `${kit.name} is already set up here.`, flow: had.flow.id, teammate: had.mate.id };
-    let mate = store.teammateByHandle(repo, kit.teammate.handle);
+        return { ok: true, said: `${kit.name} is already set up here.`, flow: had.flow.id, subagent: had.mate.id };
+    let mate = store.subagentByHandle(repo, kit.subagent.handle);
     if (mate === null) {
-        const template = TEAMMATE_TEMPLATES.find(one => one.id === kit.teammate.template);
+        const template = SUBAGENT_TEMPLATES.find(one => one.id === kit.subagent.template);
         if (template === undefined)
-            return { ok: false, said: "That kit's teammate template is missing." };
-        const made = createTeammateFrom(store, { repo, template: template.id, by }, now);
+            return { ok: false, said: "That kit's subagent template is missing." };
+        const made = createSubagentFrom(store, { repo, template: template.id, by }, now);
         if (!made.ok)
             return { ok: false, said: made.said };
-        mate = store.getTeammate(made.id);
+        mate = store.getSubagent(made.id);
     }
     let definition;
     try {
@@ -158,7 +158,7 @@ export function setUpKitNow(store, kit, repo, by, now, dir, grantByName = false)
     if (grantByName)
         for (const tool of projectToolsOf(store, repo).filter(one => kit.tools.some(each => each.tool === one.name)))
             grantListed(store, mate, tool, null, by, now);
-    return { ok: true, said: `${kit.name} is ready: ${nameOf(mate)} works its ${kit.flowName} flow.`, flow: flowId, teammate: mate.id };
+    return { ok: true, said: `${kit.name} is ready: ${nameOf(mate)} works its ${kit.flowName} flow.`, flow: flowId, subagent: mate.id };
 }
 /** What's set up and what's left, read fresh each time. */
 export function kitChecklist(store, kit, repo, dir) {
@@ -167,7 +167,7 @@ export function kitChecklist(store, kit, repo, dir) {
         return [];
     const name = nameOf(set.mate);
     const steps = [
-        { id: "teammate", done: true, said: `${name} joined the team`, href: `/teammates/${set.mate.id}` },
+        { id: "subagent", done: true, said: `${name} joined the team`, href: `/settings/lead/subagents/${set.mate.id}` },
         { id: "flow", done: true, said: `The ${kit.flowName} flow is ready`, href: `/flows/${set.flow.id}` },
     ];
     if (kit.email === true) {
@@ -184,18 +184,18 @@ export function kitChecklist(store, kit, repo, dir) {
     const tools = projectToolsOf(store, repo);
     for (const tool of kit.tools) {
         const connected = tools.some(one => one.name === tool.tool);
-        const granted = store.teammateGrant(set.mate.id, tool.tool) !== null;
+        const granted = store.subagentGrant(set.mate.id, tool.tool) !== null;
         steps.push(connected && granted
-            ? { id: `tool-${tool.tool}`, done: true, said: `${name} can use ${tool.label}`, href: `/teammates/${set.mate.id}#tools` }
+            ? { id: `tool-${tool.tool}`, done: true, said: `${name} can use ${tool.label}`, href: `/settings/lead/subagents/${set.mate.id}#tools` }
             : connected
-                ? { id: `tool-${tool.tool}`, done: false, said: `Let ${name} use ${tool.label}, ${tool.why}`, href: `/teammates/${set.mate.id}#tools` }
+                ? { id: `tool-${tool.tool}`, done: false, said: `Let ${name} use ${tool.label}, ${tool.why}`, href: `/settings/lead/subagents/${set.mate.id}#tools` }
                 : { id: `tool-${tool.tool}`, done: false, said: `Connect ${tool.label}, ${tool.why}`, href: `/settings/tools?repo=${encodeURIComponent(repo)}&kit=${kit.id}&connect=${tool.tool}#connect`, action: "connect", tool: tool.tool });
     }
     const tried = store.flowCards(set.flow.id, true).length > 0;
     steps.push({ id: "sample", done: tried, said: tried ? `${name} has worked a card` : `See ${name} work a sample card`, href: tried ? `/flows/${set.flow.id}` : null, ...(tried ? {} : { action: "sample" }) });
     return steps;
 }
-/** A sample card in the kit's first zone, so its teammate starts on it at once. */
+/** A sample card in the kit's first zone, so its subagent starts on it at once. */
 export function addKitSample(store, kit, repo, by, now) {
     const set = kitInstalled(store, kit, repo);
     if (set === null)

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

@@ -1,16 +1,16 @@
-import { type MateProposal, type Store } from "./store.js";
+import { type LeadProposal, type Store } from "./store.js";
 import { type ShapeOptions } from "./reply-shape.js";
-import type { SubscriptionMateRunner } from "./subscription-chat.js";
-export type MateCliSeams = {
+import type { SubscriptionLeadRunner } from "./subscription-chat.js";
+export type LeadCliSeams = {
     fetcher?: typeof fetch;
     env?: Record<string, string | undefined>;
     /** Lines the REPL reads instead of stdin (tests). */
     lines?: AsyncIterable<string> | Iterable<string>;
     clock?: () => Date;
     /** Subscription harness seam; tests never consume a real membership turn. */
-    subscriptionRunner?: SubscriptionMateRunner;
+    subscriptionRunner?: SubscriptionLeadRunner;
 };
-export type MateCliInput = {
+export type LeadCliInput = {
     store: Store;
     databaseFile: string;
     write: (line: string) => void;
@@ -25,18 +25,18 @@ export type MateCliInput = {
     end: boolean;
     follow?: boolean;
     ceilingUsd: number | undefined;
-    seams?: MateCliSeams;
+    seams?: LeadCliSeams;
     /** Where evidence lives — a scout's report reads from here. */
     evidenceRoot?: string;
     /** The console's address(es): a reply's links there are named as its pages ("the task"), not by host. */
     appOrigin?: ShapeOptions["appOrigin"];
 };
-export type MateCliResult = {
+export type LeadCliResult = {
     code: number;
     reason?: string;
     message?: string;
 };
-export declare const MATE_CLI_EXIT: {
+export declare const LEAD_CLI_EXIT: {
     readonly ok: 0;
     readonly failed: 1;
     readonly usage: 2;
@@ -49,7 +49,7 @@ export declare const MATE_CLI_EXIT: {
  */
 export declare function answerContextLines(store: Store, payload: Record<string, unknown>): string[];
 /** One line per proposal, numbered in thread order, for the operator to name. */
-export declare function proposalLines(proposals: readonly MateProposal[], repos: readonly string[], ordinal?: (proposal: MateProposal) => number): string[];
+export declare function proposalLines(proposals: readonly LeadProposal[], repos: readonly string[], ordinal?: (proposal: LeadProposal) => number): string[];
 /** The lines for one proposal, its answer context included when it is an answer. */
-export declare function proposalBlock(store: Store, proposal: MateProposal, repos: readonly string[], number: number): string[];
-export declare function runMateCli(input: MateCliInput): Promise<MateCliResult>;
+export declare function proposalBlock(store: Store, proposal: LeadProposal, repos: readonly string[], number: number): string[];
+export declare function runLeadCli(input: LeadCliInput): Promise<LeadCliResult>;

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

@@ -1,7 +1,7 @@
 import { configureLeadFollow, leadFollowStatus } from './lead-follow.js';
 /**
  * `toolroll chat` (mate arc §6): the same thread the console shows,
- * driven from a terminal. The password is typed once — it mints the mate
+ * driven from a terminal. The password is typed once — it mints the lead
  * session, the one ceremony a conversation gets — and every later turn
  * debits that session without asking again. Confirming a card runs the
  * same doors the console runs; password-class acts (approving a scope,
@@ -10,16 +10,16 @@ import { configureLeadFollow, leadFollowStatus } from './lead-follow.js';
 import { createHash } from "node:crypto";
 import { readFileSync } from "node:fs";
 import { dirname, join } from "node:path";
-import { MATE_ASK_OTHER } from "./store.js";
+import { LEAD_ASK_OTHER } from "./store.js";
 import { CHAT_KEY_ENV, credentialKeyOf, isDirectChatProvider, priceForConfig, subscriptionCredentialKey } from "./converse.js";
 import { verifyApproverByPassword } from "./principal.js";
-import { runMateTurn } from "./mate.js";
+import { runLeadTurn } from "./lead.js";
 import { voiceReply } from "./reply-shape.js";
-import { confirmMateProposal, dismissMateProposal } from "./mate-doors.js";
+import { confirmLeadProposal, dismissLeadProposal } from "./lead-doors.js";
 import { projectName } from "./project.js";
 import { CHAT_CONTROLS, chatControlHref, isChatControl } from "./chat-controls.js";
 import { CHAT_TASK_ACTIONS, isChatTaskAction } from "./chat-task-actions.js";
-export const MATE_CLI_EXIT = { ok: 0, failed: 1, usage: 2, refused: 3 };
+export const LEAD_CLI_EXIT = { ok: 0, failed: 1, usage: 2, refused: 3 };
 function money(microusd) {
     return `$${(microusd / 1_000_000).toFixed(2)}`;
 }
@@ -119,7 +119,7 @@ async function* linesOf(seams) {
         reader.close();
     }
 }
-export async function runMateCli(input) {
+export async function runLeadCli(input) {
     const { store, write, json } = input;
     const seams = input.seams ?? {};
     const clock = seams.clock ?? (() => new Date());
@@ -132,7 +132,7 @@ export async function runMateCli(input) {
         if (json)
             write(JSON.stringify({ command: "chat", ...envelope }));
     };
-    const refuse = (reason, message, code = MATE_CLI_EXIT.refused) => {
+    const refuse = (reason, message, code = LEAD_CLI_EXIT.refused) => {
         if (json)
             write(JSON.stringify({ ok: false, command: "chat", reason, message }));
         else
@@ -154,22 +154,22 @@ export async function runMateCli(input) {
         return refuse("no-key", `no ${directProvider} key — export ${CHAT_KEY_ENV[directProvider]}, or paste one on the console's chat page`);
     const repos = [...input.repos];
     if (repos.length === 0)
-        return refuse("empty-ceiling", "The lead has no projects to look at. Name some with --repo, or add projects in the console.", MATE_CLI_EXIT.usage);
+        return refuse("empty-ceiling", "The lead has no projects to look at. Name some with --repo, or add projects in the console.", LEAD_CLI_EXIT.usage);
     const verified = verifyApproverByPassword(store, input.credentials.name, input.credentials.token, repos);
     if (!verified.ok)
         return refuse("unauthenticated", "that is not an approver, or the password does not match");
     const who = verified.who;
     let now = clock();
     if (input.end) {
-        const turns = store.failLiveMateTurnsFor(who.name, "ended", now);
-        const sessions = store.endMateSessionsFor(who.name, who.name, now);
-        const threads = store.closeMateThreadsFor(who.name, now);
+        const turns = store.failLiveLeadTurnsFor(who.name, "ended", now);
+        const sessions = store.endLeadSessionsFor(who.name, who.name, now);
+        const threads = store.closeLeadThreadsFor(who.name, now);
         emit({ ok: true, ended: { sessions, threads, turns } });
         say(sessions === 0 ? "No conversation was open, so there was nothing to end." : "The conversation has ended and its history is forgotten.");
-        return { code: MATE_CLI_EXIT.ok };
+        return { code: LEAD_CLI_EXIT.ok };
     }
-    store.sweepStaleMateTurns(now);
-    let session = store.activeMateSession(who.name);
+    store.sweepStaleLeadTurns(now);
+    let session = store.activeLeadSession(who.name);
     const credentialKey = direct ? credentialKeyOf(directProvider, key) : subscriptionCredentialKey(subscriptionProvider);
     if (session !== null && session.credentialKey !== credentialKey) {
         // A session minted under another provider key cannot be spent by this
@@ -177,38 +177,38 @@ export async function runMateCli(input) {
         return refuse("key-mismatch", "The open conversation was started with a different provider key. Use that key, or end it with --end and start a new one.");
     }
     if (session !== null && session.ceilingDigest !== who.ceilingDigest) {
-        store.endMateSession(session.id, who.name, now);
-        store.closeMateThreadsFor(who.name, now);
+        store.endLeadSession(session.id, who.name, now);
+        store.closeLeadThreadsFor(who.name, now);
         say("The projects you named differ from the open conversation's, so it ended. Starting a new one.");
         session = null;
     }
     if (session === null) {
         const ceilingUsd = direct ? (input.ceilingUsd ?? 5) : 0;
         if (direct && (!Number.isFinite(ceilingUsd) || ceilingUsd <= 0 || ceilingUsd > 1_000))
-            return refuse("usage", "--ceiling-usd is a dollar amount between 0 and 1000", MATE_CLI_EXIT.usage);
+            return refuse("usage", "--ceiling-usd is a dollar amount between 0 and 1000", LEAD_CLI_EXIT.usage);
         const ceilingMicrousd = Math.round(ceilingUsd * 1_000_000);
         const termsDigest = createHash("sha256").update(`${ceilingMicrousd}\n${who.ceilingDigest}`).digest("hex");
-        const id = store.mintMateSession({ approver: who.name, approverGeneration: who.generation, credentialKey, ceilingMicrousd, ceilingDigest: who.ceilingDigest, termsDigest }, now);
-        session = store.getMateSession(id);
+        const id = store.mintLeadSession({ approver: who.name, approverGeneration: who.generation, credentialKey, ceilingMicrousd, ceilingDigest: who.ceilingDigest, termsDigest }, now);
+        session = store.getLeadSession(id);
         if (session === null)
-            return refuse("failed", "A new conversation couldn't be started. Try again.", MATE_CLI_EXIT.failed);
+            return refuse("failed", "A new conversation couldn't be started. Try again.", LEAD_CLI_EXIT.failed);
         if (!direct && input.ceilingUsd !== undefined)
             say("the supplied --ceiling-usd value is ignored for membership usage");
-        say(`mate conversation started: ${direct ? `up to ${money(ceilingMicrousd)}` : "subscription usage (no dollar limit)"} over ${repos.map(one => projectName(one)).join(", ")} — live until you end it`);
+        say(`lead conversation started: ${direct ? `up to ${money(ceilingMicrousd)}` : "subscription usage (no dollar limit)"} over ${repos.map(one => projectName(one)).join(", ")} — live until you end it`);
         if (direct)
             say(`(the weekly chat limit, ${money(config.weeklyCeilingMicrousd)}, still applies)`);
     }
     else {
-        say(`mate conversation live: ${direct ? `${money(session.spentMicrousd)} of ${money(session.ceilingMicrousd)} spent` : "subscription usage (no dollar limit)"} — live until you end it`);
+        say(`lead conversation live: ${direct ? `${money(session.spentMicrousd)} of ${money(session.ceilingMicrousd)} spent` : "subscription usage (no dollar limit)"} — live until you end it`);
     }
-    const thread = store.openMateThread(who.name, who.ceilingDigest, now).thread;
+    const thread = store.openLeadThread(who.name, who.ceilingDigest, now).thread;
     if (input.follow !== undefined) {
         if (!configureLeadFollow(store, who, session, thread, input.follow, now))
             return refuse("standing", "Conversation access changed.");
         say(leadFollowStatus(store, who.name).detail);
         emit({ ok: true, follow: leadFollowStatus(store, who.name) });
     }
-    const pendingProposals = () => store.listMateProposals(thread.id, ["pending"]);
+    const pendingProposals = () => store.listLeadProposals(thread.id, ["pending"]);
     // Ordinals are assigned once per proposal and never reused within this
     // run (slice-2 review, finding 4): `confirm 2` means the card printed as
     // 2, whatever the console did to its neighbours meanwhile.
@@ -224,7 +224,7 @@ export async function runMateCli(input) {
     const byOrdinal = (ordinal) => {
         for (const [id, n] of ordinals)
             if (n === ordinal)
-                return store.getMateProposal(id);
+                return store.getLeadProposal(id);
         return null;
     };
     const printProposals = () => {
@@ -239,12 +239,12 @@ export async function runMateCli(input) {
                 say(line);
     };
     const turn = async (message) => {
-        const live = store.activeMateSession(who.name);
+        const live = store.activeLeadSession(who.name);
         if (live === null) {
             const outcome = { ok: false, refused: "session-ended", message: "This conversation has ended. Run chat again to start a new one." };
             return outcome;
         }
-        return runMateTurn({ store, who, session: live, thread, config, key, message, channel: "terminal", ...(seams.fetcher === undefined ? {} : { fetcher: seams.fetcher }), ...(seams.subscriptionRunner === undefined ? {} : { subscriptionRunner: seams.subscriptionRunner }), ...(input.evidenceRoot === undefined ? {} : { evidenceRoot: input.evidenceRoot }), clock });
+        return runLeadTurn({ store, who, session: live, thread, config, key, message, channel: "terminal", ...(seams.fetcher === undefined ? {} : { fetcher: seams.fetcher }), ...(seams.subscriptionRunner === undefined ? {} : { subscriptionRunner: seams.subscriptionRunner }), ...(input.evidenceRoot === undefined ? {} : { evidenceRoot: input.evidenceRoot }), clock });
     };
     const report = (outcome, message) => {
         if (outcome.ok && outcome.replayed) {
@@ -253,14 +253,14 @@ export async function runMateCli(input) {
             return;
         }
         if (outcome.ok) {
-            const ask = store.mateAsk(outcome.turn);
+            const ask = store.leadAsk(outcome.turn);
             emit({ ok: true, turn: outcome.turn, reply: outcome.reply, activity: outcome.activity, steps: outcome.steps, settledMicrousd: outcome.settledMicrousd, proposals: pendingProposals().map(one => ({ id: one.id, ordinal: ordinalOf(one), kind: one.kind, payload: one.payload })),
-                ...(ask === null ? {} : { ask: { question: ask.question, options: [...ask.options, MATE_ASK_OTHER] } }) });
+                ...(ask === null ? {} : { ask: { question: ask.question, options: [...ask.options, LEAD_ASK_OTHER] } }) });
             say(`  ${outcome.activity}`);
             say(voiceReply(outcome.reply, "terminal", { appOrigin: input.appOrigin ?? null, ...(message === undefined ? {} : { asked: message }) }));
             // The lead's question: the terminal has no buttons, so the options are listed to type back.
             if (ask !== null)
-                say(`${ask.question}\n${ask.options.map(one => `  · ${one}`).join("\n")}\n  · ${MATE_ASK_OTHER} (type your answer)`);
+                say(`${ask.question}\n${ask.options.map(one => `  · ${one}`).join("\n")}\n  · ${LEAD_ASK_OTHER} (type your answer)`);
             printProposals();
             return;
         }
@@ -270,7 +270,7 @@ export async function runMateCli(input) {
     if (input.say !== undefined) {
         const outcome = await turn(input.say);
         report(outcome, input.say);
-        return { code: outcome.ok ? MATE_CLI_EXIT.ok : MATE_CLI_EXIT.refused };
+        return { code: outcome.ok ? LEAD_CLI_EXIT.ok : LEAD_CLI_EXIT.refused };
     }
     // The REPL. Text is a turn; a few words are acts on the cards.
     say("say something, or: proposals · confirm N · dismiss N · open N · end · quit");
@@ -311,12 +311,12 @@ export async function runMateCli(input) {
                 openTask(proposal);
             }
             else if (verb === "dismiss") {
-                const done = dismissMateProposal(store, who, proposal.id, now);
+                const done = dismissLeadProposal(store, who, proposal.id, now);
                 emit({ ok: done, act: "dismiss", proposal: proposal.id });
                 say(done ? `dismissed ${act[2]}` : "that proposal was already acted on");
             }
             else {
-                const outcome = confirmMateProposal(store, who, proposal.id, now, { confirm: act[3] !== undefined, via: "cli", chatProvider: () => {
+                const outcome = confirmLeadProposal(store, who, proposal.id, now, { confirm: act[3] !== undefined, via: "cli", chatProvider: () => {
                         const current = store.getChatConfig();
                         return current === null ? null : { config: current, key: isDirectChatProvider(current.provider) ? keyFor(current, input.databaseFile, env) : null };
                     }, ...(input.evidenceRoot === undefined ? {} : { evidenceRoot: input.evidenceRoot }) });
@@ -338,12 +338,12 @@ export async function runMateCli(input) {
         if (word === "quit" || word === "exit")
             break;
         if (word === "end") {
-            store.failLiveMateTurnsFor(who.name, "ended", now);
-            store.endMateSessionsFor(who.name, who.name, now);
-            store.closeMateThreadsFor(who.name, now);
+            store.failLiveLeadTurnsFor(who.name, "ended", now);
+            store.endLeadSessionsFor(who.name, who.name, now);
+            store.closeLeadThreadsFor(who.name, now);
             say("The conversation has ended and its history is forgotten.");
             emit({ ok: true, ended: true });
-            return { code: MATE_CLI_EXIT.ok };
+            return { code: LEAD_CLI_EXIT.ok };
         }
         if (word === "help" || word === "?") {
             say("say something, or: proposals · confirm N · dismiss N · open N · end · quit");
@@ -351,5 +351,5 @@ export async function runMateCli(input) {
         }
         report(await turn(line), line);
     }
-    return { code: MATE_CLI_EXIT.ok };
+    return { code: LEAD_CLI_EXIT.ok };
 }

package/dist/lead-commitments.js

@@ -90,7 +90,7 @@ export function getCommitment(store, id) {
 /** The reply that made a promise was shown: its turn is over, and it was answered or its text reached the conversation
  * before it failed. A turn still running has shown nothing yet, whatever it has written so far. */
 const SHOWN = (turn) => `EXISTS (SELECT 1 FROM mate_turn t WHERE t.id = ${turn} AND (t.state = 'answered'
-  OR t.state = 'failed' AND EXISTS (SELECT 1 FROM mate_message m WHERE m.turn = t.id AND m.role = 'assistant')))`;
+  OR t.state = 'failed' AND EXISTS (SELECT 1 FROM lead_message m WHERE m.turn = t.id AND m.role = 'assistant')))`;
 /** A promise only counts once the reply that made it was shown: one from a reply still being written, or one that
  * failed without reaching the owner, was never heard. */
 const HEARD = `(c.turn IS NULL OR ${SHOWN('c.turn')})`;
@@ -173,7 +173,7 @@ export function checkLeadCommitments(store, now, root) {
             continue;
         }
         // A reply still being written may yet be delivered; one that was not is dropped above.
-        const turn = one.turn === null ? null : store.getMateTurn(one.turn);
+        const turn = one.turn === null ? null : store.getLeadTurn(one.turn);
         if (turn !== null && (turn.state === 'queued' || turn.state === 'running'))
             continue;
         const account = store.accountOf(one.owner);
@@ -181,7 +181,7 @@ export function checkLeadCommitments(store, now, root) {
             close('cancelled', 'Access to this project ended.');
             continue;
         }
-        const thread = store.getMateThread(one.thread);
+        const thread = store.getLeadThread(one.thread);
         if (thread === null || thread.approver !== one.owner || thread.closedAt !== null) {
             close('cancelled', 'The conversation it was promised in was closed.');
             continue;
@@ -203,7 +203,7 @@ export function checkLeadCommitments(store, now, root) {
                 return;
             // The shared conversation always keeps the line; a promise made on a phone or team chat is also said there, as
             // the lead's own message to its owner, on that chat alone (the usual delivery receipts apply).
-            store.appendMateMessage({ thread: one.thread, turn: null, role: 'assistant', text: line }, now);
+            store.appendLeadMessage({ thread: one.thread, turn: null, role: 'assistant', text: line }, now);
             if (one.channel !== 'chat')
                 store.enqueueNotification({ dedupeKey: `${PROMISE_KEY}${one.channel}:${one.id}`, kind: LEAD_SAY_KIND, subject: leadNameOf(store, one.owner),
                     body: line.slice(0, 300), recipient: one.owner, source: { installation: true } }, now);