@arhen/pi-core-subagent 1.3.59 → 1.3.61

package/README.md

@@ -51,7 +51,7 @@ flowchart LR
 - **Proof is an exit code, never a self-report.** Tasks are asked for a runnable `Verify:` command; the leader checks `git diff --stat`. Agents auditing their own work score ~0. ([why](#why-9-is-a-verification-command-not-a-self-report))
 - **No ceremony without edges.** Six independent reviewers stay six independent reviewers — no waves, no gates, no graph vocabulary imposed on flat work.
 - **Agent files respected.** A spawn goal (name + task) that matches a user agent file's `description` (`.agents/agents`, `.claude/agents`, `.pi/agents` — project then home) loads that file — body = system prompt, frontmatter `model`/`tools` apply, file `model` validated against the pi model registry. File wins over inline; no match → on-demand definition.
-- **Two toolsets, plus explicit override.** Read-only (`read, grep, find, ls` — default) or write (`read, grep, find, ls, bash, edit, write` — `write: true`); `tools:` sets an explicit per-task allowlist.
+- **Two toolsets, plus explicit override.** Read-only (`read, grep, find, ls, codemode` — default) or write (`read, grep, find, ls, bash, edit, write, codemode` — `write: true`); `tools:` sets an explicit per-task allowlist. Children run with `noExtensions`, so `codemode` is the one extension they get: it lets a child batch `tools.*` calls instead of spending a model turn per call.
 - **In-process** — children are `AgentSession`s in the same runtime. No process spawn, no context bleed.
 - **Zero parent-context injection.** No catalog, no context hook. 7 slim tools total.
 - **Throttled updates** — widget/stream updates coalesce to ~6/s; no per-event deep clones.
@@ -294,7 +294,7 @@ Background (default) + intercom — the run returns a runId immediately; you sta
 | `await_subagent` | block until a run finishes (optional `timeoutMs`) |
 | `reply_subagent` | answer a child's `ask_parent` question |
 | `steer_subagent` | inject a steering message into a running child's session (queues as steer if mid-turn; lands at its next model boundary) |
-| `resume_subagent` | revive a failed/aborted task in its original session (context + branch preserved); optional `model` swap and custom `message` |
+| `resume_subagent` | revive a failed/aborted task in its original session (context + branch preserved); optional `model` swap, `thinking` override (the task's stored level is clamped to what the target model accepts), custom `message`. Waits for the reopened session to go idle before prompting, so a task killed mid-turn can still be resumed |
 | `subagent_cancel` | abort a running/queued run |
 
 ### Per-task fields

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@arhen/pi-core-subagent",
-	"version": "1.3.59",
+	"version": "1.3.61",
 	"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/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

@@ -68,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;
@@ -77,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 };
 }
@@ -143,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();
@@ -900,6 +931,7 @@ export class SubagentManager {
 				cwd: childCwd,
 				agentDir: getAgentDir(),
 				noExtensions: true,
+				extensionFactories: await codemodeFactories(),
 				appendSystemPromptOverride: (base) => [
 					...base,
 					[prompt?.trim(), subagentInstruction].filter(Boolean).join("\n\n"),
@@ -978,6 +1010,9 @@ export class SubagentManager {
 			});
 
 			const maxRuntimeMs = input.maxRuntimeMs ?? (this.autoLimit ? DEFAULT_RUNTIME_MS : UNLIMITED_RUNTIME_MS);
+			// A resumed session can still be draining the turn that failed or timed out. Prompting while
+			// its agent is mid-run is rejected outright ("already processing a prompt"), so wait first.
+			if (resume) await child.waitForIdle();
 			const promptPromise = child.prompt(resume?.message ?? task.task, { source: "extension" });
 			const races: Promise<unknown>[] = [promptPromise, childFailurePromise, childEndPromise];
 			if (maxRuntimeMs > 0) {
@@ -1380,8 +1415,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}.` };
@@ -1399,6 +1434,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,
@@ -1407,7 +1455,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 = {
@@ -1422,6 +1470,7 @@ export class SubagentManager {
 		this.turnActivity = true;
 		Object.assign(task, {
 			status: "queued" as TaskStatus,
+			thinking,
 			error: undefined,
 			endedAt: undefined,
 			finalText: undefined,
@@ -1454,7 +1503,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(),