toolroll 0.9.55 → 0.9.57

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)
@@ -58,7 +58,7 @@ export function createTeamRuntime(options) {
         const previous = pages.get(key);
         if (revision && previous?.revision === revision && previous.expires > now.getTime())
             return previous.page;
-        const page = workIndexPage(store, now, { principal: 'operator', repos: selected.projects }, { leadId: selected.leadId, limit: 40 });
+        const page = workIndexPage(store, now, { principal: 'operator', repos: selected.projects }, { leadId: selected.leadId, limit: 40, root: options.evidenceRoot });
         if (revision && options.workspaceRevision) {
             if (pages.size >= 64)
                 pages.delete(pages.keys().next().value);
@@ -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;

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

@@ -1,11 +1,11 @@
 import { CHAT_ACTIONS, sharedActionAllowsChallenge, sharedActionPayload } from "./chat-actions.js";
-import { taskInCeiling, mirrorToTaskChat, couldNotAnswerText, channelRepos as telegramConversationRepos, resolveChannelMate as resolveTelegramMate, tooLongText, whichTaskText, replyContextFor, NO_PHONE_LINK, NO_TASK_LINK, proposalLink, confirmedLink, proposalPreview, proposalOutcomeText, handoffCardText, confirmedCardText } 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 } from "./chat-channel.js";
+import { taskInCeiling, mirrorToTaskChat, couldNotAnswerText, channelRepos as telegramConversationRepos, resolveChannelLead as resolveTelegramLead, tooLongText, whichTaskText, replyContextFor, NO_PHONE_LINK, NO_TASK_LINK, proposalLink, confirmedLink, proposalPreview, proposalOutcomeText, handoffCardText, confirmedCardText } from "./chat-channel.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 } from "./chat-channel.js";
 /**
  * The paired phone as one more way to use the same assistant.
  *
- * Transport only. An ordinary private Telegram message becomes a mate turn
- * through `runMateTurn` — the same saved thread, proposal rows, confirm
+ * Transport only. An ordinary private Telegram message becomes a lead turn
+ * through `runLeadTurn` — the same saved thread, proposal rows, confirm
  * doors and result actions the console and `toolroll chat` use —
  * and every act is still a card the operator confirms. This module owns
  * what is specific to the wire: proving the pairing (chat AND immutable
@@ -23,10 +23,10 @@ export { channelRepos as telegramConversationRepos, resolveChannelMate as resolv
  * the console and CLI state), and the door re-proves everything again.
  */
 import { createHash, randomBytes } from "node:crypto";
-import { MATE_MESSAGE_MAX_CHARS, mateFailureText, runMateTurn } from "./mate.js";
-import { confirmMateProposal, dismissMateProposal } from "./mate-doors.js";
+import { LEAD_MESSAGE_MAX_CHARS, leadFailureText, runLeadTurn } from "./lead.js";
+import { confirmLeadProposal, dismissLeadProposal } from "./lead-doors.js";
 import { ceilingDigestOf, verifyApproverStanding } from "./principal.js";
-import { MATE_ASK_OTHER } from "./store.js";
+import { LEAD_ASK_OTHER } from "./store.js";
 import { phoneText } from "./telegram-status.js";
 import { shapeReplyParts, telegramReply } from "./reply-shape.js";
 import { WARM_EMOJI, warmTurn } from "./chat-warmth.js";
@@ -112,7 +112,7 @@ export function askKeyboard(ask) {
     const rows = [];
     for (let at = 0; at < ask.options.length; at += 2)
         rows.push(ask.options.slice(at, at + 2).map((label, offset) => telegramButton(label.slice(0, 60), `ask:${ask.turn}:${at + offset}`)));
-    rows.push([telegramButton(MATE_ASK_OTHER, `ask:${ask.turn}:x`)]);
+    rows.push([telegramButton(LEAD_ASK_OTHER, `ask:${ask.turn}:x`)]);
     return rows;
 }
 /** Mint the card's tokens before the send, so a tap can never name a token that does not exist. */
@@ -151,7 +151,7 @@ export function applyProposalTap(store, binding, token, message, repos, options,
         ack("that button is stale — send /status to see what still waits");
         return { effects, confirmed: false, ignored: true };
     }
-    const proposal = store.getMateProposal(action.proposal);
+    const proposal = store.getLeadProposal(action.proposal);
     if (proposal === null) {
         store.consumeTelegramProposalAction(token, now);
         ack("that card no longer exists");
@@ -209,10 +209,10 @@ export function applyProposalTap(store, binding, token, message, repos, options,
             ack("that button was already used");
             return { effects, confirmed: false, ignored: true };
         }
-        const done = dismissMateProposal(store, who, proposal.id, now);
+        const done = dismissLeadProposal(store, who, proposal.id, now);
         store.consumeTelegramProposalActions(proposal.id, now);
         ack(done ? "dismissed" : "that proposal was already acted on");
-        edit(done ? "Dismissed." : proposalOutcomeText(store.getMateProposal(proposal.id) ?? proposal));
+        edit(done ? "Dismissed." : proposalOutcomeText(store.getLeadProposal(proposal.id) ?? proposal));
         return { effects, confirmed: false, ignored: !done };
     }
     if (action.phase === "cancel") {
@@ -273,7 +273,7 @@ export function applyProposalTap(store, binding, token, message, repos, options,
         ack(action.phase === "yes" ? "that confirmation expired — start again from Confirm" : "that button was already used");
         return { effects, confirmed: false, ignored: true };
     }
-    const outcome = confirmMateProposal(store, who, proposal.id, now, {
+    const outcome = confirmLeadProposal(store, who, proposal.id, now, {
         via: "telegram",
         evidenceRoot: options.evidenceRoot,
         confirm: action.phase === "yes",
@@ -405,7 +405,7 @@ async function runTelegramConversation(row, args) {
     const deliver = async (outcomeWord) => {
         // The row as it is NOW: the session was bound after this claim read it.
         const bound = store.getTelegramConversation(row.id)?.session ?? null;
-        const session = bound === null ? null : store.getMateSession(bound);
+        const session = bound === null ? null : store.getLeadSession(bound);
         if (session === null) {
             await notify("This conversation was restarted before my reply went out, so it wasn't sent. Nothing was changed. Send your message again.");
             finish({ state: "failed", outcome: "unsent:no-session" });
@@ -421,7 +421,7 @@ async function runTelegramConversation(row, args) {
                 continue;
             const now = clock();
             if (part.kind === "card") {
-                const proposal = part.proposal === null ? null : store.getMateProposal(part.proposal);
+                const proposal = part.proposal === null ? null : store.getLeadProposal(part.proposal);
                 if (proposal === null || proposal.state !== "pending") {
                     // Confirmed or dismissed from the console or the terminal before the card went out: moot, not lost.
                     if (!store.dropTelegramConversationPart(row.id, part.ordinal, owner, proposal === null ? "the proposal is gone" : `the proposal was already ${proposal.state}`, now))
@@ -523,7 +523,7 @@ async function runTelegramConversation(row, args) {
                 // A card's link is minted NOW, from the persisted proposal and the
                 // origin configured at this moment: a retry after the setting changed
                 // or went away carries the current truth, never a stored URL.
-                const proposal = part.kind === "card" && part.proposal !== null ? store.getMateProposal(part.proposal) : null;
+                const proposal = part.kind === "card" && part.proposal !== null ? store.getLeadProposal(part.proposal) : null;
                 const origin = proposal === null ? null : options.phoneOrigin?.() ?? null;
                 const wanted = proposal === null ? null : proposalLink(store, proposal, repos);
                 const keyboard = keyboardWith(part.keyboard, phoneLinkButton(origin, wanted));
@@ -597,11 +597,11 @@ async function runTelegramConversation(row, args) {
                 const now = clock();
                 const parts = shapeReplyParts(reply, PART_CAP, { asked: row.text, appOrigin: options.phoneOrigin?.() ?? null }, shaped => telegramReply(shaped).text.length).map((text, index) => ({ kind: "reply", text, replyTo: index === 0 ? row.messageId : null }));
                 // The lead's question to its owner: one tap per option, then "Something else".
-                const ask = store.mateAsk(turn);
+                const ask = store.leadAsk(turn);
                 if (ask !== null)
                     parts.push({ kind: "reply", text: phoneText(ask.question, 1_000), keyboard: askKeyboard(ask) });
                 // Only a turn that answered may have its selection sent: a failed or revoked turn's rows were deleted with its drafts, and the state is read again here.
-                const selected = store.getMateTurn(turn)?.state === "answered" ? store.listMateTurnEvidence(turn) : [];
+                const selected = store.getLeadTurn(turn)?.state === "answered" ? store.listLeadTurnEvidence(turn) : [];
                 for (const image of selected)
                     parts.push({ kind: "image", text: image.caption, taskId: image.taskId, run: image.run, artifact: image.artifact, sha256: image.sha256 });
                 for (const proposal of proposals) {
@@ -625,8 +625,8 @@ async function runTelegramConversation(row, args) {
     const recover = async (session, turnId, repos) => {
         // A turn that died past its deadline is swept to failed first, so a
         // restart reports the truth instead of waiting on a ghost.
-        store.sweepStaleMateTurns(clock());
-        const turn = store.getMateTurn(turnId);
+        store.sweepStaleLeadTurns(clock());
+        const turn = store.getLeadTurn(turnId);
         if (turn === null) {
             finish({ state: "failed", outcome: "replayed:missing" });
             report.refused++;
@@ -638,13 +638,13 @@ async function runTelegramConversation(row, args) {
             return;
         }
         if (turn.state !== "answered") {
-            await notify(mateFailureText(turn.failureReason));
+            await notify(leadFailureText(turn.failureReason));
             finish({ state: "failed", outcome: `replayed:${turn.failureReason ?? "failed"}` });
             report.refused++;
             return;
         }
-        const reply = store.listMateMessages(turn.thread, 200).find(one => one.turn === turn.id && one.role === "assistant")?.text ?? "(the reply text is no longer in the thread)";
-        const proposals = store.listMateProposals(turn.thread, ["pending"]).filter(one => one.turn === turn.id);
+        const reply = store.listLeadMessages(turn.thread, 200).find(one => one.turn === turn.id && one.role === "assistant")?.text ?? "(the reply text is no longer in the thread)";
+        const proposals = store.listLeadProposals(turn.thread, ["pending"]).filter(one => one.turn === turn.id);
         if (!plan(session, turnId, reply, proposals, repos) && store.listTelegramConversationParts(row.id).length === 0)
             return;
         await sendOrHandOff("replayed");
@@ -676,14 +676,14 @@ async function runTelegramConversation(row, args) {
     // 4. A session bound before an earlier dispatch: the receipt lives there,
     // whatever session is live today.
     if (row.session !== null) {
-        const receipt = store.mateRequestReceipt(row.session, row.request);
+        const receipt = store.leadRequestReceipt(row.session, row.request);
         if (receipt !== null) {
             await recover(row.session, receipt.turn, repos);
             return;
         }
     }
     // 5. The session and thread — shared with the console and the CLI.
-    const resolved = resolveTelegramMate(store, binding, repos, clock());
+    const resolved = resolveTelegramLead(store, binding, repos, clock());
     if (!resolved.ok && resolved.reason === "busy") {
         await requeue("busy");
         return;
@@ -722,7 +722,7 @@ async function runTelegramConversation(row, args) {
     });
     let outcome;
     try {
-        outcome = await runMateTurn({
+        outcome = await runLeadTurn({
             store, who, session, thread, config, key: null, message: row.text, requestId: row.request,
             ...(row.context === null ? {} : { context: row.context }),
             ...(options.subscriptionRunner === undefined ? {} : { subscriptionRunner: options.subscriptionRunner }),
@@ -733,7 +733,7 @@ async function runTelegramConversation(row, args) {
         clearInterval(heartbeat);
         warm.stop();
     }
-    const receipt = store.mateRequestReceipt(session.id, row.request);
+    const receipt = store.leadRequestReceipt(session.id, row.request);
     if (receipt !== null)
         store.bindTelegramConversationTurn(row.id, owner, session.id, receipt.turn);
     if (!outcome.ok && "refused" in outcome) {
@@ -761,7 +761,7 @@ async function runTelegramConversation(row, args) {
     if (row.taskId !== null)
         mirrorToTaskChat(store, who, row.taskId, "Telegram", row.text, outcome.reply, clock());
     // 7. The reply and its cards: durable first, then sent.
-    const proposals = store.listMateProposals(thread.id, ["pending"]).filter(one => one.turn === outcome.turn);
+    const proposals = store.listLeadProposals(thread.id, ["pending"]).filter(one => one.turn === outcome.turn);
     if (!plan(session.id, outcome.turn, outcome.reply, proposals, who.repos) && store.listTelegramConversationParts(row.id).length === 0)
         return;
     await sendOrHandOff("answered");

package/dist/telegram-status.d.ts

@@ -17,9 +17,16 @@ export declare const PHONE_HELP: string;
 /** The same display scrub for every phone-bound string a person or a model authored. */
 export declare const phoneText: typeof publicChatText;
 export declare function projectLabel(repo: string): string;
+/** The phone's reading of saved results: `root` lets a finished result read its saved checks, requirements and
+ * review exactly as the console does. Without it, the dispatch diagnosis speaks. */
+export type PhoneRead = {
+    root?: string | undefined;
+    now?: Date;
+    repos?: readonly string[];
+};
 /** repos is the transport's explicit enrollment ceiling, never opened-project
  * history. This snapshot is intentionally bounded and advertises that bound. */
-export declare function phoneStatus(store: Store, repos: readonly string[], now: Date, focused?: string | null): string;
+export declare function phoneStatus(store: Store, repos: readonly string[], now: Date, focused?: string | null, root?: string): string;
 /** One task a person can pick to talk about from a chat app. */
 export type PhoneTaskChoice = {
     id: string;
@@ -31,7 +38,7 @@ export type PhoneTaskChoice = {
  * then work in progress, waiting work and recent results; one entry per
  * task (its revisions share it), optionally narrowed by words in the id or
  * title. Bounded, within the chat's own project ceiling. */
-export declare function phoneTaskChoices(store: Store, repos: readonly string[], now: Date, query?: string | null, limit?: number): PhoneTaskChoice[];
+export declare function phoneTaskChoices(store: Store, repos: readonly string[], now: Date, query?: string | null, limit?: number, root?: string): PhoneTaskChoice[];
 /** `id` keys the chat's choice (the task's first version, where its chat
  * lives); `view` is what to show: the exact version named, else the current one. */
 export type PhoneTaskPick = {
@@ -63,10 +70,10 @@ export type PhoneTaskLink = {
 };
 /** Where the rest lives when no button can say so: the closing line of an unlinked `/task`. */
 export declare const PHONE_CONSOLE_FOOTER = "Read-only status. Saved files and full actions are in the console.";
-export declare function phoneTask(store: Store, repos: readonly string[], id: string, now: Date): string;
+export declare function phoneTask(store: Store, repos: readonly string[], id: string, now: Date, root?: string): string;
 /** One task's status for a chat app: the words, its one console link, and
  * the saved result it shows (a reply to it is about that result). */
-export declare function phoneTaskView(store: Store, repos: readonly string[], id: string, now: Date): {
+export declare function phoneTaskView(store: Store, repos: readonly string[], id: string, now: Date, root?: string): {
     text: string;
     link: PhoneTaskLink | null;
     run: number | null;