toolroll 0.9.55 → 0.9.57

package/dist/store.d.ts

@@ -32,9 +32,9 @@ import { type LedgerChainReport } from "./ledger-chain.js";
 import { type ApprovalGate, type ApprovalRules, type ApproverKind, type Filer } from "./approval-policy.js";
 /** A lead reply stopped at its deadline, in the thread as plain words: what happened, what it means, one next step. The
  * proposals it made before then are kept; the cost line only when an unknown cost paused chat. */
-export declare function mateTimeoutNotice(keptProposals: boolean, unknownCost?: boolean): string;
+export declare function leadTimeoutNotice(keptProposals: boolean, unknownCost?: boolean): string;
 /** Whether a turn's proposals stand: it answered, or it stopped at its deadline after its completed tool calls proposed them. */
-export declare function mateTurnKeepsProposals(turn: {
+export declare function leadTurnKeepsProposals(turn: {
     state: string;
     failureReason: string | null;
 } | null): boolean;
@@ -63,7 +63,7 @@ export type TaskActRow = {
 /** The lead's one question to its owner (no version bump): at most one per answered turn, two to four short options;
  * "Something else" is implied. The tapped option comes back as the owner's next message, so nothing here is an answer:
  * a question is open while no later message from the owner sits in its thread. */
-export declare const MATE_ASK_SCHEMA = "\nCREATE TABLE IF NOT EXISTS mate_ask (\n  turn         INTEGER PRIMARY KEY REFERENCES mate_turn(id) ON DELETE CASCADE,\n  thread       INTEGER NOT NULL REFERENCES mate_thread(id) ON DELETE CASCADE,\n  question     TEXT NOT NULL,\n  options_json TEXT NOT NULL,\n  created_at   TEXT NOT NULL\n);\nCREATE INDEX IF NOT EXISTS mate_ask_thread ON mate_ask (thread, turn);\n";
+export declare const LEAD_ASK_SCHEMA = "\nCREATE TABLE IF NOT EXISTS lead_ask (\n  turn         INTEGER PRIMARY KEY REFERENCES mate_turn(id) ON DELETE CASCADE,\n  thread       INTEGER NOT NULL REFERENCES lead_thread(id) ON DELETE CASCADE,\n  question     TEXT NOT NULL,\n  options_json TEXT NOT NULL,\n  created_at   TEXT NOT NULL\n);\nCREATE INDEX IF NOT EXISTS lead_ask_thread ON lead_ask (thread, turn);\n";
 /** Decisions in the chat app (chat-decide.ts; no version bump: additive only). A token names one act on one card (the chat and message it rides); `digest` is
  * what the card showed — a receipt, a revision source, a task stamp, a plan or a commit. */
 /** A flow's "Send to me" and "Person chooses" zones (no version bump: additive only). flow_send keeps what one visit sent its
@@ -80,16 +80,16 @@ export declare const FLOW_SEND_SCHEMA = "\nCREATE TABLE IF NOT EXISTS flow_send
 export declare const RUN_ACTIVITY_SCHEMA = "\nCREATE TABLE IF NOT EXISTS run_activity (\n  run  INTEGER PRIMARY KEY REFERENCES run(id) ON DELETE CASCADE,\n  kind TEXT NOT NULL CHECK (kind IN ('session','message','edit','command','read','search','lookup','plan','delegate','tool')),\n  at   TEXT NOT NULL\n);\n";
 export declare const CHAT_APPROVAL_SCHEMA = "\nCREATE TABLE IF NOT EXISTS chat_approval_setting (\n  approver             TEXT NOT NULL,\n  scope                TEXT NOT NULL,\n  enabled              INTEGER NOT NULL CHECK (enabled IN (0,1)),\n  full_access          INTEGER NOT NULL DEFAULT 0 CHECK (full_access IN (0,1)),\n  attempt_cap_microusd INTEGER CHECK (attempt_cap_microusd IS NULL OR attempt_cap_microusd >= 0),\n  generation           INTEGER NOT NULL,\n  digest               TEXT NOT NULL,\n  updated_by           TEXT NOT NULL,\n  updated_at           TEXT NOT NULL,\n  PRIMARY KEY (approver, scope)\n);\n";
 export declare const CHAT_DECIDE_SCHEMA = "\nCREATE TABLE IF NOT EXISTS chat_decide_action (\n  token       TEXT PRIMARY KEY,\n  channel     TEXT NOT NULL,\n  binding     INTEGER NOT NULL,\n  chat        TEXT NOT NULL,\n  message     TEXT,\n  act         TEXT NOT NULL CHECK (act IN ('accept','changes','retry','approve','not-now','merge')),\n  phase       TEXT NOT NULL CHECK (phase IN ('offer','yes','cancel')),\n  task_id     TEXT NOT NULL,\n  run         INTEGER,\n  digest      TEXT NOT NULL,\n  created_at  TEXT NOT NULL,\n  expires_at  TEXT NOT NULL,\n  consumed_at TEXT\n);\nCREATE INDEX IF NOT EXISTS chat_decide_action_message ON chat_decide_action (channel, chat, message);\nCREATE TABLE IF NOT EXISTS chat_decide_prompt (\n  id          INTEGER PRIMARY KEY AUTOINCREMENT,\n  channel     TEXT NOT NULL,\n  binding     INTEGER NOT NULL,\n  chat        TEXT NOT NULL,\n  task_id     TEXT NOT NULL,\n  run         INTEGER NOT NULL,\n  digest      TEXT NOT NULL,\n  message     TEXT,\n  created_at  TEXT NOT NULL,\n  expires_at  TEXT NOT NULL,\n  consumed_at TEXT\n);\nCREATE INDEX IF NOT EXISTS chat_decide_prompt_open ON chat_decide_prompt (channel, binding, consumed_at);\n";
-export type MateAsk = {
+export type LeadAsk = {
     turn: number;
     thread: number;
     question: string;
     options: string[];
     createdAt: string;
 };
-export declare const MATE_ASK_OTHER = "Something else";
+export declare const LEAD_ASK_OTHER = "Something else";
 /** How long the question's buttons work, on every channel. */
-export declare const MATE_ASK_TTL_MS: number;
+export declare const LEAD_ASK_TTL_MS: number;
 /** What a turn the lead starts itself for automatic crew updates says in the owner's place (lead-follow.ts): never their answer. */
 export declare const LEAD_FOLLOW_MESSAGE = "Automatic crew update: inspect the saved results or decisions and tell me what needs attention. Do not rerun work.";
 /** Settings → Integrations (no version bump): each integration's last check. `outcome` is ok, failed, or absent (the check found
@@ -152,7 +152,14 @@ export type SealedLedgerEntry = LedgerEntry & {
         hash: string;
     } | null;
 };
-export declare const SCHEMA_VERSION = 116;
+export declare const SCHEMA_VERSION = 117;
+/** v117: each table renamed, by its old name. Rows, ids, foreign keys and indexes go with it (renameForV117). */
+export declare const V117_RENAMED_TABLES: Readonly<Record<string, string>>;
+/** v117: the columns renamed with them (by the table's new name): a subagent's rows name it `subagent`. */
+export declare const V117_RENAMED_COLUMNS: readonly (readonly [table: string, from: string, to: string])[];
+/** A row `PRAGMA foreign_key_check` reports, by today's table names: a row already pointing nowhere before v117 is the
+ * same row after it, though RENAME now reports it (and what it points at) under the new names. */
+export declare function orphanKey(row: Record<string, unknown>): string;
 /** v115: the tables migrateToV115 drops. */
 export declare const V115_DROPPED_TABLES: readonly string[];
 /**
@@ -163,6 +170,8 @@ export declare const V115_DROPPED_TABLES: readonly string[];
  * needs the separate verified migration procedure. The desktop update never
  * migrates and does not read this list.
  *
+ * v108 only adds provider_auth_pause; v109 only adds task_ref.auth_wait_pause,
+ * so a database at the v107 baseline (0.5.0) takes the same update.
  * v110 rebuilds action_ledger only to widen its source check ('api', 'mcp'):
  * every row, id and hash-chain link is copied unchanged. v111 adds nullable
  * api_token columns (project limit, rotation); existing tokens read as before.
@@ -183,7 +192,9 @@ export declare const V115_DROPPED_TABLES: readonly string[];
  * separate procedure. v116 is the next declared exception: every row of the 70 old
  * per-app chat tables moves into the shared chat tables keyed by provider, in one
  * transaction that checks each count before the old tables are dropped; the
- * rehearsal checks each moved table's rows arrived (HISTORY_RULES).
+ * rehearsal checks each moved table's rows arrived (HISTORY_RULES). v117 renames the mate's tables to the lead's and the
+ * teammates' to its subagents' (SQLite's RENAME, every row, id and link carried), renames their teammate column, and rewrites four internal kinds from 'teammate' to 'subagent' in place; the rehearsal checks
+ * each renamed table's rows arrived under its new name.
  */
 export declare const UPDATE_SAFE_MIGRATIONS: readonly number[];
 /** Whether a database settled at `version` reaches this build's schema through update-safe migrations alone. */
@@ -455,11 +466,11 @@ export type ChatTurn = {
     acknowledgedBy: string | null;
     replyBytes: number | null;
     candidateCount: number | null;
-    /** 'chat' = fleet chat v13, one request; 'mate-step' = one request of a mate turn. */
+    /** 'chat' = fleet chat v13, one request; 'mate-step' = one request of a lead turn. */
     kind: "chat" | "mate-step";
-    mateTurn: number | null;
+    leadTurn: number | null;
 };
-export type MateSession = {
+export type LeadSession = {
     id: number;
     approver: string;
     approverGeneration: number;
@@ -474,7 +485,7 @@ export type MateSession = {
 };
 /** What one lead thread is about (v77): the lead conversation across every
  * project, one project, or one task (keyed by its root id). */
-export type MateThreadScope = {
+export type LeadThreadScope = {
     kind: "lead";
 } | {
     kind: "project";
@@ -483,23 +494,23 @@ export type MateThreadScope = {
     kind: "task";
     key: string;
 };
-export declare const LEAD_THREAD: MateThreadScope;
-export type MateThread = {
+export declare const LEAD_THREAD: LeadThreadScope;
+export type LeadThread = {
     id: number;
     approver: string;
     ceilingDigest: string;
     openedAt: string;
     lastTurnAt: string | null;
     closedAt: string | null;
-    scope: MateThreadScope;
+    scope: LeadThreadScope;
 };
 /** A thread as the chat list shows it: its scope and its latest message. */
-export type MateThreadSummary = MateThread & {
+export type LeadThreadSummary = LeadThread & {
     lastMessageAt: string | null;
     lastMessage: string | null;
     messages: number;
 };
-export type MateMessage = {
+export type LeadMessage = {
     id: number;
     thread: number;
     turn: number | null;
@@ -508,9 +519,9 @@ export type MateMessage = {
     activity: string | null;
     createdAt: string;
 };
-export type MateProposalKind = "task" | "next" | "reserve" | "hold" | "unhold" | "steer" | "scope" | "cancel" | "answer" | "repair" | "agents" | "review" | "control" | "task_action" | "action";
+export type LeadProposalKind = "task" | "next" | "reserve" | "hold" | "unhold" | "steer" | "scope" | "cancel" | "answer" | "repair" | "agents" | "review" | "control" | "task_action" | "action";
 /** A coordinator's proposal over the MCP gateway (mate arc v3): the same
- * kinds as the mate's (no `task` — filing has its own door), confirmed by
+ * kinds as the lead's (no `task` — filing has its own door), confirmed by
  * any approver whose ceiling admits the repo. */
 export type CoordinatorProposalKind = "next" | "reserve" | "hold" | "unhold" | "scope" | "cancel" | "answer";
 export type CoordinatorProposalState = "pending" | "confirming" | "confirmed" | "refused" | "dismissed" | "expired";
@@ -528,24 +539,24 @@ export type CoordinatorProposal = {
     resolvedBy: string | null;
     outcome: Record<string, unknown> | null;
 };
-export type MateProposalState = "drafting" | "pending" | "confirming" | "confirmed" | "refused" | "dismissed" | "expired";
-export type MateProposal = {
+export type LeadProposalState = "drafting" | "pending" | "confirming" | "confirmed" | "refused" | "dismissed" | "expired";
+export type LeadProposal = {
     id: number;
     thread: number;
     turn: number;
-    kind: MateProposalKind;
+    kind: LeadProposalKind;
     payload: Record<string, unknown>;
     ceilingDigest: string;
-    state: MateProposalState;
+    state: LeadProposalState;
     createdAt: string;
     resolvedAt: string | null;
     resolvedBy: string | null;
     outcome: Record<string, unknown> | null;
 };
 /** The zones a worker's step pass runs, one run per visit. */
-export type FlowStepKind = "check" | "update" | "sort" | "draft" | "request" | "email" | "tool" | "teammate";
-/** An AI teammate (v92): who it is lives in its soul file; `handle` is how zones and chat name it. */
-export type TeammateRow = {
+export type FlowStepKind = "check" | "update" | "sort" | "draft" | "request" | "email" | "tool" | "subagent";
+/** A subagent (v92): who it is lives in its soul file; `handle` is how zones and chat name it. */
+export type SubagentRow = {
     id: number;
     repo: string;
     handle: string;
@@ -565,21 +576,21 @@ export type TeammateRow = {
     /** v97: when its last weekly report went out. */
     weeklyAt: string | null;
 };
-export type TeammateEventKind = "decided" | "handled" | "handed" | "asked" | "answered" | "note" | "paused" | "resumed" | "summary" | "failed";
-export type TeammateEventRow = {
+export type SubagentEventKind = "decided" | "handled" | "handed" | "asked" | "answered" | "note" | "paused" | "resumed" | "summary" | "failed";
+export type SubagentEventRow = {
     id: number;
-    teammate: number;
+    subagent: number;
     card: number | null;
     entry: number | null;
-    kind: TeammateEventKind;
+    kind: SubagentEventKind;
     said: string;
     detail: Record<string, unknown> | null;
     by: string | null;
     at: string;
 };
-export type TeammateQuestionRow = {
+export type SubagentQuestionRow = {
     id: number;
-    teammate: number;
+    subagent: number;
     card: number;
     entry: number;
     question: string;
@@ -595,17 +606,17 @@ export type TeammateQuestionRow = {
     answeredVia: string | null;
     answeredAt: string | null;
     createdAt: string;
-    /** v94: the ask-first tool call this question approves (null: a question of the teammate's own). */
+    /** v94: the ask-first tool call this question approves (null: a question of the subagent's own). */
     toolCall: number | null;
     /** v95: the rule change this question offers its manager (null: not one). */
     suggestion: number | null;
 };
-/** v95: one thing a teammate remembers: kept by it on a turn, or told it by a person. */
-export type TeammateMemoryRow = {
+/** v95: one thing a subagent remembers: kept by it on a turn, or told it by a person. */
+export type SubagentMemoryRow = {
     id: number;
-    teammate: number;
+    subagent: number;
     text: string;
-    source: "teammate" | "person";
+    source: "subagent" | "person";
     card: number | null;
     createdBy: string;
     createdAt: string;
@@ -613,10 +624,10 @@ export type TeammateMemoryRow = {
     updatedAt: string;
     usedAt: string | null;
 };
-/** v95: a rule change a teammate suggests from what its people approved. */
-export type TeammateSuggestionRow = {
+/** v95: a rule change a subagent suggests from what its people approved. */
+export type SubagentSuggestionRow = {
     id: number;
-    teammate: number;
+    subagent: number;
     tool: string;
     action: string;
     rule: ToolRule;
@@ -630,10 +641,10 @@ export type TeammateSuggestionRow = {
 };
 /** v94: one action a project tool offers, as it described itself when listed. */
 export type ToolActionInfo = SavedToolAction;
-/** v94: a teammate's rule for one action: do it, ask first, or never; "free" may ask first above a number in its input. */
+/** v94: a subagent's rule for one action: do it, ask first, or never; "free" may ask first above a number in its input. */
 export type ToolRule = SavedToolRule;
-export type TeammateGrantRow = {
-    teammate: number;
+export type SubagentGrantRow = {
+    subagent: number;
     tool: string;
     actions: ToolActionInfo[];
     rules: Record<string, ToolRule>;
@@ -641,11 +652,11 @@ export type TeammateGrantRow = {
     updatedBy: string;
     updatedAt: string;
 };
-export type TeammateCallState = "asked" | "approved" | "denied" | "refused" | "running" | "done" | "failed";
-/** v94: a tool call a teammate made, or asked to make, on one visit of a card: the receipt. */
-export type TeammateCallRow = {
+export type SubagentCallState = "asked" | "approved" | "denied" | "refused" | "running" | "done" | "failed";
+/** v94: a tool call a subagent made, or asked to make, on one visit of a card: the receipt. */
+export type SubagentCallRow = {
     id: number;
-    teammate: number;
+    subagent: number;
     card: number;
     entry: number;
     tool: string;
@@ -653,7 +664,7 @@ export type TeammateCallRow = {
     input: Record<string, unknown>;
     rule: ToolRule["use"];
     why: string;
-    state: TeammateCallState;
+    state: SubagentCallState;
     result: string | null;
     decidedBy: string | null;
     decidedAt: string | null;
@@ -664,10 +675,10 @@ export type TeammateCallRow = {
     undoneBy: string | null;
     undoneAt: string | null;
 };
-/** v97: one model turn a teammate took. */
-export type TeammateTurnRow = {
+/** v97: one model turn a subagent took. */
+export type SubagentTurnRow = {
     id: number;
-    teammate: number;
+    subagent: number;
     card: number | null;
     model: string;
     ok: boolean;
@@ -781,7 +792,7 @@ export type FlowTriggerRow = {
     updatedAt: string;
 };
 export type FlowEventOutcome = "created" | "ok" | "fail" | "moved" | "approved" | "sent-back" | "cancelled";
-export type MateTurn = {
+export type LeadTurn = {
     id: number;
     approver: string;
     session: number;
@@ -1328,7 +1339,7 @@ export type TelegramConversation = {
     updateId: number;
     messageId: string;
     replyTo: string | null;
-    /** The mate request receipt identity: 32 hex, derived from bot, binding and update. */
+    /** The lead request receipt identity: 32 hex, derived from bot, binding and update. */
     request: string;
     text: string;
     /** Server-authored context for the turn — the exact task/result a reply bound to. */
@@ -1401,8 +1412,8 @@ export type TelegramConversationPartPlan = {
     artifact: number;
     sha256: string;
 };
-/** One verified screenshot a mate turn selected for an exact result (v64): trusted identities only, never bytes or paths. */
-export type MateTurnEvidence = {
+/** One verified screenshot a lead turn selected for an exact result (v64): trusted identities only, never bytes or paths. */
+export type LeadTurnEvidence = {
     turn: number;
     ordinal: number;
     taskId: string;
@@ -1609,69 +1620,6 @@ export declare const REVIEW_ROOT_ATTEMPTS = 3;
 /** The receipt v114 keeps a notification's old single-destination delivery under. No sender claims it: every real
  * destination is a kind and a 64-character hash, or a Telegram binding. */
 export declare const LEGACY_NOTIFICATION_DESTINATION = "legacy:single-destination";
-/** v34: artifact.kind admits 'report'. A table already rebuilt to the v38
- * shape (migrate() runs unconditionally on every open, including a fresh
- * database created straight at the current shape) is a DONE shape too —
- * the same "old-shape-plus-later-widening" recognizer rebuildRunForV29
- * uses for V34_RUN_DDL. */
-export declare function rebuildArtifactForV34(db: Database): void;
-/** v34: incident.kind admits 'malformed-report'. Same v38-shape tolerance as rebuildArtifactForV34. */
-export declare function rebuildIncidentForV34(db: Database): void;
-/** v38: artifact.kind admits 'proof','check-log','screenshot'. */
-export declare function rebuildArtifactForV38(db: Database): void;
-/** v46: artifact.kind additionally admits structured-output. A table
- * already at the v51 shape is a DONE shape (migrate() runs every step on
- * every open). */
-export declare function rebuildArtifactForV46(db: Database): void;
-/** v51: artifact.kind additionally admits plan-contract and review-context. */
-export declare function rebuildArtifactForV51(db: Database): void;
-/** v38: incident.kind admits 'malformed-proof'. */
-export declare function rebuildIncidentForV38(db: Database): void;
-/**
- * v34: run.role admits 'scout'. An EXACT recognizer, like v29's and v33's:
- * the stored DDL must be the v29+v30 shape (either placement of the v30
- * columns is the same shape) or already v34; anything else refuses rather
- * than being guessed. Rows and ids are carried whole; foreign keys are
- * checked before commit; the indexes return with the post-migration block.
- */
-export declare function rebuildRunForV34(db: Database): void;
-export declare function rebuildMateProposalForV66(db: Database): void;
-/** v74: Microsoft Teams joins the recorded surfaces a stop or an answer names. */
-export declare const DECISION_V74_DDL: (name: string) => string;
-export declare const RUN_STOP_V74_DDL: (name: string) => string;
-export declare function rebuildTeamsAuditForV74(db: Database): void;
-export declare const DECISION_V68_DDL_FOR_TESTS: (name: string) => string;
-export declare const RUN_STOP_V68_DDL_FOR_TESTS: (name: string) => string;
-export declare function rebuildDiscordAuditForV68(db: Database): void;
-export declare function rebuildSlackAuditForV67(db: Database): void;
-/** The v63 columns, in order: what an upgrade copies, and what a wind-back keeps. */
-export declare const TELEGRAM_CONVERSATION_PART_V63_COLUMNS: readonly ["conversation", "ordinal", "kind", "text", "reply_to", "proposal", "keyboard_json", "state", "message_id", "attempts", "uncertain", "next_attempt_at", "last_error", "created_at", "sent_at"];
-/** v64: image parts join the outbound conversation parts with typed media identity. Every v63 row, receipt, attempt and uncertain count is carried whole. */
-export declare function rebuildTelegramConversationPartForV64(db: Database): void;
-/** v62: the stop audit admits 'telegram'. Rows, ids and settlements are carried whole. */
-export declare function rebuildRunStopForV62(db: Database): void;
-export declare function rebuildMateProposalForV60(db: Database): void;
-/**
- * v33 (mate v3): `answer` joins mate_proposal's kinds — an EXACT recognizer
- * (v3 review, finding 9): the stored DDL must equal the v32 shape or the
- * v33 shape, byte for byte after canonicalization; anything else refuses
- * rather than being guessed. Rows and ids are carried whole; the one
- * shipped index is recreated; foreign keys are checked before commit.
- */
-export declare function rebuildMateProposalForV33(db: Database): void;
-/** v42: `repair` joins the mate proposal kinds through the same exact,
- * row-preserving copy-rename used for v33. */
-export declare function rebuildMateProposalForV42(db: Database): void;
-/** v43: `steer` joins the mate proposal kinds through the same exact,
- * row-preserving copy-rename used for v33 and v42. */
-export declare function rebuildMateProposalForV43(db: Database): void;
-/** v48: `agents` joins the mate proposal kinds — the same exact,
- * row-preserving copy-rename as v33, v42, and v43. */
-export declare function rebuildMateProposalForV48(db: Database): void;
-/** v35: widen both persisted provider checks with exact-shape rebuilds. */
-export declare function rebuildChatProvidersForV35(db: Database): void;
-/** v36: remove the mate's artificial absolute expiry. */
-export declare function rebuildMateSessionForV36(db: Database): void;
 /** Reporting never creates, migrates, or repairs a store. SQLite itself
  * enforces read-only access, including the race where the file disappears. */
 export declare function openStoreReadOnly(file: string): Store | null;
@@ -3070,7 +3018,7 @@ export declare class Store {
      * transaction can never commit half a seal). A brief FILE whose seal
      * failed is an orphan on disk, not authority — no artifact row points at
      * it. Two concurrent seals race on the comment consumption count, the
-     * deterministic child id, or the repair chain's `source_run UNIQUE`, and
+     * family's next version id, or the repair chain's `source_run UNIQUE`, and
      * exactly one wins; the loser refuses in words with zero rows.
      *
      * The child is filed UNAPPROVED, always: this method never stamps an
@@ -3096,16 +3044,15 @@ export declare class Store {
             bytes: number;
             capture: string;
         };
-        /** The child's own words: an optional deterministic id, its title,
-         * and the explicitly described repair appended to the SOURCE goal. */
+        /** The child's own words: its title and the explicitly described repair
+         * appended to the SOURCE goal. Its id is the family's next version. */
         child: {
-            id?: string;
             title: string;
             repair: string;
         };
         /** Comments to consume, or null when the brief has no comment batch (CI / criterion repair). */
         commentIds: readonly number[] | null;
-        /** v102: who asked for this revision (a person, an AI teammate's "Name (AI)", or none for machine repairs): its filer. */
+        /** v102: who asked for this revision (a person, a subagent's "Name (AI)", or none for machine repairs): its filer. */
         requestedBy?: string | null;
         /** Fresh mode filing coverage, re-proved by the caller INSIDE this
          * transaction (never carried across one): its budget default may only
@@ -3221,7 +3168,6 @@ export declare class Store {
             capture: string;
         };
         child: {
-            id: string;
             title: string;
             repair: string;
         };
@@ -3866,7 +3812,7 @@ export declare class Store {
      * where not — the same arithmetic the admission transaction uses. */
     chatWeeklySpendMicrousd(credentialKey: string, now: Date): number;
     private chatOnlyWeeklySpendMicrousd;
-    /** The day's turns: fleet chat turns plus mate turns — a mate turn is
+    /** The day's turns: fleet chat turns plus lead turns — a lead turn is
      * one turn however many steps it took (slice-1 review, finding 11). */
     chatTurnsToday(approver: string, now: Date): number;
     /** Turns blocking this credential until somebody owns the worst case. */
@@ -4340,7 +4286,7 @@ export declare class Store {
     policyHistory(limit?: number): LedgerEntry[];
     /** Why the policy stops a task's approved terms (its profile, every routed leg), or null. */
     scopePolicyRefusal(taskId: string): string | null;
-    /** Why the policy stops an agent on a provider and model now, or null (chats, teammates, flow steps). */
+    /** Why the policy stops an agent on a provider and model now, or null (chats, subagents, flow steps). */
     agentPolicyRefusal(provider: string, model: string | null): string | null;
     /** Why the policy stops a planner, scout or native coding session (no profile to lower) on a provider and model, or null. */
     sessionPolicyRefusal(provider: string, model: string | null, what: string): string | null;
@@ -4395,7 +4341,7 @@ export declare class Store {
     budgetGate(now: Date): (work: {
         project: string | null;
         person: string | null;
-        teammate: number | null;
+        subagent: number | null;
         agents?: readonly BudgetAgent[];
     }) => BudgetHold;
     /** How each provider would bill new work now (see spend.billingOf). */
@@ -4407,11 +4353,11 @@ export declare class Store {
     /** v105: how a run was really billed, from its own evidence, fixed before its usage is priced. */
     fixRunBilling(id: number, billing: Billing, now: Date): void;
     /** What a task's new work counts toward: its project, its filer (a person, or the person behind a coordinator), and
-     * the teammate that filed it. A revision (an automatic repair included) counts as its source task's. */
+     * the subagent that filed it. A revision (an automatic repair included) counts as its source task's. */
     budgetSubject(taskRef: number): {
         project: string | null;
         person: string | null;
-        teammate: number | null;
+        subagent: number | null;
     };
     /**
      * Stamp the machine's current phase on an OPEN run. A closed run's phase
@@ -4829,7 +4775,7 @@ export declare class Store {
     /**
      * Every live binding for a bot, oldest first — and only while each approver's credential generation still matches.
      * A rotation that somehow missed the sweep reads as no binding at all, which is the failure direction that fails
-     * closed. Several teammates may each hold one (v72); nothing here ranks them.
+     * closed. Several subagents may each hold one (v72); nothing here ranks them.
      */
     liveTelegramBindings(botId: string): TelegramBinding[];
     /** The live binding one Telegram user holds with a bot, if any. */
@@ -4841,7 +4787,7 @@ export declare class Store {
      * `liveTelegramBindings` / `liveTelegramBindingFor` instead. */
     liveTelegramBinding(botId: string): TelegramBinding | null;
     /** Revoke every live binding one person holds with a bot, and everything
-     * those chats could still do. Teammates' bindings are untouched. */
+     * those chats could still do. Subagents' bindings are untouched. */
     unpairTelegram(botId: string, by: string, now: Date): boolean;
     createTelegramAction(...args: Parameters<ChatMessages["createDecisionAction"]>): ReturnType<ChatMessages["createDecisionAction"]>;
     recordTelegramDecisionMessage(...args: Parameters<ChatMessages["recordDecisionMessage"]>): ReturnType<ChatMessages["recordDecisionMessage"]>;
@@ -5106,8 +5052,8 @@ export declare class Store {
         model: string | null;
         repo: string | null;
     }[];
-    /** Delegated chat spend, signed once: the row every mate turn debits. */
-    mintMateSession(args: {
+    /** Delegated chat spend, signed once: the row every lead turn debits. */
+    mintLeadSession(args: {
         approver: string;
         approverGeneration: number;
         credentialKey: string;
@@ -5125,31 +5071,31 @@ export declare class Store {
         termsDigest: string;
         thread: number;
     }, now: Date): number;
-    teamMateSession(approver: string, thread: number): MateSession | null;
-    openTeamMateThread(approver: string, ceilingDigest: string, now: Date): MateThread;
+    teamMateSession(approver: string, thread: number): LeadSession | null;
+    openTeamMateThread(approver: string, ceilingDigest: string, now: Date): LeadThread;
     canUseTeamMateThread(approver: string, generation: number, thread: number): boolean;
     /** Rechecked at admission; membership never grants project or approval standing. */
     teamMateThreadAllows(thread: number, approver: string, generation: number): boolean;
     /** The live session — explicitly ended or still active. Exhaustion is the caller's arithmetic. */
-    activeMateSession(approver: string): MateSession | null;
-    getMateSession(id: number): MateSession | null;
-    endMateSession(id: number, by: string, now: Date): boolean;
+    activeLeadSession(approver: string): LeadSession | null;
+    getLeadSession(id: number): LeadSession | null;
+    endLeadSession(id: number, by: string, now: Date): boolean;
     /** Revocation's companion (ruling 10): an approver's standing ends every session it minted. */
-    endMateSessionsFor(approver: string, by: string, now: Date): number;
+    endLeadSessionsFor(approver: string, by: string, now: Date): number;
     /** The live thread for this approver and scope under THIS ceiling; a
      * thread under another ceiling is closed first (ruling 9) — the surface
      * says why. The lead conversation is the default scope. */
-    openMateThread(approver: string, ceilingDigest: string, now: Date, scope?: MateThreadScope): {
-        thread: MateThread;
+    openLeadThread(approver: string, ceilingDigest: string, now: Date, scope?: LeadThreadScope): {
+        thread: LeadThread;
         ceilingChanged: boolean;
     };
     /** The approver's live thread for one scope, read only — null when none is open. */
-    liveMateThreadFor(approver: string, scope?: MateThreadScope): MateThread | null;
+    liveLeadThreadFor(approver: string, scope?: LeadThreadScope): LeadThread | null;
     /** The lead thread a ceiling change closed just before `current` (ruling 9),
      * read only and for display only: it never continues and never reaches the
      * model. Null when there is none, when it was ended or revoked (its text is
      * gone), or when it closed under the same ceiling. */
-    replacedLeadThread(current: MateThread): MateThread | null;
+    replacedLeadThread(current: LeadThread): LeadThread | null;
     /** The task a paired chat is talking about (v78), or null for the lead conversation. */
     chatFocus(surface: string, binding: number): string | null;
     setChatFocus(surface: string, binding: number, task: string | null, now: Date): void;
@@ -5247,7 +5193,7 @@ export declare class Store {
         failures: number;
         lastOutcome: string | null;
     }, now: Date): void;
-    createTeammate(mate: {
+    createSubagent(mate: {
         repo: string;
         handle: string;
         soul: string;
@@ -5255,42 +5201,42 @@ export declare class Store {
         manager: string;
         by: string;
     }, now: Date): number;
-    getTeammate(id: number): TeammateRow | null;
-    /** The teammate a zone names in a project (paused ones too; never a removed one). */
-    teammateByHandle(repo: string, handle: string): TeammateRow | null;
-    teammates(repos: readonly string[]): TeammateRow[];
-    /** A new version of a teammate's soul file; false when nothing changed. */
-    saveTeammateSoul(id: number, soul: string, by: string, now: Date): boolean;
-    teammateVersions(id: number): {
+    getSubagent(id: number): SubagentRow | null;
+    /** The subagent a zone names in a project (paused ones too; never a removed one). */
+    subagentByHandle(repo: string, handle: string): SubagentRow | null;
+    subagents(repos: readonly string[]): SubagentRow[];
+    /** A new version of a subagent's soul file; false when nothing changed. */
+    saveSubagentSoul(id: number, soul: string, by: string, now: Date): boolean;
+    subagentVersions(id: number): {
         version: number;
         soul: string;
         savedBy: string;
         savedAt: string;
     }[];
-    updateTeammate(id: number, change: {
-        state?: TeammateRow["state"];
+    updateSubagent(id: number, change: {
+        state?: SubagentRow["state"];
         model?: string | null;
         dailyTurns?: number;
         manager?: string;
         summaryAt?: string;
         weeklyAt?: string;
     }, by: string, now: Date): void;
-    addTeammateEvent(event: {
-        teammate: number;
+    addSubagentEvent(event: {
+        subagent: number;
         card?: number | null;
         entry?: number | null;
-        kind: TeammateEventKind;
+        kind: SubagentEventKind;
         said: string;
         detail?: Record<string, unknown> | null;
         by?: string | null;
     }, now: Date): number;
-    /** A teammate's log, newest first; `since` bounds it (a day's summary). */
-    teammateEvents(teammate: number, limit: number, since?: string | null): TeammateEventRow[];
-    /** How many turns (decisions, handled cards, hand-offs, questions, failures, and v94 tool calls) a teammate took since a time: its daily limit. */
-    teammateTurnsSince(teammate: number, since: string): number;
+    /** A subagent's log, newest first; `since` bounds it (a day's summary). */
+    subagentEvents(subagent: number, limit: number, since?: string | null): SubagentEventRow[];
+    /** How many turns (decisions, handled cards, hand-offs, questions, failures, and v94 tool calls) a subagent took since a time: its daily limit. */
+    subagentTurnsSince(subagent: number, since: string): number;
     /** Ask a person about one visit of a card (v94: or to approve one tool call); null when that visit, or that call, already has its question. */
-    openTeammateQuestion(question: {
-        teammate: number;
+    openSubagentQuestion(question: {
+        subagent: number;
         card: number;
         entry: number;
         question: string;
@@ -5303,30 +5249,30 @@ export declare class Store {
         suggestion?: number;
     }, now: Date): number | null;
     /** v94: the first question still open on one visit of a card: its own, or a tool call's approval. */
-    openTeammateQuestionOn(card: number, entry: number): TeammateQuestionRow | null;
+    openSubagentQuestionOn(card: number, entry: number): SubagentQuestionRow | null;
     /** v94: the approval question of one tool call. */
-    teammateQuestionForCall(call: number): TeammateQuestionRow | null;
-    /** v96: the flow a teammate's desk is. */
-    setTeammateDesk(id: number, flow: number): void;
-    addTeammateMemory(memory: {
-        teammate: number;
+    subagentQuestionForCall(call: number): SubagentQuestionRow | null;
+    /** v96: the flow a subagent's desk is. */
+    setSubagentDesk(id: number, flow: number): void;
+    addSubagentMemory(memory: {
+        subagent: number;
         text: string;
-        source: TeammateMemoryRow["source"];
+        source: SubagentMemoryRow["source"];
         card?: number | null;
         by: string;
     }, now: Date): number;
-    teammateMemory(id: number): TeammateMemoryRow | null;
-    /** What a teammate remembers now, newest first: one source, and every word of `words` (any case), when given. */
-    teammateMemories(teammate: number, options?: {
-        source?: TeammateMemoryRow["source"];
+    subagentMemory(id: number): SubagentMemoryRow | null;
+    /** What a subagent remembers now, newest first: one source, and every word of `words` (any case), when given. */
+    subagentMemories(subagent: number, options?: {
+        source?: SubagentMemoryRow["source"];
         words?: readonly string[];
         limit?: number;
-    }): TeammateMemoryRow[];
-    editTeammateMemory(id: number, text: string, by: string, now: Date): boolean;
-    forgetTeammateMemory(id: number, by: string, now: Date): boolean;
-    markTeammateMemoriesUsed(ids: readonly number[], now: Date): void;
-    addTeammateSuggestion(suggestion: {
-        teammate: number;
+    }): SubagentMemoryRow[];
+    editSubagentMemory(id: number, text: string, by: string, now: Date): boolean;
+    forgetSubagentMemory(id: number, by: string, now: Date): boolean;
+    markSubagentMemoriesUsed(ids: readonly number[], now: Date): void;
+    addSubagentSuggestion(suggestion: {
+        subagent: number;
         tool: string;
         action: string;
         rule: ToolRule;
@@ -5334,27 +5280,27 @@ export declare class Store {
         evidence: number[];
         said: string;
     }, now: Date): number;
-    teammateSuggestion(id: number): TeammateSuggestionRow | null;
-    /** A teammate's suggestions about one action, newest first. */
-    teammateSuggestionsFor(teammate: number, tool: string, action: string): TeammateSuggestionRow[];
-    teammateSuggestions(teammate: number, limit?: number): TeammateSuggestionRow[];
+    subagentSuggestion(id: number): SubagentSuggestionRow | null;
+    /** A subagent's suggestions about one action, newest first. */
+    subagentSuggestionsFor(subagent: number, tool: string, action: string): SubagentSuggestionRow[];
+    subagentSuggestions(subagent: number, limit?: number): SubagentSuggestionRow[];
     /** Decide a suggestion, once: false when it was already decided. */
-    decideTeammateSuggestion(id: number, state: "accepted" | "dismissed" | "stale", by: string | null, now: Date): boolean;
+    decideSubagentSuggestion(id: number, state: "accepted" | "dismissed" | "stale", by: string | null, now: Date): boolean;
     /** v95: the question that offers a suggestion to its manager. */
-    teammateQuestionForSuggestion(suggestion: number): TeammateQuestionRow | null;
-    teammateGrants(teammate: number): TeammateGrantRow[];
-    teammateGrant(teammate: number, tool: string): TeammateGrantRow | null;
+    subagentQuestionForSuggestion(suggestion: number): SubagentQuestionRow | null;
+    subagentGrants(subagent: number): SubagentGrantRow[];
+    subagentGrant(subagent: number, tool: string): SubagentGrantRow | null;
     /** Grant a tool, or change what it offers and the rules: the whole row is written. `listedAt` undefined keeps it. */
-    saveTeammateGrant(grant: {
-        teammate: number;
+    saveSubagentGrant(grant: {
+        subagent: number;
         tool: string;
         actions: ToolActionInfo[];
         rules: Record<string, ToolRule>;
         listedAt?: string | null;
     }, by: string, now: Date): void;
-    dropTeammateGrant(teammate: number, tool: string, by: string, now: Date): boolean;
-    addTeammateCall(call: {
-        teammate: number;
+    dropSubagentGrant(subagent: number, tool: string, by: string, now: Date): boolean;
+    addSubagentCall(call: {
+        subagent: number;
         card: number;
         entry: number;
         tool: string;
@@ -5362,32 +5308,32 @@ export declare class Store {
         input: Record<string, unknown>;
         rule: ToolRule["use"];
         why: string;
-        state: TeammateCallState;
+        state: SubagentCallState;
         result?: string | null;
         undoOf?: number;
         decidedBy?: string;
     }, now: Date): number;
-    /** v103: a teammate's tool call in the ledger, as the teammate (or the person who decided it), on its card's task. */
-    private recordTeammateCall;
+    /** v103: a subagent's tool call in the ledger, as the subagent (or the person who decided it), on its card's task. */
+    private recordSubagentCall;
     /** v97: a call was undone by a person; false when it already was. */
-    markTeammateCallUndone(id: number, by: string, now: Date): boolean;
-    /** v97: cards someone moved by hand right after this actor (a teammate) moved them, since a time: what people overrode. */
+    markSubagentCallUndone(id: number, by: string, now: Date): boolean;
+    /** v97: cards someone moved by hand right after this actor (a subagent) moved them, since a time: what people overrode. */
     flowMovesOverridden(actor: string, since: string): {
         card: number;
         flow: number;
         title: string;
-        teammateTo: string;
+        subagentTo: string;
         personTo: string;
         by: string;
         at: string;
     }[];
     /** v97: undo calls a person asked for that aren't made yet. */
-    pendingTeammateUndos(): TeammateCallRow[];
+    pendingSubagentUndos(): SubagentCallRow[];
     /** v97: an undo that failed leaves the call as it was. */
-    clearTeammateCallUndone(id: number, now: Date): void;
-    /** v97: one model turn a teammate took, with what it cost. */
-    addTeammateTurn(turn: {
-        teammate: number;
+    clearSubagentCallUndone(id: number, now: Date): void;
+    /** v97: one model turn a subagent took, with what it cost. */
+    addSubagentTurn(turn: {
+        subagent: number;
         card: number | null;
         model: string;
         ok: boolean;
@@ -5402,31 +5348,31 @@ export declare class Store {
         model: string | null;
         costUsd: number | null;
     }, now: Date): void;
-    teammateTurns(teammate: number, since: string): TeammateTurnRow[];
-    teammateCall(id: number): TeammateCallRow | null;
+    subagentTurns(subagent: number, since: string): SubagentTurnRow[];
+    subagentCall(id: number): SubagentCallRow | null;
     /** Move a call on, only from the state it is known to be in: false when someone else moved it first. */
-    moveTeammateCall(id: number, from: readonly TeammateCallState[], change: {
-        state: TeammateCallState;
+    moveSubagentCall(id: number, from: readonly SubagentCallState[], change: {
+        state: SubagentCallState;
         result?: string | null;
         decidedBy?: string;
     }, now: Date): boolean;
     /** A card's receipts, oldest first: one visit (`entry`), or every visit. */
-    teammateCallsOn(card: number, entry?: number | null): TeammateCallRow[];
-    /** A teammate's receipts, newest first; `since` bounds them (a day's summary). */
-    teammateCallsOf(teammate: number, limit: number, since?: string | null): TeammateCallRow[];
-    teammateQuestion(id: number): TeammateQuestionRow | null;
-    /** The question a teammate asked of its own on one visit (never a tool call's approval). */
-    teammateQuestionFor(card: number, entry: number): TeammateQuestionRow | null;
-    /** Open questions for these teammates, oldest first. */
-    openTeammateQuestions(teammates: readonly number[]): TeammateQuestionRow[];
+    subagentCallsOn(card: number, entry?: number | null): SubagentCallRow[];
+    /** A subagent's receipts, newest first; `since` bounds them (a day's summary). */
+    subagentCallsOf(subagent: number, limit: number, since?: string | null): SubagentCallRow[];
+    subagentQuestion(id: number): SubagentQuestionRow | null;
+    /** The question a subagent asked of its own on one visit (never a tool call's approval). */
+    subagentQuestionFor(card: number, entry: number): SubagentQuestionRow | null;
+    /** Open questions for these subagents, oldest first. */
+    openSubagentQuestions(subagents: readonly number[]): SubagentQuestionRow[];
     /** The answer, once: false when it was already answered (or dropped). */
-    answerTeammateQuestion(id: number, answer: {
+    answerSubagentQuestion(id: number, answer: {
         choice: string | null;
         text: string | null;
         by: string;
         via: string;
     }, now: Date): boolean;
-    dropTeammateQuestion(id: number, now: Date): void;
+    dropSubagentQuestion(id: number, now: Date): void;
     /** A step waiting on a person's answer becomes due now (the answer came). */
     wakeFlowStep(card: number, entry: number, now: Date): void;
     /** Cards arriving in one zone of a flow after a history line: what a trigger on another flow follows. */
@@ -5620,12 +5566,12 @@ export declare class Store {
     recordTelegramTaskMessage(...args: Parameters<ChatMessages["recordTaskMessage"]>): ReturnType<ChatMessages["recordTaskMessage"]>;
     /** The approver's live personal threads that have messages, most recent
      * first — the chat list. Team conversations list themselves. */
-    listMateThreads(approver: string, limit?: number): MateThreadSummary[];
-    getMateThread(id: number): MateThread | null;
+    listLeadThreads(approver: string, limit?: number): LeadThreadSummary[];
+    getLeadThread(id: number): LeadThread | null;
     /** `--end` and revocation: the thread's text and every proposal in it are
      * deleted; the thread row stays as closed metadata (when, whose). */
-    closeMateThreadsFor(approver: string, now: Date): number;
-    appendMateMessage(message: {
+    closeLeadThreadsFor(approver: string, now: Date): number;
+    appendLeadMessage(message: {
         thread: number;
         turn: number | null;
         role: "operator" | "assistant";
@@ -5633,37 +5579,37 @@ export declare class Store {
         activity?: string | null;
     }, now: Date): number;
     /** The last `limit` messages, oldest first. */
-    listMateMessages(thread: number, limit: number): MateMessage[];
+    listLeadMessages(thread: number, limit: number): LeadMessage[];
     /** A proposal is inert (`drafting`) until its turn finalizes. */
-    draftMateProposal(proposal: {
+    draftLeadProposal(proposal: {
         thread: number;
         turn: number;
-        kind: MateProposalKind;
+        kind: LeadProposalKind;
         payload: Record<string, unknown>;
         ceilingDigest: string;
     }, now: Date): number;
     /** Record this turn's one question; false when the turn already asked one. */
-    recordMateAsk(ask: {
+    recordLeadAsk(ask: {
         turn: number;
         thread: number;
         question: string;
         options: readonly string[];
     }, now: Date): boolean;
     /** A failed turn keeps no question, as it keeps no drafts. */
-    dropMateAsk(turn: number): void;
+    dropLeadAsk(turn: number): void;
     /** The question an ANSWERED turn asked; null when it asked none or did not answer. */
-    mateAsk(turn: number): MateAsk | null;
+    leadAsk(turn: number): LeadAsk | null;
     /** What a tap on the question finds: open; answered (its owner has written in its thread since the reply that asked
      * it, typed or tapped; a turn the lead started itself, or another person's message, is no answer); or expired (older
-     * than MATE_ASK_TTL_MS, or the question or the reply that asked it is gone, as after a retention purge). */
-    mateAskState(turn: number, now: Date): {
+     * than LEAD_ASK_TTL_MS, or the question or the reply that asked it is gone, as after a retention purge). */
+    leadAskState(turn: number, now: Date): {
         state: "open";
-        ask: MateAsk;
+        ask: LeadAsk;
     } | {
         state: "answered" | "expired";
     };
-    /** The question while it is open (see mateAskState); null otherwise. */
-    mateAskOpen(turn: number, now: Date): MateAsk | null;
+    /** The question while it is open (see leadAskState); null otherwise. */
+    leadAskOpen(turn: number, now: Date): LeadAsk | null;
     /**
      * Record the screenshots one turn selected for an exact result, under the
      * turn, so a channel that delivers files can plan them from the completed
@@ -5672,25 +5618,25 @@ export declare class Store {
      * before upload. A turn holds at most `cap` images; the same artifact is
      * recorded once. Returns how many of THESE rows are recorded after the call.
      */
-    recordMateTurnEvidence(turn: number, rows: readonly Omit<MateTurnEvidence, "turn" | "ordinal" | "createdAt">[], cap: number, now: Date): number;
+    recordLeadTurnEvidence(turn: number, rows: readonly Omit<LeadTurnEvidence, "turn" | "ordinal" | "createdAt">[], cap: number, now: Date): number;
     /** The screenshots a turn selected, in selection order — meaningful only for a turn that ANSWERED (a failed turn's rows are deleted). */
-    listMateTurnEvidence(turn: number): MateTurnEvidence[];
+    listLeadTurnEvidence(turn: number): LeadTurnEvidence[];
     /** A failed turn's selection is DELETED with its drafts: nothing a failed turn selected is ever sent. */
-    discardMateTurnEvidence(turn: number): number;
+    discardLeadTurnEvidence(turn: number): number;
     /** Drafts become confirmable only under a turn that ANSWERED (review finding 12). */
-    promoteMateProposals(turn: number): number;
+    promoteLeadProposals(turn: number): number;
     /** A failed turn's drafts are DELETED — nothing a failed turn produced is durable (finding 4). */
-    discardMateProposals(turn: number): number;
-    getMateProposal(id: number): MateProposal | null;
-    listMateProposals(thread: number, states?: readonly MateProposalState[]): MateProposal[];
+    discardLeadProposals(turn: number): number;
+    getLeadProposal(id: number): LeadProposal | null;
+    listLeadProposals(thread: number, states?: readonly LeadProposalState[]): LeadProposal[];
     /** The state CAS confirmation rides on (ruling 7). */
-    casMateProposal(id: number, from: MateProposalState, to: MateProposalState, by: string | null, outcome: Record<string, unknown> | null, now: Date): boolean;
+    casLeadProposal(id: number, from: LeadProposalState, to: LeadProposalState, by: string | null, outcome: Record<string, unknown> | null, now: Date): boolean;
     /**
      * The turn's reservation, in ONE transaction against the session and the
      * weekly ledger, before any dispatch (ruling 5). One live turn per
      * approver serializes the console and the CLI.
      */
-    openMateTurn(args: {
+    openLeadTurn(args: {
         approver: string;
         session: number;
         thread: number;
@@ -5707,17 +5653,17 @@ export declare class Store {
         ok: false;
         reason: "latched" | "concurrent" | "daily-cap" | "session-exhausted" | "session-ended" | "not-yours" | "thread-closed" | "over-budget" | "monthly-budget";
     };
-    startMateTurn(id: number, now: Date): {
+    startLeadTurn(id: number, now: Date): {
         ok: true;
         generation: number;
     } | {
         ok: false;
     };
-    /** One provider request of a mate turn: a chat_turn row of kind
+    /** One provider request of a lead turn: a chat_turn row of kind
      * 'mate-step', reserved at zero (the turn holds the reservation), with
      * the same dispatch CAS, terminal CAS, and crash latch as fleet chat. */
-    openMateStep(args: {
-        mateTurn: number;
+    openLeadStep(args: {
+        leadTurn: number;
         generation: number;
         approver: string;
         credentialKey: string;
@@ -5739,7 +5685,7 @@ export declare class Store {
      * releases money it cannot prove was not spent; acknowledging the step
      * later does not refund it.
      */
-    finalizeMateTurn(id: number, generation: number, outcome: {
+    finalizeLeadTurn(id: number, generation: number, outcome: {
         state: "answered" | "failed";
         settledMicrousd: number;
         unknownSpend?: boolean;
@@ -5756,18 +5702,18 @@ export declare class Store {
     }, now: Date): boolean;
     /** A turn stopped at its deadline: the proposals its completed tool calls drafted (each validated when drafted) go pending, as an
      * answered turn's do; anything the provider sent after them was never acted on. Every other failure still deletes its drafts. */
-    private keepTimedOutMateProposals;
+    private keepTimedOutLeadProposals;
     /** Revocation's companion for a loop in flight (finding 5): every live
      * turn of the approver fails NOW, charged its whole reservation, its
      * generation moved so the returning loop's terminal CAS loses. */
-    failLiveMateTurnsFor(approver: string, reason: string, now: Date, privateOnly?: boolean): number;
+    failLiveLeadTurnsFor(approver: string, reason: string, now: Date, privateOnly?: boolean): number;
     /** The crash sweep for turns: past the deadline, failed. The session is
      * charged the settled sum of the steps that answered — unless any step
      * is unproven (dispatched and never settled, or latched), in which case
      * the WHOLE reservation is charged (finding 1). Like a turn that stopped
      * at its own deadline, it keeps the proposals its completed tool calls
      * drafted and says, in the thread, that the reply took too long. */
-    sweepStaleMateTurns(now: Date): number;
+    sweepStaleLeadTurns(now: Date): number;
     /** A task_ref by its row id: the external id and repo — for decisions, which hang off runs. */
     refById(id: number): {
         id: number;
@@ -5795,10 +5741,10 @@ export declare class Store {
     casCoordinatorProposal(id: number, from: CoordinatorProposalState, to: CoordinatorProposalState, by: string | null, outcome: Record<string, unknown> | null, now: Date): boolean;
     /** Pending rows expire after seven days; a revoked credential's pending rows expire at once. */
     sweepCoordinatorProposals(now: Date, cid?: string): number;
-    recentMateTurns(approver: string, limit?: number): MateTurn[];
-    getMateTurn(id: number): MateTurn | null;
-    liveMateTurnFor(approver: string): MateTurn | null;
-    mateStepsOf(mateTurn: number): ChatTurn[];
+    recentLeadTurns(approver: string, limit?: number): LeadTurn[];
+    getLeadTurn(id: number): LeadTurn | null;
+    liveLeadTurnFor(approver: string): LeadTurn | null;
+    leadStepsOf(leadTurn: number): ChatTurn[];
     /** Remember a project was opened. Upsert keeps added_at; recency always moves.
      * A project added for the first time starts on Quick checks. */
     upsertProject(path: string, name: string, now: Date): void;
@@ -6524,7 +6470,7 @@ export declare class Store {
     private bumpPushFailures;
     /** A chat send receipt contains no message text. The session is part of
      * its namespace; callers must prove that session before reading it. */
-    mateRequestReceipt(session: number, request: string): {
+    leadRequestReceipt(session: number, request: string): {
         digest: string;
         turn: number;
     } | null;