pi-task-dispatcher 3.0.0 → 3.0.2

package/README.md

@@ -1,29 +1,29 @@
 # pi-task-dispatcher
 
-Supervised mechanical and engineering delegations for Pi.
+Supervised mechanical, assistant, engineering, and media-design delegations for Pi.
 
 Each delegation runs in an isolated, in-memory Pi RPC session. After every cohesive tool batch, a worker-side gate stops execution at a safe boundary and returns a bounded state report. The manager can then inspect the result and explicitly continue, revise, compact, checkpoint, cancel, or take over.
 
 ## Features
 
-- **Two worker roles:** mechanical execution and broader engineering work.
+- **Four worker roles:** prescribed mechanical execution, fallback assistant work, broader engineering, and media design.
 - **Enforced supervision:** a private parent-child IPC gate calls `ctx.abort()` after persisted tool results; pausing does not depend on the worker following a prompt.
 - **Explicit control:** continue, revise, recalculate, compact, checkpoint, cancel, or take over.
 - **Resumable context:** continuation uses the same in-memory worker session and completed tool results.
-- **Least privilege:** every start selects an exact Pi built-in worker-tool allowlist; delegation tools and unrelated discovered extensions are unavailable to the worker.
-- **Model agnostic:** both roles inherit Pi's active model and thinking level unless an explicit role override is configured.
+- **Least privilege:** every start selects an exact isolated-worker tool allowlist; delegation tools and unrelated discovered extensions are unavailable to the worker. Pi's built-in `codemode` extension loads only when explicitly selected.
+- **Model agnostic:** every role inherits Pi's active model and thinking level unless an explicit role override is configured.
 - **Formula-owned budgets:** the manager supplies semantic workload units, while the dispatcher calculates turn and time ceilings from workload, role, and delegated-model limits.
 - **Context insight:** boundary reports include worker context usage, compactions, turns, elapsed time, action counts, and recommendations.
 - **Recoverable reports:** the complete action ledger and worker text remain in structured tool details; bounded model-facing text retains recent actions plus both the beginning and ending of long reports.
-- **Deterministic UI:** tool renderers display task, current activity, elapsed time, context pressure, and terminal success/failure colors. A compact paused-state line appears in Pi's footer.
+- **Deterministic UI:** tool renderers display task, current activity, elapsed time, context pressure, and terminal success/failure colors. Pi's footer retains the latest state of every role invoked in the session.
 
 ## Requirements
 
-- Pi 1.0.3 or later
+- Pi 1.0.4 or later
 - Node.js 22.19.0 or later
 - One active, authenticated Pi model; optional role-specific models must also be available and authenticated
 
-The supervision gate requires the parent Pi process and child Pi CLI to run under Node.js with an inherited IPC channel. The dispatcher fails closed when that boundary cannot be established; it does not fall back to prompt-only supervision. Worker processes disable ordinary extension discovery and load only the generated supervision gate.
+The supervision gate requires the parent Pi process and child Pi CLI to run under Node.js with an inherited IPC channel. The dispatcher fails closed when that boundary cannot be established; it does not fall back to prompt-only supervision. Worker processes disable ordinary extension discovery and load the generated supervision gate plus Pi's built-in `codemode` extension only when that tool was explicitly selected.
 
 ## Installation
 
@@ -37,16 +37,31 @@ pi install npm:pi-task-dispatcher
 
 | Tool | Responsibility |
 | --- | --- |
-| `delegate_mechanical` | Start a supervised mechanic delegation. |
-| `delegate_engineering` | Start a supervised engineer delegation. |
+| `delegate_mechanical` | Execute prescribed work whose method and expected result are already known. |
+| `delegate_assistant` | Perform the user-requested work when no other worker role applies; the orchestrator does not perform that work directly. |
+| `delegate_engineering` | Investigate or implement uncertain, cross-component, or technically intensive work. |
+| `delegate_designer` | Create or edit image assets and process image, video, or audio files with available tools. |
 | `delegate_control` | Apply one explicit manager decision to a paused delegation. |
 | `delegate_status` | Recover the current or most recent state without changing it. |
 
 Only one live delegation is currently permitted. A terminal delegation may be inspected until a new one replaces it.
 
+## Choosing a role
+
+| Role | Selection rule |
+| --- | --- |
+| Mechanic | The method and expected result are known; execute exact steps. |
+| Assistant | When no other worker role applies, use `delegate_assistant` for the user-requested work instead of having the orchestrator perform it directly. |
+| Engineer | The cause, design, or implementation path is uncertain or spans components. |
+| Designer | The requested result is an image, video, audio, or related media asset or transformation. |
+
+The orchestrator retains responsibility for delegation decisions, worker supervision, integration of delegated results, and the final response.
+
+The designer can inspect images with `read`, use image models through `codemode`, and run explicitly selected command-line media programs through `bash` or `powershell`. Generated codemode images are runtime-temporary until the worker deliberately copies a selected output to the requested workspace destination and verifies it. Video and audio generation depends on explicitly available command-line programs or services; editing workflows can use programs such as `ffmpeg` when installed.
+
 ## Starting a delegation
 
-Both role tools require:
+Every role tool requires:
 
 - `task`: a self-contained objective, scope, constraints, and acceptance checks;
 - `tools`: the smallest exact allowlist selected from Pi's built-in tools and active for the main agent;
@@ -74,7 +89,7 @@ A workload unit is intentionally semantic:
 
 At least one investigation, change, or verification unit is required.
 
-Isolated workers accept `read`, `bash`, `powershell`, `edit`, `write`, `grep`, `find`, and `ls` when the selected tools are also active in the main Pi session. Extension tools are not supported because the child disables extension discovery.
+Isolated workers accept `read`, `bash`, `powershell`, `edit`, `write`, `grep`, `find`, `ls`, and `codemode` when the selected tools are also active in the main Pi session. `codemode` is loaded as an explicit Pi built-in while ordinary extension discovery remains disabled. Its scripts can call only the worker's callable tools and non-LLM model catalog; unrelated manager extensions and delegation tools remain unavailable.
 
 The current formula derives planned work turns from those units, applies a role factor and a bounded scale based on the selected delegated model's own context window, reserves two additional turns for synthesis or recovery, then derives active execution time from calculated turns plus expected long-running time. Administrative ceilings always win. Formula inputs and results are returned in every state report so they can be reviewed and recalculated. Time spent paused for manager deliberation does not consume the active execution budget.
 
@@ -91,6 +106,8 @@ A worker run proceeds as follows:
 
 An action batch can contain parallel tool calls from one worker response. Already-running tools are allowed to finish. The boundary prevents another productive model turn from starting without a manager decision.
 
+A tool-free response that reaches the model's output limit is retained as a recoverable paused state. Continuing resumes the same in-memory session so the worker can finish its truncated report; the dispatcher does not misreport that response as completed.
+
 ## Controlling a paused delegation
 
 `delegate_control` accepts these actions:
@@ -125,7 +142,7 @@ A paused result contains:
 - the delegated task and live command or tool activity while execution is running;
 - boundary sequence and current phase;
 - completed, failed, and potentially mutating action counts;
-- recent bounded activity labels;
+- recent bounded activity labels in completion order and image-output MIME/size metadata without retained base64 payloads;
 - active elapsed time and turns against calculated budgets;
 - context tokens, context window, percentage, and compaction counts;
 - a recommended next decision;
@@ -133,7 +150,7 @@ A paused result contains:
 
 The TUI renders the same structured state as a compact block. Expanding the tool result reveals bounded worker text. The complete action ledger and worker text remain in result details for state reconstruction rather than being discarded by display truncation.
 
-When paused, one unindented footer status appears below Pi's primary report. It shows the identity, active elapsed time, last activity, and context as percentage/window—for example, `10.3%/32k context`. The percentage and window both come from that delegation's selected model and live worker-session statistics, not from the main model.
+After the first worker state, one unindented, dim footer status remains below Pi's primary report and updates across worker lifecycle states. It retains the newest state observed for every invoked role, with the most recently updated role first and each entry ordered as identity, context, model, and thinking—for example, `engineer-2 · 10.3%/32k • model-name • medium | mechanic-1 · 8.1%/128k • smaller-model • low`. Each percentage and window comes from that delegation's own fresh worker session; a continuation accumulates context in the same job, while a new delegation starts a new context. Current or latest action details appear in the delegation or manager block rather than the footer.
 
 ## Worker compaction
 
@@ -155,6 +172,22 @@ The optional configuration file is `task-dispatcher.json` in Pi's agent director
 
 ```json
 {
+  "mechanic": {
+    "model": "provider/mechanic-model",
+    "thinking": "high"
+  },
+  "assistant": {
+    "model": "provider/assistant-model",
+    "thinking": "low"
+  },
+  "engineer": {
+    "model": "provider/engineer-model",
+    "thinking": "high"
+  },
+  "designer": {
+    "model": "provider/vision-model",
+    "thinking": "medium"
+  },
   "policy": {
     "absoluteMaxTurns": 96,
     "absoluteMaxSeconds": 7200,
@@ -164,7 +197,7 @@ The optional configuration file is `task-dispatcher.json` in Pi's agent director
 }
 ```
 
-Configuration is read for every new delegation. By default, both roles inherit the manager's active model and thinking level, so installation assumes no particular provider or model access. A role may optionally override `model` with `"provider/model"`, `thinking`, or both. Policy values are administrative failsafes, not ordinary task budgets.
+Configuration is read for every new delegation. By default, all roles inherit the manager's active model and thinking level, so installation assumes no particular provider or model access. Each role may optionally override `model` with `"provider/model"`, `thinking`, or both. Policy values are administrative failsafes, not ordinary task budgets.
 
 Version 3 intentionally ignores the version 2 fields `maxTurns`, `timeoutSeconds`, and `checkpointGraceSeconds`. Remove them from local configuration after migration.
 
@@ -175,6 +208,7 @@ Version 3 intentionally ignores the version 2 fields `maxTurns`, `timeoutSeconds
 - Session shutdown or extension reload disposes the child and runtime-controlled temporary files.
 - Worker process failures reject pending RPC operations and produce a failed state.
 - Worker role instructions and the supervision gate exist only in a runtime-controlled temporary directory.
+- The selected built-in `codemode` extension may create runtime-temporary image outputs; the designer must persist requested outputs explicitly before completion.
 - The worker uses `--no-session`; no worker session file is persisted.
 
 Process separation is not a security sandbox. Worker tools execute with the Pi host's operating-system permissions. Tool availability does not establish task scope or authorization.
@@ -186,7 +220,7 @@ npm run check
 npm run test:gate
 ```
 
-`check` runs static release invariants and deterministic fake-RPC lifecycle and renderer scenarios. The fake child verifies pause/resume, usage deltas, full action-ledger retention, intercepted prompts, missing-boundary failure, fail-closed timeouts, pre-aborted operations, partial argument rendering, stable repeated rendering, and manager-state transitions without a model request.
+`check` runs static release invariants and deterministic fake-RPC lifecycle and renderer scenarios. The fake child verifies all role registrations, pause/resume, output-limit recovery, usage deltas, nested codemode usage accounting, media metadata without base64 retention, persistent per-role footer state, full action-ledger retention, intercepted prompts, missing-boundary failure, fail-closed timeouts, pre-aborted operations, partial argument rendering, stable repeated rendering, and manager-state transitions without a model request.
 
-`test:gate` performs a small live model integration check with the active parent model exported by Pi through `PI_PROVIDER`, `PI_MODEL`, and `PI_REASONING_LEVEL`, falling back to Pi's configured default when those values are unavailable; it contains no provider or model assumption. Optional `PI_TASK_DISPATCHER_GATE_MODEL` and `PI_TASK_DISPATCHER_GATE_THINKING` overrides are available for explicit test matrices. The probe verifies that the private gate pauses after a read batch and that the same in-memory child can subsequently complete. It requires configured credentials and therefore is not a hermetic unit test.
+`test:gate` performs a small live model integration check with the active parent model exported by Pi through `PI_PROVIDER`, `PI_MODEL`, and `PI_REASONING_LEVEL`, falling back to Pi's configured default when those values are unavailable; it contains no provider or model assumption. Optional `PI_TASK_DISPATCHER_GATE_MODEL` and `PI_TASK_DISPATCHER_GATE_THINKING` overrides are available for explicit test matrices. The probe verifies selective built-in `codemode` loading, a private pause after its completed tool batch, and subsequent completion in the same in-memory child. It requires configured credentials and therefore is not a hermetic unit test.
 

package/extensions/task-dispatcher.ts

@@ -14,7 +14,7 @@ import {
 import { Text } from "@earendil-works/pi-tui";
 import { Type } from "typebox";
 
-type Role = "mechanic" | "engineer";
+type Role = "mechanic" | "assistant" | "engineer" | "designer";
 type ThinkingLevel = "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
 type JobStatus =
 	| "starting"
@@ -44,11 +44,9 @@ interface DispatcherPolicy {
 	noProgressSeconds: number;
 }
 
-interface DispatcherConfig {
-	mechanic: WorkerRoleConfig;
-	engineer: WorkerRoleConfig;
+type DispatcherConfig = Record<Role, WorkerRoleConfig> & {
 	policy: DispatcherPolicy;
-}
+};
 
 interface Workload {
 	investigationUnits: number;
@@ -82,6 +80,11 @@ interface UsageTotals {
 	};
 }
 
+interface WorkerMediaOutput {
+	mimeType: string;
+	bytes: number;
+}
+
 interface WorkerAction {
 	sequence: number;
 	toolCallId: string;
@@ -91,6 +94,9 @@ interface WorkerAction {
 	status: "running" | "completed" | "failed";
 	startedAt: number;
 	endedAt?: number;
+	completionSequence?: number;
+	parentToolCallId?: string;
+	mediaOutputs?: WorkerMediaOutput[];
 }
 
 interface ContextMetrics {
@@ -149,6 +155,7 @@ interface ParsedEvent {
 	errorMessage?: string;
 	willRetry?: boolean;
 	result?: {
+		content?: Array<{ type?: string; text?: string; data?: string; mimeType?: string }>;
 		usage?: EventUsage;
 		estimatedTokensAfter?: number;
 	};
@@ -168,6 +175,7 @@ interface ParsedEvent {
 	};
 	toolCallId?: string;
 	toolName?: string;
+	parentToolCallId?: string;
 	args?: unknown;
 	isError?: boolean;
 }
@@ -189,12 +197,15 @@ const WIDGET_ID = "pi-task-dispatcher-worker";
 const MODEL_TEXT_LIMIT = 5_000;
 const STDERR_LIMIT = 16_000;
 const THINKING_LEVELS = new Set<ThinkingLevel>(["off", "minimal", "low", "medium", "high", "xhigh", "max"]);
-const MUTATING_TOOLS = new Set(["edit", "write", "bash", "powershell"]);
-const ISOLATED_WORKER_TOOLS = new Set(["read", "bash", "powershell", "edit", "write", "grep", "find", "ls"]);
+const ROLES: Role[] = ["mechanic", "assistant", "engineer", "designer"];
+const MUTATING_TOOLS = new Set(["edit", "write", "bash", "powershell", "codemode"]);
+const ISOLATED_WORKER_TOOLS = new Set(["read", "bash", "powershell", "edit", "write", "grep", "find", "ls", "codemode"]);
 
 const DEFAULT_CONFIG: DispatcherConfig = {
 	mechanic: {},
+	assistant: {},
 	engineer: {},
+	designer: {},
 	policy: {
 		absoluteMaxTurns: 96,
 		absoluteMaxSeconds: 7_200,
@@ -206,13 +217,33 @@ const DEFAULT_CONFIG: DispatcherConfig = {
 const ROLE_PROMPTS: Record<Role, string> = {
 	mechanic: `You are the mechanical worker in a supervised delegated Pi task.
 Complete only the supplied bounded objective with the available tools. Work in cohesive tool batches. After each tool batch the dispatcher pauses you externally so the manager can inspect state. On continuation, use the existing tool results and continue without repeating completed work. Finish with a concise report containing status, files changed, checks, and unresolved items.`,
+	assistant: `You are the assistant worker in a supervised delegated Pi task.
+Complete only the supplied bounded, low-complexity objective. Apply limited interpretation or synthesis, but do not assume manager responsibilities, expand scope, or make architectural decisions. Work in cohesive tool batches. After each tool batch the dispatcher pauses you externally so the manager can inspect state. On continuation, use existing results without repeating completed work. Finish with a concise report containing outcome, evidence, changes, checks, and unresolved items.`,
 	engineer: `You are the engineering worker in a supervised delegated Pi task.
 Own only the supplied subtask while the caller retains integration responsibility. Investigate, implement, and verify in cohesive tool batches. After each tool batch the dispatcher pauses you externally so the manager can inspect state. On continuation, use the existing tool results and continue without repeating completed work. Finish with a concise report containing outcome, files changed, checks, decisions, and unresolved items.`,
+	designer: `You are the media designer worker in a supervised delegated Pi task.
+Own only the supplied image, video, audio, or media-asset objective while the caller retains integration responsibility. When available, use read for visual inputs, codemode image models for image generation or editing, and explicitly available command-line programs such as ffmpeg for media processing. Verify required executables before depending on them. Treat codemode-generated images as temporary until you copy the selected result to the requested workspace destination and verify it. Preserve source assets unless the task explicitly requires replacement. Work in cohesive tool batches; the dispatcher pauses after each batch. Finish with a concise report containing outputs, source files affected, tools used, checks, and unresolved items.`,
 };
 
 const ROLE_DESCRIPTIONS: Record<Role, string> = {
-	mechanic: "Start a supervised mechanical delegation. It pauses after each completed tool batch so the manager can inspect, continue, compact, revise, checkpoint, cancel, or take over.",
-	engineer: "Start a supervised engineering delegation. It pauses after each completed tool batch so the manager can inspect, continue, compact, revise, checkpoint, cancel, or take over.",
+	mechanic: "Start a supervised mechanical delegation for prescribed execution with a known method and result.",
+	assistant: "Start a supervised assistant delegation for a subtask you would otherwise perform directly, when no other worker role applies.",
+	engineer: "Start a supervised engineering delegation for uncertain, cross-component, or implementation-intensive work.",
+	designer: "Start a supervised media-design delegation for image generation or editing and command-line image, video, or audio processing.",
+};
+
+const ROLE_TOOL_NAMES: Record<Role, string> = {
+	mechanic: "delegate_mechanical",
+	assistant: "delegate_assistant",
+	engineer: "delegate_engineering",
+	designer: "delegate_designer",
+};
+
+const ROLE_LABELS: Record<Role, string> = {
+	mechanic: "↗ mechanic",
+	assistant: "↗ assistant",
+	engineer: "↗ engineer",
+	designer: "↗ designer",
 };
 
 const WorkloadSchema = Type.Object({
@@ -349,11 +380,11 @@ function calculateBudget(
 		Math.ceil(workload.investigationUnits * 1.25) +
 		Math.ceil(workload.changeUnits * 1.5) +
 		workload.verificationUnits;
-	const roleFactor = role === "engineer" ? 1.25 : 1;
+	const roleFactor = role === "engineer" || role === "designer" ? 1.25 : 1;
 	const contextScale = Math.max(0.75, Math.min(1.5, contextWindow / 400_000));
 	// Reserve two turns for synthesis or recovery after the planned tool-producing work.
 	const turns = Math.min(policy.absoluteMaxTurns, Math.max(6, Math.ceil(plannedTurns * roleFactor * contextScale) + 2));
-	const secondsPerTurn = role === "engineer" ? 50 : 30;
+	const secondsPerTurn = role === "engineer" || role === "designer" ? 50 : 30;
 	const seconds = Math.min(
 		policy.absoluteMaxSeconds,
 		Math.max(120, 30 + turns * secondsPerTurn + workload.expectedLongRunningSeconds),
@@ -365,13 +396,15 @@ function calculateBudget(
 function loadConfig(): DispatcherConfig {
 	const result: DispatcherConfig = {
 		mechanic: { ...DEFAULT_CONFIG.mechanic },
+		assistant: { ...DEFAULT_CONFIG.assistant },
 		engineer: { ...DEFAULT_CONFIG.engineer },
+		designer: { ...DEFAULT_CONFIG.designer },
 		policy: { ...DEFAULT_CONFIG.policy },
 	};
 	if (!fs.existsSync(CONFIG_PATH)) return result;
 	const parsed = JSON.parse(fs.readFileSync(CONFIG_PATH, "utf8")) as unknown;
 	if (!isRecord(parsed)) throw new Error(`${CONFIG_PATH} must contain an object`);
-	for (const role of ["mechanic", "engineer"] as const) {
+	for (const role of ROLES) {
 		const value = parsed[role];
 		if (value === undefined) continue;
 		if (!isRecord(value)) throw new Error(`"${role}" must be an object`);
@@ -486,6 +519,7 @@ class WorkerJob {
 	private stderr = "";
 	private requestSequence = 0;
 	private actionSequence = 0;
+	private completionSequence = 0;
 	private activeActions = new Map<string, WorkerAction>();
 	private pendingRequests = new Map<string, { resolve: (event: ParsedEvent) => void; reject: (error: Error) => void }>();
 	private settleWaiter: { resolve: () => void; reject: (error: Error) => void } | undefined;
@@ -543,6 +577,7 @@ class WorkerJob {
 			"--thinking", this.thinking,
 			...(this.tools.length > 0 ? ["--tools", this.tools.join(",")] : ["--no-tools"]),
 			"--append-system-prompt", rolePromptPath,
+			...(this.tools.includes("codemode") ? ["--extension", "builtin:codemode"] : []),
 			"--extension", gatePath,
 		];
 		const invocation = getDirectPiInvocation(args);
@@ -649,6 +684,12 @@ class WorkerJob {
 		const completed = this.actions.filter((action) => action.status === "completed").length;
 		const failed = this.actions.filter((action) => action.status === "failed").length;
 		const currentAction = [...this.actions].reverse().find((action) => action.status === "running");
+		// Present completed actions in actual completion order while retaining start order in the ledger.
+		const recentActions = this.actions
+			.filter((action) => action.status !== "running")
+			.sort((left, right) => (left.completionSequence ?? 0) - (right.completionSequence ?? 0))
+			.slice(-8)
+			.map((action) => ({ ...action, mediaOutputs: action.mediaOutputs?.map((output) => ({ ...output })) }));
 		return {
 			jobId: this.id,
 			role: this.role,
@@ -670,8 +711,8 @@ class WorkerJob {
 				failed,
 				mutations: this.actions.filter((action) => action.mutating).length,
 			},
-			recentActions: this.actions.slice(-8).map((action) => ({ ...action })),
-			actionLedger: this.actions.map((action) => ({ ...action })),
+			recentActions,
+			actionLedger: this.actions.map((action) => ({ ...action, mediaOutputs: action.mediaOutputs?.map((output) => ({ ...output })) })),
 			workerText: this.workerText,
 			workerTextDisplay: display.text,
 			workerTextTruncated: display.truncated,
@@ -789,6 +830,7 @@ class WorkerJob {
 				mutating: MUTATING_TOOLS.has(event.toolName),
 				status: "running",
 				startedAt: Date.now(),
+				parentToolCallId: event.parentToolCallId,
 			};
 			this.actions.push(action);
 			this.activeActions.set(action.toolCallId, action);
@@ -800,8 +842,19 @@ class WorkerJob {
 			if (action) {
 				action.status = event.isError ? "failed" : "completed";
 				action.endedAt = Date.now();
+				action.completionSequence = ++this.completionSequence;
+				const mediaOutputs = (event.result?.content ?? []).flatMap((part) =>
+					part.type === "image" && typeof part.mimeType === "string" && typeof part.data === "string"
+						? [{ mimeType: part.mimeType, bytes: Buffer.from(part.data, "base64").length }]
+						: []
+				);
+				if (mediaOutputs.length > 0) {
+					action.mediaOutputs = mediaOutputs;
+					action.label += ` · ${mediaOutputs.length} image${mediaOutputs.length === 1 ? "" : "s"}`;
+				}
 				this.activeActions.delete(event.toolCallId);
 			}
+			// Execution-end events carry each call's own usage before Pi merges nested usage into persistence.
 			addUsage(this.usage, event.result?.usage);
 			this.emitProgress();
 			return;
@@ -843,6 +896,7 @@ class WorkerJob {
 			this.recommendation = "wait for boundary";
 			onProgress(this.snapshot());
 			this.boundaryObserved = false;
+			this.lastStopReason = undefined;
 			this.settleWaiter = undefined;
 			const settled = new Promise<void>((resolve, reject) => {
 				this.settleWaiter = { resolve, reject };
@@ -863,7 +917,10 @@ class WorkerJob {
 				const operation = (async () => {
 					const prompt = await this.request("prompt", { type: "prompt", message }, this.operationTimeout(30_000));
 					if (!prompt.success) throw new Error(prompt.error || "Worker rejected the prompt.");
-					if (prompt.disposition === "handled") throw new Error("Worker prompt was intercepted by an input handler; no agent run started.");
+					if (!isRecord(prompt.data) || typeof prompt.data.disposition !== "string") {
+						throw new Error("Worker prompt response omitted its disposition.");
+					}
+					if (prompt.data.disposition === "handled") throw new Error("Worker prompt was intercepted by an input handler; no agent run started.");
 					await settled;
 				})();
 				await this.waitForSettlement(operation);
@@ -881,9 +938,17 @@ class WorkerJob {
 				this.commitActiveElapsed();
 			}
 			await this.refreshStats();
+			// Classify tool-free settlement while preserving output-limit responses for recovery.
 			if (!this.boundaryObserved) {
-				this.status = this.lastStopReason === "error" ? "failed" : "completed";
-				this.phase = this.status === "completed" ? "worker completed" : "worker model error";
+				if (this.lastStopReason === "length") {
+					this.status = "paused";
+					this.phase = "worker response reached its output limit";
+					this.recommendation = "continue to recover the truncated response, revise, checkpoint, cancel, or take over";
+					this.schedulePausedLease();
+					return this.snapshot();
+				}
+				this.status = this.lastStopReason === "stop" ? "completed" : "failed";
+				this.phase = this.status === "completed" ? "worker completed" : `worker stopped with ${this.lastStopReason ?? "no final reason"}`;
 				this.recommendation = this.status === "completed" ? "review and integrate" : "inspect failure";
 				const snapshot = this.snapshot();
 				await this.dispose();
@@ -1051,6 +1116,7 @@ class WorkerJob {
 
 let activeJob: WorkerJob | undefined;
 let lastSnapshot: WorkerSnapshot | undefined;
+const latestRoleSnapshots = new Map<Role, WorkerSnapshot>();
 const reportedUsage = new Map<string, UsageTotals>();
 
 /** Resolve role overrides against the active parent model without assuming provider availability. */
@@ -1075,18 +1141,18 @@ function resolveWorkerConfig(config: WorkerRoleConfig, ctx: ExtensionToolContext
 	};
 }
 
-/** Restrict delegations to active, non-recursive built-in tools selected by the manager. */
+/** Restrict delegations to active, non-recursive isolated-worker tools selected by the manager. */
 function validateDelegatedTools(requested: string[], pi: ExtensionAPI): string[] {
 	const tools = [...new Set(requested.map((tool) => tool.trim()).filter(Boolean))];
-	const forbidden = new Set(["delegate_mechanical", "delegate_engineering", "delegate_control", "delegate_status"]);
+	const forbidden = new Set([...Object.values(ROLE_TOOL_NAMES), "delegate_control", "delegate_status"]);
 	const recursive = tools.filter((tool) => forbidden.has(tool));
 	if (recursive.length > 0) throw new Error(`Delegation tools cannot be delegated: ${recursive.join(", ")}`);
 	const active = new Set(pi.getActiveTools());
 	const unavailable = tools.filter((tool) => !active.has(tool));
 	if (unavailable.length > 0) throw new Error(`Delegated tools are not active for the manager: ${unavailable.join(", ")}`);
-	const extensionTools = tools.filter((tool) => !ISOLATED_WORKER_TOOLS.has(tool));
-	if (extensionTools.length > 0) {
-		throw new Error(`Isolated workers accept Pi built-in tools only; extension tools require a future explicit extension mapping: ${extensionTools.join(", ")}`);
+	const unsupportedTools = tools.filter((tool) => !ISOLATED_WORKER_TOOLS.has(tool));
+	if (unsupportedTools.length > 0) {
+		throw new Error(`Isolated workers do not support these tools: ${unsupportedTools.join(", ")}`);
 	}
 	return tools;
 }
@@ -1132,18 +1198,22 @@ function formatSnapshot(snapshot: WorkerSnapshot): string {
 	].filter(Boolean).join("\n");
 }
 
-/** Keep one unindented paused-state line in Pi's footer, below its primary report. */
+/** Keep one unindented footer line with the most recent state observed for every invoked role. */
 function updateWorkerStatus(ctx: ExtensionToolContext, snapshot: WorkerSnapshot): void {
+	latestRoleSnapshots.delete(snapshot.role);
+	latestRoleSnapshots.set(snapshot.role, snapshot);
 	if (!ctx.hasUI) return;
 	// Clear the pre-3.1 editor widget if this extension was reloaded in place.
 	ctx.ui.setWidget(WIDGET_ID, undefined);
-	if (snapshot.status !== "paused") {
-		ctx.ui.setStatus(WIDGET_ID, undefined);
-		return;
-	}
-	const latest = snapshot.currentActivity ?? snapshot.recentActions.at(-1)?.label;
-	const activity = latest ? ` · ${latest}` : "";
-	ctx.ui.setStatus(WIDGET_ID, `Paused ${snapshot.jobId} · ${formatElapsed(snapshot.durationMs)} · ${formatContext(snapshot)}${activity}`);
+	const status = [...latestRoleSnapshots.values()]
+		.reverse()
+		.map((roleSnapshot) => {
+			const model = roleSnapshot.model.slice(roleSnapshot.model.indexOf("/") + 1);
+			const context = formatContext(roleSnapshot).replace(/ context$/, "");
+			return `${roleSnapshot.jobId} · ${context} • ${model} • ${roleSnapshot.thinking}`;
+		})
+		.join(" | ");
+	ctx.ui.setStatus(WIDGET_ID, ctx.ui.theme.fg("dim", status));
 }
 
 /** Obtain mutable state shared by call/result renderers, including during partial argument streaming. */
@@ -1202,10 +1272,12 @@ function renderWorkerResult(
 	rendererState(context).snapshot = snapshot;
 	const color = snapshot.status === "paused" ? "warning" : snapshot.status === "completed" ? "success" : isTerminal(snapshot.status) && snapshot.status !== "completed" ? "error" : "accent";
 	const elapsedLabel = isPartial ? "Elapsed" : "Took";
+	const latestActivity = snapshot.currentActivity ?? snapshot.recentActions.at(-1)?.label;
+	const activityLabel = snapshot.currentActivity ? "Now" : "Last";
 	const lines = [
 		standalone ? theme.fg(color, theme.bold(`${snapshot.jobId}: ${snapshot.status}`)) : "",
 		standalone ? theme.fg("muted", `Task: ${snapshot.taskDisplay}`) : "",
-		snapshot.currentActivity ? theme.fg("warning", `Now: ${snapshot.currentActivity}`) : "",
+		latestActivity ? theme.fg(snapshot.currentActivity ? "warning" : "muted", `${activityLabel}: ${latestActivity}`) : "",
 		theme.fg("dim", `${snapshot.phase} · boundary ${snapshot.sequence} · turn ${snapshot.turns}/${snapshot.budget.turns}`),
 		theme.fg("muted", `${snapshot.actionCounts.completed} actions complete · ${snapshot.actionCounts.failed} failed · ${formatContext(snapshot)}`),
 		theme.fg("accent", snapshot.recommendation),
@@ -1234,13 +1306,16 @@ function snapshotResult(snapshot: WorkerSnapshot, isError = false): { content: A
 
 /** Register one role-specific supervised worker starter. */
 function registerDelegate(pi: ExtensionAPI, role: Role): void {
-	const name = role === "mechanic" ? "delegate_mechanical" : "delegate_engineering";
+	const name = ROLE_TOOL_NAMES[role];
 	pi.registerTool({
 		name,
-		label: role === "mechanic" ? "↗ mechanic" : "↗ engineer",
+		label: ROLE_LABELS[role],
 		description: ROLE_DESCRIPTIONS[role],
 		promptSnippet: `${name}: start a supervised ${role} delegation that pauses after each completed action batch`,
 		promptGuidelines: [
+			...(role === "assistant"
+				? ["When no other worker role applies, use delegate_assistant for the user-requested work instead of performing it directly. Retain delegation decisions, worker supervision, result integration, and the final response."]
+				: []),
 			"Supply semantic workload units rather than raw turn or timeout values.",
 			"Inspect every paused state and choose continue, revise, recalculate, compact, checkpoint, cancel, or take over.",
 			"Worker reports remain evidence to review, not proof of correctness.",
@@ -1280,6 +1355,7 @@ function registerDelegate(pi: ExtensionAPI, role: Role): void {
 				const job = new WorkerJob(role, params.task, tools, resolved.role, ctx.cwd, config.policy, budget);
 				activeJob = job;
 				const progress = (snapshot: WorkerSnapshot) => {
+					updateWorkerStatus(ctx, snapshot);
 					onUpdate?.({ content: [{ type: "text", text: formatSnapshot(snapshot) }], details: snapshot });
 				};
 				const snapshot = await job.start(signal, progress);
@@ -1346,6 +1422,7 @@ function registerControl(pi: ExtensionAPI): void {
 					if (params.action === "revise" && !params.instructions) throw new Error("revise requires instructions");
 					const progress = (state: WorkerSnapshot) => {
 						state.managerAction = params.action;
+						updateWorkerStatus(ctx, state);
 						onUpdate?.({ content: [{ type: "text", text: formatSnapshot(state) }], details: state });
 					};
 					snapshot = await job.continue(params.action === "revise" ? params.instructions : undefined, params.actionBatches ?? 1, signal, progress);
@@ -1395,8 +1472,7 @@ function registerStatus(pi: ExtensionAPI): void {
 /** Register only in the parent process and clean every live child when the session shuts down. */
 export default function taskDispatcher(pi: ExtensionAPI): void {
 	if (process.env[WORKER_ENV]) return;
-	registerDelegate(pi, "mechanic");
-	registerDelegate(pi, "engineer");
+	for (const role of ROLES) registerDelegate(pi, role);
 	registerControl(pi);
 	registerStatus(pi);
 	pi.on("session_shutdown", async () => {

package/package.json

@@ -1,50 +1,50 @@
-{
-  "name": "pi-task-dispatcher",
-  "version": "3.0.0",
-  "description": "Run configurable Pi worker models as supervised, observable, resumable jobs.",
-  "type": "module",
-  "keywords": [
-    "pi-package",
-    "pi-extension",
-    "delegation",
-    "subagent",
-    "model-routing"
-  ],
-  "author": "SorinGFS",
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/soringfs/pi-task-dispatcher.git"
-  },
-  "homepage": "https://github.com/soringfs/pi-task-dispatcher#readme",
-  "bugs": {
-    "url": "https://github.com/soringfs/pi-task-dispatcher/issues"
-  },
-  "engines": {
-    "node": ">=22.19.0"
-  },
-  "scripts": {
-    "test:gate": "node tests/gate-probe.mjs",
-    "test:fake-rpc": "node tests/fake-rpc-check.mjs",
-    "check": "node tests/static-check.mjs && node tests/fake-rpc-check.mjs"
-  },
-  "peerDependencies": {
-    "@earendil-works/pi-coding-agent": "*",
-    "@earendil-works/pi-tui": "*",
-    "typebox": "*"
-  },
-  "pi": {
-    "extensions": [
-      "./extensions/task-dispatcher.ts"
-    ]
-  },
-  "files": [
-    "extensions",
-    "tests",
-    "README.md",
-    "LICENSE"
-  ],
-  "publishConfig": {
-    "access": "public"
-  }
-}
+{
+  "name": "pi-task-dispatcher",
+  "version": "3.0.2",
+  "description": "Run configurable Pi worker models as supervised, observable, resumable jobs.",
+  "type": "module",
+  "keywords": [
+    "pi-package",
+    "pi-extension",
+    "delegation",
+    "subagent",
+    "model-routing"
+  ],
+  "author": "SorinGFS",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/soringfs/pi-task-dispatcher.git"
+  },
+  "homepage": "https://github.com/soringfs/pi-task-dispatcher#readme",
+  "bugs": {
+    "url": "https://github.com/soringfs/pi-task-dispatcher/issues"
+  },
+  "engines": {
+    "node": ">=22.19.0"
+  },
+  "scripts": {
+    "test:gate": "node tests/gate-probe.mjs",
+    "test:fake-rpc": "node tests/fake-rpc-check.mjs",
+    "check": "node tests/static-check.mjs && node tests/fake-rpc-check.mjs"
+  },
+  "peerDependencies": {
+    "@earendil-works/pi-coding-agent": "*",
+    "@earendil-works/pi-tui": "*",
+    "typebox": "*"
+  },
+  "pi": {
+    "extensions": [
+      "./extensions/task-dispatcher.ts"
+    ]
+  },
+  "files": [
+    "extensions",
+    "tests",
+    "README.md",
+    "LICENSE"
+  ],
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/tests/fake-rpc-check.mjs

@@ -42,18 +42,23 @@ try {
 	const handlers = new Map();
 	const pi = {
 		registerTool(tool) { tools.set(tool.name, tool); },
-		getActiveTools() { return ["read", "bash", "edit", "write"]; },
+		getActiveTools() { return ["read", "bash", "edit", "write", "codemode"]; },
 		on(event, handler) { handlers.set(event, handler); },
 	};
 	register(pi);
 
 	const activeModel = { provider: "fake-provider", id: "active-model", contextWindow: 272_000, maxTokens: 128_000 };
+	const statusUpdates = [];
 	const context = {
 		cwd: projectRoot,
-		hasUI: false,
+		hasUI: true,
 		model: activeModel,
 		thinkingLevel: "medium",
-		ui: { setWidget() {}, setStatus() {} },
+		ui: {
+			theme: { fg(_color, text) { return text; } },
+			setWidget() {},
+			setStatus(key, text) { statusUpdates.push({ key, text }); },
+		},
 		modelRegistry: {
 			find(provider, id) { return { provider, id, contextWindow: 272_000, maxTokens: 128_000 }; },
 			hasConfiguredAuth() { return true; },
@@ -61,8 +66,10 @@ try {
 	};
 	const workload = { investigationUnits: 1, changeUnits: 0, verificationUnits: 1, expectedLongRunningSeconds: 0 };
 	const start = tools.get("delegate_engineering");
+	const designerStart = tools.get("delegate_designer");
 	const control = tools.get("delegate_control");
-	assert(start && control, "Expected supervised tools to register.");
+	assert(start && designerStart && control, "Expected supervised tools to register.");
+	assert(tools.has("delegate_mechanical") && tools.has("delegate_assistant"), "Expected every worker role to register.");
 	const theme = { fg(_color, text) { return text; }, bold(text) { return text; } };
 	let rendererInvalidations = 0;
 	const renderContext = { args: {}, state: {}, invalidate() { rendererInvalidations++; }, cwd: projectRoot };
@@ -83,7 +90,9 @@ try {
 	assert.equal(result.usage.output, 3);
 	assert.equal(result.usage.totalTokens, 16);
 	const partialRender = start.renderResult(result, { expanded: false, isPartial: true }, theme, renderContext).render(100).join("\n");
+	assert.match(partialRender, /Last: read package\.json/);
 	assert.match(partialRender, /Elapsed:/);
+	assert.equal(statusUpdates.at(-1)?.text, "engineer-1 · 11.0%/1k • active-model • medium");
 	const resultComponent = start.renderResult(result, { expanded: false, isPartial: false }, theme, renderContext);
 	const firstRender = resultComponent.render(100).join("\n");
 	assert.match(firstRender, /Took:/);
@@ -109,10 +118,66 @@ try {
 	assert.equal(result.details.workerText, "deterministic worker complete");
 	assert.equal(result.usage.input, 5, "Continuation must return only newly observed usage.");
 	assert.equal(result.usage.totalTokens, 8);
+	assert.equal(statusUpdates.at(-1)?.text, "engineer-1 · 12.0%/1k • active-model • medium");
+	assert(!statusUpdates.some((update) => update.text === undefined), "Worker status must remain visible after it first appears.");
 	control.renderResult(result, { expanded: false, isPartial: false }, theme, managerRenderContext).render(100);
 	assert.match(managerCall.render(100).join("\n"), /manager: engineer-1 → completed/);
 	assert.doesNotMatch(managerCall.render(100).join("\n"), /continue\/completed/);
 
+	// The designer must load only the selected built-in codemode extension and account nested usage once.
+	await writeFile(configPath, JSON.stringify({ designer: { model: "media-provider/media-model", thinking: "high" } }), "utf8");
+	process.env.PI_TASK_DISPATCHER_FAKE_SCENARIO = "codemode";
+	result = await designerStart.execute("start-designer", { task: "fake image job", tools: ["read", "codemode"], workload }, undefined, undefined, context);
+	assert.equal(result.isError, false);
+	assert.equal(result.details.status, "paused");
+	assert.equal(result.details.role, "designer");
+	assert.equal(result.details.model, "media-provider/media-model");
+	assert.equal(result.details.thinking, "high");
+	assert.equal(result.details.actionLedger.length, 2);
+	assert.equal(result.details.actionCounts.mutations, 1);
+	assert.equal(result.details.recentActions.at(-1).toolName, "codemode");
+	assert.deepEqual(result.details.recentActions.at(-1).mediaOutputs, [{ mimeType: "image/png", bytes: 4 }]);
+	assert.match(result.details.recentActions.at(-1).label, /1 image/);
+	assert.doesNotMatch(JSON.stringify(result.details), /ZmFrZQ==/, "Snapshots must not retain base64 media payloads.");
+	assert.equal(result.usage.input, 20, "Each nested and parent execution must contribute its own pre-merge usage exactly once.");
+	assert.equal(result.usage.output, 6);
+	assert.equal(result.usage.totalTokens, 26);
+	assert.equal(
+		statusUpdates.at(-1)?.text,
+		"designer-2 · 11.0%/1k • media-model • high | engineer-1 · 12.0%/1k • active-model • medium",
+		"Starting another role must retain the previous role's footer status.",
+	);
+	result = await control.execute(
+		"continue-designer",
+		{ jobId: result.details.jobId, action: "continue", actionBatches: 1 },
+		undefined,
+		undefined,
+		context,
+	);
+	assert.equal(result.details.status, "completed");
+	assert.match(statusUpdates.at(-1)?.text ?? "", /designer-2.*\|.*engineer-1/);
+	await writeFile(configPath, "{}\n", "utf8");
+
+	// A tool-free output-limit stop must preserve the session so the manager can recover the report.
+	process.env.PI_TASK_DISPATCHER_FAKE_SCENARIO = "length";
+	result = await start.execute("start-length", { task: "fake truncated job", tools: ["read"], workload }, undefined, undefined, context);
+	assert.equal(result.isError, false);
+	assert.equal(result.details.status, "paused");
+	assert.equal(result.details.turns, 1);
+	assert.equal(result.details.workerText, "truncated worker report");
+	assert.match(result.details.phase, /output limit/i);
+	assert.match(result.details.recommendation, /continue to recover/i);
+	result = await control.execute(
+		"continue-length",
+		{ jobId: result.details.jobId, action: "continue", actionBatches: 1 },
+		undefined,
+		undefined,
+		context,
+	);
+	assert.equal(result.isError, false);
+	assert.equal(result.details.status, "completed");
+	assert.equal(result.details.workerText, "deterministic worker complete");
+
 	// A handled prompt starts no agent run and must fail promptly rather than waiting for settlement.
 	process.env.PI_TASK_DISPATCHER_FAKE_SCENARIO = "handled";
 	const handledStartedAt = Date.now();

package/tests/fake-rpc-worker.mjs

@@ -50,18 +50,60 @@ readline.createInterface({ input: process.stdin }).on("line", async (line) => {
 	if (markerPath) await appendFile(markerPath, `${promptCount}\n`, "utf8");
 	if (scenario === "timeout") return;
 	if (scenario === "handled") {
-		send({ type: "response", id: command.id, command: command.type, success: true, disposition: "handled" });
+		send({ type: "response", id: command.id, command: command.type, success: true, data: { disposition: "handled" } });
 		return;
 	}
 
-	send({ type: "response", id: command.id, command: command.type, success: true, disposition: "started" });
+	if (scenario === "codemode" && promptCount === 1) {
+		const toolsIndex = process.argv.indexOf("--tools");
+		const selectedTools = toolsIndex >= 0 ? process.argv[toolsIndex + 1]?.split(",") ?? [] : [];
+		const extensionValues = process.argv.flatMap((argument, index) => argument === "--extension" ? [process.argv[index + 1]] : []);
+		if (!selectedTools.includes("codemode") || !extensionValues.includes("builtin:codemode")) {
+			send({ type: "response", id: command.id, command: command.type, success: false, error: "codemode was not isolated and loaded" });
+			return;
+		}
+	}
+
+	send({ type: "response", id: command.id, command: command.type, success: true, data: { disposition: "started" } });
+	if (scenario === "length" && promptCount === 1) {
+		send({
+			type: "message_end",
+			message: {
+				role: "assistant",
+				stopReason: "length",
+				content: [{ type: "text", text: "truncated worker report" }],
+				usage: usage(7, 4),
+			},
+		});
+		send({ type: "agent_settled" });
+		return;
+	}
 	if (promptCount === 1) {
 		send({
 			type: "message_end",
 			message: { role: "assistant", stopReason: "toolUse", content: [], usage: usage(10, 2) },
 		});
-		send({ type: "tool_execution_start", toolCallId: "fake-read-1", toolName: "read", args: { path: "package.json" } });
-		send({ type: "tool_execution_end", toolCallId: "fake-read-1", toolName: "read", isError: false, result: { usage: usage(3, 1) } });
+		if (scenario === "codemode") {
+			send({ type: "tool_execution_start", toolCallId: "fake-codemode-1", toolName: "codemode", args: "return image" });
+			send({ type: "tool_execution_start", toolCallId: "fake-read-nested", parentToolCallId: "fake-codemode-1", toolName: "read", args: { path: "reference.png" } });
+			send({ type: "tool_execution_end", toolCallId: "fake-read-nested", parentToolCallId: "fake-codemode-1", toolName: "read", isError: false, result: { usage: usage(3, 1) } });
+			send({
+				type: "tool_execution_end",
+				toolCallId: "fake-codemode-1",
+				toolName: "codemode",
+				isError: false,
+				result: {
+					content: [
+						{ type: "text", text: "generated image retained in runtime temporary storage" },
+						{ type: "image", data: "ZmFrZQ==", mimeType: "image/png" },
+					],
+					usage: usage(7, 3),
+				},
+			});
+		} else {
+			send({ type: "tool_execution_start", toolCallId: "fake-read-1", toolName: "read", args: { path: "package.json" } });
+			send({ type: "tool_execution_end", toolCallId: "fake-read-1", toolName: "read", isError: false, result: { usage: usage(3, 1) } });
+		}
 		if (scenario === "missing-boundary") {
 			send({
 				type: "message_end",

package/tests/gate-probe.mjs

@@ -1,5 +1,5 @@
 /**
- * Verify that a worker-side turn boundary can abort Pi after a completed tool batch while keeping the RPC child reusable.
+ * Verify supervised codemode loading and a reusable worker-side boundary after one completed tool batch.
  */
 
 import { spawn } from "node:child_process";
@@ -55,7 +55,9 @@ export default function (pi: ExtensionAPI): void {
 		"--no-session",
 		"--no-extensions",
 		"--tools",
-		"read",
+		"codemode",
+		"--extension",
+		"builtin:codemode",
 		"--extension",
 		gatePath,
 	];
@@ -92,11 +94,11 @@ export default function (pi: ExtensionAPI): void {
 	});
 	child.on("message", (message) => boundaries.push(message));
 
-	// Run one tool batch and require the gate to settle the run before a productive follow-up turn.
+	// Run one codemode batch and require the gate to settle before a productive follow-up turn.
 	child.stdin.write(`${JSON.stringify({
 		id: "probe-1",
 		type: "prompt",
-		message: "Read package.json exactly once. Do not use any other tool. After reading it, report only its package name.",
+		message: "Call codemode exactly once with the raw JavaScript source: text('pi-task-dispatcher-codemode-ready')\nDo not use any other tool and do not add other script statements.",
 	})}\n`);
 	await Promise.race([
 		settled,
@@ -109,6 +111,9 @@ export default function (pi: ExtensionAPI): void {
 	if (!firstAssistantMessages.some((event) => event.message?.stopReason === "toolUse")) {
 		throw new Error("The first run did not execute the expected tool-use turn.");
 	}
+	if (!events.some((event) => event.type === "tool_execution_end" && event.toolName === "codemode" && !event.isError)) {
+		throw new Error("The isolated worker did not complete the selected built-in codemode tool.");
+	}
 
 	// Continue in the same in-memory RPC session and require a normal final answer without another tool batch.
 	events.length = 0;
@@ -118,7 +123,7 @@ export default function (pi: ExtensionAPI): void {
 	child.stdin.write(`${JSON.stringify({
 		id: "probe-2",
 		type: "prompt",
-		message: "Continue from the completed read. Do not call tools. Report only the package name.",
+		message: "Continue from the completed codemode result. Do not call tools. Report only the exact marker produced by the script.",
 	})}\n`);
 	await Promise.race([
 		settled,
@@ -132,7 +137,7 @@ export default function (pi: ExtensionAPI): void {
 		.map((part) => part.text)
 		.join("\n")
 		.trim();
-	if (!finalText.includes("pi-task-dispatcher")) throw new Error(`Unexpected continuation output: ${finalText}`);
+	if (!finalText.includes("pi-task-dispatcher-codemode-ready")) throw new Error(`Unexpected continuation output: ${finalText}`);
 
 	console.log(JSON.stringify({ firstBoundaryCount, firstAssistantMessages: firstAssistantMessages.length, finalText }, null, 2));
 	if (stderr.trim()) console.error(stderr.trim());

package/tests/static-check.mjs

@@ -21,8 +21,13 @@ if (!source.includes("let model = ctx.model")) throw new Error("Role defaults no
 
 // Require the supervised protocol and its externally enforced gate in every v3 candidate.
 for (const required of [
+	"delegate_mechanical",
+	"delegate_assistant",
+	"delegate_engineering",
+	"delegate_designer",
 	"delegate_control",
 	"delegate_status",
+	"builtin:codemode",
 	"task_dispatcher_boundary",
 	"without an enforced IPC boundary",
 	"--no-extensions",