@selesai/code 0.13.39 → 0.14.0

package/dist/extensions/pi-subagents/test/unit/runner-http-dispatcher.test.ts

@@ -0,0 +1,136 @@
+import assert from "node:assert/strict";
+import { createServer } from "node:http";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { after, describe, it } from "node:test";
+import { EnvHttpProxyAgent, fetch as undiciFetch, getGlobalDispatcher } from "undici";
+import {
+	DEFAULT_HTTP_IDLE_TIMEOUT_MS,
+	parseHttpIdleTimeoutMs,
+	resolveHttpIdleTimeoutMs,
+	runnerHttpDispatcherOptions,
+	installRunnerHttpDispatcher,
+} from "../../src/runs/background/runner-http-dispatcher.ts";
+import { getConfigDirName } from "../../src/shared/utils.ts";
+
+const roots: string[] = [];
+function fixture(settings: { global?: unknown; project?: unknown; globalRaw?: string }): { agentDir: string; cwd: string } {
+	const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-http-idle-"));
+	roots.push(root);
+	const agentDir = path.join(root, "agent");
+	const cwd = path.join(root, "work");
+	fs.mkdirSync(agentDir, { recursive: true });
+	fs.mkdirSync(path.join(cwd, getConfigDirName()), { recursive: true });
+	if (settings.globalRaw !== undefined) fs.writeFileSync(path.join(agentDir, "settings.json"), settings.globalRaw);
+	else if (settings.global !== undefined) fs.writeFileSync(path.join(agentDir, "settings.json"), JSON.stringify(settings.global));
+	if (settings.project !== undefined) fs.writeFileSync(path.join(cwd, getConfigDirName(), "settings.json"), JSON.stringify(settings.project));
+	return { agentDir, cwd };
+}
+after(() => { for (const root of roots) fs.rmSync(root, { recursive: true, force: true }); });
+
+describe("parseHttpIdleTimeoutMs mirrors Pi", () => {
+	it("floors numbers, accepts numeric strings, treats disabled as 0", () => {
+		assert.equal(parseHttpIdleTimeoutMs(1200.9), 1200);
+		assert.equal(parseHttpIdleTimeoutMs(" 900000 "), 900000);
+		assert.equal(parseHttpIdleTimeoutMs("Disabled"), 0);
+		assert.equal(parseHttpIdleTimeoutMs(0), 0);
+	});
+	it("rejects negative, non-finite, empty, and non-numeric values", () => {
+		for (const value of [-1, Number.NaN, Number.POSITIVE_INFINITY, "", "soon", null, true, {}]) {
+			assert.equal(parseHttpIdleTimeoutMs(value), undefined, String(value));
+		}
+	});
+});
+
+describe("resolveHttpIdleTimeoutMs", () => {
+	it("defaults to Pi's 300s when no settings file sets it", () => {
+		assert.deepEqual(resolveHttpIdleTimeoutMs(fixture({ global: { theme: "dark" } })), { timeoutMs: DEFAULT_HTTP_IDLE_TIMEOUT_MS, source: "default" });
+		assert.deepEqual(resolveHttpIdleTimeoutMs(fixture({})), { timeoutMs: DEFAULT_HTTP_IDLE_TIMEOUT_MS, source: "default" });
+	});
+	it("reads the global setting, including 0 for disabled", () => {
+		assert.deepEqual(resolveHttpIdleTimeoutMs(fixture({ global: { httpIdleTimeoutMs: 1_800_000 } })), { timeoutMs: 1_800_000, source: "global" });
+		assert.deepEqual(resolveHttpIdleTimeoutMs(fixture({ global: { httpIdleTimeoutMs: 0 } })), { timeoutMs: 0, source: "global" });
+	});
+	it("lets the project setting override the global one", () => {
+		const resolved = resolveHttpIdleTimeoutMs(fixture({ global: { httpIdleTimeoutMs: 60_000 }, project: { httpIdleTimeoutMs: 0 } }));
+		assert.deepEqual(resolved, { timeoutMs: 0, source: "project" });
+	});
+	it("falls back with a warning when the value or file is invalid", () => {
+		const invalid = resolveHttpIdleTimeoutMs(fixture({ global: { httpIdleTimeoutMs: "later" } }));
+		assert.equal(invalid.timeoutMs, DEFAULT_HTTP_IDLE_TIMEOUT_MS);
+		assert.equal(invalid.source, "default");
+		assert.match(invalid.warning ?? "", /invalid httpIdleTimeoutMs/);
+		const projectInvalid = resolveHttpIdleTimeoutMs(fixture({ global: { httpIdleTimeoutMs: 0 }, project: { httpIdleTimeoutMs: -5 } }));
+		assert.equal(projectInvalid.timeoutMs, DEFAULT_HTTP_IDLE_TIMEOUT_MS, "an invalid project override must not fall through to the global value");
+		assert.equal(projectInvalid.source, "default");
+		assert.match(projectInvalid.warning ?? "", /invalid httpIdleTimeoutMs/);
+		const broken = resolveHttpIdleTimeoutMs(fixture({ globalRaw: "{ not json", project: { httpIdleTimeoutMs: 5_000 } }));
+		assert.equal(broken.timeoutMs, 5_000);
+		assert.equal(broken.source, "project");
+		assert.equal(broken.warning, undefined, "project value wins before the global file is consulted");
+		const brokenOnly = resolveHttpIdleTimeoutMs(fixture({ globalRaw: "{ not json" }));
+		assert.equal(brokenOnly.timeoutMs, DEFAULT_HTTP_IDLE_TIMEOUT_MS);
+		assert.match(brokenOnly.warning ?? "", /cannot parse/);
+	});
+});
+
+describe("runner dispatcher honours the resolved idle timeout", () => {
+	async function withDelayedServer(delayMs: number, run: (url: string) => Promise<void>): Promise<void> {
+		const server = createServer((_req, res) => {
+			setTimeout(() => { res.writeHead(200, { "content-type": "text/plain" }); res.end("ok"); }, delayMs);
+		});
+		await new Promise<void>((resolve) => server.listen(0, "127.0.0.1", resolve));
+		const address = server.address();
+		assert.ok(address && typeof address === "object");
+		try {
+			await run(`http://127.0.0.1:${address.port}/`);
+		} finally {
+			server.closeAllConnections();
+			await new Promise<void>((resolve) => server.close(() => resolve()));
+		}
+	}
+
+	it("a short headersTimeout cuts a slow response; 0 (disabled) lets it finish", async () => {
+		// undici coalesces idle timers on a ~1s tick, so keep the delay well past the bound.
+		await withDelayedServer(2_500, async (url) => {
+			const bounded = new EnvHttpProxyAgent(runnerHttpDispatcherOptions(200));
+			try {
+				await assert.rejects(undiciFetch(url, { dispatcher: bounded }), (error: unknown) => {
+					const cause = (error as { cause?: { code?: string } }).cause;
+					return cause?.code === "UND_ERR_HEADERS_TIMEOUT";
+				});
+			} finally {
+				await bounded.close();
+			}
+			const unbounded = new EnvHttpProxyAgent(runnerHttpDispatcherOptions(0));
+			try {
+				const response = await undiciFetch(url, { dispatcher: unbounded });
+				assert.equal(await response.text(), "ok");
+			} finally {
+				await unbounded.close();
+			}
+		});
+	});
+
+	it("installRunnerHttpDispatcher applies the resolved setting to the process-global dispatcher", async () => {
+		// Runs last in this file: it replaces the global dispatcher and fetch for this test process.
+		await withDelayedServer(2_500, async (url) => {
+			installRunnerHttpDispatcher(fixture({ project: { httpIdleTimeoutMs: 200 } }));
+			const installed = getGlobalDispatcher();
+			assert.ok(installed instanceof EnvHttpProxyAgent, "runner dispatcher is the global dispatcher");
+			await assert.rejects(globalThis.fetch(url), (error: unknown) => {
+				const cause = (error as { cause?: { code?: string } }).cause;
+				return cause?.code === "UND_ERR_HEADERS_TIMEOUT";
+			});
+			installRunnerHttpDispatcher(fixture({ project: { httpIdleTimeoutMs: 0 } }));
+			assert.notEqual(getGlobalDispatcher(), installed, "a fresh dispatcher replaces the bounded one");
+			const response = await globalThis.fetch(url);
+			assert.equal(await response.text(), "ok");
+		});
+	});
+
+	it("keeps the proxy-aware shape the runner relied on", () => {
+		assert.deepEqual(runnerHttpDispatcherOptions(42), { allowH2: false, proxyTunnel: true, headersTimeout: 42, bodyTimeout: 42 });
+	});
+});

package/dist/extensions/pi-subagents/test/unit/runner-peer-loader.test.ts

@@ -0,0 +1,68 @@
+import assert from "node:assert/strict";
+import { spawnSync } from "node:child_process";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { test } from "node:test";
+import { pathToFileURL } from "node:url";
+
+const loaderUrl = new URL("../../runner-peer-loader.mjs", import.meta.url);
+const packageRootUrl = new URL("../../", import.meta.url).href;
+const hostModules = path.join(os.tmpdir(), "runner-peer-loader-host", "node_modules", "@earendil-works");
+const aliases = {
+	"@earendil-works/pi-tui": path.join(hostModules, "pi-tui", "dist", "index.js"),
+	"@earendil-works/pi-ai": path.join(hostModules, "pi-ai", "dist", "index.js"),
+};
+test("native preload leaves the SDK extension loader's require.resolve intact", () => {
+	const root = fs.mkdtempSync(path.join(os.tmpdir(), "runner-extension-resolve-"));
+	try {
+		const sdkLoader = path.join(root, "host", "dist", "core", "extensions", "loader.js");
+		const typeboxRoot = path.join(root, "host", "node_modules", "typebox");
+		const target = path.join(typeboxRoot, "index.mjs");
+		fs.mkdirSync(path.dirname(sdkLoader), { recursive: true });
+		fs.mkdirSync(typeboxRoot, { recursive: true });
+		fs.writeFileSync(sdkLoader, "");
+		fs.writeFileSync(target, "export const Type = {};\n");
+		fs.writeFileSync(path.join(typeboxRoot, "package.json"), JSON.stringify({ name: "typebox", type: "module", exports: "./index.mjs" }));
+		const child = spawnSync(process.execPath, [
+			"--import", new URL("../../runner-peer-preload.mjs", import.meta.url).href,
+			"--input-type=module", "-e",
+			"import { createRequire } from 'node:module'; console.log(createRequire(process.argv[1]).resolve('typebox'));",
+			sdkLoader,
+		], {
+			encoding: "utf8",
+			env: { ...process.env, JITI_ALIAS: JSON.stringify({ typebox: target }), PI_ASYNC_NATIVE_RUNNER: "1" },
+			timeout: 10_000,
+		});
+		assert.equal(child.status, 0, child.stderr);
+		// Compare real paths: macOS temp dirs are symlinks (/var -> /private/var).
+		assert.equal(fs.realpathSync(child.stdout.trim()), fs.realpathSync(target));
+	} finally {
+		fs.rmSync(root, { recursive: true, force: true });
+	}
+});
+
+const passthrough = (specifier: string) => ({ url: specifier, shortCircuit: true });
+
+test("fallback loader aliases every host peer for a plain-JavaScript runner", async () => {
+	const loader = await import(`${loaderUrl.href}?native`);
+	loader.initialize({ aliases, nativeRunner: true });
+	const packageContext = { parentURL: new URL("src/runs/background/subagent-runner.js", packageRootUrl).href };
+	assert.equal(loader.resolve("@earendil-works/pi-ai", packageContext, passthrough).url, pathToFileURL(aliases["@earendil-works/pi-ai"]).href);
+	assert.equal(loader.resolve("@earendil-works/pi-tui", packageContext, passthrough).url, pathToFileURL(aliases["@earendil-works/pi-tui"]).href);
+	assert.equal(loader.resolve("node:fs", packageContext, passthrough).url, "node:fs");
+	assert.equal(loader.resolve("@earendil-works/pi-ai", { parentURL: "file:///host/pi-loader.js" }, passthrough).url, pathToFileURL(aliases["@earendil-works/pi-ai"]).href);
+});
+
+test("fallback loader aliases external imports for a native TypeScript runner", async () => {
+	const loader = await import(`${loaderUrl.href}?native-typescript`);
+	loader.initialize({ aliases, nativeRunner: true });
+	assert.equal(loader.resolve("@earendil-works/pi-ai", { parentURL: "file:///tmp/child-factory.mjs" }, passthrough).url, pathToFileURL(aliases["@earendil-works/pi-ai"]).href);
+});
+
+test("fallback loader redirects only the TUI for a jiti-hosted TypeScript runner", async () => {
+	const loader = await import(`${loaderUrl.href}?jiti`);
+	loader.initialize({ aliases });
+	assert.equal(loader.resolve("@earendil-works/pi-ai", {}, passthrough).url, "@earendil-works/pi-ai");
+	assert.equal(loader.resolve("@earendil-works/pi-tui", {}, passthrough).url, pathToFileURL(aliases["@earendil-works/pi-tui"]).href);
+});

package/dist/extensions/pi-subagents/test/unit/runner-peer-symlinks.test.ts

@@ -0,0 +1,50 @@
+import assert from "node:assert/strict";
+import { spawnSync } from "node:child_process";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { test } from "node:test";
+import { pathToFileURL } from "node:url";
+import { resolveHostPeerAliases } from "../../src/runs/background/runner-aliases.ts";
+
+for (const nativeRunner of [true, false]) {
+	for (const loader of ["preload", "fallback"]) {
+		test(`${loader} resolves dependencies and module identity through symlinked host peers (native=${nativeRunner})`, () => {
+			const root = fs.mkdtempSync(path.join(os.tmpdir(), "runner-peer-symlinks-"));
+			try {
+				const host = path.join(root, "host");
+				const storeModules = path.join(root, "store", "pi-tui", "node_modules");
+				const tui = path.join(storeModules, "@earendil-works", "pi-tui");
+				const marked = path.join(storeModules, "marked");
+				const link = path.join(host, "node_modules", "@earendil-works", "pi-tui");
+				fs.mkdirSync(path.dirname(link), { recursive: true });
+				fs.mkdirSync(tui, { recursive: true });
+				fs.mkdirSync(marked, { recursive: true });
+				fs.writeFileSync(path.join(host, "package.json"), JSON.stringify({ name: "@selesai/code", version: "0.87.0" }));
+				fs.writeFileSync(path.join(tui, "package.json"), JSON.stringify({ name: "@earendil-works/pi-tui", type: "module", exports: "./index.js" }));
+				fs.writeFileSync(path.join(tui, "index.js"), "export { marker } from 'marked';\n");
+				fs.writeFileSync(path.join(marked, "package.json"), JSON.stringify({ name: "marked", type: "module", exports: "./index.js" }));
+				fs.writeFileSync(path.join(marked, "index.js"), "export const marker = 'resolved-from-store';\n");
+				fs.symlinkSync(tui, link, "junction");
+				const { aliases } = resolveHostPeerAliases(host);
+				assert.ok(aliases["@earendil-works/pi-tui"]);
+				const preload = loader === "preload"
+					? new URL("../../runner-peer-preload.mjs", import.meta.url).href
+					: `data:text/javascript,${encodeURIComponent(`import { register } from 'node:module'; register(${JSON.stringify(new URL("../../runner-peer-loader.mjs", import.meta.url).href)}, { data: { aliases: JSON.parse(process.env.JITI_ALIAS), nativeRunner: ${nativeRunner} } });`)}`;
+				const child = spawnSync(process.execPath, [
+					"--import", preload, "--input-type=module", "-e",
+					"import assert from 'node:assert/strict'; const peer = await import('@earendil-works/pi-tui'); const direct = await import(process.argv[1]); assert.strictEqual(peer, direct); console.log(peer.marker);",
+					pathToFileURL(fs.realpathSync(path.join(tui, "index.js"))).href,
+				], {
+					encoding: "utf8",
+					env: { ...process.env, JITI_ALIAS: JSON.stringify(aliases), PI_ASYNC_NATIVE_RUNNER: nativeRunner ? "1" : "0" },
+					timeout: 10_000,
+				});
+				assert.equal(child.status, 0, child.stderr);
+				assert.equal(child.stdout.trim(), "resolved-from-store");
+			} finally {
+				fs.rmSync(root, { recursive: true, force: true });
+			}
+		});
+	}
+}

package/dist/extensions/pi-subagents/test/unit/running-tone.test.ts

@@ -0,0 +1,13 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { readMainThinkingLevel } from "../../src/tui/running-tone.ts";
+
+const staleMessage = "This extension ctx is stale after session replacement or reload. Do not use a captured pi or command ctx after ctx.newSession().";
+const unboundMessage = "Extension runtime not initialized. Action methods cannot be called during extension loading.";
+
+test("reads the main session's thinking level and treats a stale or unbound runtime as having none", () => {
+	assert.equal(readMainThinkingLevel(() => "high"), "high");
+	assert.equal(readMainThinkingLevel(() => { throw new Error(staleMessage); }), undefined);
+	assert.equal(readMainThinkingLevel(() => { throw new Error(unboundMessage); }), undefined);
+	assert.throws(() => readMainThinkingLevel(() => { throw new Error("disk on fire"); }), /disk on fire/);
+});

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

@@ -44,6 +44,11 @@ function makePiWithEvents(events: ExtensionAPI["events"]): ExtensionAPI {
 	return { on() {}, registerTool() {}, events } as unknown as ExtensionAPI;
 }
 
+function writeJson(filePath: string, value: unknown): void {
+	fs.mkdirSync(path.dirname(filePath), { recursive: true });
+	fs.writeFileSync(filePath, JSON.stringify(value, null, 2), "utf-8");
+}
+
 function writeProjectAgent(name: string, aliases: string[] = []): void {
 	const filePath = path.join(tempProject, ".selesai", "agents", `${name}.md`);
 	fs.mkdirSync(path.dirname(filePath), { recursive: true });
@@ -238,7 +243,6 @@ describe("runtime agent registration", () => {
 				systemPrompt: "Help with model routing.",
 				aliases: ["model-helper"],
 				model: "openai/gpt-5-mini",
-				fallbackModels: ["anthropic/claude-sonnet-4"],
 				thinking: "high",
 			},
 		});
@@ -257,7 +261,7 @@ describe("runtime agent registration", () => {
 			const all = handleManagementAction("models", {}, ctx);
 			const allText = all.content.map((part) => part.type === "text" ? part.text ?? "" : "").join("\n");
 			assert.equal(all.isError, false);
-			assert.match(allText, /runtime-model-helper\n  model:\n    openai\/gpt-5-mini\n  source: runtime agent config\n  thinking: high\n  fallback models:\n    anthropic\/claude-sonnet-4/);
+			assert.match(allText, /runtime-model-helper\n  model:\n    openai\/gpt-5-mini\n  source: runtime agent config\n  thinking: high/);
 
 			const filtered = handleManagementAction("models", { agent: "model-helper" }, ctx);
 			const filteredText = filtered.content.map((part) => part.type === "text" ? part.text ?? "" : "").join("\n");
@@ -265,7 +269,154 @@ describe("runtime agent registration", () => {
 			assert.match(filteredText, /Agent: model-helper/);
 			assert.match(filteredText, /Effective model:\n  openai\/gpt-5-mini/);
 			assert.match(filteredText, /Source: runtime agent config/);
-			assert.match(filteredText, /Fallback models:\n  anthropic\/claude-sonnet-4/);
+		} finally {
+			registration.dispose();
+		}
+	});
+
+	it("applies subagent default model and thinking to runtime agents that declare none", () => {
+		writeJson(path.join(tempHome, ".selesai", "agent", "settings.json"), {
+			subagents: { defaultModel: "openai/gpt-5-mini", defaultThinking: "low" },
+		});
+		const unpinned = registerAgent({
+			pi,
+			name: "runtime-default-helper",
+			definition: { description: "Runtime default helper", systemPrompt: "Help.", tools: ["read"] },
+		});
+		const pinned = registerAgent({
+			pi,
+			name: "runtime-pinned-helper",
+			definition: { description: "Runtime pinned helper", systemPrompt: "Help.", model: "anthropic/claude-sonnet-4" },
+		});
+		try {
+			const settings = { cwd: tempProject, scope: "both" as const };
+			const merged = mergeRuntimeAgents(pi, discoverAgents(tempProject, "both"), undefined, settings).agents;
+			const defaulted = merged.find((candidate) => candidate.name === "runtime-default-helper");
+			assert.equal(defaulted?.model, "openai/gpt-5-mini");
+			assert.equal(defaulted?.thinking, "low");
+			assert.equal(defaulted?.modelSource?.type, "subagents.defaultModel");
+			assert.equal(defaulted?.modelSource?.scope, "user");
+			assert.deepEqual(defaulted?.tools, ["read"]);
+			assert.equal(defaulted?.systemPrompt, "Help.");
+
+			const kept = merged.find((candidate) => candidate.name === "runtime-pinned-helper");
+			assert.equal(kept?.model, "anthropic/claude-sonnet-4");
+			assert.equal(kept?.modelSource, undefined);
+			assert.equal(kept?.thinking, "low");
+
+			const bare = mergeRuntimeAgents(pi, discoverAgents(tempProject, "both")).agents
+				.find((candidate) => candidate.name === "runtime-default-helper");
+			assert.equal(bare?.model, undefined, "without a settings context the registered definition is returned as-is");
+		} finally {
+			unpinned.dispose();
+			pinned.dispose();
+		}
+	});
+
+	it("applies only model-tier agentOverrides fields to runtime agents, project over user", () => {
+		writeJson(path.join(tempHome, ".selesai", "agent", "settings.json"), {
+			subagents: {
+				defaultModel: "openai/gpt-5-mini",
+				agentOverrides: {
+					"runtime-override-helper": {
+						model: "anthropic/claude-sonnet-4",
+						thinking: "high",
+						tools: ["bash"],
+						systemPrompt: "Replaced by settings.",
+						disabled: true,
+					},
+					"runtime-cleared-helper": { thinking: "high" },
+				},
+			},
+		});
+		writeJson(path.join(tempProject, ".selesai", "settings.json"), {
+			subagents: {
+				agentOverrides: {
+					"runtime-override-helper": { thinking: "medium" },
+					"runtime-cleared-helper": { model: false },
+				},
+			},
+		});
+		const overridden = registerAgent({
+			pi,
+			name: "runtime-override-helper",
+			definition: { description: "Runtime override helper", systemPrompt: "Help.", tools: ["read"] },
+		});
+		const cleared = registerAgent({
+			pi,
+			name: "runtime-cleared-helper",
+			definition: { description: "Runtime cleared helper", systemPrompt: "Help.", model: "openai/gpt-5-mini" },
+		});
+		try {
+			const merged = mergeRuntimeAgents(pi, discoverAgents(tempProject, "both"), undefined, { cwd: tempProject, scope: "both" }).agents;
+			const agent = merged.find((candidate) => candidate.name === "runtime-override-helper");
+			assert.equal(agent?.model, "anthropic/claude-sonnet-4", "user override model wins over defaultModel");
+			assert.equal(agent?.thinking, "medium", "project override thinking wins over user override thinking");
+			assert.deepEqual(agent?.tools, ["read"], "tools stay extension-owned");
+			assert.equal(agent?.systemPrompt, "Help.", "systemPrompt stays extension-owned");
+			assert.notEqual(agent?.disabled, true, "disabled is not honored for runtime agents");
+
+			const back = merged.find((candidate) => candidate.name === "runtime-cleared-helper");
+			assert.equal(back?.model, undefined, "model: false clears the definition model so the agent inherits the session model");
+			assert.equal(back?.thinking, "high");
+		} finally {
+			overridden.dispose();
+			cleared.dispose();
+		}
+	});
+
+	it("reports the subagent default model source for runtime agents", () => {
+		writeJson(path.join(tempHome, ".selesai", "agent", "settings.json"), {
+			subagents: { defaultModel: "openai/gpt-5-mini" },
+		});
+		const registration = registerAgent({
+			pi,
+			name: "runtime-default-source-helper",
+			definition: { description: "Runtime default source helper", systemPrompt: "Help." },
+		});
+		try {
+			const ctx = {
+				cwd: tempProject,
+				modelRegistry: { getAvailable: () => [{ provider: "openai", id: "gpt-5-mini" }] },
+				model: { provider: "anthropic", id: "claude-sonnet-4" },
+				runtimeAgentOwner: pi,
+			};
+			const filtered = handleManagementAction("models", { agent: "runtime-default-source-helper" }, ctx);
+			const text = filtered.content.map((part) => part.type === "text" ? part.text ?? "" : "").join("\n");
+			assert.equal(filtered.isError, false);
+			assert.match(text, /Effective model:\n  openai\/gpt-5-mini/);
+			assert.match(text, /Source: user defaultModel/);
+		} finally {
+			registration.dispose();
+		}
+	});
+
+	it("reports provider-scoped model settings for runtime agents", () => {
+		writeJson(path.join(tempHome, ".selesai", "agent", "settings.json"), {
+			subagents: {
+				agentOverridesByProvider: {
+					anthropic: {
+						"runtime-provider-helper": { model: "anthropic/claude-sonnet-4", thinking: "high" },
+					},
+				},
+			},
+		});
+		const registration = registerAgent({
+			pi,
+			name: "runtime-provider-helper",
+			definition: { description: "Runtime provider helper", systemPrompt: "Help." },
+		});
+		try {
+			const managed = handleManagementAction("models", { agent: "runtime-provider-helper" }, {
+				cwd: tempProject,
+				modelRegistry: { getAvailable: () => [{ provider: "anthropic", id: "claude-sonnet-4" }] },
+				model: { provider: "anthropic", id: "claude-sonnet-4" },
+				runtimeAgentOwner: pi,
+			});
+			const text = managed.content.map((part) => part.type === "text" ? part.text ?? "" : "").join("\n");
+			assert.equal(managed.isError, false);
+			assert.match(text, /Effective model:\n  anthropic\/claude-sonnet-4/);
+			assert.match(text, /Thinking: high/);
 		} finally {
 			registration.dispose();
 		}
@@ -346,4 +497,4 @@ describe("runtime agent registration", () => {
 			/collides with configured agent 'hidden-user' on name or alias 'hidden-user'/,
 		);
 	});
-});
+});

package/dist/extensions/pi-subagents/test/unit/schedule-claim-initialization.test.ts

@@ -0,0 +1,71 @@
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { syncBuiltinESMExports } from "node:module";
+import { it } from "node:test";
+import { createScheduledRunManager, scheduledRunStorePath } from "../../src/runs/background/scheduled-runs.ts";
+
+async function withSchedule(action: (h: { run: () => Promise<any>; lock: string; launches: () => number }) => Promise<void>) {
+	const root = fs.mkdtempSync(path.join(os.tmpdir(), "schedule-claim-init-"));
+	const project = path.join(root, "project");
+	fs.mkdirSync(project);
+	const storeRoot = path.join(root, "stores");
+	const context = { cwd: project, sessionManager: { getSessionId: () => "owner", getSessionFile: () => path.join(project, "owner.jsonl") } } as any;
+	let launches = 0;
+	let id = 0;
+	const manager = createScheduledRunManager({
+		config: { scheduledRuns: { enabled: true } }, storeRoot, now: () => Date.parse("2030-01-01T00:00:00Z"),
+		randomId: () => `run-${++id}`, timers: { setTimeout: () => 1 as any, clearTimeout: () => {} },
+		launch: async () => { launches++; return { content: [], details: { asyncId: `async-${launches}` } }; },
+	});
+	manager.bindSession(context);
+	const originalWrite = fs.writeFileSync;
+	try {
+		const created = await manager.handleToolCall({ action: "schedule.create", id: "check", every: "1h", workflowScript: "return 1" }, context);
+		assert.equal(created.isError, undefined);
+		const lock = path.join(scheduledRunStorePath(project, undefined, storeRoot), "check", "active.lock");
+		await action({ run: () => manager.handleToolCall({ action: "schedule.run", id: "check" }, context), lock, launches: () => launches });
+	} finally {
+		fs.writeFileSync = originalWrite;
+		syncBuiltinESMExports();
+		manager.stop();
+		fs.rmSync(root, { recursive: true, force: true });
+	}
+}
+
+function failNextDescriptorWrite(before?: () => void): void {
+	const originalWrite = fs.writeFileSync;
+	fs.writeFileSync = function (file: any, ...args: any[]) {
+		if (typeof file !== "number") return (originalWrite as any).call(fs, file, ...args);
+		fs.writeFileSync = originalWrite;
+		syncBuiltinESMExports();
+		before?.();
+		throw Object.assign(new Error("claim write ENOSPC"), { code: "ENOSPC" });
+	} as typeof fs.writeFileSync;
+	syncBuiltinESMExports();
+}
+
+it("removes a schedule claim whose run id could not be written, so the next run launches", () => withSchedule(async (h) => {
+	failNextDescriptorWrite();
+	const failed = await h.run();
+	assert.equal(failed.isError, true);
+	assert.match(failed.content[0].text, /claim write ENOSPC/);
+	assert.equal(fs.existsSync(h.lock), false);
+	assert.equal(h.launches(), 0);
+
+	const retry = await h.run();
+	assert.equal(retry.isError, undefined);
+	assert.equal(retry.details.schedules.runs[0].state, "running");
+	assert.equal(h.launches(), 1);
+}));
+
+it("keeps a replacement owner's lock when its own claim write fails", () => withSchedule(async (h) => {
+	failNextDescriptorWrite(() => {
+		fs.unlinkSync(h.lock);
+		fs.writeFileSync(h.lock, "replacement");
+	});
+	const failed = await h.run();
+	assert.equal(failed.isError, true);
+	assert.equal(fs.readFileSync(h.lock, "utf-8"), "replacement");
+}));

package/dist/extensions/pi-subagents/test/unit/schedule-claim-preservation.test.ts

@@ -0,0 +1,98 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import assert from 'node:assert/strict';
+import { it } from 'node:test';
+import { syncBuiltinESMExports } from 'node:module';
+import { createScheduledRunManager, scheduledRunStorePath } from '../../src/runs/background/scheduled-runs.ts';
+const t0 = Date.parse('2030-01-01T00:00:00Z');
+async function setup(kind, action) {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), 'pi-claim-boundary-'));
+    const project = path.join(root, 'project');
+    fs.mkdirSync(project);
+    const storeRoot = path.join(root, 'stores');
+    const clock = { now: t0 };
+    const ctx = { cwd: project, sessionManager: { getSessionId: () => 'probe', getSessionFile: () => path.join(project, 'probe.jsonl') } };
+    const timers = new Map();
+    let timerId = 0;
+    let launches = 0;
+    let id = 0;
+    const manager = createScheduledRunManager({ config: { scheduledRuns: { enabled: true } }, storeRoot, now: () => clock.now, randomId: () => `probe-${++id}`,
+        timers: { setTimeout: (callback, delay) => { const key = ++timerId; timers.set(key, { callback, delay }); return key; }, clearTimeout: key => timers.delete(key) },
+        launch: async () => { launches++; return { content: [], details: { asyncId: 'probe-async' } }; }
+    });
+    const originalOpen = fs.openSync;
+    try {
+        manager.bindSession(ctx);
+        const trigger = kind === 'calendar' ? { every: 'day', at: '09:00', timezone: 'Asia/Taipei' } : kind === 'once' ? { at: '+1h' } : { every: '1h' };
+        const create = await manager.handleToolCall({ action: 'schedule.create', id: 'check', workflowScript: 'return 1', ...trigger }, ctx);
+        assert.equal(create.isError, undefined);
+        const dir = path.join(scheduledRunStorePath(project, undefined, storeRoot), 'check');
+        const file = path.join(dir, 'schedule.json');
+        const lock = path.join(dir, 'active.lock');
+        clock.now = t0 + 3600000;
+        fs.writeFileSync(lock, 'owner-proof');
+        const read = () => JSON.parse(fs.readFileSync(file, 'utf8'));
+        await action({ manager, ctx, dir, file, lock, read, clock, timers, launches: () => launches, originalOpen });
+    }
+    finally {
+        fs.openSync = originalOpen;
+        syncBuiltinESMExports();
+        manager.stop();
+        fs.rmSync(root, { recursive: true, force: true });
+    }
+}
+for (const kind of ['interval', 'calendar', 'once'])
+    it(`EEXIST preserves current owner edits: ${kind}`, async () => setup(kind, async (h) => {
+        let current;
+        fs.openSync = function (file, flags, ...args) {
+            if (file === h.lock && flags === 'wx') {
+                current = h.read();
+                current.activeRunId = 'winner';
+                current.lastRunId = 'winner';
+                current.name = 'Edited by owner';
+                current.paused = true;
+                fs.writeFileSync(h.file, JSON.stringify(current));
+            }
+            return h.originalOpen.call(fs, file, flags, ...args);
+        };
+        syncBuiltinESMExports();
+        const result = await h.manager.handleToolCall({ action: 'schedule.run-due' }, h.ctx);
+        assert.equal(result.isError, undefined);
+        assert.deepEqual(h.read(), current);
+        assert.equal(h.launches(), 0);
+        assert.equal(h.timers.size, 0);
+        assert.equal(fs.readFileSync(h.lock, 'utf8'), 'owner-proof');
+    }));
+for (const kind of ['interval', 'calendar', 'once'])
+    it(`EEXIST before owner persistence avoids immediate polling: ${kind}`, async () => setup(kind, async (h) => {
+        const before = h.read();
+        const result = await h.manager.handleToolCall({ action: 'schedule.run-due' }, h.ctx);
+        assert.equal(result.isError, undefined);
+        assert.deepEqual(h.read(), before);
+        const delays = [...h.timers.values()].map(timer => timer.delay);
+        if (kind === 'once')
+            assert.deepEqual(delays, []);
+        else
+            assert.equal(delays.length === 1 && delays[0] > 0, true);
+        assert.equal(h.launches(), 0);
+        assert.equal(fs.readFileSync(h.lock, 'utf8'), 'owner-proof');
+    }));
+it('EEXIST does not recreate a concurrently removed schedule', async () => setup('interval', async (h) => {
+    fs.openSync = function (file, flags, ...args) {
+        try {
+            return h.originalOpen.call(fs, file, flags, ...args);
+        }
+        catch (error) {
+            if (file === h.lock && flags === 'wx' && error.code === 'EEXIST')
+                fs.rmSync(h.dir, { recursive: true, force: true });
+            throw error;
+        }
+    };
+    syncBuiltinESMExports();
+    const result = await h.manager.handleToolCall({ action: 'schedule.run-due' }, h.ctx);
+    assert.equal(result.isError, undefined);
+    assert.equal(fs.existsSync(h.dir), false);
+    assert.equal(h.timers.size, 0);
+    assert.equal(h.launches(), 0);
+}));