toolroll 0.9.55 → 0.9.56

package/dist/contracts/flow.js

@@ -16,7 +16,7 @@
 import { z } from "zod";
 import { TEXT_LIMITS } from "../text-limits.js";
 import { limited, toModelSchema, versioned } from "./contract.js";
-export const FLOW_STAGE_KINDS = ["inbox", "task", "report", "approval", "check", "pull-request", "update", "notify", "sort", "draft", "request", "email", "tool", "wait", "teammate", "send", "choose", "done"];
+export const FLOW_STAGE_KINDS = ["inbox", "task", "report", "approval", "check", "pull-request", "update", "notify", "sort", "draft", "request", "email", "tool", "wait", "subagent", "send", "choose", "done"];
 export const FLOW_COLORS = ["slate", "blue", "violet", "amber", "green", "rose"];
 /** How a Pull request zone merges once checks pass. */
 export const FLOW_MERGE_METHODS = ["squash", "merge", "rebase"];
@@ -105,7 +105,7 @@ export const flowWaitSchema = z.strictObject({
 });
 /** A choose zone's option: its button's words, and the zone it leads to (FLOW_END closes the card as Ignored). */
 export const flowChoiceSchema = z.strictObject({ label: words("label", "flowChoice").min(1), to: z.union([stageRef, z.literal(FLOW_END)]) });
-/** A script's or teammate's answer and the zone it leads to. */
+/** A script's or subagent's answer and the zone it leads to. */
 export const flowRouteSchema = z.strictObject({ answer: z.string().min(1).max(TEXT_LIMITS.flowAnswer).regex(/^[^\n]*$/, { error: "must be one line" }), to: stageRef });
 /** A time limit on a zone: after this long, the person it waits on is reminded; a Holding, "Person decides" or "Person
  * chooses" zone can also move the card on (`to`). */
@@ -127,7 +127,7 @@ function zoneSchemas(instructions) {
         z.strictObject({ id, title, kind: z.literal("inbox"), zone, instructions: said, planning: nil, approver: nil, message: message.nullable(), close: nil, script: nil, sort: nil, limit: move, next, onFail }),
         z.strictObject({ id, title, kind: z.literal("task"), zone, instructions: text, planning: z.enum(FLOW_PLANNING), approver: nil, message: message.nullable(), close: nil, script: nil, sort: nil, repo: words("repo", "flowRepo").min(1).optional(), limit: remind, next, onFail }),
         z.strictObject({ id, title, kind: z.literal("report"), zone, instructions: text, planning: nil, approver: nil, message: message.nullable(), close: nil, script: nil, sort: nil, limit: remind, next, onFail }),
-        z.strictObject({ id, title, kind: z.literal("approval"), zone, instructions: said, planning: nil, approver: words("approver", "flowDecider").min(1).nullable(), toOwner: z.literal(true).optional(), message: message.nullable(), close: nil, script: nil, sort: nil, teammate: zoneId.optional(), limit: move, next, onFail }),
+        z.strictObject({ id, title, kind: z.literal("approval"), zone, instructions: said, planning: nil, approver: words("approver", "flowDecider").min(1).nullable(), toOwner: z.literal(true).optional(), message: message.nullable(), close: nil, script: nil, sort: nil, subagent: zoneId.optional(), limit: move, next, onFail }),
         z.strictObject({ id, title, kind: z.literal("check"), zone, instructions: said, planning: nil, approver: nil, message: message.nullable(), close: nil, script: scriptName, runIn: z.enum(FLOW_RUN_IN).optional(), routes, secrets: z.array(secretName).min(1).max(SECRETS_MAX).optional(), sort: nil, limit: remind, next, onFail }),
         z.strictObject({ id, title, kind: z.literal("pull-request"), zone, instructions: said, planning: nil, approver: nil, message: message.nullable(), close: nil, script: nil, sort: nil, merge: z.enum(FLOW_MERGE_METHODS).optional(), limit: remind, next, onFail }),
         z.strictObject({ id, title, kind: z.literal("update"), zone, instructions: said, planning: nil, approver: nil, message: message.nullable(), close: z.boolean(), script: nil, sort: nil, limit: remind, next, onFail }),
@@ -138,7 +138,7 @@ function zoneSchemas(instructions) {
         z.strictObject({ id, title, kind: z.literal("email"), zone, instructions: said, planning: nil, approver: nil, message: message.nullable(), close: nil, script: nil, sort: nil, email: flowEmailSchema, limit: remind, next, onFail }),
         z.strictObject({ id, title, kind: z.literal("tool"), zone, instructions: said, planning: nil, approver: nil, message: message.nullable(), close: nil, script: nil, sort: nil, tool: flowToolSchema, limit: remind, next, onFail }),
         z.strictObject({ id, title, kind: z.literal("wait"), zone, instructions: said, planning: nil, approver: nil, message: message.nullable(), close: nil, script: nil, sort: nil, wait: flowWaitSchema, next, onFail }),
-        z.strictObject({ id, title, kind: z.literal("teammate"), zone, instructions: said, planning: nil, approver: nil, message: message.nullable(), close: nil, script: nil, sort: nil, teammate: zoneId, routes, reply: z.literal(true).optional(), limit: remind, next, onFail }),
+        z.strictObject({ id, title, kind: z.literal("subagent"), zone, instructions: said, planning: nil, approver: nil, message: message.nullable(), close: nil, script: nil, sort: nil, subagent: zoneId, routes, reply: z.literal(true).optional(), limit: remind, next, onFail }),
         z.strictObject({ id, title, kind: z.literal("send"), zone, instructions: said, planning: nil, approver: nil, message: message.nullable(), close: nil, script: nil, sort: nil, limit: remind, next, onFail }),
         z.strictObject({ id, title, kind: z.literal("choose"), zone, instructions: said, planning: nil, approver: nil, message: message.nullable(), close: nil, script: nil, sort: nil, options: z.array(flowChoiceSchema).min(CHOICES_MIN).max(CHOICES_MAX), limit: move, next: nil, onFail }),
         z.strictObject({ id, title, kind: z.literal("done"), zone, instructions: said, planning: nil, approver: nil, message: message.nullable(), close: nil, script: nil, sort: nil, next: nil, onFail: nil }),
@@ -210,8 +210,8 @@ const STEP_FIELDS = {
     /** Like "2 days" ("none" removes it), or minutes. */
     remindAfter: duration,
     thenMoveTo: ref,
-    /** A teammate's short name; "nobody" takes one off. */
-    teammate: z.string().min(1).max(TEXT_LIMITS.flowTeammate),
+    /** A subagent's short name; "nobody" takes one off. */
+    subagent: z.string().min(1).max(TEXT_LIMITS.flowSubagent),
     reply: z.boolean(),
     options: z.array(flowStepOptionSchema).min(CHOICES_MIN).max(CHOICES_MAX),
     ifReplied: ref,
@@ -229,7 +229,7 @@ const STEP_KINDS = {
     inbox: ["next", "ifFails", "remindAfter", "thenMoveTo"],
     task: ["instructions", "planning", "repo", "next", "ifFails", "remindAfter"],
     report: ["instructions", "next", "ifFails", "remindAfter"],
-    approval: ["decider", "teammate", "next", "ifFails", "remindAfter", "thenMoveTo"],
+    approval: ["decider", "subagent", "next", "ifFails", "remindAfter", "thenMoveTo"],
     check: ["script", "runIn", "routes", "secrets", "next", "ifFails", "remindAfter"],
     "pull-request": ["merge", "next", "ifFails", "remindAfter"],
     update: ["message", "close", "next", "ifFails", "remindAfter"],
@@ -240,7 +240,7 @@ const STEP_KINDS = {
     email: ["to", "subject", "body", "next", "ifFails", "remindAfter"],
     tool: ["server", "tool", "args", "next", "ifFails", "remindAfter"],
     wait: ["waitFor", "wait", "from", "until", "timeZone", "next", "ifNoReply"],
-    teammate: ["teammate", "instructions", "routes", "reply", "next", "ifFails", "remindAfter"],
+    subagent: ["subagent", "instructions", "routes", "reply", "next", "ifFails", "remindAfter"],
     send: ["next", "ifFails", "remindAfter"],
     choose: ["options", "ifReplied", "remindAfter", "ifNoReply", "thenMoveTo"],
     done: [],
@@ -255,9 +255,9 @@ const stepOf = (kind) => z.strictObject({
 const STEPS = {
     inbox: stepOf("inbox"), task: stepOf("task"), report: stepOf("report"), approval: stepOf("approval"), check: stepOf("check"), "pull-request": stepOf("pull-request"),
     update: stepOf("update"), notify: stepOf("notify"), sort: stepOf("sort"), draft: stepOf("draft"), request: stepOf("request"), email: stepOf("email"),
-    tool: stepOf("tool"), wait: stepOf("wait"), teammate: stepOf("teammate"), send: stepOf("send"), choose: stepOf("choose"), done: stepOf("done"),
+    tool: stepOf("tool"), wait: stepOf("wait"), subagent: stepOf("subagent"), send: stepOf("send"), choose: stepOf("choose"), done: stepOf("done"),
 };
-const stepList = [STEPS.inbox, STEPS.task, STEPS.report, STEPS.approval, STEPS.check, STEPS["pull-request"], STEPS.update, STEPS.notify, STEPS.sort, STEPS.draft, STEPS.request, STEPS.email, STEPS.tool, STEPS.wait, STEPS.teammate, STEPS.send, STEPS.choose, STEPS.done];
+const stepList = [STEPS.inbox, STEPS.task, STEPS.report, STEPS.approval, STEPS.check, STEPS["pull-request"], STEPS.update, STEPS.notify, STEPS.sort, STEPS.draft, STEPS.request, STEPS.email, STEPS.tool, STEPS.wait, STEPS.subagent, STEPS.send, STEPS.choose, STEPS.done];
 /** A step as the lead, `toolroll flows create/edit`, starters, kits and the gallery describe it, one schema per kind. */
 export const flowStepSchema = z.discriminatedUnion("kind", stepList);
 /** A flow's steps, in order: what `flowFromSteps` reads. */
@@ -269,8 +269,23 @@ const fileZone = (step) => step.extend({ id: zoneId, at: fileAt.optional() });
 export const flowFileZoneSchema = z.discriminatedUnion("kind", [
     fileZone(STEPS.inbox), fileZone(STEPS.task), fileZone(STEPS.report), fileZone(STEPS.approval), fileZone(STEPS.check), fileZone(STEPS["pull-request"]),
     fileZone(STEPS.update), fileZone(STEPS.notify), fileZone(STEPS.sort), fileZone(STEPS.draft), fileZone(STEPS.request), fileZone(STEPS.email),
-    fileZone(STEPS.tool), fileZone(STEPS.wait), fileZone(STEPS.teammate), fileZone(STEPS.send), fileZone(STEPS.choose), fileZone(STEPS.done),
+    fileZone(STEPS.tool), fileZone(STEPS.wait), fileZone(STEPS.subagent), fileZone(STEPS.send), fileZone(STEPS.choose), fileZone(STEPS.done),
 ]);
+/**
+ * D5 (schema v117): a subagent step was a "teammate" step, naming its "teammate", and a flow file's needs said
+ * "teammate:<handle>". Saved drawings, step lists and flow files from before still read: the old words mean the new ones.
+ */
+export function legacySubagentStep(step) {
+    if (step === null || typeof step !== "object" || Array.isArray(step))
+        return step;
+    const row = step;
+    if (row["kind"] !== "teammate" && !Object.hasOwn(row, "teammate"))
+        return step;
+    const { teammate, ...rest } = row;
+    return { ...rest, ...(rest["kind"] === "teammate" ? { kind: "subagent" } : {}), ...(teammate !== undefined && rest["subagent"] === undefined ? { subagent: teammate } : {}) };
+}
+/** A flow file's need as it was written before D5 ("teammate:maya"), in today's words. */
+export const legacyFlowNeed = (need) => typeof need === "string" && need.startsWith("teammate:") ? `subagent:${need.slice(9)}` : need;
 /** The keys people and models write for the ones a step means: refusals suggest them (contract.ts). */
 export const FLOW_ALIASES = {
     aliases: {
@@ -370,7 +385,7 @@ export const flowFileSchema = versioned(FLOW_FILE_VERSION, {
     format: z.literal(FLOW_FILE_FORMAT),
     name: visible("name", "flowName").min(1),
     about: visible("about", "flowFileAbout").optional().describe("One line on what the flow does. Untrusted: shown in the import preview."),
-    needs: z.array(visible("need", "flowFileNeed").min(1)).max(40).optional().describe("What the flow needs to run: github, linear, openrouter, email, tool:<server>, secret:<NAME>, teammate:<handle>, script:<name>."),
+    needs: z.array(visible("need", "flowFileNeed").min(1)).max(40).optional().describe("What the flow needs to run: github, linear, openrouter, email, tool:<server>, secret:<NAME>, subagent:<handle>, script:<name>."),
     parameters: z.array(flowFileParameterSchema).max(20).optional(),
     zones: z.array(flowFileZoneSchema).min(1).max(FLOW_ZONES_MAX).describe("The zones in order; the first is where cards start."),
     triggers: z.array(flowFileTriggerSchema).max(10).optional(),

package/dist/contracts/lead-context.d.ts

@@ -64,7 +64,7 @@ export declare const leadContextSchema: z.ZodObject<{
     aboutYou: z.ZodArray<z.ZodString>;
     people: z.ZodObject<{
         people: z.ZodArray<z.ZodString>;
-        teammates: z.ZodArray<z.ZodString>;
+        subagents: z.ZodArray<z.ZodString>;
         teams: z.ZodArray<z.ZodString>;
     }, z.core.$strict>;
     channel: z.ZodNullable<z.ZodObject<{

package/dist/contracts/lead-context.js

@@ -36,8 +36,8 @@ export const leadContextSchema = z.strictObject({
     you: z.strictObject({ firstName: z.string().nullable(), timeZone: z.string(), today: z.string() }),
     /** Lines the person confirmed about themselves. */
     aboutYou: z.array(z.string()),
-    /** The people, AI teammates and team chats the lead works with, one line each. */
-    people: z.strictObject({ people: z.array(z.string()), teammates: z.array(z.string()), teams: z.array(z.string()) }),
+    /** The people, subagents and team chats the lead works with, one line each. */
+    people: z.strictObject({ people: z.array(z.string()), subagents: z.array(z.string()), teams: z.array(z.string()) }),
     channel: z.strictObject({ id: z.enum(LEAD_CHANNELS), fit: z.string(), replyLimit: z.int().nullable() }).nullable(),
     needsYou: z.array(leadTaskSchema),
     /** This conversation's follow-through; absent outside one. */

package/dist/contracts/lead-tools.d.ts

@@ -219,7 +219,7 @@ export declare const LEAD_TOOL_INPUTS: {
             ifFails: z.ZodOptional<z.ZodString>;
             next: z.ZodOptional<z.ZodString>;
             remindAfter: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodInt]>>;
-            teammate: z.ZodOptional<z.ZodString>;
+            subagent: z.ZodOptional<z.ZodString>;
             thenMoveTo: z.ZodOptional<z.ZodString>;
         }, z.core.$strict>, z.ZodObject<{
             id: z.ZodOptional<z.ZodString>;
@@ -352,7 +352,7 @@ export declare const LEAD_TOOL_INPUTS: {
         }, z.core.$strict>, z.ZodObject<{
             id: z.ZodOptional<z.ZodString>;
             title: z.ZodString;
-            kind: z.ZodLiteral<"teammate">;
+            kind: z.ZodLiteral<"subagent">;
             ifFails: z.ZodOptional<z.ZodString>;
             instructions: z.ZodOptional<z.ZodString>;
             next: z.ZodOptional<z.ZodString>;
@@ -362,7 +362,7 @@ export declare const LEAD_TOOL_INPUTS: {
                 answer: z.ZodString;
                 goesTo: z.ZodString;
             }, z.core.$strict>>>;
-            teammate: z.ZodOptional<z.ZodString>;
+            subagent: z.ZodOptional<z.ZodString>;
         }, z.core.$strict>, z.ZodObject<{
             id: z.ZodOptional<z.ZodString>;
             title: z.ZodString;
@@ -458,14 +458,15 @@ export declare const LEAD_TOOL_INPUTS: {
             timeZone: z.ZodOptional<z.ZodString>;
         }, z.core.$strict>], "kind">>;
     }, z.core.$strict>;
-    readonly get_teammates: z.ZodObject<{
+    readonly get_subagents: z.ZodObject<{
         repo: z.ZodOptional<z.ZodString>;
-        teammate: z.ZodOptional<z.ZodInt>;
+        subagent: z.ZodOptional<z.ZodInt>;
     }, z.core.$strict>;
-    readonly propose_teammate: z.ZodObject<{
+    readonly propose_subagent: z.ZodObject<{
         operation: z.ZodEnum<{
             add_routine: "add_routine";
             answer: "answer";
+            ask: "ask";
             create: "create";
             edit_memory: "edit_memory";
             edit_section: "edit_section";
@@ -497,7 +498,7 @@ export declare const LEAD_TOOL_INPUTS: {
         limitField: z.ZodOptional<z.ZodString>;
         limitOver: z.ZodOptional<z.ZodNumber>;
         repo: z.ZodOptional<z.ZodString>;
-        teammate: z.ZodOptional<z.ZodInt>;
+        subagent: z.ZodOptional<z.ZodInt>;
         template: z.ZodOptional<z.ZodEnum<{
             [x: string]: string;
         }>>;
@@ -907,7 +908,7 @@ export declare const LEAD_TOOL_READ_INPUTS: {
             ifFails: z.ZodOptional<z.ZodString>;
             next: z.ZodOptional<z.ZodString>;
             remindAfter: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodInt]>>;
-            teammate: z.ZodOptional<z.ZodString>;
+            subagent: z.ZodOptional<z.ZodString>;
             thenMoveTo: z.ZodOptional<z.ZodString>;
         }, z.core.$strict>, z.ZodObject<{
             id: z.ZodOptional<z.ZodString>;
@@ -1040,7 +1041,7 @@ export declare const LEAD_TOOL_READ_INPUTS: {
         }, z.core.$strict>, z.ZodObject<{
             id: z.ZodOptional<z.ZodString>;
             title: z.ZodString;
-            kind: z.ZodLiteral<"teammate">;
+            kind: z.ZodLiteral<"subagent">;
             ifFails: z.ZodOptional<z.ZodString>;
             instructions: z.ZodOptional<z.ZodString>;
             next: z.ZodOptional<z.ZodString>;
@@ -1050,7 +1051,7 @@ export declare const LEAD_TOOL_READ_INPUTS: {
                 answer: z.ZodString;
                 goesTo: z.ZodString;
             }, z.core.$strict>>>;
-            teammate: z.ZodOptional<z.ZodString>;
+            subagent: z.ZodOptional<z.ZodString>;
         }, z.core.$strict>, z.ZodObject<{
             id: z.ZodOptional<z.ZodString>;
             title: z.ZodString;
@@ -1146,14 +1147,15 @@ export declare const LEAD_TOOL_READ_INPUTS: {
             timeZone: z.ZodOptional<z.ZodString>;
         }, z.core.$strict>], "kind">>;
     }, z.core.$strict>;
-    readonly get_teammates: z.ZodObject<{
+    readonly get_subagents: z.ZodObject<{
         repo: z.ZodOptional<z.ZodString>;
-        teammate: z.ZodOptional<z.ZodInt>;
+        subagent: z.ZodOptional<z.ZodInt>;
     }, z.core.$strict>;
-    readonly propose_teammate: z.ZodObject<{
+    readonly propose_subagent: z.ZodObject<{
         operation: z.ZodEnum<{
             add_routine: "add_routine";
             answer: "answer";
+            ask: "ask";
             create: "create";
             edit_memory: "edit_memory";
             edit_section: "edit_section";
@@ -1185,7 +1187,7 @@ export declare const LEAD_TOOL_READ_INPUTS: {
         limitField: z.ZodOptional<z.ZodString>;
         limitOver: z.ZodOptional<z.ZodNumber>;
         repo: z.ZodOptional<z.ZodString>;
-        teammate: z.ZodOptional<z.ZodInt>;
+        subagent: z.ZodOptional<z.ZodInt>;
         template: z.ZodOptional<z.ZodEnum<{
             [x: string]: string;
         }>>;
@@ -1656,9 +1658,9 @@ export declare const LEAD_TOOL_OUTPUTS: {
         awaiting: z.ZodString;
         executed: z.ZodLiteral<false>;
     }, z.core.$loose>;
-    readonly get_teammates: z.ZodObject<{
-        teammates: z.ZodArray<z.ZodObject<{
-            teammate: z.ZodNumber;
+    readonly get_subagents: z.ZodObject<{
+        subagents: z.ZodArray<z.ZodObject<{
+            subagent: z.ZodNumber;
             name: z.ZodString;
             working: z.ZodBoolean;
             soul: z.ZodString;
@@ -1666,7 +1668,7 @@ export declare const LEAD_TOOL_OUTPUTS: {
         templates: z.ZodArray<z.ZodUnknown>;
         rule: z.ZodString;
     }, z.core.$loose>;
-    readonly propose_teammate: z.ZodObject<{
+    readonly propose_subagent: z.ZodObject<{
         proposal: z.ZodNumber;
         label: z.ZodString;
         awaiting: z.ZodString;

package/dist/contracts/lead-tools.js

@@ -18,7 +18,7 @@ import { CHECK_RESULTS, RUN_OUTCOMES, TASK_STATES } from "../lead-commitments.js
 import { PERSON_ID } from "../lead-people.js";
 import { TASK_SIZES } from "../phase-routing.js";
 import { ACCEPTANCE_LIMITS } from "../scope.js";
-import { TEAMMATE_TEMPLATES } from "../teammates.js";
+import { SUBAGENT_TEMPLATES } from "../subagents.js";
 import { TEXT_LIMITS } from "../text-limits.js";
 import { parseContract } from "./contract.js";
 import { FLOW_ALIASES } from "./flow.js";
@@ -48,8 +48,8 @@ export const acceptance = z.array(acceptanceCriterionSchema).min(1).max(ACCEPTAN
 const note = z.string().max(LIMITS.note, { error: issue => overBy(LIMITS.note, issue.input) }).describe(`At most ${LIMITS.note} characters; longer is refused with its length, not cut.`);
 /** Task states a list filters by. */
 export const LISTED_TASK_STATES = ["queued", "running", "done", "failed", "cancelled"];
-/** The shared actions the lead proposes with propose_action; flows and teammates have their own tools. */
-const ACTION_OPERATIONS = Object.keys(CHAT_ACTIONS).filter(one => !one.startsWith("flow_") && !one.startsWith("teammate_"));
+/** The shared actions the lead proposes with propose_action; flows and subagents have their own tools. */
+const ACTION_OPERATIONS = Object.keys(CHAT_ACTIONS).filter(one => !one.startsWith("flow_") && !one.startsWith("subagent_"));
 export const LEAD_TOOL_INPUTS = {
     get_brief: z.strictObject({ repo: repoId.optional() }),
     get_project_context: z.strictObject({ repo: repoId, query: text("contextQuery").min(1), mode: z.enum(["search", "impact"]).optional() }),
@@ -84,15 +84,15 @@ export const LEAD_TOOL_INPUTS = {
     get_flows: z.strictObject({ repo: repoId.optional(), flow: id.optional(), card: id.optional() }),
     // The flow contract's own schema (src/contracts/flow-propose.ts), never a second one here.
     propose_flow: proposeFlowInputSchema,
-    get_teammates: z.strictObject({ repo: repoId.optional(), teammate: id.optional() }),
-    propose_teammate: z.strictObject({
-        operation: z.enum(["create", "edit_section", "edit_soul", "pause", "resume", "remove", "note", "answer", "use_tool", "stop_tool", "tool_rule", "forget", "edit_memory", "add_routine", "stop_routine", "undo"]),
-        section: text("teammateSection").optional(), schedule: text("teammateSchedule").optional(), routine: id.optional(), memory: id.optional(),
-        tool: text("teammateTool").optional(), action: text("teammateAction").optional(), undoWith: text("teammateAction").optional(), call: id.optional(),
-        use: z.enum(["free", "ask", "never"]).optional(), limitField: text("teammateAction").optional(), limitOver: z.number().min(0).optional(),
-        repo: repoId.optional(), teammate: id.optional(), template: enumOf(TEAMMATE_TEMPLATES.map(one => one.id)).optional(),
-        name: text("teammateName").optional(), soul: text("teammateSoul").optional(), note: text("teammateNote").optional(),
-        question: id.optional(), choice: text("teammateChoice").optional(), text: text("teammateText").optional(),
+    get_subagents: z.strictObject({ repo: repoId.optional(), subagent: id.optional() }),
+    propose_subagent: z.strictObject({
+        operation: z.enum(["ask", "create", "edit_section", "edit_soul", "pause", "resume", "remove", "note", "answer", "use_tool", "stop_tool", "tool_rule", "forget", "edit_memory", "add_routine", "stop_routine", "undo"]),
+        section: text("subagentSection").optional(), schedule: text("subagentSchedule").optional(), routine: id.optional(), memory: id.optional(),
+        tool: text("subagentTool").optional(), action: text("subagentAction").optional(), undoWith: text("subagentAction").optional(), call: id.optional(),
+        use: z.enum(["free", "ask", "never"]).optional(), limitField: text("subagentAction").optional(), limitOver: z.number().min(0).optional(),
+        repo: repoId.optional(), subagent: id.optional(), template: enumOf(SUBAGENT_TEMPLATES.map(one => one.id)).optional(),
+        name: text("subagentName").optional(), soul: text("subagentSoul").optional(), note: text("subagentNote").optional(),
+        question: id.optional(), choice: text("subagentChoice").optional(), text: text("subagentText").optional(),
     }),
     get_flow_insights: z.strictObject({ repo: repoId.optional(), flow: id.optional(), days: z.int().min(1).max(90).optional(), card: id.optional(), entry: id.optional() }),
     get_skills: z.strictObject({ repo: repoId, version: z.string().regex(/^[a-f0-9]{20}$/).optional(), offset: offset.optional() }),
@@ -165,7 +165,7 @@ const int = z.number().int();
 const list = z.array(z.unknown());
 const nullable = (schema) => schema.nullable();
 const rows = (shape) => z.array(z.looseObject(shape));
-/** A proposal drafted as a card the operator confirms (propose_action, propose_flow, propose_teammate). */
+/** A proposal drafted as a card the operator confirms (propose_action, propose_flow, propose_subagent). */
 const cardDrafted = z.looseObject({ proposal: int, label: str, awaiting: str, executed: z.literal(false) });
 /** A proposal row drafted by one of the queue, hold, scope and answer tools. */
 const proposed = (kind, shape = {}) => z.looseObject({ proposal: int, kind: z.literal(kind), awaiting: str, ...shape });
@@ -211,8 +211,8 @@ export const LEAD_TOOL_OUTPUTS = {
         z.looseObject({ flows: rows({ flow: int, name: str, cards: int, needYou: int, triggers: int }), templates: list, scripts: list, rule: str }),
     ]),
     propose_flow: cardDrafted,
-    get_teammates: z.looseObject({ teammates: rows({ teammate: int, name: str, working: z.boolean(), soul: str }), templates: list, rule: str }),
-    propose_teammate: cardDrafted,
+    get_subagents: z.looseObject({ subagents: rows({ subagent: int, name: str, working: z.boolean(), soul: str }), templates: list, rule: str }),
+    propose_subagent: cardDrafted,
     get_flow_insights: z.union([
         z.looseObject({ days: int, flows: rows({ flow: int, name: str }) }),
         z.looseObject({ card: int, entry: int, state: str, log: str }),

package/dist/contracts/stage-output.d.ts

@@ -68,7 +68,7 @@ export declare const STAGE_HANDOFFS: {
     readonly wait: z.ZodObject<{
         text: z.ZodString;
     }, z.core.$strict>;
-    readonly teammate: z.ZodObject<{
+    readonly subagent: z.ZodObject<{
         text: z.ZodString;
     }, z.core.$strict>;
     readonly send: z.ZodObject<{

package/dist/contracts/stage-output.js

@@ -29,7 +29,7 @@ const words = stageHandoffSchema.pick({ text: true });
  */
 export const STAGE_HANDOFFS = {
     inbox: null, task: words, report: stageHandoffSchema, approval: null, check: words, "pull-request": words, update: words, notify: null,
-    sort: words, draft: words, request: words, email: words, tool: words, wait: words, teammate: words, send: words, choose: null, done: null,
+    sort: words, draft: words, request: words, email: words, tool: words, wait: words, subagent: words, send: words, choose: null, done: null,
 };
 /** The extra `{{stage.<id>.<field>}}` fields a zone kind hands on. */
 export function stageFieldsOf(kind) {

package/dist/contracts/store-json.d.ts

@@ -13,7 +13,7 @@
  */
 import { z } from "zod";
 import { type ContractIssue } from "./contract.js";
-/** A teammate's rule for one tool action, as `teammates.ts` writes it. */
+/** A subagent's rule for one tool action, as `subagents.ts` writes it. */
 export declare const savedToolRuleSchema: z.ZodObject<{
     use: z.ZodEnum<{
         ask: "ask";
@@ -42,7 +42,7 @@ export declare const savedDecisionOptionSchema: z.ZodObject<{
 }, z.core.$loose>;
 declare const STORE_COLUMN_VALUES: {
     readonly "run_check.suites_json": z.ZodArray<z.ZodUnknown>;
-    readonly "teammate_suggestion.rule_json": z.ZodObject<{
+    readonly "subagent_suggestion.rule_json": z.ZodObject<{
         use: z.ZodEnum<{
             ask: "ask";
             free: "free";
@@ -54,7 +54,7 @@ declare const STORE_COLUMN_VALUES: {
         }, z.core.$loose>>;
         undo: z.ZodOptional<z.ZodString>;
     }, z.core.$loose>;
-    readonly "teammate_suggestion.was_json": z.ZodObject<{
+    readonly "subagent_suggestion.was_json": z.ZodObject<{
         use: z.ZodEnum<{
             ask: "ask";
             free: "free";
@@ -66,15 +66,15 @@ declare const STORE_COLUMN_VALUES: {
         }, z.core.$loose>>;
         undo: z.ZodOptional<z.ZodString>;
     }, z.core.$loose>;
-    readonly "teammate_suggestion.evidence_json": z.ZodArray<z.ZodNumber>;
-    readonly "teammate_call.input_json": z.ZodObject<{}, z.core.$loose>;
-    readonly "teammate_tool.actions_json": z.ZodArray<z.ZodObject<{
+    readonly "subagent_suggestion.evidence_json": z.ZodArray<z.ZodNumber>;
+    readonly "subagent_call.input_json": z.ZodObject<{}, z.core.$loose>;
+    readonly "subagent_tool.actions_json": z.ZodArray<z.ZodObject<{
         name: z.ZodString;
         about: z.ZodString;
         input: z.ZodNullable<z.ZodObject<{}, z.core.$loose>>;
         readOnly: z.ZodBoolean;
     }, z.core.$loose>>;
-    readonly "teammate_tool.rules_json": z.ZodObject<{}, z.core.$catchall<z.ZodObject<{
+    readonly "subagent_tool.rules_json": z.ZodObject<{}, z.core.$catchall<z.ZodObject<{
         use: z.ZodEnum<{
             ask: "ask";
             free: "free";
@@ -86,11 +86,11 @@ declare const STORE_COLUMN_VALUES: {
         }, z.core.$loose>>;
         undo: z.ZodOptional<z.ZodString>;
     }, z.core.$loose>>>;
-    readonly "teammate_question.options_json": z.ZodArray<z.ZodObject<{
+    readonly "subagent_question.options_json": z.ZodArray<z.ZodObject<{
         id: z.ZodString;
         label: z.ZodString;
     }, z.core.$loose>>;
-    readonly "teammate_event.detail_json": z.ZodObject<{}, z.core.$loose>;
+    readonly "subagent_event.detail_json": z.ZodObject<{}, z.core.$loose>;
     readonly "flow_card.source_json": z.ZodObject<{
         label: z.ZodString;
     }, z.core.$loose>;
@@ -138,7 +138,7 @@ declare const STORE_COLUMN_VALUES: {
         method: z.ZodString;
         paths: z.ZodNumber;
     }, z.core.$loose>;
-    readonly "mate_ask.options_json": z.ZodArray<z.ZodString>;
+    readonly "lead_ask.options_json": z.ZodArray<z.ZodString>;
     readonly "lead_config.about_json": z.ZodArray<z.ZodUnknown>;
     readonly "mutation.result": z.ZodUnknown;
     readonly "plan_revision.changed_fields": z.ZodArray<z.ZodString>;
@@ -163,7 +163,7 @@ declare const STORE_COLUMN_VALUES: {
     readonly "task_ref.capability_requirements": z.ZodArray<z.ZodUnknown>;
     readonly "coordinator_proposal.payload_json": z.ZodObject<{}, z.core.$loose>;
     readonly "coordinator_proposal.outcome_json": z.ZodObject<{}, z.core.$loose>;
-    readonly "mate_proposal.payload_json": z.ZodUnion<readonly [z.ZodObject<{
+    readonly "lead_proposal.payload_json": z.ZodUnion<readonly [z.ZodObject<{
         version: z.ZodLiteral<1>;
         operation: z.ZodEnum<{
             decision_record: "decision_record";
@@ -198,17 +198,18 @@ declare const STORE_COLUMN_VALUES: {
             skill_import: "skill_import";
             skill_restore: "skill_restore";
             skill_test: "skill_test";
+            subagent_answer: "subagent_answer";
+            subagent_ask: "subagent_ask";
+            subagent_create: "subagent_create";
+            subagent_memory: "subagent_memory";
+            subagent_note: "subagent_note";
+            subagent_routine: "subagent_routine";
+            subagent_soul: "subagent_soul";
+            subagent_state: "subagent_state";
+            subagent_tools: "subagent_tools";
+            subagent_undo: "subagent_undo";
             task_cancel: "task_cancel";
             task_resume: "task_resume";
-            teammate_answer: "teammate_answer";
-            teammate_create: "teammate_create";
-            teammate_memory: "teammate_memory";
-            teammate_note: "teammate_note";
-            teammate_routine: "teammate_routine";
-            teammate_soul: "teammate_soul";
-            teammate_state: "teammate_state";
-            teammate_tools: "teammate_tools";
-            teammate_undo: "teammate_undo";
             tool_add: "tool_add";
             tool_remove: "tool_remove";
         }>;
@@ -219,7 +220,7 @@ declare const STORE_COLUMN_VALUES: {
         stamp: z.ZodString;
         state: z.ZodObject<{}, z.core.$catchall<z.ZodUnknown>>;
     }, z.core.$strict>, z.ZodObject<{}, z.core.$loose>]>;
-    readonly "mate_proposal.outcome_json": z.ZodObject<{}, z.core.$loose>;
+    readonly "lead_proposal.outcome_json": z.ZodObject<{}, z.core.$loose>;
     readonly "proof_verdict.matrix_json": z.ZodArray<z.ZodObject<{
         id: z.ZodString;
         statement: z.ZodString;
@@ -250,7 +251,7 @@ declare const STORE_COLUMN_VALUES: {
 export type StoreColumn = keyof typeof STORE_COLUMN_VALUES;
 export type StoreColumnValue<C extends StoreColumn> = z.infer<(typeof STORE_COLUMN_VALUES)[C]>;
 /** Every JSON column the store reads itself, by `table.column`. */
-export declare const STORE_COLUMNS: ("approval_policy.protected_paths" | "backend_grant.mutations" | "backend_grant.paths" | "coordinator_proposal.outcome_json" | "coordinator_proposal.payload_json" | "criterion_review.screenshots_json" | "decision.options" | "flow_card.source_json" | "flow_comment.mentions_json" | "lead_config.about_json" | "mate_ask.options_json" | "mate_proposal.outcome_json" | "mate_proposal.payload_json" | "mutation.result" | "operating_mode.terms_json" | "plan_revision.changed_fields" | "proof_verdict.matrix_json" | "proof_verdict.reasons_json" | "publication_grant.capabilities" | "repair_chain.unresolved_json" | "run_check.suites_json" | "run_checkpoint.snapshot_json" | "run_tool.tools_json" | "runner.agents" | "runner.repos" | "task_ref.capability_requirements" | "task_ref.zones" | "task_scope.acceptance_json" | "task_scope.touches" | "teammate_call.input_json" | "teammate_event.detail_json" | "teammate_question.options_json" | "teammate_suggestion.evidence_json" | "teammate_suggestion.rule_json" | "teammate_suggestion.was_json" | "teammate_tool.actions_json" | "teammate_tool.rules_json" | "tool_seal.tools_json")[];
+export declare const STORE_COLUMNS: ("approval_policy.protected_paths" | "backend_grant.mutations" | "backend_grant.paths" | "coordinator_proposal.outcome_json" | "coordinator_proposal.payload_json" | "criterion_review.screenshots_json" | "decision.options" | "flow_card.source_json" | "flow_comment.mentions_json" | "lead_ask.options_json" | "lead_config.about_json" | "lead_proposal.outcome_json" | "lead_proposal.payload_json" | "mutation.result" | "operating_mode.terms_json" | "plan_revision.changed_fields" | "proof_verdict.matrix_json" | "proof_verdict.reasons_json" | "publication_grant.capabilities" | "repair_chain.unresolved_json" | "run_check.suites_json" | "run_checkpoint.snapshot_json" | "run_tool.tools_json" | "runner.agents" | "runner.repos" | "subagent_call.input_json" | "subagent_event.detail_json" | "subagent_question.options_json" | "subagent_suggestion.evidence_json" | "subagent_suggestion.rule_json" | "subagent_suggestion.was_json" | "subagent_tool.actions_json" | "subagent_tool.rules_json" | "task_ref.capability_requirements" | "task_ref.zones" | "task_scope.acceptance_json" | "task_scope.touches" | "tool_seal.tools_json")[];
 /** A SQL projection, not a physical column; replay it separately after its owning column. */
 export declare const STORE_PROJECTIONS: readonly ["run_tool.tools_json.fence"];
 /** These readers historically only parsed JSON. Shape errors must not change their values or catch boundaries. */

package/dist/contracts/store-json.js

@@ -23,7 +23,7 @@ const savedObject = z.looseObject({});
 const savedList = z.array(z.unknown());
 /** An object with a text `label`: a card's source (its reader keeps picking the fields it knows). */
 const cardSource = z.looseObject({ label: z.string() });
-/** A teammate's rule for one tool action, as `teammates.ts` writes it. */
+/** A subagent's rule for one tool action, as `subagents.ts` writes it. */
 export const savedToolRuleSchema = z.looseObject({
     use: z.enum(["free", "ask", "never"]),
     limit: z.looseObject({ field: z.string(), over: z.number() }).optional(),
@@ -59,14 +59,14 @@ const savedMatrixRowSchema = proofCriterionSchema.pick({ id: true, statement: tr
 }).loose();
 const STORE_COLUMN_VALUES = {
     "run_check.suites_json": savedList,
-    "teammate_suggestion.rule_json": savedToolRuleSchema,
-    "teammate_suggestion.was_json": savedToolRuleSchema,
-    "teammate_suggestion.evidence_json": z.array(z.number()),
-    "teammate_call.input_json": savedObject,
-    "teammate_tool.actions_json": z.array(savedToolActionSchema),
-    "teammate_tool.rules_json": z.object({}).catchall(savedToolRuleSchema),
-    "teammate_question.options_json": z.array(savedQuestionOptionSchema),
-    "teammate_event.detail_json": savedObject,
+    "subagent_suggestion.rule_json": savedToolRuleSchema,
+    "subagent_suggestion.was_json": savedToolRuleSchema,
+    "subagent_suggestion.evidence_json": z.array(z.number()),
+    "subagent_call.input_json": savedObject,
+    "subagent_tool.actions_json": z.array(savedToolActionSchema),
+    "subagent_tool.rules_json": z.object({}).catchall(savedToolRuleSchema),
+    "subagent_question.options_json": z.array(savedQuestionOptionSchema),
+    "subagent_event.detail_json": savedObject,
     "flow_card.source_json": cardSource,
     "flow_comment.mentions_json": savedList,
     "task_scope.touches": z.lazy(() => scopeTermsSchema.unwrap().shape.touches.unwrap()),
@@ -81,7 +81,7 @@ const STORE_COLUMN_VALUES = {
     "run_tool.tools_json": savedToolsSchema,
     /** `json_extract(tools_json, '$.fence')`: the fence an attempt ran with. */
     "run_tool.tools_json.fence": savedFenceSchema,
-    "mate_ask.options_json": z.array(z.string()),
+    "lead_ask.options_json": z.array(z.string()),
     "lead_config.about_json": savedList,
     "mutation.result": z.unknown(),
     "plan_revision.changed_fields": z.array(z.string()),
@@ -92,8 +92,8 @@ const STORE_COLUMN_VALUES = {
     "coordinator_proposal.payload_json": savedObject,
     "coordinator_proposal.outcome_json": savedObject,
     // Other proposal kinds have operation-specific fields; the action variant already has a canonical contract.
-    "mate_proposal.payload_json": z.union([sharedActionSchema, savedObject]),
-    "mate_proposal.outcome_json": savedObject,
+    "lead_proposal.payload_json": z.union([sharedActionSchema, savedObject]),
+    "lead_proposal.outcome_json": savedObject,
     "proof_verdict.matrix_json": z.array(savedMatrixRowSchema),
     "proof_verdict.reasons_json": savedList,
     "criterion_review.screenshots_json": savedList,
@@ -107,14 +107,14 @@ export const STORE_COLUMNS = Object.keys(STORE_COLUMN_VALUES).filter(column => c
 export const STORE_PROJECTIONS = ["run_tool.tools_json.fence"];
 /** These readers historically only parsed JSON. Shape errors must not change their values or catch boundaries. */
 export const LEGACY_JSON_COLUMNS = [
-    "teammate_suggestion.rule_json", "teammate_suggestion.was_json", "teammate_suggestion.evidence_json",
-    "teammate_call.input_json", "teammate_tool.actions_json", "teammate_tool.rules_json", "teammate_question.options_json",
-    "teammate_event.detail_json", "task_scope.touches", "task_scope.acceptance_json",
+    "subagent_suggestion.rule_json", "subagent_suggestion.was_json", "subagent_suggestion.evidence_json",
+    "subagent_call.input_json", "subagent_tool.actions_json", "subagent_tool.rules_json", "subagent_question.options_json",
+    "subagent_event.detail_json", "task_scope.touches", "task_scope.acceptance_json",
     "operating_mode.terms_json", "decision.options", "run_tool.tools_json",
-    "run_tool.tools_json.fence", "mate_ask.options_json", "mutation.result", "plan_revision.changed_fields",
+    "run_tool.tools_json.fence", "lead_ask.options_json", "mutation.result", "plan_revision.changed_fields",
     "run_checkpoint.snapshot_json", "publication_grant.capabilities",
     "coordinator_proposal.payload_json", "coordinator_proposal.outcome_json",
-    "mate_proposal.payload_json", "mate_proposal.outcome_json",
+    "lead_proposal.payload_json", "lead_proposal.outcome_json",
 ];
 /** One column's versioned envelope: `{ version: 1, value }`, built in memory around the saved bare value. */
 export function storeColumnSchema(column) {

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

@@ -1,22 +1,22 @@
 /**
- * A teammate's turn (teammates.ts): one schema for the JSON Schema Claude answers in (`--json-schema`) and the reader
+ * A subagent's turn (subagents.ts): one schema for the JSON Schema Claude answers in (`--json-schema`) and the reader
  * that takes the answer back. One flat object with every field (a root union is refused by the API); fields a turn
  * does not use are "" (or [] for options).
  *
  * The text limits (TURN_LIMITS, from TEXT_LIMITS) are deliberately not in the schema: the CLI refuses an answer a few
  * characters over one whole, so they are checked after parsing and an answer over one is asked once to shorten
- * (teammate-work.ts), then kept whole. What the zone allows — which actions, which answers, a note for a send-back, a
+ * (subagent-work.ts), then kept whole. What the zone allows — which actions, which answers, a note for a send-back, a
  * question for an ask, a tool for a tool call — is checked after parsing too (`readTurn`), by path.
  *
  * A turn is kept as the step's decision (`flow_step_run.decision_json`) as it was read, so a saved one is this shape.
  */
 import { z } from "zod";
 import { type ContractResult } from "./contract.js";
-/** What a teammate may do on one turn. A decision zone: approve, send back, or hand it to a person. A work zone: pick
+/** What a subagent may do on one turn. A decision zone: approve, send back, or hand it to a person. A work zone: pick
  * where it goes, ask its person, or say it can't. v94: "use_tool" asks for one tool call. */
 export declare const TURN_ACTIONS: readonly ["approve", "send_back", "hand_off", "route", "ask", "cant", "use_tool"];
 export type TurnAction = (typeof TURN_ACTIONS)[number];
-export declare const teammateTurnSchema: z.ZodObject<{
+export declare const subagentTurnSchema: z.ZodObject<{
     action: z.ZodEnum<{
         approve: "approve";
         ask: "ask";
@@ -36,7 +36,7 @@ export declare const teammateTurnSchema: z.ZodObject<{
     input: z.ZodString;
     remember: z.ZodString;
 }, z.core.$strip>;
-export type TurnAnswer = z.infer<typeof teammateTurnSchema>;
+export type TurnAnswer = z.infer<typeof subagentTurnSchema>;
 /** What Claude's `--json-schema` is for a turn: the turn schema, exactly. */
 export declare const TURN_MODEL_SCHEMA: Readonly<Record<string, unknown>>;
 /** Older and plain-text turns default absent or non-text fields to "", and keep only string options. */