toolroll 0.9.55 → 0.9.57

package/dist/flow-engine.d.ts

@@ -72,8 +72,8 @@ export declare function decideFlowCard(store: Store, input: {
     draft?: string | null;
     /** The visit the person saw (a chat button's): a card that moved on since is refused. */
     entry?: number;
-    /** v92: the AI teammate (by handle) deciding a zone it staffs; `actor` is then how it reads in history. */
-    teammate?: string;
+    /** v92: the subagent (by handle) deciding a zone it staffs; `actor` is then how it reads in history. */
+    subagent?: string;
     /** Where the decision was made, for its ledger line: "the console", "the command line", "Telegram". */
     where?: string;
 }, now: Date): FlowDecision;

package/dist/flow-engine.js

@@ -18,7 +18,7 @@ import { readVerifiedReport, scanForSecrets } from "./evidence.js";
 import { cardFollowers, notifyPeople } from "./flow-people.js";
 import { DRAFT_CHARS, keptDraft } from "./flow-draft.js";
 import { chooseStep, flowPersonOf, sendStep } from "./flow-send.js";
-import { parseSoul, teammateLabel } from "./teammates.js";
+import { parseSoul, subagentLabel } from "./subagents.js";
 import { withStageHandoff } from "./contracts/stage-output.js";
 /** The flow's drawing, or null when it can't be read (the card then says so and waits). */
 export function flowDefinitionOf(flow) {
@@ -42,15 +42,15 @@ function fill(template, card) {
 }
 const titleIn = (definition, id) => definition.stages.find(one => one.id === id)?.title ?? id;
 const flowDefinitionStage = (definition, id) => definition.stages.find(one => one.id === id);
-/** A teammate's name as its soul file gives it (its handle when the file can't be read). */
-function teammateName(mate) {
+/** A subagent's name as its soul file gives it (its handle when the file can't be read). */
+function subagentName(mate) {
     const read = parseSoul(mate.soul);
     return read.ok ? read.soul.name : mate.handle;
 }
-/** What a teammate said when it handed a card to its person, or why it couldn't decide. */
+/** What a subagent said when it handed a card to its person, or why it couldn't decide. */
 function handoffWords(mate, turn) {
     const read = parseSoul(mate.soul);
-    const label = read.ok ? teammateLabel(read.soul) : mate.handle;
+    const label = read.ok ? subagentLabel(read.soul) : mate.handle;
     let note = "";
     try {
         const decided = JSON.parse(turn.decisionJson ?? "{}");
@@ -187,20 +187,20 @@ function advanceCard(store, flow, definition, card, now, options, outcome) {
         case "approval": {
             const decider = deciderOf(stage, flow);
             const who = decider ?? "an approver";
-            // v92: a zone an active teammate staffs is its to decide first (the step pass runs it). A person hears
-            // about the card only when the teammate hands it over, can't decide, or is paused or gone.
-            // v102: on a protected project an AI teammate never decides; the person does.
-            const mate = stage.teammate === undefined || store.approvalRules(flow.repo).protectProject ? null : store.teammateByHandle(flow.repo, stage.teammate);
+            // v92: a zone an active subagent staffs is its to decide first (the step pass runs it). A person hears
+            // about the card only when the subagent hands it over, can't decide, or is paused or gone.
+            // v102: on a protected project a subagent never decides; the person does.
+            const mate = stage.subagent === undefined || store.approvalRules(flow.repo).protectProject ? null : store.subagentByHandle(flow.repo, stage.subagent);
             const turn = mate === null ? null : store.flowStepRun(card.id, card.entry);
-            const handed = turn !== null && turn.kind === "teammate" && (turn.state === "failed" || turn.state === "passed");
+            const handed = turn !== null && turn.kind === "subagent" && (turn.state === "failed" || turn.state === "passed");
             if (mate !== null && mate.state === "active" && !handed) {
-                const name = teammateName(mate);
+                const name = subagentName(mate);
                 if (card.waiting !== `${name} is deciding`)
                     store.updateFlowCard(card.id, { waiting: `${name} is deciding` }, now);
                 return;
             }
             const handoff = handed && mate !== null ? handoffWords(mate, turn) : null;
-            if (card.waiting === null || (mate !== null && card.waiting === `${teammateName(mate)} is deciding`)) {
+            if (card.waiting === null || (mate !== null && card.waiting === `${subagentName(mate)} is deciding`)) {
                 // A named decider hears it alone; "anyone who approves" pages everyone who can.
                 // With a draft in front of it, the decision carries the draft itself: it can be read (and answered) where it arrives.
                 const draft = draftFor(definition, stage);
@@ -447,8 +447,8 @@ export function cancelFlowCard(store, card, actor, now) {
 /** The draft a decision is about: the draft zone that sends its cards to this one. */
 export function draftFor(definition, stage) {
     return definition.stages.find(one => one.kind === "draft" && one.next === stage.id)
-        // A teammate's zone that leads here (by its next, or one of its answers) wrote the draft this decision checks (starter kits).
-        ?? definition.stages.find(one => one.kind === "teammate" && (one.next === stage.id || (one.routes ?? []).some(route => route.to === stage.id))) ?? null;
+        // A subagent's zone that leads here (by its next, or one of its answers) wrote the draft this decision checks (starter kits).
+        ?? definition.stages.find(one => one.kind === "subagent" && (one.next === stage.id || (one.routes ?? []).some(route => route.to === stage.id))) ?? null;
 }
 /** Back to a build zone with a finished result: a revision of that same work, carrying the note; null when it isn't one. */
 export function revisionWithNote(store, card, target, note, actor, repos, evidenceRoot, now) {
@@ -478,21 +478,21 @@ export function decideFlowCard(store, input, now) {
     const stage = definition.stages.find(one => one.id === card.stage);
     if (stage === undefined || stage.kind !== "approval" || (input.entry !== undefined && input.entry !== card.entry))
         return { ok: false, message: "That card has moved on since; nothing was changed." };
-    // A teammate decides only a zone it staffs; its person (and only them) can always decide instead.
+    // A subagent decides only a zone it staffs; its person (and only them) can always decide instead.
     const decider = deciderOf(stage, flow);
-    if (input.teammate !== undefined ? stage.teammate !== input.teammate : decider !== null && decider !== input.actor)
+    if (input.subagent !== undefined ? stage.subagent !== input.subagent : decider !== null && decider !== input.actor)
         return { ok: false, message: `Only ${decider ?? "an approver"} decides here.` };
-    // v102: a protected project's decisions are a person's, never an AI teammate's.
-    if (input.teammate !== undefined && store.approvalRules(flow.repo).protectProject)
+    // v102: a protected project's decisions are a person's, never a subagent's.
+    if (input.subagent !== undefined && store.approvalRules(flow.repo).protectProject)
         return { ok: false, message: "This project is protected: a person decides here." };
     // Every decision is one ledger line, the same wherever it was made; only `via` says where.
     const ledger = (outcome) => store.recordAction({ at: now.toISOString(), actor: input.actor, repo: flow.repo, taskId: card.primaryTask, runId: null,
-        action: "flow decision", outcome, source: "request", detail: `${flow.name} · card ${card.id} · ${stage.title}${input.teammate === undefined ? "" : ` · teammate ${input.teammate}`} · via ${input.where ?? "Toolroll"}` });
+        action: "flow decision", outcome, source: "request", detail: `${flow.name} · card ${card.id} · ${stage.title}${input.subagent === undefined ? "" : ` · subagent ${input.subagent}`} · via ${input.where ?? "Toolroll"}` });
     if (input.decision === "approve") {
         // An edited draft replaces the one Claude wrote, so the steps after this send what the person approved.
         const draft = draftFor(definition, stage);
-        // A person's edit over the draft limit is refused with it, never cut. (A teammate's was asked once to shorten and is kept whole.)
-        if (draft !== null && input.teammate === undefined && typeof input.draft === "string" && input.draft.trim().length > DRAFT_CHARS) {
+        // A person's edit over the draft limit is refused with it, never cut. (A subagent's was asked once to shorten and is kept whole.)
+        if (draft !== null && input.subagent === undefined && typeof input.draft === "string" && input.draft.trim().length > DRAFT_CHARS) {
             return { ok: false, message: `Keep the draft to ${DRAFT_CHARS.toLocaleString("en-US")} characters; this is ${input.draft.trim().length.toLocaleString("en-US")}.` };
         }
         if (draft !== null && typeof input.draft === "string" && input.draft.trim() !== "" && input.draft.trim() !== card.outputs[draft.id]?.trim()) {

package/dist/flow-insights.d.ts

@@ -58,7 +58,7 @@ export type StepRunInsight = {
     entry: number;
     zone: string;
     zoneTitle: string;
-    kind: "check" | "update" | "sort" | "draft" | "request" | "email" | "tool" | "teammate";
+    kind: "check" | "update" | "sort" | "draft" | "request" | "email" | "tool" | "subagent";
     script: string | null;
     version: number | null;
     state: FlowStepRunRow["state"];

package/dist/flow-share.js

@@ -24,7 +24,7 @@ import { addFlowTriggerTo, describeTrigger, HOOK_PATH, readHooksBase, triggerCon
 import { durationMinutes, durationWords, FlowContractError, flowTerms, inStepWords, LANGUAGE_WORDS, validateFlowDefinition } from "./flows.js";
 import { stageReferenceProblems } from "./contracts/stage-output.js";
 import { readVersioned } from "./contracts/contract.js";
-import { FLOW_ALIASES, FLOW_FILE_FORMAT, FLOW_FILE_VERSION, flowFileSchema, PARAMETER_ID } from "./contracts/flow.js";
+import { FLOW_ALIASES, FLOW_FILE_FORMAT, legacyFlowNeed, legacySubagentStep, FLOW_FILE_VERSION, flowFileSchema, PARAMETER_ID } from "./contracts/flow.js";
 import { parseSchedule } from "./flow-schedule.js";
 export { FLOW_FILE_FORMAT, FLOW_FILE_VERSION };
 /** The largest flow file Toolroll reads or fetches. */
@@ -38,7 +38,7 @@ function stepOf(stage, ask) {
     const step = { id: stage.id, title: stage.title, kind: stage.kind };
     const words = (minutes) => durationMinutes(durationWords(minutes)) === minutes ? durationWords(minutes) : minutes;
     // Only what the step's kind says: words a zone kept from a kind it was before stay behind.
-    if (stage.instructions !== null && (stage.kind === "task" || stage.kind === "report" || stage.kind === "draft" || stage.kind === "teammate"))
+    if (stage.instructions !== null && (stage.kind === "task" || stage.kind === "report" || stage.kind === "draft" || stage.kind === "subagent"))
         step["instructions"] = stage.instructions;
     if (stage.kind === "task")
         step["planning"] = stage.planning;
@@ -79,8 +79,8 @@ function stepOf(stage, ask) {
             ...(stage.wait.for === "hours" ? { from: stage.wait.from, until: stage.wait.to, ...(stage.wait.timeZone === undefined ? {} : { timeZone: stage.wait.timeZone }) } : { wait: words(stage.wait.minutes) }) });
     if (stage.merge !== undefined)
         step["merge"] = stage.merge;
-    if (stage.teammate !== undefined)
-        step["teammate"] = stage.teammate;
+    if (stage.subagent !== undefined)
+        step["subagent"] = stage.subagent;
     if (stage.reply === true)
         step["reply"] = true;
     // A choice's buttons; "end" ignores the card. A build in another project names a path on this computer, so it stays here.
@@ -135,8 +135,8 @@ function needsOf(definition, triggers, scripts) {
             needs.add("email");
         if (stage.tool !== undefined)
             needs.add(`tool:${stage.tool.server}`);
-        if (stage.teammate !== undefined)
-            needs.add(`teammate:${stage.teammate}`);
+        if (stage.subagent !== undefined)
+            needs.add(`subagent:${stage.subagent}`);
         for (const name of stage.secrets ?? [])
             needs.add(`secret:${name}`);
         for (const value of Object.values(stage.request?.headers ?? {}))
@@ -296,7 +296,7 @@ function stageInputOf(step, index, find) {
         ...(kind === "email" ? { email: { to: step["to"], subject: step["subject"], body: step["body"] } } : {}),
         ...(kind === "tool" ? { tool: { server: step["server"], name: step["tool"], args: typeof step["args"] === "object" && step["args"] !== null ? JSON.stringify(step["args"]) : step["args"] } } : {}),
         ...(kind === "wait" ? { wait: step["waitFor"] === "hours" ? { for: "hours", from: step["from"], to: step["until"], timeZone: step["timeZone"] } : { for: step["waitFor"] ?? "reply", minutes: minutes(step["wait"] ?? "3 days", "wait") } } : {}),
-        merge: step["merge"], teammate: step["teammate"], reply: step["reply"],
+        merge: step["merge"], subagent: step["subagent"], reply: step["reply"],
         ...(kind === "choose" ? { options: (list("options") ?? []).map((one, n) => ({ label: one["label"], to: one["goesTo"] === "end" ? "end" : find(one["goesTo"], `${at}.options[${n}].goesTo`) })) } : {}),
         ...(step["remindAfter"] === undefined ? {} : { limit: { minutes: minutes(step["remindAfter"], "remindAfter"), to: find(step["thenMoveTo"], `${at}.thenMoveTo`) } }),
         next: find(step["next"], `${at}.next`), onFail: find(fail, `${at}.${failKey}`),
@@ -371,6 +371,11 @@ export function parseFlowFile(text) {
         if (kind === "flow")
             refuse(`triggers[${index}].kind: a trigger from another flow can't come from a file; it names a flow on the installation it was made on`);
     });
+    // D5: a file written before subagents were named so (a "teammate" zone, a "teammate:" need) reads as one written since.
+    if (Array.isArray(input["zones"]))
+        input["zones"] = input["zones"].map(legacySubagentStep);
+    if (Array.isArray(input["needs"]))
+        input["needs"] = input["needs"].map(legacyFlowNeed);
     const read = readVersioned(flowFileSchema, input, {}, FLOW_ALIASES);
     if (!read.ok)
         return refuse(read.issues.map(one => one.line).join("\n"));
@@ -443,7 +448,7 @@ const NEED_WORDS = {
 };
 export function needWords(need) {
     const [kind, name] = need.includes(":") ? [need.slice(0, need.indexOf(":")), need.slice(need.indexOf(":") + 1)] : [need, ""];
-    return NEED_WORDS[need] ?? (kind === "secret" ? `A saved secret called ${name}` : kind === "tool" ? `The ${name} tool (Settings → Tools)` : kind === "teammate" ? `An AI teammate called ${name}` : kind === "script" ? `The ${name} script` : need);
+    return NEED_WORDS[need] ?? (kind === "secret" ? `A saved secret called ${name}` : kind === "tool" ? `The ${name} tool (Settings → Tools)` : kind === "subagent" ? `A subagent called ${name}` : kind === "script" ? `The ${name} script` : need);
 }
 /** The import in plain words, checked against the project it lands in. Throws FlowFileError. */
 export function planFlowImport(store, repo, file, given, actor) {

package/dist/flow-steps.d.ts

@@ -2,8 +2,8 @@ import type { Runner } from "./backend.js";
 import { type DraftRunner } from "./flow-draft.js";
 import { type MailSender, type ToolCaller } from "./flow-actions.js";
 import type { Store } from "./store.js";
-import type { TurnRunner } from "./teammates.js";
-import type { ToolLister } from "./teammate-tools.js";
+import type { TurnRunner } from "./subagents.js";
+import type { ToolLister } from "./subagent-tools.js";
 export type StepIo = {
     /** `gh` for GitHub; git and the check's shell, both without a model. */
     gh: Runner;
@@ -27,9 +27,9 @@ export type StepIo = {
     callTool?: ToolCaller;
     /** Where the project tools' secrets live (default: this computer's home). */
     toolHome?: string;
-    /** Takes a teammate's turn (default: Claude through this computer's sign-in, answering in its fixed shape). */
-    teammate?: TurnRunner;
-    /** Lists what a project tool offers a teammate (default: starts its MCP server and asks). */
+    /** Takes a subagent's turn (default: Claude through this computer's sign-in, answering in its fixed shape). */
+    subagent?: TurnRunner;
+    /** Lists what a project tool offers a subagent (default: starts its MCP server and asks). */
     listTools?: ToolLister;
 };
 export type StepPass = {

package/dist/flow-steps.js

@@ -40,14 +40,14 @@ import { agentFence } from "./agent-fence.js";
 import { readProviderKey } from "./keys.js";
 import { replyInChannel } from "./chat-inbox.js";
 import { recordSent, threadOf } from "./flow-replies.js";
-import { ASKED, teammateReady, teammateTurn } from "./teammate-work.js";
+import { ASKED, subagentReady, subagentTurn } from "./subagent-work.js";
 import { budgetHoldWords, claudeMachineBilling, monthOf } from "./spend.js";
 import { toolRefusal } from "./policy.js";
 import { pullRequestStep } from "./flow-pull-request.js";
 import { withStageHandoff } from "./contracts/stage-output.js";
 const RETRY_MS = [5 * 60_000, 15 * 60_000];
-/** A teammate's turn tries again sooner: a card waiting on a person's colleague shouldn't wait long for a hiccup. */
-const TEAMMATE_RETRY_MS = [60_000, 5 * 60_000];
+/** A subagent's turn tries again sooner: a card waiting on a person's colleague shouldn't wait long for a hiccup. */
+const SUBAGENT_RETRY_MS = [60_000, 5 * 60_000];
 const OUTPUT_CHARS = 3000;
 /** How much of a step's output its run keeps as the log. */
 const LOG_CHARS = 64_000;
@@ -71,9 +71,9 @@ export async function runFlowSteps(store, repo, now, io) {
         const stage = known.definition?.stages.find(one => one.id === card.stage);
         if (stage === undefined)
             continue;
-        // v92: a teammate's turn — a zone it handles, or a decision it staffs (a person decides when it's paused or gone).
-        if (stage.kind === "teammate" || (stage.kind === "approval" && stage.teammate !== undefined)) {
-            await teammateStep(store, known.flow, known.definition, stage, card, now, io, pass);
+        // v92: a subagent's turn — a zone it handles, or a decision it staffs (a person decides when it's paused or gone).
+        if (stage.kind === "subagent" || (stage.kind === "approval" && stage.subagent !== undefined)) {
+            await subagentStep(store, known.flow, known.definition, stage, card, now, io, pass);
             continue;
         }
         // A pull request: opened for the card's result, then CI decides where it goes (flow-pull-request.ts).
@@ -108,7 +108,7 @@ export async function runFlowSteps(store, repo, now, io) {
         // (or everything) that holds key work holds them.
         const agents = stage.kind === "sort" ? [{ provider: "openrouter", billing: "api-key" }]
             : stage.kind === "draft" ? [{ provider: "claude", billing: claudeMachineBilling(store.handle) }] : null;
-        const held = agents === null ? null : budgetGate({ project: repo, person: null, teammate: null, agents });
+        const held = agents === null ? null : budgetGate({ project: repo, person: null, subagent: null, agents });
         if (held !== null && held.over !== null) {
             const waiting = `${budgetHoldWords(held, monthOf(now).name)}. Raise it on Spend to go on.`;
             if (card.waiting !== waiting)
@@ -183,32 +183,32 @@ function claimStep(store, card, step, now) {
         return store.claimFlowStep({ card: card.id, entry: card.entry, ...step }, now);
     });
 }
-/** One teammate turn, when one is due for this card: claimed like any step, retried on failure, and waiting while its question is open. */
-async function teammateStep(store, flow, definition, stage, card, now, io, pass) {
-    // v102: on a protected project an AI teammate never decides an approval; the engine asks the person.
+/** One subagent turn, when one is due for this card: claimed like any step, retried on failure, and waiting while its question is open. */
+async function subagentStep(store, flow, definition, stage, card, now, io, pass) {
+    // v102: on a protected project a subagent never decides an approval; the engine asks the person.
     if (stage.kind === "approval" && store.approvalRules(flow.repo).protectProject)
         return true;
-    const mate = stage.teammate === undefined ? null : store.teammateByHandle(flow.repo, stage.teammate);
-    const ready = teammateReady(store, mate, now);
+    const mate = stage.subagent === undefined ? null : store.subagentByHandle(flow.repo, stage.subagent);
+    const ready = subagentReady(store, mate, now);
     if (!ready.ok) {
         // A decision goes to its person (the engine asks them). A zone only it handles waits, saying why.
         if (stage.kind === "approval")
             return true;
-        const waiting = ready.why === "gone" ? `There's no teammate called ${stage.teammate ?? "(none)"} in this project.` : `${mate.handle} is ${ready.why === "paused" ? "paused" : `waiting: ${ready.why}`}.`;
+        const waiting = ready.why === "gone" ? `There's no subagent called ${stage.subagent ?? "(none)"} in this project.` : `${mate.handle} is ${ready.why === "paused" ? "paused" : `waiting: ${ready.why}`}.`;
         if (card.waiting !== waiting)
             store.updateFlowCard(card.id, { waiting }, now);
         return true;
     }
     // Waiting on a person: its own question, or (v94) a tool call they approve first.
-    if (store.openTeammateQuestionOn(card.id, card.entry) !== null)
+    if (store.openSubagentQuestionOn(card.id, card.entry) !== null)
         return true;
-    if (!claimStep(store, card, { stage: stage.id, kind: "teammate", script: null, scriptVersion: null }, now))
+    if (!claimStep(store, card, { stage: stage.id, kind: "subagent", script: null, scriptVersion: null }, now))
         return true;
     pass.ran++;
     const started = Date.now();
     let outcome;
     try {
-        outcome = await teammateTurn(store, flow, definition, stage, card, mate, now, { ...(io.teammate === undefined ? {} : { turn: io.teammate }), ...(io.evidenceRoot === undefined ? {} : { evidenceRoot: io.evidenceRoot }),
+        outcome = await subagentTurn(store, flow, definition, stage, card, mate, now, { ...(io.subagent === undefined ? {} : { turn: io.subagent }), ...(io.evidenceRoot === undefined ? {} : { evidenceRoot: io.evidenceRoot }),
             ...(io.callTool === undefined ? {} : { callTool: io.callTool }), ...(io.listTools === undefined ? {} : { listTools: io.listTools }), ...(io.toolHome === undefined ? {} : { toolHome: io.toolHome }) });
     }
     catch (error) {
@@ -218,15 +218,15 @@ async function teammateStep(store, flow, definition, stage, card, now, io, pass)
     const kept = { log: outcome.log === undefined ? null : keptLog(outcome.log), durationMs: Date.now() - started, ...(outcome.decisionJson === undefined ? {} : { decisionJson: outcome.decisionJson }) };
     if (outcome.state === "retry") {
         const attempts = run?.attempts ?? 1;
-        if (attempts <= TEAMMATE_RETRY_MS.length) {
-            store.finishFlowStep(card.id, card.entry, { state: "waiting", result: outcome.said, nextAt: new Date(now.getTime() + TEAMMATE_RETRY_MS[attempts - 1]).toISOString(), ...kept }, now);
+        if (attempts <= SUBAGENT_RETRY_MS.length) {
+            store.finishFlowStep(card.id, card.entry, { state: "waiting", result: outcome.said, nextAt: new Date(now.getTime() + SUBAGENT_RETRY_MS[attempts - 1]).toISOString(), ...kept }, now);
             if (stage.kind !== "approval")
                 store.updateFlowCard(card.id, { waiting: `${outcome.said} Trying again in ${attempts === 1 ? "a minute" : "5 minutes"}.` }, now);
             pass.problems.push(`flow card ${card.id}: ${outcome.said}`);
             return true;
         }
         outcome = { state: "failed", said: `${outcome.said} It didn't work after three tries.` };
-        store.addTeammateEvent({ teammate: mate.id, card: card.id, entry: card.entry, kind: "failed", said: `Couldn't take its turn on “${card.title}”: ${outcome.said}` }, now);
+        store.addSubagentEvent({ subagent: mate.id, card: card.id, entry: card.entry, kind: "failed", said: `Couldn't take its turn on “${card.title}”: ${outcome.said}` }, now);
         if (stage.kind !== "approval")
             store.updateFlowCard(card.id, { waiting: outcome.said }, now);
     }

package/dist/flow-triggers.d.ts

@@ -155,7 +155,7 @@ export declare function planeStatusLink(config: TriggerConfig | null, status: st
     label: string;
     href: string;
 } | null;
-/** v96: a schedule (a teammate's routine) makes its card now, once per press, and keeps its own times. */
+/** v96: a schedule (a subagent's routine) makes its card now, once per press, and keeps its own times. */
 export declare function runScheduleNow(store: Store, trigger: FlowTriggerRow, actor: string, now: Date): {
     ok: true;
     card: number;

package/dist/flow-triggers.js

@@ -731,7 +731,7 @@ export const NEEDS_YOU_HREF = "/work?view=needs-you";
 export function planeStatusLink(config, status) {
     return config?.kind === "plane-review" && status !== null && /waited over \d+ days for you\.$/.test(status) ? { label: "Needs you", href: NEEDS_YOU_HREF } : null;
 }
-/** v96: a schedule (a teammate's routine) makes its card now, once per press, and keeps its own times. */
+/** v96: a schedule (a subagent's routine) makes its card now, once per press, and keeps its own times. */
 export function runScheduleNow(store, trigger, actor, now) {
     const config = triggerConfigOf(trigger);
     if (config?.kind !== "schedule" || config.script !== undefined)

package/dist/flows-cli.js

@@ -516,7 +516,7 @@ function zoneOf(stage, flow) {
         ...(stage.kind === 'approval' ? { decider: deciderOf(stage, flow) } : {}),
         ...(stage.script === null ? {} : { script: stage.script }),
         ...(stage.merge === undefined ? {} : { merge: stage.merge }),
-        ...(stage.teammate === undefined ? {} : { teammate: stage.teammate }),
+        ...(stage.subagent === undefined ? {} : { subagent: stage.subagent }),
         ...(stage.options === undefined ? {} : { options: stage.options.map(one => ({ label: one.label, to: one.to })) }),
         ...(stage.repo === undefined ? {} : { repo: stage.repo }),
     };

package/dist/flows-ui.js

@@ -12,9 +12,9 @@ import { itemCaption, whyLines } from "./flow-items.js";
 import { FLOW_FILE_MAX_BYTES } from "./flow-share.js";
 import { googleConnected } from "./google-mail.js";
 import { mailboxReady } from "./mailbox.js";
-import { labelOf, nameOf } from "./teammate-admin.js";
-import { callWords, receiptWords } from "./teammate-tools.js";
-import { undoFor } from "./teammate-week.js";
+import { labelOf, nameOf } from "./subagent-admin.js";
+import { callWords, receiptWords } from "./subagent-tools.js";
+import { undoFor } from "./subagent-week.js";
 import { flowCardTaskLine } from "./flow-card-task.js";
 import { readFlowSecrets } from "./flow-secrets.js";
 import { html, joinHtml, postForm } from "./html.js";
@@ -39,7 +39,7 @@ export function flowsListHtml(store, flows, projects, canCreate, problem) {
     const example = flows.length === 0 && canCreate && projects.length > 0
         ? postForm("/flows/example", html `<h2>See a flow work</h2><p class="meta">Claude drafts a reply to a sample customer question; you approve it here or in your chat app.</p>${projectField}<button>Try an example</button>`, { attrs: { class: "card flow-example" } })
         : null;
-    const intro = html `<p class="meta">A flow is your process drawn as zones. Cards move through them: agents do the work, people approve, and the team hears about it.</p>${canCreate && projects.length > 0 && html `<p class="flow-chat">Describe how work should move and your lead drafts the flow for you to confirm, or start from a template. <a href="/chat?draft=${encodeURIComponent("Make a flow for ")}">Describe it in chat</a></p>`}<p class="flow-chat">AI teammates can decide and handle cards for you, within rules you write. <a href="/teammates">Teammates</a> · or set one up with its flow in one click: <a href="/kits">Starter kits</a></p>`;
+    const intro = html `<p class="meta">A flow is your process drawn as zones. Cards move through them: agents do the work, people approve, and the team hears about it.</p>${canCreate && projects.length > 0 && html `<p class="flow-chat">Describe how work should move and your lead drafts the flow for you to confirm, or start from a template. <a href="/chat?draft=${encodeURIComponent("Make a flow for ")}">Describe it in chat</a></p>`}<p class="flow-chat">subagents can decide and handle cards for you, within rules you write. <a href="/settings/lead/subagents">Subagents</a> · or set one up with its flow in one click: <a href="/kits">Starter kits</a></p>`;
     return html `<section class="flows">${problem !== null && html `<p class="problem" role="alert">${problem}</p>`}${intro}${create}${rows.length > 0 ? rows : example ?? html `<p class="meta">No flows yet.</p>`}</section>`;
 }
 /** Reads the chosen flow file into the form (the server reads it again, whole, before anything is made). */
@@ -75,7 +75,7 @@ export function flowView(store, flow, viewer, selectedCard, setup = { dir: null,
     const title = (id) => stages.find(one => one.id === id)?.title ?? id;
     const sortZones = new Set(stages.filter(one => one.kind === "sort").map(one => one.id));
     const decisions = sortZones.size === 0 ? new Map() : store.flowSortDecisions(flow.id);
-    const mates = new Map(store.teammates([flow.repo]).map(one => [one.id, one]));
+    const mates = new Map(store.subagents([flow.repo]).map(one => [one.id, one]));
     const taskSecrets = new Map();
     const secretsFor = (repo) => {
         if (!taskSecrets.has(repo))
@@ -92,9 +92,9 @@ export function flowView(store, flow, viewer, selectedCard, setup = { dir: null,
         const discussion = store.flowComments(card.id);
         const watchers = store.flowCardWatchers(card.id);
         const decider = stage?.kind === "approval" ? deciderOf(stage, flow) : null;
-        // While its teammate is deciding (v92), the card isn't anyone else's to decide yet.
-        const teammateDeciding = stage?.teammate !== undefined && card.waiting !== null && card.waiting.endsWith(" is deciding");
-        const canDecide = viewer.approver && card.state === "active" && stage?.kind === "approval" && (decider === null || decider === viewer.name) && !teammateDeciding;
+        // While its subagent is deciding (v92), the card isn't anyone else's to decide yet.
+        const subagentDeciding = stage?.subagent !== undefined && card.waiting !== null && card.waiting.endsWith(" is deciding");
+        const canDecide = viewer.approver && card.state === "active" && stage?.kind === "approval" && (decider === null || decider === viewer.name) && !subagentDeciding;
         // History reads moves and ownership together, newest first.
         const owned = discussion.filter(one => one.kind === "owner").map(one => ({ text: one.body === "" ? `${one.author} left it without an owner` : one.body === one.author ? `${one.author} took it on` : `${one.author} made ${one.body} the owner`, at: one.at }));
         const moves = store.flowEvents(card.id).map(event => ({ text: historyText(event, title, sortZones), at: event.at }));
@@ -109,15 +109,15 @@ export function flowView(store, flow, viewer, selectedCard, setup = { dir: null,
             label: stage.wait !== undefined && stage.wait.for !== "hours" ? (stage.wait.for === "reply" ? "No reply by" : "Moves on at") : stage.limit.to !== null ? `Moves to ${title(stage.limit.to)} at` : "Reminder at",
         };
         // Its open question: one of its own, or (v94) a tool call waiting for approval.
-        const asked = card.state === "active" ? store.openTeammateQuestionOn(card.id, card.entry) : null;
-        const pending = asked?.toolCall == null ? null : store.teammateCall(asked.toolCall);
-        // A decision its teammate handed over carries what the teammate said (v92).
-        const turn = card.state === "active" && stage?.kind === "approval" && stage.teammate !== undefined ? store.flowStepRun(card.id, card.entry) : null;
+        const asked = card.state === "active" ? store.openSubagentQuestionOn(card.id, card.entry) : null;
+        const pending = asked?.toolCall == null ? null : store.subagentCall(asked.toolCall);
+        // A decision its subagent handed over carries what the subagent said (v92).
+        const turn = card.state === "active" && stage?.kind === "approval" && stage.subagent !== undefined ? store.flowStepRun(card.id, card.entry) : null;
         let handoff = null;
-        if (turn !== null && turn.kind === "teammate" && turn.state === "passed") {
+        if (turn !== null && turn.kind === "subagent" && turn.state === "passed") {
             try {
                 const said = JSON.parse(turn.decisionJson ?? "{}");
-                const mate = store.teammateByHandle(flow.repo, stage.teammate);
+                const mate = store.subagentByHandle(flow.repo, stage.subagent);
                 if (said.action === "hand_off" && typeof said.note === "string" && said.note !== "" && mate !== null)
                     handoff = { from: labelOf(mate), note: said.note };
             }
@@ -125,7 +125,7 @@ export function flowView(store, flow, viewer, selectedCard, setup = { dir: null,
                 handoff = null;
             }
         }
-        const asker = asked === null || asked.state !== "open" ? null : store.getTeammate(asked.teammate);
+        const asker = asked === null || asked.state !== "open" ? null : store.getSubagent(asked.subagent);
         // "Person chooses" (flow-send.ts): what was sent, and the options, for the person it waits on; the latest send otherwise.
         const choosing = card.state === "active" && stage?.kind === "choose" ? flowChoiceAt(store, card.id, card.entry) : null;
         const latest = store.flowSends(card.id)[0] ?? null;
@@ -162,11 +162,11 @@ export function flowView(store, flow, viewer, selectedCard, setup = { dir: null,
             question: asked === null || asked.state !== "open" || asker === null ? null
                 : { id: asked.id, from: labelOf(asker), question: asked.question, options: asked.options, askedOf: asked.askedOf, mine: asked.askedOf === viewer.name,
                     call: pending === null ? null : { why: pending.why, rule: pending.result ?? "" } },
-            calls: store.teammateCallsOn(card.id).slice(-30).map(call => {
-                const mate = mates.get(call.teammate) ?? null;
+            calls: store.subagentCallsOn(card.id).slice(-30).map(call => {
+                const mate = mates.get(call.subagent) ?? null;
                 // A person's undo (v97) reads as theirs, and its outcome says what it undid.
-                return { id: call.id, who: call.undoOf !== null ? call.decidedBy ?? "A person" : mate === null ? "A teammate" : nameOf(mate), words: callWords(call.tool, call.action, call.input, 400), state: call.state, outcome: receiptWords(store, call),
-                    why: call.undoOf !== null ? "" : call.why, result: call.state === "asked" ? null : call.result, at: call.createdAt, teammate: call.teammate, undo: viewer.approver ? undoFor(store, call) : null };
+                return { id: call.id, who: call.undoOf !== null ? call.decidedBy ?? "A person" : mate === null ? "A subagent" : nameOf(mate), words: callWords(call.tool, call.action, call.input, 400), state: call.state, outcome: receiptWords(store, call),
+                    why: call.undoOf !== null ? "" : call.why, result: call.state === "asked" ? null : call.result, at: call.createdAt, subagent: call.subagent, undo: viewer.approver ? undoFor(store, call) : null };
             }),
         };
     });
@@ -197,7 +197,7 @@ export function flowView(store, flow, viewer, selectedCard, setup = { dir: null,
         startTrigger: setup.startTrigger ?? null,
         me: viewer.name,
         sortReady: setup.sortReady ?? false,
-        teammates: store.teammates([flow.repo]).map(mate => ({ handle: mate.handle, label: labelOf(mate), name: nameOf(mate), working: mate.state === "active", href: `/teammates/${mate.id}` })),
+        subagents: store.subagents([flow.repo]).map(mate => ({ handle: mate.handle, label: labelOf(mate), name: nameOf(mate), working: mate.state === "active", href: `/settings/lead/subagents/${mate.id}` })),
         emailReady: sendingReady(setup.dir),
         requestSecrets: flowSecretNames(setup.dir, flow.repo),
         tools: projectToolsOf(store, flow.repo).map(tool => ({ name: tool.name, about: tool.spec.about, functions: tool.lastTest?.ok === true ? tool.lastTest.tools : [],

package/dist/flows.js

@@ -52,7 +52,7 @@ import { createHash } from "node:crypto";
 import { projectName } from "./project.js";
 import { parseContract, readVersioned } from "./contracts/contract.js";
 import { stageReferenceProblems } from "./contracts/stage-output.js";
-import { CHOICES_MAX, CHOICES_MIN, FLOW_ALIASES, FLOW_COLORS, FLOW_DEFINITION_VERSION, FLOW_END, FLOW_MERGE_METHODS, FLOW_STAGE_KINDS, flowDefinitionSchema, flowStepsSchema, HEADERS_MAX, LONGEST_WAIT_MINUTES, savedFlowDefinitionSchema, SCRIPT_LANGUAGES, SCRIPT_NAME, sortKeyOf, SURE_AT_MAX, SURE_AT_MIN, ZONE_ID, } from "./contracts/flow.js";
+import { CHOICES_MAX, CHOICES_MIN, FLOW_ALIASES, FLOW_COLORS, FLOW_DEFINITION_VERSION, FLOW_END, FLOW_MERGE_METHODS, FLOW_STAGE_KINDS, flowDefinitionSchema, flowStepsSchema, HEADERS_MAX, legacySubagentStep, LONGEST_WAIT_MINUTES, savedFlowDefinitionSchema, SCRIPT_LANGUAGES, SCRIPT_NAME, sortKeyOf, SURE_AT_MAX, SURE_AT_MIN, ZONE_ID, } from "./contracts/flow.js";
 export { CHOICES_MAX, CHOICES_MIN, FLOW_COLORS, FLOW_END, FLOW_MERGE_METHODS, FLOW_STAGE_KINDS, LONGEST_WAIT_MINUTES, SCRIPT_LANGUAGES, SCRIPT_NAME, sortKeyOf };
 /** What each kind is called and does, in the words the canvas uses. */
 export const FLOW_KIND_WORDS = {
@@ -70,7 +70,7 @@ export const FLOW_KIND_WORDS = {
     draft: { label: "Draft", about: "Claude writes a reply, summary or note from the card in seconds. Nothing is sent until a later step sends it." },
     sort: { label: "Sort", about: "Jev reads the card in under a second and sends it where its answer leads. Cards it isn't sure about take the not-sure path." },
     wait: { label: "Wait", about: "Waits for a reply to the card's email, or for a set time. A reply moves the card on; if none comes in time, it takes the no-reply path." },
-    teammate: { label: "Teammate handles it", about: "An AI teammate reads the card, decides where it goes within its rules, and writes what the next zones send. When its rules say to ask, it asks you first." },
+    subagent: { label: "Subagent handles it", about: "A subagent reads the card, decides where it goes within its rules, and writes what the next zones send. When its rules say to ask, it asks you first." },
     send: { label: "Send to me", about: "Sends the card's owner what the step before produced: its summary, links and any screenshots, in each chat app they use and on the card. Then moves on." },
     choose: { label: "Person chooses", about: "Sends the card's owner what was done with 2 to 4 buttons you name, in their chat apps and here. Each leads to a zone or ignores the card; a reply instead goes where replies go, as the note." },
     done: { label: "Done", about: "The end of the flow." },
@@ -170,7 +170,7 @@ function canonicalSort(input) {
         sureAt, notes,
     };
 }
-/** A script's or teammate's answers as every release has kept them: trimmed, none left out. */
+/** A script's or subagent's answers as every release has kept them: trimmed, none left out. */
 function canonicalRoutes(input) {
     if (!given(input))
         return undefined;
@@ -200,7 +200,7 @@ function canonicalWait(input) {
 function canonicalStage(input, index) {
     if (!isRecord(input))
         return input;
-    const stage = input;
+    const stage = legacySubagentStep(input);
     const kind = stage["kind"];
     const zone = isRecord(stage["zone"]) ? stage["zone"] : {};
     const planning = stage["planning"] === "required" || stage["planning"] === "skip" || stage["planning"] === "auto" ? stage["planning"] : null;
@@ -231,9 +231,9 @@ function canonicalStage(input, index) {
         ...(kind === "wait" ? { wait: canonicalWait(stage["wait"]) } : {}),
         // true is a squash, the default; false or none is no merge.
         ...(kind === "pull-request" && given(stage["merge"]) && stage["merge"] !== false ? { merge: stage["merge"] === true ? "squash" : stage["merge"] } : {}),
-        ...((kind === "approval" || kind === "teammate") && given(stage["teammate"]) && stage["teammate"] !== "" ? { teammate: stage["teammate"] } : {}),
-        ...(kind === "teammate" && routes !== undefined ? { routes } : {}),
-        ...(kind === "teammate" && stage["reply"] === true ? { reply: true } : {}),
+        ...((kind === "approval" || kind === "subagent") && given(stage["subagent"]) && stage["subagent"] !== "" ? { subagent: stage["subagent"] } : {}),
+        ...(kind === "subagent" && routes !== undefined ? { routes } : {}),
+        ...(kind === "subagent" && stage["reply"] === true ? { reply: true } : {}),
         ...(kind === "choose" ? { options: Array.isArray(stage["options"]) ? stage["options"].map(one => { const row = isRecord(one) ? one : {}; return { label: said(row["label"]), to: said(row["to"]) }; }) : given(stage["options"]) ? stage["options"] : [] } : {}),
         ...(kind === "task" && given(stage["repo"]) && stage["repo"] !== "" ? { repo: said(stage["repo"]) } : {}),
         ...(limit === undefined ? {} : { limit }),
@@ -565,7 +565,7 @@ function fillOne(key, stage, card) {
         return stage === undefined ? "" : card.outputs[stage] ?? "";
     }
 }
-const KIND_COLORS = { inbox: "slate", task: "blue", report: "violet", approval: "amber", check: "blue", "pull-request": "blue", update: "green", notify: "green", sort: "violet", draft: "violet", request: "blue", email: "green", tool: "blue", wait: "slate", teammate: "violet", send: "green", choose: "amber", done: "green" };
+const KIND_COLORS = { inbox: "slate", task: "blue", report: "violet", approval: "amber", check: "blue", "pull-request": "blue", update: "green", notify: "green", sort: "violet", draft: "violet", request: "blue", email: "green", tool: "blue", wait: "slate", subagent: "violet", send: "green", choose: "amber", done: "green" };
 /** A step id as the lead may write it (sort_by_hand, Sort-By-Hand) in the one form zones use. */
 const idOf = (value) => value.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 32);
 const slugOf = (title) => title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 28) || "zone";
@@ -632,7 +632,7 @@ export function withKeptSteps(steps, previous) {
 }
 /** A flow's steps, read by their one schema: `steps[0].routes[0]: unknown key 'to' (did you mean goesTo?)`. */
 export function readFlowSteps(input, previous = null) {
-    const read = parseContract(flowStepsSchema, { steps: withKeptSteps(input, previous) }, FLOW_ALIASES);
+    const read = parseContract(flowStepsSchema, { steps: withKeptSteps(Array.isArray(input) ? input.map(legacySubagentStep) : input, previous) }, FLOW_ALIASES);
     return read.ok ? { ok: true, value: read.value.steps } : read;
 }
 /**
@@ -707,7 +707,7 @@ export function flowFromSteps(input, previous = null) {
             id, title, kind,
             zone: old?.zone ?? { x: 0, y: 0, w: 260, h: kind === "done" || kind === "notify" || kind === "send" ? 220 : 300, color: KIND_COLORS[kind] },
             // A kept step on our default instructions gets the default again, so it reads any research step added before it.
-            instructions: kind === "teammate" ? step.instructions?.trim() || old?.instructions || "Read the card and decide what happens next."
+            instructions: kind === "subagent" ? step.instructions?.trim() || old?.instructions || "Read the card and decide what happens next."
                 : kind === "draft" ? step.instructions?.trim() || old?.instructions || DRAFT_DEFAULT
                     : kind === "task" || kind === "report"
                         ? step.instructions?.trim() || (old?.instructions && old.instructions !== defaultInstructions(kind, previous.stages.slice(0, previous.stages.indexOf(old))) ? old.instructions : defaultInstructions(kind, earlier))
@@ -731,10 +731,10 @@ export function flowFromSteps(input, previous = null) {
             ...(kind === "tool" ? { tool: { server: step.server ?? old?.tool?.server ?? "", name: step.tool ?? old?.tool?.name ?? "", args: typeof step.args === "string" ? step.args : step.args !== undefined ? JSON.stringify(step.args) : old?.tool?.args ?? "{}" } } : {}),
             ...(kind === "wait" ? { wait: waitFromStep(step, old?.wait ?? null, at) } : {}),
             ...(kind === "pull-request" && (step.merge === undefined ? old?.merge !== undefined : step.merge !== false) ? { merge: step.merge === undefined || step.merge === true || step.merge === false ? old?.merge ?? "squash" : step.merge } : {}),
-            // v92: "nobody" (or "none") takes a teammate off an approval step.
-            ...((kind === "approval" || kind === "teammate") && (step.teammate === undefined ? old?.teammate !== undefined : !/^(nobody|none|no one)$/i.test(step.teammate.trim())) ? { teammate: idOf(step.teammate ?? old.teammate) } : {}),
-            ...(kind === "teammate" ? step.routes !== undefined ? routesOf(step.routes) : old?.routes === undefined ? {} : { routes: old.routes } : {}),
-            ...(kind === "teammate" && (step.reply ?? old?.reply) === true ? { reply: true } : {}),
+            // v92: "nobody" (or "none") takes a subagent off an approval step.
+            ...((kind === "approval" || kind === "subagent") && (step.subagent === undefined ? old?.subagent !== undefined : !/^(nobody|none|no one)$/i.test(step.subagent.trim())) ? { subagent: idOf(step.subagent ?? old.subagent) } : {}),
+            ...(kind === "subagent" ? step.routes !== undefined ? routesOf(step.routes) : old?.routes === undefined ? {} : { routes: old.routes } : {}),
+            ...(kind === "subagent" && (step.reply ?? old?.reply) === true ? { reply: true } : {}),
             ...(kind === "choose" ? { options: choicesFromStep(step, old?.options ?? null, at, find) } : {}),
             ...(kind === "task" && (step.repo ?? old?.repo) !== undefined && (step.repo ?? old?.repo).trim() !== "" ? { repo: (step.repo ?? old?.repo).trim() } : {}),
             ...(() => {
@@ -882,9 +882,9 @@ export function flowTerms(definition, previous) {
         else if (stage.kind === "tool" && stage.tool !== undefined)
             lines.push(`Uses ${stage.tool.server} → ${stage.tool.name} with ${plain(stage.tool.args).slice(0, 400)}`, `Then → ${to(stage.next)}${stage.onFail === null ? " If it fails → waits there." : ` If it fails → ${to(stage.onFail)}`}`);
         else if (stage.kind === "approval")
-            lines.push(`Decides: ${stage.teammate !== undefined ? `the AI teammate ${stage.teammate}, within its rules, handing hard ones to ${stage.toOwner === true ? "the flow's owner" : stage.approver ?? "anyone who approves"}` : stage.toOwner === true ? "the flow's owner, in their chat app" : stage.approver ?? "anyone who approves on this project"}. Approve → ${to(stage.next)} Send back → ${stage.onFail === null ? "not possible." : to(stage.onFail)}`);
-        else if (stage.kind === "teammate")
-            lines.push(`The AI teammate ${stage.teammate ?? "(none)"} handles it${stage.instructions === null ? "" : `: ${plain(stage.instructions)}`}`, ...(stage.routes === undefined || stage.routes.length === 0 ? [`Then → ${to(stage.next)}`] : stage.routes.map(one => `${one.answer} → ${to(one.to)}`)), `It asks the flow's owner when its rules say to.${stage.reply === true ? " It sends what it writes back to whoever asked." : ""}${stage.onFail === null ? "" : ` If it can't → ${to(stage.onFail)}`}`);
+            lines.push(`Decides: ${stage.subagent !== undefined ? `the subagent ${stage.subagent}, within its rules, handing hard ones to ${stage.toOwner === true ? "the flow's owner" : stage.approver ?? "anyone who approves"}` : stage.toOwner === true ? "the flow's owner, in their chat app" : stage.approver ?? "anyone who approves on this project"}. Approve → ${to(stage.next)} Send back → ${stage.onFail === null ? "not possible." : to(stage.onFail)}`);
+        else if (stage.kind === "subagent")
+            lines.push(`The subagent ${stage.subagent ?? "(none)"} handles it${stage.instructions === null ? "" : `: ${plain(stage.instructions)}`}`, ...(stage.routes === undefined || stage.routes.length === 0 ? [`Then → ${to(stage.next)}`] : stage.routes.map(one => `${one.answer} → ${to(one.to)}`)), `It asks the flow's owner when its rules say to.${stage.reply === true ? " It sends what it writes back to whoever asked." : ""}${stage.onFail === null ? "" : ` If it can't → ${to(stage.onFail)}`}`);
         else if (stage.kind === "notify")
             lines.push(`Posts: ${plain(stage.message ?? "")}`, `Then → ${to(stage.next)}`);
         else if (stage.kind === "send")
@@ -945,8 +945,8 @@ export function flowTerms(definition, previous) {
         terms.push("Draft steps send each card's text to Claude through the lead chat's sign-in. Nothing a draft writes is sent until a later step sends it.");
     if (definition.stages.some(one => one.kind === "task" && one.repo !== undefined))
         terms.push("A build step in another project files its task there, only when the flow's owner may file work in that project.");
-    if (definition.stages.some(one => one.teammate !== undefined))
-        terms.push("AI teammates decide and act within their soul files' rules, reading each card through Claude on this computer's sign-in; they never approve code tasks or merges.");
+    if (definition.stages.some(one => one.subagent !== undefined))
+        terms.push("subagents decide and act within their soul files' rules, reading each card through Claude on this computer's sign-in; they never approve code tasks or merges.");
     return terms;
 }
 const zone = (x, y, color, h = 300) => ({ x, y, w: 260, h, color });