toolroll 0.9.54 → 0.9.56

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

@@ -1,5 +1,5 @@
-import type { Store, TeammateCallRow, TeammateRow } from "./store.js";
-import { type ToolIo } from "./teammate-tools.js";
+import type { Store, SubagentCallRow, SubagentRow } from "./store.js";
+import { type ToolIo } from "./subagent-tools.js";
 type Done = {
     ok: true;
     said: string;
@@ -38,20 +38,20 @@ export type Week = {
     }[];
 };
 /** The undo action a call's rule names, when there is one and the call can still be undone. */
-export declare function undoFor(store: Store, call: TeammateCallRow): string | null;
-/** The last seven days (or since a time) for one teammate. */
-export declare function weekOf(store: Store, mate: TeammateRow, now: Date, since?: string): Week;
+export declare function undoFor(store: Store, call: SubagentCallRow): string | null;
+/** The last seven days (or since a time) for one subagent. */
+export declare function weekOf(store: Store, mate: SubagentRow, now: Date, since?: string): Week;
 /** The week in words its manager reads at a glance. */
-export declare function weekWords(mate: TeammateRow, week: Week): string;
-/** Each Monday from 9:00 (this computer's time), the week's report to each active teammate's manager, once; or now, for one. */
-export declare function sendTeammateWeeklies(store: Store, repo: string, now: Date, only?: number | null): number;
+export declare function weekWords(mate: SubagentRow, week: Week): string;
+/** Each Monday from 9:00 (this computer's time), the week's report to each active subagent's manager, once; or now, for one. */
+export declare function sendSubagentWeeklies(store: Store, repo: string, now: Date, only?: number | null): number;
 /**
  * A person asks to undo one of its tool calls with the action its manager
  * named: the undo call is recorded at once (the same input, as them), and
  * made by finishUndo — right away on the page, or by the worker's next pass
  * when it was asked for in chat. Both calls keep their receipts.
  */
-export declare function requestUndo(store: Store, mate: TeammateRow, id: number, by: string, now: Date): {
+export declare function requestUndo(store: Store, mate: SubagentRow, id: number, by: string, now: Date): {
     ok: true;
     call: number;
     said: string;
@@ -64,5 +64,5 @@ export declare function finishUndo(store: Store, id: number, io: ToolIo, now: Da
 /** The worker's pass: undo calls asked for in chat, made now. */
 export declare function runRequestedUndos(store: Store, io: ToolIo, now: Date): Promise<number>;
 /** Undo, on the page: asked for and made at once. */
-export declare function undoCall(store: Store, mate: TeammateRow, id: number, by: string, io: ToolIo, now: Date): Promise<Done>;
+export declare function undoCall(store: Store, mate: SubagentRow, id: number, by: string, io: ToolIo, now: Date): Promise<Done>;
 export {};

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

@@ -1,5 +1,5 @@
 /**
- * A teammate's week (v97): what it did, what it cost, what its people
+ * A subagent's week (v97): what it did, what it cost, what its people
  * overrode, and its receipts — on its page, and each Monday morning to its
  * manager in their chat app.
  *
@@ -13,29 +13,29 @@
  * keep their receipts.
  */
 import { flowCardHref } from "./flow-engine.js";
-import { labelOf, nameOf } from "./teammate-admin.js";
-import { callWords, makeCall } from "./teammate-tools.js";
+import { labelOf, nameOf } from "./subagent-admin.js";
+import { callWords, makeCall } from "./subagent-tools.js";
 const WEEK_MS = 7 * 86_400_000;
 const money = (usd) => usd < 0.01 ? "under 1¢" : usd < 10 ? `$${usd.toFixed(2)}` : `$${Math.round(usd)}`;
 /** The undo action a call's rule names, when there is one and the call can still be undone. */
 export function undoFor(store, call) {
     if (call.state !== "done" || call.undoneBy !== null || call.undoOf !== null)
         return null;
-    const grant = store.teammateGrant(call.teammate, call.tool);
+    const grant = store.subagentGrant(call.subagent, call.tool);
     const undo = grant?.rules[call.action]?.undo;
     return undo !== undefined && grant.actions.some(one => one.name === undo) ? undo : null;
 }
-/** The last seven days (or since a time) for one teammate. */
+/** The last seven days (or since a time) for one subagent. */
 export function weekOf(store, mate, now, since = new Date(now.getTime() - WEEK_MS).toISOString()) {
-    const turns = store.teammateTurns(mate.id, since);
+    const turns = store.subagentTurns(mate.id, since);
     const costs = turns.map(one => one.costUsd).filter((one) => one !== null);
-    const events = store.teammateEvents(mate.id, 5000, since);
+    const events = store.subagentEvents(mate.id, 5000, since);
     const count = (kind) => events.filter(one => one.kind === kind).length;
-    const calls = store.teammateCallsOf(mate.id, 5000, since).filter(one => one.undoOf === null);
+    const calls = store.subagentCallsOf(mate.id, 5000, since).filter(one => one.undoOf === null);
     const hrefOf = (card) => { const found = card === null ? null : store.getFlowCard(card); return found === null ? null : flowCardHref(found.flow, found.id); };
     const name = nameOf(mate);
     const denied = calls.filter(one => one.state === "denied").map(one => {
-        const words = store.teammateQuestionForCall(one.id)?.answer;
+        const words = store.subagentQuestionForCall(one.id)?.answer;
         return { said: `${one.decidedBy ?? "Someone"} turned down ${callWords(one.tool, one.action, one.input, 160)}${words ? `: “${words.slice(0, 160)}”` : ""}`, at: one.decidedAt ?? one.createdAt, href: hrefOf(one.card) };
     });
     const moved = store.flowMovesOverridden(`${name} (AI)`, since).map(one => ({ said: `${one.by} moved “${one.title.slice(0, 80)}” after ${name} did`, at: one.at, href: flowCardHref(one.flow, one.card) }));
@@ -63,22 +63,22 @@ export function weekWords(mate, week) {
     ];
     return lines.join("\n");
 }
-/** Each Monday from 9:00 (this computer's time), the week's report to each active teammate's manager, once; or now, for one. */
-export function sendTeammateWeeklies(store, repo, now, only = null) {
+/** Each Monday from 9:00 (this computer's time), the week's report to each active subagent's manager, once; or now, for one. */
+export function sendSubagentWeeklies(store, repo, now, only = null) {
     const monday = new Date(now);
     monday.setHours(9, 0, 0, 0);
     monday.setDate(monday.getDate() - ((monday.getDay() + 6) % 7));
     let sent = 0;
-    for (const mate of store.teammates([repo])) {
-        // One a week, from Monday 9:00; a teammate that joined since then has its first next Monday.
+    for (const mate of store.subagents([repo])) {
+        // One a week, from Monday 9:00; a subagent that joined since then has its first next Monday.
         if (only !== null ? mate.id !== only : mate.state !== "active" || now < monday || (mate.weeklyAt ?? mate.createdAt) >= monday.toISOString())
             continue;
-        store.updateTeammate(mate.id, { weeklyAt: now.toISOString() }, "weekly", now);
+        store.updateSubagent(mate.id, { weeklyAt: now.toISOString() }, "weekly", now);
         const week = weekOf(store, mate, now);
         if (week.turns === 0 && only === null)
             continue;
         store.enqueueNotification({ dedupeKey: `teammate-weekly:${mate.id}:${now.toISOString().slice(0, only === null ? 10 : 19)}`, kind: "teammate-weekly", recipient: mate.manager,
-            subject: `${labelOf(mate)}: the week`, body: weekWords(mate, week), link: `/teammates/${mate.id}#week`, source: { project: repo } }, now);
+            subject: `${labelOf(mate)}: the week`, body: weekWords(mate, week), link: `/settings/lead/subagents/${mate.id}#week`, source: { project: repo } }, now);
         sent++;
     }
     return sent;
@@ -90,36 +90,36 @@ export function sendTeammateWeeklies(store, repo, now, only = null) {
  * when it was asked for in chat. Both calls keep their receipts.
  */
 export function requestUndo(store, mate, id, by, now) {
-    const call = store.teammateCall(id);
-    if (call === null || call.teammate !== mate.id)
+    const call = store.subagentCall(id);
+    if (call === null || call.subagent !== mate.id)
         return { ok: false, said: "No such call." };
     const undo = undoFor(store, call);
     if (undo === null)
         return { ok: false, said: call.undoneBy !== null ? `${call.undoneBy} already undid it.` : "That call can't be undone here." };
     return store.transact(() => {
-        if (!store.markTeammateCallUndone(call.id, by, now))
+        if (!store.markSubagentCallUndone(call.id, by, now))
             return { ok: false, said: "Someone undid it just now." };
-        const made = store.addTeammateCall({ teammate: mate.id, card: call.card, entry: call.entry, tool: call.tool, action: undo, input: call.input, rule: "free",
+        const made = store.addSubagentCall({ subagent: mate.id, card: call.card, entry: call.entry, tool: call.tool, action: undo, input: call.input, rule: "free",
             why: `${by} undid ${call.action} (call ${call.id}).`, state: "approved", undoOf: call.id, decidedBy: by }, now);
         return { ok: true, call: made, said: `Undoing it with ${undo}.` };
     });
 }
 /** Make a requested undo call; if the tool says it failed, the original call stands (and can be undone again). */
 export async function finishUndo(store, id, io, now) {
-    const pending = store.teammateCall(id);
-    const mate = pending === null ? null : store.getTeammate(pending.teammate);
+    const pending = store.subagentCall(id);
+    const mate = pending === null ? null : store.getSubagent(pending.subagent);
     if (pending === null || mate === null || pending.undoOf === null || pending.state !== "approved")
         return { ok: false, said: "That undo was already made." };
     const made = await makeCall(store, pending, mate.repo, io, now, { byPerson: true });
     if (made.state === "done")
         return { ok: true, said: `Undone: ${callWords(made.tool, made.action, made.input, 120)}. ${made.result ?? ""}`.trim() };
-    store.clearTeammateCallUndone(pending.undoOf, now);
+    store.clearSubagentCallUndone(pending.undoOf, now);
     return { ok: false, said: `The undo call failed: ${made.result ?? "no answer"}. The original call stands.` };
 }
 /** The worker's pass: undo calls asked for in chat, made now. */
 export async function runRequestedUndos(store, io, now) {
     let made = 0;
-    for (const call of store.pendingTeammateUndos()) {
+    for (const call of store.pendingSubagentUndos()) {
         await finishUndo(store, call.id, io, now);
         made++;
     }

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

@@ -1,66 +1,66 @@
 /**
- * A teammate's turn on a card (v92), run by the flow step pass.
+ * A subagent's turn on a card (v92), run by the flow step pass.
  *
  * The turn reads the zone, the card (as data) and what its people told it,
- * and answers with one decision (teammates.ts). This carries the decision
+ * and answers with one decision (subagents.ts). This carries the decision
  * out within the zone's own choices, and writes it down — what it did and
- * why — in the card's history and the teammate's log:
+ * why — in the card's history and the subagent's log:
  *
  * - "Person decides" zone: approve (the draft as written, or as it rewrote
  *   it), send back with a note, or hand it to the zone's person, whose
  *   decision then arrives in their chat app as always.
- * - "Teammate handles it" zone: pick one of the zone's answers (its text is
+ * - "Subagent handles it" zone: pick one of the zone's answers (its text is
  *   kept for the next zones), ask its person a question and wait for the
  *   answer, or say it can't and take the failure path.
  *
  * Either way (v94), before it decides it may use the project tools its
  * manager let it use: each call is checked against its rule for that action
- * (teammate-tools.ts), made at once or put to its person first, and kept as
+ * (subagent-tools.ts), made at once or put to its person first, and kept as
  * a receipt; the turn goes on with what the tool answered.
  */
-import type { FlowCardRow, FlowRow, Store, TeammateRow } from "./store.js";
+import type { FlowCardRow, FlowRow, Store, SubagentRow } from "./store.js";
 import type { FlowDefinition, FlowStage } from "./flows.js";
-import { type TurnRunner } from "./teammates.js";
-import { type ToolIo } from "./teammate-tools.js";
+import { type TurnRunner } from "./subagents.js";
+import { type ToolIo } from "./subagent-tools.js";
 /** A question waits for its answer this long before the step is due again on its own: never, in practice. */
 export declare const ASKED = "9999-12-31T00:00:00.000Z";
 /** v94: tool calls one visit of a card may make, and turns one step run may take, before it must decide with what it has. */
 export declare const CALLS_PER_VISIT = 12;
-/** The two answers an ask-first call offers; words instead tell the teammate what to do. */
+/** The two answers an ask-first call offers; words instead tell the subagent what to do. */
 export declare const APPROVE = "approve", DENY = "deny";
-export type TeammateOutcome = {
+export type SubagentOutcome = {
     state: "passed" | "failed" | "retry" | "waiting";
     said: string;
     log?: string;
     decisionJson?: string;
     nextAt?: string;
 };
-/** The Claude model a teammate's turns run on: its own, or the lead chat's Claude model, or Claude's default. */
-export declare function teammateModel(store: Store, mate: TeammateRow): string;
-/** Whether a teammate can take a turn now: active, readable, and under its daily limit. */
-export declare function teammateReady(store: Store, mate: TeammateRow | null, now: Date): {
+/** The Claude model a subagent's turns run on: its own, or the lead chat's Claude model, or Claude's default. */
+export declare function subagentModel(store: Store, mate: SubagentRow): string;
+/** Whether a subagent can take a turn now: active, readable, and under its daily limit. */
+export declare function subagentReady(store: Store, mate: SubagentRow | null, now: Date): {
     ok: true;
 } | {
     ok: false;
     why: string;
 };
-/** The answers a "Teammate handles it" zone offers, each with the zone it leads to. */
+/** The answers a "Subagent handles it" zone offers, each with the zone it leads to. */
 export declare function handleAnswers(stage: FlowStage): {
     answer: string;
     to: string | null;
 }[];
 /**
- * Run one teammate turn on a card and carry out what it decided. With tools
+ * Run one subagent turn on a card and carry out what it decided. With tools
  * (v94) a turn is a short loop: each tool call it asks for is made (or put to
  * its person, and the turn waits), and it decides again with the answer —
  * until it decides, or it has used its tools as much as a visit allows.
  */
-export declare function teammateTurn(store: Store, flow: FlowRow, definition: FlowDefinition, stage: FlowStage, card: FlowCardRow, mate: TeammateRow, now: Date, io: {
+export declare function subagentTurn(store: Store, flow: FlowRow, definition: FlowDefinition, stage: FlowStage, card: FlowCardRow, mate: SubagentRow, now: Date, io: {
     turn?: TurnRunner;
     evidenceRoot?: string;
-} & ToolIo): Promise<TeammateOutcome>;
-/** A person answers a teammate's question: once, by the person it was asked of; the card's turn is due again. */
-export declare function answerTeammateQuestion(store: Store, id: number, answer: {
+} & ToolIo): Promise<SubagentOutcome>;
+/** A person answers a subagent's question: once, by the person it was asked of; the card's turn is due again. */
+export declare function answerSubagentQuestion(store: Store, id: number, answer: {
     choice: string | null;
     text: string | null;
     by: string;
@@ -73,4 +73,4 @@ export declare function answerTeammateQuestion(store: Store, id: number, answer:
     said: string;
 };
 /** A card's link, for messages about it. */
-export declare const teammateCardHref: (flow: number, card: number) => string;
+export declare const subagentCardHref: (flow: number, card: number) => string;

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

@@ -1,12 +1,12 @@
 import { decideFlowCard, draftFor, flowCardHref } from "./flow-engine.js";
 import { wholeDraft } from "./flow-draft.js";
 import { notifyPeople } from "./flow-people.js";
-import { claudeTurnRunner, parseSoul, readTurn, teammateActor, teammateLabel, TURN_TIMEOUT_MS, turnOverruns, turnPrompt } from "./teammates.js";
+import { claudeTurnRunner, parseSoul, readTurn, subagentActor, subagentLabel, TURN_TIMEOUT_MS, turnOverruns, turnPrompt } from "./subagents.js";
 import { passOn, shortenAsk, TEXT_LIMITS } from "./text-limits.js";
 import { LIMITS } from "./decision.js";
-import { callName, callOutcome, callWords, inputProblem, makeCall, offeredTools, refreshGrants, ruleFor } from "./teammate-tools.js";
-import { answerSuggestion, considerSuggestion, memoriesFor, remember } from "./teammate-memory.js";
-import { replyToAsker } from "./teammate-desk.js";
+import { callName, callOutcome, callWords, inputProblem, makeCall, offeredTools, refreshGrants, ruleFor } from "./subagent-tools.js";
+import { answerSuggestion, considerSuggestion, memoriesFor, remember } from "./subagent-memory.js";
+import { replyToAsker } from "./subagent-desk.js";
 import { claudeMachineBilling } from "./spend.js";
 /** A question waits for its answer this long before the step is due again on its own: never, in practice. */
 export const ASKED = "9999-12-31T00:00:00.000Z";
@@ -15,35 +15,35 @@ const CARRY_ON = "Carry on";
 /** v94: tool calls one visit of a card may make, and turns one step run may take, before it must decide with what it has. */
 export const CALLS_PER_VISIT = 12;
 const TURNS_PER_RUN = 8;
-/** The two answers an ask-first call offers; words instead tell the teammate what to do. */
+/** The two answers an ask-first call offers; words instead tell the subagent what to do. */
 export const APPROVE = "approve", DENY = "deny";
 const startOfDay = (now) => { const day = new Date(now); day.setHours(0, 0, 0, 0); return day.toISOString(); };
-/** The Claude model a teammate's turns run on: its own, or the lead chat's Claude model, or Claude's default. */
-export function teammateModel(store, mate) {
+/** The Claude model a subagent's turns run on: its own, or the lead chat's Claude model, or Claude's default. */
+export function subagentModel(store, mate) {
     const config = store.getChatConfig();
     return mate.model ?? (config?.provider === "claude-subscription" ? config.model : "default");
 }
-/** Whether a teammate can take a turn now: active, readable, and under its daily limit. */
-export function teammateReady(store, mate, now) {
+/** Whether a subagent can take a turn now: active, readable, and under its daily limit. */
+export function subagentReady(store, mate, now) {
     if (mate === null)
         return { ok: false, why: "gone" };
     if (mate.state !== "active")
         return { ok: false, why: "paused" };
     if (!parseSoul(mate.soul).ok)
         return { ok: false, why: "its soul file can't be read" };
-    if (store.teammateTurnsSince(mate.id, startOfDay(now)) >= mate.dailyTurns)
+    if (store.subagentTurnsSince(mate.id, startOfDay(now)) >= mate.dailyTurns)
         return { ok: false, why: `it reached today's limit of ${mate.dailyTurns} turns` };
     // v105: its turns bill as this computer's Claude does with no key from us; billed to a key, a budget holds them.
-    const held = store.budgetGate(now)({ project: mate.repo, person: null, teammate: mate.id, agents: [{ provider: "claude", billing: claudeMachineBilling(store.handle) }] });
+    const held = store.budgetGate(now)({ project: mate.repo, person: null, subagent: mate.id, agents: [{ provider: "claude", billing: claudeMachineBilling(store.handle) }] });
     if (held.over !== null)
         return { ok: false, why: held.why === "used-up" ? "a monthly budget its work counts toward is used up" : "a monthly budget can't price its work yet" };
     // Sprint 8: its turns run on Claude, with its own model or the lead chat's: the organisation policy has to allow them.
-    const disallowed = store.agentPolicyRefusal("claude", teammateModel(store, mate));
+    const disallowed = store.agentPolicyRefusal("claude", subagentModel(store, mate));
     if (disallowed !== null)
         return { ok: false, why: disallowed };
     return { ok: true };
 }
-/** The answers a "Teammate handles it" zone offers, each with the zone it leads to. */
+/** The answers a "Subagent handles it" zone offers, each with the zone it leads to. */
 export function handleAnswers(stage) {
     return stage.routes !== undefined && stage.routes.length > 0 ? stage.routes : [{ answer: CARRY_ON, to: stage.next }];
 }
@@ -54,7 +54,7 @@ function contextOf(store, flow, definition, stage, card, mate, tools = [], spent
         throw new Error(soul.problem);
     const title = (id) => definition.stages.find(one => one.id === id)?.title ?? id;
     const draft = stage.kind === "approval" ? draftFor(definition, stage) : null;
-    const question = store.teammateQuestionFor(card.id, card.entry);
+    const question = store.subagentQuestionFor(card.id, card.entry);
     // v95: what its people told it lately, and what it kept that fits this card.
     const memory = memoriesFor(store, mate, `${card.title}\n${card.description ?? ""}`, new Date());
     return {
@@ -72,28 +72,28 @@ function contextOf(store, flow, definition, stage, card, mate, tools = [], spent
         notes: memory.told.map(one => ({ by: one.createdBy, text: one.text })),
         memory: memory.kept.map(one => one.text),
         tools, toolsSpent: spent,
-        calls: store.teammateCallsOn(card.id, card.entry).map(call => {
-            const question = call.state === "denied" ? store.teammateQuestionForCall(call.id) : null;
+        calls: store.subagentCallsOn(card.id, card.entry).map(call => {
+            const question = call.state === "denied" ? store.subagentQuestionForCall(call.id) : null;
             return { name: callName(call.tool, call.action), input: JSON.stringify(call.input), outcome: callOutcome(call),
                 said: call.state === "denied" ? question?.answer ?? null : call.state === "asked" ? null : call.result };
         }),
     };
 }
 /**
- * Run one teammate turn on a card and carry out what it decided. With tools
+ * Run one subagent turn on a card and carry out what it decided. With tools
  * (v94) a turn is a short loop: each tool call it asks for is made (or put to
  * its person, and the turn waits), and it decides again with the answer —
  * until it decides, or it has used its tools as much as a visit allows.
  */
-export async function teammateTurn(store, flow, definition, stage, card, mate, now, io) {
-    const model = teammateModel(store, mate);
-    if (store.teammateGrants(mate.id).length > 0) {
+export async function subagentTurn(store, flow, definition, stage, card, mate, now, io) {
+    const model = subagentModel(store, mate);
+    if (store.subagentGrants(mate.id).length > 0) {
         try {
             await refreshGrants(store, mate, now, io);
         }
         catch { /* the last listing stands */ }
         // Calls a person approved since the last turn are made first, exactly as they approved them.
-        for (const call of store.teammateCallsOn(card.id, card.entry).filter(one => one.state === "approved" && one.undoOf === null))
+        for (const call of store.subagentCallsOn(card.id, card.entry).filter(one => one.state === "approved" && one.undoOf === null))
             await makeCall(store, call, flow.repo, io, now);
     }
     const log = [];
@@ -101,14 +101,14 @@ export async function teammateTurn(store, flow, definition, stage, card, mate, n
     let shorten;
     let shortened = false;
     for (let turn = 1;; turn++) {
-        const made = store.teammateCallsOn(card.id, card.entry).length;
+        const made = store.subagentCallsOn(card.id, card.entry).length;
         const spent = made >= CALLS_PER_VISIT || turn > TURNS_PER_RUN;
         const tools = spent ? [] : offeredTools(store, mate);
         const context = { ...contextOf(store, flow, definition, stage, card, mate, tools, spent && made > 0), ...(shorten === undefined ? {} : { shorten }) };
         const asked = Date.now();
         const reply = await (io.turn ?? claudeTurnRunner())({ model, prompt: turnPrompt(context), timeoutMs: TURN_TIMEOUT_MS });
         // v97: every turn is kept with what it cost, for its weekly report.
-        store.addTeammateTurn({ teammate: mate.id, card: card.id, model, ok: reply.ok, ms: reply.ok ? reply.ms : Date.now() - asked, costUsd: reply.costUsd ?? null, tokensIn: reply.tokensIn ?? null, tokensOut: reply.tokensOut ?? null }, now);
+        store.addSubagentTurn({ subagent: mate.id, card: card.id, model, ok: reply.ok, ms: reply.ok ? reply.ms : Date.now() - asked, costUsd: reply.costUsd ?? null, tokensIn: reply.tokensIn ?? null, tokensOut: reply.tokensOut ?? null }, now);
         if (!reply.ok)
             return { state: "retry", said: reply.said, ...(log.length === 0 ? {} : { log: log.join("\n\n") }) };
         const read = readTurn(reply.value, context);
@@ -126,7 +126,7 @@ export async function teammateTurn(store, flow, definition, stage, card, mate, n
         }
         shorten = undefined;
         if (answer.remember !== "")
-            remember(store, mate, answer.remember, { source: "teammate", card: card.id, by: teammateActor({ name: context.name }) }, now);
+            remember(store, mate, answer.remember, { source: "subagent", card: card.id, by: subagentActor({ name: context.name }) }, now);
         if (answer.action !== "use_tool") {
             const outcome = carryOut(store, flow, definition, stage, card, mate, context, answer, now, io, header);
             return log.length === 0 ? outcome : { ...outcome, log: `${log.join("\n\n")}\n\n${outcome.log ?? ""}`.trim() };
@@ -145,8 +145,8 @@ export async function teammateTurn(store, flow, definition, stage, card, mate, n
 async function useTool(store, flow, stage, card, mate, context, answer, io, now) {
     const split = answer.tool.indexOf(".");
     const tool = split < 0 ? answer.tool : answer.tool.slice(0, split), action = split < 0 ? "" : answer.tool.slice(split + 1);
-    const receipt = { teammate: mate.id, card: card.id, entry: card.entry, tool: tool.slice(0, 40), action: action.slice(0, 64) || "(none)", why: answer.reason };
-    const refuse = (input, said) => { store.addTeammateCall({ ...receipt, input, rule: "never", state: "refused", result: said }, now); return null; };
+    const receipt = { subagent: mate.id, card: card.id, entry: card.entry, tool: tool.slice(0, 40), action: action.slice(0, 64) || "(none)", why: answer.reason };
+    const refuse = (input, said) => { store.addSubagentCall({ ...receipt, input, rule: "never", state: "refused", result: said }, now); return null; };
     if (!(context.tools ?? []).some(one => one.name === answer.tool))
         return refuse({}, `There's no ${answer.tool} among the tools you may use.`);
     let input;
@@ -159,7 +159,7 @@ async function useTool(store, flow, stage, card, mate, context, answer, io, now)
     catch {
         return refuse({}, "Its input wasn't a JSON object.");
     }
-    const grant = store.teammateGrant(mate.id, tool);
+    const grant = store.subagentGrant(mate.id, tool);
     const info = grant.actions.find(one => one.name === action);
     const problem = inputProblem(info, input);
     if (problem !== null)
@@ -168,18 +168,18 @@ async function useTool(store, flow, stage, card, mate, context, answer, io, now)
     if (rule.use === "never")
         return refuse(input, rule.why);
     if (rule.use === "free") {
-        const id = store.addTeammateCall({ ...receipt, input, rule: "free", state: "running" }, now);
-        await makeCall(store, store.teammateCall(id), flow.repo, io, now);
+        const id = store.addSubagentCall({ ...receipt, input, rule: "free", state: "running" }, now);
+        await makeCall(store, store.subagentCall(id), flow.repo, io, now);
         return null;
     }
     // Ask first: its person approves this exact call, in their chat app or on the card.
     const soul = { name: context.name, role: context.role };
-    const id = store.addTeammateCall({ ...receipt, input, rule: "ask", state: "asked", result: rule.why }, now);
+    const id = store.addSubagentCall({ ...receipt, input, rule: "ask", state: "asked", result: rule.why }, now);
     const words = callWords(tool, action, input, 480);
-    const question = store.openTeammateQuestion({ teammate: mate.id, card: card.id, entry: card.entry, question: `Use ${words}?`, options: [{ id: APPROVE, label: "Approve" }, { id: DENY, label: "Deny" }], askedOf: context.person, toolCall: id }, now);
+    const question = store.openSubagentQuestion({ subagent: mate.id, card: card.id, entry: card.entry, question: `Use ${words}?`, options: [{ id: APPROVE, label: "Approve" }, { id: DENY, label: "Deny" }], askedOf: context.person, toolCall: id }, now);
     if (question === null)
         return { state: "failed", said: "It asked to make the same call twice." };
-    notifyPeople(store, card, [context.person], null, { key: `teammate-q:${question}`, attention: true, subject: `${teammateLabel(soul)} asks to use ${action} on “${card.title}”`,
+    notifyPeople(store, card, [context.person], null, { key: `teammate-q:${question}`, attention: true, subject: `${subagentLabel(soul)} asks to use ${action} on “${card.title}”`,
         body: `${words}\n\n${answer.reason === "" ? "" : `Why: ${answer.reason}\n`}(${rule.why})\n\nApprove makes exactly this call. Deny stops it. Or answer in words to tell ${context.name} what to do instead.`,
     }, now);
     if (stage.kind !== "approval")
@@ -196,17 +196,17 @@ function keptWhole(store, flow, card, author, text, limit, holds, what, now) {
 }
 function carryOut(store, flow, definition, stage, card, mate, context, answer, now, io, header) {
     const soul = { name: context.name, role: context.role };
-    const actor = teammateActor(soul), label = teammateLabel(soul);
+    const actor = subagentActor(soul), label = subagentLabel(soul);
     const decisionJson = JSON.stringify(answer);
     const log = `${header}\n\n${decisionJson}`;
-    const event = (kind, said) => store.addTeammateEvent({ teammate: mate.id, card: card.id, entry: card.entry, kind, said, detail: { flow: flow.id, zone: stage.id, action: answer.action, reason: answer.reason } }, now);
+    const event = (kind, said) => store.addSubagentEvent({ subagent: mate.id, card: card.id, entry: card.entry, kind, said, detail: { flow: flow.id, zone: stage.id, action: answer.action, reason: answer.reason } }, now);
     const titleOf = (id) => definition.stages.find(one => one.id === id)?.title ?? "the next zone";
     const repos = [flow.repo];
     const note = (text) => keptWhole(store, flow, card, actor, text, LIMITS.note, "a note holds", `${label}'s note`, now);
     if (answer.action === "approve" || answer.action === "send_back") {
         const draft = draftFor(definition, stage);
         const decided = decideFlowCard(store, {
-            card: card.id, decision: answer.action === "approve" ? "approve" : "send-back", note: answer.action === "approve" ? answer.reason || null : note(answer.note), actor, repos, teammate: mate.handle, entry: card.entry, where: "a teammate",
+            card: card.id, decision: answer.action === "approve" ? "approve" : "send-back", note: answer.action === "approve" ? answer.reason || null : note(answer.note), actor, repos, subagent: mate.handle, entry: card.entry, where: "a subagent",
             ...(answer.action === "approve" && draft !== null && answer.text !== "" ? { draft: wholeDraft(answer.text) } : {}),
             ...(io.evidenceRoot === undefined ? {} : { evidenceRoot: io.evidenceRoot }),
         }, now);
@@ -223,7 +223,7 @@ function carryOut(store, flow, definition, stage, card, mate, context, answer, n
     }
     if (answer.action === "ask") {
         const options = answer.options.map((label, at) => ({ id: `o${at + 1}`, label }));
-        const opened = store.openTeammateQuestion({ teammate: mate.id, card: card.id, entry: card.entry, question: answer.question, options, askedOf: context.person }, now);
+        const opened = store.openSubagentQuestion({ subagent: mate.id, card: card.id, entry: card.entry, question: answer.question, options, askedOf: context.person }, now);
         if (opened === null)
             return { state: "failed", said: "It asked twice about the same visit.", log, decisionJson };
         event("asked", `Asked ${context.person} about “${card.title}”: ${answer.question}`);
@@ -260,10 +260,10 @@ function carryOut(store, flow, definition, stage, card, mate, context, answer, n
         store.moveFlowCard(card.id, { to: picked.to, outcome: "ok", actor, historyNote: `${actor}: ${picked.answer === CARRY_ON ? "" : `${picked.answer}. `}${answer.reason}`.trim(), expectEntry: card.entry }, now);
     return { state: "passed", said, log, decisionJson };
 }
-/** A person answers a teammate's question: once, by the person it was asked of; the card's turn is due again. */
-export function answerTeammateQuestion(store, id, answer, now) {
+/** A person answers a subagent's question: once, by the person it was asked of; the card's turn is due again. */
+export function answerSubagentQuestion(store, id, answer, now) {
     return store.transact(() => {
-        const question = store.teammateQuestion(id);
+        const question = store.subagentQuestion(id);
         if (question === null || question.state !== "open")
             return { ok: false, said: "That question was already answered." };
         if (question.askedOf !== answer.by)
@@ -275,28 +275,28 @@ export function answerTeammateQuestion(store, id, answer, now) {
         const card = store.getFlowCard(question.card);
         // v95: a rule change it suggested to its manager. Nothing about the card waits on it.
         if (question.suggestion !== null) {
-            const mate = store.getTeammate(question.teammate);
-            const decided = mate === null ? { ok: false, said: "That teammate is off the team." } : answerSuggestion(store, mate, question.suggestion, { choice: choice?.id ?? null, text, by: answer.by }, now);
-            store.answerTeammateQuestion(id, { choice: choice?.id ?? null, text, by: answer.by, via: answer.via }, now);
-            store.addTeammateEvent({ teammate: question.teammate, card: question.card, entry: question.entry, kind: "answered", said: `${answer.by}: ${[choice?.label, text].filter(Boolean).join(" — ")}`, by: answer.by }, now);
+            const mate = store.getSubagent(question.subagent);
+            const decided = mate === null ? { ok: false, said: "That subagent is off the team." } : answerSuggestion(store, mate, question.suggestion, { choice: choice?.id ?? null, text, by: answer.by }, now);
+            store.answerSubagentQuestion(id, { choice: choice?.id ?? null, text, by: answer.by, via: answer.via }, now);
+            store.addSubagentEvent({ subagent: question.subagent, card: question.card, entry: question.entry, kind: "answered", said: `${answer.by}: ${[choice?.label, text].filter(Boolean).join(" — ")}`, by: answer.by }, now);
             return decided;
         }
         // v94: an ask-first tool call. Approve makes exactly that call (on the card's next turn); Deny, or words alone, don't.
         if (question.toolCall !== null) {
             if (card === null || card.state !== "active" || card.entry !== question.entry) {
-                store.moveTeammateCall(question.toolCall, ["asked"], { state: "refused", result: "The card moved on before anyone approved it." }, now);
-                store.dropTeammateQuestion(id, now);
+                store.moveSubagentCall(question.toolCall, ["asked"], { state: "refused", result: "The card moved on before anyone approved it." }, now);
+                store.dropSubagentQuestion(id, now);
                 return { ok: false, said: "That card has moved on, so nothing was done." };
             }
-            if (!store.moveTeammateCall(question.toolCall, ["asked"], { state: choice?.id === APPROVE ? "approved" : "denied", decidedBy: answer.by }, now))
+            if (!store.moveSubagentCall(question.toolCall, ["asked"], { state: choice?.id === APPROVE ? "approved" : "denied", decidedBy: answer.by }, now))
                 return { ok: false, said: "That call was already decided." };
             // v95: approving the same action again and again teaches it to suggest a looser rule.
-            const mate = store.getTeammate(question.teammate), call = store.teammateCall(question.toolCall);
+            const mate = store.getSubagent(question.subagent), call = store.subagentCall(question.toolCall);
             if (choice?.id === APPROVE && mate !== null && call !== null)
                 considerSuggestion(store, mate, call, now);
         }
-        store.answerTeammateQuestion(id, { choice: choice?.id ?? null, text, by: answer.by, via: answer.via }, now);
-        store.addTeammateEvent({ teammate: question.teammate, card: question.card, entry: question.entry, kind: "answered", said: `${answer.by}: ${[choice?.label, text].filter(Boolean).join(" — ")}`, by: answer.by }, now);
+        store.answerSubagentQuestion(id, { choice: choice?.id ?? null, text, by: answer.by, via: answer.via }, now);
+        store.addSubagentEvent({ subagent: question.subagent, card: question.card, entry: question.entry, kind: "answered", said: `${answer.by}: ${[choice?.label, text].filter(Boolean).join(" — ")}`, by: answer.by }, now);
         if (card !== null && card.state === "active" && card.entry === question.entry) {
             store.updateFlowCard(card.id, { waiting: null }, now);
             store.wakeFlowStep(card.id, card.entry, now);
@@ -305,4 +305,4 @@ export function answerTeammateQuestion(store, id, answer, now) {
     });
 }
 /** A card's link, for messages about it. */
-export const teammateCardHref = (flow, card) => flowCardHref(flow, card);
+export const subagentCardHref = (flow, card) => flowCardHref(flow, card);

package/dist/subagents-ui.d.ts

@@ -0,0 +1,22 @@
+/**
+ * The Subagents pages (v92): who is on the team, and one page per subagent —
+ * what it asks you, its soul file, what it did and why, what you told it,
+ * and its settings. Server-rendered forms, like the other settings pages.
+ */
+import type { Store, SubagentRow } from "./store.js";
+import { type Html } from "./html.js";
+/** v94: the Tools section's rule rows; a limit's fields show only while "Up to a limit" is chosen. */
+export declare const SUBAGENT_CSS = ".subagent-tools .tool-grant{border-top:1px solid var(--so-line);padding-top:12px;margin-top:12px}.subagent-tools .tool-grant:first-of-type{border-top:0;margin-top:0;padding-top:0}.subagent-tools h3{font-size:1rem;margin:0 0 4px}.subagent-tools .tool-rule{display:grid;gap:6px;padding:10px 0;border-bottom:1px solid var(--so-line)}.subagent-tools .tool-rule:last-of-type{border-bottom:0}.subagent-tools .tool-rule .meta{display:block}.subagent-tools select,.subagent-tools input{max-width:100%;box-sizing:border-box}.subagent-tools .tool-limit{display:none;flex-wrap:wrap;align-items:center;gap:6px}.subagent-tools .tool-rule:has(option[value=\"limit\"]:checked) .tool-limit{display:flex}.subagent-tools .tool-rule>select{width:auto;min-width:16em}.subagent-tools .tool-limit select{width:auto}.subagent-tools .tool-limit input{width:7em}.subagent-tools .tool-buttons{display:flex;flex-wrap:wrap;gap:8px;margin-top:8px}.subagent-tools button{min-height:44px}.subagent-activity li{overflow-wrap:anywhere}.subagent-memory .memory-tell,.subagent-memory .memory-search{display:flex;flex-wrap:wrap;gap:8px;align-items:flex-end;margin:0 0 12px}.subagent-memory .memory-tell textarea{flex:1 1 280px}.subagent-memory .memory-search input{flex:1 1 220px}.subagent-memory button{min-height:44px}.subagent-memories{list-style:none;padding:0;margin:0}.subagent-memories li{padding:10px 0;border-top:1px solid var(--so-line);overflow-wrap:anywhere}.subagent-memories li:first-child{border-top:0}.subagent-memories .meta{display:block;font-size:.85rem}.subagent-memories details.memory-edit{border:0;padding:0;margin:2px 0 0;background:transparent;box-shadow:none}.memory-edit summary{cursor:pointer;min-height:32px;display:inline-flex;align-items:center;font-size:.85rem;font-weight:400;color:var(--so-muted)}.tool-undo{border:0;padding:0;margin:8px 0;background:transparent;box-shadow:none}.tool-undo summary{cursor:pointer;min-height:36px;display:inline-flex;align-items:center;font-size:.9rem}.tool-undo-row{display:flex;flex-wrap:wrap;gap:6px;align-items:center;margin:6px 0}.tool-undo-row select{width:auto}.subagent-overrides,.subagent-undo{padding-left:18px}.subagent-undo li{margin:6px 0}.subagent-undo form{display:inline}.subagent-week h3{font-size:1rem;margin:14px 0 4px}.subagent-week button{min-height:44px}.subagent-routines{list-style:none;padding:0;margin:8px 0}.subagent-routines li{display:grid;gap:4px;padding:10px 0;border-top:1px solid var(--so-line)}.subagent-routines li:first-child{border-top:0}.routine-buttons{display:flex;flex-wrap:wrap;gap:8px}.routine-buttons button,.routine-add button{min-height:44px}.routine-add{display:flex;flex-wrap:wrap;gap:8px;align-items:flex-end;margin:8px 0}.routine-add label{display:grid;gap:4px;flex:1 1 200px}.routine-add label:first-of-type{flex:0 1 180px}.subagent-actions,.question-options{display:flex;flex-wrap:wrap;gap:8px;margin:8px 0}.subagent-actions form,.question-options form{margin:0}.memory-edit form{display:grid;gap:8px;margin-top:6px}.memory-buttons{display:flex;flex-wrap:wrap;gap:8px}@media(max-width:600px){.subagent-tools select,.subagent-tools input{font-size:16px}}";
+/** A blank soul file: the sections a subagent reads, to fill in. */
+export declare const BLANK_SOUL = "---\nname: \nrole: \n---\n\n## Who you are\n\n\n## How you write\n\n\n## What you know\n\n\n## Decide on your own\n- \n\n## Ask first\n- \n\n## Never\n- \n";
+export declare function subagentsListHtml(store: Store, mates: readonly SubagentRow[], projects: readonly string[], projectName: (repo: string) => string, canCreate: boolean, notice: {
+    said?: string | null;
+    problem?: string | null;
+    adding?: boolean;
+}): Html;
+export declare function subagentPageHtml(store: Store, mate: SubagentRow, viewer: string, projectName: (repo: string) => string, canManage: boolean, approvers: readonly string[], notice: {
+    said?: string | null;
+    problem?: string | null;
+    soulDraft?: string | null;
+    query?: string | null;
+}): Html;