@selesai/code 0.13.0 → 0.13.2

package/dist/extensions/pi-subagents/test/unit/mcp-direct-tool-grant.test.ts

@@ -0,0 +1,138 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { planMcpDirectToolGrant } from "../../src/runs/shared/mcp-direct-tool-grant.ts";
+
+test("plans server grants from explicit metadata facts and preserves resource filtering", () => {
+	const grant = planMcpDirectToolGrant({
+		selectors: ["browser-mcp"],
+		servers: {
+			"browser-mcp": { excludeTools: ["browser_click"] },
+		},
+		metadata: {
+			"browser-mcp": {
+				tools: [{ name: "click" }, { name: "navigate" }],
+				resources: [{ name: "Console Logs", uri: "resource://console" }],
+			},
+		},
+		toolPrefix: "server",
+	});
+
+	assert.deepEqual(grant, {
+		selections: [
+			{ name: "browser_mcp_navigate", selector: "browser-mcp/navigate" },
+			{ name: "browser_mcp_get_console_logs", selector: "browser-mcp/get_console_logs" },
+		],
+		unresolvedSelectors: [],
+	});
+});
+
+test("plans tool-specific grants and reports unresolved selectors deterministically", () => {
+	const grant = planMcpDirectToolGrant({
+		selectors: ["github/search_repositories", "missing"],
+		servers: {
+			github: {},
+		},
+		metadata: {
+			github: { tools: [{ name: "search_repositories" }, { name: "create_issue" }] },
+		},
+		toolPrefix: "none",
+	});
+
+	assert.deepEqual(grant, {
+		selections: [{ name: "search_repositories", selector: "github/search_repositories" }],
+		unresolvedSelectors: ["missing"],
+	});
+});
+
+test("fails closed for missing or stale source facts without consulting ambient state", () => {
+	const grant = planMcpDirectToolGrant({
+		selectors: ["github", "github/search_repositories"],
+		servers: {
+			github: {},
+		},
+		metadata: {},
+	});
+
+	assert.deepEqual(grant, {
+		selections: [],
+		unresolvedSelectors: ["github", "github/search_repositories"],
+	});
+});
+
+test("enforces server includeTools before exclusions for tools and generated resources", () => {
+	const grant = planMcpDirectToolGrant({
+		selectors: ["demo"],
+		servers: {
+			demo: {
+				includeTools: ["get_*", "demo_list_records"],
+				excludeTools: ["get_secret", "demo_get_private*"],
+			},
+		},
+		metadata: {
+			demo: {
+				tools: [
+					{ name: "get_public" },
+					{ name: "get_secret" },
+					{ name: "list_records" },
+					{ name: "other" },
+				],
+				resources: [
+					{ name: "Run Book", uri: "resource://run-book" },
+					{ name: "Private Notes", uri: "resource://private-notes" },
+				],
+			},
+		},
+		toolPrefix: "server",
+	});
+
+	assert.deepEqual(grant.selections, [
+		{ name: "demo_get_public", selector: "demo/get_public" },
+		{ name: "demo_list_records", selector: "demo/list_records" },
+		{ name: "demo_get_run_book", selector: "demo/get_run_book" },
+	]);
+	assert.deepEqual(grant.unresolvedSelectors, []);
+});
+
+test("matches include and exclude patterns against raw and alternate prefix names", () => {
+	for (const [toolPrefix, expectedName] of [
+		["server", "demo_mcp_search-records"],
+		["short", "demo_search-records"],
+		["none", "search-records"],
+	] as const) {
+		const allowed = planMcpDirectToolGrant({
+			selectors: ["demo-mcp"],
+			servers: { "demo-mcp": { includeTools: ["demo_mcp_search_records"] } },
+			metadata: { "demo-mcp": { tools: [{ name: "search-records" }] } },
+			toolPrefix,
+		});
+		assert.deepEqual(allowed.selections, [{ name: expectedName, selector: "demo-mcp/search-records" }]);
+
+		const excluded = planMcpDirectToolGrant({
+			selectors: ["demo-mcp"],
+			servers: { "demo-mcp": { includeTools: ["demo_mcp_search_records"], excludeTools: ["search_records"] } },
+			metadata: { "demo-mcp": { tools: [{ name: "search-records" }] } },
+			toolPrefix,
+		});
+		assert.deepEqual(excluded.selections, []);
+	}
+});
+
+test("supports adapter-compatible question-mark patterns", () => {
+	const grant = planMcpDirectToolGrant({
+		selectors: ["demo"],
+		servers: { demo: { includeTools: ["get_????"], excludeTools: ["get_?ecret"] } },
+		metadata: { demo: { tools: [{ name: "get_wiki" }, { name: "get_secret" }, { name: "get_longer" }] } },
+	});
+
+	assert.deepEqual(grant.selections, [{ name: "demo_get_wiki", selector: "demo/get_wiki" }]);
+});
+
+test("matches adapter mcp-prefixed policy names", () => {
+	const grant = planMcpDirectToolGrant({
+		selectors: ["demo"],
+		servers: { demo: { includeTools: ["mcp_search_records"] } },
+		metadata: { demo: { tools: [{ name: "search_records" }, { name: "list_records" }] } },
+	});
+
+	assert.deepEqual(grant.selections, [{ name: "demo_search_records", selector: "demo/search_records" }]);
+});

package/dist/extensions/pi-subagents/test/unit/mission-lifecycle.test.ts

@@ -136,7 +136,7 @@ describe("mission launch lifecycle", () => {
 				config: test.missionConfig,
 			});
 			assert.ok(binding);
-			const missionDir = path.join(worktreeRoot, ".selesai", "subagents", "missions");
+			const missionDir = path.join(worktreeRoot, ".pi-subagents", "missions");
 			assert.throws(() => prepareMissionLaunch({
 				params: { missionId: binding.missionId, task: "Prepare worktree work" },
 				projectRoot: worktreeRoot,

package/dist/extensions/pi-subagents/test/unit/model-exclusions.test.ts

@@ -3,6 +3,7 @@ import * as fs from "node:fs";
 import { afterEach, beforeEach, describe, it } from "node:test";
 import {
 	clearExclusions,
+	DEFAULT_MODEL_EXCLUSION_TTL_MS,
 	filterFallbackCandidates,
 	flushPersist,
 	getExcludedCount,
@@ -11,13 +12,16 @@ import {
 	parseModelKey,
 	recordModelFailure,
 	reloadFromDisk,
+	MAX_MODEL_EXCLUSION_TTL_MS,
 	setDefaultTTL,
+	type ModelExclusion,
 } from "../../src/runs/shared/model-exclusions.ts";
 
 // The exclusion store is a process-wide singleton persisted under TEMP_ROOT_DIR
 // (isolated per test run by test/support/isolated-temp-root.mjs). Clear it
 // before/after each test so cases don't leak state into each other.
 beforeEach(() => {
+	setDefaultTTL(DEFAULT_MODEL_EXCLUSION_TTL_MS);
 	fs.rmSync(getExclusionsFilePath(), { force: true });
 	clearExclusions();
 });
@@ -61,6 +65,16 @@ describe("model exclusions — TTL expiry", () => {
 	it("rejects invalid default TTLs", () => {
 		assert.throws(() => setDefaultTTL(0), /finite positive/);
 		assert.throws(() => setDefaultTTL(Number.POSITIVE_INFINITY), /finite positive/);
+		assert.throws(() => setDefaultTTL(MAX_MODEL_EXCLUSION_TTL_MS + 1), /no greater than/);
+	});
+
+	it("keeps the maximum configured expiry representable", () => {
+		setDefaultTTL(MAX_MODEL_EXCLUSION_TTL_MS);
+		recordModelFailure({ modelId: "gpt-4", provider: "openai" });
+		reloadFromDisk();
+		const entry = JSON.parse(fs.readFileSync(getExclusionsFilePath(), "utf-8")).exclusions[0] as ModelExclusion;
+		assert.doesNotThrow(() => new Date(entry.expiresAt).toISOString());
+		assert.equal(isExcluded("gpt-4", "openai"), true);
 	});
 
 	it("drops an exclusion after its TTL elapses", async () => {
@@ -69,6 +83,23 @@ describe("model exclusions — TTL expiry", () => {
 		await new Promise((r) => setTimeout(r, 150));
 		assert.equal(isExcluded("gpt-4", "openai"), false);
 	});
+
+	it("shortens active exclusions without synchronously persisting or extending expiries", () => {
+		recordModelFailure({ modelId: "gpt-4", provider: "openai", reason: "503", ttlMs: 60_000 });
+		const before = JSON.parse(fs.readFileSync(getExclusionsFilePath(), "utf-8")).exclusions[0] as ModelExclusion;
+		setDefaultTTL(30_000, { shortenExisting: true });
+		const beforeFlush = JSON.parse(fs.readFileSync(getExclusionsFilePath(), "utf-8")).exclusions[0] as ModelExclusion;
+		assert.equal(beforeFlush.expiresAt, before.expiresAt);
+		flushPersist();
+		const shortened = JSON.parse(fs.readFileSync(getExclusionsFilePath(), "utf-8")).exclusions[0] as ModelExclusion;
+		assert.equal(shortened.expiresAt, shortened.recordedAt + 30_000);
+
+		setDefaultTTL(120_000, { shortenExisting: true });
+		flushPersist();
+		const notExtended = JSON.parse(fs.readFileSync(getExclusionsFilePath(), "utf-8")).exclusions[0] as ModelExclusion;
+		assert.equal(notExtended.expiresAt, shortened.expiresAt);
+		assert.ok(shortened.expiresAt < before.expiresAt);
+	});
 });
 
 describe("model exclusions — parseModelKey", () => {
@@ -119,6 +150,18 @@ describe("model exclusions — filtering fallback candidates", () => {
 		const filtered = filterFallbackCandidates(candidates);
 		assert.deepEqual(filtered, ["anthropic/claude-3", "openai/gpt-4"]);
 	});
+
+	it("reports the cached reason and expiry for skipped candidates", () => {
+		const skipped: Array<{ candidate: string; exclusion: Readonly<ModelExclusion> }> = [];
+		recordModelFailure({ modelId: "gpt-4", provider: "openai", reason: "503 unavailable" });
+		const filtered = filterFallbackCandidates(["openai/gpt-4", "anthropic/claude-3"], {
+			onExcluded: (candidate, exclusion) => skipped.push({ candidate, exclusion }),
+		});
+		assert.deepEqual(filtered, ["anthropic/claude-3"]);
+		assert.equal(skipped[0]?.candidate, "openai/gpt-4");
+		assert.equal(skipped[0]?.exclusion.reason, "503 unavailable");
+		assert.ok((skipped[0]?.exclusion.expiresAt ?? 0) > Date.now());
+	});
 });
 
 describe("model exclusions — persistence", () => {
@@ -164,4 +207,52 @@ describe("model exclusions — persistence", () => {
 		assert.equal(errors.length, 1);
 		assert.match(String(errors[0]?.[0]), /Failed to load exclusions/);
 	});
+
+	it("rejects persisted exclusions with invalid timestamps", () => {
+		for (const [field, value] of [
+			["expiresAt", null],
+			["expiresAt", 0],
+			["expiresAt", 9_000_000_000_000_000],
+			["recordedAt", null],
+			["recordedAt", -1],
+			["recordedAt", 9_000_000_000_000_000],
+		] as const) {
+			const now = Date.now();
+			const entry = { modelId: "gpt-4", provider: "openai", reason: "503", recordedAt: now, expiresAt: now + 60_000, [field]: value };
+			fs.writeFileSync(getExclusionsFilePath(), JSON.stringify({ version: 1, exclusions: [entry] }), "utf-8");
+			const originalError = console.error;
+			const errors: unknown[][] = [];
+			console.error = (...args: unknown[]) => errors.push(args);
+			try {
+				reloadFromDisk();
+			} finally {
+				console.error = originalError;
+			}
+			assert.equal(getExcludedCount(), 0);
+			assert.equal(errors.length, 1);
+			assert.match(String(errors[0]?.[1]), new RegExp(`invalid ${field}`));
+		}
+	});
+
+	it("rejects persisted exclusions with non-string reasons", () => {
+		for (const reason of [null, 503, { bad: true }, ["503"]]) {
+			const now = Date.now();
+			fs.writeFileSync(getExclusionsFilePath(), JSON.stringify({
+				version: 1,
+				exclusions: [{ modelId: "gpt-4", provider: "openai", reason, recordedAt: now, expiresAt: now + 60_000 }],
+			}), "utf-8");
+			const originalError = console.error;
+			const errors: unknown[][] = [];
+			console.error = (...args: unknown[]) => errors.push(args);
+			try {
+				reloadFromDisk();
+			} finally {
+				console.error = originalError;
+			}
+			assert.equal(getExcludedCount(), 0);
+			assert.equal(errors.length, 1);
+			assert.match(String(errors[0]?.[1]), /invalid reason/);
+			assert.deepEqual(filterFallbackCandidates(["openai/gpt-4", "anthropic/claude-3"]), ["openai/gpt-4", "anthropic/claude-3"]);
+		}
+	});
 });

package/dist/extensions/pi-subagents/test/unit/model-fallback.test.ts

@@ -6,13 +6,14 @@ import {
 	formatSubagentModelVerificationError,
 	isContextOverflow,
 	isRetryableModelFailure,
+	isRetryableModelFailureAttempt,
 	normalizeModelSegment,
 	recordRetryableModelFailure,
 	resolveEffectiveSubagentModel,
 	resolveModelCandidate,
 	resolveSubagentModelOverride,
 } from "../../src/runs/shared/model-fallback.ts";
-import { clearExclusions } from "../../src/runs/shared/model-exclusions.ts";
+import { clearExclusions, recordModelFailure } from "../../src/runs/shared/model-exclusions.ts";
 import { resolveModelScopesForAgent } from "../../src/runs/shared/model-scope.ts";
 
 beforeEach(() => clearExclusions());
@@ -53,6 +54,38 @@ describe("model fallback helpers", () => {
 		);
 	});
 
+	it("accepts a bare leaf reported by an Anthropic gateway driver", () => {
+		const gatewayModels = [{
+			provider: "bifrost-anthropic",
+			id: "vertex/claude-fable-5",
+			fullId: "bifrost-anthropic/vertex/claude-fable-5",
+		}];
+		assert.equal(
+			formatSubagentModelVerificationError(
+				"bifrost-anthropic/vertex/claude-fable-5:high",
+				"claude-fable-5",
+				gatewayModels,
+			),
+			undefined,
+		);
+		assert.match(
+			formatSubagentModelVerificationError(
+				"bifrost-anthropic/vertex/claude-fable-5:high",
+				"wrong-provider/claude-fable-5",
+				gatewayModels,
+			) ?? "",
+			/model_verification_failed/,
+		);
+		assert.match(
+			formatSubagentModelVerificationError(
+				"bifrost-anthropic/vertex/claude-fable-5:high",
+				"claude-sonnet-4",
+				gatewayModels,
+			) ?? "",
+			/model_verification_failed/,
+		);
+	});
+
 	it("resolves unique owner/name ids when the owner is not a registered provider", () => {
 		const registry = [
 			...availableModels,
@@ -125,12 +158,21 @@ describe("model fallback helpers", () => {
 	});
 
 	it("excludes a candidate after a retryable model failure is recorded", () => {
-		recordRetryableModelFailure("openai/gpt-5-mini", "rate limit exceeded");
-
-		assert.deepEqual(
-			buildModelCandidates("gpt-5-mini", ["anthropic/claude-sonnet-4"], availableModels),
-			["anthropic/claude-sonnet-4"],
-		);
+		const warnings: string[] = [];
+		const originalWarn = console.warn;
+		console.warn = (message: unknown) => warnings.push(String(message));
+		try {
+			recordRetryableModelFailure("openai/gpt-5-mini", "rate limit exceeded for Bearer secret-token-value");
+			assert.deepEqual(
+				buildModelCandidates("gpt-5-mini", ["anthropic/claude-sonnet-4"], availableModels),
+				["anthropic/claude-sonnet-4"],
+			);
+		} finally {
+			console.warn = originalWarn;
+		}
+		assert.equal(warnings.length, 1);
+		assert.match(warnings[0]!, /Skipping model 'openai\/gpt-5-mini'.*reason: rate limit exceeded for \[redacted\]; expires: \d{4}-\d{2}-\d{2}T/);
+		assert.doesNotMatch(warnings[0]!, /secret-token-value/);
 	});
 
 	it("does not exclude a candidate after a task or tool failure", () => {
@@ -190,7 +232,12 @@ describe("model fallback helpers", () => {
 		assert.equal(isRetryableModelFailure("Subagent produced no output (possible model cold-start or empty response)."), true);
 		assert.equal(isRetryableModelFailure("model load failed"), true);
 		assert.equal(isRetryableModelFailure("Stream ended without finish_reason"), true);
+		assert.equal(isRetryableModelFailure("Connection error"), true);
+		assert.equal(isRetryableModelFailure("APIConnectionError: Connection closed."), true);
+		assert.equal(isRetryableModelFailure("Connection reset by peer"), true);
 		assert.equal(isRetryableModelFailure("Request timed out."), true);
+		assert.equal(isRetryableModelFailure("internal server error"), true);
+		assert.equal(isRetryableModelFailure("500"), true);
 	});
 
 	it("does not treat ordinary task/tool failures as retryable model failures", () => {
@@ -208,6 +255,13 @@ describe("model fallback helpers", () => {
 		assert.equal(isRetryableModelFailure("Provider error: bash failed (exit 1): request timed out"), true);
 		assert.equal(isRetryableModelFailure("bash failed (exit unknown): request timed out"), true);
 	});
+
+	it("does not retry raw process stderr after child activity", () => {
+		assert.equal(isRetryableModelFailureAttempt({ error: "APIConnectionError: Connection closed.", messages: [{ role: "assistant" }], toolCount: 0 }), false);
+		assert.equal(isRetryableModelFailureAttempt({ error: "APIConnectionError: Connection closed.", messages: [{ role: "assistant", errorMessage: "APIConnectionError: Connection closed." }], toolCount: 0 }), true);
+		assert.equal(isRetryableModelFailureAttempt({ error: "APIConnectionError: Connection closed.", messages: [], toolCount: 0 }), true);
+		assert.equal(isRetryableModelFailureAttempt({ error: "APIConnectionError: Connection closed.", messages: [{ role: "assistant", errorMessage: "APIConnectionError: Connection closed." }], toolCount: 1 }), false);
+	});
 });
 
 describe("resolveSubagentModelOverride (cross-session inherit, issue #266)", () => {
@@ -264,6 +318,17 @@ describe("resolveSubagentModelOverride (cross-session inherit, issue #266)", ()
 		);
 	});
 
+	it("fails visibly when an explicit model is excluded instead of falling back", () => {
+		recordModelFailure({ modelId: "gpt-5-mini", provider: "openai", reason: "rate limit" });
+		assert.throws(
+			() => resolveEffectiveSubagentModel("openai/gpt-5-mini", undefined, parentModel, availableModels),
+			(error: unknown) => {
+				const message = String(error);
+				return message.includes("openai/gpt-5-mini") && message.includes("rate limit") && message.includes("expires:");
+			},
+		);
+	});
+
 	it("resolves owner/name frontmatter models against the registry", () => {
 		const models = [
 			...availableModels,

package/dist/extensions/pi-subagents/test/unit/mutation-evidence.test.ts

@@ -88,6 +88,27 @@ describe("tracked mutation evidence", () => {
 		});
 	});
 
+	it("does not invoke repository fsmonitor while collecting mutation evidence", () => {
+		withRepo((repo) => {
+			const marker = path.join(repo, "fsmonitor-invoked");
+			const hook = path.join(repo, "fsmonitor-hook.cjs");
+			fs.writeFileSync(hook, `require("node:fs").appendFileSync(${JSON.stringify(marker)}, "invoked\\n");\n`, "utf-8");
+			git(repo, ["config", "core.fsmonitor", `${JSON.stringify(process.execPath)} ${JSON.stringify(hook)}`]);
+			git(repo, ["status", "--short"]);
+			assert.equal(fs.existsSync(marker), true);
+			fs.rmSync(marker);
+			fs.writeFileSync(path.join(repo, "tracked.txt"), "dirty before child\n", "utf-8");
+
+			const snapshot = snapshotTrackedMutations(repo);
+			fs.writeFileSync(path.join(repo, "tracked.txt"), "dirty after child\n", "utf-8");
+			const evidence = collectTrackedMutationEvidence(snapshot, repo);
+
+			assert.equal(snapshot.unavailable, undefined);
+			assert.equal(evidence.attemptedMutation, true);
+			assert.equal(fs.existsSync(marker), false);
+		});
+	});
+
 	it("uses tracked evidence as completion guard mutation proof", () => {
 		const guard = evaluateCompletionMutationGuard({
 			agent: "worker",

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

@@ -390,6 +390,7 @@ describe("nested control routing", () => {
 				agent: "worker",
 				cwd: root,
 				systemPromptMode: "replace",
+				inheritGlobalContext: false,
 				inheritProjectContext: false,
 				inheritSkills: false,
 				outputMode: "inline",

package/dist/extensions/pi-subagents/test/unit/nested-events.test.ts

@@ -333,7 +333,7 @@ describe("nested event parsing and projection", () => {
 			ts: 100,
 			parentRunId: "root-run",
 			parentStepIndex: 1,
-			child: { ...child("nested-valid-tokens", "running", 100), totalTokens: { input: 10, output: 15, total: 25 } },
+			child: { ...child("nested-valid-tokens", "running", 100), totalTokens: { input: 10, output: 15, total: 25, window: 30, windowPeak: 40 } },
 		});
 		fs.writeFileSync(path.join(route.eventSink, "0000000000200-invalid-tokens.json"), `${JSON.stringify({
 			type: "subagent.nested.updated",
@@ -347,7 +347,7 @@ describe("nested event parsing and projection", () => {
 
 		const registry = projectNestedEvents(route);
 
-		assert.deepEqual(registry.children.find((item) => item.id === "nested-valid-tokens")?.totalTokens, { input: 10, output: 15, total: 25 });
+		assert.deepEqual(registry.children.find((item) => item.id === "nested-valid-tokens")?.totalTokens, { input: 10, output: 15, total: 25, window: 30, windowPeak: 40 });
 		assert.equal(registry.children.find((item) => item.id === "nested-invalid-tokens")?.totalTokens, undefined);
 	});
 
@@ -472,3 +472,21 @@ describe("nested event parsing and projection", () => {
 		assert.equal(secondProjection.children[0]?.state, "complete");
 	});
 });
+
+describe("nested session-name projection", () => {
+	it("keeps bounded root and step session names from async status", () => {
+		const summary = nestedSummaryFromAsyncStatus({
+			runId: "child-run",
+			mode: "single",
+			state: "running",
+			startedAt: 1,
+			steps: [{
+				agent: "reviewer",
+				sessionName: "reviewer: Inspect the changed auth middleware",
+				status: "running",
+			}],
+		}, "/tmp/child-run", { id: "child-run", parentRunId: "root-run", depth: 1, ts: 1 });
+		assert.equal(summary.sessionName, "reviewer: Inspect the changed auth middleware");
+		assert.equal(summary.steps?.[0]?.sessionName, "reviewer: Inspect the changed auth middleware");
+	});
+});

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

@@ -10,6 +10,7 @@ import registerSubagentNotify, {
 	type SubagentNotifyDetails,
 } from "../../src/runs/background/notify.ts";
 import { SUBAGENT_ASYNC_COMPLETE_EVENT, SUBAGENT_FOREGROUND_COMPLETE_EVENT } from "../../src/shared/types.ts";
+import { createResultDeliveryOwnership } from "../../src/runs/background/result-delivery-ownership.ts";
 
 const COMPLETION_OWNER_ID = "completion-owner-a";
 
@@ -159,6 +160,47 @@ describe("registerSubagentNotify", () => {
 		assert.equal(sent.length, 0);
 	});
 
+	it("accepts only explicitly claimed predecessor-session completions", async () => {
+		const events = createEventBus();
+		const sent: unknown[] = [];
+		const pi = { events, sendMessage(message: unknown) { sent.push(message); } };
+		const state = { currentSessionId: "session-old" as string | null, completionOwnerId: COMPLETION_OWNER_ID };
+		const ownership = createResultDeliveryOwnership(state);
+		assert.equal(ownership.claimPredecessor("session-old", "session-old"), true);
+		state.currentSessionId = "session-new";
+		const notifier = registerSubagentNotify(pi as never, state, { batchConfig: { enabled: false }, ownership });
+		try {
+			assert.equal(await notifier.deliver(completionResult({ id: "predecessor", sessionId: "session-old" })), true);
+			assert.equal(await notifier.deliver(completionResult({ id: "foreign", sessionId: "session-foreign" })), false);
+			assert.equal(await notifier.deliver(completionResult({ id: "wrong-owner", sessionId: "session-old", completionOwnerId: "other-owner" })), false);
+			assert.equal(sent.length, 1);
+		} finally {
+			notifier.dispose();
+		}
+	});
+
+	it("rechecks session ownership before emitting a delayed batch", async () => {
+		const clock = createFakeClock();
+		const events = createEventBus();
+		const sent: unknown[] = [];
+		const pi = { events, sendMessage(message: unknown) { sent.push(message); } };
+		const state = { currentSessionId: "session-a" as string | null, completionOwnerId: COMPLETION_OWNER_ID };
+		const notifier = registerSubagentNotify(pi as never, state, {
+			batchConfig: { enabled: true, debounceMs: 150, maxWaitMs: 1000, stragglerDebounceMs: 75, stragglerMaxWaitMs: 400, stragglerWindowMs: 2000 },
+			timers: clock.api,
+			now: clock.now,
+		});
+		try {
+			const pending = notifier.deliver(completionResult({ id: "delayed-unclaimed" }));
+			state.currentSessionId = "session-b";
+			clock.advance(150);
+			assert.equal(await pending, false);
+			assert.equal(sent.length, 0);
+		} finally {
+			notifier.dispose();
+		}
+	});
+
 	it("does not wake the session when background delivery explicitly disables triggerTurn", async () => {
 		const { notifier, sent } = createPi("session-a");
 		assert.equal(await notifier.deliver(completionResult({ id: "direct-silent", triggerTurn: false })), true);
@@ -320,7 +362,7 @@ describe("registerSubagentNotify", () => {
 		assert.deepEqual(sent[0], {
 			message: {
 				customType: "subagent-notify",
-				content: "Background task paused: **workflow**\n\nRun 'detaches' detached for intercom coordination.\n\nWorkflow run: workflow-1\nChild runs: detaches=child-1 (paused)",
+				content: "Background task paused: **workflow**\n\nRun 'detaches' detached for intercom coordination.\n\nChild outputs:\n- key=detaches run=child-1 status=paused\n  Saved output: unavailable\n  Preview: unavailable (no safe inline output)\n\nWorkflow run: workflow-1\nChild runs: detaches=child-1 (paused)",
 				display: true,
 			},
 			options: { triggerTurn: true },
@@ -549,6 +591,89 @@ describe("completion formatting helpers", () => {
 		assert.equal(parsed?.reconciledFromDetachedChild, "child-2");
 	});
 
+	it("shows bounded child output paths and previews before workflow correlation metadata", () => {
+		const details = buildCompletionDetails({
+			id: "workflow-stopped",
+			runId: "workflow-stopped",
+			mode: "workflow",
+			agent: "workflow",
+			success: false,
+			state: "stopped",
+			summary: "Workflow stopped after one child completed.",
+			results: [
+				{
+					workflowKey: "review",
+					runId: "child-review",
+					agent: "worker",
+					success: true,
+					outputState: "present",
+					outputReference: "/tmp/review.md",
+					artifactPaths: { outputPath: "/tmp/legacy-review-path" },
+					output: `\u001b[31mReview heading\u001b[0m\n${"x".repeat(5_000)}`,
+				},
+				{
+					workflowKey: "stopped",
+					agent: "worker",
+					stopped: true,
+					outputState: "absent",
+					artifactPaths: { outputPath: "/tmp/stopped.md" },
+				},
+			],
+		});
+
+		assert.equal(details.status, "stopped");
+		assert.deepEqual(details.childOutputs?.map(({ workflowKey, runId, status, savedOutputPath }) => ({ workflowKey, runId, status, savedOutputPath })), [
+			{ workflowKey: "review", runId: "child-review", status: "completed", savedOutputPath: "/tmp/review.md" },
+			{ workflowKey: "stopped", runId: undefined, status: "stopped", savedOutputPath: undefined },
+		]);
+		assert.ok(Buffer.byteLength(details.childOutputs?.[0]?.preview ?? "", "utf8") <= 4 * 1024);
+
+		const content = formatSingleCompletion(details);
+		assert.match(content, /Child outputs:/);
+		assert.match(content, /key=review run=child-review status=completed/);
+		assert.match(content, /Saved output: \/tmp\/review\.md/);
+		assert.match(content, /Review heading/);
+		assert.doesNotMatch(content, /legacy-review-path/);
+		assert.match(content, /preview truncated/);
+		assert.match(content, /key=stopped run=unavailable status=stopped/);
+		assert.match(content, /Saved output: unavailable/);
+		assert.match(content, /Preview: unavailable \(no safe inline output\)/);
+		assert.doesNotMatch(content, /\u001b/);
+		assert.match(content, /Workflow run: workflow-stopped/);
+		assert.match(content, /Child runs: review=child-review \(completed\), stopped=unavailable \(stopped\)/);
+
+		const parsed = parseSubagentNotifyContent(content);
+		assert.equal(parsed?.workflowRunId, "workflow-stopped");
+		assert.match(parsed?.resultPreview ?? "", /Child outputs:/);
+		assert.match(parsed?.resultPreview ?? "", /Review heading/);
+		assert.doesNotMatch(parsed?.resultPreview ?? "", /Workflow run:/);
+	});
+
+	it("does not label artifact-only paths as saved workflow output", () => {
+		const details = buildCompletionDetails({
+			id: "workflow-artifact-only",
+			runId: "workflow-artifact-only",
+			mode: "workflow",
+			agent: "workflow",
+			success: true,
+			results: [{
+				workflowKey: "artifact-only",
+				runId: "child-artifact-only",
+				agent: "worker",
+				success: true,
+				outputState: "present",
+				output: "inline artifact-only report",
+				artifactPaths: { outputPath: "/tmp/pi/async/child-artifact-only" },
+			}],
+		});
+
+		const content = formatSingleCompletion(details);
+		assert.match(content, /key=artifact-only run=child-artifact-only status=completed/);
+		assert.match(content, /Saved output: unavailable/);
+		assert.match(content, /inline artifact-only report/);
+		assert.doesNotMatch(content, /\/tmp\/pi\/async\/child-artifact-only/);
+	});
+
 	it("reports false when Pi rejects sendMessage synchronously", async () => {
 		const pi = { events: createEventBus(), sendMessage() { throw new Error("runtime inactive"); } };
 		const notifier = registerSubagentNotify(pi as never, { currentSessionId: "session-a" }, { batchConfig: { enabled: false } });
@@ -558,6 +683,9 @@ describe("completion formatting helpers", () => {
 
 	it("buildCompletionDetails derives paused and stopped statuses", () => {
 		assert.equal(buildCompletionDetails({ id: "x", agent: "w", success: false, state: "paused", summary: "Paused after interrupt.", timestamp: 1 }).status, "paused");
+		assert.equal(buildCompletionDetails({ id: "x", agent: "w", success: false, interrupted: true, summary: "interrupted", timestamp: 1 }).status, "paused");
+		const pausedWorkflow = buildCompletionDetails({ id: "workflow", agent: "workflow", mode: "workflow", state: "paused", results: [{ workflowKey: "failed", success: false }] });
+		assert.equal(pausedWorkflow.childOutputs?.[0]?.status, "failed");
 		assert.equal(buildCompletionDetails({ id: "x", agent: "w", success: false, summary: "boom", exitCode: 1, timestamp: 1 }).status, "failed");
 		assert.equal(buildCompletionDetails({ id: "x", agent: "w", success: false, summary: "terminated", exitCode: 1, processSignal: "SIGTERM", timestamp: 1 }).status, "stopped");
 		assert.equal(buildCompletionDetails({ id: "x", agent: "w", success: false, summary: "terminated", results: [{ success: false, exitCode: 1, processSignal: "SIGTERM" }], timestamp: 1 }).status, "stopped");

package/dist/extensions/pi-subagents/test/unit/orca-progress-tabs.test.ts

@@ -256,7 +256,7 @@ test("enabled tabs use a worktree sequence and successful Pi sessions get cleanu
 	assert.doesNotMatch(viewer, /(?:&|;)\s*exit(?:\s|$)/);
 
 	const progressDir = path.join(TEMP_ROOT_DIR, "orca-progress");
-	const manifestDir = path.join(dir, ".selesai", "subagents", "views", "orca");
+	const manifestDir = path.join(dir, ".pi-subagents", "views", "orca");
 	const manifestName = fs.readdirSync(manifestDir).find((name) => name.startsWith(`${runId}-2-`) && name.endsWith(".json"));
 	assert.ok(manifestName);
 	const manifest = await readManifestWithState(path.join(manifestDir, manifestName), "open");
@@ -272,7 +272,7 @@ test("enabled tabs use a worktree sequence and successful Pi sessions get cleanu
 	assert.match(text, /done output/);
 	const quotedSessionFile = `'${fs.realpathSync(sessionFile).replace(/'/g, `'"'"'`)}'`;
 	assert.ok(text.includes(`completed. To remove the Pi session for this run, run rm -- ${quotedSessionFile}`));
-	assert.doesNotMatch(text, /find ~\/\.pi\/agent\/sessions/);
+	assert.doesNotMatch(text, /find ~\/\.selesai[\\/]agent\/sessions/);
 
 	const nestedCwd = path.join(dir, "packages", "app");
 	fs.mkdirSync(nestedCwd, { recursive: true });