catui-agent 1.0.0-beta.0

package/dist/extensions/builtin/team/team-mailbox.d.ts

@@ -0,0 +1,50 @@
+/**
+ * [WHO]: TeamMailbox, MailboxMessage, MailboxMessageType, MailboxDirection
+ * [FROM]: No external deps
+ * [TO]: Consumed by team-runtime.ts, index.ts
+ * [HERE]: extensions/builtin/team/team-mailbox.ts - Phase B B.3 mailbox protocol
+ *
+ * Per refactor plan §B.3: mailbox is the single channel between the leader
+ * and teammates; no direct callbacks are allowed. The implementation is a
+ * typed append-only log with subscribe() for live observers and JSONL-backed
+ * replay across restarts.
+ */
+export type MailboxMessageType = "task_request" | "task_progress" | "task_result" | "permission_request" | "permission_response" | "plan_approval_request" | "plan_approval_response" | "teammate_message" | "handoff" | "task_claim" | "task_update" | "mode_change" | "shutdown_request" | "shutdown_ack";
+export type MailboxDirection = "leader_to_teammate" | "teammate_to_leader" | "teammate_to_teammate";
+export interface MailboxMessage {
+    id: string;
+    teammateId: string;
+    teammateName: string;
+    targetTeammateId?: string;
+    targetTeammateName?: string;
+    type: MailboxMessageType;
+    direction: MailboxDirection;
+    payload: Record<string, unknown>;
+    timestamp: number;
+}
+export type MailboxListener = (message: MailboxMessage) => void;
+/**
+ * Append-only typed mailbox shared by all teammates. Bounded by
+ * `maxMessages` to prevent unbounded growth in long-lived sessions; oldest
+ * messages drop first.
+ */
+export declare class TeamMailbox {
+    private messages;
+    private listeners;
+    private readonly maxMessages;
+    private readonly filePath?;
+    constructor(maxMessages?: number, filePath?: string);
+    /** Load persisted JSONL messages. Corrupt lines are ignored. */
+    load(): Promise<void>;
+    /** Post a new message and notify listeners. */
+    post(message: Omit<MailboxMessage, "id" | "timestamp">): MailboxMessage;
+    /** All messages, optionally filtered by teammate id. */
+    list(teammateId?: string): MailboxMessage[];
+    /** Subscribe to live mailbox events. Returns an unsubscribe handle. */
+    subscribe(listener: MailboxListener): () => void;
+    /** Drop all messages owned by a teammate (called on terminate). */
+    clearTeammate(teammateId: string): void;
+    private persist;
+    /** Remove persisted mailbox data. Intended for tests and full team reset flows. */
+    clearAll(): Promise<void>;
+}

package/dist/extensions/builtin/team/team-mailbox.js

@@ -0,0 +1,4 @@
+var h=Object.defineProperty;var r=(a,s)=>h(a,"name",{value:s,configurable:!0});import{mkdir as n,readFile as l,rm as m,writeFile as c}from"node:fs/promises";import{dirname as o}from"node:path";class d{static{r(this,"TeamMailbox")}messages=[];listeners=new Set;maxMessages;filePath;constructor(s=1e3,t){this.maxMessages=s,this.filePath=t}async load(){if(this.filePath)try{const s=await l(this.filePath,"utf-8"),t=[];for(const e of s.split(`
+`))if(e.trim())try{const i=JSON.parse(e);i?.id&&i?.type&&t.push(i)}catch{}this.messages=t.slice(-this.maxMessages)}catch{this.messages=[]}}post(s){const t={...s,id:crypto.randomUUID(),timestamp:Date.now()};this.messages.push(t),this.messages.length>this.maxMessages&&this.messages.splice(0,this.messages.length-this.maxMessages),this.persist();for(const e of this.listeners)try{e(t)}catch{}return t}list(s){return s?this.messages.filter(t=>t.teammateId===s||t.targetTeammateId===s):[...this.messages]}subscribe(s){return this.listeners.add(s),()=>this.listeners.delete(s)}clearTeammate(s){this.messages=this.messages.filter(t=>t.teammateId!==s&&t.targetTeammateId!==s),this.persist()}async persist(){if(this.filePath)try{await n(o(this.filePath),{recursive:!0});const s=this.messages.map(t=>JSON.stringify(t)).join(`
+`);await c(this.filePath,s?`${s}
+`:"","utf-8")}catch{}}async clearAll(){this.messages=[],this.filePath&&await m(this.filePath,{force:!0}).catch(()=>{})}}export{d as TeamMailbox};

package/dist/extensions/builtin/team/team-orchestrator.d.ts

@@ -0,0 +1,39 @@
+/**
+ * [WHO]: Provides createTeamUtterance(), buildLeaderPlan(), parseTeamMentions(), runLeaderOrchestration()
+ * [FROM]: Depends on ./team-types, ./team-presets, ./team-runtime
+ * [TO]: Consumed by index.ts for structured speaker-stream rendering and leader-led team orchestration
+ * [HERE]: extensions/builtin/team/team-orchestrator.ts - leader planning, mention parsing, and handoff execution
+ */
+import type { Model } from "@catui/ai/types";
+import type { TeamRuntime, TeamRuntimeEvent } from "./team-runtime.js";
+import type { Handoff, LeaderPlan, PersistedTeammate, TeamMention, TeamSpeakerRole, TeamUtterance } from "./team-types.js";
+export interface TeamStreamEmitter {
+    emitUtterance(utterance: TeamUtterance, options?: {
+        streamKey?: string;
+        replace?: boolean;
+    }): void;
+}
+export interface LeaderOrchestrationOptions extends TeamStreamEmitter {
+    taskDescription: string;
+    baseCwd: string;
+    model?: Model<any>;
+    onRuntimeEvent?: (event: TeamRuntimeEvent) => void;
+    completeSimple?: (systemPrompt: string, userMessage: string) => Promise<string | undefined>;
+}
+export interface LeaderOrchestrationResult {
+    plan: LeaderPlan;
+    handoffs: Handoff[];
+}
+export declare function createTeamUtterance(input: {
+    speakerId: string;
+    speakerLabel: string;
+    role: TeamSpeakerRole;
+    text: string;
+    kind: TeamUtterance["kind"];
+    mentions?: TeamMention[];
+    timestamp?: number;
+}): TeamUtterance;
+export declare function formatUtteranceForContext(utterance: TeamUtterance): string;
+export declare function parseTeamMentions(text: string, teammates: PersistedTeammate[]): TeamMention[];
+export declare function buildLeaderPlan(userGoal: string, teammates: PersistedTeammate[], completeSimple?: (systemPrompt: string, userMessage: string) => Promise<string | undefined>): Promise<LeaderPlan>;
+export declare function runLeaderOrchestration(runtime: TeamRuntime, options: LeaderOrchestrationOptions): Promise<LeaderOrchestrationResult>;

package/dist/extensions/builtin/team/team-orchestrator.js

@@ -0,0 +1,5 @@
+var S=Object.defineProperty;var c=(e,t)=>S(e,"name",{value:t,configurable:!0});import{executePreset as C,selectAutoTeamPlan as T}from"./team-presets.js";const x="leader",U="catui";function I(e){return{id:crypto.randomUUID(),speakerId:e.speakerId,speakerLabel:e.speakerLabel,role:e.role,text:e.text.trim(),kind:e.kind,mentions:e.mentions??[],timestamp:e.timestamp??Date.now()}}c(I,"createTeamUtterance");function V(e){return`${e.speakerLabel}: ${e.text}`}c(V,"formatUtteranceForContext");function M(e,t){const n=[],a=/(^|\s)@([A-Za-z][A-Za-z0-9-]*)/g;for(const i of e.matchAll(a)){const r=i[2];if(!r)continue;const d=_(r,t);if(!d)continue;const o=(i.index??0)+i[1].length+r.length+1,u=j(e,o);u&&n.push({raw:`@${r}`,targetId:d.identity.id,targetName:d.identity.name,targetLabel:d.identity.label,task:u})}return B(n)}c(M,"parseTeamMentions");async function P(e,t,n){const a=n?await E(e,t,n):void 0;return a||z(e,t)}c(P,"buildLeaderPlan");async function Q(e,t){const n=await T(t.taskDescription,t.completeSimple),i=(await C(e,n.presetName,t.taskDescription,t.baseCwd,t.model,t.onRuntimeEvent,!1)).teammates,r=await P(t.taskDescription,i,t.completeSimple),d=[],f=[],o=new Set,u=new Map(i.map(s=>[s.identity.id,s])),y=X(t.taskDescription);t.emitUtterance(I({speakerId:x,speakerLabel:U,role:"leader",kind:"thought",text:H(r)})),t.emitUtterance(I({speakerId:x,speakerLabel:U,role:"leader",kind:"thought",text:`A research plan named ${y} has already been created. If you would like to make any changes to this plan, please provide your input directly in the chat box.`})),r.phase="assign",r.completionState="running";const m=c(s=>{const p=`${s.target.identity.id}:${A(s.task).toLowerCase()}`;o.has(p)||(o.add(p),f.push(s))},"enqueue");for(const s of r.subtasks.filter(p=>p.dependsOn.length===0)){const p=u.get(s.ownerId);p&&m({target:p,task:s.task,title:s.title,kind:"work",subtaskId:s.id})}let l=0;const L=Math.max(6,i.length*4),D=c(async s=>{const p=s.subtaskId?r.subtasks.find(v=>v.id===s.subtaskId):void 0;p&&(p.status="in_progress"),t.emitUtterance(I({speakerId:x,speakerLabel:U,role:"leader",kind:s.kind,text:q(s),mentions:[{raw:`@${s.target.identity.name}`,targetId:s.target.identity.id,targetName:s.target.identity.name,targetLabel:s.target.identity.label,task:s.task}]}));const b=await e.send(s.target.identity.name,Z(t.taskDescription,s,r,i),t.model,{onEvent:t.onRuntimeEvent}),h=b.response||b.error||"No response.",w=M(h,i);return t.emitUtterance(I({speakerId:s.target.identity.id,speakerLabel:s.target.identity.name,role:s.target.identity.role,kind:w.length>0?"handoff":b.success?"result":"work",text:h,mentions:w}),{streamKey:`team-stream:${s.target.identity.id}`,replace:!0}),p&&(p.status=b.success?"done":"blocked"),{assignment:s,subtask:p,sendResult:b,replyText:h,mentions:w}},"runAssignment");for(;f.length>0&&l<L;){const s=Math.min(f.length,L-l),p=f.splice(0,s);l+=p.length;const b=await Promise.all(p.map(h=>D(h)));for(const{assignment:h,replyText:w,mentions:v}of b){for(const k of v){const g=u.get(k.targetId);g&&(d.push({id:crypto.randomUUID(),from:h.target.identity.name,to:k.targetName,task:k.task,status:"pending",timestamp:Date.now()}),m({target:g,task:k.task,title:`Follow-up from ${h.target.identity.name}`,kind:"handoff",sourceLabel:h.target.identity.name,sourceExcerpt:w}))}for(const k of r.subtasks.filter(g=>g.status==="pending"&&g.dependsOn.length>0&&g.dependsOn.every(R=>r.subtasks.find(N=>N.id===R)?.status==="done"))){const g=u.get(k.ownerId);g&&m({target:g,task:k.task,title:k.title,kind:"work",subtaskId:k.id})}}}for(const s of d)s.status=r.subtasks.some(p=>p.ownerName===s.to&&p.status==="blocked")?"blocked":"done";return r.phase="summarize",r.completionState=r.subtasks.some(s=>s.status==="blocked")?"blocked":"completed",t.emitUtterance(I({speakerId:x,speakerLabel:U,role:"leader",kind:"result",text:F(r,d)})),r.phase="done",{plan:r,handoffs:d}}c(Q,"runLeaderOrchestration");async function E(e,t,n){try{const a=await n(["You are the leader of a terminal-native coding team.","Split the user goal into a small, dependency-aware plan for the given teammates.",'Return strict JSON only: {"subtasks":[{"owner":"Ada","title":"...","task":"...","dependsOn":["Ada"]}]}',"Use only the provided teammate names as owners.","Keep 1-6 subtasks total."].join(`
+`),[`User goal: ${e}`,"Teammates:",...t.map(o=>`- ${o.identity.name}: ${o.identity.role}`)].join(`
+`));if(!a)return;const i=JSON.parse(J(a));if(!Array.isArray(i.subtasks)||i.subtasks.length===0)return;const r=new Map(t.map(o=>[o.identity.name.toLowerCase(),o])),d=[];for(const o of i.subtasks.slice(0,6)){const u=o.owner?r.get(o.owner.toLowerCase()):void 0;!u||typeof o.task!="string"||typeof o.title!="string"||d.push({id:crypto.randomUUID(),ownerId:u.identity.id,ownerName:u.identity.name,ownerLabel:u.identity.label,ownerRole:u.identity.role,title:o.title.trim(),task:o.task.trim(),dependsOn:[],status:"pending"})}if(d.length===0)return;const f=new Map(d.map(o=>[o.ownerName.toLowerCase(),o.id]));for(let o=0;o<d.length;o++){const u=i.subtasks?.[o],y=d[o];!u||!y||(y.dependsOn=(u.dependsOn??[]).map(m=>f.get(String(m).toLowerCase())).filter(m=>!!m&&m!==y.id))}return O(e,d)}catch{return}}c(E,"buildLeaderPlanWithModel");function z(e,t){const n=[...t].sort((l,L)=>l.identity.createdAt-L.identity.createdAt);if(n.length===0)return O(e,[]);if(n.length===1){const l=n[0];return O(e,[{id:crypto.randomUUID(),ownerId:l.identity.id,ownerName:l.identity.name,ownerLabel:l.identity.label,ownerRole:l.identity.role,title:"Deliver the task",task:e,dependsOn:[],status:"pending"}])}const a=$(n,["pm","planner","researcher","generic"])??n[0],i=$(n.filter(l=>l.identity.id!==a.identity.id),["architect","researcher","planner","generic"])??n.find(l=>l.identity.id!==a.identity.id)??a,r=$(n.filter(l=>![a.identity.id,i.identity.id].includes(l.identity.id)),["developer","implementer"])??n.find(l=>l.identity.id!==a.identity.id&&l.identity.id!==i.identity.id)??i,d=$(n.filter(l=>![a.identity.id,i.identity.id,r.identity.id].includes(l.identity.id)),["designer","reviewer","researcher","generic"]),f=$(n.filter(l=>![a.identity.id,i.identity.id,r.identity.id,d?.identity.id].includes(l.identity.id)),["data-analyst","verifier","reviewer","generic"]),o=crypto.randomUUID(),u=crypto.randomUUID(),y=crypto.randomUUID(),m=[{id:o,ownerId:a.identity.id,ownerName:a.identity.name,ownerLabel:a.identity.label,ownerRole:a.identity.role,title:"Frame the goal and success bar",task:`Break "${e}" into the smallest practical delivery slice and hand the technical framing to @${i.identity.name}.`,dependsOn:[],status:"pending"},{id:u,ownerId:i.identity.id,ownerName:i.identity.name,ownerLabel:i.identity.label,ownerRole:i.identity.role,title:"Map files, interfaces, and approach",task:`Identify the likely modules/files and implementation shape for "${e}", then hand the concrete build step to @${r.identity.name}.`,dependsOn:[o],status:"pending"},{id:y,ownerId:r.identity.id,ownerName:r.identity.name,ownerLabel:r.identity.label,ownerRole:r.identity.role,title:"Implement the change",task:`Implement the requested change for "${e}". When useful, hand UX polish to @${d?.identity.name??i.identity.name} and evidence/risk review to @${f?.identity.name??i.identity.name}.`,dependsOn:[u],status:"pending"}];return d&&m.push({id:crypto.randomUUID(),ownerId:d.identity.id,ownerName:d.identity.name,ownerLabel:d.identity.label,ownerRole:d.identity.role,title:"Check UX, copy, and visual impact",task:"Review the change from a UX/design perspective. Call out confusing copy, weak affordances, or UI regressions.",dependsOn:[y],status:"pending"}),f&&m.push({id:crypto.randomUUID(),ownerId:f.identity.id,ownerName:f.identity.name,ownerLabel:f.identity.label,ownerRole:f.identity.role,title:"Validate evidence and risks",task:"Review the implementation for evidence, metrics, test coverage, and remaining risks. Summarize release readiness.",dependsOn:[y],status:"pending"}),O(e,m)}c(z,"buildLeaderPlanHeuristic");function O(e,t){return{userGoal:e,phase:"plan",subtasks:t,owners:Object.fromEntries(t.map(n=>[n.ownerLabel,n.ownerRole])),dependencies:Object.fromEntries(t.map(n=>[n.id,n.dependsOn])),completionState:t.length===0?"completed":"pending"}}c(O,"finalizePlan");function $(e,t){for(const n of t){const a=e.find(i=>i.identity.role===n);if(a)return a}return e[0]}c($,"pickOwner");function _(e,t){const n=e.trim(),a=n.toUpperCase();return t.find(i=>i.identity.label.toUpperCase()===a||i.identity.name.toLowerCase()===n.toLowerCase())}c(_,"resolveMentionTarget");function j(e,t){const n=e.slice(t);if(!n.trim())return"";const a=n.search(/\s@[A-Za-z][A-Za-z0-9-]*/),i=n.indexOf(`
+`),r=n.search(/[。！？!?]/),d=[a,i,r].filter(u=>u>=0),f=d.length>0?Math.min(...d):n.length,o=n.slice(0,f).replace(/^[\s:：,，-]+/,"").trim();return A(o)}c(j,"extractMentionTask");function B(e){const t=new Set;return e.filter(n=>{const a=`${n.targetId}:${n.task.toLowerCase()}`;return t.has(a)?!1:(t.add(a),!0)})}c(B,"dedupeMentions");function Z(e,t,n,a){const i=[`Leader goal: ${e}`,`Your assignment: ${t.task}`,"","Team roster:",...a.map(r=>`- ${r.identity.name} (${r.identity.role})`),"","Mention rules:","- Use @Name mentions only for concrete next-step handoffs.","- A mention must be followed by the task fragment for the target agent.","- Do not ping without actionable work."];return t.sourceLabel&&t.sourceExcerpt&&i.push("",`Handoff source: ${t.sourceLabel}`,`Context: ${K(A(t.sourceExcerpt),280)}`),t.subtaskId&&n.subtasks.find(d=>d.id===t.subtaskId)?.dependsOn.length&&i.push("","Dependencies are already satisfied. Build on prior team outputs rather than repeating discovery."),i.push("","Respond as yourself, not as the leader."),i.join(`
+`)}c(Z,"buildAssignmentPrompt");function H(e){if(e.subtasks.length===0)return"I did not need to split the work; the task can be handled directly.";const t=e.subtasks.map(n=>`${n.ownerName} (${n.ownerRole}) handles "${n.title}"${n.dependsOn.length?" after its dependencies clear":""}`);return`I split the goal into ${e.subtasks.length} steps. ${t.join("; ")}.`}c(H,"formatLeaderPlanAnnouncement");function q(e){return e.kind==="handoff"&&e.sourceLabel?`@${e.target.identity.name} take the handoff from ${e.sourceLabel}: ${e.task}`:`@${e.target.identity.name} ${e.task}`}c(q,"formatLeaderAssignment");function F(e,t){const n=e.subtasks.filter(r=>r.status==="done").length,a=e.subtasks.filter(r=>r.status==="blocked").length,i=t.length;return a>0?`The team completed ${n}/${e.subtasks.length} planned steps. ${a} step(s) ended blocked. Handoffs observed: ${i}.`:`The team completed ${n}/${e.subtasks.length} planned steps. Handoffs observed: ${i}.`}c(F,"formatLeaderSummary");function J(e){const t=e.indexOf("{"),n=e.lastIndexOf("}");return t===-1||n===-1||n<=t?e:e.slice(t,n+1)}c(J,"extractJsonObject");function A(e){return e.replace(/\s+/g," ").trim()}c(A,"singleLine");function K(e,t){return e.length<=t?e:e.slice(e.length-t)}c(K,"tailText");function X(e){return`Team_Research_${A(e).replace(/[^A-Za-z0-9]+/g,"_").replace(/^_+|_+$/g,"").slice(0,32)||"Plan"}`}c(X,"buildResearchPlanName");export{P as buildLeaderPlan,I as createTeamUtterance,V as formatUtteranceForContext,M as parseTeamMentions,Q as runLeaderOrchestration};

package/dist/extensions/builtin/team/team-parser.d.ts

@@ -0,0 +1,84 @@
+/**
+ * [WHO]: Team command parser - /team:* subcommands including harness/preset/dashboard/status helpers
+ * [FROM]: No external deps
+ * [TO]: Consumed by index.ts
+ * [HERE]: extensions/builtin/team/team-parser.ts
+ *
+ * Parses /team series commands per Phase B spec:
+ *   /team                      - List teammates
+ *   /team:spawn <role> [--name <id>] [--harness] - Create teammate
+ *   /team:send <name> <message>      - Send message to teammate
+ *   /team:status [<name>]            - Show status
+ *   /team:preset <solo|duo|squad> <task> - Create preset team
+ *   /team:progress [<name>]          - Show harness progress
+ *   /team:psyche [<name>]            - Show psyche weights
+ *   /team:dashboard                  - Toggle dashboard widget
+ *   /team:task <add|claim|done|block|cancel|list> ... - Manage shared task list
+ *   /team:mail <from> <to> <message> - Route a teammate-to-teammate mailbox message
+ *   /team:allow-path <name> <path>   - Grant teammate write access to a path prefix
+ *   /team:stop <name>                - Stop teammate turn
+ *   /team:terminate <name>           - Destroy teammate
+ *   /team:approve <request-id>       - Approve permission request
+ *   /team:mode <name> <plan|execute|review> - Switch mode
+ */
+import type { PresetName, TeammateMode, TeammateRole } from "./team-types.js";
+export type TeamSubcommand = "list" | "spawn" | "send" | "status" | "stop" | "terminate" | "approve" | "mode" | "preset" | "auto" | "dashboard" | "progress" | "psyche" | "task" | "mail" | "allow-path" | "help";
+export interface ParsedTeamCommand {
+    command: TeamSubcommand;
+    /** For spawn: role name */
+    role?: TeammateRole;
+    /** For spawn: optional name override */
+    name?: string;
+    /** For send/status/stop/terminate/approve/mode: target teammate name or request id */
+    target?: string;
+    /** For send: message content */
+    message?: string;
+    /** For mode: target mode */
+    mode?: TeammateMode;
+    /** For approve: request id */
+    requestId?: string;
+    /** For spawn: enable harness protocol */
+    harnessEnabled?: boolean;
+    /** For preset: preset name */
+    presetName?: PresetName;
+    /** For preset: task description */
+    taskDescription?: string;
+    /** For task: task subcommand */
+    taskAction?: "add" | "claim" | "done" | "block" | "cancel" | "list";
+    /** For task: task id */
+    taskId?: string;
+    /** For task add: title */
+    taskTitle?: string;
+    /** For mail: source teammate */
+    from?: string;
+    /** For mail: target teammate */
+    to?: string;
+    /** For allow-path: path prefix */
+    path?: string;
+}
+export declare const TEAM_ROOT_COMPLETIONS: readonly ["help", "spawn", "send", "status", "stop", "terminate", "approve", "mode", "preset", "dashboard", "progress", "psyche", "task", "mail", "allow-path"];
+export declare const VALID_ROLES: TeammateRole[];
+export declare const VALID_MODES: TeammateMode[];
+export declare const VALID_PRESETS: PresetName[];
+export declare const VALID_TASK_ACTIONS: readonly ["add", "claim", "done", "block", "cancel", "list"];
+type TeamArgumentCompletionContext = {
+    commandName: string;
+    argumentText: string;
+    argumentPrefix: string;
+    tokenIndex: number;
+    previousTokens: string[];
+};
+export declare function getTeamArgumentCompletions(commandName: string, argumentPrefix: string, context?: TeamArgumentCompletionContext): Array<{
+    value: string;
+    label: string;
+    description?: string;
+}> | null;
+/**
+ * Parse a /team command invocation.
+ */
+export declare function parseTeamCommand(commandName: string, args?: string): ParsedTeamCommand | null;
+/**
+ * Build help text for /team commands.
+ */
+export declare function buildTeamHelp(): string;
+export {};

package/dist/extensions/builtin/team/team-parser.js

@@ -0,0 +1,38 @@
+var S=Object.defineProperty;var m=(r,t)=>S(r,"name",{value:t,configurable:!0});const x=["help","spawn","send","status","stop","terminate","approve","mode","preset","dashboard","progress","psyche","task","mail","allow-path"],c=["pm","architect","developer","designer","data-analyst","researcher","reviewer","implementer","planner","verifier","generic"],l=["research","plan","execute","review"],d=["solo","duo","squad"],I=["add","claim","done","block","cancel","list"],p=["--name","--harness"],b={help:"Show team commands",spawn:"Create a teammate",send:"Send work to a teammate",status:"Show teammate status",stop:"Stop a teammate's current turn",terminate:"Remove a teammate",approve:"Approve a teammate request",mode:"Change how a teammate works",preset:"Start with a preset team shape",dashboard:"Show or hide the team panel",progress:"Show teammate progress",psyche:"Show teammate decision settings",task:"Manage shared team tasks",mail:"Send a teammate-to-teammate note","allow-path":"Allow a teammate to write in a path",pm:"Plan priorities and coordinate work",architect:"Design structure and break down trade-offs",developer:"Have a teammate write code",designer:"Review product and interaction details","data-analyst":"Check evidence, metrics, and results",researcher:"Explore read-only context",reviewer:"Review code or plans without writing",implementer:"Have a teammate write code",planner:"Have a teammate make a plan",verifier:"Check whether the work is correct",generic:"Use a flexible teammate role","--name":"Choose the teammate name","--harness":"Use structured progress tracking",research:"Read and investigate without writing",plan:"Write a plan before code changes",execute:"Allow code changes",review:"Review without writing",solo:"Use one focused teammate",duo:"Use two teammates with complementary roles",squad:"Use a larger team for broader work",add:"Add a shared task",claim:"Assign a task to a teammate",done:"Mark a task complete",block:"Mark a task blocked",cancel:"Cancel a task",list:"List shared tasks"};function T(r,t){switch(r){case"team":return!t||t.tokenIndex===0?x:[];case"team:spawn":return t?t.tokenIndex===0?c:p:[...c,...p];case"team:preset":return!t||t.tokenIndex===0?d:[];case"team:task":return!t||t.tokenIndex===0?I:[];case"team:mode":return t?.tokenIndex===1?l:[];default:return[]}}m(T,"getTeamCompletionValues");function O(r,t,e){const a=t.trim().toLowerCase(),n=T(r,e).filter(i=>i.startsWith(a));return n.length>0?n.map(i=>({value:i,label:i,description:b[i]})):null}m(O,"getTeamArgumentCompletions");function y(r,t=""){const e=t.trim();switch(r){case"team":return e?e==="help"?{command:"help"}:e.startsWith("spawn ")?u(e.slice(6)):e.startsWith("send ")?h(e.slice(5)):e.startsWith("status")?f(e.slice(6).trim()):e.startsWith("stop ")?{command:"stop",target:e.slice(5).trim()}:e.startsWith("terminate ")?{command:"terminate",target:e.slice(10).trim()}:e==="approve"?{command:"approve"}:e.startsWith("approve ")?{command:"approve",requestId:e.slice(8).trim()||void 0}:e.startsWith("mode ")?g(e.slice(5)):e.startsWith("preset ")?w(e.slice(7)):e==="dashboard"?{command:"dashboard"}:e.startsWith("progress")?o("progress",e.slice(8).trim()):e.startsWith("psyche")?o("psyche",e.slice(6).trim()):e.startsWith("task")?k(e.slice(4).trim()):e.startsWith("mail ")?A(e.slice(5)):e.startsWith("allow-path ")?v(e.slice(11)):{command:"auto",taskDescription:e}:{command:"list"};case"team:spawn":return u(e);case"team:send":return h(e);case"team:status":return f(e);case"team:stop":return e?{command:"stop",target:e}:null;case"team:terminate":return e?{command:"terminate",target:e}:null;case"team:approve":return e?{command:"approve",requestId:e}:{command:"approve"};case"team:mode":return g(e);case"team:preset":return w(e);case"team:dashboard":return{command:"dashboard"};case"team:progress":return o("progress",e);case"team:psyche":return o("psyche",e);case"team:task":return k(e);case"team:mail":return A(e);case"team:allow-path":return v(e);default:return null}}m(y,"parseTeamCommand");function u(r){const t=r.trim().split(/\s+/);if(t.length===0)return null;const e=t[0];if(!c.includes(e))return null;let a,s=!1;for(let n=1;n<t.length;n++)t[n]==="--name"&&n+1<t.length?(a=t[n+1],n++):t[n]==="--harness"&&(s=!0);return s?{command:"spawn",role:e,name:a,harnessEnabled:s}:{command:"spawn",role:e,name:a}}m(u,"parseSpawnArgs");function h(r){const t=r.trim(),e=t.indexOf(" ");if(e===-1)return null;const a=t.slice(0,e),s=t.slice(e+1).trim();return!a||!s?null:{command:"send",target:a,message:s}}m(h,"parseSendArgs");function f(r){return{command:"status",target:r.trim()||void 0}}m(f,"parseStatusArgs");function g(r){const t=r.trim().split(/\s+/);if(t.length<2)return null;const e=t[0],a=t[1];return l.includes(a)?{command:"mode",target:e,mode:a}:null}m(g,"parseModeArgs");function w(r){const t=r.trim(),e=t.indexOf(" "),a=e===-1?t:t.slice(0,e);if(!d.includes(a))return null;const s=e===-1?"":t.slice(e+1).trim();return s?{command:"preset",presetName:a,taskDescription:s}:null}m(w,"parsePresetArgs");function o(r,t){const e=t.trim();return{command:r,target:e||void 0}}m(o,"parseTargetOnly");function k(r){const t=r.trim();if(!t||t==="list")return{command:"task",taskAction:"list"};const e=t.indexOf(" "),a=e===-1?t:t.slice(0,e),s=e===-1?"":t.slice(e+1).trim();if(a==="add")return s?{command:"task",taskAction:"add",taskTitle:s}:null;if(a==="claim"){const n=s.split(/\s+/);return n[0]&&n[1]?{command:"task",taskAction:"claim",taskId:n[0],target:n[1]}:null}return(a==="done"||a==="block"||a==="cancel")&&s?{command:"task",taskAction:a,taskId:s.split(/\s+/)[0]}:null}m(k,"parseTaskArgs");function A(r){const t=r.trim(),e=t.indexOf(" ");if(e===-1)return null;const a=t.indexOf(" ",e+1);if(a===-1)return null;const s=t.slice(0,e),n=t.slice(e+1,a),i=t.slice(a+1).trim();return!s||!n||!i?null:{command:"mail",from:s,to:n,message:i}}m(A,"parseMailArgs");function v(r){const t=r.trim(),e=t.indexOf(" ");if(e===-1)return null;const a=t.slice(0,e),s=t.slice(e+1).trim();return!a||!s?null:{command:"allow-path",target:a,path:s}}m(v,"parseAllowPathArgs");function W(){return`
+Team Commands (AgentTeam + Harness):
+  /team                           - List all teammates
+  /team <task>                    - Auto-select a team and start the task
+  /team:spawn <role> [--name <n>] [--harness] - Create a persistent teammate
+  /team:preset <solo|duo|squad> <task> - Create teammates from a preset
+  /team:send <name> <message>     - Send message to a teammate
+  /team:status [<name>]           - Show team or teammate status
+  /team:progress [<name>]         - Show harness progress
+  /team:psyche [<name>]           - Show psyche weights
+  /team:dashboard                 - Toggle team dashboard widget
+  /team:task list                 - Show shared team tasks
+  /team:task add <title>          - Add a shared task
+  /team:task claim <id> <name>    - Assign/claim task for teammate
+  /team:task done <id>            - Mark task done
+  /team:task block <id>           - Mark task blocked
+  /team:mail <from> <to> <msg>    - Send teammate-to-teammate mailbox message
+  /team:allow-path <name> <path>  - Grant teammate write access to a path prefix
+  /team:stop <name>               - Stop teammate's current turn
+  /team:terminate <name>          - Destroy a teammate
+  /team:approve <request-id>      - Approve a permission request
+  /team:mode <name> <mode>        - Switch teammate mode
+
+Roles: pm, architect, developer, designer, data-analyst, researcher, reviewer, implementer, planner, verifier, generic
+Modes: research, plan, execute, review
+
+Examples:
+  /team Implement login with tests
+  /team:spawn implementer --name alice --harness
+  /team:preset solo "Implement login feature"
+  /team:send alice "Implement login feature"
+  /team:task add Implement login tests
+  /team:task claim T-1 alice
+  /team:mail alice verifier "Please review T-1 when ready"
+  /team:status alice
+  /team:mode alice execute
+  /team:terminate alice
+`.trim()}m(W,"buildTeamHelp");export{x as TEAM_ROOT_COMPLETIONS,l as VALID_MODES,d as VALID_PRESETS,c as VALID_ROLES,I as VALID_TASK_ACTIONS,W as buildTeamHelp,O as getTeamArgumentCompletions,y as parseTeamCommand};

package/dist/extensions/builtin/team/team-permissions.d.ts

@@ -0,0 +1,63 @@
+/**
+ * [WHO]: PermissionStore, PermissionRequest, PermissionAction, PermissionDecision
+ * [FROM]: No external deps
+ * [TO]: Consumed by team-runtime.ts, index.ts
+ * [HERE]: extensions/builtin/team/team-permissions.ts - Phase B B.4 permission model
+ *
+ * Per refactor plan §B.4: "permission must be frozen before mailbox".
+ *
+ * The permission model is the trust boundary between leader and teammate.
+ * Any action that mutates the world or escalates a teammate's mode goes
+ * through a PermissionRequest which the leader must approve via
+ * `/team:approve <request-id>`.
+ *
+ * Pending requests carry a `resolve` callback so the runtime side can
+ * `await` the leader's decision without polling.
+ */
+export type PermissionAction = "mode_change_to_execute" | "write_path" | "bash_command";
+export type PermissionStatus = "pending" | "approved" | "denied" | "expired";
+export interface PermissionRequest {
+    id: string;
+    teammateId: string;
+    teammateName: string;
+    action: PermissionAction;
+    detail: string;
+    createdAt: number;
+    status: PermissionStatus;
+}
+/**
+ * In-memory permission store. Decisions never persist across process restarts:
+ * if the main session dies while a request is pending, the teammate is left
+ * idle and the leader must reissue the action after restart.
+ */
+export declare class PermissionStore {
+    private requests;
+    private pathAllowlist;
+    /**
+     * File a new permission request and return a promise that resolves
+     * with the leader's decision (true = approved, false = denied).
+     */
+    request(teammateId: string, teammateName: string, action: PermissionAction, detail: string): {
+        id: string;
+        decision: Promise<boolean>;
+    };
+    /** Approve a pending request. Returns false if id is unknown or already resolved. */
+    approve(id: string): boolean;
+    /** Deny a pending request. */
+    deny(id: string): boolean;
+    /** All pending requests, sorted oldest first. */
+    listPending(): PermissionRequest[];
+    /** Get a request snapshot without the resolve handle. */
+    get(id: string): PermissionRequest | undefined;
+    /**
+     * Cancel any pending requests owned by `teammateId`. Used when the
+     * teammate is terminated so the awaiting promise does not leak.
+     */
+    cancelForTeammate(teammateId: string): void;
+    /** Grant a teammate write permission for a path prefix. */
+    allowPath(teammateId: string, path: string): void;
+    /** Check whether a teammate currently holds write access to `path`. */
+    isPathAllowed(teammateId: string, path: string): boolean;
+    /** Drop a teammate's allowlist entirely (called on terminate). */
+    clearPaths(teammateId: string): void;
+}

package/dist/extensions/builtin/team/team-permissions.js

@@ -0,0 +1 @@
+var p=Object.defineProperty;var l=(r,t)=>p(r,"name",{value:t,configurable:!0});class f{static{l(this,"PermissionStore")}requests=new Map;pathAllowlist=new Map;request(t,e,s,a){const n=crypto.randomUUID(),u=new Promise(d=>{const c={id:n,teammateId:t,teammateName:e,action:s,detail:a,createdAt:Date.now(),status:"pending",resolve:d};this.requests.set(n,c)});return{id:n,decision:u}}approve(t){const e=this.requests.get(t);return!e||e.status!=="pending"?!1:(e.status="approved",e.resolve(!0),!0)}deny(t){const e=this.requests.get(t);return!e||e.status!=="pending"?!1:(e.status="denied",e.resolve(!1),!0)}listPending(){return[...this.requests.values()].filter(t=>t.status==="pending").map(o).sort((t,e)=>t.createdAt-e.createdAt)}get(t){const e=this.requests.get(t);return e?o(e):void 0}cancelForTeammate(t){for(const e of this.requests.values())e.teammateId===t&&e.status==="pending"&&(e.status="expired",e.resolve(!1))}allowPath(t,e){let s=this.pathAllowlist.get(t);s||(s=new Set,this.pathAllowlist.set(t,s)),s.add(i(e))}isPathAllowed(t,e){const s=this.pathAllowlist.get(t);if(!s)return!1;const a=i(e);for(const n of s)if(a===n||a.startsWith(`${n}/`))return!0;return!1}clearPaths(t){this.pathAllowlist.delete(t)}}function o(r){const{resolve:t,...e}=r;return e}l(o,"stripResolve");function i(r){return r.replace(/\\/g,"/").replace(/\/+$/,"").toLowerCase()}l(i,"normalizeAllowedPath");export{f as PermissionStore};

package/dist/extensions/builtin/team/team-presets.d.ts

@@ -0,0 +1,45 @@
+/**
+ * [WHO]: Provides PRESETS, executePreset(), executeAutoTeam(), selectAutoTeamPlan(), formatPresetResult()
+ * [FROM]: Depends on ./team-types and ./team-runtime for spawning configured teammates
+ * [TO]: Consumed by index.ts for /team:preset command handling
+ * [HERE]: extensions/builtin/team/team-presets.ts - built-in AgentTeam preset definitions
+ */
+import type { TeamRuntime } from "./team-runtime.js";
+import type { TeamRuntimeEvent } from "./team-runtime.js";
+import type { PersistedTeammate, PresetName, PsycheWeights, TeammateMode, TeammateRole } from "./team-types.js";
+export interface PresetTeammateSpec {
+    role: TeammateRole;
+    name?: string;
+    mode?: TeammateMode;
+    harnessEnabled: boolean;
+    psycheOverrides?: Partial<PsycheWeights>;
+}
+export interface PresetSpec {
+    name: PresetName;
+    description: string;
+    teammates: PresetTeammateSpec[];
+    autoStart: boolean;
+}
+export interface PresetResult {
+    preset: PresetSpec;
+    teammates: PersistedTeammate[];
+    started?: {
+        teammateName: string;
+        success: boolean;
+        error?: string;
+    };
+}
+export interface AutoTeamPlan {
+    presetName: PresetName;
+    rationale: string;
+    startTargetRole: TeammateRole;
+}
+export interface AutoTeamResult extends PresetResult {
+    plan: AutoTeamPlan;
+}
+export declare const PRESETS: Record<PresetName, PresetSpec>;
+export declare function executePreset(runtime: TeamRuntime, presetName: PresetName, taskDescription: string, baseCwd: string, model?: Parameters<TeamRuntime["send"]>[2], onEvent?: (event: TeamRuntimeEvent) => void, autoStartOverride?: boolean): Promise<PresetResult>;
+export declare function executeAutoTeam(runtime: TeamRuntime, taskDescription: string, baseCwd: string, model?: Parameters<TeamRuntime["send"]>[2], onEvent?: (event: TeamRuntimeEvent) => void, completeSimple?: (systemPrompt: string, userMessage: string) => Promise<string | undefined>): Promise<AutoTeamResult>;
+export declare function selectAutoTeamPlan(taskDescription: string, completeSimple?: (systemPrompt: string, userMessage: string) => Promise<string | undefined>): Promise<AutoTeamPlan>;
+export declare function formatPresetResult(result: PresetResult): string[];
+export declare function formatAutoTeamResult(result: AutoTeamResult): string[];

package/dist/extensions/builtin/team/team-presets.js

@@ -0,0 +1,2 @@
+var h=Object.defineProperty;var r=(e,t)=>h(e,"name",{value:t,configurable:!0});const g={solo:{name:"solo",description:"Single developer with harness, suited for focused delivery tasks.",teammates:[{role:"developer",name:"Theo",harnessEnabled:!0}],autoStart:!0},duo:{name:"duo",description:"Architect plus developer for discovery followed by execution.",teammates:[{role:"architect",name:"Ada",mode:"plan",harnessEnabled:!1},{role:"developer",name:"Theo",harnessEnabled:!0}],autoStart:!1},squad:{name:"squad",description:"PM, architect, developer, designer, and data analyst for explicit multi-agent handoffs.",teammates:[{role:"pm",name:"Mason",mode:"plan",harnessEnabled:!1},{role:"architect",name:"Ada",mode:"plan",harnessEnabled:!1},{role:"developer",name:"Theo",harnessEnabled:!0},{role:"designer",name:"Iris",mode:"research",harnessEnabled:!1,psycheOverrides:{id:1.3,ego:1.1}},{role:"data-analyst",name:"Quinn",mode:"review",harnessEnabled:!1,psycheOverrides:{superego:1.5,id:.5}}],autoStart:!1}};async function b(e,t,a,s,i,n,l){const d=g[t],o=[];for(const m of d.teammates)o.push(await v(e,m,s));const c={preset:d,teammates:o};if((l??d.autoStart)&&o[0]){const m=await e.send(o[0].identity.name,a,i,{onEvent:n});c.started={teammateName:o[0].identity.name,success:m.success,error:m.error}}return c}r(b,"executePreset");async function R(e,t,a,s,i,n){const l=await y(t,n),d=await b(e,l.presetName,t,a,s,i,!1),o=d.teammates.find(u=>u.identity.role===l.startTargetRole)??d.teammates[0],c={...d,plan:l};if(o){const u=await e.send(o.identity.name,t,s,{onEvent:i});c.started={teammateName:o.identity.name,success:u.success,error:u.error,response:u.response}}return c}r(R,"executeAutoTeam");async function y(e,t){if(t){const a=await N(e,t);if(a){const s=p(e);return s.presetName==="squad"&&a.presetName!=="squad"&&f(e)?{...s,rationale:"Website, clone, or design delivery tasks need the full PM, architecture, development, design, and validation squad."}:a}}return p(e)}r(y,"selectAutoTeamPlan");async function v(e,t,a){const s=t.name?e.getTeammate(t.name):void 0;return s&&s.identity.role===t.role?s:e.spawn({role:t.role,name:t.name,mode:t.mode,baseCwd:a,harnessEnabled:t.harnessEnabled,psycheOverrides:t.psycheOverrides})}r(v,"getOrSpawnPresetTeammate");function T(e){const t=[`Preset "${e.preset.name}" created: ${e.preset.description}`,""];for(const a of e.teammates){const s=a.harness?.enabled?" harness:on":"";t.push(`  ${a.identity.name} (${a.identity.role}, ${a.mode})${s}`)}if(e.started){const a=e.started;t.push("",a.success?`Auto-started ${a.teammateName}.`:`Auto-start for ${a.teammateName} failed: ${a.error??"Unknown error"}`),a.success&&a.response?.trim()&&t.push("",`Response from ${a.teammateName}:`,"",a.response)}return t}r(T,"formatPresetResult");function A(e){return[`Auto team selected "${e.plan.presetName}".`,`Reason: ${e.plan.rationale}`,"",...T(e)]}r(A,"formatAutoTeamResult");async function N(e,t){try{const a=await t(["You select the smallest useful AgentTeam preset for a coding task.",'Return strict JSON only: {"presetName":"solo|duo|squad","rationale":"short reason","startTargetRole":"developer|architect|pm"}',"solo: focused implementation or small/medium bugfix.","duo: implementation needs architecture reading, API mapping, or light decomposition before coding.","squad: tasks that need explicit handoff, product framing, design input, data validation, review, tests, or broader coordination.","squad: also use for websites, landing pages, website clones, browser research, design systems, frontend polish, and release-readiness checks."].join(`
+`),e);if(!a)return;const s=JSON.parse(w(a));if(s.presetName==="solo"||s.presetName==="duo"||s.presetName==="squad"){const i=s.startTargetRole==="pm"&&s.presetName==="squad"?"pm":s.startTargetRole==="architect"&&(s.presetName==="duo"||s.presetName==="squad")?"architect":"developer";return{presetName:s.presetName,rationale:typeof s.rationale=="string"?s.rationale:"Selected by the current model.",startTargetRole:i}}}catch{return}}r(N,"selectAutoTeamPlanWithModel");function p(e){const t=e.toLowerCase(),a=["architecture","refactor","migration","migrate","system","multiple","end-to-end","e2e","large","\u5B8C\u6574","\u91CD\u6784","\u67B6\u6784","\u8FC1\u79FB","\u5927\u578B"],s=["website","official site","site","homepage","landing","front-end","frontend","web page","clone","rebuild","design system","visual","ux","ui","browser"],i=["test","tests","verify","review","security","auth","payment","release","bug","\u9A8C\u8BC1","\u6D4B\u8BD5","\u5B89\u5168","\u767B\u5F55","\u652F\u4ED8","\u53D1\u5E03"];return a.some(n=>t.includes(n))||s.some(n=>t.includes(n))||f(e)||e.length>240?{presetName:"squad",rationale:"Task looks broad or architectural, so PM, architect, developer, designer, and data analyst are safer.",startTargetRole:"pm"}:i.some(n=>t.includes(n))?{presetName:"squad",rationale:"Task has correctness or verification signals, so explicit PM, architecture, implementation, design, and data validation are appropriate.",startTargetRole:"pm"}:t.includes("refactor")||t.includes("api")||t.includes("investigate")||t.includes("analyze")?{presetName:"duo",rationale:"Task benefits from architecture framing before coding, so an architect plus developer is appropriate.",startTargetRole:"architect"}:{presetName:"solo",rationale:"Task appears focused enough for one harnessed developer.",startTargetRole:"developer"}}r(p,"selectAutoTeamPlanHeuristic");function f(e){return/(?:\u5b98\u7f51|\u9875\u9762|\u524d\u7aef|\u8bbe\u8ba1|\u590d\u523b|\u514b\u9686|\u89c6\u89c9|\u4ea4\u4e92)/.test(e)}r(f,"hasWebsiteOrDesignDeliverySignal");function w(e){const t=e.indexOf("{"),a=e.lastIndexOf("}");return t===-1||a===-1||a<=t?e:e.slice(t,a+1)}r(w,"extractJsonObject");export{g as PRESETS,R as executeAutoTeam,b as executePreset,A as formatAutoTeamResult,T as formatPresetResult,y as selectAutoTeamPlan};

package/dist/extensions/builtin/team/team-psyche.d.ts

@@ -0,0 +1,14 @@
+/**
+ * [WHO]: Provides computePsycheWeights(), buildPsychePrompt(), formatPsycheWeights()
+ * [FROM]: Depends on ./team-types for teammate roles, phases, weights, persisted teammate state
+ * [TO]: Consumed by team-runtime.ts, team-dashboard.ts, index.ts for phase-aware teammate prompts and status rendering
+ * [HERE]: extensions/builtin/team/team-psyche.ts - Freud-inspired internal prompt layer for AgentTeam harness work
+ */
+import type { HarnessPhase, PersistedTeammate, PsycheWeights, TeammateRole } from "./team-types.js";
+export type SoulTraits = Partial<Record<string, number>>;
+export declare function computePsycheWeights(phase: HarnessPhase, role: TeammateRole, soulTraits?: SoulTraits, overrides?: Partial<PsycheWeights>): PsycheWeights;
+export declare function buildPsychePrompt(weights: PsycheWeights, phase: HarnessPhase, teammate: PersistedTeammate): string;
+export declare function buildIdLayer(weight: number, phase: HarnessPhase): string;
+export declare function buildEgoLayer(weight: number, phase: HarnessPhase): string;
+export declare function buildSuperegoLayer(weight: number, phase: HarnessPhase): string;
+export declare function formatPsycheWeights(weights: PsycheWeights | undefined): string;

package/dist/extensions/builtin/team/team-psyche.js

@@ -0,0 +1,5 @@
+var p=Object.defineProperty;var i=(e,t)=>p(e,"name",{value:t,configurable:!0});const d={init:{id:2,ego:7,superego:1},coding:{id:5,ego:3,superego:2},verify:{id:1,ego:2,superego:7},fix:{id:4,ego:4,superego:2},complete:{id:1,ego:3,superego:6}},g={pm:{ego:1.4,superego:1.1},architect:{ego:1.4,id:.8},developer:{id:1.1},designer:{id:1.2,ego:1.1},"data-analyst":{superego:1.4,ego:1.1},implementer:{},verifier:{superego:1.5,id:.5},planner:{ego:1.3,id:.7},researcher:{ego:1.2},reviewer:{superego:1.3},generic:{}},f=[{trait:"conscientiousness",target:"superego",scale:.3},{trait:"openness",target:"id",scale:.3},{trait:"neuroticism",target:"ego",scale:.2},{trait:"explorationDrive",target:"id",scale:.2},{trait:"safetyMargin",target:"superego",scale:.2}];function $(e,t,n,o){const a={...d[e]},u=g[t]??{};for(const r of Object.keys(u))a[r]=a[r]*(u[r]??1);if(n)for(const r of f){const c=h(n[r.trait]);c!==void 0&&(a[r.target]=a[r.target]*(1+c*r.scale))}if(o)for(const r of Object.keys(o))a[r]=o[r]??a[r];return v(a)}i($,"computePsycheWeights");function S(e,t,n){const o=b(e);return["## Internal Psyche Structure","","You have three simultaneous internal forces. They are not separate agents; they jointly influence every decision.",`Current phase: ${t} | Weights: Id=${e.id} Ego=${e.ego} Superego=${e.superego}`,`Dominant layer: ${o}`,"",l(e.id,t),"",m(e.ego,t),"",y(e.superego,t),"",`Apply these forces as ${n.identity.name} (${n.identity.role}) in ${n.mode} mode.`].join(`
+`)}i(S,"buildPsychePrompt");function l(e,t){const n=e>=5?"dominant":e<=2?"restrained":"active",o=t==="verify"?"Suppress implementation impulses. Record defects instead of fixing them in this phase.":t==="init"?"Channel creative drive into decomposing the work into concrete, testable features.":"Implement one valuable feature at a time and keep momentum visible.";return[`### Id - Creative Drive [${n}]`,o].join(`
+`)}i(l,"buildIdLayer");function m(e,t){const n=e>=5?"dominant":e<=2?"supporting":"active",o=t==="init"?"First understand the task, create the harness files, then stop after the initialization checkpoint.":"Read the injected harness files, choose the next bounded step, and preserve context by updating progress.";return[`### Ego - Reality Coordination [${n}]`,o,"- Work incrementally; avoid one-shotting a large task.","- Prefer observable progress over broad unfinished changes."].join(`
+`)}i(m,"buildEgoLayer");function y(e,t){const n=e>=5?"dominant":e<=2?"watching":"active",o=t==="verify"?"Strictly verify every claimed passing feature and downgrade any unverified claim.":"Do not claim completion without concrete verification evidence.";return[`### Superego - Quality Constraint [${n}]`,o,"- Do not remove or rewrite feature definitions in feature_list.json.","- Only set passes=true after executing the listed verification steps.","- Keep progress.txt accurate enough for the next session to resume."].join(`
+`)}i(y,"buildSuperegoLayer");function I(e){return e?`psyche: Id=${e.id} Ego=${e.ego} Superego=${e.superego}`:"psyche: unavailable"}i(I,"formatPsycheWeights");function h(e){if(!(typeof e!="number"||!Number.isFinite(e)))return e>1?Math.max(-1,Math.min(1,e/100)):Math.max(-1,Math.min(1,e))}i(h,"normalizeTrait");function v(e){return{id:s(e.id),ego:s(e.ego),superego:s(e.superego)}}i(v,"clampWeights");function s(e){return Math.max(0,Math.min(10,Math.round(e*10)/10))}i(s,"clampWeight");function b(e){return e.superego>=e.id&&e.superego>=e.ego?"Superego":e.ego>=e.id&&e.ego>=e.superego?"Ego":"Id"}i(b,"getDominantLayer");export{m as buildEgoLayer,l as buildIdLayer,S as buildPsychePrompt,y as buildSuperegoLayer,$ as computePsycheWeights,I as formatPsycheWeights};

package/dist/extensions/builtin/team/team-runtime-helpers.d.ts

@@ -0,0 +1,48 @@
+/**
+ * [WHO]: Provides TeamRuntime helper functions for prompts, harness turns, live events, tools, labels, roles, and path guards
+ * [FROM]: Depends on core tools/sub-agent events, team-harness, team-psyche, team-mailbox, team-types
+ * [TO]: Consumed by team-runtime.ts to keep TeamRuntime focused on lifecycle, persistence, and send queues
+ * [HERE]: extensions/builtin/team/team-runtime-helpers.ts - stateless runtime support boundary
+ */
+import type { SubAgentEvent } from "../../../core/sub-agent/index.js";
+import { type Tool } from "../../../core/tools/index.js";
+import type { MailboxMessage } from "./team-mailbox.js";
+import type { AgentLiveView, PersistedTeammate, TeamTask, TeammateIdentity, TeammateMode, TeammateRole } from "./team-types.js";
+import type { RuntimeTeammate } from "./team-runtime.js";
+export declare function ensureLiveView(view: AgentLiveView | undefined, identity: TeammateIdentity): AgentLiveView;
+export declare function getDefaultModeForRole(role: TeammateRole): TeammateMode;
+export declare function buildTeammatePrompt(input: {
+    state: PersistedTeammate;
+    teammates: PersistedTeammate[];
+    tasks: TeamTask[];
+    mailboxMessages: MailboxMessage[];
+}): string;
+export declare function prepareHarnessTurn(input: {
+    teammate: RuntimeTeammate;
+    taskDescription: string;
+    soulManager: unknown;
+}): Promise<{
+    psychePrompt: string;
+    harnessInstructions: string;
+    contextFiles: string[];
+} | undefined>;
+export declare function applyLiveEvent(teammate: RuntimeTeammate, event: SubAgentEvent): void;
+export declare function selectToolsForMode(input: {
+    mode: TeammateMode;
+    cwd: string;
+    getAllTeammates: () => PersistedTeammate[];
+    isPathAllowed: (teammateId: string, absolutePath: string) => boolean;
+}): Tool[];
+export declare function createWritePathGuard(input: {
+    cwd: string;
+    getAllTeammates: () => PersistedTeammate[];
+    isPathAllowed: (teammateId: string, absolutePath: string) => boolean;
+}): (absolutePath: string) => void;
+export declare function normalizePath(path: string): string;
+export declare function isWithinPath(target: string, root: string): boolean;
+export declare function summarizeTask(value: string): string;
+export declare function singleLine(value: string): string;
+export declare function tailText(value: string, maxLength: number): string;
+export declare function labelFromIndex(index: number): string;
+export declare function indexFromLabel(label: string): number;
+export declare function isBuilderRole(role: TeammateRole): boolean;

package/dist/extensions/builtin/team/team-runtime-helpers.js

@@ -0,0 +1,2 @@
+var T=Object.defineProperty;var a=(e,t)=>T(e,"name",{value:t,configurable:!0});import{isAbsolute as k,resolve as v}from"node:path";import{createBashTool as g,createCodingTools as N,createReadOnlyTools as P,createSandboxHook as w}from"../../../core/tools/index.js";import{beginHarnessTurn as A,buildHarnessInstructions as C,ensureHarnessFiles as F,prepareContextFiles as R}from"./team-harness.js";import{buildPsychePrompt as W,computePsycheWeights as M}from"./team-psyche.js";function O(e,t){return{name:t.name,label:t.label,role:t.role,currentTask:e?.currentTask,lastUtterance:e?.lastUtterance,blockedOn:e?.blockedOn,progress:e?.progress}}a(O,"ensureLiveView");function j(e){switch(e){case"pm":case"architect":return"plan";case"designer":case"data-analyst":case"researcher":return"research";case"developer":return"plan";case"reviewer":case"verifier":return"review";case"implementer":case"planner":return"plan";default:return"research"}}a(j,"getDefaultModeForRole");function D(e){const{state:t,teammates:r,tasks:s,mailboxMessages:i}=e,n=["You are a persistent teammate in an AgentTeam.","","Identity:",`  Label: ${t.identity.label}`,`  Name: ${t.identity.name}`,`  Role: ${t.identity.role}`,`  Mode: ${t.mode}`,`  Working directory: ${t.cwd}`,"","Mode rules:","  - research: read-only exploration and reporting","  - plan: read-only; produce a plan and wait for leader approval before executing","  - execute: sandboxed write inside your working directory","  - review: read-only review and feedback","","Team roster:",...r.map(o=>`  - ${o.identity.name} (${o.identity.role})`),"","Mention rules:","  - Use @Name mentions only for concrete handoffs.","  - Every mention must include the next-step task after the mention.","  - Do not ping another teammate without actionable work.","","Conversation history with the leader:"];if(t.messages.length===0)n.push("  (none yet)");else for(const o of t.messages){const h=o.direction==="leader"?"catui":t.identity.name;n.push(`${h}: ${o.content}`)}const l=s.filter(o=>o.ownerId===t.identity.id),p=s.filter(o=>o.status==="blocked"),d=s.filter(o=>o.status==="open").slice(0,8);if(n.push("","Shared team tasks:"),l.length===0&&p.length===0&&d.length===0)n.push("  (none)");else{if(l.length>0){n.push("  Claimed by you:");for(const o of l)n.push(`    ${f(o)}`)}if(p.length>0){n.push("  Blocked:");for(const o of p.slice(0,6))n.push(`    ${f(o)}`)}if(d.length>0){n.push("  Open:");for(const o of d)n.push(`    ${f(o)}`)}}if(n.push("","Recent team mailbox:"),i.length===0)n.push("  (none)");else for(const o of i){const h=o.teammateName,x=o.targetTeammateName?` -> ${o.targetTeammateName}`:"",$=typeof o.payload.content=="string"?o.payload.content:typeof o.payload.action=="string"?`${o.payload.action}`:JSON.stringify(o.payload);n.push(`  [${o.type}] ${h}${x}: ${$}`)}return n.push("","Respond to the leader's last message in your current mode."),n.join(`
+`)}a(D,"buildTeammatePrompt");async function E(e){const{teammate:t,taskDescription:r,soulManager:s}=e,i=t.state.harness;if(!i?.enabled)return;await F(i,t.state.cwd,r),t.state.harness=await A(i,t.state.cwd);const n=await S(s),l=M(t.state.harness.phase,t.state.identity.role,n,t.state.psycheOverrides);t.state.psyche=l;const p=W(l,t.state.harness.phase,t.state),d=await C(t.state.harness,t.state.cwd,r);return{psychePrompt:p,harnessInstructions:d,contextFiles:R(t.state.harness)}}a(E,"prepareHarnessTurn");async function S(e){const t=e;if(t?.getProfile)try{return(await t.getProfile())?.personality}catch{return}}a(S,"getSoulTraits");function G(e,t){const r=e.state.live,s=O(e.state.liveView,e.state.identity);switch(t.type){case"agent_start":e.state.live={phase:"starting",preview:"Sub-agent starting...",toolName:null,updatedAt:t.timestamp},e.state.liveView={...s,progress:"starting"};break;case"message_update":e.state.live={phase:t.text?"thinking":r?.phase??"thinking",preview:c(t.text||r?.preview||"",1200),toolName:r?.toolName??null,updatedAt:t.timestamp},e.state.liveView={...s,lastUtterance:c(m(t.text||r?.preview||""),200),progress:"thinking"};break;case"message_end":e.state.live={phase:"finishing",preview:c(t.text||r?.preview||"",1200),toolName:r?.toolName??null,updatedAt:t.timestamp},e.state.liveView={...s,lastUtterance:c(m(t.text||r?.preview||""),200),progress:"finishing"};break;case"tool_start":case"tool_update":case"tool_end":e.state.live={phase:"tool",preview:t.type==="tool_update"?c(String(t.partialResult??r?.preview??""),1200):r?.preview??"",toolName:t.toolName,updatedAt:t.timestamp},e.state.liveView={...s,progress:`tool:${t.toolName}`};break;case"agent_end":e.state.live={phase:t.success?"done":"error",preview:t.error??r?.preview??"",toolName:null,updatedAt:t.timestamp},e.state.liveView={...s,progress:t.success?"done":"error"};break}}a(G,"applyLiveEvent");function J(e){switch(e.mode){case"research":case"review":case"plan":return y(e.cwd);case"execute":return V(e);default:return y(e.cwd)}}a(J,"selectToolsForMode");function y(e){const t=P(e),r=g(e,{spawnHook:w()});return[...t.filter(s=>s.name!=="bash"),r]}a(y,"createReadOnlyToolsForCwd");function V(e){const t=_(e),r=N(e.cwd,{edit:{beforeWrite:t},write:{beforeWrite:t}}),s=g(e.cwd,{spawnHook:w({allowWritePath:a(i=>{try{return t(i),!0}catch{return!1}},"allowWritePath"),blockedMessage:"Write operations outside the teammate workspace are not allowed. Use /team:allow-path to grant a path prefix."})});return[...r.filter(i=>i.name!=="bash"),s]}a(V,"createSandboxedTools");function _(e){const t=u(e.cwd);return r=>{const s=u(r),i=e.getAllTeammates().find(n=>u(n.cwd)===t);if(!H(s,t)&&!(i&&e.isPathAllowed(i.identity.id,s)))throw new Error(`Write denied for ${s}. Team execute mode may only write inside ${t} unless the leader grants a path allowlist.`)}}a(_,"createWritePathGuard");function u(e){return v((k(e),e))}a(u,"normalizePath");function H(e,t){const r=b(t),s=b(e);return s===r||s.startsWith(`${r}/`)}a(H,"isWithinPath");function f(e){const t=e.ownerName?` owner:${e.ownerName}`:"",r=e.dependsOn.length?` deps:${e.dependsOn.join(",")}`:"",s=e.artifactPaths.length?` artifacts:${e.artifactPaths.join(",")}`:"",i=e.description?` - ${e.description}`:"";return`${e.id} [${e.status}]${t}${r}${s} ${e.title}${i}`}a(f,"formatTaskForPrompt");function Y(e){return c(m(e),160)}a(Y,"summarizeTask");function m(e){return e.replace(/\s+/g," ").trim()}a(m,"singleLine");function c(e,t){return e.length<=t?e:e.slice(e.length-t)}a(c,"tailText");function q(e){let t=e,r="";for(;t>0;)t--,r=String.fromCharCode(65+t%26)+r,t=Math.floor(t/26);return r||"A"}a(q,"labelFromIndex");function K(e){let t=0;for(const r of e.toUpperCase()){const s=r.charCodeAt(0);if(s<65||s>90)return 0;t=t*26+(s-64)}return t}a(K,"indexFromLabel");function Q(e){return e==="implementer"||e==="developer"}a(Q,"isBuilderRole");function b(e){return u(e).replace(/\\/g,"/").replace(/\/+$/,"").toLowerCase()}a(b,"normalizeForComparison");export{G as applyLiveEvent,D as buildTeammatePrompt,_ as createWritePathGuard,O as ensureLiveView,j as getDefaultModeForRole,K as indexFromLabel,Q as isBuilderRole,H as isWithinPath,q as labelFromIndex,u as normalizePath,E as prepareHarnessTurn,J as selectToolsForMode,m as singleLine,Y as summarizeTask,c as tailText};

package/dist/extensions/builtin/team/team-runtime.d.ts

@@ -0,0 +1,91 @@
+/**
+ * [WHO]: TeamRuntime - teammate registry, lifecycle, persistence, task/mailbox, permission, transcript, and send queue management
+ * [FROM]: Depends on ./team-types, stores, permissions, mailbox, transcript, team-runtime-helpers.ts, core/sub-agent/*, core/workspace/*
+ * [TO]: Consumed by index.ts
+ * [HERE]: extensions/builtin/team/team-runtime.ts
+ */
+import type { SubAgentEvent, SubAgentHandle } from "../../../core/sub-agent/index.js";
+import type { WorkspacePath } from "../../../core/workspace/index.js";
+import type { Model } from "@catui/ai/types";
+import { PermissionStore } from "./team-permissions.js";
+import { TeamMailbox } from "./team-mailbox.js";
+import { TeamTaskStore } from "./team-task-store.js";
+import type { PersistedTeammate, TeamTask, TeamTaskStatus, TeammateMode, TeamSpawnSpec, TeamSendResult } from "./team-types.js";
+export interface RuntimeTeammate {
+    state: PersistedTeammate;
+    abortController: AbortController;
+    currentTurnAbortController?: AbortController;
+    handle?: SubAgentHandle;
+    worktree?: WorkspacePath;
+}
+export interface TeamRuntimeOptions {
+    storageDir?: string;
+}
+export interface TeamSendOptions {
+    onEvent?: (event: TeamRuntimeEvent) => void;
+}
+export type TeamRuntimeEvent = {
+    type: "teammate_live";
+    teammate: PersistedTeammate;
+    event: SubAgentEvent;
+} | {
+    type: "teammate_status";
+    teammate: PersistedTeammate;
+    event: string;
+} | {
+    type: "harness_event";
+    teammate: PersistedTeammate;
+    event: string;
+};
+export declare class TeamRuntime {
+    private store;
+    private worktreeManager;
+    private subAgentRuntime;
+    private permissions;
+    private mailbox;
+    private tasks;
+    private transcripts;
+    private teammates;
+    private sendQueues;
+    private loaded;
+    private nameCounter;
+    private labelCounter;
+    private soulManager;
+    constructor(options?: TeamRuntimeOptions);
+    getPermissionStore(): PermissionStore;
+    getMailbox(): TeamMailbox;
+    getTaskStore(): TeamTaskStore;
+    setSoulManager(soulManager: unknown | undefined): void;
+    load(): Promise<void>;
+    spawn(spec: TeamSpawnSpec): Promise<PersistedTeammate>;
+    send(name: string, message: string, model?: Model<any>, options?: TeamSendOptions): Promise<TeamSendResult>;
+    stop(name: string): Promise<boolean>;
+    terminate(name: string): Promise<boolean>;
+    setMode(name: string, mode: TeammateMode): Promise<{
+        ok: boolean;
+        pending?: {
+            requestId: string;
+        };
+        error?: string;
+    }>;
+    approvePermission(requestId: string): boolean;
+    denyPermission(requestId: string): boolean;
+    addTask(title: string): Promise<TeamTask>;
+    claimTask(taskId: string, teammateName: string): Promise<TeamTask | undefined>;
+    updateTaskStatus(taskId: string, status: TeamTaskStatus): Promise<TeamTask | undefined>;
+    listTasks(): Promise<TeamTask[]>;
+    sendTeammateMail(fromName: string, toName: string, content: string): Promise<boolean>;
+    allowPath(teammateName: string, path: string): Promise<string | undefined>;
+    getAllTeammates(): PersistedTeammate[];
+    getTeammate(name: string): PersistedTeammate | undefined;
+    dispose(): Promise<void>;
+    private ensureLoaded;
+    private findByName;
+    private generateName;
+    private generateLabel;
+    private bumpNameCounter;
+    private bumpLabelCounter;
+    private detectWorkspaceType;
+    private selectTools;
+    private createWritePathGuard;
+}