@selesai/code 0.13.16 → 0.13.18

package/dist/extensions/pi-subagents/test/unit/readonly-drain-observation.test.ts

@@ -0,0 +1,174 @@
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import { syncBuiltinESMExports } from "node:module";
+import { join } from "node:path";
+import { it } from "node:test";
+import { ReadonlyDrainObservation } from "../../src/runs/shared/readonly-drain-observation.ts";
+import { drainOutstandingWork } from "../../src/runs/background/auto-drain.ts";
+import { updateActiveRunIndex, releaseActiveRunIndex } from "../../src/runs/background/active-run-index.ts";
+import { DIRS, type SubagentState } from "../../src/shared/types.ts";
+import { listBackgroundWorkProviders, registerBackgroundWorkProvider } from "../../src/api/background-work.ts";
+import { captureReadonlyChildDrain, createCapturedChildHooks, observeReadonlyChildHookDrain } from "../../src/runs/shared/child-hooks.ts";
+
+const file = "/exact/child.jsonl";
+const state = { currentSessionId: file } as SubagentState;
+const observation = () => new ReadonlyDrainObservation(file, () => listBackgroundWorkProviders().length === 0);
+const done = { content: [{ type: "text" as const, text: "done" }], details: { mode: "management" as const, results: [] } };
+
+it("only the installed runtime drain can complete evidence, not acknowledgements, UI, wrong file or replacement installation", async () => {
+	for (const kind of ["normal", "ack-only", "UI", "wrong-file", "second", "reinstalled", "missing-installation"] as const) {
+		const config = { fanoutChild: false, fast: false, waitTool: { enabled: false } };
+		const { hooks } = createCapturedChildHooks(config);
+		type Handler = (event: unknown, ctx: unknown) => unknown;
+		const handlers = new Map<string, Handler[]>();
+		const pi = { on(event: string, handler: Handler) { handlers.set(event, [...handlers.get(event) ?? [], handler]); }, events: { on() { return () => {}; } } };
+		observeReadonlyChildHookDrain(hooks, true, file); hooks[0].factory(pi as never);
+		const settled = captureReadonlyChildDrain(hooks);
+		const ctx = { hasUI: kind === "UI", sessionManager: { getSessionFile: () => file } };
+		for (const handler of handlers.get("session_start") ?? []) await handler({}, ctx);
+		const ends = handlers.get("agent_end")!;
+		assert.equal(ends.length, 2, "acknowledgement and actual drain remain distinct");
+		await ends[0]({}, ctx); assert.equal(settled(), false);
+		if (kind !== "ack-only") await ends[1]({}, kind === "wrong-file" ? { sessionManager: { getSessionFile: () => "/other" } } : ctx);
+		if (kind === "second") await ends[1]({}, ctx);
+		if (kind === "reinstalled") { observeReadonlyChildHookDrain(hooks, true, file); hooks[0].factory(pi as never); }
+		if (kind === "missing-installation") { observeReadonlyChildHookDrain(hooks, true, file); assert.equal(captureReadonlyChildDrain(hooks)(), false); }
+		assert.equal(settled(), kind === "normal");
+	}
+});
+
+it("requires first false AND actual completion, with sticky first-true and second-episode denial", () => {
+	for (const active of [false, true]) {
+		const proof = observation();
+		assert.equal(proof.settled(), false);
+		proof.begin(file, true); proof.predicate(active);
+		assert.equal(proof.check(), !active, "first true denies synchronously, before waiting or completion");
+		assert.equal(proof.settled(), false);
+		proof.predicate(false); proof.complete();
+		assert.equal(proof.settled(), !active);
+		proof.begin(file, true); proof.predicate(false); proof.complete();
+		assert.equal(proof.settled(), false);
+	}
+});
+
+it("observes true before wait, preserves waits/errors/deadlines and never certifies injected dependencies", async () => {
+	for (const mode of ["success", "error", "throw", "timeout", "predicate throw", "false"] as const) {
+		const proof = observation(); let checks = 0; let waits = 0; let clock = 0;
+		const draining = drainOutstandingWork({ state, timeoutMs: 10, now: () => clock,
+			hasWork: () => { if (mode === "predicate throw") throw new Error("query failure"); return mode !== "false" && checks++ === 0 || mode === "timeout"; },
+			wait: async (_params, _signal, deps) => {
+				waits++; assert.equal(proof.settled(), false);
+				assert.equal(deps.failOnFailedRuns, true); assert.equal(deps.stopOnAttention, false);
+				if (mode === "throw") throw new Error("wait throw");
+				clock = 11; return mode === "error" ? { ...done, isError: true } : done;
+			},
+		}, proof);
+		if (["error", "throw", "timeout", "predicate throw"].includes(mode)) await assert.rejects(draining, /Auto-drain failed|wait throw|timed out|query failure/);
+		else await draining;
+		assert.equal(waits, mode === "false" || mode === "predicate throw" ? 0 : 1);
+		assert.equal(proof.settled(), false);
+	}
+	for (const injection of [{ hasWork: () => false }, { wait: async () => done }, { now: Date.now }]) {
+		const proof = observation(); await drainOutstandingWork({ state, ...injection }, proof); assert.equal(proof.settled(), false);
+	}
+});
+
+it("requires exact identity, normal completion and a nonthrowing clean guard", async () => {
+	for (const identity of [null, "SDK-UUID", "/different.jsonl"]) {
+		const proof = observation();
+		if (identity === null) await assert.rejects(drainOutstandingWork({ state: { currentSessionId: identity } as SubagentState }, proof), /identity/);
+		else await drainOutstandingWork({ state: { currentSessionId: identity } as SubagentState }, proof);
+		assert.equal(proof.settled(), false);
+	}
+	const broken = new ReadonlyDrainObservation(file, () => { throw new Error("inspection"); });
+	await drainOutstandingWork({ state }, broken); assert.equal(broken.settled(), false);
+});
+
+for (const kind of ["empty", "dead-owned", "result-queued-owned", "result-running-owned", "dismissed-owned", "unrelated-running", "unrelated-dead", "terminal-owned", "unknown-owner", "unknown-state", "corrupt", "missing-status", "missing-directory", "rejected-entry", "rejected-entry-ENOENT", "rejected-entry-ENOTDIR", "unrelated-scale"] as const) {
+	it(`ordinary scan/read counts unchanged and conservative raw evidence: ${kind}`, async (t) => {
+		async function run(opted: boolean) {
+			const dirs: string[] = [];
+			const rejectedEntry = kind.startsWith("rejected-entry");
+			const count = kind === "unrelated-scale" ? 40 : kind === "empty" ? 0 : 1;
+			for (let i = 0; i < count; i++) {
+				const id = `drain-proof-${kind}-${opted}-${i}`; const dir = join(DIRS.async, id); dirs.push(dir);
+				fs.mkdirSync(dir, { recursive: true });
+				const status = { runId: id, mode: "single", state: kind === "terminal-owned" ? "complete" : kind === "result-queued-owned" ? "queued" : "running",
+					sessionId: kind.startsWith("unrelated") ? "/other/file" : kind === "unknown-owner" ? undefined : file,
+					startedAt: Date.now(), steps: [{ agent: "reader", status: "running" }],
+					...(kind.includes("dead") ? { pid: 2147483647 } : {}), ...(kind === "dismissed-owned" ? { displayDismissedAt: 1 } : {}),
+				};
+				if (kind === "unknown-state") status.state = "nonsense";
+				if (kind !== "missing-status") fs.writeFileSync(join(dir, "status.json"), kind === "corrupt" ? "{" : JSON.stringify(status));
+				updateActiveRunIndex(dir, "running");
+				if (kind === "missing-directory") fs.rmSync(dir, { recursive: true });
+				if (rejectedEntry) { fs.rmSync(dir, { recursive: true }); fs.writeFileSync(dir, "not a directory"); }
+				if (kind.startsWith("result-")) { fs.mkdirSync(DIRS.results, { recursive: true }); fs.writeFileSync(join(DIRS.results, `${id}.json`), JSON.stringify({ success: true, results: [] })); }
+			}
+			const originalRead = fs.readFileSync; const originalStat = fs.statSync; const originalReaddir = fs.readdirSync;
+			// lstat rejects the regular-file entry on every OS. Marker cleanup then
+			// stats file/status.json: Windows reports ENOENT, POSIX ENOTDIR.
+			// Exercise the native boundary and deterministically cover both contracts.
+			const injectedCode = kind === "rejected-entry-ENOENT" ? "ENOENT" : kind === "rejected-entry-ENOTDIR" ? "ENOTDIR" : undefined;
+			let boundaryCode = injectedCode;
+			if (rejectedEntry && !boundaryCode) {
+				assert.throws(() => originalStat(join(dirs[0], "status.json")), (error: NodeJS.ErrnoException) => {
+					assert.ok(error.code === "ENOENT" || error.code === "ENOTDIR");
+					boundaryCode = error.code;
+					return true;
+				});
+			}
+			const counts = { index: 0, read: 0, stat: 0 };
+			const isStatus = (p: unknown) => dirs.some((dir) => String(p) === join(dir, "status.json"));
+			fs.readFileSync = ((...args: Parameters<typeof fs.readFileSync>) => { if (isStatus(args[0])) counts.read++; return originalRead(...args); }) as typeof fs.readFileSync;
+			fs.statSync = ((...args: Parameters<typeof fs.statSync>) => {
+				if (isStatus(args[0])) {
+					counts.stat++;
+					if (injectedCode) throw Object.assign(new Error(`${injectedCode}: fixture status stat`), { code: injectedCode });
+				}
+				return originalStat(...args);
+			}) as typeof fs.statSync;
+			fs.readdirSync = ((...args: Parameters<typeof fs.readdirSync>) => { if (String(args[0]) === join(DIRS.async, ".active-runs")) counts.index++; return originalReaddir(...args); }) as typeof fs.readdirSync;
+			syncBuiltinESMExports();
+			const proof = opted ? observation() : undefined;
+			try {
+				const outcome = await drainOutstandingWork({ state }, proof).then(
+					() => "completed",
+					(error: Error) => {
+						assert.ok(rejectedEntry, `unexpected drain rejection: ${error}`);
+						assert.match(error.message, /Failed to list async runs/);
+						const inspection = error.cause as Error;
+						assert.match(inspection.message, /Failed to inspect async status file/);
+						return (inspection.cause as NodeJS.ErrnoException).code;
+					},
+				);
+				assert.equal(outcome, boundaryCode === "ENOTDIR" ? "ENOTDIR" : "completed");
+				if (rejectedEntry) assert.deepEqual(counts, { index: 1, read: 0, stat: 1 }, "rejected entry reaches the cleanup status-stat boundary exactly once");
+				assert.equal(counts.index, 1, "first predicate is false, with no wait/final requery");
+				if (proof) assert.equal(proof.settled(), ["empty", "unrelated-running", "unrelated-dead", "terminal-owned", "unrelated-scale"].includes(kind));
+				const capturedCounts = { ...counts };
+				if (kind.includes("dead")) assert.equal(JSON.parse(originalRead(join(dirs[0], "status.json"), "utf8")).state, "failed", "ordinary dead-PID repair remains");
+				if (kind.startsWith("result-")) assert.equal(JSON.parse(originalRead(join(dirs[0], "status.json"), "utf8")).state, "complete", "ordinary result repair remains");
+				return { counts: capturedCounts, outcome };
+			} finally {
+				fs.readFileSync = originalRead; fs.statSync = originalStat; fs.readdirSync = originalReaddir; syncBuiltinESMExports();
+				for (const dir of dirs) { releaseActiveRunIndex(dir); fs.rmSync(dir, { recursive: true, force: true }); fs.rmSync(join(DIRS.results, `${dir.split("/").at(-1)}.json`), { force: true }); }
+			}
+		}
+		const observed = await run(true), baseline = await run(false);
+		assert.deepEqual(observed, baseline, "observation preserves outcome and adds no index enumeration/status reads or metadata checks");
+		t.diagnostic(`baseline = opted-in ${JSON.stringify(observed)}`);
+	});
+}
+
+for (const throws of [false, true]) it(`unknown provider veto precedes ordinary callbacks and survives removal (throws=${throws})`, async () => {
+	const proof = observation(); let calls = 0;
+	const unregister = registerBackgroundWorkProvider({ name: "drain-proof-provider", listActiveWork() { calls++; assert.equal(proof.check(), false); if (throws) throw new Error("provider failure"); return []; } });
+	try {
+		assert.equal(calls, 0);
+		if (throws) await assert.rejects(drainOutstandingWork({ state }, proof), /provider failure/);
+		else await drainOutstandingWork({ state }, proof);
+		assert.ok(calls > 0);
+	} finally { unregister(); }
+	assert.equal(proof.settled(), false);
+});

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

@@ -0,0 +1,94 @@
+import assert from "node:assert/strict";
+import { execFileSync } from "node:child_process";
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { it } from "node:test";
+import { createDefaultChildSessionFactory, type ChildSession, type ChildSessionLaunch, type PiCodingAgentModule } from "../../src/runs/shared/child-session.ts";
+import { createChildHooks } from "../../src/runs/shared/child-hooks.ts";
+import { getReadonlySessionEvidence, requestReadonlySessionEvidence } from "../../src/runs/shared/readonly-session-evidence.ts";
+import { planReadonlyModelContinuation as plan, type ReadonlyContinuationCandidate, type ReadonlyContinuationInput } from "../../src/runs/shared/readonly-model-continuation.ts";
+
+const candidate = (model: string, provider = "baseten", tried = false): ReadonlyContinuationCandidate => ({ resolved: { model, provider, api: "openai-completions" }, tried, compatibility: "compatible" });
+function input(source?: ChildSession): ReadonlyContinuationInput {
+	return { source, recoveryState: "unused", candidates: [candidate("model-a", "baseten", true), candidate("model-b")], currentIndex: 0,
+		lifecycleAllowsContinuation: true, effectsAllowContinuation: true, budget: "unconfigured", knownContextOverflow: false };
+}
+it("denies absent and duck-typed serialized receipts", () => {
+	assert.deepEqual(plan(input()), { kind: "deny", reason: "no-evidence" });
+	assert.deepEqual(plan(input({ continuationEvidence: { status: 429, readOnly: true } } as unknown as ChildSession)), { kind: "deny", reason: "no-evidence" });
+});
+
+const sdkRoot = process.env.SELESAI_SUBAGENTS_NATIVE_SDK;
+it("plans only from a real settled receipt: ordered siblings, vetoes, one-cap transitions and revocation", { skip: !sdkRoot && "Set SELESAI_SUBAGENTS_NATIVE_SDK" }, async () => {
+	const entry = execFileSync(process.execPath, ["--input-type=module", "-e", "console.log(import.meta.resolve('@selesai/code'))"], { cwd: sdkRoot, encoding: "utf8" }).trim();
+	const pi: PiCodingAgentModule = await import(entry);
+	assert.equal(pi.VERSION, "0.85.1");
+	const cwd = mkdtempSync(join(tmpdir(), "readonly-planner-"));
+	const agentDir = join(cwd, "agent"); mkdirSync(agentDir);
+	const priorDir = process.env.SELESAI_CODING_AGENT_DIR, priorFetch = globalThis.fetch;
+	process.env.SELESAI_CODING_AGENT_DIR = agentDir;
+	writeFileSync(join(agentDir, "settings.json"), JSON.stringify({ retry: { enabled: false, provider: { maxRetries: 0 } }, compaction: { enabled: false } }));
+	writeFileSync(join(agentDir, "models.json"), JSON.stringify({ providers: { baseten: { baseUrl: "https://synthetic.invalid/v1", apiKey: "fixture", models: ["model-a", "model-b"].map(id => ({ id, name: id, api: "openai-completions", reasoning: false, input: ["text"], contextWindow: 128000, maxTokens: 512, cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 } })) } } }));
+	writeFileSync(join(cwd, "marker.txt"), "Actual builtin read result");
+	let requests = 0;
+	let stale = false;
+	globalThis.fetch = async (url, init) => {
+		assert.equal(String(url), "https://synthetic.invalid/v1/chat/completions");
+		assert.equal(init?.method, "POST");
+		requests++;
+		if (requests === 1) {
+			const chunk = { id: "synthetic", object: "chat.completion.chunk", created: 1, model: "model-a", choices: [{ index: 0, delta: { tool_calls: [{ index: 0, id: "read-1", type: "function", function: { name: "read", arguments: JSON.stringify({ path: "marker.txt" }) } }] }, finish_reason: "tool_calls" }] };
+			return new Response(`data: ${JSON.stringify(chunk)}\n\ndata: [DONE]\n\n`, { headers: { "content-type": "text/event-stream" } });
+		}
+		if (stale) throw new Error("429: stale-looking error without a response");
+		return new Response(JSON.stringify({ error: { message: "rate limited" } }), { status: 429, headers: { "content-type": "application/json" } });
+	};
+	const factory = createDefaultChildSessionFactory({ loadPiCodingAgent: async () => pi });
+	function launch(file: string): ChildSessionLaunch {
+		const runtime = { fanoutChild: false, fast: false, depth: 1, waitTool: { enabled: false } };
+		return { cwd, storage: { kind: "file", sessionFile: join(cwd, file) }, model: "baseten/model-a", tools: ["read"], extensionPaths: [], ambientExtensions: false, hooks: createChildHooks(runtime), noSkills: true, noContextFiles: true, runtime };
+	}
+	try {
+		const l = launch("session.jsonl"); requestReadonlySessionEvidence(l);
+		const child = await factory.create(l);
+		await child.prompt("Read marker.txt once");
+		assert.equal(plan(input(child)).kind, "deny", "prompt completion alone is not settlement proof");
+		await child.dispose();
+		const receipt = getReadonlySessionEvidence(child); assert.ok(receipt);
+		const base = input(child);
+		const selected = plan({ ...base, candidates: [candidate("model-a", "baseten", true), candidate("foreign", "other"), candidate("model-a"), candidate("tried", "baseten", true), candidate("tried"), candidate("model-b")] });
+		assert.ok(selected.kind === "continue");
+		assert.equal(selected.candidateIndex, 5);
+		assert.equal(selected.expected, receipt, "opaque receipt is passed unchanged");
+		assert.equal(selected.prompt, "The previous provider request failed with HTTP 429 after read-only progress. Continue from the retained transcript and completed tool results. Do not restart or repeat completed work. Use only the existing read-only tools and finish the requested response.");
+		assert.equal(base.recoveryState, "unused", "planner does not consume host-owned state itself");
+		assert.equal(plan({ ...base, recoveryState: selected.recoveryState }).kind, "deny");
+		assert.equal(plan({ ...base, recoveryState: "abort-recovery" }).kind, "deny");
+		for (const patch of [
+			{ lifecycleAllowsContinuation: false }, { effectsAllowContinuation: false }, { knownContextOverflow: true },
+			...(["unknown", "exhausted", "tool-budget-configured"] as const).map(budget => ({ budget })),
+			{ currentIndex: -1 }, { currentIndex: 0.5 }, { currentIndex: 8 },
+			{ candidates: [candidate("alias"), candidate("model-b")] },
+			{ candidates: [base.candidates[0], candidate("foreign", "other")] },
+			{ candidates: [base.candidates[0], { ...candidate("model-b"), resolved: undefined }] },
+			...(["unknown", "incompatible"] as const).map(compatibility => ({ candidates: [base.candidates[0], { ...candidate("model-b"), compatibility }] })),
+			{ candidates: [base.candidates[0], { ...candidate("model-b"), resolved: { provider: "baseten", model: "model-b", api: "other" } }] },
+		]) assert.equal(plan({ ...base, ...patch }).kind, "deny", JSON.stringify(patch));
+		assert.equal(plan({ ...base, budget: "available" }).kind, "continue");
+		assert.equal(requests, 2, "all decisions are dispatch-free");
+		await child.abort();
+		assert.equal(getReadonlySessionEvidence(child), undefined);
+		assert.deepEqual(plan(base), { kind: "deny", reason: "no-evidence" }, "previously captured receipt cannot bypass revocation");
+		// A prior real 429 on this retained transcript cannot authorize a later statusless error.
+		stale = true;
+		const later = launch("session.jsonl"); requestReadonlySessionEvidence(later);
+		const laterChild = await factory.create(later);
+		await laterChild.prompt("Continue"); await laterChild.dispose();
+		assert.deepEqual(plan(input(laterChild)), { kind: "deny", reason: "no-evidence" });
+	} finally {
+		await factory.dispose(); globalThis.fetch = priorFetch;
+		if (priorDir === undefined) delete process.env.SELESAI_CODING_AGENT_DIR; else process.env.SELESAI_CODING_AGENT_DIR = priorDir;
+		rmSync(cwd, { recursive: true, force: true });
+	}
+});