toolroll 0.9.54 → 0.9.56

package/dist/{teammate-memory.js → subagent-memory.js}

@@ -1,14 +1,14 @@
 /**
- * What a teammate remembers (v95), and how it learns from its people.
+ * What a subagent remembers (v95), and how it learns from its people.
  *
  * Memory is short facts, each a line: what its people told it ("this week,
  * offer free shipping instead of a refund" — v92's notes), and what it kept
  * from its own turns ("Sam prefers email to phone"). Every turn reads what
  * its people said lately, and what it kept that fits the card. People search,
- * edit and forget any of it on the teammate's page or through the lead.
+ * edit and forget any of it on the subagent's page or through the lead.
  *
  * Learning: when its manager approves the same ask-first tool action again
- * and again (five in a row, none denied), the teammate suggests loosening
+ * and again (five in a row, none denied), the subagent suggests loosening
  * that one rule — "You approved my last 5 refunds (amount 55 to 70): may I
  * make them on my own up to 75?" — as a question its manager accepts or
  * not, in their chat app or on its page. Accepting changes only that rule,
@@ -16,12 +16,12 @@
  */
 import { scanForSecrets } from "./evidence.js";
 import { notifyPeople } from "./flow-people.js";
-import { labelOf, nameOf } from "./teammate-admin.js";
-import { defaultRule, numberFields, setToolRules } from "./teammate-tools.js";
+import { labelOf, nameOf } from "./subagent-admin.js";
+import { defaultRule, numberFields, setToolRules } from "./subagent-tools.js";
 export const MEMORY_CHARS = 300;
-/** Facts a teammate keeps on its own: past this, its oldest are forgotten. What people told it is never dropped this way. */
+/** Facts a subagent keeps on its own: past this, its oldest are forgotten. What people told it is never dropped this way. */
 export const MEMORY_CAP = 300;
-/** Approvals in a row of one action before the teammate suggests loosening its rule. */
+/** Approvals in a row of one action before the subagent suggests loosening its rule. */
 export const SUGGEST_AFTER = 5;
 export const ACCEPT = "accept", DISMISS = "dismiss";
 const STOP = new Set("about after again also been before being could does doing from have here into just like more most much must only other over same some such than that their them then there these they this those through very want were what when where which while will with would your yours please thanks thank hello".split(" "));
@@ -45,57 +45,57 @@ export function cleanMemory(text) {
     if (line.length > MEMORY_CHARS)
         return { ok: false, said: `Keep a memory to ${MEMORY_CHARS} characters; put lasting rules in its soul file.` };
     if (scanForSecrets(line).length > 0)
-        return { ok: false, said: "That looks like a key or password. Keep secrets out of a teammate's memory." };
+        return { ok: false, said: "That looks like a key or password. Keep secrets out of a subagent's memory." };
     return { ok: true, text: line };
 }
-/** Keep one thing: from a person (what they told it), or from the teammate itself on a turn. The same words twice are kept once. */
+/** Keep one thing: from a person (what they told it), or from the subagent itself on a turn. The same words twice are kept once. */
 export function remember(store, mate, text, from, now) {
-    const clean = cleanMemory(from.source === "teammate" ? text.slice(0, MEMORY_CHARS) : text);
+    const clean = cleanMemory(from.source === "subagent" ? text.slice(0, MEMORY_CHARS) : text);
     if (!clean.ok)
         return clean;
-    const same = store.teammateMemories(mate.id).find(one => one.text.toLowerCase() === clean.text.toLowerCase());
+    const same = store.subagentMemories(mate.id).find(one => one.text.toLowerCase() === clean.text.toLowerCase());
     if (same !== undefined)
         return { ok: true, said: `${nameOf(mate)} already remembers that.`, id: same.id };
     // Saying nearly the same thing again on the same card (another turn of the same visit) refreshes what it kept instead of adding a second line.
-    if (from.source === "teammate" && from.card !== undefined && from.card !== null) {
-        const near = store.teammateMemories(mate.id, { source: "teammate" }).find(one => one.card === from.card && similar(one.text, clean.text));
+    if (from.source === "subagent" && from.card !== undefined && from.card !== null) {
+        const near = store.subagentMemories(mate.id, { source: "subagent" }).find(one => one.card === from.card && similar(one.text, clean.text));
         if (near !== undefined) {
-            store.editTeammateMemory(near.id, clean.text, from.by, now);
+            store.editSubagentMemory(near.id, clean.text, from.by, now);
             return { ok: true, said: `${nameOf(mate)} already remembers that.`, id: near.id };
         }
     }
-    const id = store.addTeammateMemory({ teammate: mate.id, text: clean.text, source: from.source, card: from.card ?? null, by: from.by }, now);
-    if (from.source === "teammate")
-        for (const old of store.teammateMemories(mate.id, { source: "teammate" }).slice(MEMORY_CAP))
-            store.forgetTeammateMemory(old.id, "limit", now);
+    const id = store.addSubagentMemory({ subagent: mate.id, text: clean.text, source: from.source, card: from.card ?? null, by: from.by }, now);
+    if (from.source === "subagent")
+        for (const old of store.subagentMemories(mate.id, { source: "subagent" }).slice(MEMORY_CAP))
+            store.forgetSubagentMemory(old.id, "limit", now);
     return { ok: true, said: `${nameOf(mate)} will remember that.`, id };
 }
-/** Something a person tells a teammate (the page's "Tell Maya something", or the lead): kept in its memory, read by every turn while it's among the latest ten. */
-export function tellTeammate(store, mate, note, by, now) {
+/** Something a person tells a subagent (the page's "Tell Maya something", or the lead): kept in its memory, read by every turn while it's among the latest ten. */
+export function tellSubagent(store, mate, note, by, now) {
     const kept = remember(store, mate, note, { source: "person", by }, now);
     return kept.ok ? { ok: true, said: `${nameOf(mate)} will keep that in mind.` } : kept;
 }
 export function editMemory(store, mate, id, text, by, now) {
-    const memory = store.teammateMemory(id);
-    if (memory === null || memory.teammate !== mate.id)
+    const memory = store.subagentMemory(id);
+    if (memory === null || memory.subagent !== mate.id)
         return { ok: false, said: "It doesn't remember that any more." };
     const clean = cleanMemory(text);
     if (!clean.ok)
         return clean;
-    store.editTeammateMemory(id, clean.text, by, now);
+    store.editSubagentMemory(id, clean.text, by, now);
     return { ok: true, said: "Saved." };
 }
 export function forgetMemory(store, mate, id, by, now) {
-    const memory = store.teammateMemory(id);
-    if (memory === null || memory.teammate !== mate.id)
+    const memory = store.subagentMemory(id);
+    if (memory === null || memory.subagent !== mate.id)
         return { ok: false, said: "It doesn't remember that any more." };
-    store.forgetTeammateMemory(id, by, now);
+    store.forgetSubagentMemory(id, by, now);
     return { ok: true, said: `${nameOf(mate)} forgot it.` };
 }
 /** Memories whose text holds every word searched for. */
 export function searchMemories(store, mate, query) {
     const words = query.toLowerCase().split(/[^\p{L}\p{N}$]+/u).filter(one => one.length >= 2);
-    return store.teammateMemories(mate.id, { words, limit: 100 });
+    return store.subagentMemories(mate.id, { words, limit: 100 });
 }
 /**
  * What one turn reads: what its people told it lately (oldest first), and
@@ -103,13 +103,13 @@ export function searchMemories(store, mate, query) {
  * words, then its newest — up to eight.
  */
 export function memoriesFor(store, mate, cardText, now) {
-    const told = store.teammateMemories(mate.id, { source: "person", limit: 10 }).reverse();
-    const own = store.teammateMemories(mate.id, { source: "teammate", limit: MEMORY_CAP });
+    const told = store.subagentMemories(mate.id, { source: "person", limit: 10 }).reverse();
+    const own = store.subagentMemories(mate.id, { source: "subagent", limit: MEMORY_CAP });
     const words = wordsOf(cardText);
     const scored = own.map(one => ({ one, score: words.filter(word => one.text.toLowerCase().includes(word)).length })).filter(one => one.score > 0)
         .sort((a, b) => b.score - a.score || b.one.id - a.one.id).slice(0, 6).map(one => one.one);
     const kept = [...scored, ...own.filter(one => !scored.includes(one))].slice(0, 8);
-    store.markTeammateMemoriesUsed(kept.map(one => one.id), now);
+    store.markSubagentMemoriesUsed(kept.map(one => one.id), now);
     return { told, kept };
 }
 const numberOf = (value) => typeof value === "number" && Number.isFinite(value) ? value
@@ -119,22 +119,22 @@ export const roundUp = (value) => { const step = value < 20 ? 1 : value < 100 ?
 /**
  * After a person approves an ask-first call: when they have approved this
  * action enough times in a row since it last suggested anything about it,
- * the teammate suggests the rule that would have let it make them all.
+ * the subagent suggests the rule that would have let it make them all.
  */
 export function considerSuggestion(store, mate, approved, now) {
-    const grant = store.teammateGrant(mate.id, approved.tool);
+    const grant = store.subagentGrant(mate.id, approved.tool);
     const info = grant?.actions.find(one => one.name === approved.action);
     if (grant === null || info === undefined)
         return null;
     const rule = grant.rules[approved.action] ?? defaultRule(info);
     if (rule.use === "never" || (rule.use === "free" && rule.limit === undefined))
         return null;
-    const earlier = store.teammateSuggestionsFor(mate.id, approved.tool, approved.action);
+    const earlier = store.subagentSuggestionsFor(mate.id, approved.tool, approved.action);
     if (earlier.some(one => one.state === "open"))
         return null;
     const since = earlier[0]?.createdAt ?? "";
     const run = [];
-    for (const call of store.teammateCallsOf(mate.id, 400).filter(one => one.tool === approved.tool && one.action === approved.action && one.rule === "ask" && one.decidedBy !== null && (one.decidedAt ?? "") > since)) {
+    for (const call of store.subagentCallsOf(mate.id, 400).filter(one => one.tool === approved.tool && one.action === approved.action && one.rule === "ask" && one.decidedBy !== null && (one.decidedAt ?? "") > since)) {
         if (call.state === "denied")
             break;
         run.push(call);
@@ -162,8 +162,8 @@ export function considerSuggestion(store, mate, approved, now) {
     const said = suggested.limit === undefined
         ? `You approved my last ${run.length} ${approved.action} calls on ${approved.tool}. May I make them on my own from now on?`
         : `You approved my last ${run.length} ${approved.action} calls on ${approved.tool}${range}. May I make them on my own up to ${suggested.limit.field} ${suggested.limit.over}, and ask you above that?`;
-    const id = store.addTeammateSuggestion({ teammate: mate.id, tool: approved.tool, action: approved.action, rule: suggested, was: rule, evidence: run.map(one => one.id), said }, now);
-    const question = store.openTeammateQuestion({ teammate: mate.id, card: card.id, entry: approved.entry, question: said, options: [{ id: ACCEPT, label: "Yes, change it" }, { id: DISMISS, label: "Not now" }], askedOf: mate.manager, suggestion: id }, now);
+    const id = store.addSubagentSuggestion({ subagent: mate.id, tool: approved.tool, action: approved.action, rule: suggested, was: rule, evidence: run.map(one => one.id), said }, now);
+    const question = store.openSubagentQuestion({ subagent: mate.id, card: card.id, entry: approved.entry, question: said, options: [{ id: ACCEPT, label: "Yes, change it" }, { id: DISMISS, label: "Not now" }], askedOf: mate.manager, suggestion: id }, now);
     if (question === null)
         return id;
     notifyPeople(store, card, [mate.manager], null, { key: `teammate-q:${question}`, attention: false, subject: `${labelOf(mate)} suggests a rule change`,
@@ -172,24 +172,24 @@ export function considerSuggestion(store, mate, approved, now) {
 }
 /** Its manager answers a suggestion: accept changes the one rule (if it is still what it was), anything else leaves it; their words are remembered. */
 export function answerSuggestion(store, mate, suggestion, answer, now) {
-    const offered = store.teammateSuggestion(suggestion);
+    const offered = store.subagentSuggestion(suggestion);
     if (offered === null || offered.state !== "open")
         return { ok: false, said: "That suggestion was already answered." };
     if (answer.choice === ACCEPT) {
-        const grant = store.teammateGrant(mate.id, offered.tool);
+        const grant = store.subagentGrant(mate.id, offered.tool);
         const current = grant === null ? null : grant.rules[offered.action] ?? null;
         const { undo: _undo, ...compared } = current ?? { use: "never" };
         if (current === null || JSON.stringify(compared) !== JSON.stringify((({ undo: _was, ...rest }) => rest)(offered.was))) {
-            store.decideTeammateSuggestion(offered.id, "stale", null, now);
+            store.decideSubagentSuggestion(offered.id, "stale", null, now);
             return { ok: false, said: "Its rules changed since it suggested this, so nothing was changed." };
         }
         const changed = setToolRules(store, mate, offered.tool, { [offered.action]: { use: offered.rule.use, limit: offered.rule.limit ?? null, undo: current.undo ?? "" } }, answer.by, now);
         if (!changed.ok)
             return changed;
-        store.decideTeammateSuggestion(offered.id, "accepted", answer.by, now);
+        store.decideSubagentSuggestion(offered.id, "accepted", answer.by, now);
         return { ok: true, said: `Changed. ${nameOf(mate)} makes ${offered.action} calls on its own ${offered.rule.limit === undefined ? "from now on" : `up to ${offered.rule.limit.field} ${offered.rule.limit.over}`}.` };
     }
-    store.decideTeammateSuggestion(offered.id, "dismissed", answer.by, now);
+    store.decideSubagentSuggestion(offered.id, "dismissed", answer.by, now);
     if (answer.text !== null && answer.text.trim() !== "")
         remember(store, mate, `About ${offered.action} on ${offered.tool}: ${answer.text.trim()}`.slice(0, MEMORY_CHARS), { source: "person", by: answer.by }, now);
     return { ok: true, said: "Left as it is." };

package/dist/{teammate-question.d.ts → subagent-question.d.ts}

@@ -1,13 +1,13 @@
 import type { ChatBinding, ChatContent, ChatEvent, ChatState } from "./chat-delivery-state.js";
-import type { Store, TelegramBinding, TeammateQuestionRow } from "./store.js";
-import type { InlineButton } from "./telegram-mate.js";
-/** The key notifyPeople gives a teammate's question: flow-card:<card>:teammate-q:<question>:<person>. */
-export declare const TEAMMATE_Q_KEY: RegExp;
+import type { Store, TelegramBinding, SubagentQuestionRow } from "./store.js";
+import type { InlineButton } from "./telegram-lead.js";
+/** The key notifyPeople gives a subagent's question: flow-card:<card>:teammate-q:<question>:<person>. */
+export declare const SUBAGENT_Q_KEY: RegExp;
 export declare const IN_WORDS = "Answer in words";
 /** The question a notice is about, while it is still open. */
-export declare function openQuestionOf(store: Store, dedupeKey: string): TeammateQuestionRow | null;
+export declare function openQuestionOf(store: Store, dedupeKey: string): SubagentQuestionRow | null;
 /** Buttons for the question, minted before the send (for the person it asks only); `place` stamps the message they land on. */
-export declare function telegramQuestionButtons(store: Store, binding: TelegramBinding, question: TeammateQuestionRow, now: Date): {
+export declare function telegramQuestionButtons(store: Store, binding: TelegramBinding, question: SubagentQuestionRow, now: Date): {
     keyboard: InlineButton[][];
     tokens: string[];
 } | null;

package/dist/{teammate-question.js → subagent-question.js}

@@ -1,32 +1,32 @@
 /**
- * A teammate's question, answered in the chat app (v93).
+ * A subagent's question, answered in the chat app (v93).
  *
- * When a teammate asks its person something ("Refund all $200, or half?"),
- * the notice reaches them in their chat app under the teammate's name, with
+ * When a subagent asks its person something ("Refund all $200, or half?"),
+ * the notice reaches them in their chat app under the subagent's name, with
  * one button per option and one to answer in their own words. A tap answers
  * at once; "Answer in words" opens a prompt: on Telegram, a reply to it; in
  * Slack, Discord and Teams, their next message in their chat with Standing
  * Orders ("cancel" leaves it). Either way the answer goes through the same
- * door as the card's own panel (answerTeammateQuestion): once, and only from
+ * door as the card's own panel (answerSubagentQuestion): once, and only from
  * the person it was asked of. Answered anywhere, every button retires.
  */
 import { randomBytes } from "node:crypto";
 import { partContent, savedChatPart } from "./chat-delivery-state.js";
-import { answerTeammateQuestion } from "./teammate-work.js";
-import { labelOf } from "./teammate-admin.js";
+import { answerSubagentQuestion } from "./subagent-work.js";
+import { labelOf } from "./subagent-admin.js";
 import { telegramButton } from "./contracts/telegram-callback.js";
-/** The key notifyPeople gives a teammate's question: flow-card:<card>:teammate-q:<question>:<person>. */
-export const TEAMMATE_Q_KEY = /^flow-card:[1-9][0-9]{0,14}:teammate-q:([1-9][0-9]{0,14}):/;
+/** The key notifyPeople gives a subagent's question: flow-card:<card>:teammate-q:<question>:<person>. */
+export const SUBAGENT_Q_KEY = /^flow-card:[1-9][0-9]{0,14}:teammate-q:([1-9][0-9]{0,14}):/;
 export const IN_WORDS = "Answer in words";
 const PROMPT_MS = 30 * 60_000;
 const ANSWER_CHARS = 2000;
 /** The question a notice is about, while it is still open. */
 export function openQuestionOf(store, dedupeKey) {
-    const match = TEAMMATE_Q_KEY.exec(dedupeKey);
-    const question = match === null ? null : store.teammateQuestion(Number(match[1]));
+    const match = SUBAGENT_Q_KEY.exec(dedupeKey);
+    const question = match === null ? null : store.subagentQuestion(Number(match[1]));
     return question !== null && question.state === "open" ? question : null;
 }
-const who = (store, question) => { const mate = store.getTeammate(question.teammate); return mate === null ? "Your teammate" : labelOf(mate).split(" · ")[0]; };
+const who = (store, question) => { const mate = store.getSubagent(question.subagent); return mate === null ? "Your subagent" : labelOf(mate).split(" · ")[0]; };
 /** Everyone else's buttons retire once a question is answered anywhere. */
 function retireEverywhere(store, question, now, state) {
     store.retireTelegramQuestion(question, now);
@@ -51,7 +51,7 @@ export function telegramQuestionButtons(store, binding, question, now) {
 export function applyTelegramQuestionTap(store, binding, action, message, now) {
     if (action.consumedAt !== null || action.expiresAt <= now.toISOString())
         return [{ kind: "ack", text: "That was already answered, or these buttons are too old." }];
-    const question = store.teammateQuestion(action.question);
+    const question = store.subagentQuestion(action.question);
     if (question === null || question.state !== "open") {
         store.retireTelegramQuestion(action.question, now);
         return [{ kind: "ack", text: "That was already answered." }];
@@ -59,7 +59,7 @@ export function applyTelegramQuestionTap(store, binding, action, message, now) {
     if (action.choice === null)
         return [{ kind: "ack", text: "Send your answer" }, { kind: "prompt", question: question.id, placeholder: "Your answer",
                 text: `Your answer to ${who(store, question)}: “${question.question}” Reply to this message.` }];
-    const answered = answerTeammateQuestion(store, question.id, { choice: action.choice, text: null, by: binding.approver, via: "telegram" }, now);
+    const answered = answerSubagentQuestion(store, question.id, { choice: action.choice, text: null, by: binding.approver, via: "telegram" }, now);
     if (!answered.ok)
         return [{ kind: "ack", text: answered.said.slice(0, 190) }];
     retireEverywhere(store, question.id, now);
@@ -75,7 +75,7 @@ export function applyTelegramQuestionReply(store, binding, prompt, text, now) {
         return "Send the answer itself as a reply.";
     if (said.length > ANSWER_CHARS)
         return `Keep it under ${ANSWER_CHARS.toLocaleString("en-US")} characters.`;
-    const answered = answerTeammateQuestion(store, prompt.question, { choice: null, text: said, by: binding.approver, via: "telegram" }, now);
+    const answered = answerSubagentQuestion(store, prompt.question, { choice: null, text: said, by: binding.approver, via: "telegram" }, now);
     retireEverywhere(store, prompt.question, now);
     return answered.ok ? `✅ ${answered.said}` : answered.said;
 }
@@ -117,7 +117,7 @@ export function applyChatQuestionTap(options, event, binding, token, now) {
         return true;
     }
     const questionId = Number(action["question"]), part = Number(action["part"]);
-    const question = store.teammateQuestion(questionId);
+    const question = store.subagentQuestion(questionId);
     if (action["consumed"] !== null || String(action["expires"]) <= now.toISOString() || question === null || question.state !== "open") {
         retireEverywhere(store, questionId, now, state);
         repaint(state, part, event, "This was already answered.");
@@ -132,7 +132,7 @@ export function applyChatQuestionTap(options, event, binding, token, now) {
         say(`Your next message here is your answer to ${who(store, question)}: “${question.question}” Send “cancel” to leave it.`);
         return true;
     }
-    const answered = answerTeammateQuestion(store, questionId, { choice: String(action["choice"]), text: null, by: binding.approver, via: options.label.toLowerCase() }, now);
+    const answered = answerSubagentQuestion(store, questionId, { choice: String(action["choice"]), text: null, by: binding.approver, via: options.label.toLowerCase() }, now);
     if (!answered.ok) {
         say(answered.said);
         return true;
@@ -169,7 +169,7 @@ export function answerChatQuestionPrompt(options, event, binding, input, now) {
             say(`That's too long to take from here. Keep it under ${ANSWER_CHARS.toLocaleString("en-US")} characters, or answer on the card.`);
             return true;
         }
-        const answered = answerTeammateQuestion(store, questionId, { choice: null, text: said, by: binding.approver, via: options.label.toLowerCase() }, now);
+        const answered = answerSubagentQuestion(store, questionId, { choice: null, text: said, by: binding.approver, via: options.label.toLowerCase() }, now);
         retireEverywhere(store, questionId, now, state);
         say(answered.ok ? `✅ ${answered.said}` : answered.said);
         return true;

package/dist/{teammate-tools.d.ts → subagent-tools.d.ts}

@@ -1,6 +1,6 @@
 import type { ToolCaller } from "./flow-actions.js";
 import { type ProjectTool, type ToolSpec } from "./project-tools.js";
-import type { Store, TeammateCallRow, TeammateGrantRow, TeammateRow, ToolActionInfo, ToolRule } from "./store.js";
+import type { Store, SubagentCallRow, SubagentGrantRow, SubagentRow, ToolActionInfo, ToolRule } from "./store.js";
 /** Lists what a tool offers; injectable so tests never start a server. */
 export type ToolLister = (spec: ToolSpec, values: Record<string, string>) => Promise<{
     ok: true;
@@ -32,11 +32,11 @@ export declare function withActions(rules: Record<string, ToolRule>, actions: re
     rules: Record<string, ToolRule>;
 };
 /** The rule that applies to one call with this input, and why, in words. */
-export declare function ruleFor(grant: Pick<TeammateGrantRow, "actions" | "rules">, action: string, input: Record<string, unknown>): {
+export declare function ruleFor(grant: Pick<SubagentGrantRow, "actions" | "rules">, action: string, input: Record<string, unknown>): {
     use: ToolRule["use"];
     why: string;
 };
-/** A rule in words, for the teammate's turn and its page. */
+/** A rule in words, for the subagent's turn and its page. */
 export declare function ruleWords(rule: ToolRule): string;
 /** Number fields an action's input declares: what a limit can be set on. */
 export declare function numberFields(action: Pick<ToolActionInfo, "input">): string[];
@@ -51,17 +51,17 @@ export type OfferedTool = {
     input: string;
     rule: string;
 };
-/** What a teammate may use now: its grants' actions on tools the project still has, "never" left out. */
-export declare function offeredTools(store: Store, mate: TeammateRow): OfferedTool[];
+/** What a subagent may use now: its grants' actions on tools the project still has, "never" left out. */
+export declare function offeredTools(store: Store, mate: SubagentRow): OfferedTool[];
 /** Before a turn: re-list tools whose listing is old (or never happened), so the turn sees what they offer today. A tool that can't be reached keeps its last listing. */
-export declare function refreshGrants(store: Store, mate: TeammateRow, now: Date, io: ToolIo): Promise<void>;
-/** Let a teammate use one of the project's tools. Its actions start at their defaults: reading is free, everything else asks first. */
-export declare function grantTool(store: Store, mate: TeammateRow, tool: string, by: string, now: Date, io?: ToolIo): Promise<Done>;
+export declare function refreshGrants(store: Store, mate: SubagentRow, now: Date, io: ToolIo): Promise<void>;
+/** Let a subagent use one of the project's tools. Its actions start at their defaults: reading is free, everything else asks first. */
+export declare function grantTool(store: Store, mate: SubagentRow, tool: string, by: string, now: Date, io?: ToolIo): Promise<Done>;
 /** A grant from what the tool offers (or, not reachable now, the names its last test found). */
-export declare function grantListed(store: Store, mate: TeammateRow, tool: ProjectTool, actions: ToolActionInfo[] | null, by: string, now: Date): Done;
-export declare function revokeTool(store: Store, mate: TeammateRow, tool: string, by: string, now?: Date): Done;
+export declare function grantListed(store: Store, mate: SubagentRow, tool: ProjectTool, actions: ToolActionInfo[] | null, by: string, now: Date): Done;
+export declare function revokeTool(store: Store, mate: SubagentRow, tool: string, by: string, now?: Date): Done;
 /** Check one rule: an action the tool offers, a known use, and a limit on one of its number fields. */
-export declare function checkRule(grant: Pick<TeammateGrantRow, "tool" | "actions">, action: string, rule: {
+export declare function checkRule(grant: Pick<SubagentGrantRow, "tool" | "actions">, action: string, rule: {
     use: unknown;
     limit?: {
         field: unknown;
@@ -76,7 +76,7 @@ export declare function checkRule(grant: Pick<TeammateGrantRow, "tool" | "action
     said: string;
 };
 /** Set the rules for some of a granted tool's actions; the others keep theirs. */
-export declare function setToolRules(store: Store, mate: TeammateRow, tool: string, changes: Record<string, {
+export declare function setToolRules(store: Store, mate: SubagentRow, tool: string, changes: Record<string, {
     use: unknown;
     limit?: {
         field: unknown;
@@ -87,17 +87,17 @@ export declare function setToolRules(store: Store, mate: TeammateRow, tool: stri
 /**
  * Make one call now: a free one, or one a person approved (exactly as they
  * saw it). What the tool said is kept on the receipt, secrets scrubbed; a
- * tool that says it failed is an answer the teammate reads, not trouble.
+ * tool that says it failed is an answer the subagent reads, not trouble.
  */
-export declare function makeCall(store: Store, call: TeammateCallRow, repo: string, io: ToolIo, now: Date, options?: {
+export declare function makeCall(store: Store, call: SubagentCallRow, repo: string, io: ToolIo, now: Date, options?: {
     byPerson?: boolean;
-}): Promise<TeammateCallRow>;
+}): Promise<SubagentCallRow>;
 /** A receipt in words: what happened to the call. */
-export declare function callOutcome(call: TeammateCallRow): string;
+export declare function callOutcome(call: SubagentCallRow): string;
 /** A receipt as a person reads it on the card: what happened, and who decided. */
-export declare function receiptWords(store: Store, call: TeammateCallRow): string;
+export declare function receiptWords(store: Store, call: SubagentCallRow): string;
 /** The Tools section's form, read into rule changes: every action the grant knows. */
-export declare function rulesFromForm(grant: Pick<TeammateGrantRow, "actions">, field: (key: string) => string | null): Record<string, {
+export declare function rulesFromForm(grant: Pick<SubagentGrantRow, "actions">, field: (key: string) => string | null): Record<string, {
     use: unknown;
     limit?: {
         field: unknown;

package/dist/{teammate-tools.js → subagent-tools.js}

@@ -1,20 +1,20 @@
 /**
- * The tools a teammate may use (v94), and its rule for each of their actions.
+ * The tools a subagent may use (v94), and its rule for each of their actions.
  *
- * A teammate never calls a tool itself. On its turn it may ask for one call
+ * A subagent never calls a tool itself. On its turn it may ask for one call
  * ("use_tool": which action, with what input, and why), and Toolroll
  * checks the rule its manager set for that action:
  *
- * - do it: the call is made and its answer goes back to the teammate, whose
+ * - do it: the call is made and its answer goes back to the subagent, whose
  *   turn goes on;
  * - ask first: the exact call goes to the zone's person, in their chat app
  *   and on the card. Approve makes exactly that call; Deny doesn't; words
- *   tell the teammate what to do instead;
+ *   tell the subagent what to do instead;
  * - never: the action isn't offered at all.
  *
  * "Do it" can ask first above a number in the input ("refunds up to $50"),
  * so a limit holds in code, not only in the soul file's words. Every call,
- * made or not, is a receipt on the card and on the teammate's page.
+ * made or not, is a receipt on the card and on the subagent's page.
  */
 import { redactSecretLines, scanForSecrets } from "./evidence.js";
 import { scrubSecrets } from "./flow-secrets.js";
@@ -52,7 +52,7 @@ export function ruleFor(grant, action, input) {
     }
     return { use: "free", why: "" };
 }
-/** A rule in words, for the teammate's turn and its page. */
+/** A rule in words, for the subagent's turn and its page. */
 export function ruleWords(rule) {
     if (rule.use === "never")
         return "never";
@@ -91,12 +91,12 @@ export function callWords(tool, action, input, cap = 300) {
     const line = `${tool} → ${action}${parts.length === 0 ? "" : ` · ${parts.join(" · ")}`}`;
     return line.length <= cap ? line : `${line.slice(0, cap - 1)}…`;
 }
-/** What a teammate may use now: its grants' actions on tools the project still has, "never" left out. */
+/** What a subagent may use now: its grants' actions on tools the project still has, "never" left out. */
 export function offeredTools(store, mate) {
     const present = new Set(projectToolsOf(store, mate.repo).map(one => one.name));
     // Sprint 8: a tool the organisation policy doesn't allow isn't offered.
     const policy = store.orgPolicy();
-    return store.teammateGrants(mate.id).filter(grant => present.has(grant.tool) && toolRefusal(policy, grant.tool) === null).flatMap(grant => grant.actions.flatMap(action => {
+    return store.subagentGrants(mate.id).filter(grant => present.has(grant.tool) && toolRefusal(policy, grant.tool) === null).flatMap(grant => grant.actions.flatMap(action => {
         const rule = grant.rules[action.name] ?? defaultRule(action);
         if (rule.use === "never")
             return [];
@@ -107,7 +107,7 @@ export function offeredTools(store, mate) {
 /** Before a turn: re-list tools whose listing is old (or never happened), so the turn sees what they offer today. A tool that can't be reached keeps its last listing. */
 export async function refreshGrants(store, mate, now, io) {
     const tools = projectToolsOf(store, mate.repo);
-    for (const grant of store.teammateGrants(mate.id)) {
+    for (const grant of store.subagentGrants(mate.id)) {
         if (grant.listedAt !== null && now.getTime() - Date.parse(grant.listedAt) < LISTING_MS)
             continue;
         const tool = tools.find(one => one.name === grant.tool);
@@ -116,18 +116,18 @@ export async function refreshGrants(store, mate, now, io) {
         const listed = await listed_(tool, mate.repo, io);
         if (!listed.ok)
             continue;
-        store.saveTeammateGrant({ teammate: mate.id, tool: grant.tool, ...withActions(grant.rules, listed.actions), listedAt: now.toISOString() }, grant.updatedBy, now);
+        store.saveSubagentGrant({ subagent: mate.id, tool: grant.tool, ...withActions(grant.rules, listed.actions), listedAt: now.toISOString() }, grant.updatedBy, now);
     }
 }
 const listed_ = (tool, repo, io) => (io.listTools ?? ((spec, values) => listProjectToolActions(spec, values, { timeoutMs: 60_000, omitEnv: ALL_CREDENTIAL_ENV })))(tool.spec, readToolSecrets(repo, tool.name, io.toolHome));
 /** Names only, from the tool's last test: what a grant starts with when it can't be listed right now. */
 const namesOnly = (tool) => (tool.lastTest?.tools ?? []).map(name => ({ name, about: "", input: null, readOnly: false }));
-/** Let a teammate use one of the project's tools. Its actions start at their defaults: reading is free, everything else asks first. */
+/** Let a subagent use one of the project's tools. Its actions start at their defaults: reading is free, everything else asks first. */
 export async function grantTool(store, mate, tool, by, now, io = {}) {
     const found = projectToolsOf(store, mate.repo).find(one => one.name === tool);
     if (found === undefined)
         return { ok: false, said: `This project has no tool called ${tool}. Add it on the Tools page first.` };
-    if (store.teammateGrant(mate.id, tool) !== null)
+    if (store.subagentGrant(mate.id, tool) !== null)
         return { ok: true, said: `It can already use ${tool}.` };
     const listed = await listed_(found, mate.repo, io);
     return grantListed(store, mate, found, listed.ok ? listed.actions : null, by, now);
@@ -137,18 +137,18 @@ export function grantListed(store, mate, tool, actions, by, now) {
     const offered = actions ?? namesOnly(tool);
     if (offered.length === 0)
         return { ok: false, said: `${tool.name} didn't say what it can do. Test it on the Tools page, then try again.` };
-    store.saveTeammateGrant({ teammate: mate.id, tool: tool.name, ...withActions({}, offered), listedAt: actions === null ? null : now.toISOString() }, by, now);
+    store.saveSubagentGrant({ subagent: mate.id, tool: tool.name, ...withActions({}, offered), listedAt: actions === null ? null : now.toISOString() }, by, now);
     const free = offered.filter(one => defaultRule(one).use === "free").length;
     return { ok: true, said: `It can use ${tool.name} now: ${free} of its ${offered.length} action${offered.length === 1 ? "" : "s"} freely (the ones that only read), and the rest after a person approves each call. Change that under Tools.` };
 }
 export function revokeTool(store, mate, tool, by, now = new Date()) {
-    for (const call of store.teammateCallsOf(mate.id, 200).filter(one => one.tool === tool && one.state === "asked")) {
-        store.moveTeammateCall(call.id, ["asked"], { state: "refused", result: `It can't use ${tool} any more.` }, new Date());
-        const question = store.teammateQuestionForCall(call.id);
+    for (const call of store.subagentCallsOf(mate.id, 200).filter(one => one.tool === tool && one.state === "asked")) {
+        store.moveSubagentCall(call.id, ["asked"], { state: "refused", result: `It can't use ${tool} any more.` }, new Date());
+        const question = store.subagentQuestionForCall(call.id);
         if (question !== null)
-            store.dropTeammateQuestion(question.id, new Date());
+            store.dropSubagentQuestion(question.id, new Date());
     }
-    return store.dropTeammateGrant(mate.id, tool, by, now) ? { ok: true, said: `It can't use ${tool} any more.` } : { ok: true, said: `It wasn't using ${tool}.` };
+    return store.dropSubagentGrant(mate.id, tool, by, now) ? { ok: true, said: `It can't use ${tool} any more.` } : { ok: true, said: `It wasn't using ${tool}.` };
 }
 /** Check one rule: an action the tool offers, a known use, and a limit on one of its number fields. */
 export function checkRule(grant, action, rule) {
@@ -176,7 +176,7 @@ export function checkRule(grant, action, rule) {
 }
 /** Set the rules for some of a granted tool's actions; the others keep theirs. */
 export function setToolRules(store, mate, tool, changes, by, now) {
-    const grant = store.teammateGrant(mate.id, tool);
+    const grant = store.subagentGrant(mate.id, tool);
     if (grant === null)
         return { ok: false, said: `It doesn't use ${tool}. Let it use ${tool} first.` };
     const rules = { ...grant.rules };
@@ -186,35 +186,35 @@ export function setToolRules(store, mate, tool, changes, by, now) {
             return { ok: false, said: checked.said };
         rules[action] = checked.rule;
     }
-    store.saveTeammateGrant({ teammate: mate.id, tool, actions: grant.actions, rules }, by, now);
+    store.saveSubagentGrant({ subagent: mate.id, tool, actions: grant.actions, rules }, by, now);
     return { ok: true, said: "Saved. Its next turn uses these rules." };
 }
 const blank = (text) => redactSecretLines(text, scanForSecrets(text));
 /**
  * Make one call now: a free one, or one a person approved (exactly as they
  * saw it). What the tool said is kept on the receipt, secrets scrubbed; a
- * tool that says it failed is an answer the teammate reads, not trouble.
+ * tool that says it failed is an answer the subagent reads, not trouble.
  */
 export async function makeCall(store, call, repo, io, now, options = {}) {
     // Its rules are read again at the moment of the call: a tool taken away, or an action set to never, since it was approved stops it.
-    // (A person's own undo (v97) needs the tool still granted, not the teammate's rule for that action.)
-    const grant = store.teammateGrant(call.teammate, call.tool);
+    // (A person's own undo (v97) needs the tool still granted, not the subagent's rule for that action.)
+    const grant = store.subagentGrant(call.subagent, call.tool);
     if (grant === null || (options.byPerson !== true && ruleFor(grant, call.action, call.input).use === "never")) {
-        store.moveTeammateCall(call.id, ["approved", "running"], { state: "refused", result: "Its rules changed before the call was made." }, now);
-        return store.teammateCall(call.id);
+        store.moveSubagentCall(call.id, ["approved", "running"], { state: "refused", result: "Its rules changed before the call was made." }, now);
+        return store.subagentCall(call.id);
     }
     // Sprint 8: nor does a call to a tool the organisation policy doesn't allow (a person's undo included).
     const disallowed = toolRefusal(store.orgPolicy(), call.tool);
     if (disallowed !== null) {
-        store.moveTeammateCall(call.id, ["approved", "running"], { state: "refused", result: disallowed }, now);
-        return store.teammateCall(call.id);
+        store.moveSubagentCall(call.id, ["approved", "running"], { state: "refused", result: disallowed }, now);
+        return store.subagentCall(call.id);
     }
-    if (call.state !== "running" && !store.moveTeammateCall(call.id, ["approved"], { state: "running" }, now))
-        return store.teammateCall(call.id);
+    if (call.state !== "running" && !store.moveSubagentCall(call.id, ["approved"], { state: "running" }, now))
+        return store.subagentCall(call.id);
     const tool = projectToolsOf(store, repo).find(one => one.name === call.tool);
     if (tool === undefined) {
-        store.moveTeammateCall(call.id, ["running"], { state: "failed", result: `There's no tool called ${call.tool} in this project any more.` }, now);
-        return store.teammateCall(call.id);
+        store.moveSubagentCall(call.id, ["running"], { state: "failed", result: `There's no tool called ${call.tool} in this project any more.` }, now);
+        return store.subagentCall(call.id);
     }
     const values = readToolSecrets(repo, tool.name, io.toolHome);
     let answer;
@@ -226,8 +226,8 @@ export async function makeCall(store, call, repo, io, now, options = {}) {
     }
     const text = answer.ok ? blank(scrubSecrets(answer.text, values)).trim() : answer.problem;
     const kept = text.length <= RESULT_CHARS ? text : `${text.slice(0, RESULT_CHARS - 1)}…`;
-    store.moveTeammateCall(call.id, ["running"], { state: answer.ok && !answer.isError ? "done" : "failed", result: kept || (answer.ok ? "(no answer)" : "It couldn't be reached.") }, now);
-    return store.teammateCall(call.id);
+    store.moveSubagentCall(call.id, ["running"], { state: answer.ok && !answer.isError ? "done" : "failed", result: kept || (answer.ok ? "(no answer)" : "It couldn't be reached.") }, now);
+    return store.subagentCall(call.id);
 }
 /** A receipt in words: what happened to the call. */
 export function callOutcome(call) {
@@ -245,15 +245,15 @@ export function callOutcome(call) {
 export function receiptWords(store, call) {
     switch (call.state) {
         case "asked": {
-            const question = store.teammateQuestionForCall(call.id);
+            const question = store.subagentQuestionForCall(call.id);
             return `Waiting for ${question?.askedOf ?? "a person"} to approve`;
         }
         case "approved":
         case "running": return call.decidedBy === null ? "Making it now" : `${call.decidedBy} approved · making it now`;
-        case "done": return call.undoneBy !== null ? `Done · undone by ${call.undoneBy}` : call.undoOf !== null ? `Undid ${store.teammateCall(call.undoOf)?.action ?? "a call"} · done` : call.decidedBy === null ? "Done" : `${call.decidedBy} approved · done`;
+        case "done": return call.undoneBy !== null ? `Done · undone by ${call.undoneBy}` : call.undoOf !== null ? `Undid ${store.subagentCall(call.undoOf)?.action ?? "a call"} · done` : call.decidedBy === null ? "Done" : `${call.decidedBy} approved · done`;
         case "failed": return call.decidedBy === null ? "Failed" : `${call.decidedBy} approved · failed`;
         case "denied": {
-            const said = store.teammateQuestionForCall(call.id)?.answer;
+            const said = store.subagentQuestionForCall(call.id)?.answer;
             return `${call.decidedBy ?? "A person"} said no${said ? `: ${said}` : ""}`;
         }
         default: return `Not made: ${call.result ?? "outside its rules"}`;