@arhen/pi-core-subagent 1.3.58 → 1.3.60

package/README.md

@@ -305,13 +305,15 @@ Background (default) + intercom — the run returns a runId immediately; you sta
 
 | Tool | Meaning |
 |---|---|
-| `ask_parent` | blocking question to the leader; parent answers via `reply_subagent` |
+| `ask_parent` | blocking question to the leader; delivered mid-turn as a **steering** message labelled `[URGENT]` or `[not urgent]`, parent answers via `reply_subagent` |
 | `notify_parent` | one-way message to the leader |
 | `send_agent_message` | message to a sibling subagent's mailbox (`to` = its task id, or `"leader"`) |
 | `poll_agent_messages` | drain this subagent's mailbox |
 
 > **Intercom anti-deadlock:** children are told to never block indefinitely on intercom replies — an unanswered `ask_parent` times out after 10 minutes (the child is told to proceed with best judgment), and sibling polls are capped (~5 tries) with the same fallback. Gated siblings (later waves) may not be running yet — waiting on them is the top stall cause, so children are instructed not to.
 
+> **Ask urgency:** `ask_parent` takes `urgent` (default `false`). Both variants steer into the leader's current turn so the question is never deferred to the end of a long turn. `[URGENT]` tells the leader to answer before its next step; `[not urgent]` tells it that the child keeps waiting, so it may finish its current step first. Failures steer for the same reason; completions and aborts queue as follow-ups.
+
 ## Commands
 
 - `/subagents` — list runs; `/subagents peek` (or `ctrl+shift+a`) — browsable pane

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@arhen/pi-core-subagent",
-	"version": "1.3.58",
+	"version": "1.3.60",
 	"type": "module",
 	"description": "pi extension: fast in-process subagents with a dependency-graph scheduler (needs edges gate tasks and carry upstream output into dependent prompts), plus background runs, intercom and agent-to-agent mailbox. Leader defines agents inline.",
 	"license": "MIT",

package/src/child.ts

@@ -6,7 +6,7 @@ import type { MailboxMessage } from "./mailbox.ts";
 export const CHILD_TALK_TOOLS = ["ask_parent", "notify_parent", "send_agent_message", "poll_agent_messages"] as const;
 
 export interface ChildHandlers {
-	onAskParent(taskId: string, question: string): Promise<string>;
+	onAskParent(taskId: string, question: string, urgent: boolean): Promise<string>;
 	onNotifyParent(taskId: string, message: string, level: "info" | "warning" | "error"): void;
 	onSendMessage(taskId: string, to: string, text: string): boolean;
 	onPollMailbox(taskId: string): MailboxMessage[];
@@ -18,18 +18,26 @@ export function createChildTools(taskId: string, handlers: ChildHandlers): ToolD
 			name: "ask_parent",
 			label: "Ask Parent",
 			description:
-				"Ask the parent agent a clarifying question and BLOCK until it replies (10 min cap — then proceed with best judgment). Use sparingly — only when you truly cannot proceed without information only the parent has. Prefer figuring it out yourself.",
+				"Ask the parent agent a clarifying question and BLOCK until it replies (10 min cap — then proceed with best judgment). Use sparingly — only when you truly cannot proceed without information only the parent has. Prefer figuring it out yourself. The parent sees the question mid-turn: set urgent when you cannot continue until it answers, leave it unset when the parent may finish its current step first.",
 			promptSnippet: "Ask the parent agent a question when truly blocked.",
 			promptGuidelines: [
 				"Use ask_parent only as a last resort when blocked on information only the parent has.",
 				"Ask one focused question at a time. The parent's reply resumes your work.",
+				"Set urgent: true only when you cannot keep working while waiting; otherwise the parent is told it may answer after its current step.",
 			],
 			parameters: Type.Object({
 				question: Type.String({ description: "A single, focused question for the parent agent" }),
+				urgent: Type.Optional(
+					Type.Boolean({
+						description:
+							"True when nothing else can proceed until the parent answers — it is told to stop and reply now",
+						default: false,
+					}),
+				),
 			}),
 			async execute(_toolCallId, params) {
-				const { question } = params as { question: string };
-				const answer = await handlers.onAskParent(taskId, question);
+				const { question, urgent } = params as { question: string; urgent?: boolean };
+				const answer = await handlers.onAskParent(taskId, question, urgent === true);
 				return { content: [{ type: "text" as const, text: answer || "(parent gave no answer)" }], details: {} };
 			},
 		},

package/src/format.ts

@@ -250,6 +250,17 @@ export function makeTaskNotice(run: RunSnapshot, task: TaskSnapshot, kind: strin
 				: `Session file kept — resume_subagent(runId: "${run.id}", taskId: "${task.id}", model?: ...) revives it with full context. subagent_result for what it produced so far.`,
 	].join("\n");
 }
+export function makeAskNotice(
+	run: RunSnapshot,
+	extra: { taskId?: string; agent?: string; question?: string; urgent?: boolean },
+): string {
+	const who = extra.agent ? `${extra.agent} (${extra.taskId ?? "task"})` : (extra.taskId ?? "a subagent");
+	const reply = `reply_subagent(runId: "${run.id}", taskId: "${extra.taskId ?? ""}", message: ...)`;
+	return extra.urgent
+		? `[URGENT] Subagent ${who} is blocked and cannot continue until you answer: ${extra.question ?? ""}\nAnswer now, before your next step, with ${reply}.`
+		: `[not urgent] Subagent ${who} asks: ${extra.question ?? ""}\nIt waits while you keep working — finish your current step first if you want, then answer with ${reply}.`;
+}
+
 export function makeNotice(run: RunSnapshot, kind: string): string {
 	const lines = [
 		`Background subagent run ${run.id} ${kind}: ${run.tasks.filter((t) => t.status === "completed").length}/${run.tasks.length} succeeded.`,

package/src/index.ts

@@ -381,23 +381,24 @@ export default function (pi: ExtensionAPI) {
 		name: "resume_subagent",
 		label: "Resume Subagent",
 		description:
-			"Revive a failed/aborted task in its original session (full context + worktree branch preserved). Optional `model` swaps provider (e.g. after a rate limit); optional `message` replaces the default 'recap and continue' prompt. Refuses tasks that never started — respawn those.",
+			"Revive a failed/aborted task in its original session (full context + worktree branch preserved). Optional `model` swaps provider (e.g. after a rate limit); optional `thinking` sets the effort — the stored level is clamped to what the target model accepts, so a resume never dies on an unsupported effort; optional `message` replaces the default 'recap and continue' prompt. Refuses tasks that never started — respawn those.",
 		parameters: ResumeParam,
 		async execute(_id, params, _signal, _onUpdate, ctx) {
-			const { runId, taskId, message, model } = params as {
+			const { runId, taskId, message, model, thinking } = params as {
 				runId: string;
 				taskId: string;
 				message?: string;
 				model?: string;
+				thinking?: string;
 			};
-			const res = manager.resumeTask(runId, taskId, ctx, { message, model });
+			const res = manager.resumeTask(runId, taskId, ctx, { message, model, thinking });
 			if (!res.ok) return { content: [{ type: "text", text: res.reason }], isError: true, details: {} };
 			const run = manager.getRun(runId);
 			return {
 				content: [
 					{
 						type: "text",
-						text: `Resumed ${runId}/${taskId} (${res.task.agent})${model ? ` on ${model}` : ""} from ${res.task.sessionFile}${res.task.branch ? `, branch ${res.task.branch}` : ""}.\nNext: subagent_status("${runId}") to confirm it is running; completion will notify you.`,
+						text: `Resumed ${runId}/${taskId} (${res.task.agent})${model ? ` on ${model}` : ""} from ${res.task.sessionFile}${res.task.branch ? `, branch ${res.task.branch}` : ""}.${res.note ? ` Adjusted ${res.note}.` : ""}\nNext: subagent_status("${runId}") to confirm it is running; completion will notify you.`,
 					},
 				],
 				details: { run: run ? cloneRun(run) : undefined },

package/src/manager.ts

@@ -29,6 +29,7 @@ import {
 	getFirstText,
 	isStartupFailure,
 	isTalking,
+	makeAskNotice,
 	makeNotice,
 	makeTaskNotice,
 	SubagentsWidget,
@@ -67,8 +68,8 @@ const DEFAULT_RUNTIME_MS = 3_600_000;
 const UNLIMITED_RUNTIME_MS = 21_600_000;
 const PARENT_REPLY_TIMEOUT_MS = 600_000;
 const PARKED_MSG_CAP = 24;
-const READONLY_TOOLS = ["read", "grep", "find", "ls"];
-const WRITE_TOOLS = ["read", "grep", "find", "ls", "bash", "edit", "write"];
+const READONLY_TOOLS = ["read", "grep", "find", "ls", "codemode"];
+const WRITE_TOOLS = ["read", "grep", "find", "ls", "bash", "edit", "write", "codemode"];
 const WRITE_CAPABLE = ["bash", "edit", "write"];
 const SAFE_TASK_ID = /^[A-Za-z0-9_-]{1,64}$/;
 const WIDGET_THROTTLE_MS = 150;
@@ -76,6 +77,25 @@ const WIDGET_THROTTLE_MS = 150;
 function newId(prefix: string): string {
 	return `${prefix}_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
 }
+
+type ChildExtensionFactories = ConstructorParameters<typeof DefaultResourceLoader>[0]["extensionFactories"];
+
+/**
+ * Children run with `noExtensions`, so they get none of the configured extensions — codemode is the
+ * one exception, because it is how a child batches tool calls. `createCodemodeExtension()` is the
+ * supported factory (pi >= 1.0); hosts that do not export it simply give children no codemode.
+ */
+async function codemodeFactories(): Promise<ChildExtensionFactories> {
+	try {
+		const host = (await import("@earendil-works/pi-coding-agent")) as unknown as {
+			createCodemodeExtension?: () => unknown;
+		};
+		const factory = host.createCodemodeExtension?.();
+		return factory ? ([factory] as ChildExtensionFactories) : [];
+	} catch {
+		return [];
+	}
+}
 function emptyUsage(): UsageStats {
 	return { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 0 };
 }
@@ -142,6 +162,18 @@ function updateUsageFromMessage(task: TaskSnapshot, message: AssistantMessage):
 export function cloneRun(run: RunSnapshot): RunSnapshot {
 	return JSON.parse(JSON.stringify(run)) as RunSnapshot;
 }
+/**
+ * A resumed task keeps its stored thinking level, clamped to what the target model accepts — a
+ * resume that swaps model must not fail on an effort the new model does not define.
+ */
+export function clampResumeThinking(
+	model: Model<Api> | undefined,
+	thinking: ThinkingLevel | undefined,
+): ThinkingLevel | undefined {
+	if (!thinking || !model) return thinking;
+	return clampThinkingLevel(model, thinking) as ThinkingLevel;
+}
+
 export function resolveChildModel(ctx: ExtensionContext, explicit: string | undefined) {
 	if (!explicit?.trim()) return ctx.model;
 	const ref = explicit.trim();
@@ -494,19 +526,21 @@ export class SubagentManager {
 	private notifyParent(
 		run: RunSnapshot,
 		kind: "completed" | "failed" | "aborted" | "asked",
-		extra?: { taskId?: string; question?: string },
+		extra?: { taskId?: string; agent?: string; question?: string; urgent?: boolean },
 	): void {
 		if (kind !== "asked" && run.awaited) return;
 		// single-task completed run: the task notice already said everything (failure paths may not have notified per-task)
 		if (kind === "completed" && run.tasks.length === 1 && run.notifyPerTask) return;
-		const body =
-			kind === "asked"
-				? `A subagent is asking you a question (task ${extra?.taskId}): ${extra?.question ?? ""}\nReply with reply_subagent(runId: "${run.id}", taskId: "${extra?.taskId}", message: ...).`
-				: makeNotice(run, kind);
+		const body = kind === "asked" ? makeAskNotice(run, extra ?? {}) : makeNotice(run, kind);
+		// asks steer: the leader sees the question during its turn and the urgent flag tells it whether to
+		// answer now or after the current step. Failures steer for the same reason — a broken result must
+		// not be consumed. Completions and aborts queue as follow-ups.
 		try {
-			this.pi.sendUserMessage(body, { deliverAs: kind === "failed" ? "steer" : "followUp" });
+			this.pi.sendUserMessage(body, {
+				deliverAs: kind === "completed" || kind === "aborted" ? "followUp" : "steer",
+			});
 		} catch {}
-		this.emit("subagent:notification", { runId: run.id, kind, body });
+		this.emit("subagent:notification", { runId: run.id, taskId: extra?.taskId, kind, body });
 	}
 
 	private widgetTui: TUI | null = null;
@@ -614,14 +648,14 @@ export class SubagentManager {
 
 	private makeChildHandlers(run: RunSnapshot, task: TaskSnapshot, ctx: ExtensionContext): ChildHandlers {
 		return {
-			onAskParent: async (_taskId, question) => {
+			onAskParent: async (_taskId, question, urgent) => {
 				if (TERMINAL.includes(task.status)) {
 					return "(your task has already ended — stop work and return immediately)";
 				}
 				this.updateTask(run, task, { status: "awaiting_parent" }, ctx);
 
 				if (!this.collectParked(run.id, { kind: "ask", taskId: task.id, agent: task.agent, text: question })) {
-					this.notifyParent(run, "asked", { taskId: task.id, question });
+					this.notifyParent(run, "asked", { taskId: task.id, agent: task.agent, question, urgent });
 				}
 
 				const reply = await this.awaitParentReply(run.id, task.id, PARENT_REPLY_TIMEOUT_MS);
@@ -891,12 +925,13 @@ export class SubagentManager {
 			const worktreeNote = wt
 				? ` You work in an isolated git worktree (branch ${wt.branch})${task.stackedOn ? `, stacked on ${task.stackedOn} (its changes are already in your tree)` : ""}. Never run git commands that switch branches, create branches, or move the worktree (git switch/checkout/branch/worktree). The extension commits your changes when you finish. git status/diff are fine for inspecting your own changes. node_modules is a SHARED symlink to the main checkout: never install, upgrade, or delete dependencies (no npm/bun/yarn/pnpm install, no \`rm -rf node_modules\`) — those writes escape your worktree and damage the user's project. If the task truly needs a dependency change, edit the manifest only and say so in your answer.`
 				: "";
-			const subagentInstruction = `You are running as a subagent. Your bash tool already executes in the project working directory — never prefix commands with \`cd\`. Do not call subagent/delegation tools unless the parent explicitly asks. Return a concise final answer. You MAY use ask_parent only when truly blocked on information only the parent has; notify_parent for one-way updates; send_agent_message/poll_agent_messages to coordinate with siblings. Your mailbox address and siblings: ${task.roster ?? "(none)"}. Use the exact task ids (e.g. task_2) as send_agent_message targets. Siblings run independently and may start late or finish early — never block indefinitely on their replies: poll at most 5 times, then proceed with your best judgment. A gated sibling (marked ↳ waits in the graph) may not be running yet; do not wait for it. An unanswered ask_parent times out after 10 minutes — proceed with your best judgment then. When your work is done, call notify_parent ONCE with a concise result summary — key findings, verdicts, file:line evidence — so the leader can start consuming your output before the run finishes.${worktreeNote}`;
+			const subagentInstruction = `You are running as a subagent. Your bash tool already executes in the project working directory — never prefix commands with \`cd\`. Do not call subagent/delegation tools unless the parent explicitly asks. Return a concise final answer. You MAY use ask_parent only when truly blocked on information only the parent has (set urgent: true only when nothing else can proceed while you wait); notify_parent for one-way updates; send_agent_message/poll_agent_messages to coordinate with siblings. Your mailbox address and siblings: ${task.roster ?? "(none)"}. Use the exact task ids (e.g. task_2) as send_agent_message targets. Siblings run independently and may start late or finish early — never block indefinitely on their replies: poll at most 5 times, then proceed with your best judgment. A gated sibling (marked ↳ waits in the graph) may not be running yet; do not wait for it. An unanswered ask_parent times out after 10 minutes — proceed with your best judgment then. When your work is done, call notify_parent ONCE with a concise result summary — key findings, verdicts, file:line evidence — so the leader can start consuming your output before the run finishes.${worktreeNote}`;
 
 			const loader = new DefaultResourceLoader({
 				cwd: childCwd,
 				agentDir: getAgentDir(),
 				noExtensions: true,
+				extensionFactories: await codemodeFactories(),
 				appendSystemPromptOverride: (base) => [
 					...base,
 					[prompt?.trim(), subagentInstruction].filter(Boolean).join("\n\n"),
@@ -1377,8 +1412,8 @@ export class SubagentManager {
 		runId: string,
 		taskId: string,
 		ctx: ExtensionContext,
-		opts: { message?: string; model?: string } = {},
-	): { ok: true; task: TaskSnapshot } | { ok: false; reason: string } {
+		opts: { message?: string; model?: string; thinking?: string } = {},
+	): { ok: true; task: TaskSnapshot; note?: string } | { ok: false; reason: string } {
 		const run = this.runs.get(runId);
 		const task = run?.tasks.find((t) => t.id === taskId);
 		if (!run || !task) return { ok: false, reason: `Unknown ${runId}/${taskId}.` };
@@ -1396,6 +1431,19 @@ export class SubagentManager {
 
 		const tools = task.tools?.filter((t) => !(CHILD_TALK_TOOLS as readonly string[]).includes(t));
 		const write = tools?.some((t) => WRITE_CAPABLE.includes(t)) ?? false;
+		// A resume may swap the model, so the level stored on the task can be one the new model
+		// rejects (a mode-clamped xhigh onto a model that only takes low|high|max). Clamp it, or take
+		// the caller's explicit level and clamp that.
+		let resumeModel: Model<Api> | undefined;
+		try {
+			resumeModel = resolveChildModel(ctx, opts.model ?? task.model);
+		} catch {}
+		const requestedThinking = (opts.thinking ?? task.thinking) as ThinkingLevel | undefined;
+		const thinking = clampResumeThinking(resumeModel, requestedThinking);
+		const thinkingNote =
+			requestedThinking && thinking !== requestedThinking
+				? `thinking ${requestedThinking} → ${thinking} (${resumeModel?.provider}/${resumeModel?.id} does not accept ${requestedThinking})`
+				: undefined;
 		const input: TaskInput = {
 			id: task.id,
 			agent: task.agent,
@@ -1404,7 +1452,7 @@ export class SubagentManager {
 			write,
 			tools: tools?.length ? tools : undefined,
 			model: opts.model ?? task.model,
-			thinking: task.thinking as TaskInput["thinking"],
+			thinking: thinking as TaskInput["thinking"],
 			needs: task.needs,
 		};
 		const resume: ResumeInput = {
@@ -1419,6 +1467,7 @@ export class SubagentManager {
 		this.turnActivity = true;
 		Object.assign(task, {
 			status: "queued" as TaskStatus,
+			thinking,
 			error: undefined,
 			endedAt: undefined,
 			finalText: undefined,
@@ -1451,7 +1500,7 @@ export class SubagentManager {
 				if (run.notifyPerTask) this.notifyTask(run, task, task.status as "completed" | "failed" | "aborted");
 				this.finishRunIfSettled(run, ctx);
 			});
-		return { ok: true, task };
+		return { ok: true, task, note: thinkingNote };
 	}
 
 	private finishRunIfSettled(run: RunSnapshot, ctx: ExtensionContext): void {

package/src/schemas.ts

@@ -89,6 +89,12 @@ export const ResumeParam = Type.Object({
 				"Model override for the resumed session (provider/model-id) — use when the original provider is rate-limited",
 		}),
 	),
+	thinking: Type.Optional(
+		StringEnum(THINKING_LEVELS, {
+			description:
+				"Thinking level for the resumed session. Default: the task's stored level, clamped to what the target model accepts",
+		}),
+	),
 });
 export const SteerParam = Type.Object({
 	runId: Type.String(),