toolroll 0.9.55 → 0.9.56

package/dist/subagent-admin.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Looking after subagents (v92): making one from a template or a soul
+ * file, editing its soul (a new version each time), pausing or removing it,
+ * telling it something, and the daily summary it sends its manager.
+ *
+ * Shared by the Subagents pages and the lead chat, so both do the same thing.
+ */
+import type { Store, SubagentRow } from "./store.js";
+export type Done = {
+    ok: true;
+    said: string;
+    id?: number;
+} | {
+    ok: false;
+    said: string;
+};
+export declare const SUBAGENT_MODELS: readonly ["default", "sonnet", "opus", "haiku"];
+/** A soul file with a different name: the template's, renamed. */
+export declare function renamedSoul(soul: string, name: string): string;
+/** A new subagent in a project, from a template (optionally renamed) or a whole soul file. */
+export declare function createSubagentFrom(store: Store, input: {
+    repo: string;
+    template?: string | null;
+    name?: string | null;
+    soul?: string | null;
+    by: string;
+}, now: Date): Done;
+/** Save a new version of a subagent's soul file. Its name stays: zones name it by handle. */
+export declare function saveSoul(store: Store, mate: SubagentRow, soul: string, by: string, now: Date): Done;
+/** Pause, resume or remove. Paused, its decisions go to people and the zones it handles wait. */
+export declare function setSubagentState(store: Store, mate: SubagentRow, state: "active" | "paused" | "removed", by: string, now: Date): Done;
+export declare function subagentSettings(store: Store, mate: SubagentRow, change: {
+    model?: string;
+    dailyTurns?: number;
+    manager?: string;
+}, by: string, now: Date): Done;
+export declare const nameOf: (mate: SubagentRow) => string;
+export declare const labelOf: (mate: SubagentRow) => string;
+/** Every zone a subagent works, in every flow of its project. */
+export declare function zonesOf(store: Store, mate: SubagentRow): {
+    flow: number;
+    flowName: string;
+    zone: string;
+    title: string;
+    kind: "decides" | "handles";
+}[];
+/** What a subagent did since a time, in words its manager reads at a glance. */
+export declare function summaryOf(store: Store, mate: SubagentRow, since: string | null): {
+    said: string;
+    quiet: boolean;
+};
+/** The daily summary, to each subagent's manager, once a day after 5 pm (this computer's time), or now when asked. */
+export declare function sendSubagentSummaries(store: Store, repo: string, now: Date, only?: number | null): number;

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

@@ -1,13 +1,13 @@
 import { flowDefinitionOf } from "./flow-engine.js";
-import { handleOf, parseSoul, TEAMMATE_TEMPLATES, teammateLabel } from "./teammates.js";
-export const TEAMMATE_MODELS = ["default", "sonnet", "opus", "haiku"];
+import { handleOf, parseSoul, SUBAGENT_TEMPLATES, subagentLabel } from "./subagents.js";
+export const SUBAGENT_MODELS = ["default", "sonnet", "opus", "haiku"];
 /** A soul file with a different name: the template's, renamed. */
 export function renamedSoul(soul, name) {
     return soul.replace(/^name:.*$/m, `name: ${name.replace(/[\r\n]/g, " ").trim()}`);
 }
-/** A new teammate in a project, from a template (optionally renamed) or a whole soul file. */
-export function createTeammateFrom(store, input, now) {
-    const template = TEAMMATE_TEMPLATES.find(one => one.id === input.template);
+/** A new subagent in a project, from a template (optionally renamed) or a whole soul file. */
+export function createSubagentFrom(store, input, now) {
+    const template = SUBAGENT_TEMPLATES.find(one => one.id === input.template);
     let soul = input.soul?.trim() ? input.soul : template?.soul ?? null;
     if (soul === null)
         return { ok: false, said: "Start from a template, or write a soul file." };
@@ -17,67 +17,67 @@ export function createTeammateFrom(store, input, now) {
     if (!read.ok)
         return { ok: false, said: read.problem };
     const handle = handleOf(read.soul.name);
-    if (store.teammateByHandle(input.repo, handle) !== null)
-        return { ok: false, said: `There's already a teammate called ${read.soul.name} in this project. Give this one another name.` };
-    const id = store.createTeammate({ repo: input.repo, handle, soul, model: null, manager: input.by, by: input.by }, now);
-    store.addTeammateEvent({ teammate: id, kind: "note", said: `${input.by} brought ${read.soul.name} onto the team.`, by: input.by }, now);
-    return { ok: true, said: `${teammateLabel(read.soul)} is on the team. Put ${read.soul.name} on a zone to start.`, id };
+    if (store.subagentByHandle(input.repo, handle) !== null)
+        return { ok: false, said: `There's already a subagent called ${read.soul.name} in this project. Give this one another name.` };
+    const id = store.createSubagent({ repo: input.repo, handle, soul, model: null, manager: input.by, by: input.by }, now);
+    store.addSubagentEvent({ subagent: id, kind: "note", said: `${input.by} brought ${read.soul.name} onto the team.`, by: input.by }, now);
+    return { ok: true, said: `${subagentLabel(read.soul)} is on the team. Put ${read.soul.name} on a zone to start.`, id };
 }
-/** Save a new version of a teammate's soul file. Its name stays: zones name it by handle. */
+/** Save a new version of a subagent's soul file. Its name stays: zones name it by handle. */
 export function saveSoul(store, mate, soul, by, now) {
     const read = parseSoul(soul);
     if (!read.ok)
         return { ok: false, said: read.problem };
     if (handleOf(read.soul.name) !== mate.handle)
-        return { ok: false, said: `Keep the name (zones find this teammate as ${mate.handle}); make a new teammate for another name.` };
-    const saved = store.saveTeammateSoul(mate.id, soul.replace(/\r\n?/g, "\n").trim() + "\n", by, now);
+        return { ok: false, said: `Keep the name (zones find this subagent as ${mate.handle}); make a new subagent for another name.` };
+    const saved = store.saveSubagentSoul(mate.id, soul.replace(/\r\n?/g, "\n").trim() + "\n", by, now);
     return { ok: true, said: saved ? `Saved. ${read.soul.name} works from version ${mate.version + 1} now.` : "No changes to save." };
 }
 /** Pause, resume or remove. Paused, its decisions go to people and the zones it handles wait. */
-export function setTeammateState(store, mate, state, by, now) {
+export function setSubagentState(store, mate, state, by, now) {
     const name = nameOf(mate);
     if (state === mate.state)
         return { ok: true, said: "No change." };
     if (state === "removed") {
-        for (const question of store.openTeammateQuestions([mate.id]))
-            store.dropTeammateQuestion(question.id, now);
+        for (const question of store.openSubagentQuestions([mate.id]))
+            store.dropSubagentQuestion(question.id, now);
         // v94: calls waiting for approval, or approved and not made yet, are never made.
-        for (const call of store.teammateCallsOf(mate.id, 500).filter(one => one.state === "asked" || one.state === "approved"))
-            store.moveTeammateCall(call.id, ["asked", "approved"], { state: "refused", result: `${name} left the team before the call was made.` }, now);
-        store.updateTeammate(mate.id, { state }, by, now);
+        for (const call of store.subagentCallsOf(mate.id, 500).filter(one => one.state === "asked" || one.state === "approved"))
+            store.moveSubagentCall(call.id, ["asked", "approved"], { state: "refused", result: `${name} left the team before the call was made.` }, now);
+        store.updateSubagent(mate.id, { state }, by, now);
         return { ok: true, said: `${name} is off the team. Zones that named ${name} go to people now.` };
     }
-    store.updateTeammate(mate.id, { state }, by, now);
-    store.addTeammateEvent({ teammate: mate.id, kind: state === "paused" ? "paused" : "resumed", said: state === "paused" ? `${by} paused ${name}.` : `${by} set ${name} working again.`, by }, now);
+    store.updateSubagent(mate.id, { state }, by, now);
+    store.addSubagentEvent({ subagent: mate.id, kind: state === "paused" ? "paused" : "resumed", said: state === "paused" ? `${by} paused ${name}.` : `${by} set ${name} working again.`, by }, now);
     return { ok: true, said: state === "paused" ? `${name} is paused. Its decisions go to people until you resume it.` : `${name} is working again.` };
 }
-export function teammateSettings(store, mate, change, by, now) {
-    const model = change.model === undefined ? undefined : change.model === "default" ? null : TEAMMATE_MODELS.includes(change.model) ? change.model : undefined;
+export function subagentSettings(store, mate, change, by, now) {
+    const model = change.model === undefined ? undefined : change.model === "default" ? null : SUBAGENT_MODELS.includes(change.model) ? change.model : undefined;
     if (change.model !== undefined && model === undefined)
         return { ok: false, said: "Choose one of the models listed." };
     if (change.dailyTurns !== undefined && (!Number.isInteger(change.dailyTurns) || change.dailyTurns < 1 || change.dailyTurns > 2000))
         return { ok: false, said: "A daily limit is 1 to 2,000 turns." };
     if (change.manager !== undefined && !store.accountCanAccess(change.manager, mate.repo))
         return { ok: false, said: "Its manager must be someone on this project." };
-    store.updateTeammate(mate.id, { ...(model === undefined ? {} : { model }), ...(change.dailyTurns === undefined ? {} : { dailyTurns: change.dailyTurns }), ...(change.manager === undefined ? {} : { manager: change.manager }) }, by, now);
+    store.updateSubagent(mate.id, { ...(model === undefined ? {} : { model }), ...(change.dailyTurns === undefined ? {} : { dailyTurns: change.dailyTurns }), ...(change.manager === undefined ? {} : { manager: change.manager }) }, by, now);
     return { ok: true, said: "Saved." };
 }
 export const nameOf = (mate) => { const read = parseSoul(mate.soul); return read.ok ? read.soul.name : mate.handle; };
-export const labelOf = (mate) => { const read = parseSoul(mate.soul); return read.ok ? teammateLabel(read.soul) : mate.handle; };
-/** Every zone a teammate works, in every flow of its project. */
+export const labelOf = (mate) => { const read = parseSoul(mate.soul); return read.ok ? subagentLabel(read.soul) : mate.handle; };
+/** Every zone a subagent works, in every flow of its project. */
 export function zonesOf(store, mate) {
-    return store.listFlows([mate.repo]).flatMap(flow => (flowDefinitionOf(flow)?.stages ?? []).filter(one => one.teammate === mate.handle)
+    return store.listFlows([mate.repo]).flatMap(flow => (flowDefinitionOf(flow)?.stages ?? []).filter(one => one.subagent === mate.handle)
         .map(one => ({ flow: flow.id, flowName: flow.name, zone: one.id, title: one.title, kind: one.kind === "approval" ? "decides" : "handles" })));
 }
-/** What a teammate did since a time, in words its manager reads at a glance. */
+/** What a subagent did since a time, in words its manager reads at a glance. */
 export function summaryOf(store, mate, since) {
     const name = nameOf(mate);
-    const events = store.teammateEvents(mate.id, 500, since);
+    const events = store.subagentEvents(mate.id, 500, since);
     const count = (kind) => events.filter(one => one.kind === kind).length;
     const decided = count("decided"), handled = count("handled"), handed = count("handed"), asked = count("asked"), failed = count("failed");
-    const open = store.openTeammateQuestions([mate.id]).length;
+    const open = store.openSubagentQuestions([mate.id]).length;
     // v94: its tool calls — made, approved first, and what its people said no to.
-    const calls = store.teammateCallsOf(mate.id, 1000, since);
+    const calls = store.subagentCallsOf(mate.id, 1000, since);
     const made = calls.filter(one => one.state === "done" || one.state === "failed").length, approved = calls.filter(one => one.decidedBy !== null && one.state !== "denied").length, denied = calls.filter(one => one.state === "denied").length;
     const quiet = decided + handled + handed + asked + failed + calls.length === 0;
     const lines = [
@@ -88,23 +88,23 @@ export function summaryOf(store, mate, since) {
     ];
     return { said: lines.join("\n"), quiet };
 }
-/** The daily summary, to each teammate's manager, once a day after 5 pm (this computer's time), or now when asked. */
-export function sendTeammateSummaries(store, repo, now, only = null) {
+/** The daily summary, to each subagent's manager, once a day after 5 pm (this computer's time), or now when asked. */
+export function sendSubagentSummaries(store, repo, now, only = null) {
     const evening = new Date(now);
     evening.setHours(17, 0, 0, 0);
     const start = new Date(now);
     start.setHours(0, 0, 0, 0);
     let sent = 0;
-    for (const mate of store.teammates([repo])) {
+    for (const mate of store.subagents([repo])) {
         if (only !== null ? mate.id !== only : mate.state !== "active" || now < evening || (mate.summaryAt !== null && mate.summaryAt >= evening.toISOString()))
             continue;
         const summary = summaryOf(store, mate, start.toISOString());
-        store.updateTeammate(mate.id, { summaryAt: now.toISOString() }, "summary", now);
+        store.updateSubagent(mate.id, { summaryAt: now.toISOString() }, "summary", now);
         if (summary.quiet && only === null)
             continue;
         store.enqueueNotification({ dedupeKey: `teammate-summary:${mate.id}:${now.toISOString().slice(0, only === null ? 10 : 19)}`, kind: "teammate-summary", recipient: mate.manager,
-            subject: `${labelOf(mate)}: today`, body: summary.said, link: `/teammates/${mate.id}`, source: { project: repo } }, now);
-        store.addTeammateEvent({ teammate: mate.id, kind: "summary", said: summary.said }, now);
+            subject: `${labelOf(mate)}: today`, body: summary.said, link: `/settings/lead/subagents/${mate.id}`, source: { project: repo } }, now);
+        store.addSubagentEvent({ subagent: mate.id, kind: "summary", said: summary.said }, now);
         sent++;
     }
     return sent;

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

@@ -1,5 +1,5 @@
-import type { FlowCardRow, FlowRow, Store, TeammateRow } from "./store.js";
-/** The zone on a desk where the teammate handles what it's asked. */
+import type { FlowCardRow, FlowRow, Store, SubagentRow } from "./store.js";
+/** The zone on a desk where the subagent handles what it's asked. */
 export declare const DESK_ZONE = "handle";
 type Done = {
     ok: true;
@@ -9,34 +9,33 @@ type Done = {
     said: string;
 };
 /** Its desk, when it has one. */
-export declare function deskOf(store: Store, mate: TeammateRow): FlowRow | null;
+export declare function deskOf(store: Store, mate: SubagentRow): FlowRow | null;
 /** Its desk, made the first time it's needed: owned by its manager, drawn like any flow. */
-export declare function ensureDesk(store: Store, mate: TeammateRow, now: Date): FlowRow;
+export declare function ensureDesk(store: Store, mate: SubagentRow, now: Date): FlowRow;
 /** Who a desk card's answer goes to: the person who asked (when they can see the project), else its manager. */
-export declare function askerOf(store: Store, flow: FlowRow, card: FlowCardRow, mate: TeammateRow): string;
-/** The answer a teammate wrote, back to whoever asked, under its name. Once per visit. */
-export declare function replyToAsker(store: Store, flow: FlowRow, card: FlowCardRow, mate: TeammateRow, text: string, now: Date): void;
-/** "@rosa …", "@rosa, …", "Rosa: …" or "Rosa, …": the teammate a message is addressed to, and what it says. */
-export declare function addressedTo(text: string): {
-    name: string;
-    said: string;
-} | null;
+export declare function askerOf(store: Store, flow: FlowRow, card: FlowCardRow, mate: SubagentRow): string;
+/** The answer a subagent wrote, back to whoever asked, under its name. Once per visit. */
+export declare function replyToAsker(store: Store, flow: FlowRow, card: FlowCardRow, mate: SubagentRow, text: string, now: Date): void;
 /**
- * A message in someone's chat with Toolroll, addressed to a teammate
- * by name, becomes a card on its desk; null when it isn't addressed to one of
- * the teammates in their projects (it goes to the lead as usual).
+ * The lead delegates (D5): "ask Rosa to …", once its person confirms the card, is a card on Rosa's desk from that
+ * person. Rosa works it within her own rules and tools (asking them first where her rules say to), and her answer goes
+ * back to whoever asked. It gives her nothing her rules don't: a code change is still a task a person approves.
  */
-export declare function messageTeammate(store: Store, from: {
+export declare function askSubagent(store: Store, given: SubagentRow, from: {
     who: string;
-    repos: readonly string[];
     via: string;
 }, text: string, now: Date): {
+    ok: true;
     said: string;
-    link?: {
+    card: number;
+    link: {
         label: string;
         path: string;
     };
-} | null;
+} | {
+    ok: false;
+    said: string;
+};
 export type Routine = {
     id: number;
     schedule: string;
@@ -47,14 +46,14 @@ export type Routine = {
     nextAt: string | null;
 };
 /** Its routines: the schedules on its desk that start in its zone. */
-export declare function routinesOf(store: Store, mate: TeammateRow): Routine[];
+export declare function routinesOf(store: Store, mate: SubagentRow): Routine[];
 /** This computer's time zone: what a routine's time means when it names none. */
 export declare const localZone: () => string;
 /** A routine's schedule as kept: a calendar time with no zone is this computer's time, not UTC. */
 export declare function routineSchedule(words: string): string | null;
 /** A routine: on this schedule ("weekdays 09:00", "daily 17:00 Europe/London", "every 2 hours"), a card on its desk saying what to do. */
-export declare function addRoutine(store: Store, mate: TeammateRow, schedule: string, text: string, by: string, now: Date, dir: string | null): Done;
-export declare function removeRoutine(store: Store, mate: TeammateRow, id: number, now: Date, dir: string | null): Done;
+export declare function addRoutine(store: Store, mate: SubagentRow, schedule: string, text: string, by: string, now: Date, dir: string | null): Done;
+export declare function removeRoutine(store: Store, mate: SubagentRow, id: number, now: Date, dir: string | null): Done;
 /** Try a routine now: its card lands on the desk at once. */
-export declare function runRoutine(store: Store, mate: TeammateRow, id: number, by: string, now: Date): Done;
+export declare function runRoutine(store: Store, mate: SubagentRow, id: number, by: string, now: Date): Done;
 export {};

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

@@ -1,10 +1,10 @@
 /**
- * A teammate's desk (v96): its own flow, where anything asked of it directly
- * lands as a card — a message to it by name in a chat app ("@rosa, where's
- * order 2201?", or "Rosa: …"), or one of its routines ("every weekday at
- * 9:00: …") — and its answer goes back to whoever asked.
+ * A subagent's desk (v96): its own flow, where anything asked of it directly
+ * lands as a card — the lead asking it for its person ("ask Rosa where order
+ * 2201 is", D5), or one of its routines ("every weekday at 9:00: …") — and
+ * its answer goes back to whoever asked.
  *
- * The desk is an ordinary flow its manager owns and can redraw. The teammate
+ * The desk is an ordinary flow its manager owns and can redraw. The subagent
  * handles each card there within its rules and tools (asking first when they
  * say to), writes its answer, and picks where the card goes: Done, a code
  * change (the Build zone files an ordinary task that a person approves as
@@ -14,8 +14,8 @@ import { flowCardHref, flowDefinitionOf } from "./flow-engine.js";
 import { flowFromSteps } from "./flows.js";
 import { addFlowTriggerTo, removeFlowTrigger, runScheduleNow, scheduleFromWords, triggerConfigOf } from "./flow-triggers.js";
 import { describeSchedule, parseSchedule } from "./flow-schedule.js";
-import { labelOf, nameOf } from "./teammate-admin.js";
-/** The zone on a desk where the teammate handles what it's asked. */
+import { labelOf, nameOf } from "./subagent-admin.js";
+/** The zone on a desk where the subagent handles what it's asked. */
 export const DESK_ZONE = "handle";
 const DESK_INSTRUCTIONS = "Someone asked you this directly, or it's one of your routines. Do what they ask within your rules, using your tools when it needs them, and write your answer to them in \"text\": it goes back to whoever asked. Pick Done when you've answered, Needs a code change when what they want is a change to this project's code (it's filed as a task for a person to approve), and Needs a person when it's beyond you.";
 /** Its desk, when it has one. */
@@ -31,61 +31,52 @@ export function ensureDesk(store, mate, now) {
     const name = nameOf(mate);
     const person = `For ${mate.manager}`.slice(0, 60);
     const definition = flowFromSteps([
-        { id: DESK_ZONE, title: "Requests", kind: "teammate", teammate: mate.handle, reply: true, instructions: DESK_INSTRUCTIONS,
+        { id: DESK_ZONE, title: "Requests", kind: "subagent", subagent: mate.handle, reply: true, instructions: DESK_INSTRUCTIONS,
             routes: [{ answer: "Done", goesTo: "Done" }, { answer: "Needs a code change", goesTo: "Build it" }, { answer: "Needs a person", goesTo: person }], ifFails: person },
         { id: "build", title: "Build it", kind: "task", planning: "auto", next: "Done" },
         { id: "person", title: person, kind: "inbox" },
         { id: "done", title: "Done", kind: "done" },
     ], null);
     const id = store.createFlow({ repo: mate.repo, name: `${name}'s desk`.slice(0, 80), definitionJson: JSON.stringify(definition), by: mate.manager }, now);
-    store.setTeammateDesk(mate.id, id);
+    store.setSubagentDesk(mate.id, id);
     return store.getFlow(id);
 }
 /** Who a desk card's answer goes to: the person who asked (when they can see the project), else its manager. */
 export function askerOf(store, flow, card, mate) {
     return store.accountOf(card.createdBy) !== null && store.accountCanAccess(card.createdBy, flow.repo) ? card.createdBy : mate.manager;
 }
-/** The answer a teammate wrote, back to whoever asked, under its name. Once per visit. */
+/** The answer a subagent wrote, back to whoever asked, under its name. Once per visit. */
 export function replyToAsker(store, flow, card, mate, text, now) {
     const to = askerOf(store, flow, card, mate);
     store.enqueueNotification({ dedupeKey: `teammate-reply:${card.id}:${card.entry}`, kind: "teammate-reply", recipient: to, subject: `${labelOf(mate)}: ${card.title}`.slice(0, 200),
         body: text.slice(0, 3500), link: flowCardHref(flow.id, card.id), source: { project: flow.repo } }, now);
 }
-/** "@rosa …", "@rosa, …", "Rosa: …" or "Rosa, …": the teammate a message is addressed to, and what it says. */
-export function addressedTo(text) {
-    const at = /^\s*@([\p{L}\p{N}][\p{L}\p{N}-]{0,31})[\s,:]+([\s\S]*\S[\s\S]*)$/u.exec(text);
-    if (at !== null)
-        return { name: at[1], said: at[2].trim() };
-    const named = /^\s*([\p{L}][\p{L}\p{N}-]{0,31})\s*[,:]\s+([\s\S]*\S[\s\S]*)$/u.exec(text);
-    return named === null ? null : { name: named[1], said: named[2].trim() };
-}
 /**
- * A message in someone's chat with Toolroll, addressed to a teammate
- * by name, becomes a card on its desk; null when it isn't addressed to one of
- * the teammates in their projects (it goes to the lead as usual).
+ * The lead delegates (D5): "ask Rosa to …", once its person confirms the card, is a card on Rosa's desk from that
+ * person. Rosa works it within her own rules and tools (asking them first where her rules say to), and her answer goes
+ * back to whoever asked. It gives her nothing her rules don't: a code change is still a task a person approves.
  */
-export function messageTeammate(store, from, text, now) {
-    const addressed = addressedTo(text);
-    if (addressed === null)
-        return null;
-    const wanted = addressed.name.toLowerCase();
-    const mate = store.teammates(from.repos).find(one => one.handle === wanted || nameOf(one).toLowerCase() === wanted);
-    if (mate === undefined || !store.accountCanAccess(from.who, mate.repo))
-        return null;
+export function askSubagent(store, given, from, text, now) {
+    // As it is now (its desk may have been made since the caller read it), never as the caller last saw it.
+    const mate = store.getSubagent(given.id) ?? given;
     const name = nameOf(mate);
     if (mate.state !== "active")
-        return { said: `${name} is paused, so nothing was passed on. Resume ${name} on its page, or ask the lead.` };
+        return { ok: false, said: `${name} is paused, so nothing was passed on. Resume ${name} first.` };
+    if (!store.accountCanAccess(from.who, mate.repo))
+        return { ok: false, said: `${name} works in a project you can't use.` };
+    const said = text.replace(/\r\n?/g, "\n").trim().slice(0, 4000);
+    if (said === "")
+        return { ok: false, said: `Say what to ask ${name}.` };
     const desk = ensureDesk(store, mate, now);
     const definition = flowDefinitionOf(desk);
     const zone = definition?.stages.find(one => one.id === DESK_ZONE) ?? definition?.stages.find(one => one.id === definition.start);
     if (zone === undefined)
-        return { said: `${name}'s desk can't take cards right now.` };
-    const said = addressed.said.slice(0, 4000);
+        return { ok: false, said: `${name}'s desk can't take cards right now.` };
     const firstLine = said.split("\n")[0].trim();
     const title = firstLine.length <= 100 ? firstLine : `${firstLine.slice(0, 99)}…`;
-    const card = store.addFlowCard({ flow: desk.id, title, description: said === title ? null : said, stage: zone.id, by: from.who, source: { kind: "message", label: `${from.via} message`, url: null } }, now);
+    const card = store.addFlowCard({ flow: desk.id, title, description: said === title ? null : said, stage: zone.id, by: from.who, source: { kind: "message", label: `Asked through ${from.via}`, url: null } }, now);
     store.setFlowCardWatcher(card, from.who, true, now);
-    return { said: `${name} has it. The answer comes here when it's done.`, link: { label: "Open the card", path: flowCardHref(desk.id, card) } };
+    return { ok: true, said: `${name} has it. The answer comes to you when it's done.`, card, link: { label: "Open the card", path: flowCardHref(desk.id, card) } };
 }
 /** Its routines: the schedules on its desk that start in its zone. */
 export function routinesOf(store, mate) {
@@ -122,7 +113,7 @@ export function addRoutine(store, mate, schedule, text, by, now, dir) {
     if (what.length > 200)
         return { ok: false, said: "Keep a routine to 200 characters; put detail in its soul file." };
     if (routinesOf(store, mate).length >= 10)
-        return { ok: false, said: "A teammate has at most 10 routines." };
+        return { ok: false, said: "A subagent has at most 10 routines." };
     const kept = routineSchedule(schedule);
     if (kept === null)
         return { ok: false, said: "Say the schedule like “weekdays 09:00”, “daily 17:00”, “monday 09:00” or “every 2 hours”." };

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

@@ -1,8 +1,8 @@
-import type { Store, TeammateCallRow, TeammateMemoryRow, TeammateRow } from "./store.js";
+import type { Store, SubagentCallRow, SubagentMemoryRow, SubagentRow } from "./store.js";
 export declare 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 declare 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 declare const SUGGEST_AFTER = 5;
 export declare const ACCEPT = "accept", DISMISS = "dismiss";
 type Done = {
@@ -24,39 +24,39 @@ export declare function cleanMemory(text: string): {
     ok: false;
     said: string;
 };
-/** 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. */
-export declare function remember(store: Store, mate: TeammateRow, text: string, from: {
-    source: TeammateMemoryRow["source"];
+/** 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 declare function remember(store: Store, mate: SubagentRow, text: string, from: {
+    source: SubagentMemoryRow["source"];
     card?: number | null;
     by: string;
 }, now: Date): Done & {
     id?: number;
 };
-/** 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 declare function tellTeammate(store: Store, mate: TeammateRow, note: string, by: string, now: Date): Done;
-export declare function editMemory(store: Store, mate: TeammateRow, id: number, text: string, by: string, now: Date): Done;
-export declare function forgetMemory(store: Store, mate: TeammateRow, id: number, by: string, now: Date): Done;
+/** 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 declare function tellSubagent(store: Store, mate: SubagentRow, note: string, by: string, now: Date): Done;
+export declare function editMemory(store: Store, mate: SubagentRow, id: number, text: string, by: string, now: Date): Done;
+export declare function forgetMemory(store: Store, mate: SubagentRow, id: number, by: string, now: Date): Done;
 /** Memories whose text holds every word searched for. */
-export declare function searchMemories(store: Store, mate: TeammateRow, query: string): TeammateMemoryRow[];
+export declare function searchMemories(store: Store, mate: SubagentRow, query: string): SubagentMemoryRow[];
 /**
  * What one turn reads: what its people told it lately (oldest first), and
  * what it kept that fits the card — the facts sharing most of the card's
  * words, then its newest — up to eight.
  */
-export declare function memoriesFor(store: Store, mate: TeammateRow, cardText: string, now: Date): {
-    told: TeammateMemoryRow[];
-    kept: TeammateMemoryRow[];
+export declare function memoriesFor(store: Store, mate: SubagentRow, cardText: string, now: Date): {
+    told: SubagentMemoryRow[];
+    kept: SubagentMemoryRow[];
 };
 /** A limit a person would pick: rounded up to a round number. */
 export declare const roundUp: (value: number) => number;
 /**
  * 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 declare function considerSuggestion(store: Store, mate: TeammateRow, approved: TeammateCallRow, now: Date): number | null;
+export declare function considerSuggestion(store: Store, mate: SubagentRow, approved: SubagentCallRow, now: Date): number | null;
 /** 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 declare function answerSuggestion(store: Store, mate: TeammateRow, suggestion: number, answer: {
+export declare function answerSuggestion(store: Store, mate: SubagentRow, suggestion: number, answer: {
     choice: string | null;
     text: string | null;
     by: string;