@selesai/code 0.13.0 → 0.13.2

package/dist/extensions/pi-subagents/test/unit/agent-overrides.test.ts

@@ -342,8 +342,10 @@ describe("builtin agent overrides", () => {
 						systemPromptMode: "replace",
 						inheritProjectContext: true,
 						inheritSkills: true,
+						allowNestedSubagents: true,
 						acceptanceRole: "writer",
 						subagentOnlyExtensions: ["./tools/child-review.ts"],
+						mutationTools: ["replace", "undo_last_replace"],
 						completionGuard: false,
 					},
 				},
@@ -359,8 +361,10 @@ describe("builtin agent overrides", () => {
 		assert.equal(reviewer.systemPromptMode, "replace");
 		assert.equal(reviewer.inheritProjectContext, true);
 		assert.equal(reviewer.inheritSkills, true);
+		assert.equal(reviewer.allowNestedSubagents, true);
 		assert.equal(reviewer.acceptanceRole, "writer");
 		assert.deepEqual(reviewer.subagentOnlyExtensions, ["./tools/child-review.ts"]);
+		assert.deepEqual(reviewer.mutationTools, ["replace", "undo_last_replace"]);
 		assert.equal(reviewer.completionGuard, false);
 		assert.equal(reviewer.override?.scope, "user");
 		assert.equal(reviewer.override?.path, path.join(tempHome, ".selesai", "agent", "settings.json"));
@@ -479,6 +483,76 @@ describe("builtin agent overrides", () => {
 		assert.equal(reviewer.override?.path, path.join(tempProject, ".selesai", "settings.json"));
 	});
 
+	it("layers active-provider overrides over default agentOverrides", () => {
+		writeJson(path.join(tempHome, ".selesai", "agent", "settings.json"), {
+			subagents: {
+				agentOverrides: {
+					worker: { model: "openai/gpt-5-mini", thinking: "low" },
+				},
+				agentOverridesByProvider: {
+					"github-copilot": {
+						worker: { model: "github-copilot/gpt-5-mini", thinking: "high" },
+					},
+					openrouter: {
+						worker: { model: "openrouter/openai/gpt-5-mini" },
+					},
+				},
+			},
+		});
+
+		const defaultWorker = discoverAgents(tempProject, "both").agents.find((agent) => agent.name === "worker");
+		const copilotWorker = discoverAgents(tempProject, "both", "github-copilot").agents.find((agent) => agent.name === "worker");
+		const openrouterWorker = discoverAgents(tempProject, "both", "openrouter").agents.find((agent) => agent.name === "worker");
+		assert.equal(defaultWorker?.model, "openai/gpt-5-mini");
+		assert.equal(defaultWorker?.thinking, "low");
+		assert.equal(copilotWorker?.model, "github-copilot/gpt-5-mini");
+		assert.equal(copilotWorker?.thinking, "high");
+		assert.equal(openrouterWorker?.model, "openrouter/openai/gpt-5-mini");
+		assert.equal(openrouterWorker?.thinking, "low");
+	});
+
+	it("keeps project precedence when provider-specific overrides are active", () => {
+		writeJson(path.join(tempHome, ".selesai", "agent", "settings.json"), {
+			subagents: { agentOverridesByProvider: { openrouter: { worker: { model: "openrouter/user-model", thinking: "low" } } } },
+		});
+		writeJson(path.join(tempProject, ".selesai", "settings.json"), {
+			subagents: {
+				agentOverrides: {
+					worker: { thinking: "medium" },
+				},
+				agentOverridesByProvider: {
+					openrouter: { worker: { model: "openrouter/project-model", thinking: "high" } },
+				},
+			},
+		});
+
+		const worker = discoverAgents(tempProject, "both", "openrouter").agents.find((agent) => agent.name === "worker");
+		assert.equal(worker?.model, "openrouter/project-model");
+		assert.equal(worker?.thinking, "high");
+		assert.equal(worker?.override?.scope, "project");
+	});
+
+	it("keeps provider overrides unambiguous for agents named like override fields", () => {
+		writeJson(path.join(tempHome, ".selesai", "agent", "settings.json"), {
+			subagents: {
+				agentOverridesByProvider: {
+					openrouter: {
+						model: { model: "openrouter/special-model" },
+						tools: { thinking: "high" },
+					},
+				},
+			},
+		});
+		fs.mkdirSync(path.join(tempHome, ".selesai", "agent", "agents"), { recursive: true });
+		for (const name of ["model", "tools"]) {
+			fs.writeFileSync(path.join(tempHome, ".selesai", "agent", "agents", `${name}.md`), `---\nname: ${name}\ndescription: ${name}\n---\n`, "utf-8");
+		}
+
+		const agents = discoverAgents(tempProject, "both", "openrouter").agents;
+		assert.equal(agents.find((agent) => agent.name === "model")?.model, "openrouter/special-model");
+		assert.equal(agents.find((agent) => agent.name === "tools")?.thinking, "high");
+	});
+
 	it("layers a project override on top of a user override for a custom agent instead of discarding it", () => {
 		// Regression test: a custom agent (e.g. a reviewer persona shipped as a .md
 		// file with no model/thinking/fallbackModels in frontmatter) that gets its
@@ -1007,6 +1081,7 @@ describe("builtin agent overrides", () => {
 				thinking: "high",
 				systemPromptMode: "append",
 				inheritProjectContext: true,
+				inheritGlobalContext: true,
 				inheritSkills: false,
 				defaultContext: "fork",
 				acceptanceRole: "read-only",
@@ -1026,6 +1101,7 @@ describe("builtin agent overrides", () => {
 				thinking: undefined,
 				systemPromptMode: "replace",
 				inheritProjectContext: false,
+				inheritGlobalContext: false,
 				inheritSkills: false,
 				defaultContext: undefined,
 				acceptanceRole: undefined,
@@ -1047,6 +1123,7 @@ describe("builtin agent overrides", () => {
 			thinking: false,
 			systemPromptMode: "replace",
 			inheritProjectContext: false,
+			inheritGlobalContext: false,
 			defaultContext: false,
 			acceptanceRole: false,
 			skills: false,

package/dist/extensions/pi-subagents/test/unit/agent-refinements.test.ts

@@ -68,6 +68,24 @@ describe("agent refinements", () => {
 		assert.throws(() => getAgentRefinementPath(tempDir, "../worker"), /cannot be used/);
 	});
 
+	it("reports discovery evidence and does not launch or write for a missing refinement target", async () => {
+		let launched = false;
+		const result = await handleRefinementAction("refine", { agent: "missing" }, {
+			cwd: tempDir,
+			state: state(),
+			signal: new AbortController().signal,
+			launchProposalChild: async () => {
+				launched = true;
+				return { details: { results: [] } };
+			},
+		});
+		assert.equal(result.isError, true);
+		assert.equal(launched, false);
+		assert.match(firstText(result), /^Unknown agent: missing\nEffective cwd: /);
+		assert.match(firstText(result), /Consulted agent-definition directories:[\s\S]*Discovered agents:/);
+		assert.equal(fs.existsSync(getAgentRefinementPath(tempDir, "missing")), false);
+	});
+
 	it("does not launch or write when no bounded evidence exists", async () => {
 		writeProjectAgent();
 		let launched = false;

package/dist/extensions/pi-subagents/test/unit/anti-slop-oxlint.test.ts

@@ -0,0 +1,86 @@
+import assert from "node:assert/strict";
+import { spawnSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { describe, it } from "node:test";
+import { fileURLToPath } from "node:url";
+
+const projectRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../..");
+const oxlint = path.join(projectRoot, "node_modules", "oxlint", "bin", "oxlint");
+const config = path.join(projectRoot, ".oxlintrc.json");
+
+function lintFixture(source: string): string {
+	const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-anti-slop-"));
+	try {
+		const fixture = path.join(root, "rules.ts");
+		fs.writeFileSync(fixture, source, "utf8");
+		const result = spawnSync(process.execPath, [oxlint, "--config", config, "--format", "json", fixture], {
+			cwd: projectRoot,
+			encoding: "utf8",
+		});
+		assert.equal(result.error, undefined, result.error?.message);
+		assert.ok(result.status !== null, result.stderr);
+		assert.notEqual(result.status, 0, result.stderr);
+		return result.stdout;
+	} finally {
+		fs.rmSync(root, { recursive: true, force: true });
+	}
+}
+
+describe("anti-slop Oxlint plugin", () => {
+	it("loads every configured rule and reports representative violations without flagging safe counterparts", () => {
+		const output = lintFixture(String.raw`
+const chained = ("value" as string) as number;
+const conditional = { ...(true ? { value: 1 } : {}) };
+const widened: unknown = "known";
+vi.mock("module");
+function broad(parameter: object): void { void parameter; }
+Reflect.apply(() => {}, null, []);
+Reflect.get({ key: "value" }, "key");
+function runtime(value: string): boolean { return typeof value === "string"; }
+const shapeSignal = 1;
+function unknownInput(value: unknown): void { void value; }
+function unknownOutput(): unknown { return null; }
+type Hidden = unknown;
+type HiddenUnion = string | unknown;
+export type ConcreteAlias = string | number;
+type Opaque = object;
+type ConditionalFunction = unknown extends infer Opaque ? (conditionalValue: Opaque) => void : never;
+const dictionary: Record<string, unknown> = {};
+const broadValue: object = { id: 1 };
+const narrowedValue = broadValue as { id: number };
+const asserted = "x" as string;
+
+export function safeObjectInput(parameter: { id: number }): void { void parameter; }
+export function safeCauseInput(cause: unknown): void { void cause; }
+export const safeDictionary: Record<string, string> = {};
+export const safeSpread = { ...(true ? { value: 1 } : { value: 2 }) };
+export const safeConst = "x" as const;
+`);
+		const rules = [
+			"no-chained-type-assertions",
+			"no-conditional-empty-object-spread",
+			"no-known-value-widening",
+			"no-module-mocking",
+			"no-object-parameters",
+			"no-reflect-apply",
+			"no-reflect-get",
+			"no-runtime-typeof",
+			"no-shape-in-symbol-names",
+			"no-unknown-parameters",
+			"no-unknown-returns",
+			"no-unknown-type-aliases",
+			"no-unsafe-dictionary-type",
+			"no-widen-then-assert",
+			"require-safety-comment-for-type-assertion",
+		];
+		for (const rule of rules) assert.ok(output.includes(`"code": "anti-slop(${rule})"`), `missing ${rule}`);
+		assert.ok(output.includes("Type alias `HiddenUnion` hides `unknown`."), "missing union unknown alias");
+		assert.equal(output.includes("Type alias `ConcreteAlias` hides `unknown`."), false);
+		assert.equal(output.includes("Parameter `conditionalValue` uses the broad `object` type."), false);
+		for (const safeName of ["safeObjectInput", "safeCauseInput", "safeDictionary", "safeSpread", "safeConst"]) {
+			assert.equal(output.includes(safeName), false, `unexpected diagnostic for ${safeName}`);
+		}
+	});
+});

package/dist/extensions/pi-subagents/test/unit/artifacts.test.ts

@@ -32,7 +32,7 @@ describe("project-local artifact paths", () => {
 		assert.match(getProjectArtifactPackagingWarning(packageDir({ name: "unsafe" })) ?? "", /\.npmignore/);
 		assert.equal(getProjectArtifactPackagingWarning(packageDir({ name: "gitignored" }, { name: ".gitignore", content: ".pi-subagents/\n" })), undefined);
 		assert.equal(getProjectArtifactPackagingWarning(packageDir({ name: "globignored" }, { name: ".npmignore", content: "**/.pi-subagents/**\n" })), undefined);
-		assert.equal(getProjectArtifactPackagingWarning(packageDir({ name: "classignored" }, { name: ".npmignore", content: "[.]pi/subagents/**\n" })), undefined);
+		assert.equal(getProjectArtifactPackagingWarning(packageDir({ name: "classignored" }, { name: ".npmignore", content: "[.]pi-subagents/**\n" })), undefined);
 		assert.match(getProjectArtifactPackagingWarning(packageDir({ name: "explicit-files-over-ignore", files: [".pi-subagents/**"] }, { name: ".npmignore", content: ".pi-subagents/\n" })) ?? "", /artifactDir/);
 		assert.equal(getProjectArtifactPackagingWarning(packageDir({ name: "restricted", files: ["src/**"] })), undefined);
 		assert.equal(getProjectArtifactPackagingWarning(packageDir({ name: "malformed-pattern", files: ["[z-a]"] })), undefined);

package/dist/extensions/pi-subagents/test/unit/async-execution.test.ts

@@ -1,8 +1,10 @@
 import assert from "node:assert/strict";
 import * as path from "node:path";
 import { describe, it } from "node:test";
-import { buildAsyncRunnerSteps, DEFAULT_ASYNC_TIMEOUT_MS, formatAsyncStartedMessage, resolveAsyncRunnerLogPaths } from "../../src/runs/background/async-execution.ts";
+import type { ExtensionAPI } from "@selesai/code";
+import { buildAsyncRunnerSteps, DEFAULT_ASYNC_TIMEOUT_MS, emitProcessTerminalEvent, formatAsyncStartedMessage, resolveAsyncRunnerLogPaths } from "../../src/runs/background/async-execution.ts";
 import type { AgentConfig } from "../../src/agents/agents.ts";
+import { SUBAGENT_PROCESS_TERMINAL_EVENT } from "../../src/shared/types.ts";
 
 const agent = (name: string, toolBudget?: AgentConfig["toolBudget"]): AgentConfig => ({
 	name,
@@ -25,6 +27,41 @@ const ctx = {
 };
 
 describe("async runner execution", () => {
+	it("uses supplied discovery context for missing async agents", () => {
+		const result = buildAsyncRunnerSteps("missing-agent", {
+			chain: [{ agent: "missing", task: "Do not launch" }],
+			agents: [agent("arbitrary")],
+			unknownAgentDiagnosticContext: {
+				cwd: path.resolve(ctx.cwd),
+				scope: "both",
+				directories: [{ source: "project", path: path.join(ctx.cwd, ".selesai", "agents"), state: "empty" }],
+				agents: [agent("discovered")],
+			},
+			ctx,
+			maxSubagentDepth: 1,
+			asyncDir: path.join(process.cwd(), ".tmp-missing-agent"),
+		});
+		assert.ok("error" in result);
+		assert.match(result.error, /^Unknown agent: missing\nEffective cwd: /);
+		assert.match(result.error, /discovered \(project\)/);
+		assert.doesNotMatch(result.error, /arbitrary \(project\)/);
+	});
+
+	it("uses the resolved cwd override for no-context missing-agent fallback discovery", () => {
+		const override = path.join("diagnostic-cwd-override", "nested");
+		const result = buildAsyncRunnerSteps("missing-agent-cwd", {
+			chain: [{ agent: "missing", task: "Do not launch" }],
+			agents: [agent("arbitrary")],
+			ctx,
+			cwd: override,
+			maxSubagentDepth: 1,
+			asyncDir: path.join(process.cwd(), ".tmp-missing-agent-cwd"),
+		});
+		assert.ok("error" in result);
+		assert.ok(result.error.startsWith(`Unknown agent: missing\nEffective cwd: ${path.resolve(ctx.cwd, override)}`));
+		assert.doesNotMatch(result.error, /arbitrary \(project\)/);
+	});
+
 	it("formats interactive yield and headless auto-drain guidance separately", () => {
 		const interactive = formatAsyncStartedMessage("Async: worker [interactive]", true);
 		assert.match(interactive, /interactive session[\s\S]*return control/i);
@@ -71,6 +108,31 @@ describe("async runner execution", () => {
 		assert.equal(result.steps[0]?.waitToolEnabled, false);
 		assert.deepEqual(result.steps[1]?.toolBudget, { hard: 2, block: ["grep"] });
 	});
+	it("carries the resolved model context window into async runner steps", () => {
+		const result = buildAsyncRunnerSteps("context-limit-run", {
+			chain: [{ agent: "worker", task: "inspect context" }],
+			agents: [{ ...agent("worker"), model: "mock/context" }],
+			availableModels: [{ provider: "mock", id: "context", fullId: "mock/context", contextWindow: 128_000 }],
+			ctx,
+			asyncDir: path.join(process.cwd(), ".tmp-async-context-limit-test"),
+			maxSubagentDepth: 2,
+		});
+
+		assert.ok("steps" in result, "expected successful step build");
+		assert.equal(result.steps[0]?.contextLimit, 128_000);
+	});
+
+	it("carries explicit nested fanout authorization into async runner steps", () => {
+		const nestedAgent = { ...agent("delegator"), allowNestedSubagents: true };
+		const result = buildAsyncRunnerSteps("nested-fanout-run", {
+			chain: [{ agent: "delegator", task: "delegate" }],
+			agents: [nestedAgent],
+			ctx,
+		});
+
+		assert.equal(result.error, undefined);
+		assert.equal(result.steps[0]?.allowNestedSubagents, true);
+	});
 
 	it("assigns default and agent-level deadlines to async serial and parallel children", () => {
 		const result = buildAsyncRunnerSteps("timeout-run", {
@@ -148,3 +210,41 @@ describe("async runner execution", () => {
 		assert.deepEqual(result.steps[0]?.toolBudget, { hard: 5, block: ["ls"] });
 	});
 });
+
+describe("async runner process terminal events", () => {
+	const proof = { version: 1, runId: "run-terminal", runnerProcessInstanceId: "runner-1", state: "unknown", reason: "writer-close-unverified" };
+	const staleMessage = "This extension ctx is stale after session replacement or reload.";
+
+	const makeCtx = (emit: (name: string, payload?: unknown) => unknown) => ({
+		...ctx,
+		pi: { events: { emit } } as unknown as ExtensionAPI,
+	});
+
+	it("emits the process terminal proof on a live event bus", () => {
+		const emitted: Array<[string, unknown]> = [];
+		emitProcessTerminalEvent(makeCtx((name, payload) => { emitted.push([name, payload]); }), proof);
+
+		assert.deepEqual(emitted, [[SUBAGENT_PROCESS_TERMINAL_EVENT, proof]]);
+	});
+
+	it("drops stale extension ctx failures without throwing", () => {
+		assert.doesNotThrow(() => emitProcessTerminalEvent(makeCtx(() => {
+			throw new Error(staleMessage);
+		}), proof));
+	});
+
+	it("logs non-stale event bus failures without throwing", () => {
+		const originalError = console.error;
+		let logged: unknown[] | undefined;
+		console.error = (...args: unknown[]) => { logged = args; };
+		try {
+			assert.doesNotThrow(() => emitProcessTerminalEvent(makeCtx(() => {
+				throw new Error("event bus unavailable");
+			}), proof));
+		} finally {
+			console.error = originalError;
+		}
+
+		assert.ok(logged?.some((arg) => arg instanceof Error && arg.message === "event bus unavailable"));
+	});
+});

package/dist/extensions/pi-subagents/test/unit/async-interrupt-action.test.ts

@@ -8,6 +8,7 @@ import { consumeSteerRequests, consumeSteerRequestsFromDir, consumeStopRequestPa
 import { listAsyncRuns } from "../../src/runs/background/async-status.ts";
 import { inspectSubagentStatus } from "../../src/runs/background/run-status.ts";
 import { createSubagentExecutor, steerWorkflowChildByKey } from "../../src/runs/foreground/subagent-executor.ts";
+import { resolveExternalCliRunnerStatus } from "../../src/runs/shared/external-cli-contract.ts";
 import { steerWorkflowForegroundTarget, workflowForegroundSteeringDir } from "../../src/runs/foreground/workflow-foreground-steering.ts";
 import { ASYNC_DIR, RESULTS_DIR, type SubagentState } from "../../src/shared/types.ts";
 
@@ -266,6 +267,30 @@ describe("async interrupt action", () => {
 		}
 	});
 
+	it("rejects workflow-key steering for a one-shot external CLI child", async () => {
+		const state = createState();
+		const workflowRunId = `workflow-key-external-${Date.now().toString(36)}`;
+		const childRunId = `${workflowRunId}-child`;
+		const workflowDir = createRunningAsync(state, workflowRunId, { track: false, mode: "workflow" });
+		const childDir = createRunningAsync(state, childRunId, { track: false });
+		const workflowStatus = JSON.parse(fs.readFileSync(path.join(workflowDir, "status.json"), "utf-8"));
+		workflowStatus.steps = [{ agent: "external", status: "running", workflowKey: "external", runId: childRunId, async: true }];
+		writeJson(path.join(workflowDir, "status.json"), workflowStatus);
+		const childStatus = JSON.parse(fs.readFileSync(path.join(childDir, "status.json"), "utf-8"));
+		childStatus.pid = process.pid;
+		childStatus.steps[0].runner = resolveExternalCliRunnerStatus({ command: "review-cli" });
+		writeJson(path.join(childDir, "status.json"), childStatus);
+		try {
+			const result = await steerWorkflowChildByKey({ state, workflowRunId, key: "external", message: "Do not deliver.", options: { ackTimeoutMs: 20 } });
+			assert.equal(result.state, "failed");
+			assert.match(result.error ?? "", /External adapter 'external-cli' does not support runs\.steer/);
+			assert.equal(consumeSteerRequests(childDir).length, 0);
+		} finally {
+			cleanup(workflowRunId, workflowDir);
+			cleanup(childRunId, childDir);
+		}
+	});
+
 	it("returns missed when a terminal keyed child cannot accept a retained follow-up", async () => {
 		const state = createState();
 		const workflowRunId = `workflow-key-terminal-${Date.now().toString(36)}`;
@@ -546,6 +571,44 @@ describe("async interrupt action", () => {
 		}
 	});
 
+	it("rejects runs.steer for the one-shot external CLI with its adapter reason", async () => {
+		const state = createState();
+		const runId = `steer-external-${Date.now().toString(36)}`;
+		const asyncDir = createRunningAsync(state, runId, { track: false });
+		const statusPath = path.join(asyncDir, "status.json");
+		const status = JSON.parse(fs.readFileSync(statusPath, "utf-8")) as { steps: Array<Record<string, unknown>> };
+		status.steps[0]!.runner = resolveExternalCliRunnerStatus({ command: "review-cli" });
+		writeJson(statusPath, status);
+		try {
+			const result = await executorWithKill(state, () => true)
+				.execute("steer", { action: "steer", id: runId, message: "Do not deliver" }, new AbortController().signal, undefined, ctx());
+			assert.equal(result.isError, true);
+			assert.match(text(result), /External adapter 'external-cli' does not support runs\.steer: The one-shot stdin adapter closes input/);
+			assert.equal(fs.existsSync(path.join(asyncDir, "control", "steer-requests")), false);
+		} finally {
+			cleanup(runId, asyncDir);
+		}
+	});
+
+	it("rejects runs.steer for an old persisted external CLI status shape", async () => {
+		const state = createState();
+		const runId = `steer-old-external-${Date.now().toString(36)}`;
+		const asyncDir = createRunningAsync(state, runId, { track: false });
+		const statusPath = path.join(asyncDir, "status.json");
+		const status = JSON.parse(fs.readFileSync(statusPath, "utf-8")) as { steps: Array<Record<string, unknown>> };
+		status.steps[0]!.runner = { type: "external-cli", command: "review-cli", args: [], promptDelivery: "stdin", capabilities: { stop: true, steer: false, resume: false, structuredOutput: false, toolEvents: false } };
+		writeJson(statusPath, status);
+		try {
+			const result = await executorWithKill(state, () => true)
+				.execute("steer", { action: "steer", id: runId, message: "Do not deliver" }, new AbortController().signal, undefined, ctx());
+			assert.equal(result.isError, true);
+			assert.match(text(result), /External adapter 'external-cli' does not support runs\.steer/);
+			assert.equal(fs.existsSync(path.join(asyncDir, "control", "steer-requests")), false);
+		} finally {
+			cleanup(runId, asyncDir);
+		}
+	});
+
 	it("requests an interrupt without signaling a running async runner", async () => {
 		const state = createState();
 		const runId = `interrupt-disk-${Date.now().toString(36)}`;
@@ -631,6 +694,27 @@ describe("async interrupt action", () => {
 		}
 	});
 
+	it("stops a reload-recovered workflow through the durable control channel", async () => {
+		const state = createState();
+		state.currentSessionId = "session";
+		const runId = `stop-recovered-workflow-${Date.now().toString(36)}`;
+		const asyncDir = createRunningAsync(state, runId, { track: false, sessionId: "session", mode: "workflow" });
+		try {
+			const kills: Array<{ pid: number; signal?: NodeJS.Signals | 0 }> = [];
+			const result = await executorWithKill(state, (pid, signal) => {
+				kills.push({ pid, signal });
+				return true;
+			}).execute("stop-recovered-workflow", { action: "stop", id: runId }, new AbortController().signal, undefined, ctx());
+
+			assert.equal(result.isError, undefined);
+			assert.match(text(result), new RegExp(`Stop requested for async run ${runId}`));
+			assert.equal(consumeStopRequestPayload(asyncDir)?.type, "stop");
+			assert.deepEqual(kills, [{ pid: 12345, signal: 0 }]);
+		} finally {
+			cleanup(runId, asyncDir);
+		}
+	});
+
 	it("writes child-scoped stop requests for a running async run", async () => {
 		const state = createState();
 		state.currentSessionId = "session";
@@ -662,6 +746,43 @@ describe("async interrupt action", () => {
 		}
 	});
 
+	it("/subagents-stop rejects a nested-only child without writing a parent target request", async () => {
+		const state = createState();
+		state.currentSessionId = "session";
+		const runId = `stop-nested-${Date.now().toString(36)}`;
+		const nestedChildId = `${runId}-nested`;
+		const asyncDir = createRunningAsync(state, runId, { track: false, sessionId: "session" });
+		try {
+			const statusPath = path.join(asyncDir, "status.json");
+			writeJson(statusPath, {
+				...JSON.parse(fs.readFileSync(statusPath, "utf-8")),
+				steps: [{
+					agent: "wrapper",
+					status: "running",
+					startedAt: 100,
+					children: [{
+						id: nestedChildId,
+						parentRunId: runId,
+						parentStepIndex: 0,
+						depth: 1,
+						path: [{ runId, stepIndex: 0 }],
+						state: "running",
+					}],
+				}],
+			});
+
+			const result = await executorWithKill(state, () => {
+				throw new Error("nested-only child stop must not signal the parent runner");
+			}).execute("stop-nested", { action: "stop", id: runId, childId: nestedChildId }, new AbortController().signal, undefined, ctx());
+
+			assert.equal(result.isError, true);
+			assert.match(text(result), new RegExp(`Child '${nestedChildId}' was not found under async run '${runId}'`));
+			assert.equal(consumeStopRequestPayload(asyncDir), undefined);
+		} finally {
+			cleanup(runId, asyncDir);
+		}
+	});
+
 	it("dismisses only a reload-recovered running workflow without terminating work", async () => {
 		const state = createState();
 		state.currentSessionId = "session";

package/dist/extensions/pi-subagents/test/unit/async-recovery-descriptor.test.ts

@@ -31,6 +31,7 @@ describe("async recovery descriptor", () => {
 				agent: "worker",
 				cwd: root,
 				systemPromptMode: "replace",
+				inheritGlobalContext: false,
 				inheritProjectContext: false,
 				inheritSkills: false,
 				outputMode: "inline",
@@ -48,6 +49,31 @@ describe("async recovery descriptor", () => {
 		}
 	});
 
+	it("defaults inheritGlobalContext from inheritProjectContext for descriptors from older versions", () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-async-recovery-legacy-global-context-"));
+		try {
+			fs.writeFileSync(path.join(root, "recovery-descriptor.json"), JSON.stringify({
+				version: 1,
+				runFanoutBudget: runFanoutBudget("run-legacy-global-context"),
+				sourceRunId: "run-legacy-global-context",
+				agent: "worker",
+				cwd: root,
+				systemPromptMode: "replace",
+				inheritProjectContext: true,
+				inheritSkills: false,
+				outputMode: "inline",
+				maxSubagentDepth: 2,
+				share: false,
+			}), "utf-8");
+
+			const descriptor = readAsyncRecoveryDescriptor(root);
+
+			assert.equal(descriptor?.inheritGlobalContext, true);
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
 	it("rejects unresolved profile context values", () => {
 		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-async-recovery-bad-context-"));
 		try {
@@ -58,6 +84,7 @@ describe("async recovery descriptor", () => {
 				agent: "worker",
 				cwd: root,
 				systemPromptMode: "replace",
+				inheritGlobalContext: false,
 				inheritProjectContext: false,
 				inheritSkills: false,
 				outputMode: "inline",
@@ -86,6 +113,7 @@ describe("async recovery descriptor", () => {
 				agent: "worker",
 				cwd: root,
 				systemPromptMode: "replace",
+				inheritGlobalContext: false,
 				inheritProjectContext: false,
 				inheritSkills: false,
 				outputMode: "inline",

package/dist/extensions/pi-subagents/test/unit/async-resume.test.ts

@@ -277,7 +277,7 @@ describe("async resume lookup", () => {
 			});
 			const descriptor = {
 				version: 1, runFanoutBudget: createRunFanoutBudget("run-descriptor", 64), sourceRunId: "run-descriptor", agent: "worker", cwd: root, systemPromptMode: "replace",
-				inheritProjectContext: false, inheritSkills: false, outputMode: "inline", maxSubagentDepth: 2, share: false,
+				inheritProjectContext: false, inheritGlobalContext: false, inheritSkills: false, outputMode: "inline", maxSubagentDepth: 2, share: false,
 			};
 			writeJson(path.join(asyncDir, "recovery-descriptor.json"), { ...descriptor, token: "must-not-be-accepted" });
 			assert.throws(() => resolveAsyncResumeTarget({ id: "run-descriptor" }, { asyncDirRoot: asyncRoot, resultsDir }), /unknown field 'token'/);
@@ -291,15 +291,20 @@ describe("async resume lookup", () => {
 			writeJson(path.join(asyncDir, "recovery-descriptor.json"), {
 				...descriptor,
 				launchContractDigest: "launch-contract-digest",
+				allowNestedSubagents: true,
 				intercomBridge: { mode: "off" },
 				extensionBindings: { "shepherd.dispatch/1": { role: "coder" } },
 			});
 			const valid = resolveAsyncResumeTarget({ id: "run-descriptor" }, { asyncDirRoot: asyncRoot, resultsDir });
 			assert.equal(valid.launchContractDigest, "launch-contract-digest");
 			assert.equal(valid.recoveryDescriptor?.launchContractDigest, "launch-contract-digest");
+			assert.equal(valid.recoveryDescriptor?.allowNestedSubagents, true);
 			assert.deepEqual(valid.recoveryDescriptor?.intercomBridge, { mode: "off" });
 			assert.deepEqual(valid.recoveryDescriptor?.extensionBindings, { "shepherd.dispatch/1": { role: "coder" } });
 
+			writeJson(path.join(asyncDir, "recovery-descriptor.json"), { ...descriptor, allowNestedSubagents: "true" });
+			assert.throws(() => resolveAsyncResumeTarget({ id: "run-descriptor" }, { asyncDirRoot: asyncRoot, resultsDir }), /allowNestedSubagents/);
+
 			writeJson(path.join(asyncDir, "recovery-descriptor.json"), { ...descriptor, extensionBindings: { invalid: true } });
 			assert.throws(() => resolveAsyncResumeTarget({ id: "run-descriptor" }, { asyncDirRoot: asyncRoot, resultsDir }), /namespace/);
 
@@ -313,7 +318,7 @@ describe("async resume lookup", () => {
 		}
 	});
 
-	it("normalizes persisted turn-budget state without weakening public input validation", () => {
+	it("ignores removed turn budgets in persisted recovery descriptors", () => {
 		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-async-resume-turn-budget-"));
 		try {
 			const asyncRoot = path.join(root, "runs");
@@ -332,6 +337,7 @@ describe("async resume lookup", () => {
 				agent: "worker",
 				cwd: root,
 				systemPromptMode: "replace",
+				inheritGlobalContext: false,
 				inheritProjectContext: false,
 				inheritSkills: false,
 				outputMode: "inline",
@@ -353,16 +359,14 @@ describe("async resume lookup", () => {
 
 			const target = resolveAsyncResumeTarget({ id: "run-turn-budget" }, { asyncDirRoot: asyncRoot, resultsDir });
 
-			assert.deepEqual(target.recoveryDescriptor?.initialTurnBudget, { maxTurns: 8, graceTurns: 2 });
+			assert.equal("initialTurnBudget" in (target.recoveryDescriptor ?? {}), false);
 
 			writeJson(path.join(asyncDir, "recovery-descriptor.json"), {
 				...descriptor,
 				initialTurnBudget: { maxTurns: 8, graceTurns: 2, unrelated: true },
 			});
-			assert.throws(
-				() => resolveAsyncResumeTarget({ id: "run-turn-budget" }, { asyncDirRoot: asyncRoot, resultsDir }),
-				/recoveryDescriptor\.initialTurnBudget\.unrelated is not supported/,
-			);
+			const malformedLegacy = resolveAsyncResumeTarget({ id: "run-turn-budget" }, { asyncDirRoot: asyncRoot, resultsDir });
+			assert.equal("initialTurnBudget" in (malformedLegacy.recoveryDescriptor ?? {}), false);
 		} finally {
 			fs.rmSync(root, { recursive: true, force: true });
 		}
@@ -387,6 +391,7 @@ describe("async resume lookup", () => {
 				agent: "worker",
 				cwd: root,
 				systemPromptMode: "replace",
+				inheritGlobalContext: false,
 				inheritProjectContext: false,
 				inheritSkills: false,
 				outputMode: "inline",
@@ -435,6 +440,7 @@ describe("async resume lookup", () => {
 				agent: "worker",
 				cwd: root,
 				systemPromptMode: "replace",
+				inheritGlobalContext: false,
 				inheritProjectContext: false,
 				inheritSkills: false,
 				outputMode: "inline",
@@ -478,6 +484,7 @@ describe("async resume lookup", () => {
 				agent: "worker",
 				cwd: root,
 				systemPromptMode: "replace",
+				inheritGlobalContext: false,
 				inheritProjectContext: false,
 				inheritSkills: false,
 				outputMode: "inline",