@selesai/code 0.13.40 → 0.14.3

package/dist/extensions/pi-subagents/test/unit/typed-gate-output.test.ts

@@ -0,0 +1,141 @@
+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 { describe, it } from "node:test";
+import {
+	acceptanceFailureMessage,
+	acceptanceHasTypedVerify,
+	evaluateAcceptance,
+	normalizeGateAcceptance,
+	parseGateInput,
+	resolveEffectiveAcceptance,
+	typedVerifyOutput,
+	validateAcceptanceInput,
+} from "../../src/runs/shared/acceptance.ts";
+
+function tempGitRepo(): string {
+	const dir = fs.mkdtempSync(path.join(os.tmpdir(), "typed-gate-"));
+	execFileSync("git", ["init", "-q"], { cwd: dir });
+	execFileSync("git", ["-c", "user.name=t", "-c", "user.email=t@t", "commit", "-q", "--allow-empty", "-m", "init"], { cwd: dir });
+	return dir;
+}
+
+/** A gate command that prints exactly `text` on stdout and exits 0. */
+function printing(text: string): string {
+	return `${process.execPath} -e "process.stdout.write(process.argv[1])" ${JSON.stringify(text)}`;
+}
+
+async function runGate(gate: unknown, cwd: string, extra: { artifactsDir?: string; runId?: string } = {}) {
+	const normalized = normalizeGateAcceptance(gate, undefined);
+	assert.equal(normalized.ok, true, normalized.ok ? undefined : normalized.error);
+	const acceptance = resolveEffectiveAcceptance({
+		agentName: "reviewer",
+		task: "Review the report.",
+		explicit: normalized.ok ? normalized.acceptance : undefined,
+		agentContract: { version: 1 },
+	});
+	return evaluateAcceptance({ acceptance, output: "done", cwd, reportOptional: true, ...extra });
+}
+
+describe("gate object form", () => {
+	it("parses the string form and the object form", () => {
+		assert.deepEqual(parseGateInput(" npm test "), { ok: true, gate: { command: "npm test" } });
+		assert.deepEqual(parseGateInput({ command: "classify.sh", output: "json", timeoutMs: 5000 }), {
+			ok: true,
+			gate: { command: "classify.sh", output: "json", timeoutMs: 5000 },
+		});
+		assert.deepEqual(normalizeGateAcceptance({ command: "classify.sh", output: "json", schema: { type: "object" } }, undefined), {
+			ok: true,
+			acceptance: { level: "verified", verify: [{ id: "gate", command: "classify.sh", output: "json", schema: { type: "object" } }] },
+		});
+	});
+
+	it("rejects malformed object gates with a field-level message", () => {
+		for (const [gate, pattern] of [
+			[{}, /non-empty command string/],
+			[{ command: " " }, /non-empty command string/],
+			[{ command: "x", output: "yaml" }, /gate\.output must be "json"/],
+			[{ command: "x", schema: { type: "object" } }, /gate\.schema requires gate\.output/],
+			[{ command: "x", output: "json", schema: "nope" }, /gate\.schema must be a JSON Schema object/],
+			[{ command: "x", timeoutMs: 0 }, /gate\.timeoutMs must be an integer/],
+			[{ command: "x", cwd: "." }, /gate\.cwd is not supported/],
+			[["x"], /non-empty command string/],
+		] as const) {
+			const parsed = parseGateInput(gate);
+			assert.equal(parsed.ok, false, JSON.stringify(gate));
+			assert.match(parsed.ok ? "" : parsed.error, pattern, JSON.stringify(gate));
+		}
+	});
+
+	it("detects typed verify commands in either spelling", () => {
+		assert.equal(acceptanceHasTypedVerify(undefined), false);
+		assert.equal(acceptanceHasTypedVerify("checked"), false);
+		assert.equal(acceptanceHasTypedVerify({ level: "verified", verify: [{ id: "v", command: "x" }] }), false);
+		assert.equal(acceptanceHasTypedVerify({ level: "verified", verify: [{ id: "v", command: "x", output: "json" }] }), true);
+		const gate = normalizeGateAcceptance({ command: "x", output: "json" }, undefined);
+		assert.equal(gate.ok && acceptanceHasTypedVerify(gate.acceptance), true);
+	});
+
+	it("accepts output and schema on explicit acceptance.verify entries", () => {
+		assert.deepEqual(validateAcceptanceInput({ level: "verified", verify: [{ id: "v", command: "x", output: "json", schema: { type: "object" } }] }), []);
+		assert.match(validateAcceptanceInput({ level: "verified", verify: [{ id: "v", command: "x", output: "text" }] }).join("\n"), /output must be "json"/);
+		assert.match(validateAcceptanceInput({ level: "verified", verify: [{ id: "v", command: "x", schema: {} }] }).join("\n"), /schema requires output/);
+	});
+});
+
+describe("typed gate output", () => {
+	it("parses a passing json gate's stdout into the verify run and exposes it", async () => {
+		const cwd = tempGitRepo();
+		const ledger = await runGate({ command: printing('{"verdict":"blocked","score":0.9}'), output: "json" }, cwd);
+		assert.equal(ledger.status, "verified");
+		assert.equal(ledger.verifyRuns[0]?.status, "passed");
+		assert.deepEqual(ledger.verifyRuns[0]?.structuredOutput, { verdict: "blocked", score: 0.9 });
+		assert.deepEqual(typedVerifyOutput(ledger), { value: { verdict: "blocked", score: 0.9 } });
+	});
+
+	it("validates the parsed stdout against gate.schema", async () => {
+		const cwd = tempGitRepo();
+		const schema = { type: "object", properties: { verdict: { type: "string", enum: ["ok", "blocked"] } }, required: ["verdict"], additionalProperties: false };
+		const good = await runGate({ command: printing('{"verdict":"ok"}'), output: "json", schema }, cwd);
+		assert.equal(good.status, "verified");
+		assert.deepEqual(typedVerifyOutput(good), { value: { verdict: "ok" } });
+
+		const bad = await runGate({ command: printing('{"verdict":"maybe"}'), output: "json", schema }, cwd);
+		assert.equal(bad.status, "rejected");
+		assert.equal(bad.verifyRuns[0]?.status, "failed");
+		assert.match(bad.verifyRuns[0]?.structuredOutputError ?? "", /does not match gate\.schema/);
+		assert.match(acceptanceFailureMessage(bad) ?? "", /verification 'gate' failed: output: "json" stdout does not match gate\.schema/);
+		assert.equal(typedVerifyOutput(bad), undefined);
+	});
+
+	it("fails the gate on invalid or empty stdout instead of dropping the verdict", async () => {
+		const cwd = tempGitRepo();
+		const invalid = await runGate({ command: printing("WRITER-FIX report=x"), output: "json" }, cwd);
+		assert.equal(invalid.status, "rejected");
+		assert.match(invalid.verifyRuns[0]?.structuredOutputError ?? "", /not valid JSON/);
+
+		const empty = await runGate({ command: printing(""), output: "json" }, cwd);
+		assert.equal(empty.status, "rejected");
+		assert.match(empty.verifyRuns[0]?.structuredOutputError ?? "", /printed nothing/);
+	});
+
+	it("leaves string gates and non-json verify commands untouched", async () => {
+		const cwd = tempGitRepo();
+		const plain = await runGate(printing('{"verdict":"blocked"}'), cwd);
+		assert.equal(plain.status, "verified");
+		assert.equal(plain.verifyRuns[0]?.structuredOutput, undefined);
+		assert.equal(typedVerifyOutput(plain), undefined);
+	});
+
+	it("never memoizes a typed gate, because its input can change without the tracked tree changing", async () => {
+		const cwd = tempGitRepo();
+		const artifactsDir = path.join(cwd, ".artifacts");
+		const first = await runGate({ command: printing('{"n":1}'), output: "json" }, cwd, { artifactsDir, runId: "typed-memo" });
+		const second = await runGate({ command: printing('{"n":1}'), output: "json" }, cwd, { artifactsDir, runId: "typed-memo" });
+		assert.equal(first.verifyRuns[0]?.memoized, undefined);
+		assert.equal(second.verifyRuns[0]?.memoized, undefined);
+		assert.equal(second.verifyRuns[0]?.cacheKey, undefined);
+	});
+});

package/dist/extensions/pi-subagents/test/unit/upgrade-notice.test.ts

@@ -0,0 +1,31 @@
+import assert from "node:assert/strict";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { it } from "node:test";
+import { showUpgradeNotice } from "../../src/extension/upgrade-notice.ts";
+
+const CHANGELOG = "## [Unreleased]\n\n### Highlights\n\n- Unreleased.\n\n## [0.3.0]\n\n### Highlights\n\n- Newest [highlight](https://example.com).\n\n### Fixed\n\n- Not a highlight.\n\n## [0.2.0]\n\n### Highlights\n\n- Middle highlight.\n\n## [0.1.0]\n\n### Highlights\n\n- Already seen.\n";
+
+it("announces each upgrade's highlights once, only in a UI session", async () => {
+	const dir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-upgrade-notice-"));
+	const changelog = path.join(dir, "CHANGELOG.md");
+	fs.writeFileSync(changelog, CHANGELOG);
+	const notices: string[] = [];
+	const start = (version: string, hasUI = true) => showUpgradeNotice({ hasUI, ui: { notify: (message: string) => notices.push(message) } }, dir, changelog, version);
+	try {
+		await start("0.1.0", false);
+		assert.equal(fs.existsSync(path.join(dir, "last-seen-version.json")), false);
+		await start("0.1.0");
+		await start("0.1.0");
+		assert.deepEqual(notices, []);
+		await start("0.3.0");
+		await start("0.3.0");
+		assert.deepEqual(notices, ["pi-subagents updated from 0.1.0 to 0.3.0\n- Newest highlight.\n- Middle highlight.\nChangelog: https://github.com/nicobailon/pi-subagents/blob/main/CHANGELOG.md"]);
+		fs.writeFileSync(path.join(dir, "last-seen-version.json"), "{");
+		await start("0.3.0");
+		assert.deepEqual([notices.length, JSON.parse(fs.readFileSync(path.join(dir, "last-seen-version.json"), "utf-8"))], [1, { version: "0.3.0" }]);
+	} finally {
+		fs.rmSync(dir, { recursive: true, force: true });
+	}
+});

package/dist/extensions/pi-subagents/test/unit/usage-reconciliation-owners.test.ts

@@ -0,0 +1,66 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import type { AgentMessage } from "@earendil-works/pi-agent-core";
+import type { ChildSession, ChildSessionEvent, ChildSessionFactory } from "../../src/runs/shared/child-session.ts";
+import { runSync } from "../../src/runs/foreground/execution.ts";
+import { runChildSession } from "../../src/runs/background/run-child-session.ts";
+import { buildRunnerChildLaunch } from "../../src/runs/background/runner-child-launch.ts";
+import { toSubagentDelegationUpdate } from "../../src/slash/delegation-adapters.ts";
+import { makeAgent } from "../support/helpers.ts";
+
+const inherited = { role: "assistant", content: [{ type: "text", text: "old" }], timestamp: 1, usage: { input: 100, output: 100, cacheRead: 100, cacheWrite: 100, cost: { total: 100 } } } as unknown as AgentMessage;
+const liveMessage = { role: "assistant", content: [{ type: "text", text: "done" }], stopReason: "stop", model: "mock/test", usage: { input: 5, output: 3 } } as unknown as AgentMessage;
+const persistedMessage = { ...liveMessage, timestamp: 2, usage: { input: 5, output: 3, cacheRead: 7, cacheWrite: 2, cost: { total: 0.4 } } } as unknown as AgentMessage;
+const expected = { input: 5, output: 3, cacheRead: 7, cacheWrite: 2, cost: 0.4, turns: 1 };
+
+function scriptedFactory(fail = false): ChildSessionFactory {
+	return {
+		async create() {
+			const listeners = new Set<(event: ChildSessionEvent) => void>();
+			let terminal: readonly AgentMessage[] = [inherited];
+			return {
+				subscribe(listener) { listeners.add(listener); return () => listeners.delete(listener); },
+				async prompt() {
+					for (const listener of listeners) listener({ type: "message_end", message: liveMessage } as ChildSessionEvent);
+					terminal = [inherited, persistedMessage];
+					if (fail) throw new Error("prompt failed after usage");
+				},
+				async steer() {}, async followUp() {}, async abort() {}, async dispose() {},
+				get messages() { return terminal; },
+				get sessionFile() { return undefined; },
+				get sessionId() { return "usage-test"; },
+				get modelId() { return "mock/test"; },
+			} satisfies ChildSession;
+		},
+		async dispose() {},
+	};
+}
+
+describe("terminal usage reconciliation owners", () => {
+	it("reconciles foreground runSync usage before its terminal progress update", async () => {
+		const updates: any[] = [];
+		const result = await runSync(process.cwd(), [makeAgent("worker")], "worker", "test usage", {
+			acceptance: false,
+			childSessionFactory: scriptedFactory(),
+			onUpdate(update) { updates.push(update.details); },
+		});
+		assert.deepEqual(result.usage, expected);
+		const details = updates.at(-1)!;
+		assert.deepEqual(details.results[0]!.usage, expected);
+		assert.deepEqual({ tokens: details.progress[0]!.tokens, inputTokens: details.progress[0]!.inputTokens, outputTokens: details.progress[0]!.outputTokens, turnCount: details.progress[0]!.turnCount }, { tokens: 8, inputTokens: 5, outputTokens: 3, turnCount: 1 });
+		assert.equal(details.progress[0]!.cacheRead, undefined);
+		assert.equal(details.progress[0]!.cacheWrite, undefined);
+		const update = toSubagentDelegationUpdate({ requestId: "usage-test", ownerRunId: "owner", nodeId: "node", agent: "worker", task: "test usage", context: "fresh", cwd: process.cwd(), result: { kind: "text" } }, { details });
+		assert.equal(update?.usage, undefined);
+	});
+
+	it("reconciles background settlement after success and failure", async () => {
+		for (const fail of [false, true]) {
+			const launch = buildRunnerChildLaunch({ agent: "worker", task: "test usage", cwd: process.cwd(), inheritProjectContext: false, inheritGlobalContext: false, inheritSkills: false }, { cwd: process.cwd(), id: `usage-${fail}`, flatIndex: 0 }, { sessionEnabled: true, watchdogStatus() {} });
+			const result = await runChildSession({ factory: scriptedFactory(fail), launch, prompt: "Task: test usage", appendChildEvent() {}, writeOutputLine() {} });
+			assert.deepEqual(result.usage, expected);
+			assert.equal(result.exitCode, fail ? 1 : 0);
+			if (fail) assert.match(result.error ?? "", /prompt failed after usage/u);
+		}
+	});
+});

package/dist/extensions/pi-subagents/test/unit/usage-reconciliation.test.ts

@@ -0,0 +1,23 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { reconcileAttemptUsage } from "../../src/runs/shared/usage-reconciliation.ts";
+import type { Usage } from "../../src/shared/types.ts";
+
+const live: Usage = { input: 20, output: 10, cacheRead: 3, cacheWrite: 4, cost: 2, turns: 9 };
+const assistant = (usage: Record<string, unknown>, timestamp?: number) => ({ role: "assistant", content: [], usage, ...(timestamp === undefined ? {} : { timestamp }) });
+
+describe("attempt usage reconciliation", () => {
+	it("applies the public field-completeness and attempt-baseline contract", () => {
+		assert.deepEqual(reconcileAttemptUsage(live, [{ role: "user" }], 0), live);
+		assert.deepEqual(reconcileAttemptUsage(live, [assistant({ input: 999, output: 999, cacheRead: 999, cacheWrite: 999, cost: 999 }), { role: "user" }, assistant({ input: 2, output: 1, cacheRead: 0, cacheWrite: 0, cost: { total: 0.2 } })], 2), { input: 2, output: 1, cacheRead: 0, cacheWrite: 0, cost: 0.2, turns: 1 });
+		assert.deepEqual(reconcileAttemptUsage(live, [assistant({ input: 2, output: 1, cacheRead: 3, cacheWrite: 4, cost: 0.25 }), assistant({ input: 4, output: 3, cacheRead: 2, cacheWrite: 1, cost: { total: 0.5 } })], 0), { input: 6, output: 4, cacheRead: 5, cacheWrite: 5, cost: 0.75, turns: 2 });
+		assert.deepEqual(reconcileAttemptUsage(live, [assistant({ input: -1, inputTokens: 5, output: Number.NaN, outputTokens: 2, cacheRead: 0, cacheWriteTokens: 1, cost: { total: 0 } })], 0), { input: 5, output: 2, cacheRead: 0, cacheWrite: 1, cost: 0, turns: 1 });
+		assert.deepEqual(reconcileAttemptUsage({ input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 4 }, [assistant({ inputTokens: 5, outputTokens: 2, cacheReadTokens: 1, cacheWriteTokens: 1, cost: 0.25 })], 0), { input: 5, output: 2, cacheRead: 1, cacheWrite: 1, cost: 0.25, turns: 1 });
+		assert.deepEqual(reconcileAttemptUsage(live, [assistant({ input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0 })], 0), { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 1 });
+		assert.deepEqual(reconcileAttemptUsage(live, [assistant({ input: 1, output: 1, cacheRead: 1, cacheWrite: 1, cost: 1 }), assistant({ input: 2, output: "bad", cacheRead: -1, cacheWrite: 2, cost: {} })], 0), { input: 3, output: 10, cacheRead: 3, cacheWrite: 3, cost: 2, turns: 2 });
+		assert.deepEqual(reconcileAttemptUsage(live, [assistant({ input: 1, output: 2, cacheRead: 3, cacheWrite: 4, cost: 5 }, 10), assistant({ input: 1, output: 2, cacheRead: 3, cacheWrite: 4, cost: 5 }, 10), assistant({ input: 1, output: 2, cacheRead: 3, cacheWrite: 4, cost: 5 }, 11)], 0), { input: 2, output: 4, cacheRead: 6, cacheWrite: 8, cost: 10, turns: 2 });
+		assert.equal(reconcileAttemptUsage(live, [assistant({ input: 1 }, 10), { role: "user" }, assistant({ input: 1 }, 10)], 0).turns, 2, "only adjacent duplicate projections collapse");
+		assert.equal(reconcileAttemptUsage(live, [assistant({ input: 1 }), assistant({ input: 1 })], 0).turns, 2, "messages without timestamp identity remain distinct");
+		assert.deepEqual(reconcileAttemptUsage(live, [assistant({ input: 1 }, 10)], 2), live, "contracted message lists retain live evidence");
+	});
+});

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

@@ -1,8 +1,202 @@
 import assert from "node:assert/strict";
 import { describe, it } from "node:test";
-import { toWaitCompletion } from "../../src/runs/background/wait-completions.ts";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { writeCompletionReplay } from "../../src/runs/background/completion-replay.ts";
+import { writeAsyncResultFile } from "../../src/runs/background/result-files.ts";
+import type { SubagentState, WaitCompletion } from "../../src/shared/types.ts";
+import type { AsyncRunSummary } from "../../src/runs/background/async-status.ts";
+import { collectWaitCompletions, recordWaitCompletion, toWaitCompletion } from "../../src/runs/background/wait-completions.ts";
 
 describe("workflow wait completion projection", () => {
+	it("returns readable evidence references from the matched result namespace and its replay", (t) => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-wait-evidence-"));
+		t.after(() => fs.rmSync(root, { recursive: true, force: true }));
+		const resultsDir = path.join(root, "nested", "root-run");
+		const runId = "persona";
+		const data = { runId, sessionId: "owner", results: [{ agent: "persona", output: "NESTED_FINDING" }] };
+		const resultPath = path.join(resultsDir, `${runId}.json`);
+		writeAsyncResultFile(resultPath, data);
+		writeAsyncResultFile(path.join(root, `${runId}.json`), { ...data, results: [{ output: "WRONG_NAMESPACE" }] });
+		const terminal: AsyncRunSummary[] = [{ id: runId, sessionId: "owner", asyncDir: root, mode: "single", state: "complete", startedAt: Date.now(), steps: [] }];
+		// SAFETY: the collector only reads the optional completedResults store from this fixture.
+		const state = { currentSessionId: "owner" } as SubagentState;
+		const references: string[] = [];
+		assert.equal(collectWaitCompletions(terminal, state, resultsDir, (text) => references.push(text))?.[0]?.runId, runId);
+		assert.deepEqual(references, [`Result [${runId}]: ${resultPath}`]);
+		assert.equal(JSON.parse(fs.readFileSync(resultPath, "utf8")).results[0].output, "NESTED_FINDING");
+		const replay = writeCompletionReplay({ resultsDir, runId, sessionId: "owner", completion: toWaitCompletion(data, runId), data, now: Date.now(), ttlMs: 60_000 });
+		fs.rmSync(resultPath);
+		references.length = 0;
+		assert.equal(collectWaitCompletions(terminal, state, resultsDir, (text) => references.push(text))?.[0]?.archivePath, replay.archivePath);
+		assert.deepEqual(references, [`Result [${runId}]: ${replay.archivePath}`]);
+		assert.equal(JSON.parse(fs.readFileSync(replay.archivePath, "utf8")).entries[0].text, "NESTED_FINDING");
+		assert.equal(collectWaitCompletions([{ ...terminal[0]!, sessionId: "sibling" }], state, resultsDir), undefined);
+	});
+
+	it("only references an unindexed public fallback owned by the completed run session", (t) => {
+		const resultsDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-wait-public-fallback-"));
+		t.after(() => fs.rmSync(resultsDir, { recursive: true, force: true }));
+		const runId = "shared-run";
+		const terminal: AsyncRunSummary[] = [{ id: runId, sessionId: "owner", asyncDir: resultsDir, mode: "single", state: "complete", startedAt: Date.now(), steps: [] }];
+		// SAFETY: recordWaitCompletion initializes the only state collection used by this fixture.
+		const state = { currentSessionId: "owner" } as SubagentState;
+		recordWaitCompletion(state, runId, { runId, sessionId: "owner", agent: "owner-agent", success: true }, Date.now(), 60_000);
+		const resultPath = path.join(resultsDir, `${runId}.json`);
+		fs.writeFileSync(resultPath, JSON.stringify({ runId, sessionId: "foreign", agent: "foreign-agent", state: "failed", results: [{ error: "FOREIGN_PAYLOAD" }] }));
+
+		const foreignReferences: string[] = [];
+		const foreignCompletion = collectWaitCompletions(terminal, state, resultsDir, (text) => foreignReferences.push(text))?.[0];
+		assert.deepEqual(foreignReferences, []);
+		assert.equal(foreignCompletion?.agent, "owner-agent");
+		assert.equal(foreignCompletion?.state, undefined);
+		assert.equal(foreignCompletion?.results, undefined);
+		assert.doesNotMatch(JSON.stringify(foreignCompletion), /foreign-agent|FOREIGN_PAYLOAD/);
+
+		fs.writeFileSync(resultPath, JSON.stringify({ runId, sessionId: "owner", agent: "owner-payload" }));
+		const ownerReferences: string[] = [];
+		const ownerCompletion = collectWaitCompletions(terminal, state, resultsDir, (text) => ownerReferences.push(text))?.[0];
+		assert.equal(ownerCompletion?.agent, "owner-agent");
+		assert.deepEqual(ownerReferences, [`Result [${runId}]: ${resultPath}`]);
+	});
+
+	it("does not surface an in-memory completion after the run id is reused by another session", (t) => {
+		const resultsDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-wait-memory-owner-"));
+		t.after(() => fs.rmSync(resultsDir, { recursive: true, force: true }));
+		const runId = "shared-run";
+		const state = { currentSessionId: "session-b" } as SubagentState;
+		assert.equal(recordWaitCompletion(state, runId, {
+			runId,
+			sessionId: "session-a",
+			agent: "session-a-agent",
+			state: "failed",
+			results: [{ error: "SESSION_A_ONLY" }],
+		}, Date.now(), 60_000, { resultsDir, sessionId: "session-a" }), true);
+		const terminal = [{ id: runId, sessionId: "session-b" }] as AsyncRunSummary[];
+		const references: string[] = [];
+
+		assert.equal(collectWaitCompletions(terminal, state, resultsDir, (text) => references.push(text)), undefined);
+		assert.deepEqual(references, []);
+		assert.equal(state.completedResults?.get(runId)?.sessionId, "session-a");
+	});
+
+	it("owner-gates the in-memory completion discovered during the result-file race", (t) => {
+		const resultsDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-wait-late-memory-owner-"));
+		t.after(() => fs.rmSync(resultsDir, { recursive: true, force: true }));
+		const runId = "shared-run";
+		const completion = toWaitCompletion({ agent: "recorded-agent", success: true }, runId);
+		const entry = { sessionId: "session-a", seenAt: Date.now(), completion };
+		class LateCompletionMap extends Map<string, typeof entry> {
+			private reads = 0;
+			override get(key: string): typeof entry | undefined {
+				this.reads += 1;
+				return this.reads === 1 ? undefined : super.get(key);
+			}
+		}
+		const collect = (sessionId: string): WaitCompletion[] | undefined => {
+			const completedResults = new LateCompletionMap([[runId, entry]]);
+			const state = { currentSessionId: sessionId, completedResults } as SubagentState;
+			return collectWaitCompletions([{ id: runId, sessionId }] as AsyncRunSummary[], state, resultsDir);
+		};
+
+		assert.equal(collect("session-b"), undefined);
+		assert.equal(collect("session-a")?.[0]?.agent, "recorded-agent");
+	});
+
+	it("refuses to record a completion without matching payload and persistence ownership", (t) => {
+		const resultsDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-wait-record-owner-"));
+		t.after(() => fs.rmSync(resultsDir, { recursive: true, force: true }));
+		const state = { currentSessionId: "session-a" } as SubagentState;
+
+		assert.equal(recordWaitCompletion(state, "missing", { runId: "missing" }, Date.now(), 60_000), false);
+		assert.equal(recordWaitCompletion(state, "expected-run", {
+			runId: "foreign-run",
+			sessionId: "session-a",
+			agent: "foreign-agent",
+		}, Date.now(), 60_000), false);
+		assert.equal(recordWaitCompletion(state, "mismatch", {
+			runId: "mismatch",
+			sessionId: "session-a",
+		}, Date.now(), 60_000, { resultsDir, sessionId: "session-b" }), false);
+		assert.equal(state.completedResults, undefined);
+		assert.equal(fs.existsSync(path.join(resultsDir, "completion-replay")), false);
+	});
+
+	it("rejects foreign unindexed public payloads before the watcher records completion", (t) => {
+		const resultsDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-wait-public-prewatcher-"));
+		t.after(() => fs.rmSync(resultsDir, { recursive: true, force: true }));
+		const runId = "shared-run";
+		const terminal: AsyncRunSummary[] = [{ id: runId, sessionId: "owner", asyncDir: resultsDir, mode: "single", state: "complete", startedAt: Date.now(), steps: [] }];
+		const state = { currentSessionId: "owner" } as SubagentState;
+		const resultPath = path.join(resultsDir, `${runId}.json`);
+		fs.writeFileSync(resultPath, JSON.stringify({ runId, sessionId: "foreign", agent: "foreign-agent", state: "failed", results: [{ error: "FOREIGN_PAYLOAD" }] }));
+
+		const foreignReferences: string[] = [];
+		const foreignCompletion = collectWaitCompletions(terminal, state, resultsDir, (text) => foreignReferences.push(text));
+		assert.equal(foreignCompletion, undefined);
+		assert.deepEqual(foreignReferences, []);
+
+		fs.writeFileSync(resultPath, JSON.stringify({ runId, sessionId: "owner", agent: "owner-agent", state: "complete", success: true }));
+		const ownerReferences: string[] = [];
+		const ownerCompletion = collectWaitCompletions(terminal, state, resultsDir, (text) => ownerReferences.push(text))?.[0];
+		assert.equal(ownerCompletion?.agent, "owner-agent");
+		assert.equal(ownerCompletion?.state, "complete");
+		assert.equal(ownerCompletion?.success, true);
+		assert.deepEqual(ownerReferences, [`Result [${runId}]: ${resultPath}`]);
+	});
+
+	it("validates stale indexed public payload ownership with and without memory", (t) => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-wait-stale-index-"));
+		t.after(() => fs.rmSync(root, { recursive: true, force: true }));
+		for (const hasMemory of [false, true]) {
+			for (const payloadOwner of ["owner", "foreign"]) {
+				const resultsDir = path.join(root, `${hasMemory ? "memory" : "no-memory"}-${payloadOwner}`);
+				const runId = "shared-run";
+				const resultPath = path.join(resultsDir, `${runId}.json`);
+				writeAsyncResultFile(resultPath, { runId, sessionId: "owner", agent: "initial-owner" });
+				// Leave the owner's index intact while replacing its public payload.
+				fs.writeFileSync(resultPath, JSON.stringify({
+					runId,
+					sessionId: payloadOwner,
+					agent: `${payloadOwner}-payload`,
+					state: payloadOwner === "owner" ? "complete" : "failed",
+					results: payloadOwner === "foreign" ? [{ error: "FOREIGN_PAYLOAD" }] : undefined,
+				}));
+				const terminal: AsyncRunSummary[] = [{ id: runId, sessionId: "owner", asyncDir: resultsDir, mode: "single", state: "complete", startedAt: Date.now(), steps: [] }];
+				const state = { currentSessionId: "owner" } as SubagentState;
+				if (hasMemory) recordWaitCompletion(state, runId, { runId, sessionId: "owner", agent: "memory-owner", success: true }, Date.now(), 60_000);
+				const references: string[] = [];
+				const completion = collectWaitCompletions(terminal, state, resultsDir, (text) => references.push(text))?.[0];
+
+				if (payloadOwner === "owner") {
+					assert.equal(completion?.agent, hasMemory ? "memory-owner" : "owner-payload");
+					assert.deepEqual(references, [`Result [${runId}]: ${resultPath}`]);
+				} else {
+					assert.equal(completion?.agent, hasMemory ? "memory-owner" : undefined);
+					assert.deepEqual(references, []);
+					assert.doesNotMatch(JSON.stringify(completion) ?? "", /foreign-payload|FOREIGN_PAYLOAD|failed/);
+				}
+			}
+		}
+	});
+
+	it("reports malformed indexed payloads", (t) => {
+		const resultsDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-wait-malformed-indexed-"));
+		t.after(() => fs.rmSync(resultsDir, { recursive: true, force: true }));
+		const runId = "malformed-run";
+		const resultPath = path.join(resultsDir, `${runId}.json`);
+		writeAsyncResultFile(resultPath, { runId, sessionId: "owner", agent: "initial-owner" });
+		fs.writeFileSync(resultPath, "{\"runId\":");
+		const terminal: AsyncRunSummary[] = [{ id: runId, sessionId: "owner", asyncDir: resultsDir, mode: "single", state: "complete", startedAt: Date.now(), steps: [] }];
+		const references: string[] = [];
+		assert.throws(
+			() => collectWaitCompletions(terminal, { currentSessionId: "owner" } as SubagentState, resultsDir, (text) => references.push(text)),
+			/Failed to read subagent result .*Unexpected end of JSON input/,
+		);
+		assert.deepEqual(references, []);
+	});
+
 	it("omits absent and malformed receipt references", () => {
 		for (const workflowReceipt of [undefined, null, [], "path", { path: "" }, { path: 42 }]) {
 			assert.equal("workflowReceiptPath" in toWaitCompletion({ workflowReceipt }, "run"), false);

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

@@ -168,6 +168,8 @@ describe("non-blocking wait subscriptions", () => {
 
 			writeStatus(asyncRoot, "run-exact", "complete", { sessionId: "session-a" });
 			recordWaitCompletion(restoredState, "run-exact", {
+				runId: "run-exact",
+				sessionId: "session-a",
 				agent: "worker",
 				state: "complete",
 				success: true,
@@ -660,4 +662,4 @@ describe("wait subscriptions armed by another session", () => {
 			fs.rmSync(root, { recursive: true, force: true });
 		}
 	});
-});
+});

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

@@ -6,66 +6,50 @@ import {
 	acceptChildWatchdogEvent,
 	applyChildWatchdogMessage,
 	childWatchdogIsActive,
+	childWatchdogProgressForModel,
 	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;
-}
+import { childResolvedConfig } from "../../src/watchdog/register-child.ts";
 
 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);
+	it("marks status-event findings addressed on assistant turns", () => {
+		const snapshot = acceptChildWatchdogEvent({ current: undefined, event: {
+			type: CHILD_WATCHDOG_STATUS_EVENT, seq: 1, phase: "idle", ts: 5,
+			warning: { severity: "blocker", importance: "high", category: "correctness", summary: "Unverified tests", evidence: "No test command.", recommendedAction: "Run tests.", addressed: false, 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" });
+		const addressed = applyChildWatchdogMessage(snapshot, { role: "assistant" });
 		assert.equal(addressed?.warnings?.every((entry) => entry.addressed), true);
-		assert.equal(unresolvedChildWatchdogBlockers(addressed).length, 0);
+		assert.equal(unresolvedChildWatchdogBlockers(addressed).length, 1, "stalemate remains unresolved");
 		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("retains bounded findings in audit status but projects only high importance to the parent model", () => {
+		let snapshot;
+		for (let index = 0; index < CHILD_WATCHDOG_WARNING_LIMIT + 2; index++) {
+			const importance = index % 3 === 0 ? "high" : index % 3 === 1 ? "medium" : "low";
+			snapshot = acceptChildWatchdogEvent({
+				current: snapshot,
+				event: {
+					type: CHILD_WATCHDOG_STATUS_EVENT, seq: index + 1, phase: "idle", ts: index,
+					warning: { severity: index === 4 ? "blocker" : "concern", importance, category: "correctness", summary: `${importance}-summary-${index}`, evidence: `${importance}-evidence-${index}`, recommendedAction: `${importance}-action-${index}`, addressed: false, stalemate: false },
+				},
+			});
+		}
+		assert.equal(snapshot?.warnings?.length, CHILD_WATCHDOG_WARNING_LIMIT);
+		assert.equal(unresolvedChildWatchdogBlockers(snapshot).length, 1, "low/medium blockers still gate acceptance");
+		const serialized = JSON.stringify(childWatchdogProgressForModel(snapshot));
+		assert.doesNotMatch(serialized, /low-(summary|evidence|action)|medium-(summary|evidence|action)/);
+		assert.match(serialized, /high-summary/);
+	});
+
 	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 });
@@ -136,6 +120,13 @@ describe("child watchdog status helpers", () => {
 		);
 	});
 
+	it("rejects removed fallbackModels in child watchdog config", () => {
+		assert.throws(
+			() => decodeChildWatchdogConfig(JSON.stringify({ enabled: false, fallbackModels: ["model/backup"] })),
+			/fallbackModels was removed; configure one model instead/,
+		);
+	});
+
 	it("accepts latest matching status events and drops stale or foreign events", () => {
 		const firstEvent = {
 			type: CHILD_WATCHDOG_STATUS_EVENT,
@@ -167,4 +158,16 @@ describe("child watchdog status helpers", () => {
 		assert.equal(settled?.phase, "idle");
 		assert.equal(childWatchdogIsActive(settled), false);
 	});
-});
+
+	it("rejects malformed status warning values without throwing", () => {
+		const event = { type: CHILD_WATCHDOG_STATUS_EVENT, seq: 1, phase: "idle", ts: 1 };
+		for (const warning of [null, [], "warning", 1, true]) {
+			assert.equal(isChildWatchdogStatusEvent({ ...event, warning }), false);
+		}
+		assert.equal(isChildWatchdogStatusEvent(null), false);
+		assert.equal(isChildWatchdogStatusEvent([]), false);
+		const warning = { severity: "concern", importance: "low", category: "other", summary: "summary", evidence: "evidence", recommendedAction: "act", addressed: false, stalemate: false };
+		assert.equal(isChildWatchdogStatusEvent({ ...event, warning: { ...warning, displayedAt: 1 } }), false);
+		assert.equal(isChildWatchdogStatusEvent({ ...event, warning: { ...warning, displayedAt: "2026-09-13T00:00:00.000Z" } }), true);
+	});
+});