@selesai/code 0.13.12 → 0.13.14

package/dist/extensions/pi-subagents/test/unit/subagent-control.test.ts

@@ -20,11 +20,15 @@ const config = resolveControlConfig(undefined, {
 describe("subagent control attention state", () => {
 	it("marks a run as needing attention only after the idle threshold", () => {
 		assert.equal(deriveActivityState({ config, startedAt: 0, lastActivityAt: 0, now: 50 }), undefined);
-		assert.equal(deriveActivityState({ config, startedAt: 0, lastActivityAt: 0, now: 400 }), "needs_attention");
+		assert.equal(deriveActivityState({ config, startedAt: 0, lastActivityAt: 0, turnCount: 1, now: 400 }), "needs_attention");
 		assert.equal(deriveActivityState({ config, startedAt: 0, lastActivityAt: 0, currentTool: "bash", now: 400 }), undefined);
-		assert.equal(deriveActivityState({ config, startedAt: 0, now: 400 }), "needs_attention");
+		assert.equal(deriveActivityState({ config, startedAt: 0, turnCount: 1, now: 400 }), "needs_attention");
 	});
 
+	it("does not mark a zero-turn run as needing attention", () => {
+		assert.equal(deriveActivityState({ config, startedAt: 0, lastActivityAt: 0, turnCount: 0, now: 400 }), undefined);
+		assert.equal(deriveActivityState({ config, startedAt: 0, lastActivityAt: 0, now: 400 }), undefined);
+	});
 
 	it("builds compact needs-attention control events", () => {
 		const event = buildControlEvent({
@@ -103,25 +107,34 @@ describe("subagent control attention state", () => {
 	it("scales the default idle threshold for higher thinking levels", () => {
 		const defaults = resolveControlConfig();
 
-		assert.equal(deriveActivityState({ config: defaults, startedAt: 0, now: 60_001 }), "needs_attention");
-		assert.equal(deriveActivityState({ config: defaults, startedAt: 0, thinking: "low", now: 60_001 }), "needs_attention");
-		assert.equal(deriveActivityState({ config: defaults, startedAt: 0, thinking: "minimal", now: 60_001 }), "needs_attention");
-		assert.equal(deriveActivityState({ config: defaults, startedAt: 0, thinking: "high", now: 60_001 }), undefined);
-		assert.equal(deriveActivityState({ config: defaults, startedAt: 0, thinking: "high", now: 300_001 }), "needs_attention");
+		assert.equal(deriveActivityState({ config: defaults, startedAt: 0, turnCount: 1, now: 60_001 }), "needs_attention");
+		assert.equal(deriveActivityState({ config: defaults, startedAt: 0, turnCount: 1, thinking: "low", now: 60_001 }), "needs_attention");
+		assert.equal(deriveActivityState({ config: defaults, startedAt: 0, turnCount: 1, thinking: "minimal", now: 60_001 }), "needs_attention");
+		assert.equal(deriveActivityState({ config: defaults, startedAt: 0, turnCount: 1, thinking: "high", now: 60_001 }), undefined);
+		assert.equal(deriveActivityState({ config: defaults, startedAt: 0, turnCount: 1, thinking: "high", now: 300_001 }), "needs_attention");
 	});
 
 	it("keeps explicit idle threshold overrides higher priority than thinking scale", () => {
 		const explicit = resolveControlConfig(undefined, { needsAttentionAfterMs: 90_000 });
 
 		assert.equal(explicit.needsAttentionAfterMsIsExplicit, true);
-		assert.equal(deriveActivityState({ config: explicit, startedAt: 0, thinking: "high", now: 90_001 }), "needs_attention");
+		assert.equal(deriveActivityState({ config: explicit, startedAt: 0, turnCount: 1, thinking: "high", now: 90_001 }), "needs_attention");
+	});
+
+	it("preserves inherited default idle scaling when merging a resolved control config", () => {
+		const inherited = resolveControlConfig();
+		const merged = resolveControlConfig(inherited, { activeNoticeAfterMs: 123_000 });
+
+		assert.equal(merged.needsAttentionAfterMsIsExplicit, false);
+		assert.equal(merged.activeNoticeAfterMs, 123_000);
+		assert.equal(deriveActivityState({ config: merged, startedAt: 0, turnCount: 1, thinking: "high", now: 60_001 }), undefined);
 	});
 
 	it("treats recovered resolved configs without explicitness metadata as fixed thresholds", () => {
 		const recovered = { ...resolveControlConfig(undefined, { needsAttentionAfterMs: 90_000 }) };
 		delete recovered.needsAttentionAfterMsIsExplicit;
 
-		assert.equal(deriveActivityState({ config: recovered, startedAt: 0, thinking: "high", now: 90_001 }), "needs_attention");
+		assert.equal(deriveActivityState({ config: recovered, startedAt: 0, turnCount: 1, thinking: "high", now: 90_001 }), "needs_attention");
 	});
 
 	it("marks non-exempt open tools for attention at the active threshold", () => {

package/dist/extensions/pi-subagents/test/unit/subagent-prompt-runtime.test.ts

@@ -17,7 +17,7 @@ import {
 	SUBAGENT_SUPERVISOR_CHANNEL_DIR_ENV,
 } from "../../src/runs/shared/pi-args.ts";
 import { RUNTIME_EXTENSION_ACK_EVENT, RUNTIME_EXTENSION_ACK_PATH_ENV } from "../../src/runs/shared/runtime-acknowledged-extensions.ts";
-import { STRUCTURED_OUTPUT_CAPTURE_ENV, STRUCTURED_OUTPUT_SCHEMA_ENV } from "../../src/runs/shared/structured-output.ts";
+import { clearStructuredOutputCaptures, STRUCTURED_OUTPUT_ACCEPTANCE_CAPTURE_ENV, STRUCTURED_OUTPUT_ACCEPTANCE_REQUIRED_ENV, STRUCTURED_OUTPUT_CAPTURE_ENV, STRUCTURED_OUTPUT_SCHEMA_ENV } from "../../src/runs/shared/structured-output.ts";
 import { TOOL_BUDGET_ENV } from "../../src/runs/shared/tool-budget.ts";
 import { getAgentDir } from "../../src/shared/utils.ts";
 import { PERMISSION_POLICY_ENV } from "../../src/runs/shared/permissions.ts";
@@ -49,6 +49,8 @@ const envSnapshot = {
 	SELESAI_SUBAGENT_STEER_ACK_DIR: process.env.SELESAI_SUBAGENT_STEER_ACK_DIR,
 	SELESAI_SUBAGENT_STRUCTURED_OUTPUT_CAPTURE: process.env.SELESAI_SUBAGENT_STRUCTURED_OUTPUT_CAPTURE,
 	SELESAI_SUBAGENT_STRUCTURED_OUTPUT_SCHEMA: process.env.SELESAI_SUBAGENT_STRUCTURED_OUTPUT_SCHEMA,
+	SELESAI_SUBAGENT_STRUCTURED_OUTPUT_ACCEPTANCE_CAPTURE: process.env.SELESAI_SUBAGENT_STRUCTURED_OUTPUT_ACCEPTANCE_CAPTURE,
+	SELESAI_SUBAGENT_STRUCTURED_OUTPUT_ACCEPTANCE_REQUIRED: process.env.SELESAI_SUBAGENT_STRUCTURED_OUTPUT_ACCEPTANCE_REQUIRED,
 	SELESAI_SUBAGENT_RUNTIME_ACKNOWLEDGED_EXTENSIONS: process.env.SELESAI_SUBAGENT_RUNTIME_ACKNOWLEDGED_EXTENSIONS,
 	SELESAI_SUBAGENT_TOOL_BUDGET: process.env.SELESAI_SUBAGENT_TOOL_BUDGET,
 	SELESAI_SUBAGENT_PERMISSION_POLICY: process.env.SELESAI_SUBAGENT_PERMISSION_POLICY,
@@ -62,7 +64,7 @@ const envSnapshot = {
 	SELESAI_SUBAGENT_CHILD_AGENT: process.env.SELESAI_SUBAGENT_CHILD_AGENT,
 	SELESAI_SUBAGENT_CHILD_INDEX: process.env.SELESAI_SUBAGENT_CHILD_INDEX,
 	SELESAI_SUBAGENT_WATCHDOG_CHILD_CONFIG: process.env.SELESAI_SUBAGENT_WATCHDOG_CHILD_CONFIG,
-	SELESAI_SUBAGENT_SESSION_NAME: process.env.SELESAI_SUBAGENT_SESSION_NAME,
+
 };
 
 const SKILLS_SECTION = "\n\nThe following skills provide specialized instructions for specific tasks.\nUse the read tool to load a skill's file when the task matches its description.\nWhen a skill file references a relative path, resolve it against the skill directory (parent of SKILL.md / dirname of the path) and use that absolute path in tool commands.\n\n<available_skills>\n  <skill>\n    <name>safe-bash</name>\n    <description>desc</description>\n    <location>/tmp/SKILL.md</location>\n  </skill>\n  <skill>\n    <name>pi-subagents</name>\n    <description>delegate to subagents</description>\n    <location>/tmp/pi-subagents/SKILL.md</location>\n  </skill>\n</available_skills>";
@@ -105,6 +107,10 @@ afterEach(() => {
 	else process.env[STRUCTURED_OUTPUT_CAPTURE_ENV] = envSnapshot.SELESAI_SUBAGENT_STRUCTURED_OUTPUT_CAPTURE;
 	if (envSnapshot.SELESAI_SUBAGENT_STRUCTURED_OUTPUT_SCHEMA === undefined) delete process.env[STRUCTURED_OUTPUT_SCHEMA_ENV];
 	else process.env[STRUCTURED_OUTPUT_SCHEMA_ENV] = envSnapshot.SELESAI_SUBAGENT_STRUCTURED_OUTPUT_SCHEMA;
+	if (envSnapshot.SELESAI_SUBAGENT_STRUCTURED_OUTPUT_ACCEPTANCE_CAPTURE === undefined) delete process.env[STRUCTURED_OUTPUT_ACCEPTANCE_CAPTURE_ENV];
+	else process.env[STRUCTURED_OUTPUT_ACCEPTANCE_CAPTURE_ENV] = envSnapshot.SELESAI_SUBAGENT_STRUCTURED_OUTPUT_ACCEPTANCE_CAPTURE;
+	if (envSnapshot.SELESAI_SUBAGENT_STRUCTURED_OUTPUT_ACCEPTANCE_REQUIRED === undefined) delete process.env[STRUCTURED_OUTPUT_ACCEPTANCE_REQUIRED_ENV];
+	else process.env[STRUCTURED_OUTPUT_ACCEPTANCE_REQUIRED_ENV] = envSnapshot.SELESAI_SUBAGENT_STRUCTURED_OUTPUT_ACCEPTANCE_REQUIRED;
 	if (envSnapshot.SELESAI_SUBAGENT_RUNTIME_ACKNOWLEDGED_EXTENSIONS === undefined) delete process.env[RUNTIME_EXTENSION_ACK_PATH_ENV];
 	else process.env[RUNTIME_EXTENSION_ACK_PATH_ENV] = envSnapshot.SELESAI_SUBAGENT_RUNTIME_ACKNOWLEDGED_EXTENSIONS;
 	if (envSnapshot.SELESAI_SUBAGENT_TOOL_BUDGET === undefined) delete process.env[TOOL_BUDGET_ENV];
@@ -131,8 +137,7 @@ afterEach(() => {
 	else process.env[SUBAGENT_CHILD_INDEX_ENV] = envSnapshot.SELESAI_SUBAGENT_CHILD_INDEX;
 	if (envSnapshot.SELESAI_SUBAGENT_WATCHDOG_CHILD_CONFIG === undefined) delete process.env[CHILD_WATCHDOG_CONFIG_ENV];
 	else process.env[CHILD_WATCHDOG_CONFIG_ENV] = envSnapshot.SELESAI_SUBAGENT_WATCHDOG_CHILD_CONFIG;
-	if (envSnapshot.SELESAI_SUBAGENT_SESSION_NAME === undefined) delete process.env.SELESAI_SUBAGENT_SESSION_NAME;
-	else process.env.SELESAI_SUBAGENT_SESSION_NAME = envSnapshot.SELESAI_SUBAGENT_SESSION_NAME;
+
 });
 
 function setSupervisorEnv(): void {
@@ -182,9 +187,8 @@ describe("subagent prompt runtime", () => {
 				agentEndTimeoutMs: 5,
 				maxWarnings: null,
 				lsp: { enabled: false, timeoutMs: 100, maxFiles: 1, maxDiagnostics: 1 },
-				autoFollowBlockers: false,
-				autoFollowMaxAttempts: null,
 				stalemateRepeats: 2,
+				cadence: { everyNTools: null },
 			});
 			const handlers: Array<(event: { toolName?: string; input?: unknown }, ctx: { signal?: AbortSignal }) => unknown> = [];
 			registerPermissionGate({ on(event: string, handler: (event: { toolName?: string; input?: unknown }, ctx: { signal?: AbortSignal }) => unknown) { if (event === "tool_call") handlers.push(handler); } } as never, async () => new Promise(() => undefined));
@@ -696,9 +700,8 @@ describe("subagent prompt runtime", () => {
 			agentEndTimeoutMs: 500,
 			maxWarnings: null,
 			lsp: { enabled: false, timeoutMs: 3000, maxFiles: 20, maxDiagnostics: 50 },
-			autoFollowBlockers: false,
-			autoFollowMaxAttempts: 3,
 			stalemateRepeats: 2,
+			cadence: { everyNTools: null },
 		});
 		const handlersWith = new Map<string, unknown[]>();
 		registerSubagentPromptRuntime({
@@ -752,6 +755,86 @@ describe("subagent prompt runtime", () => {
 		}
 	});
 
+	it("requires and validates acceptanceReport when structured capture is required", async () => {
+		const dir = fs.mkdtempSync(path.join(os.tmpdir(), "subagent-structured-acceptance-"));
+		try {
+			const schemaPath = path.join(dir, "schema.json");
+			const outputPath = path.join(dir, "output.json");
+			const acceptancePath = path.join(dir, "acceptance.json");
+			fs.writeFileSync(schemaPath, JSON.stringify({ type: "object" }), "utf-8");
+			process.env[STRUCTURED_OUTPUT_SCHEMA_ENV] = schemaPath;
+			process.env[STRUCTURED_OUTPUT_CAPTURE_ENV] = outputPath;
+			process.env[STRUCTURED_OUTPUT_ACCEPTANCE_CAPTURE_ENV] = acceptancePath;
+			process.env[STRUCTURED_OUTPUT_ACCEPTANCE_REQUIRED_ENV] = "1";
+			let execute: ((_id: string, params: { value: unknown; acceptanceReport?: unknown }) => Promise<unknown>) | undefined;
+			let parameters: { required?: string[] } | undefined;
+
+			registerSubagentPromptRuntime({
+				registerTool(tool: { name: string; parameters: unknown; execute: typeof execute }) {
+					if (tool.name === "structured_output") {
+						execute = tool.execute;
+						parameters = tool.parameters as { required?: string[] };
+					}
+				},
+				on() {},
+			} as { registerTool(tool: { name: string; parameters: unknown; execute: typeof execute }): void; on(): void });
+
+			assert.deepEqual(parameters?.required, ["value", "acceptanceReport"]);
+			await assert.rejects(execute!("missing", { value: {} }), /Missing acceptanceReport/);
+			await assert.rejects(execute!("empty", { value: {}, acceptanceReport: {} }), /expected at least one acceptance report field/);
+			await execute!("valid", { value: {}, acceptanceReport: { manualNotes: "validated evidence" } });
+			assert.deepEqual(JSON.parse(fs.readFileSync(acceptancePath, "utf-8")), { manualNotes: "validated evidence" });
+		} finally {
+			fs.rmSync(dir, { recursive: true, force: true });
+		}
+	});
+
+	it("clears stale optional acceptance reports when structured output omits them", async () => {
+		const dir = fs.mkdtempSync(path.join(os.tmpdir(), "subagent-structured-acceptance-stale-"));
+		try {
+			const schemaPath = path.join(dir, "schema.json");
+			const outputPath = path.join(dir, "output.json");
+			const acceptancePath = path.join(dir, "acceptance.json");
+			fs.writeFileSync(schemaPath, JSON.stringify({ type: "object" }), "utf-8");
+			fs.writeFileSync(acceptancePath, JSON.stringify({ manualNotes: "stale" }), "utf-8");
+			process.env[STRUCTURED_OUTPUT_SCHEMA_ENV] = schemaPath;
+			process.env[STRUCTURED_OUTPUT_CAPTURE_ENV] = outputPath;
+			process.env[STRUCTURED_OUTPUT_ACCEPTANCE_CAPTURE_ENV] = acceptancePath;
+			let execute: ((_id: string, params: { value: unknown }) => Promise<unknown>) | undefined;
+
+			registerSubagentPromptRuntime({
+				registerTool(tool: { name: string; execute: typeof execute }) {
+					if (tool.name === "structured_output") execute = tool.execute;
+				},
+				on() {},
+			} as { registerTool(tool: { name: string; execute: typeof execute }): void; on(): void });
+
+			await execute!("without-report", { value: {} });
+			assert.equal(fs.existsSync(acceptancePath), false);
+			assert.deepEqual(JSON.parse(fs.readFileSync(outputPath, "utf-8")), {});
+		} finally {
+			fs.rmSync(dir, { recursive: true, force: true });
+		}
+	});
+
+	it("reports capture cleanup failures after clearing every stale file it can", () => {
+		const dir = fs.mkdtempSync(path.join(os.tmpdir(), "subagent-structured-cleanup-"));
+		try {
+			const outputPath = path.join(dir, "output.json");
+			const acceptancePath = path.join(dir, "acceptance.json");
+			fs.mkdirSync(outputPath);
+			fs.writeFileSync(acceptancePath, JSON.stringify({ manualNotes: "stale" }), "utf-8");
+
+			const error = clearStructuredOutputCaptures({ schema: { type: "object" }, schemaPath: path.join(dir, "schema.json"), outputPath, acceptanceReportPath: acceptancePath });
+
+			assert.match(error ?? "", /Failed to clear stale structured output capture/);
+			assert.equal(fs.existsSync(outputPath), true);
+			assert.equal(fs.existsSync(acceptancePath), false);
+		} finally {
+			fs.rmSync(dir, { recursive: true, force: true });
+		}
+	});
+
 	it("scopes local structured_output schema refs under the value parameter", () => {
 		const dir = fs.mkdtempSync(path.join(os.tmpdir(), "subagent-structured-refs-"));
 		try {

package/dist/extensions/pi-subagents/test/unit/task-intent.test.ts

@@ -16,6 +16,13 @@ describe("classifyTaskMutationIntent", () => {
 		assert.equal(classifyTaskMutationIntent("worker", "Do not modify tests; implement the fix").kind, "implementation");
 		assert.equal(classifyTaskMutationIntent("worker", "Fix the bug. Do not edit files outside src/.").kind, "implementation");
 		assert.equal(classifyTaskMutationIntent("worker", "Must not touch the production database; implement the fix locally").kind, "implementation");
+		assert.equal(classifyTaskMutationIntent("worker", "Do not modify tests\\nImplement the fix").kind, "implementation");
+		assert.equal(classifyTaskMutationIntent("worker", "Do not modify tests\\r\\nImplement the fix").kind, "implementation");
+		assert.equal(classifyTaskMutationIntent("worker", "Do not modify files\\nin src; implement the fix").kind, "implementation");
+		assert.equal(classifyTaskMutationIntent("worker", "Do not modify files\\nin output/; implement the fix").kind, "implementation");
+		assert.equal(classifyTaskMutationIntent("worker", "Do not modify files\\nin report/; implement the fix").kind, "implementation");
+		assert.equal(classifyTaskMutationIntent("worker", "Do not modify files\\r\\noutside docs; implement the fix").kind, "implementation");
+		assert.equal(classifyTaskMutationIntent("worker", "Do not modify files\nin src; implement the fix").kind, "implementation");
 	});
 
 	it("stops the prohibition object before a following implementation clause", () => {
@@ -33,9 +40,29 @@ describe("classifyTaskMutationIntent", () => {
 		assert.equal(classifyTaskMutationIntent("worker", "Do not modify tests and fixtures").kind, "read-only");
 	});
 
+	it("recognizes coordinated read-only prohibitions", () => {
+		for (const task of [
+			"Do not read more files, run commands, or edit anything.",
+			"Do not read more files, run commands, and edit anything.",
+			"Do not read files or modify anything.",
+		]) {
+			assert.notEqual(classifyTaskMutationIntent("worker", task).kind, "implementation", task);
+			assert.equal(expectsImplementationMutation("worker", task), false, task);
+			assert.equal(taskMayMutate(task), false, task);
+		}
+		assert.equal(classifyTaskMutationIntent("worker", "Do not read more files, run commands, or edit anything; implement the fix").kind, "implementation");
+		assert.equal(classifyTaskMutationIntent("worker", "Do not read more files, run commands, or edit anything\\r\\nImplement the fix").kind, "implementation");
+		assert.equal(classifyTaskMutationIntent("worker", "Do not read more files\\r\\nImplement or edit the fix").kind, "implementation");
+		assert.equal(taskMayMutate("Do not read more files\\r\\nImplement or edit the fix"), true);
+	});
+
 	it("lets blanket no-edit prohibitions win over write verbs", () => {
 		assert.equal(classifyTaskMutationIntent("worker", "Implement this. Do not edit files.").kind, "read-only");
 		assert.equal(classifyTaskMutationIntent("worker", "Do not edit files. Tell me how to fix the bug.").kind, "read-only");
+		assert.equal(classifyTaskMutationIntent("worker", "Do not modify files\nIn your final response, explain how to implement the fix.").kind, "read-only");
+		assert.equal(classifyTaskMutationIntent("worker", "Do not modify files\\nIn your final output, implement the fix.").kind, "read-only");
+		assert.equal(classifyTaskMutationIntent("worker", "Do not modify files\\nIn your final output/report/response, implement the fix.").kind, "read-only");
+		assert.equal(classifyTaskMutationIntent("worker", "Do not modify files\\nIn your report, explain how to fix the bug.").kind, "read-only");
 		assert.equal(classifyTaskMutationIntent("worker", "Report on the extraction pipeline. Do not modify project/source files.").kind, "read-only");
 		assert.equal(classifyTaskMutationIntent("reviewer", "Final correctness review after prior fixes. Inspect all changed files and tests. Do not modify project/source files. Report findings.").kind, "read-only");
 		assert.equal(classifyTaskMutationIntent("worker", "Verification-only task. Do not edit product/source/config files.\n   Run a disposable check, delete its temporary harness, and retain only\n   a sanitized report at an explicitly named artifact path.").kind, "read-only");

package/dist/extensions/pi-subagents/test/unit/temp-paths.test.ts

@@ -78,6 +78,56 @@ describe("shared temp paths", () => {
 		}
 	});
 
+	it("isolates agent-dir profile writes from an inherited SELESAI_CODING_AGENT_DIR", () => {
+		const fixture = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-agent-isolation-"));
+		const tempRoot = path.join(fixture, "temp-root");
+		const callerAgentDir = path.join(fixture, "caller-agent");
+		try {
+			const loaderUrl = new URL("../support/isolated-temp-root.mjs", import.meta.url).href;
+			const profilesUrl = new URL("../../src/profiles/profiles.ts", import.meta.url).href;
+			const utilsUrl = new URL("../../src/shared/utils.ts", import.meta.url).href;
+			const script = `
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { applySubagentProfile, getSubagentProfilesDir } from ${JSON.stringify(profilesUrl)};
+import { getAgentDir } from ${JSON.stringify(utilsUrl)};
+
+const profilesDir = getSubagentProfilesDir();
+fs.mkdirSync(profilesDir, { recursive: true });
+fs.writeFileSync(path.join(profilesDir, "isolated.json"), JSON.stringify({ subagents: { agentOverrides: { worker: { thinking: "high" } } } }));
+const result = applySubagentProfile("isolated");
+console.log(JSON.stringify({ agentDir: getAgentDir(), profilePath: path.join(profilesDir, "isolated.json"), settingsPath: result.settingsPath }));
+`;
+			const env = {
+				...process.env,
+				SELESAI_CODING_AGENT_DIR: callerAgentDir,
+				SELESAI_SUBAGENTS_TEMP_ROOT: tempRoot,
+			};
+			delete env.SELESAI_SUBAGENTS_TEST_LOADER;
+			const result = spawnSync(process.execPath, [
+				"--experimental-strip-types",
+				"--import", loaderUrl,
+				"--input-type=module",
+				"--eval", script,
+			], {
+				cwd: process.cwd(),
+				encoding: "utf-8",
+				env,
+			});
+			assert.equal(result.status, 0, result.stderr);
+			const output = JSON.parse(result.stdout.trim()) as { agentDir: string; profilePath: string; settingsPath: string };
+			const isolatedAgentDir = path.join(tempRoot, "home", ".selesai", "agent");
+			assert.equal(output.agentDir, isolatedAgentDir);
+			assert.equal(output.profilePath, path.join(isolatedAgentDir, "profiles", "pi-subagents", "isolated.json"));
+			assert.equal(output.settingsPath, path.join(isolatedAgentDir, "settings.json"));
+			assert.equal(fs.existsSync(output.profilePath), true);
+			assert.equal(fs.existsSync(output.settingsPath), true);
+			assert.equal(fs.existsSync(callerAgentDir), false);
+		} finally {
+			fs.rmSync(fixture, { recursive: true, force: true });
+		}
+	});
+
 	it("anchors shared temp directories under one scoped root", () => {
 		assert.equal(path.dirname(RESULTS_DIR), TEMP_ROOT_DIR);
 		assert.equal(path.dirname(ASYNC_DIR), TEMP_ROOT_DIR);

package/dist/extensions/pi-subagents/test/unit/tool-description.test.ts

@@ -94,7 +94,6 @@ describe("registered subagent tool description", () => {
 		assert.doesNotMatch(description, /tasks\[\]|chain\[\]/i);
 		assert.match(description, /ordinary async subagents notify this session natively.*return control.*do not call bg_wait/i);
 		assert.match(description, /bg_wait only for provider, detached, or other background work without a native notification/i);
-		assert.doesNotMatch(description, /subagent_wait/i);
 		assert.match(description, /continue independent work only until its next dependency barrier; consume the result before work that depends on it/i);
 		assert.match(description, /children\.list.*resume only rows reported resumable/i);
 		assert.match(description, /Each workflow key identifies one result lane.*new stable workflow key.*retained resume pass/i);

package/dist/extensions/pi-subagents/test/unit/tool-timeout.test.ts

@@ -77,14 +77,14 @@ describe("effectiveToolTimeoutMs", () => {
 	});
 
 	it("never applies a tool timeout to blocking coordination tools", () => {
-		for (const tool of ["contact_supervisor", "intercom", "bg_wait", "subagent_wait"]) {
+		for (const tool of ["contact_supervisor", "intercom", "bg_wait"]) {
 			assert.equal(isToolTimeoutExempt(tool), true, `${tool} must be exempt`);
 			assert.equal(effectiveToolTimeoutMs(tool, 1234), undefined);
 			assert.equal(effectiveToolTimeoutMs(tool, undefined), undefined);
 		}
 		assert.equal(isToolTimeoutExempt("bash"), false);
 		assert.equal(isToolTimeoutExempt(undefined), false);
-		assert.deepEqual([...TOOL_TIMEOUT_ALLOWLIST].sort(), ["bg_wait", "contact_supervisor", "intercom", "subagent_wait"]);
+		assert.deepEqual([...TOOL_TIMEOUT_ALLOWLIST].sort(), ["bg_wait", "contact_supervisor", "intercom"]);
 	});
 });
 

package/dist/extensions/pi-subagents/test/unit/wait-completions.test.ts

@@ -66,6 +66,40 @@ describe("workflow wait completion projection", () => {
 		assert.doesNotMatch(JSON.stringify(completion), /raw recovery message|settlementDiagnostic/);
 	});
 
+	it("retains captured structured output and its durable artifact path", () => {
+		const completion = toWaitCompletion({
+			success: true,
+			results: [{
+				agent: "delegate",
+				success: true,
+				output: "",
+				structuredOutput: { payload: { ok: true }, contract_checks: {} },
+				structuredOutputPath: "/runs/structured-output/output.json",
+			}],
+		}, "run-structured");
+
+		assert.deepEqual(completion.results?.[0]?.structuredOutput, { payload: { ok: true }, contract_checks: {} });
+		assert.equal(completion.results?.[0]?.structuredOutputPath, "/runs/structured-output/output.json");
+	});
+
+	it("omits oversized structured output while retaining its artifact path", () => {
+		const completion = toWaitCompletion({
+			success: true,
+			results: [{
+				agent: "delegate",
+				structuredOutput: { payload: "x".repeat(8_000) },
+				structuredOutputPath: "/runs/structured-output/output.json",
+			}],
+		}, "run-large-structured");
+
+		assert.equal(completion.results?.[0]?.structuredOutput, undefined);
+		assert.equal(completion.results?.[0]?.structuredOutputPath, "/runs/structured-output/output.json");
+	});
+
+	it("rejects non-JSON structured output", () => {
+		assert.throws(() => toWaitCompletion({ success: true, results: [{ structuredOutput: 1n }] }, "run-invalid-structured"), /JSON-serializable|serialize a BigInt/);
+	});
+
 	it("rejects unbounded or unknown summary fields at the replay boundary", () => {
 		assert.throws(() => toWaitCompletion({ workflowChildren: { version: 1, parentToolCallId: "tool", workflowRunId: "run", inventoryComplete: true, workflowState: "completed", children: [], output: "secret" } }, "run"), /unsupported fields/);
 	});

package/dist/extensions/pi-subagents/test/unit/wait-subscriptions.test.ts

@@ -107,7 +107,7 @@ describe("non-blocking wait subscriptions", () => {
 		}
 	});
 
-	it("rejects non-blocking subscriptions from headless tool calls", async () => {
+	it("registers bg_wait and rejects non-blocking subscriptions from headless tool calls", async () => {
 		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-wait-subscribe-headless-"));
 		try {
 			const state = makeState();
@@ -127,7 +127,6 @@ describe("non-blocking wait subscriptions", () => {
 				arm() { throw new Error("headless calls must not arm subscriptions"); },
 			});
 			assert.deepEqual(registered.map((entry) => entry.name), ["bg_wait", "subagent_wait"]);
-			assert.match(registered[1]?.description ?? "", /deprecated compatibility alias for `bg_wait`/i);
 			await assert.rejects(
 				registered[0]!.execute("wait", { id: "run-headless", nonBlocking: true }, undefined, undefined, { hasUI: false }),
 				/long-lived interactive subagent runtime/,

package/dist/extensions/pi-subagents/test/unit/watchdog-child-status.test.ts

@@ -2,15 +2,82 @@ import { describe, it } from "node:test";
 import assert from "node:assert/strict";
 import {
 	CHILD_WATCHDOG_STATUS_EVENT,
+	CHILD_WATCHDOG_WARNING_LIMIT,
 	acceptChildWatchdogEvent,
+	applyChildWatchdogMessage,
 	childWatchdogIsActive,
 	decodeChildWatchdogConfig,
 	isChildWatchdogStatusEvent,
 	resolveChildWatchdogConfig,
+	unresolvedChildWatchdogBlockers,
 } from "../../src/watchdog/child-status.ts";
 import { DEFAULT_WATCHDOG_CONFIG } from "../../src/watchdog/settings.ts";
+import { events } from "../support/helpers.ts";
+
+function warningMessage(overrides: Record<string, unknown> = {}) {
+	return (events.watchdogWarning("blocker", "Claims tests passed without running them", { category: "correctness", evidence: "No test command appears in the transcript.", displayedAt: "2026-09-01T00:00:00.000Z", ...overrides }) as { message: object }).message;
+}
+
+describe("child watchdog warning envelope", () => {
+	it("lifts watchdog warning messages, ignores other messages, and marks warnings addressed on assistant turns", () => {
+		let snapshot = applyChildWatchdogMessage(undefined, warningMessage(), 5);
+		assert.deepEqual(snapshot, {
+			phase: "idle",
+			seq: 0,
+			lastUpdate: 5,
+			warnings: [{
+				severity: "blocker",
+				category: "correctness",
+				summary: "Claims tests passed without running them",
+				evidence: "No test command appears in the transcript.",
+				recommendedAction: "Run the focused test before finishing.",
+				displayedAt: "2026-09-01T00:00:00.000Z",
+				addressed: false,
+				stalemate: false,
+			}],
+		});
+		assert.equal(applyChildWatchdogMessage(undefined, warningMessage({ state: "stalemate" }))?.warnings?.[0]?.stalemate, true);
+		assert.equal(applyChildWatchdogMessage(undefined, { role: "assistant", content: [] }), undefined);
+		assert.equal(applyChildWatchdogMessage(undefined, { role: "custom", customType: "subagent-notify", details: {} }), undefined);
+		assert.equal(applyChildWatchdogMessage(undefined, warningMessage({ severity: "nit" })), undefined);
+
+		for (let index = 0; index < CHILD_WATCHDOG_WARNING_LIMIT + 5; index++) {
+			snapshot = applyChildWatchdogMessage(snapshot, warningMessage({ summary: `warning ${index}` }));
+		}
+		assert.equal(snapshot?.warnings?.length, CHILD_WATCHDOG_WARNING_LIMIT);
+		assert.equal(snapshot?.warnings?.at(-1)?.summary, `warning ${CHILD_WATCHDOG_WARNING_LIMIT + 4}`);
+
+		const status = acceptChildWatchdogEvent({ current: snapshot, event: { type: CHILD_WATCHDOG_STATUS_EVENT, seq: 1, phase: "reviewing", ts: 10 } });
+		assert.equal(status?.warnings?.length, CHILD_WATCHDOG_WARNING_LIMIT, "status events keep the warning envelope");
+		assert.equal(unresolvedChildWatchdogBlockers(status).length, CHILD_WATCHDOG_WARNING_LIMIT);
+
+		const addressed = applyChildWatchdogMessage(status, { role: "assistant" });
+		assert.equal(addressed?.warnings?.every((entry) => entry.addressed), true);
+		assert.equal(unresolvedChildWatchdogBlockers(addressed).length, 0);
+		assert.equal(applyChildWatchdogMessage(addressed, { role: "assistant" }), undefined, "nothing left to address");
+	});
+
+	it("treats stalemate blockers as unresolved even when a turn followed, and never concerns", () => {
+		const withBlocker = applyChildWatchdogMessage(undefined, warningMessage({ state: "stalemate" }));
+		const withConcern = applyChildWatchdogMessage(withBlocker, warningMessage({ severity: "concern" }));
+		const snapshot = applyChildWatchdogMessage(withConcern, { role: "assistant" });
+		assert.deepEqual(unresolvedChildWatchdogBlockers(snapshot).map((entry) => entry.severity), ["blocker"]);
+	});
+});
 
 describe("child watchdog status helpers", () => {
+	it("resolves child cadence from override, then children, then the top-level cadence", () => {
+		const base = { ...DEFAULT_WATCHDOG_CONFIG, enabled: true, children: { ...DEFAULT_WATCHDOG_CONFIG.children, enabled: true, overrides: {} } };
+		assert.deepEqual(resolveChildWatchdogConfig({ config: base, agent: "worker" })?.cadence, { everyNTools: null });
+		const root = { ...base, cadence: { everyNTools: 20 } };
+		assert.deepEqual(resolveChildWatchdogConfig({ config: root, agent: "worker" })?.cadence, { everyNTools: 20 });
+		const children = { ...root, children: { ...root.children, cadence: { everyNTools: 10 } } };
+		assert.deepEqual(resolveChildWatchdogConfig({ config: children, agent: "worker" })?.cadence, { everyNTools: 10 });
+		const override = { ...children, children: { ...children.children, overrides: { worker: { cadence: { everyNTools: 5 } } } } };
+		assert.deepEqual(resolveChildWatchdogConfig({ config: override, agent: "worker" })?.cadence, { everyNTools: 5 });
+		assert.deepEqual(resolveChildWatchdogConfig({ config: override, agent: "reviewer" })?.cadence, { everyNTools: 10 });
+	});
+
 	it("preserves child model and explicit override thinking when resolving config", () => {
 		const config = resolveChildWatchdogConfig({
 			config: {
@@ -41,7 +108,6 @@ describe("child watchdog status helpers", () => {
 
 	it("decodes child watchdog config and rejects malformed enabled payloads", () => {
 		const payload = {
-			enabled: true,
 			runId: "run-1",
 			agent: "worker",
 			childIndex: 1,
@@ -49,9 +115,8 @@ describe("child watchdog status helpers", () => {
 			agentEndTimeoutMs: 200,
 			maxWarnings: null,
 			lsp: { enabled: false, timeoutMs: 50, maxFiles: 2, maxDiagnostics: 3 },
-			autoFollowBlockers: true,
-			autoFollowMaxAttempts: 2,
 			stalemateRepeats: 3,
+			cadence: { everyNTools: 10 },
 		};
 		const config = decodeChildWatchdogConfig(JSON.stringify(payload));
 
@@ -61,18 +126,14 @@ describe("child watchdog status helpers", () => {
 			() => decodeChildWatchdogConfig(JSON.stringify({ ...payload, lsp: { ...payload.lsp, timeoutMs: 0 } })),
 			/lsp\.timeoutMs/,
 		);
-		assert.throws(
-			() => decodeChildWatchdogConfig(JSON.stringify({ ...payload, autoFollowBlockers: undefined })),
-			/autoFollowBlockers/,
-		);
-		assert.throws(
-			() => decodeChildWatchdogConfig(JSON.stringify({ ...payload, autoFollowBlockers: "yes" })),
-			/autoFollowBlockers/,
-		);
 		assert.throws(
 			() => decodeChildWatchdogConfig(JSON.stringify({ ...payload, stalemateRepeats: 0 })),
 			/stalemateRepeats/,
 		);
+		assert.throws(
+			() => decodeChildWatchdogConfig(JSON.stringify({ ...payload, cadence: { everyNTools: 3 } })),
+			/cadence\.everyNTools/,
+		);
 	});
 
 	it("accepts latest matching status events and drops stale or foreign events", () => {
@@ -84,12 +145,11 @@ describe("child watchdog status helpers", () => {
 			seq: 1,
 			phase: "reviewing",
 			ts: 10,
-			followUpPending: false,
 		} as const;
 
 		assert.equal(isChildWatchdogStatusEvent(firstEvent), true);
 		const first = acceptChildWatchdogEvent({ event: firstEvent, runId: "run-1", agent: "worker", childIndex: 0, current: undefined });
-		assert.deepEqual(first, { phase: "reviewing", seq: 1, lastUpdate: 10, followUpPending: false });
+		assert.deepEqual(first, { phase: "reviewing", seq: 1, lastUpdate: 10 });
 		assert.equal(childWatchdogIsActive(first), true);
 		assert.equal(acceptChildWatchdogEvent({ event: firstEvent, current: first, runId: "run-1", agent: "worker", childIndex: 0 }), undefined);
 		assert.equal(acceptChildWatchdogEvent({ event: { ...firstEvent, seq: 2, runId: undefined }, current: first, runId: "run-1", agent: "worker", childIndex: 0 }), undefined);

package/dist/extensions/pi-subagents/test/unit/watchdog-diff-tool.test.ts

@@ -0,0 +1,79 @@
+import assert from "node:assert/strict";
+import { execFileSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { afterEach, beforeEach, describe, it } from "node:test";
+import { captureWatchdogDiffBaseline, createWatchdogDiffTool, WATCHDOG_DIFF_MAX_CHARS } from "../../src/watchdog/diff-tool.ts";
+
+let repo = "";
+
+function git(...args: string[]): string {
+	return execFileSync("git", args, { cwd: repo, encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"] });
+}
+
+async function run(tool: ReturnType<typeof createWatchdogDiffTool>, params: { path?: string; stat?: boolean } = {}): Promise<string> {
+	const result = await tool.execute("call", params, undefined as never, undefined as never, undefined as never);
+	return result.content.map((part) => (part as { text?: string }).text ?? "").join("\n");
+}
+
+describe("watchdog diff tool", () => {
+	beforeEach(() => {
+		repo = fs.mkdtempSync(path.join(os.tmpdir(), "watchdog-diff-"));
+		git("init", "-q");
+		git("config", "user.email", "test@example.com");
+		git("config", "user.name", "Test User");
+		fs.mkdirSync(path.join(repo, "src"), { recursive: true });
+		fs.writeFileSync(path.join(repo, "src", "a.ts"), "export const a = 1;\n", "utf-8");
+		fs.writeFileSync(path.join(repo, "README.md"), "readme\n", "utf-8");
+		git("add", ".");
+		git("commit", "-q", "-m", "base");
+	});
+
+	afterEach(() => {
+		fs.rmSync(repo, { recursive: true, force: true });
+	});
+
+	it("captures the session baseline and reports no changes when clean", async () => {
+		const baseline = captureWatchdogDiffBaseline(path.join(repo, "src"));
+		assert.ok(baseline);
+		assert.equal(fs.realpathSync.native(baseline.root), fs.realpathSync.native(repo), "git expands Windows 8.3 short names; compare native real paths");
+		assert.equal(baseline.ref, git("rev-parse", "HEAD").trim());
+		assert.match(await run(createWatchdogDiffTool(baseline)), /^No changes since baseline/);
+		assert.equal(captureWatchdogDiffBaseline(os.tmpdir()), undefined);
+	});
+
+	it("shows tracked changes since the baseline, including later commits, and lists untracked paths", async () => {
+		const baseline = captureWatchdogDiffBaseline(repo)!;
+		fs.writeFileSync(path.join(repo, "src", "a.ts"), "export const a = 2;\n", "utf-8");
+		git("commit", "-q", "-am", "child commit");
+		fs.writeFileSync(path.join(repo, "src", "b.ts"), "export const b = 1;\n", "utf-8");
+		const tool = createWatchdogDiffTool(baseline);
+
+		const full = await run(tool);
+		assert.match(full, /-export const a = 1;/);
+		assert.match(full, /\+export const a = 2;/);
+		assert.match(full, /Untracked files \(use read to inspect\):\n src\/b\.ts/);
+		assert.doesNotMatch(full, /export const b = 1;/);
+
+		const stat = await run(tool, { stat: true });
+		assert.match(stat, /src\/a\.ts \|/);
+		assert.match(stat, /Untracked files \(use read to inspect\):\n src\/b\.ts/);
+
+		const narrowed = await run(tool, { path: "README.md" });
+		assert.doesNotMatch(narrowed, /a\.ts|b\.ts/);
+	});
+
+	it("rejects traversal and option-like paths and bounds large diffs", async () => {
+		const baseline = captureWatchdogDiffBaseline(repo)!;
+		const tool = createWatchdogDiffTool(baseline);
+		await assert.rejects(() => run(tool, { path: "../etc" }), /must not contain '\.\.'/);
+		await assert.rejects(() => run(tool, { path: "-R" }), /must not start with '-'/);
+		await assert.rejects(() => run(tool, { path: "/etc/hosts" }), /relative/);
+
+		fs.writeFileSync(path.join(repo, "src", "a.ts"), `${"export const line = 1;\n".repeat(3_000)}`, "utf-8");
+		const bounded = await run(tool);
+		assert.ok(bounded.length <= WATCHDOG_DIFF_MAX_CHARS, `bounded output was ${bounded.length}`);
+		assert.match(bounded, /characters omitted; call again with a narrower path/);
+	});
+});

package/dist/extensions/pi-subagents/test/unit/watchdog-permission-arbiter.test.ts

@@ -46,9 +46,8 @@ const childConfig = JSON.stringify({
 	agentEndTimeoutMs: 1_000,
 	maxWarnings: null,
 	lsp: { enabled: false, timeoutMs: 100, maxFiles: 1, maxDiagnostics: 1 },
-	autoFollowBlockers: false,
-	autoFollowMaxAttempts: null,
 	stalemateRepeats: 2,
+	cadence: { everyNTools: null },
 });
 
 describe("watchdog permission arbiter", () => {
@@ -97,9 +96,8 @@ describe("watchdog permission arbiter", () => {
 					agentEndTimeoutMs: 5,
 					maxWarnings: null,
 					lsp: { enabled: false, timeoutMs: 100, maxFiles: 1, maxDiagnostics: 1 },
-					autoFollowBlockers: false,
-					autoFollowMaxAttempts: null,
 					stalemateRepeats: 2,
+					cadence: { everyNTools: null },
 				}),
 			}),
 			new Promise((resolve) => setTimeout(() => resolve("hung"), 100)),