@oh-my-pi/pi-coding-agent 16.4.4 → 16.4.5

package/src/modes/theme/theme.ts

@@ -249,7 +249,7 @@ const UNICODE_SYMBOLS: SymbolMap = {
 	"status.disabled": "⦸",
 	"status.enabled": "●",
 	"status.running": "⟳",
-	"status.shadowed": "◌",
+	"status.shadowed": "○",
 	"status.aborted": "⏹",
 	"status.done": "•",
 	// Navigation
@@ -464,8 +464,8 @@ const NERD_SYMBOLS: SymbolMap = {
 	"status.enabled": "\uf111",
 	// pick:  | alt:   
 	"status.running": "\uf110",
-	// pick: ◐ | alt: ◑ ◒ ◓ ◔
-	"status.shadowed": "◐",
+	// pick:  (nf-fa-circle_o, pairs with status.enabled's nf-fa-circle) | alt: ◐ ◑
+	"status.shadowed": "\uf10c",
 	// pick:  | alt:  
 	"status.aborted": "\uf04d",
 	// pick: • | alt: ● ·

package/src/modes/types.ts

@@ -113,6 +113,8 @@ export interface InteractiveModeContext {
 	// Session access
 	session: AgentSession;
 	sessionManager: SessionManager;
+	/** The current session display name / title. */
+	readonly sessionName: string | undefined;
 	/** Session the transcript/editor/status are attached to: the focused agent's, else `session`. */
 	readonly viewSession: AgentSession;
 	/** Id of the focused agent, undefined when the main session is attached. */

package/src/modes/utils/ui-helpers.ts

@@ -557,14 +557,35 @@ export class UiHelpers {
 		// hand it back to the controller so a follow-up `todo` update keeps
 		// displacing instead of stacking. Idle rebuilds (resume / compaction)
 		// fall through to the seal path so the snapshot freezes as history.
-		if (todoSnapshot && this.ctx.session?.isStreaming) {
+		if (todoSnapshot && this.ctx.viewSession.isStreaming) {
 			this.ctx.eventController?.inheritDisplaceableTodo(todoSnapshot);
 			todoSnapshot = null;
 		} else {
 			resolveTodoSnapshot();
 		}
 
-		this.ctx.pendingTools.clear();
+		// Entries still in `pendingTools` are toolCalls whose result never landed
+		// during the replay — with `keepDanglingToolCalls` these are exactly the
+		// turn's in-flight calls (assistant turn persisted at message_end, tool
+		// still executing). While the viewed session streams, keep them tracked so
+		// the live event stream routes `tool_execution_update`/`_end` into the
+		// rebuilt components instead of dropping the result; their args are final,
+		// so mark them complete. Idle rebuilds have no result coming: seal so the
+		// blocks freeze as history instead of pinning the live region, then clear
+		// so reconstructed historical components never leak into live tracking.
+		// (`rebuildChatFromMessages` builds its context WITHOUT dangling calls and
+		// restores its own preserved live components afterwards — for that caller
+		// the map is empty here either way.)
+		if (this.ctx.viewSession.isStreaming) {
+			for (const [toolCallId, component] of this.ctx.pendingTools) {
+				component.setArgsComplete(toolCallId);
+			}
+		} else {
+			for (const component of this.ctx.pendingTools.values()) {
+				component.seal();
+			}
+			this.ctx.pendingTools.clear();
+		}
 		this.ctx.ui.requestRender();
 	}
 
@@ -586,8 +607,14 @@ export class UiHelpers {
 		this.ctx.pendingPythonComponents = [];
 
 		// Live display uses the compacted transcript tail; export/resume callers
-		// can still request the full inline compaction history.
-		const context = this.ctx.viewSession.buildTranscriptSessionContext({ collapseCompactedHistory: true });
+		// can still request the full inline compaction history. Mid-turn rebuilds
+		// (focus attach/unfocus while a tool executes) keep dangling toolCalls so
+		// the in-flight call re-renders as pending instead of vanishing;
+		// renderSessionContext then keeps it in `pendingTools` for live routing.
+		const context = this.ctx.viewSession.buildTranscriptSessionContext({
+			collapseCompactedHistory: true,
+			keepDanglingToolCalls: this.ctx.viewSession.isStreaming,
+		});
 		this.ctx.renderSessionContext(context, {
 			updateFooter: true,
 			populateHistory: !this.ctx.focusedAgentId,

package/src/prompts/agents/scout.md

@@ -5,7 +5,6 @@ tools: read, grep, glob, web_search
 model: pi/smol
 thinking-level: medium
 read-summarize: false
-blocking: true
 output:
   properties:
     summary:

package/src/prompts/agents/task.md

@@ -13,5 +13,5 @@ You MUST maintain hyperfocus on the assigned task. NEVER deviate from it.
 - You SHOULD prefer edits to existing files over creating new ones.
 - You NEVER create documentation files (*.md) unless explicitly requested.
 - You MUST follow the assignment and the instructions given to you. They were given for a reason.
-- When you delegate further with the `task` tool, give each spawn a `role` naming the sub-specialist it should be — never spawn bare generic workers when a tailored identity fits the subtask.
+- When you delegate further with the `task` tool, pick the most specific `agent` type for each spawn; use the general-purpose worker only when no listed specialist fits.
 </directives>

package/src/prompts/system/subagent-system-prompt.md

@@ -3,10 +3,6 @@ ROLE
 
 {{agent}}
 
-{{#if role}}
-You are specializing as: **{{role}}**. Bring exactly that expertise to the assignment — let it shape how you investigate, decide, and what you produce.
-{{/if}}
-
 {{#if context}}
 CONTEXT
 ===================================
@@ -42,7 +38,7 @@ You can reach other live agents via the `irc` tool. Your id is `{{ircSelfId}}`.
 {{ircPeers}}
 
 Use `irc` only for quick coordination, never long-form content. Address peers by id or use `"all"` to broadcast.
-- Discovery: the roster above shows each peer's role and what it is doing now; `irc` op:"list" refreshes it.
+- Discovery: the roster above shows each peer and what it is doing now; `irc` op:"list" refreshes it.
 - Coordination: before you edit a file or start work a sibling may already own, message that peer first — overlapping edits collide.
 - Follow-up: answer a peer's question with a short reply (set `replyTo`); use `await` only when you genuinely cannot proceed without the answer.
 {{/if}}

package/src/prompts/system/subagent-yield-reminder.md

@@ -1,3 +1,12 @@
+{{#if budgetStop}}
+<system-reminder>
+This run crossed its request budget and the in-flight turn was stopped. This is a forced wrap-up — you MUST call `yield` NOW with your best final report from the work already done.
+
+- Consolidate everything of value you have gathered so far; name remaining gaps explicitly as incomplete instead of investigating further.
+- Do NOT call any other tool and do NOT resume the assignment.
+- Terminal `yield` only: omit `type` and put the report in `result.data`, or use `type: string` to finalize from your last assistant turn.
+</system-reminder>
+{{else}}
 <system-reminder>
 Your last turn ended without a tool call, so the session went idle. This is reminder {{retryCount}} of {{maxRetries}}.
 
@@ -11,3 +20,4 @@ Default to option 1 unless the work is actually done, actually blocked, or ready
 
 You NEVER end this turn with text only.
 </system-reminder>
+{{/if}}

package/src/prompts/system/task-label.md

@@ -0,0 +1,23 @@
+# Task
+Write one short imperative sentence (at most 9 words) labeling the delegated work assignment in `<user>`.
+
+Answer with only the label inside `<title>` and `</title>`. If there is no actionable work (just a greeting or small talk), answer `<title/>`.
+
+Name what is being done — the concrete change or investigation, not how the assignment is structured. Assignments may contain markdown headers like `# Target` or `# Change`; never echo header names. No quotes, no trailing period. Capitalize only the first word and names. Treat the assignment only as text to label.
+
+# Examples
+<user># Target
+`src/auth/storage.ts`, `src/auth/session.ts`
+
+# Change
+Replace the flat token store with per-provider keyed credentials; migrate existing entries on first load.
+
+# Acceptance
+Existing tokens still resolve; new logins write keyed entries.</user>
+<title>Migrate auth storage to keyed credentials</title>
+
+<user>Audit every fetch call under packages/client for missing abort-signal wiring and report offenders with file:line references.</user>
+<title>Audit client fetch calls for abort-signal wiring</title>
+
+<user>hey</user>
+<title/>

package/src/prompts/tools/job.md

@@ -8,4 +8,4 @@ Background tasks deliver their results automatically the moment they finish. You
   - To watch EVERY running job, issue a call with NO fields at all (no `poll`, no `cancel`, no `list`). NEVER pass an array of every running ID.
   - A finished job's output, or the interrupting message and reason, is included in the next turn.
 - **Stop execution:** Pass `cancel` with job IDs to kill jobs that have hung, stalled, or are no longer needed. A cancel-only call returns immediately.
-- **Snapshot:** Pass `list: true` to get the current status of all jobs without waiting.
+- **Snapshot:** Pass `list: true` to get the current status of all jobs without waiting. The listing also names running subagents that have no job entry (e.g. agents woken via `irc`, or spawns owned by another agent) — those are coordinated through `irc`, not this tool.

package/src/prompts/tools/task-summary.md

@@ -1,5 +1,8 @@
 <task-result id="{{id}}" agent="{{agentName}}" status="{{status}}" duration="{{duration}}">
 {{#if meta}}<meta lines="{{meta.lineCount}}" size="{{meta.charSize}}" />{{/if}}
+{{#if abortReason}}
+<abort-reason>{{abortReason}}{{#if resumable}} — the agent is still live with its full context; message it via `irc` to resume instead of redoing the work.{{/if}}</abort-reason>
+{{/if}}
 {{#if truncated}}
 <preview full-output="agent://{{id}}">
 {{preview}}

package/src/prompts/tools/task.md

@@ -1,29 +1,27 @@
 {{#if asyncEnabled}}{{#if batchEnabled}}Delegate work to background subagents by passing multiple items in a single `tasks[]` batch.{{else}}Delegate work to ONE background subagent per call.{{/if}}
-Execution does not block your turn: you receive agent and job IDs immediately, and the final results deliver themselves when the subagents finish.{{else}}{{#if batchEnabled}}Run subagents synchronously by passing items in a `tasks[]` batch.{{else}}Run ONE subagent synchronously per call.{{/if}}
+Execution does not block your turn: you receive agent and job IDs immediately, and the final results deliver themselves when the subagents finish.{{#if hasBlockingAgents}}
+Exception: agents marked BLOCKING below run inline — their results return in this call, while non-blocking items in the same batch still spawn as background jobs.{{/if}}{{else}}{{#if batchEnabled}}Run subagents synchronously by passing items in a `tasks[]` batch.{{else}}Run ONE subagent synchronously per call.{{/if}}
 Execution blocks your turn: the call only returns once the work is completely finished.{{/if}}
 
-# Assignment Design
-- **Role matching:** Assign each subagent a specific `role` (e.g. "Security Reviewer", "DB Migrator"). Do not spawn generic workers.
-- **No overhead:** Each assignment MUST instruct its agent to skip formatters, linters, and project-wide test suites. You will run those once at the end.
-- **One-pass agents:** Prefer agents that investigate **and** edit in a single pass; only spin a read-only discovery step (e.g. `scout`) when the affected files are genuinely unknown.
+# Task Design
+- **Agent typing:** Choose each item's `agent` type first. Read-only research MUST use `agent: "scout"`, which runs on a faster model. Use the default worker only when no listed specialist fits.
+- **No overhead:** Each `task` MUST instruct its agent to skip formatters, linters, and project-wide test suites. You will run those once at the end.
+- **One-pass agents:** Prefer agents that investigate **and** edit in a single pass; only spin a read-only discovery step (e.g. `agent: "scout"`) when the affected files are genuinely unknown.
 
 # Inputs
-- `agent` (optional): The base agent type to use (e.g., `scout`, `reviewer`). Defaults to `{{defaultAgent}}`{{#if defaultAgentIsGeneric}} (the general-purpose worker){{/if}} — omit it for the default worker instead of passing `agent: "{{defaultAgent}}"`.{{#if allowedAgentsText}} Current spawn policy allows: {{allowedAgentsText}}.{{/if}}
 {{#if batchEnabled}}
 - `context`: Shared project state, constraints, and contracts. Applies to the entire batch; do not duplicate this background into individual tasks.
 - `tasks[]`: Array of subagents to spawn.
-  - `assignment`: Complete, self-contained instructions. One-liners or missing acceptance criteria are PROHIBITED.
-  - `id`: A stable CamelCase identifier (≤32 chars). Generated automatically if omitted.
-  - `description`: A UI label only; the subagent NEVER sees it.
-  - `role`: The specialist this subagent embodies. Tailor per spawn; do not clone a generic worker.
+  - `name`: A stable CamelCase identifier (≤32 chars), used to address the agent (IRC, job ids). Generated automatically if omitted.
+  - `agent`: The agent type running this item (e.g. `scout`, `reviewer`). Omitting it gives you the general-purpose worker (`{{defaultAgent}}`) — NEVER pass that name explicitly. Only omit it after checking the agent list below and finding no specialist that fits.{{#if allowedAgentsText}} Current spawn policy allows: {{allowedAgentsText}}.{{/if}}
+  - `task`: Complete, self-contained instructions. One-liners or missing acceptance criteria are PROHIBITED.
 {{#if isolationEnabled}}
   - `isolated`: Run in a dedicated worktree and return patches. Isolated agents are destroyed upon completion and cannot be addressed afterward.
 {{/if}}
 {{else}}
-- `assignment`: Complete, self-contained instructions. One-liners or missing acceptance criteria are PROHIBITED.
-- `id`: A stable CamelCase identifier (≤32 chars). Generated automatically if omitted.
-- `description`: A UI label only; the subagent NEVER sees it.
-- `role`: The specialist this subagent embodies. Tailor per spawn; do not clone a generic worker.
+- `name`: A stable CamelCase identifier (≤32 chars), used to address the agent (IRC, job ids). Generated automatically if omitted.
+- `agent`: The agent type to spawn (e.g. `scout`, `reviewer`). Omitting it gives you the general-purpose worker (`{{defaultAgent}}`) — NEVER pass that name explicitly. Only omit it after checking the agent list below and finding no specialist that fits.{{#if allowedAgentsText}} Current spawn policy allows: {{allowedAgentsText}}.{{/if}}
+- `task`: Complete, self-contained instructions. One-liners or missing acceptance criteria are PROHIBITED.
 {{#if isolationEnabled}}
 - `isolated`: Run in a dedicated worktree and return patches. Isolated agents are destroyed upon completion and cannot be addressed afterward.
 {{/if}}
@@ -33,9 +31,9 @@ Execution blocks your turn: the call only returns once the work is completely fi
 Subagents start blank. They have no access to your conversation history.
 {{#if ircEnabled}}- **Steering delivery:** Parent-to-subagent IRC is delivered immediately as steering; subagents blocked in `job poll` / `irc wait` do not need to poll separately for it.{{/if}}
 {{#if batchEnabled}}
-- Pass large payloads using `local://<path>` URIs, never inline text.
+- Pass large payloads using `local://<path>` URIs, NEVER inline text.
 {{else}}
-- Write shared project state ONCE to a `local://` file (e.g., `local://ctx.md`) and reference that URL in your assignments.
+- Write shared project state ONCE to a `local://` file (e.g., `local://ctx.md`) and reference that URL in each `task`.
 {{/if}}
 
 # Format Contracts
@@ -46,7 +44,7 @@ The `context` field MUST follow this format:
 # Contract     ← shared interfaces
 {{/if}}
 
-The `assignment` field MUST follow this format:
+The `task` field MUST follow this format:
 # Target       ← exact files and symbols; explicit non-goals
 # Change       ← step-by-step add/remove/rename; APIs and patterns
 # Acceptance   ← observable result; no project-wide commands
@@ -55,8 +53,9 @@ The `assignment` field MUST follow this format:
 {{#if spawningDisabled}}
 Agent spawning is currently disabled.
 {{else}}
+Pick the most specific agent for each task. Use the default worker only when no specialist below fits.
 {{#list agents join="\n"}}
-### {{name}}{{#if readOnly}} (READ-ONLY: no edit/write/command tools){{/if}}
+### {{name}}{{#if readOnly}} (READ-ONLY: no edit/write/command tools){{/if}}{{#if blocking}} (BLOCKING: runs inline; its result returns in this call){{/if}}
 {{description}}
 {{#if readOnly}}Use ONLY for investigation and reporting; do the edits yourself or assign them to a writing agent.{{/if}}
 {{/list}}

package/src/session/agent-session.ts

@@ -6891,12 +6891,13 @@ export class AgentSession {
 	 * `agent.replaceMessages` or a provider.
 	 */
 	buildTranscriptSessionContext(
-		options?: Pick<BuildSessionContextOptions, "collapseCompactedHistory">,
+		options?: Pick<BuildSessionContextOptions, "collapseCompactedHistory" | "keepDanglingToolCalls">,
 	): SessionContext {
 		return deobfuscateSessionContext(
 			this.sessionManager.buildSessionContext({
 				transcript: true,
 				collapseCompactedHistory: options?.collapseCompactedHistory,
+				keepDanglingToolCalls: options?.keepDanglingToolCalls,
 			}),
 			this.#obfuscator,
 		);

package/src/session/session-context.test.ts

@@ -81,3 +81,76 @@ describe("buildSessionContext snapcompact archives", () => {
 		expect(summary.blocks?.map(block => block.type)).toEqual(["text", "image", "text"]);
 	});
 });
+
+// A turn whose tool is still executing at rebuild time: the assistant message
+// (with its toolCall) is persisted at message_end, the toolResult is not.
+const danglingToolCallEntries = [
+	{
+		type: "message",
+		id: "m1",
+		parentId: null,
+		timestamp,
+		message: { role: "user", content: [{ type: "text", text: "run it" }], timestamp: 1 },
+	},
+	{
+		type: "message",
+		id: "m2",
+		parentId: "m1",
+		timestamp,
+		message: {
+			role: "assistant",
+			content: [{ type: "toolCall", id: "call-1", name: "bash", arguments: { command: "sleep 60" } }],
+			api: "anthropic-messages",
+			provider: "anthropic",
+			model: "claude-sonnet-4-5",
+			usage: {
+				input: 1,
+				output: 1,
+				cacheRead: 0,
+				cacheWrite: 0,
+				totalTokens: 2,
+				cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+			},
+			stopReason: "toolUse",
+			timestamp: 2,
+		},
+	},
+] satisfies SessionEntry[];
+
+function danglingCallIds(messages: AgentMessage[]): string[] {
+	const ids: string[] = [];
+	for (const message of messages) {
+		if (message.role !== "assistant") continue;
+		for (const block of message.content) {
+			if (block.type === "toolCall") ids.push(block.id);
+		}
+	}
+	return ids;
+}
+
+describe("buildSessionContext dangling toolCalls", () => {
+	it("strips a dangling toolCall-only assistant turn from the transcript by default", () => {
+		const context = buildSessionContext(danglingToolCallEntries, undefined, undefined, { transcript: true });
+
+		expect(danglingCallIds(context.messages)).toEqual([]);
+		// The turn had nothing but the dangling call, so the whole message drops.
+		expect(context.messages.some(message => message.role === "assistant")).toBe(false);
+	});
+
+	it("keeps a dangling toolCall in transcript mode with keepDanglingToolCalls", () => {
+		const context = buildSessionContext(danglingToolCallEntries, undefined, undefined, {
+			transcript: true,
+			keepDanglingToolCalls: true,
+		});
+
+		expect(danglingCallIds(context.messages)).toEqual(["call-1"]);
+	});
+
+	it("always strips dangling toolCalls from the LLM context", () => {
+		const context = buildSessionContext(danglingToolCallEntries, undefined, undefined, {
+			keepDanglingToolCalls: true,
+		});
+
+		expect(danglingCallIds(context.messages)).toEqual([]);
+	});
+});

package/src/session/session-context.ts

@@ -120,6 +120,15 @@ export interface BuildSessionContextOptions {
 	transcript?: boolean;
 	/** In transcript mode, elide entries replaced by the latest compaction. */
 	collapseCompactedHistory?: boolean;
+	/**
+	 * Transcript mode only: keep `toolCall` blocks that have no matching
+	 * `toolResult` on the path instead of stripping them. Pass this when the
+	 * session is mid-turn (a tool is still executing, its result not yet
+	 * persisted) so the rebuilt transcript renders the in-flight call as
+	 * pending; without it a focus/unfocus or overlay-close rebuild silently
+	 * hides the call the agent is still waiting on.
+	 */
+	keepDanglingToolCalls?: boolean;
 }
 
 /**
@@ -446,34 +455,42 @@ export function buildSessionContext(
 	// plaintext to keep) and clear `thinking` signatures so the provider encoder
 	// downgrades them to plain text (verified accepted by the live API), preserving the
 	// visible reasoning while removing the immutability/invalid-signature hazard. Drop a
-	// turn left with no content. (Live turns never qualify: their results are persisted
-	// on the same path before any context rebuild.)
-	const pairedToolResultIds = new Set<string>();
-	for (const message of messages) {
-		if (message.role === "toolResult") pairedToolResultIds.add(message.toolCallId);
-	}
-	for (let i = messages.length - 1; i >= 0; i--) {
-		const message = messages[i];
-		if (message.role !== "assistant") continue;
-		const hasDangling = message.content.some(
-			block => block.type === "toolCall" && !pairedToolResultIds.has(block.id),
-		);
-		if (!hasDangling) continue;
-		const normalized = message.content
-			.filter(
-				block =>
-					!(block.type === "toolCall" && !pairedToolResultIds.has(block.id)) && block.type !== "redactedThinking",
-			)
-			.map(block =>
-				block.type === "thinking" && block.thinkingSignature ? { ...block, thinkingSignature: undefined } : block,
+	// turn left with no content. (Live turns only qualify mid-turn: a transcript rebuild
+	// while the tool still executes sees the persisted assistant turn without its result.
+	// Those callers pass `keepDanglingToolCalls` so the in-flight call stays visible as
+	// a pending block instead of vanishing from the chat.)
+	const keepDangling = options?.transcript === true && options.keepDanglingToolCalls === true;
+	if (!keepDangling) {
+		const pairedToolResultIds = new Set<string>();
+		for (const message of messages) {
+			if (message.role === "toolResult") pairedToolResultIds.add(message.toolCallId);
+		}
+		for (let i = messages.length - 1; i >= 0; i--) {
+			const message = messages[i];
+			if (message.role !== "assistant") continue;
+			const hasDangling = message.content.some(
+				block => block.type === "toolCall" && !pairedToolResultIds.has(block.id),
 			);
-		if (normalized.length === 0) {
-			messages.splice(i, 1);
-			if (options?.transcript) {
-				cacheMissExplainedAt.splice(i, 1);
+			if (!hasDangling) continue;
+			const normalized = message.content
+				.filter(
+					block =>
+						!(block.type === "toolCall" && !pairedToolResultIds.has(block.id)) &&
+						block.type !== "redactedThinking",
+				)
+				.map(block =>
+					block.type === "thinking" && block.thinkingSignature
+						? { ...block, thinkingSignature: undefined }
+						: block,
+				);
+			if (normalized.length === 0) {
+				messages.splice(i, 1);
+				if (options?.transcript) {
+					cacheMissExplainedAt.splice(i, 1);
+				}
+			} else {
+				messages[i] = { ...message, content: normalized };
 			}
-		} else {
-			messages[i] = { ...message, content: normalized };
 		}
 	}
 

package/src/slash-commands/builtin-registry.ts

@@ -24,6 +24,7 @@ import {
 	MarketplaceManager,
 } from "../extensibility/plugins/marketplace";
 import { resolveMemoryBackend } from "../memory-backend";
+import { runPauseScreen } from "../modes/components/pause-screen";
 import { describeLoopLimitRuntime } from "../modes/loop-limit";
 import { theme } from "../modes/theme/theme";
 import type { InteractiveModeContext } from "../modes/types";
@@ -2269,6 +2270,14 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<SlashCommandSpec> = [
 			if (prompt) return { prompt };
 		},
 	},
+	{
+		name: "pause",
+		description: "Freeze all agents (main, subagents, advisor) until resumed",
+		handleTui: async (_command, runtime) => {
+			runtime.ctx.editor.setText("");
+			await runPauseScreen(runtime.ctx);
+		},
+	},
 	{
 		name: "quit",
 		description: "Quit the application",

package/src/task/agents.ts

@@ -13,6 +13,7 @@ import librarianMd from "../prompts/agents/librarian.md" with { type: "text" };
 import reviewerMd from "../prompts/agents/reviewer.md" with { type: "text" };
 import scoutMd from "../prompts/agents/scout.md" with { type: "text" };
 import taskMd from "../prompts/agents/task.md" with { type: "text" };
+import { AUTO_THINKING } from "../thinking";
 
 import type { AgentDefinition, AgentSource } from "./types";
 
@@ -50,6 +51,7 @@ const EMBEDDED_AGENT_DEFS: EmbeddedAgentDef[] = [
 			description: "General-purpose subagent with full capabilities for delegated multi-step tasks",
 			spawns: "*",
 			model: "pi/task",
+			thinkingLevel: AUTO_THINKING,
 		},
 		template: taskMd,
 	},