toolroll 0.9.55 → 0.9.56

package/dist/subscription-chat.js

@@ -1,5 +1,5 @@
 /**
- * Subscription-backed transport for the mate.
+ * Subscription-backed transport for the lead.
  *
  * The direct API transport owns dollar reservations and native function
  * calls. A cached Codex or Claude login has neither an API key nor a
@@ -7,16 +7,16 @@
  * temporary directory and asks for the same tool-call envelope as strict
  * structured JSON. The harness receives no repository path, no project
  * instructions, no MCP servers, and no executable tool surface. Tool calls
- * are still interpreted and executed by mate.ts, where every act remains a
+ * are still interpreted and executed by lead.ts, where every act remains a
  * proposal that needs a human confirmation card.
  */
 import { Buffer } from "node:buffer";
 import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { MATE_MAX_CALLS_PER_STEP, MATE_STEP_TEXT_CAP_BYTES, MATE_TOOL_CALL_CAP_BYTES, MATE_TOOL_CALL_ID_CAP_BYTES, strictJsonParse, tokenCount, } from "./converse.js";
+import { LEAD_MAX_CALLS_PER_STEP, LEAD_STEP_TEXT_CAP_BYTES, LEAD_TOOL_CALL_CAP_BYTES, LEAD_TOOL_CALL_ID_CAP_BYTES, strictJsonParse, tokenCount, } from "./converse.js";
 import { run } from "./exec.js";
-import { claudeStreamReader } from "./mate-progress.js";
+import { claudeStreamReader } from "./lead-progress.js";
 import { ALL_CREDENTIAL_ENV } from "./provider.js";
 import { claudeLimitsOf, noteLimits } from "./provider-limits.js";
 import { claudeBillingFrom } from "./spend.js";
@@ -25,18 +25,18 @@ function outputSchema(tools) {
     return {
         type: "object",
         properties: {
-            text: { type: "string", maxLength: MATE_STEP_TEXT_CAP_BYTES },
+            text: { type: "string", maxLength: LEAD_STEP_TEXT_CAP_BYTES },
             // With no tools offered there is nothing to name: an empty enum is not
             // a valid schema, so the calls array is simply required to be empty.
             calls: tools.length === 0 ? { type: "array", maxItems: 0 } : {
                 type: "array",
-                maxItems: MATE_MAX_CALLS_PER_STEP,
+                maxItems: LEAD_MAX_CALLS_PER_STEP,
                 items: {
                     type: "object",
                     properties: {
-                        id: { type: "string", minLength: 1, maxLength: MATE_TOOL_CALL_ID_CAP_BYTES },
+                        id: { type: "string", minLength: 1, maxLength: LEAD_TOOL_CALL_ID_CAP_BYTES },
                         name: { type: "string", enum: tools.map(tool => tool.name) },
-                        argumentsJson: { type: "string", maxLength: MATE_TOOL_CALL_CAP_BYTES },
+                        argumentsJson: { type: "string", maxLength: LEAD_TOOL_CALL_CAP_BYTES },
                     },
                     required: ["id", "name", "argumentsJson"],
                     additionalProperties: false,
@@ -47,8 +47,8 @@ function outputSchema(tools) {
         additionalProperties: false,
     };
 }
-/** The model-visible request. Tool results are already redacted by mateView. */
-export function composeSubscriptionMatePrompt(request) {
+/** The model-visible request. Tool results are already redacted by leadView. */
+export function composeSubscriptionLeadPrompt(request) {
     return [
         request.system,
         "SUBSCRIPTION HARNESS PROTOCOL:",
@@ -68,7 +68,7 @@ function exactKeys(value, keys) {
     return actual.length === keys.length && [...keys].sort().every((key, index) => actual[index] === key);
 }
 /** Strictly turn the harness's structured output into the provider-neutral answer. */
-export function parseSubscriptionMateAnswer(text, usage = {}) {
+export function parseSubscriptionLeadAnswer(text, usage = {}) {
     const parsed = strictJsonParse(Buffer.from(text, "utf8"), RESPONSE_CAP_BYTES, 8);
     if (!parsed.ok || typeof parsed.value !== "object" || parsed.value === null || Array.isArray(parsed.value)) {
         return { ok: false, problem: parsed.ok ? "not-an-object" : parsed.problem };
@@ -77,7 +77,7 @@ export function parseSubscriptionMateAnswer(text, usage = {}) {
     if (!exactKeys(body, ["text", "calls"]) || typeof body["text"] !== "string" || !Array.isArray(body["calls"])) {
         return { ok: false, problem: "wrong-shape" };
     }
-    if (Buffer.byteLength(body["text"], "utf8") > MATE_STEP_TEXT_CAP_BYTES || body["calls"].length > MATE_MAX_CALLS_PER_STEP) {
+    if (Buffer.byteLength(body["text"], "utf8") > LEAD_STEP_TEXT_CAP_BYTES || body["calls"].length > LEAD_MAX_CALLS_PER_STEP) {
         return { ok: false, problem: "over-cap" };
     }
     const calls = [];
@@ -87,20 +87,20 @@ export function parseSubscriptionMateAnswer(text, usage = {}) {
         const call = raw;
         if (!exactKeys(call, ["id", "name", "argumentsJson"]))
             return { ok: false, problem: "bad-tool-call" };
-        if (typeof call["id"] !== "string" || call["id"] === "" || Buffer.byteLength(call["id"], "utf8") > MATE_TOOL_CALL_ID_CAP_BYTES) {
+        if (typeof call["id"] !== "string" || call["id"] === "" || Buffer.byteLength(call["id"], "utf8") > LEAD_TOOL_CALL_ID_CAP_BYTES) {
             return { ok: false, problem: "bad-tool-call" };
         }
         if (typeof call["name"] !== "string" || call["name"] === "" || call["name"].length > 64 || typeof call["argumentsJson"] !== "string") {
             return { ok: false, problem: "bad-tool-call" };
         }
         const argumentsBytes = Buffer.from(call["argumentsJson"], "utf8");
-        if (argumentsBytes.byteLength > MATE_TOOL_CALL_CAP_BYTES)
+        if (argumentsBytes.byteLength > LEAD_TOOL_CALL_CAP_BYTES)
             return { ok: false, problem: "bad-tool-call" };
-        const args = strictJsonParse(argumentsBytes, MATE_TOOL_CALL_CAP_BYTES, 6);
+        const args = strictJsonParse(argumentsBytes, LEAD_TOOL_CALL_CAP_BYTES, 6);
         if (!args.ok || typeof args.value !== "object" || args.value === null || Array.isArray(args.value))
             return { ok: false, problem: "bad-tool-call" };
         const normalized = { id: call["id"], name: call["name"], args: args.value };
-        if (Buffer.byteLength(JSON.stringify(normalized), "utf8") > MATE_TOOL_CALL_CAP_BYTES)
+        if (Buffer.byteLength(JSON.stringify(normalized), "utf8") > LEAD_TOOL_CALL_CAP_BYTES)
             return { ok: false, problem: "bad-tool-call" };
         calls.push(normalized);
     }
@@ -186,10 +186,10 @@ function lastResultLine(stdout) {
     return "";
 }
 /** Production runner; injectable so tests never consume a subscription turn. */
-export async function performSubscriptionMateRequest(request, runner = run) {
+export async function performSubscriptionLeadRequest(request, runner = run) {
     const dir = mkdtempSync(join(tmpdir(), "standing-orders-mate-"));
     try {
-        const prompt = composeSubscriptionMatePrompt(request);
+        const prompt = composeSubscriptionLeadPrompt(request);
         const streaming = request.provider !== "codex-subscription" && request.onText !== undefined;
         const schema = request.outputSchema ?? outputSchema(request.tools);
         let command;
@@ -274,7 +274,7 @@ export async function performSubscriptionMateRequest(request, runner = run) {
         if (request.outputSchema !== undefined) {
             return { ok: true, answer: { text: output.text, calls: [], tokensIn: output.tokensIn, tokensOut: output.tokensOut, reportedCostMicrousd: null } };
         }
-        return parseSubscriptionMateAnswer(output.text, output);
+        return parseSubscriptionLeadAnswer(output.text, output);
     }
     finally {
         rmSync(dir, { recursive: true, force: true });

package/dist/surface.d.ts

@@ -1,10 +1,27 @@
+/**
+ * The declared command guide (arc 5): the agent-facing surface as data,
+ * dumped by `contract --commands`. This is DOCUMENTATION with a stable
+ * shape, not authority — legacy verbs do not execute from it,
+ * and the runtime envelope remains the truth. Its honest limits ride the
+ * envelope itself as SURFACE_NOTES, because a source comment is invisible
+ * to consumers (arc-5 review, finding 1).
+ *
+ * What the tests DO hold to the code: every root here is a routed verb
+ * and every routed verb appears here; every declared flag lives in the
+ * parser's global vocabulary with the declared arity; the subcommand
+ * inventories for task/publish/config/approver match the
+ * exported action lists their dispatchers consult; keyed mutations
+ * declare --key; notableReasons come from DOCUMENTED_REASONS. What they
+ * CANNOT prove — that a given flag is read by a given handler — is why
+ * SURFACE_NOTES.flags says "intended".
+ */
 import { type CommandFlag, type CommandRow, type RemotePolicy } from './contracts/cli.js';
 /** A guide row and its flags are derived from their schemas in src/contracts/cli.ts. */
 export type { CommandFlag, CommandRow, RemotePolicy };
 /** The guide's limits, stated machine-readably in every dump. */
 export declare const SURFACE_NOTES: {
-    readonly authority: "documentation is not permission; session descriptors also drive parser and request validation; legacy entries remain advisory";
-    readonly flags: "session flags are exact per operation; legacy flags are intended per command and may use a global parser vocabulary";
+    readonly authority: "documentation is not permission; legacy entries remain advisory";
+    readonly flags: "flags are intended per command and may use a global parser vocabulary";
     readonly reasons: "curated, not exhaustive — the runtime `reason` field is the truth; ignore tokens you do not recognize";
     readonly database: "local database commands wait up to 15 seconds for another writer; an exhausted wait returns database-busy and names the selected file";
 };

package/dist/surface.js

@@ -19,13 +19,11 @@ import { FLOWS_DESCRIPTORS } from "./flows-cli.js";
  * CANNOT prove — that a given flag is read by a given handler — is why
  * SURFACE_NOTES.flags says "intended".
  */
-import { SESSION_DESCRIPTORS } from './session-contract.js';
-import { sessionCliFlags } from './session-cli.js';
 import { commandEntries } from './contracts/cli.js';
 /** The guide's limits, stated machine-readably in every dump. */
 export const SURFACE_NOTES = {
-    authority: "documentation is not permission; session descriptors also drive parser and request validation; legacy entries remain advisory",
-    flags: "session flags are exact per operation; legacy flags are intended per command and may use a global parser vocabulary",
+    authority: "documentation is not permission; legacy entries remain advisory",
+    flags: "flags are intended per command and may use a global parser vocabulary",
     reasons: "curated, not exhaustive — the runtime `reason` field is the truth; ignore tokens you do not recognize",
     database: "local database commands wait up to 15 seconds for another writer; an exhausted wait returns database-busy and names the selected file",
 };
@@ -66,22 +64,9 @@ const GUIDE_ROWS = [
     { invocation: "graph", synopsis: "report which work graph is already here", audience: "agent", agentMayInvoke: true, mutation: "none", flags: [jsonFlag] },
     { invocation: "repos", synopsis: "list connected repositories", audience: "agent", agentMayInvoke: true, mutation: "none", flags: [jsonFlag] },
     operator("proposals", "what coordinators proposed over the MCP gateway — list, confirm <id> [--yes], dismiss <id>; confirming runs the plane's own door under your password"),
-    operator("chat", "with a saved profile, --lead <id> --conversation <id> opens central chat; --say sends one message, --follow only reads updates, --authorize --terms-digest enables the displayed paid terms; --local uses the existing local coordinator, where --follow enables crew updates and --no-follow pauses them; proposals keep their approval requirements"),
-    operator('connect', 'save an authenticated central HTTPS profile with --as and --token-stdin or --token-file; --local-login explicitly uses the existing private local sign-in; secrets never belong in arguments or URLs'),
-    operatorRead('lead list', 'list central leads available to the signed-in account; --profile selects a saved connection'),
-    operator('lead create', 'create a central lead with --name, --instructions and repeatable --project paths admitted by the server'),
-    operator('lead update', 'change --name, --instructions or --status for --lead at --revision; projects remain fixed'),
-    operator('lead member', 'set --account membership on --lead with --role, --active true|false and the current --revision'),
-    operator('lead transfer', 'move ownership of --task to --lead at --revision; existing execution authority remains unchanged'),
-    operatorRead('conversation list', 'list admitted conversations, optionally within --lead; attachment never starts model work'),
-    operator('conversation create', 'create a conversation with --lead, --title, --visibility private|team and repeatable --project paths'),
-    operatorRead('conversation show', 'read --conversation messages and saved work; no model call or read-marker mutation'),
-    operator('conversation member', 'set --account membership on --conversation with --role, --active true|false and the current --revision; lead membership must already permit the role'),
-    operator('conversation edit', 'edit your queued --message in --conversation at --revision using --text; running messages cannot be edited'),
-    operator('conversation withdraw', 'withdraw your queued --message in --conversation at --revision; an active turn requires stop'),
-    operator('conversation read', 'explicitly record your read position at --message within --conversation'),
-    operator('conversation follow', 'enable or pause automatic lead summaries with --conversation and --enabled true|false, within the existing paid chat authorization; passive chat --follow only reads updates'),
-    operator('conversation stop', 'request stopping the exact --message in --conversation; retain uncertain work until its owner settles it'),
+    // D5: the central team service (connect, the central lead verbs, conversation …) and native coding sessions are
+    // deprecated: they still run this release, with a warning, but are no longer declared here.
+    operator("chat", "talk to your lead: one conversation across every project; --say sends one message; --follow enables crew updates and --no-follow pauses them; proposals keep their approval requirements"),
     { invocation: "repos add", synopsis: "add a project: a Git repository, in the console at once; the lead adds with its token", audience: "agent", agentMayInvoke: true, mutation: "identity-idempotent",
         positionals: [{ name: "path", required: false, meaning: "the repository (default: the one you are in)" }],
         flags: [jsonFlag, { name: "token", takesValue: true, meaning: "the lead token (or TOOLROLL_LEAD_TOKEN)" }],
@@ -126,12 +111,6 @@ const GUIDE_ROWS = [
             { name: "yes", takesValue: false, meaning: "with --release-gate: lift that one pause once it is proved" }],
         notableReasons: ["usage", "ambiguous", "drift", "timeout", "check-failed", "ci-failed", "tree-mismatch", "conflict", "mixed-runtime", "gate-held", "after-swap"] },
     operator("demo", "a seeded throwaway sandbox"),
-    { invocation: 'session capabilities', synopsis: 'Show executable session schemas and operator authority requirements; no credentials needed', audience: 'agent', agentMayInvoke: true, mutation: 'none', flags: [jsonFlag] },
-    ...SESSION_DESCRIPTORS.map(spec => ({
-        invocation: `session ${spec.operation}`, synopsis: spec.synopsis, audience: spec.audience, agentMayInvoke: spec.agentMayInvoke,
-        mutation: spec.mutation ? 'keyed' : 'none', inputSchema: spec.inputSchema,
-        flags: Object.entries(sessionCliFlags(spec)).map(([name, arity]) => ({ name, takesValue: arity === 'value', meaning: name === 'key' ? 'keep the same key when reconciling; inspect after unknown delivery, never blind-retry' : `see session ${spec.operation} --help` })),
-    })),
     ...KNOWLEDGE_DESCRIPTORS.map(spec => ({ invocation: `knowledge ${spec.action}`, synopsis: spec.synopsis, audience: "audience" in spec ? spec.audience : "agent", agentMayInvoke: !("audience" in spec), mutation: spec.mutation, flags: spec.flags, ...(spec.takesQuery ? { positionals: [{ name: "query", required: true, meaning: "search text or source file for impact" }] } : {}) })),
     ...MEMORY_DESCRIPTORS.map(spec => ({ invocation: `memory ${spec.action}`, synopsis: spec.synopsis, audience: "agent", agentMayInvoke: true, mutation: spec.mutation, flags: spec.flags, ...(spec.takesQuery ? { positionals: [{ name: "query", required: true, meaning: "search text, a decision id, or the decision sentence" }] } : {}) })),
     // Flow writes carry an approver's credential: an agent runs them only as the person asked, after showing the preview.
@@ -144,7 +123,7 @@ const GUIDE_ROWS = [
     { invocation: "integrations", synopsis: "every integration as Connected, Not set up or Broken, with its last success and error, what uses it and what to do; --saved skips new checks; never a secret", audience: "agent", agentMayInvoke: true, mutation: "none",
         flags: [jsonFlag, dbFlag, { name: "saved", takesValue: false, meaning: "show the last checks without checking again" }] },
     { invocation: "ready", synopsis: "what could be dispatched right now (rows carry reservedFor)", audience: "agent", agentMayInvoke: true, mutation: "none", flags: [jsonFlag, dbFlag] },
-    { invocation: "brief", synopsis: "with a saved central profile, --lead <id> --conversation <id> reads messages, proposals and saved work; --request-id inspects your saved receipt without resending; --local uses local DB catch-up, where --history selects the older operational report", audience: "agent", agentMayInvoke: true, mutation: "none", flags: [jsonFlag, dbFlag] },
+    { invocation: "brief", synopsis: "the lead's catch-up from the local database; --history selects the older operational report", audience: "agent", agentMayInvoke: true, mutation: "none", flags: [jsonFlag, dbFlag] },
     { invocation: "gaps", synopsis: "requirement gaps blocking dispatch", audience: "agent", agentMayInvoke: true, mutation: "none", flags: [jsonFlag, dbFlag, repoFlag] },
     { invocation: "grants", synopsis: "list authority grants", audience: "agent", agentMayInvoke: true, mutation: "none", flags: [jsonFlag, dbFlag] },
     { invocation: "audit", synopsis: "what people did on this server with their API tokens, newest first: when, who, which token, from the CLI (api) or an agent (mcp), the command or tool, the project and the outcome (ok, refused, error); an approver sees everyone in their projects, anyone else only themselves",
@@ -439,10 +418,7 @@ const GUIDE_ROWS = [
 const REMOTE_NO = [
     // Answered by the local CLI, or a client of a central server itself.
     "", "pulls", "graph", "repos", "repos add", "repos remove", "repos add-from-github", "contract", "skills list", "skills get", "skills install",
-    "link", "unlink", "update", "release", "demo", "chat", "connect", "lead list", "lead create", "lead update", "lead member", "lead transfer",
-    "conversation list", "conversation create", "conversation show", "conversation member", "conversation edit", "conversation withdraw",
-    "conversation read", "conversation follow", "conversation stop",
-    "session capabilities", "session list", "session show", "session changes", "session start", "session send", "session stop", "session resume", "session recover",
+    "link", "unlink", "update", "release", "demo", "chat",
     // This machine's checkout, saved profile, credentials and catch-up.
     "project show", "project use", "brief", "lead token", "lead say", "health",
     "assignment show", "assignment updates", "assignment claim", "assignment check", "assignment brief", "assignment inbox", "assignment ack",

package/dist/team-cli.d.ts

@@ -10,6 +10,7 @@ export type TeamCliOptions = {
     signal?: AbortSignal;
     sleep?: (milliseconds: number, signal: AbortSignal) => Promise<void>;
 };
+/** D5: deprecated (deprecations.ts). Each still runs this release, hidden from help and the contract, with one warning on stderr. */
 export declare const TEAM_CLI_ACTIONS: readonly ['connect', 'lead list', 'lead create', 'lead update', 'lead member', 'lead transfer', 'conversation list', 'conversation create', 'conversation show', 'conversation member', 'conversation edit', 'conversation withdraw', 'conversation read', 'conversation follow', 'conversation stop'];
 export declare class UsageError extends Error {
 }

package/dist/team-cli.js

@@ -9,6 +9,10 @@ import { sessionServiceOrigin } from './session-cli.js';
 import { databasePath } from './store.js';
 import { configBase, namedPath } from './names.js';
 import { parseApiToken } from './api-tokens.js';
+import { deprecationWarning } from './deprecations.js';
+/** The central service's own lead verbs; every other `lead …` (token, say, or none) is the local lead's. */
+const CENTRAL_LEAD_ACTIONS = ['list', 'create', 'update', 'member', 'transfer'];
+/** D5: deprecated (deprecations.ts). Each still runs this release, hidden from help and the contract, with one warning on stderr. */
 export const TEAM_CLI_ACTIONS = ['connect', 'lead list', 'lead create', 'lead update', 'lead member', 'lead transfer', 'conversation list', 'conversation create', 'conversation show', 'conversation member', 'conversation edit', 'conversation withdraw', 'conversation read', 'conversation follow', 'conversation stop'];
 const HELP = `toolroll connect <HTTPS-origin> --as <account> --token-stdin
   Pipe your API token (so_…, from Settings → API tokens) or use --token-file <private-file>;
@@ -335,8 +339,9 @@ function render(reply, listing) {
 /** null means preserve the existing local command path. Nothing here opens a database. */
 export async function maybeRunTeamCommand(argv, write, options = {}) {
     const command = argv[0];
-    // `lead token` is local: the credential a lead agent acts with on this computer.
-    if (command === 'lead' && (argv[1] === 'token' || argv[1] === 'say'))
+    // `lead token` and `lead say` are local: the credential a lead agent acts with on this computer, and its voice. A bare
+    // `lead` is the local lead's too ("lead" means only the lead); only the central service's verbs go on from here.
+    if (command === 'lead' && (argv[1] === 'token' || argv[1] === 'say' || !argv.some(arg => arg === '--profile' || CENTRAL_LEAD_ACTIONS.includes(arg))))
         return null;
     if (!['connect', 'lead', 'conversation', 'chat', 'brief'].includes(command ?? '') && !argv.includes('--profile'))
         return null;
@@ -357,6 +362,11 @@ export async function maybeRunTeamCommand(argv, write, options = {}) {
             return null;
         }
         const explicit = ['connect', 'lead', 'conversation'].includes(command) || argv.some(arg => ['--profile', '--lead', '--conversation', '--authorize', '--terms-digest', '--request-id'].includes(arg));
+        // D5: the central team service is deprecated. It still runs this release; each use says so once, on stderr.
+        const verb = command === 'lead' || command === 'conversation' ? `${command} ${argv.slice(1).find(arg => !arg.startsWith('--')) ?? ''}`.trim() : command === 'connect' ? command : `${command} --conversation`;
+        const warn = () => stderr(deprecationWarning(verb, 'team'));
+        if (explicit)
+            warn();
         if (explicit && (argv.includes('--help') || ['lead', 'conversation'].includes(command) && argv.length === 1)) {
             write(HELP);
             return 0;
@@ -364,6 +374,8 @@ export async function maybeRunTeamCommand(argv, write, options = {}) {
         const saved = profiles(options);
         if (!explicit && !saved)
             return null;
+        if (!explicit)
+            warn();
         const parsed = parse(argv), { flags, action } = parsed;
         if (flags.help || ((command === 'lead' || command === 'conversation') && !action)) {
             write(HELP);

package/dist/team-leads.js

@@ -185,7 +185,7 @@ export class TeamLeads {
         }
         const selected = conversationId ? this.access(actor, conversationId).conversation : conversations[0] ?? null;
         const access = selected ? this.access(actor, selected.id) : null;
-        const messages = selected ? this.db.prepare(`SELECT * FROM (SELECT m.*,q.author,q.request_id,q.status,q.revision AS message_revision,q.error FROM mate_message m LEFT JOIN team_message q ON q.message=m.id WHERE m.thread=? ORDER BY m.id DESC LIMIT 201) ORDER BY id`).all(selected.threadId).map(r => ({ id: Number(r['id']), author: r['role'] === 'assistant' ? access.lead.name : String(r['author'] ?? selected.createdBy), role: String(r['role']), text: String(r['text']), status: (r['status'] ?? 'answered'), revision: Number(r['message_revision'] ?? 1), createdAt: String(r['created_at']), requestId: r['request_id'] == null ? null : String(r['request_id']), turnId: r['turn'] == null ? null : Number(r['turn']), error: r['error'] == null ? null : String(r['error']) })) : [];
+        const messages = selected ? this.db.prepare(`SELECT * FROM (SELECT m.*,q.author,q.request_id,q.status,q.revision AS message_revision,q.error FROM lead_message m LEFT JOIN team_message q ON q.message=m.id WHERE m.thread=? ORDER BY m.id DESC LIMIT 201) ORDER BY id`).all(selected.threadId).map(r => ({ id: Number(r['id']), author: r['role'] === 'assistant' ? access.lead.name : String(r['author'] ?? selected.createdBy), role: String(r['role']), text: String(r['text']), status: (r['status'] ?? 'answered'), revision: Number(r['message_revision'] ?? 1), createdAt: String(r['created_at']), requestId: r['request_id'] == null ? null : String(r['request_id']), turnId: r['turn'] == null ? null : Number(r['turn']), error: r['error'] == null ? null : String(r['error']) })) : [];
         const participants = selected ? this.db.prepare('SELECT account,role,active FROM team_participant WHERE conversation=? ORDER BY account').all(selected.id).map(r => ({ account: String(r['account']), role: String(r['role']), active: Number(r['active']) === 1 })) : [];
         const canManage = account.role === 'approver' && (access ? access.role === 'manager' : leadId ? this.leadAccess(actor, leadId).role === 'manager' : false);
         return { leads, conversations, selected, participants, messages: messages.slice(-200), canManage, canCreateLead: account.role === 'approver' && this.enrolled().some(p => projectAccessAllows(account.projects, p)), canSend: account.role === 'approver' && access !== null && rank(access.role) >= 1 && access.lead.status === 'active', cursor: this.cursor(actor, selected?.id) ?? 0, truncated: messages.length > 200, projects: this.enrolled().filter(p => projectAccessAllows(account.projects, p)), accounts: canManage ? this.store.accountFacts().filter(a => a.revokedAt === null && (selected?.projects ?? []).every(p => projectAccessAllows(a.projects, p))).map(a => a.name) : [] };
@@ -345,14 +345,14 @@ export class TeamLeads {
                 return ok('Message already saved.', { messageId: Number(seen['message']), status: String(seen['status']) });
             }
             const revisions = this.memberRevisions(conversationId, actor.name);
-            const messageId = this.store.appendMateMessage({ thread: conversation.threadId, turn: null, role: 'operator', text }, now);
+            const messageId = this.store.appendLeadMessage({ thread: conversation.threadId, turn: null, role: 'operator', text }, now);
             this.db.prepare("INSERT INTO team_message(message,conversation,author,author_generation,lead_member_revision,participant_revision,request_id,payload_hash,status) VALUES(?,?,?,?,?,?,?,?,'queued')").run(messageId, conversationId, actor.name, actor.generation, revisions.lead, revisions.participant, requestId, digest);
             this.event(lead.id, conversationId, 'message-queued', actor.name, now);
             return ok('Message saved.', { messageId, status: 'queued' });
         }
         if (request.operation === 'read') {
             const id = integer(a['messageId'], 'Message');
-            if (id > 0 && !this.db.prepare('SELECT 1 FROM mate_message WHERE id=? AND thread=?').get(id, conversation.threadId))
+            if (id > 0 && !this.db.prepare('SELECT 1 FROM lead_message WHERE id=? AND thread=?').get(id, conversation.threadId))
                 refuse('not-found', 'Message not available.');
             this.db.prepare('INSERT INTO team_read(conversation,account,message) VALUES(?,?,?) ON CONFLICT(conversation,account) DO UPDATE SET message=MAX(team_read.message,excluded.message)').run(conversationId, actor.name, id);
             return ok('Read position saved.');
@@ -374,9 +374,9 @@ export class TeamLeads {
             if (message['status'] === 'running') {
                 this.db.prepare('UPDATE team_message SET stop_requested=1 WHERE message=?').run(id);
                 if (message['turn_id'] !== null) {
-                    const turn = this.store.getMateTurn(Number(message['turn_id']));
+                    const turn = this.store.getLeadTurn(Number(message['turn_id']));
                     if (turn)
-                        this.store.finalizeMateTurn(turn.id, turn.generation, { state: 'failed', settledMicrousd: turn.reservedMicrousd, unknownSpend: true, tokensIn: 0, tokensOut: 0, failureReason: 'stopped' }, now);
+                        this.store.finalizeLeadTurn(turn.id, turn.generation, { state: 'failed', settledMicrousd: turn.reservedMicrousd, unknownSpend: true, tokensIn: 0, tokensOut: 0, failureReason: 'stopped' }, now);
                 }
             }
             else if (message['status'] === 'queued' || message['status'] === 'uncertain')
@@ -393,7 +393,7 @@ export class TeamLeads {
                 refuse('conflict', 'This message changed or has started. Send a follow-up instead.');
             if (request.operation === 'edit') {
                 const text = messageText(a['text']);
-                this.db.prepare('UPDATE mate_message SET text=? WHERE id=?').run(text, id);
+                this.db.prepare('UPDATE lead_message SET text=? WHERE id=?').run(text, id);
                 this.db.prepare('UPDATE team_message SET revision=revision+1 WHERE message=?').run(id);
             }
             else
@@ -404,9 +404,9 @@ export class TeamLeads {
         refuse('unsupported', 'This action is not available here.');
     }
     revokeMemberSessions(leadId, conversationId, account, now) {
-        this.db.prepare(`UPDATE mate_session SET ended_at=?,ended_by='membership-changed' WHERE approver=? AND ended_at IS NULL
+        this.db.prepare(`UPDATE lead_session SET ended_at=?,ended_by='membership-changed' WHERE approver=? AND ended_at IS NULL
       AND EXISTS(SELECT 1 FROM team_mate_session ms JOIN team_conversation c ON c.thread=ms.thread
-      WHERE ms.session=mate_session.id AND c.lead=? AND (? IS NULL OR c.id=?))`).run(now.toISOString(), account, leadId, conversationId, conversationId);
+      WHERE ms.session=lead_session.id AND c.lead=? AND (? IS NULL OR c.id=?))`).run(now.toISOString(), account, leadId, conversationId, conversationId);
     }
     memberRevisions(conversationId, account) {
         const row = this.db.prepare(`SELECT lm.revision AS lr,p.revision AS pr FROM team_conversation c JOIN team_lead_member lm ON lm.lead=c.lead AND lm.account=? AND lm.active=1 JOIN team_participant p ON p.conversation=c.id AND p.account=lm.account AND p.active=1 WHERE c.id=?`).get(account, conversationId);
@@ -427,7 +427,7 @@ export class TeamLeads {
     claimNext(runner, now = new Date(), eligible) {
         str(runner, 'Runner', 180);
         return this.store.transact(() => {
-            const candidates = this.db.prepare(`SELECT q.*,m.text,c.lead,c.thread FROM team_message q JOIN mate_message m ON m.id=q.message JOIN team_conversation c ON c.id=q.conversation JOIN team_lead l ON l.id=c.lead AND l.status='active'
+            const candidates = this.db.prepare(`SELECT q.*,m.text,c.lead,c.thread FROM team_message q JOIN lead_message m ON m.id=q.message JOIN team_conversation c ON c.id=q.conversation JOIN team_lead l ON l.id=c.lead AND l.status='active'
         WHERE q.status='queued' AND NOT EXISTS(SELECT 1 FROM team_message live WHERE live.conversation=q.conversation AND live.status IN ('running','uncertain'))
         AND NOT EXISTS(SELECT 1 FROM team_message earlier WHERE earlier.conversation=q.conversation AND earlier.status='queued' AND earlier.message<q.message)
         AND (SELECT COUNT(*) FROM team_message running JOIN team_conversation other ON other.id=running.conversation WHERE running.status='running' AND other.lead=c.lead)<2
@@ -453,7 +453,7 @@ export class TeamLeads {
     current(claim) { const row = this.claimed(claim); return row !== undefined && Number(row['stop_requested']) === 0 && this.authorStillAllowed(row); }
     bindTurn(claim, turnId) {
         return this.store.transact(() => { if (!this.current(claim))
-            return false; const turn = this.store.getMateTurn(turnId); if (!turn || turn.thread !== claim.threadId || turn.approver !== claim.actor.name)
+            return false; const turn = this.store.getLeadTurn(turnId); if (!turn || turn.thread !== claim.threadId || turn.approver !== claim.actor.name)
             return false; const changed = this.db.prepare('UPDATE team_message SET turn_id=? WHERE message=? AND turn_id IS NULL').run(turnId, claim.messageId); return Number(changed.changes) === 1; });
     }
     finish(claim, result, now = new Date()) {
@@ -467,7 +467,7 @@ export class TeamLeads {
                 return false;
             this.db.prepare('UPDATE team_message SET status=?,error=?,turn_id=COALESCE(turn_id,?),revision=revision+1 WHERE message=?').run(status, result.error ?? (!allowed ? 'Access changed while this message was running.' : stopped ? 'Stopped.' : null), result.turnId ?? null, claim.messageId);
             if (allowed && !stopped && result.text)
-                this.store.appendMateMessage({ thread: claim.threadId, turn: result.turnId ?? (row['turn_id'] === null ? null : Number(row['turn_id'])), role: 'assistant', text: result.text }, now);
+                this.store.appendLeadMessage({ thread: claim.threadId, turn: result.turnId ?? (row['turn_id'] === null ? null : Number(row['turn_id'])), role: 'assistant', text: result.text }, now);
             this.event(claim.leadId, claim.conversationId, 'message-finished', claim.actor.name, now);
             return true;
         });
@@ -478,7 +478,7 @@ export class TeamLeads {
             const row = this.claimed(claim);
             if (!row || row['turn_id'] !== null || !this.current(claim))
                 return false;
-            if (this.db.prepare('SELECT turn FROM mate_message WHERE id=?').get(claim.messageId)?.['turn'] !== null)
+            if (this.db.prepare('SELECT turn FROM lead_message WHERE id=?').get(claim.messageId)?.['turn'] !== null)
                 return false;
             const changed = this.db.prepare("UPDATE team_message SET status='queued',generation=generation+1,revision=revision+1,runner=NULL,claimed_at=NULL,error=? WHERE message=? AND status='running' AND turn_id IS NULL AND generation=?").run(error, claim.messageId, claim.generation);
             if (Number(changed.changes) !== 1)
@@ -520,7 +520,7 @@ export class TeamLeads {
         return this.store.transact(() => {
             const rows = this.db.prepare("SELECT q.*,c.lead FROM team_message q JOIN team_conversation c ON c.id=q.conversation WHERE runner=? AND status='running'").all(runner);
             for (const row of rows) {
-                const turn = row['turn_id'] === null ? null : this.store.getMateTurn(Number(row['turn_id']));
+                const turn = row['turn_id'] === null ? null : this.store.getLeadTurn(Number(row['turn_id']));
                 const status = turn?.state === 'answered' ? 'answered' : turn?.state === 'failed' && !this.deliveryUncertain(turn.id) ? 'failed' : 'uncertain';
                 const error = status === 'uncertain' ? 'Delivery unconfirmed after the previous worker stopped. Inspect activity before continuing.' : status === 'failed' ? savedFailure(turn?.failureReason) : null;
                 this.db.prepare('UPDATE team_message SET status=?,generation=generation+1,revision=revision+1,error=? WHERE message=?').run(status, error, Number(row['message']));

package/dist/team-runtime.d.ts

@@ -2,14 +2,14 @@ import type { Store } from './store.js';
 import type { WorkspaceRevision } from './workspace-revision.js';
 import { TeamLeads } from './team-leads.js';
 import { type TeamActor, type TeamExecute } from './team-contract.js';
-import { type MateTurnInput } from './mate.js';
+import { type LeadTurnInput } from './lead.js';
 import { type TeamChatProviderResolver } from './team-chat-authorization.js';
 export type TeamRuntimeOptions = {
     store: Store;
     repos: () => readonly string[];
     evidenceRoot: string;
     provider: TeamChatProviderResolver;
-    subscriptionRunner?: MateTurnInput['subscriptionRunner'];
+    subscriptionRunner?: LeadTurnInput['subscriptionRunner'];
     fetcher?: typeof fetch;
     clock?: () => Date;
     capacity?: number;

package/dist/team-runtime.js

@@ -6,8 +6,8 @@ import { workIndexPage } from './work-index.js';
 import { TeamLeads } from './team-leads.js';
 import { teamScopeAllows } from './team-contract.js';
 import { verifyApproverStanding } from './principal.js';
-import { credentialKeyOf, isDirectChatProvider, priceForConfig, subscriptionCredentialKey, mateWorstCaseForPrice } from './converse.js';
-import { runMateTurn } from './mate.js';
+import { credentialKeyOf, isDirectChatProvider, priceForConfig, subscriptionCredentialKey, leadWorstCaseForPrice } from './converse.js';
+import { runLeadTurn } from './lead.js';
 import { teamChatAuthorization } from './team-chat-authorization.js';
 import { updateAdmissionPaused } from './desktop-update-gate.js';
 const hash = (value) => createHash('sha256').update(JSON.stringify(value)).digest('hex');
@@ -34,7 +34,7 @@ export function createTeamRuntime(options) {
         const stamp = hash([grant.termsDigest, grant.enabled, session?.id, session?.spentMicrousd, used, weekly, Boolean(latched), legacyBusy]);
         let reason = grant.waitingReason ?? (!grant.enabled ? 'Enable chat using the current provider and limits.' : null);
         if (!reason && live && session) {
-            const price = priceForConfig(live.config), minimum = isDirectChatProvider(live.config.provider) && price ? mateWorstCaseForPrice(price, 0, { steps: 1 }) : 0;
+            const price = priceForConfig(live.config), minimum = isDirectChatProvider(live.config.provider) && price ? leadWorstCaseForPrice(price, 0, { steps: 1 }) : 0;
             if (latched)
                 reason = 'A previous chat cost is unconfirmed. Open Settings to inspect it.';
             else if (used >= live.config.dailyTurns)
@@ -72,7 +72,7 @@ export function createTeamRuntime(options) {
         const waitingReason = selected && view.canSend && grant.enabled ? admission(actor, selected.id).reason : null;
         return { ...view, chatAuthorization: { ...grant, ...(waitingReason ? { waitingReason } : {}) },
             ...(selected ? { tasks: tasksFor(selected),
-                proposals: store.listMateProposals(selected.threadId).filter(p => p.state !== 'drafting').slice(-40).map(p => ({ id: p.id, turnId: p.turn, title: typeof p.payload['title'] === 'string' ? p.payload['title'].slice(0, 160) : `Review ${p.kind.replaceAll('_', ' ')}`, state: p.state, href: `/chat?conversation=${encodeURIComponent(selected.id)}&proposal=${p.id}` })) } : {}) };
+                proposals: store.listLeadProposals(selected.threadId).filter(p => p.state !== 'drafting').slice(-40).map(p => ({ id: p.id, turnId: p.turn, title: typeof p.payload['title'] === 'string' ? p.payload['title'].slice(0, 160) : `Review ${p.kind.replaceAll('_', ' ')}`, state: p.state, href: `/chat?conversation=${encodeURIComponent(selected.id)}&proposal=${p.id}` })) } : {}) };
     }
     function authorize(actor, args) {
         const id = typeof args['conversationId'] === 'string' ? args['conversationId'] : '';
@@ -113,7 +113,7 @@ export function createTeamRuntime(options) {
                 domain.finish(claim, { status: 'cancelled', error: 'Automatic updates were paused.' }, clock());
                 return;
             }
-            const provider = options.provider(), session = store.teamMateSession(claim.actor.name, claim.threadId), thread = store.getMateThread(claim.threadId);
+            const provider = options.provider(), session = store.teamMateSession(claim.actor.name, claim.threadId), thread = store.getLeadThread(claim.threadId);
             const proof = verifyApproverStanding(store, claim.actor.name, claim.actor.generation, claim.projects);
             if (!provider || !session || !thread || !proof.ok || !grant?.enabled) {
                 domain.finish(claim, { status: 'failed', error: grant?.waitingReason ?? 'Chat authorization changed. Enable chat before sending a new message.' }, clock());
@@ -122,14 +122,14 @@ export function createTeamRuntime(options) {
             const requestId = requestFor(claim);
             // A saved terminal provider receipt wins over delivery bookkeeping.
             // Neither failure nor an unconfirmed receipt causes another provider call.
-            const receipt = store.mateRequestReceipt(session.id, requestId);
+            const receipt = store.leadRequestReceipt(session.id, requestId);
             if (receipt) {
-                const turn = store.getMateTurn(receipt.turn);
+                const turn = store.getLeadTurn(receipt.turn);
                 domain.finish(claim, { status: turn?.state === 'answered' ? 'answered' : turn?.state === 'failed' && !domain.deliveryUncertain(turn.id) ? 'failed' : 'uncertain',
                     turnId: receipt.turn, ...(turn?.state === 'answered' ? {} : { error: 'Inspect the saved response; this message was not sent again.' }) }, clock());
                 return;
             }
-            const result = await runMateTurn({ store, who: proof.who, session, thread, ...provider, message: claim.text, requestId, channel: "console",
+            const result = await runLeadTurn({ store, who: proof.who, session, thread, ...provider, message: claim.text, requestId, channel: "console",
                 ...(() => { const name = view.leads.find(lead => lead.id === claim.leadId)?.name; return name === undefined ? {} : { leadName: name }; })(),
                 queuedMessageId: claim.messageId,
                 onAdmitted: turn => { if (!domain.current(claim) || !domain.bindTurn(claim, turn))

package/dist/teams-chat.js

@@ -1,13 +1,13 @@
 /** Microsoft Teams on the shared chat layer: activities in, Adaptive Cards
  * out, the same durable receipts, rooms and commands as every other channel. */
 import { resultShotsPruned } from "./result-shots.js";
-import { chatQuestionButtons } from "./teammate-question.js";
+import { chatQuestionButtons } from "./subagent-question.js";
 import { chatAskButtons } from "./chat-ask.js";
 import { ChatDeliveryError, ChatState, chatHash, partContent } from "./chat-delivery-state.js";
 import { channelAccess, chatObject as object, planChatNotifications, planRoomMessages, processChatEvent, splitChatText } from "./chat-delivery.js";
 import { PLATFORM_LIMITS } from "./text-limits.js";
 import { roomCommand } from "./chat-rooms.js";
-import { MATE_MESSAGE_MAX_CHARS } from "./mate.js";
+import { LEAD_MESSAGE_MAX_CHARS } from "./lead.js";
 import { renderReply } from "./reply-shape.js";
 import { armedCardText, armedYesLabel, proposalLink, proposalOutcomeText, proposalPreview } from "./chat-channel.js";
 import { chatFlowButtons } from "./chat-flow.js";
@@ -109,7 +109,7 @@ export function receiveTeams(state, identity, raw, serviceUrlClaim, now) {
         const text = isRoom ? withoutMentions(activity.text) : activity.text.trim();
         const pair = /^pair ([a-f0-9]{32})$/.exec(text);
         kind = pair ? "pair" : "message";
-        payload = pair ? { hash: chatHash(pair[1]) } : { text: text.slice(0, MATE_MESSAGE_MAX_CHARS + 1), originalLength: text.length,
+        payload = pair ? { hash: chatHash(pair[1]) } : { text: text.slice(0, LEAD_MESSAGE_MAX_CHARS + 1), originalLength: text.length,
             ...(Array.isArray(activity.attachments) && activity.attachments.length > 0 ? { unsupported: "Incoming files are not supported yet. Describe the request in a message; saved result screenshots open from their links." } : {}) };
         eventId = chatHash(`${identity.installation}:message:${id}`);
     }
@@ -176,7 +176,7 @@ export async function deliverTeamsPart(options) {
         return true;
     }
     try {
-        const session = event.session === null ? null : store.getMateSession(event.session);
+        const session = event.session === null ? null : store.getLeadSession(event.session);
         const repos = await channelAccess(shared, binding, session?.ceilingDigest);
         if (event.kind === "notice" && options.canNotify?.() === false)
             return false;
@@ -197,7 +197,7 @@ export async function deliverTeamsPart(options) {
             actions = openUrlAction(options.origin(), { label: "Open result", path: chatResultHref(content.image.taskId, content.image.run, "checks") });
         }
         if (content.proposal) {
-            const proposal = store.getMateProposal(content.proposal);
+            const proposal = store.getLeadProposal(content.proposal);
             if (!proposal)
                 text = "This proposal is unavailable.";
             else if (proposal.state !== "pending")
@@ -220,7 +220,7 @@ export async function deliverTeamsPart(options) {
         else if (!content.image) {
             // A flow decision (v88): Approve / Edit / Send back, then the link.
             const flow = content.flow || content.choose || content.note ? chatFlowButtons(state, row.id, now).map(one => ({ type: "Action.Submit", title: one.label, data: { so: one.token }, ...(one.action === "approve" ? { style: "positive" } : {}) })) : [];
-            // A teammate's question (v93): its options, then "Answer in words".
+            // A subagent's question (v93): its options, then "Answer in words".
             const asked = content.question ? chatQuestionButtons(state, row.id, now).map(one => ({ type: "Action.Submit", title: one.label.slice(0, 80), data: { so: one.token } })) : [];
             // The lead's question to its owner: its options, then "Something else".
             const owner = content.ask ? chatAskButtons(state, row.id, now).map(one => ({ type: "Action.Submit", title: one.label.slice(0, 80), data: { so: one.token } })) : [];

package/dist/telegram-flow.d.ts

@@ -1,6 +1,6 @@
 import { type FlowChoiceVisit, type FlowSendContent } from "./flow-send.js";
 import { type FlowStage } from "./flows.js";
-import { type InlineButton } from "./telegram-mate.js";
+import { type InlineButton } from "./telegram-lead.js";
 import type { FlowCardRow, FlowRow, Store, TelegramBinding, TelegramFlowAction, TelegramFlowChoice, TelegramFlowPrompt } from "./store.js";
 /** A flow decision's notice: one per visit, and again (`:ask:<ms>`) when the owner asks the lead to approve it. */
 export declare const FLOW_DECIDE_KEY: RegExp;
@@ -14,8 +14,8 @@ type Waiting = {
 export declare function flowDecisionAt(store: Store, cardId: number, entry: number): Waiting | null;
 /**
  * A flow decision as Telegram shows it: the action and where each button takes the card first, then the draft (as
- * the card holds it now, so what is approved is what is read) and why a teammate handed it over, then the flow and
- * zone. `said` is the saved notice's body: the words before its instruction are the teammate's handoff.
+ * the card holds it now, so what is approved is what is read) and why a subagent handed it over, then the flow and
+ * zone. `said` is the saved notice's body: the words before its instruction are the subagent's handoff.
  */
 export declare function flowDecisionText(waiting: Waiting, said: string | null, head?: string): string;
 /** Buttons for one visit, minted before the send; `place` stamps the message they landed on. */

package/dist/telegram-flow.js

@@ -25,7 +25,7 @@ import { keptDraft } from "./flow-draft.js";
 import { decideFlowCard, draftFor, flowCardHref, flowDefinitionOf } from "./flow-engine.js";
 import { chooseFlowCard, flowChoiceAt, flowPersonOf, flowSendPaths, readFlowSend } from "./flow-send.js";
 import { deciderOf, FLOW_END, replyTarget } from "./flows.js";
-import { phoneLinkButton } from "./telegram-mate.js";
+import { phoneLinkButton } from "./telegram-lead.js";
 import { telegramButton } from "./contracts/telegram-callback.js";
 /** A flow decision's notice: one per visit, and again (`:ask:<ms>`) when the owner asks the lead to approve it. */
 export const FLOW_DECIDE_KEY = /^flow-decide:([1-9][0-9]{0,14}):([1-9][0-9]{0,9})(?::ask:[0-9]{1,15})?$/;
@@ -49,8 +49,8 @@ function decisionTerms(waiting) {
 }
 /**
  * A flow decision as Telegram shows it: the action and where each button takes the card first, then the draft (as
- * the card holds it now, so what is approved is what is read) and why a teammate handed it over, then the flow and
- * zone. `said` is the saved notice's body: the words before its instruction are the teammate's handoff.
+ * the card holds it now, so what is approved is what is read) and why a subagent handed it over, then the flow and
+ * zone. `said` is the saved notice's body: the words before its instruction are the subagent's handoff.
  */
 export function flowDecisionText(waiting, said, head = `Approve “${waiting.card.title}”`) {
     const at = said === null ? -1 : said.indexOf(`${waiting.stage.title}: approve`);

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

@@ -1,7 +1,7 @@
 import { type PhoneLink } from "./chat-channel.js";
-export { channelRepos as telegramConversationRepos, resolveChannelMate as resolveTelegramMate, tooLongText, whichTaskText, replyContextFor, NO_PHONE_LINK, NO_TASK_LINK, proposalLink, confirmedLink, proposalPreview, proposalOutcomeText, handoffCardText, confirmedCardText, CHAT_ACTION_PARITY as TELEGRAM_ACTION_PARITY, parityGaps, type PhoneLink, type ResolvedMate, type ParitySupport } from "./chat-channel.js";
-import { type MateAsk, type Store, type TelegramBinding } from "./store.js";
-import type { SubscriptionMateRunner } from "./subscription-chat.js";
+export { channelRepos as telegramConversationRepos, resolveChannelLead as resolveTelegramLead, tooLongText, whichTaskText, replyContextFor, NO_PHONE_LINK, NO_TASK_LINK, proposalLink, confirmedLink, proposalPreview, proposalOutcomeText, handoffCardText, confirmedCardText, CHAT_ACTION_PARITY as TELEGRAM_ACTION_PARITY, parityGaps, type PhoneLink, type ResolvedLead, type ParitySupport } from "./chat-channel.js";
+import { type LeadAsk, type Store, type TelegramBinding } from "./store.js";
+import type { SubscriptionLeadRunner } from "./subscription-chat.js";
 import type { TelegramTransport } from "./telegram.js";
 import { type TelegramCallbackButton, type TelegramUpdate } from "./contracts/telegram-callback.js";
 /** How long one claimed turn may go without a heartbeat before another poller may take it over. */
@@ -18,7 +18,7 @@ export type TelegramConversationOptions = {
     /** Where evidence lives — the same root the console and CLI read results from. */
     evidenceRoot: string;
     /** Injected by tests; production invokes the isolated local harness. */
-    subscriptionRunner?: SubscriptionMateRunner;
+    subscriptionRunner?: SubscriptionLeadRunner;
     /**
      * The https origin a phone link may open, read again on EVERY call (a
      * card is linked immediately before it is sent or edited, never from a
@@ -71,7 +71,7 @@ export declare function phoneLinkButton(origin: string | null, link: PhoneLink |
 /** One inline button: an opaque callback token (a real in-chat act) or a url (navigation, never authority). */
 /** The buttons under the lead's question: options two to a row, then "Something else". Each names the turn and the
  * option's place, nothing more; a tap re-proves that the question is still open and is the tapper's own. */
-export declare function askKeyboard(ask: MateAsk): CallbackKeyboard;
+export declare function askKeyboard(ask: LeadAsk): CallbackKeyboard;
 export type InlineButton = TelegramCallbackButton | {
     text: string;
     url: string;