@aragon-agent/cli 0.5.2 → 0.5.4

package/dist/agent/controller.js

@@ -9,10 +9,14 @@
  * from the event stream by the reducer (TUI) and the headless writer.
  */
 import { Agent, initProviders, ModelRegistry, } from '@aragon-agent/core';
-import { isAdapterProvider } from '../config/schema.js';
+import { clampTeamConfig, isAdapterProvider } from '../config/schema.js';
 import { makeGetApiKey } from '../config/load.js';
 import { updatePersistedConfig } from '../config/store.js';
 import { createBuiltinTools } from '../tools/index.js';
+import { TeamRuntime } from '../team/runtime.js';
+import { TeamHumanQueue } from '../team/human-queue.js';
+import { createTaskTool } from '../team/task-tool.js';
+import { buildTeamBlock } from '../team/prompt.js';
 import { createPlanTools } from '../tools/plan-tools.js';
 import { DENY_ALL_HUMAN_INPUT } from '../tools/human-input.js';
 import { createNodeSkillHost } from '../skills/node-host.js';
@@ -48,6 +52,25 @@ export class AgentController {
     askRounds = 0;
     /** Static: whether this session could ever render a question overlay. */
     planInteractive;
+    // -----------------------------------------------------------------------
+    // Team mode (team-subagents §4.5) — TWO FLAGS, AND THEY ARE NOT THE SAME.
+    //
+    // `teamRegistered` is decided ONCE, at construction, and can never change:
+    // it is whether the `task` tool is in `this.tools` at all. The array is
+    // immutable for the life of the session (see the note in the constructor),
+    // so `/team on` in a session started with `--no-team` CANNOT add it.
+    //
+    // `teamEnabled` is live. `/team off` flips it, which makes `task` refuse
+    // through its own guard and drops `<team_mode>` from the next prompt rebuild
+    // — `rebuildSystemPrompt()` IS a live path, unlike the tool array.
+    //
+    // Conflating them is P0-2: the prompt would advertise a tool that was never
+    // registered, every call would come back "unknown tool", and the model would
+    // have no way to discover why (D-17 / R-18).
+    // -----------------------------------------------------------------------
+    teamRegistered;
+    teamEnabled;
+    teamRuntime;
     constructor(config, deps = {}) {
         this.config = config;
         this.cwd = config.cwd;
@@ -81,6 +104,40 @@ export class AgentController {
             this.skills.reportUnknownForcedSkills();
         }
         const confirm = deps.confirm;
+        // --- Team mode ---------------------------------------------------------
+        this.teamRegistered = config.team.enabled;
+        this.teamEnabled = config.team.enabled;
+        this.teamRuntime = this.teamRegistered
+            ? new TeamRuntime({
+                getConfig: () => this.config,
+                providerRegistry: this.providerRegistry,
+                getCwd: () => this.cwd,
+                getMode: () => this.effectiveMode,
+                getApiKey: (id) => this.resolveKey(id),
+                // `skill_find` only, and the lead's always-on bodies. See the long
+                // note in `subagent.ts` for why `skill` itself is withheld (D-16).
+                ...(this.skillsEnabled
+                    ? {
+                        skillRegistry: this.skills.getRegistry(),
+                        alwaysBlock: () => this.skills.alwaysBlock(),
+                        toolPolicy: () => this.skills.toolPolicyDecision(() => this.toolNames()),
+                        // Label-decorating, and it DOES NOT advance the lead's
+                        // escalation counter (P1-3). That counter exists to tell ONE
+                        // agent to stop retrying ONE tool; a child cannot retry the
+                        // lead's turn, and letting children spend the lead's budget
+                        // makes the escalation fire on the lead's next legitimate call.
+                        onChildToolPolicyEvent: (e) => deps.notify?.('warn', `[${e.label}] ${e.verdict.message ?? `Blocked ${e.tool}`}`),
+                    }
+                    : {}),
+                // NOT routed through `withHumanWait` (I-3, and this one is subtle):
+                // the lead's watchdog is ALREADY paused for the whole dispatch, and
+                // `IdleWatchdog.pause()` is a boolean rather than a counter — so a
+                // nested resume when one child's dialog closed would re-arm the lead
+                // mid-dispatch and abort it at `idleTimeoutMs`. The queue pauses the
+                // CHILD's watchdog instead, which is the one that needs it (P0-4).
+                ...(confirm ? { humanQueue: new TeamHumanQueue(confirm) } : {}),
+            })
+            : null;
         this.tools = createBuiltinTools({
             getCwd: () => this.cwd,
             confirmTools: config.confirmTools,
@@ -110,6 +167,27 @@ export class AgentController {
                 withHumanWait: (fn) => this.withHumanWait(fn),
                 onPlanApproved: () => this.setAgentMode('build', { force: true }),
             }),
+            // THROUGH THE FACTORY, NEVER APPENDED AFTERWARDS (D-15 / P0-1).
+            // `tools.test.ts::C7` asserts `HOST_TOOL_NAMES` equals what
+            // `createBuiltinTools` produces, so appending `task` here would turn that
+            // test red with a message about two lists of names.
+            //
+            // Empty when team mode was off at construction, which leaves the array
+            // byte-identical to the pre-team build (AC-11).
+            teamTools: this.teamRuntime
+                ? [
+                    createTaskTool({
+                        runtime: this.teamRuntime,
+                        // Read LIVE: `/team off` flips the flag, it cannot unregister.
+                        isTeamEnabled: () => this.teamEnabled,
+                        maxSubagents: () => this.config.team.maxSubagents,
+                        hasApiKey: () => this.hasApiKey(),
+                        activeProvider: () => this.config.provider,
+                        modelCost: () => this.getModelInfo().cost,
+                        withPausedWatchdog: (fn) => this.withPausedWatchdog(fn),
+                    }),
+                ]
+                : [],
             // Read at CALL time, never cached: the mode flips mid-run when the user
             // approves a plan, and a cached 'plan' would refuse the work they just
             // authorized.
@@ -149,6 +227,11 @@ export class AgentController {
                 toolTimeoutOverrides: {
                     ask_user: config.planModeHumanTimeoutMs,
                     submit_plan: config.planModeHumanTimeoutMs,
+                    // A fan-out is not a hung tool either. Like the two above, this
+                    // number only bites BECAUSE `task` races `ctx.signal` — the
+                    // executor's timeout is cooperative, so an override is inert for any
+                    // tool that does not listen (I-2).
+                    ...(this.teamRegistered ? { task: config.team.dispatchTimeoutMs } : {}),
                 },
             },
         });
@@ -193,6 +276,16 @@ export class AgentController {
             agentMode: this.effectiveMode,
             planInteractive: this.planInteractive,
             planMaxAskRounds: this.config.planModeMaxAskRounds,
+            // BOTH flags, and both are required (§4.5). `teamRegistered` false means
+            // there is no `task` tool to advertise; `teamEnabled` false means the user
+            // turned it off for this session. Advertising in either case would
+            // describe a capability the model does not have.
+            teamBlock: this.teamRegistered && this.teamEnabled
+                ? buildTeamBlock({
+                    maxSubagents: this.config.team.maxSubagents,
+                    maxConcurrent: this.config.team.maxConcurrent,
+                })
+                : '',
         });
     }
     rebuildSystemPrompt() {
@@ -293,6 +386,13 @@ export class AgentController {
     }
     abort() {
         this.agent.abort();
+        // DELIBERATE REDUNDANCY (§3.8). Aborting the lead already aborts the
+        // in-flight `task` call's `ctx.signal`, which the runtime listens to — that
+        // path is correct today. Calling it directly as well makes "no child
+        // survives its dispatch" a property of THIS class rather than a consequence
+        // of signal plumbing three modules away, which is the same argument
+        // `App.tsx` records for `cancelPendingHuman()` on `agent_end`.
+        this.teamRuntime?.abortAll();
     }
     steer(text) {
         // Mid-run interjection: promote the queue, keep what is already in force
@@ -393,8 +493,19 @@ export class AgentController {
      * path must not leave the watchdog disarmed for the rest of the run. Also used
      * by the `--confirm` gate, which had exactly this bug — a user who took four
      * minutes over `Proceed? (y/N)` had their run killed by the watchdog.
+     *
+     * RENAMED FROM `withHumanWait`, WITH THE OLD NAME KEPT AS AN ALIAS (D-12). The
+     * mechanism is not about humans any more — a `task` dispatch is a long wait
+     * with no human in it at all — but the plan tools and the `--confirm` gate read
+     * correctly with the old name at their call sites, and renaming those would be
+     * churn in files this change should barely touch.
+     *
+     * NOT RE-ENTRANT, and that matters here: `IdleWatchdog.pause()` sets a boolean
+     * rather than a counter, so a nested call's `finally` re-arms the watchdog
+     * while the outer wait is still going. That is why a child's `--confirm`
+     * dialog does NOT route through this (see the constructor's `humanQueue`).
      */
-    async withHumanWait(fn) {
+    async withPausedWatchdog(fn) {
         this.agent.pauseIdleWatchdog();
         try {
             return await fn();
@@ -403,6 +514,70 @@ export class AgentController {
             this.agent.resumeIdleWatchdog();
         }
     }
+    /** @see withPausedWatchdog — the name the plan tools and `--confirm` use. */
+    withHumanWait(fn) {
+        return this.withPausedWatchdog(fn);
+    }
+    // -----------------------------------------------------------------------
+    // Team mode (team-subagents §4.5)
+    // -----------------------------------------------------------------------
+    /** Whether `task` is in `this.tools`. Fixed at construction; see the fields. */
+    isTeamRegistered() {
+        return this.teamRegistered;
+    }
+    /** Whether `task` will actually dispatch. Flipped live by `/team on|off`. */
+    isTeamEnabled() {
+        return this.teamEnabled;
+    }
+    /**
+     * Flip the live switch and re-render the prompt.
+     *
+     * Turning it ON in a session that started with `--no-team` deliberately does
+     * NOT register the tool (D-17): the array is immutable, and advertising an
+     * unregistered tool is the dead end P0-2 is about. `/team` reports that
+     * honestly by checking `isTeamRegistered()` first.
+     */
+    setTeamEnabled(enabled) {
+        this.teamEnabled = enabled;
+        this.rebuildSystemPrompt();
+    }
+    getTeamConfig() {
+        return this.config.team;
+    }
+    /**
+     * Adopt a new team config for this session and re-render the prompt (the block
+     * quotes the numbers). Clamped here as well as on the persist path, so a bad
+     * value can never reach the runtime.
+     */
+    setTeamConfig(patch) {
+        const team = clampTeamConfig({ ...this.config.team, ...patch });
+        this.config = { ...this.config, team };
+        this.rebuildSystemPrompt();
+        return team;
+    }
+    /** Refused mid-dispatch by `/team`; half a dispatch under two ceilings is not
+     *  a result anything can afterwards explain (the reasoning `/reload` uses). */
+    isTeamBusy() {
+        return this.teamRuntime?.isBusy() ?? false;
+    }
+    getTeamSnapshot() {
+        return this.teamRuntime?.snapshot() ?? null;
+    }
+    /**
+     * Subscribe to the CLI-local team event stream.
+     *
+     * Returns a no-op unsubscribe when team mode was off at construction, so every
+     * caller can subscribe unconditionally.
+     */
+    subscribeTeam(listener) {
+        if (!this.teamRuntime)
+            return () => { };
+        return this.teamRuntime.subscribe(listener);
+    }
+    /** Abort every child and clear timers. Idempotent; safe to call twice. */
+    dispose() {
+        this.teamRuntime?.dispose();
+    }
     // -----------------------------------------------------------------------
     // Mutators
     // -----------------------------------------------------------------------

package/dist/agent/headless.d.ts

@@ -6,12 +6,24 @@
  */
 import type { AgentEvent, ModelInfo } from '@aragon-agent/core';
 import type { PreflightResult } from './controller.js';
+import type { TeamEvent } from '../team/types.js';
 /** The minimal controller surface headless mode needs (real or stubbed). */
 export interface HeadlessController {
     preflight(): PreflightResult;
     subscribe(listener: (event: AgentEvent) => void): () => void;
     prompt(text: string): Promise<void>;
     getModelInfo(): ModelInfo;
+    /**
+     * The CLI-local team stream — OPTIONAL, deliberately (team-subagents §3.12 /
+     * P1-6).
+     *
+     * This interface is minimal so tests can satisfy it with an object literal.
+     * Making the member REQUIRED would break every existing stub for no benefit,
+     * and the subscription genuinely is optional: a controller with no team
+     * runtime has no team events. `runHeadless` calls it with `?.`, which keeps
+     * the `--no-team` headless path byte-identical to today's.
+     */
+    subscribeTeam?(listener: (event: TeamEvent) => void): () => void;
 }
 export interface HeadlessOptions {
     quiet?: boolean;

package/dist/agent/headless.js

@@ -4,7 +4,7 @@
  * derived from the event stream (R2), not from the resolved promise:
  *   0 = success, 1 = agent error (incl. a silently-swallowed throw), 2 = config.
  */
-import { formatCost, formatTokens, computeCost } from './usage.js';
+import { formatCost, formatTokens, formatDuration, computeCost } from './usage.js';
 import { formatStreamError } from './reducer.js';
 /** Run a single prompt headlessly and resolve with the process exit code. */
 export async function runHeadless(controller, prompt, options = {}) {
@@ -57,11 +57,51 @@ export async function runHeadless(controller, prompt, options = {}) {
                 break;
         }
     });
+    // Team mode is ON in headless: a fan-out needs no human (§3.12). What the
+    // children's spend must NOT do is vanish from the footer — the `[usage]` line
+    // is the only cost readout `-p` has, and a dispatch is where most of the
+    // tokens go.
+    const started = new Set();
+    const finished = new Set();
+    const unsubscribeTeam = controller.subscribeTeam?.((event) => {
+        if (event.type === 'usage') {
+            total.inputTokens += event.usage.inputTokens;
+            total.outputTokens += event.usage.outputTokens;
+            return;
+        }
+        if (quiet)
+            return;
+        if (event.type === 'dispatch_start') {
+            err.write(`\n[team] dispatch ${event.specs.length} subagents\n`);
+            return;
+        }
+        if (event.type === 'agent_update') {
+            const { run } = event;
+            if (run.phase !== 'queued' && !started.has(run.label)) {
+                started.add(run.label);
+                err.write(`[team] ${run.label} start "${run.description}"\n`);
+            }
+            const terminal = run.phase === 'done' || run.phase === 'failed' || run.phase === 'aborted';
+            if (terminal && !finished.has(run.label)) {
+                finished.add(run.label);
+                const ms = Math.max(0, (run.endedAt ?? 0) - (run.startedAt ?? 0));
+                const verdict = run.phase === 'done' && !run.error ? 'ok' : run.phase;
+                err.write(`[team] ${run.label} ${verdict} ${formatDuration(ms)} ${run.toolCalls} tools\n`);
+            }
+            return;
+        }
+        if (event.type === 'dispatch_end') {
+            const ok = event.outcome.runs.filter((r) => r.phase === 'done' && !r.error).length;
+            err.write(`[team] done ${ok}/${event.outcome.runs.length} ok` +
+                `${event.outcome.aborted ? ' (aborted)' : ''}\n`);
+        }
+    });
     try {
         await controller.prompt(prompt);
     }
     finally {
         unsubscribe();
+        unsubscribeTeam?.();
     }
     // Ensure a trailing newline so piped output is well-formed.
     if (wroteText)

package/dist/agent/reducer.d.ts

@@ -12,6 +12,7 @@
  */
 import type { AgentEvent, ModelCost, ToolResult, TokenUsage } from '@aragon-agent/core';
 import type { AgentMode } from './agent-mode.js';
+import type { DispatchOutcome, SubagentRun, SubagentSpec, TeamSnapshot } from '../team/types.js';
 export type NoticeLevel = 'info' | 'warn' | 'error';
 export type ToastLevel = NoticeLevel | 'success';
 export type Overlay = null | 'settings' | 'model' | 'help' | 'confirm' | 'question' | 'plan';
@@ -55,6 +56,28 @@ export type Entry = {
     kind: 'notice';
     level: NoticeLevel;
     text: string;
+}
+/**
+ * A team dispatch (team-subagents §5.3). JSON-SERIALIZABLE by construction, so
+ * `/save` and `/resume` need no format change.
+ *
+ * `active: true` is normalized away ON LOAD, in `session/persist.ts`, not here
+ * (P1-5). A session saved mid-dispatch would otherwise resume with a card that
+ * claims to be running while nothing is: it spins forever, and because
+ * `Transcript`'s settled boundary is MONOTONIC an entry that never settles
+ * never reaches `<Static>` and is re-rendered on every frame for the rest of
+ * the session. The reducer never legitimately sees a stale-active entry — only
+ * the file does — which is why the fix belongs in the load path.
+ */
+ | {
+    id: string;
+    kind: 'team';
+    dispatchId: string;
+    requested: number;
+    runs: SubagentRun[];
+    aborted: boolean;
+    durationMs?: number;
+    active: boolean;
 };
 export interface UsageTotal {
     inputTokens: number;
@@ -81,7 +104,17 @@ export interface ViewState {
     agentMode: AgentMode;
     /** Set only by a DEFERRED `plan -> build`; drives the `PLAN -> BUILD` readout. */
     pendingAgentMode: AgentMode | null;
+    /**
+     * The live team roster, or `null` when no dispatch is running.
+     *
+     * NEVER PERSISTED. `/save` writes `entries`, and the settled `team` entry is
+     * the history; this field is the ephemeral panel, and a resumed session has no
+     * live dispatch to show (§6.4).
+     */
+    team: TeamSnapshot | null;
     seq: number;
+    /** The `kind: 'team'` entry the live dispatch is writing into. */
+    teamEntryId?: string;
     streamingId?: string;
     turnProduced: boolean;
     errorNoticed: boolean;
@@ -165,6 +198,21 @@ export type ViewAction = {
     type: 'setAgentMode';
     mode: AgentMode;
     pending: AgentMode | null;
+} | {
+    type: 'teamStart';
+    dispatchId: string;
+    requested: number;
+    specs: SubagentSpec[];
+} | {
+    type: 'teamUpdate';
+    snapshot: TeamSnapshot;
+} | {
+    type: 'teamUsage';
+    usage: TokenUsage;
+    costDelta: number;
+} | {
+    type: 'teamEnd';
+    outcome: DispatchOutcome;
 };
 export declare const STORED_PREVIEW_CHARS = 8000;
 export declare const STORED_PREVIEW_LINES = 200;

package/dist/agent/reducer.js

@@ -27,7 +27,9 @@ export function initialViewState() {
         // `controller.getAgentMode()` so `--plan` renders on the first frame.
         agentMode: 'build',
         pendingAgentMode: null,
+        team: null,
         seq: 0,
+        teamEntryId: undefined,
         streamingId: undefined,
         turnProduced: false,
         errorNoticed: false,
@@ -367,8 +369,17 @@ export function viewReducer(state, action) {
                 entries: mapEntry(state.entries, state.streamingId, (e) => e.kind === 'assistant' ? { ...e, streaming: false, aborted: true } : e),
             };
         }
+        // `teamEntryId` is dropped with the entries it pointed at. Keeping it would
+        // leave `teamUpdate` mapping an id that no longer exists — harmless today,
+        // and a dangling reference the next reader has to reason about.
         case 'clearTranscript':
-            return { ...state, entries: [], streamingId: undefined, expandedToolIds: {} };
+            return {
+                ...state,
+                entries: [],
+                streamingId: undefined,
+                expandedToolIds: {},
+                teamEntryId: undefined,
+            };
         case 'resetConversation':
             return {
                 ...state,
@@ -377,6 +388,7 @@ export function viewReducer(state, action) {
                 expandedToolIds: {},
                 contextTokens: 0,
                 usageTotal: { inputTokens: 0, outputTokens: 0, costUsd: 0 },
+                teamEntryId: undefined,
             };
         case 'setOverlay':
             return { ...state, overlay: action.overlay };
@@ -407,13 +419,90 @@ export function viewReducer(state, action) {
                 next[action.id] = true;
             return { ...state, expandedToolIds: next };
         }
+        // --- Team mode (team-subagents §5.3) ---------------------------------
+        case 'teamStart': {
+            const { id, seq } = nextId(state);
+            const runs = action.specs.map((spec) => ({
+                label: spec.label,
+                description: spec.description,
+                phase: 'queued',
+                turns: 0,
+                toolCalls: 0,
+                usage: { inputTokens: 0, outputTokens: 0 },
+                filesTouched: [],
+                messagesSent: 0,
+            }));
+            const entry = {
+                id,
+                kind: 'team',
+                dispatchId: action.dispatchId,
+                requested: action.requested,
+                runs,
+                aborted: false,
+                active: true,
+            };
+            return {
+                ...state,
+                seq,
+                entries: [...state.entries, entry],
+                teamEntryId: id,
+                team: {
+                    dispatchId: action.dispatchId,
+                    active: true,
+                    runs,
+                    requested: action.requested,
+                    startedAt: Date.now(),
+                    messageCount: 0,
+                },
+            };
+        }
+        case 'teamUpdate': {
+            // One `mapEntry` on the KNOWN id, never a scan: this action arrives at up
+            // to `maxConcurrent` x 8/s and a reverse search over a long transcript on
+            // every one of them is exactly the cost the coalescer exists to avoid.
+            const entries = state.teamEntryId
+                ? mapEntry(state.entries, state.teamEntryId, (e) => e.kind === 'team' ? { ...e, runs: action.snapshot.runs } : e)
+                : state.entries;
+            return { ...state, entries, team: action.snapshot };
+        }
+        case 'teamUsage':
+            // `usageTotal` AND NOTHING ELSE (§3.9 / AC-15). In particular NOT
+            // `contextTokens`: that gauge shows the LEAD's context occupancy against
+            // the model's window, and folding five children into it would read 180%
+            // on a perfectly healthy session. Child spend is real money and has to
+            // appear in the cost readout; it is not the lead's context.
+            return {
+                ...state,
+                usageTotal: {
+                    inputTokens: state.usageTotal.inputTokens + action.usage.inputTokens,
+                    outputTokens: state.usageTotal.outputTokens + action.usage.outputTokens,
+                    costUsd: state.usageTotal.costUsd + action.costDelta,
+                },
+            };
+        case 'teamEnd': {
+            const { outcome } = action;
+            const entries = state.teamEntryId
+                ? mapEntry(state.entries, state.teamEntryId, (e) => e.kind === 'team'
+                    ? {
+                        ...e,
+                        runs: outcome.runs,
+                        aborted: outcome.aborted,
+                        durationMs: Math.max(0, outcome.endedAt - outcome.startedAt),
+                        active: false,
+                    }
+                    : e)
+                : state.entries;
+            // `team: null` is what makes the panel disappear — the requirement's
+            // "(dang you de shi hou)": it renders only while a dispatch is running.
+            return { ...state, entries, team: null, teamEntryId: undefined };
+        }
         case 'restoreEntries': {
             // Adopt a seq beyond any restored id to keep future ids unique.
             const maxSeq = action.entries.reduce((acc, e) => {
                 const n = Number.parseInt(e.id.replace(/^e/, ''), 10);
                 return Number.isFinite(n) ? Math.max(acc, n) : acc;
             }, state.seq);
-            return { ...state, entries: [...action.entries], seq: maxSeq };
+            return { ...state, entries: [...action.entries], seq: maxSeq, teamEntryId: undefined };
         }
         default:
             return state;

package/dist/agent/system-prompt.d.ts

@@ -36,6 +36,23 @@ export interface SystemPromptParams {
     planInteractive?: boolean;
     /** `planModeMaxAskRounds`, substituted into the block so the two agree. */
     planMaxAskRounds?: number;
+    /**
+     * The rendered `<team_mode>` block for a LEAD with team mode on, or `''`.
+     *
+     * Spliced conditionally exactly as `skillsBlock` and the plan block are, which
+     * is what keeps invariant I-8 true: `team.enabled: false` (and `--no-team`)
+     * produce the pre-team prompt BYTE FOR BYTE.
+     */
+    teamBlock?: string;
+    /**
+     * The rendered `<subagent_role>` block for a CHILD, or `''`.
+     *
+     * Never set together with `teamBlock`: a child has no `task` tool (D-3), and a
+     * lead is not a subagent. Two fields rather than one because the two blocks
+     * carry opposite instructions and a single "team text" parameter would make
+     * mixing them a one-character mistake.
+     */
+    subagentBlock?: string;
 }
 /** Describe the active shell so the model does not emit incompatible syntax. */
 export declare function describeShell(): {

package/dist/agent/system-prompt.js

@@ -37,6 +37,8 @@ export function buildSystemPrompt(params) {
             maxAskRounds: params.planMaxAskRounds ?? 4,
         })
         : '';
+    const teamBlock = params.teamBlock ?? '';
+    const subagentBlock = params.subagentBlock ?? '';
     return [
         'You are AragonAgent, an autonomous coding assistant operating inside a terminal (TUI).',
         'You help the user accomplish software-engineering tasks by reasoning step by step and using the provided tools.',
@@ -50,6 +52,8 @@ export function buildSystemPrompt(params) {
         toolList,
         ...(hasSkills ? ['', skillsBlock] : []),
         ...(planBlock ? ['', planBlock] : []),
+        ...(teamBlock ? ['', teamBlock] : []),
+        ...(subagentBlock ? ['', subagentBlock] : []),
         '',
         'Operating guidance:',
         '- Prefer reading files and inspecting the workspace before making changes.',