@selesai/code 0.8.3 → 0.8.5

package/dist/extensions/pi-subagents/test/unit/prompt-template-bridge.test.ts

@@ -25,8 +25,7 @@ class FakeEvents implements PromptTemplateBridgeEvents {
 	}
 
 	emit(event: string, data: unknown): void {
-		const list = this.handlers.get(event) ?? [];
-		for (const handler of [...list]) handler(data);
+		for (const handler of [...this.handlers.get(event) ?? []]) handler(data);
 	}
 }
 
@@ -39,21 +38,36 @@ function once(events: FakeEvents, event: string): Promise<unknown> {
 	});
 }
 
+function structuredRequest(overrides: Record<string, unknown> = {}): Record<string, unknown> {
+	return {
+		requestId: "r1",
+		ownerRunId: "owner-1",
+		nodeId: "node-1",
+		agent: "worker",
+		task: "do work",
+		context: "fresh",
+		model: "openai/gpt-5",
+		cwd: "/repo",
+		result: { kind: "text" },
+		...overrides,
+	};
+}
+
 describe("prompt-template delegation bridge", () => {
-	it("emits started/update/response on successful request", async () => {
+	it("emits started/update/response on successful structured request", async () => {
 		const events = new FakeEvents();
 		let executeCalls = 0;
 		const bridge = registerPromptTemplateDelegationBridge({
 			events,
 			getContext: () => ({ cwd: "/repo" }),
-			execute: async (_requestId, _request, _signal, _ctx, onUpdate) => {
+			executeStructured: async (_requestId, _request, _signal, _ctx, onUpdate) => {
 				executeCalls++;
 				onUpdate({
 					details: {
-						results: [{ agent: "builder", model: "openai/gpt-5-mini" }],
+						results: [{ agent: "worker", model: "openai/gpt-5-mini" }],
 						progress: [{
 							index: 0,
-							agent: "builder",
+							agent: "worker",
 							currentTool: "read",
 							currentToolArgs: "src/extension/index.ts",
 							recentOutput: ["line 1"],
@@ -66,30 +80,26 @@ describe("prompt-template delegation bridge", () => {
 				});
 				return {
 					details: {
-						results: [{ messages: [{ role: "assistant", content: [{ type: "text", text: "ok" }] }] }],
+						results: [{ agent: "worker", finalOutput: "ok", exitCode: 0 }],
 					},
 				};
 			},
+			execute: async () => { throw new Error("structured request should use executeStructured"); },
 		});
 
 		const startedPromise = once(events, PROMPT_TEMPLATE_SUBAGENT_STARTED_EVENT);
 		const updatePromise = once(events, PROMPT_TEMPLATE_SUBAGENT_UPDATE_EVENT);
 		const responsePromise = once(events, PROMPT_TEMPLATE_SUBAGENT_RESPONSE_EVENT);
 
-		events.emit(PROMPT_TEMPLATE_SUBAGENT_REQUEST_EVENT, {
-			requestId: "r1",
-			agent: "builder",
-			task: "do work",
-			context: "fresh",
-			model: "openai/gpt-5",
-			cwd: "/repo",
-		});
+		events.emit(PROMPT_TEMPLATE_SUBAGENT_REQUEST_EVENT, structuredRequest());
 
-		const started = await startedPromise as { requestId: string };
-		assert.equal(started.requestId, "r1");
+		const started = await startedPromise as { requestId: string; ownerRunId: string; nodeId: string };
+		assert.deepEqual(started, { requestId: "r1", ownerRunId: "owner-1", nodeId: "node-1" });
 
 		const update = await updatePromise as {
 			requestId: string;
+			ownerRunId: string;
+			nodeId: string;
 			currentTool?: string;
 			toolCount?: number;
 			recentOutputLines?: string[];
@@ -98,107 +108,24 @@ describe("prompt-template delegation bridge", () => {
 			taskProgress?: Array<{ model?: string }>;
 		};
 		assert.equal(update.requestId, "r1");
+		assert.equal(update.ownerRunId, "owner-1");
+		assert.equal(update.nodeId, "node-1");
 		assert.equal(update.currentTool, "read");
 		assert.equal(update.toolCount, 1);
 		assert.deepEqual(update.recentOutputLines, ["line 1"]);
 		assert.deepEqual(update.recentTools, [{ tool: "read", args: '{"path":"src/extension/index.ts"}' }]);
-		assert.equal(update.model, "openai/gpt-5-mini");
-		assert.equal(update.taskProgress?.[0]?.model, "openai/gpt-5-mini");
 
-		const response = await responsePromise as { requestId: string; isError: boolean; messages: unknown[] };
+		const response = await responsePromise as { requestId: string; ownerRunId: string; nodeId: string; status: string; result?: { kind: string; text?: string } };
 		assert.equal(response.requestId, "r1");
-		assert.equal(response.isError, false);
-		assert.equal(Array.isArray(response.messages), true);
+		assert.equal(response.ownerRunId, "owner-1");
+		assert.equal(response.nodeId, "node-1");
+		assert.equal(response.status, "completed");
+		assert.deepEqual(response.result, { kind: "text", text: "ok" });
 		assert.equal(executeCalls, 1);
 
 		bridge.dispose();
 	});
 
-	it("rebuilds compact tool-call summaries into delegated response messages", async () => {
-		const events = new FakeEvents();
-		const bridge = registerPromptTemplateDelegationBridge({
-			events,
-			getContext: () => ({ cwd: "/repo" }),
-			execute: async () => ({
-				details: {
-					results: [{
-						finalOutput: "finished",
-						toolCalls: [
-							{ text: "write src/output.md", expandedText: "write src/output.md" },
-							{ text: "edit src/output.md", expandedText: "edit src/output.md" },
-						],
-					}],
-				},
-			}),
-		});
-
-		const responsePromise = once(events, PROMPT_TEMPLATE_SUBAGENT_RESPONSE_EVENT);
-		events.emit(PROMPT_TEMPLATE_SUBAGENT_REQUEST_EVENT, {
-			requestId: "r-compact-tools",
-			agent: "builder",
-			task: "do work",
-			context: "fresh",
-			model: "openai/gpt-5",
-			cwd: "/repo",
-		});
-
-		const response = await responsePromise as { messages: Array<{ role?: string; content?: Array<{ type?: string; name?: string; text?: string }> }> };
-		assert.equal(response.messages.length, 1);
-		assert.equal(response.messages[0]?.role, "assistant");
-		assert.deepEqual(
-			response.messages[0]?.content?.filter((part) => part.type === "toolCall").map((part) => part.name),
-			["write", "edit"],
-		);
-		assert.equal(response.messages[0]?.content?.some((part) => part.type === "text" && part.text === "finished"), true);
-
-		bridge.dispose();
-	});
-
-	it("filters malformed recent output entries in updates", async () => {
-		const events = new FakeEvents();
-		const bridge = registerPromptTemplateDelegationBridge({
-			events,
-			getContext: () => ({ cwd: "/repo" }),
-			execute: async (_requestId, _request, _signal, _ctx, onUpdate) => {
-				onUpdate({
-					details: {
-						results: [{ agent: "builder", model: "openai/gpt-5-mini" }],
-						progress: [{
-							index: 0,
-							agent: "builder",
-							recentOutput: ["line 1", 123 as unknown as string],
-						}],
-					},
-				});
-				return { details: { results: [{ messages: [] }] } };
-			},
-		});
-
-		const updatePromise = once(events, PROMPT_TEMPLATE_SUBAGENT_UPDATE_EVENT);
-		const responsePromise = once(events, PROMPT_TEMPLATE_SUBAGENT_RESPONSE_EVENT);
-		events.emit(PROMPT_TEMPLATE_SUBAGENT_REQUEST_EVENT, {
-			requestId: "r-malformed-output",
-			agent: "builder",
-			task: "do work",
-			context: "fresh",
-			model: "openai/gpt-5",
-			cwd: "/repo",
-		});
-
-		const update = await updatePromise as {
-			recentOutput?: string;
-			recentOutputLines?: string[];
-			taskProgress?: Array<{ recentOutput?: string; recentOutputLines?: string[] }>;
-		};
-		assert.equal(update.recentOutput, undefined);
-		assert.deepEqual(update.recentOutputLines, ["line 1"]);
-		assert.equal(update.taskProgress?.[0]?.recentOutput, undefined);
-		assert.deepEqual(update.taskProgress?.[0]?.recentOutputLines, ["line 1"]);
-
-		await responsePromise;
-		bridge.dispose();
-	});
-
 	it("returns structured error when no active context", async () => {
 		const events = new FakeEvents();
 		const bridge = registerPromptTemplateDelegationBridge({
@@ -208,113 +135,86 @@ describe("prompt-template delegation bridge", () => {
 		});
 
 		const responsePromise = once(events, PROMPT_TEMPLATE_SUBAGENT_RESPONSE_EVENT);
-		events.emit(PROMPT_TEMPLATE_SUBAGENT_REQUEST_EVENT, {
-			requestId: "r2",
-			agent: "builder",
-			task: "do work",
-			context: "fresh",
-			model: "openai/gpt-5",
-			cwd: "/repo",
-		});
+		events.emit(PROMPT_TEMPLATE_SUBAGENT_REQUEST_EVENT, structuredRequest({ requestId: "r2" }));
 
-		const response = await responsePromise as { isError: boolean; errorText?: string };
-		assert.equal(response.isError, true);
-		assert.match(response.errorText ?? "", /No active extension context/);
+		const response = await responsePromise as { status: string; error?: string };
+		assert.equal(response.status, "unavailable_context");
+		assert.match(response.error ?? "", /No active extension context/);
 
 		bridge.dispose();
 	});
 
-	it("accepts requests when delegated cwd differs from active context", async () => {
+	it("applies pending cancel when cancel arrives before structured request", async () => {
 		const events = new FakeEvents();
-		let executeCwd: string | undefined;
+		let executeCalls = 0;
 		const bridge = registerPromptTemplateDelegationBridge({
 			events,
-			getContext: () => ({ cwd: "/actual" }),
-			execute: async (_requestId, request) => {
-				executeCwd = request.cwd;
+			getContext: () => ({ cwd: "/repo" }),
+			execute: async () => {
+				executeCalls++;
 				return { details: { results: [{ messages: [] }] } };
 			},
 		});
 
+		events.emit(PROMPT_TEMPLATE_SUBAGENT_CANCEL_EVENT, { requestId: "r4", ownerRunId: "owner-1", nodeId: "node-1" });
 		const responsePromise = once(events, PROMPT_TEMPLATE_SUBAGENT_RESPONSE_EVENT);
-		events.emit(PROMPT_TEMPLATE_SUBAGENT_REQUEST_EVENT, {
-			requestId: "r3",
-			agent: "builder",
-			task: "do work",
-			context: "fresh",
-			model: "openai/gpt-5",
-			cwd: "/repo",
-		});
+		events.emit(PROMPT_TEMPLATE_SUBAGENT_REQUEST_EVENT, structuredRequest({ requestId: "r4" }));
 
-		const response = await responsePromise as { isError: boolean; errorText?: string };
-		assert.equal(response.isError, false);
-		assert.equal(executeCwd, "/repo");
+		const response = await responsePromise as { status: string };
+		assert.equal(response.status, "cancelled");
+		assert.equal(executeCalls, 0);
 
 		bridge.dispose();
 	});
 
-	it("applies pending cancel when cancel arrives before request", async () => {
+	it("cancels in-flight structured delegated execution", async () => {
 		const events = new FakeEvents();
-		let executeCalls = 0;
 		const bridge = registerPromptTemplateDelegationBridge({
 			events,
 			getContext: () => ({ cwd: "/repo" }),
-			execute: async () => {
-				executeCalls++;
-				return { details: { results: [{ messages: [] }] } };
-			},
+			execute: async (_requestId, _request, signal) =>
+				await new Promise((_resolve, reject) => {
+					signal.addEventListener("abort", () => reject(new Error("aborted")), { once: true });
+				}),
 		});
 
-		events.emit(PROMPT_TEMPLATE_SUBAGENT_CANCEL_EVENT, { requestId: "r4" });
+		const startedPromise = once(events, PROMPT_TEMPLATE_SUBAGENT_STARTED_EVENT);
 		const responsePromise = once(events, PROMPT_TEMPLATE_SUBAGENT_RESPONSE_EVENT);
 
-		events.emit(PROMPT_TEMPLATE_SUBAGENT_REQUEST_EVENT, {
-			requestId: "r4",
-			agent: "builder",
-			task: "do work",
-			context: "fresh",
-			model: "openai/gpt-5",
-			cwd: "/repo",
-		});
+		events.emit(PROMPT_TEMPLATE_SUBAGENT_REQUEST_EVENT, structuredRequest({ requestId: "r5" }));
 
-		const response = await responsePromise as { isError: boolean; errorText?: string };
-		assert.equal(response.isError, true);
-		assert.equal(response.errorText, "Delegated prompt cancelled.");
-		assert.equal(executeCalls, 0);
+		await startedPromise;
+		events.emit(PROMPT_TEMPLATE_SUBAGENT_CANCEL_EVENT, { requestId: "r5", ownerRunId: "owner-1", nodeId: "node-1" });
+
+		const response = await responsePromise as { status: string; error?: string };
+		assert.equal(response.status, "cancelled");
 
 		bridge.dispose();
 	});
 
-	it("cancels in-flight delegated execution", async () => {
+	it("rejects legacy direct payloads without executor dispatch", async () => {
 		const events = new FakeEvents();
+		let executeCalls = 0;
 		const bridge = registerPromptTemplateDelegationBridge({
 			events,
 			getContext: () => ({ cwd: "/repo" }),
-			execute: async (_requestId, _request, signal) =>
-				await new Promise((_resolve, reject) => {
-					signal.addEventListener("abort", () => reject(new Error("aborted")), { once: true });
-				}),
+			execute: async () => { executeCalls++; return {}; },
 		});
 
-		const startedPromise = once(events, PROMPT_TEMPLATE_SUBAGENT_STARTED_EVENT);
 		const responsePromise = once(events, PROMPT_TEMPLATE_SUBAGENT_RESPONSE_EVENT);
-
 		events.emit(PROMPT_TEMPLATE_SUBAGENT_REQUEST_EVENT, {
-			requestId: "r5",
-			agent: "builder",
+			requestId: "legacy-1",
+			agent: "worker",
 			task: "do work",
 			context: "fresh",
 			model: "openai/gpt-5",
 			cwd: "/repo",
 		});
 
-		await startedPromise;
-		events.emit(PROMPT_TEMPLATE_SUBAGENT_CANCEL_EVENT, { requestId: "r5" });
-
 		const response = await responsePromise as { isError: boolean; errorText?: string };
 		assert.equal(response.isError, true);
-		assert.match(response.errorText ?? "", /aborted/i);
-
+		assert.match(response.errorText ?? "", /Legacy prompt-template direct delegation was removed/);
+		assert.equal(executeCalls, 0);
 		bridge.dispose();
 	});
 
@@ -330,7 +230,7 @@ describe("prompt-template delegation bridge", () => {
 		const tasksResponse = once(events, PROMPT_TEMPLATE_SUBAGENT_RESPONSE_EVENT);
 		events.emit(PROMPT_TEMPLATE_SUBAGENT_REQUEST_EVENT, {
 			requestId: "r6",
-			tasks: [{ agent: "builder-a", task: "A" }],
+			tasks: [{ agent: "worker-a", task: "A" }],
 			context: "fresh",
 			model: "openai/gpt-5",
 			cwd: "/repo",

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

@@ -4,6 +4,7 @@ import * as os from "node:os";
 import * as path from "node:path";
 import { afterEach, beforeEach, describe, it } from "node:test";
 import { discoverPromptWorkflows, registerPromptWorkflowCommands } from "../../src/slash/prompt-workflows.ts";
+import { renderWorkflowPrompt } from "../../src/shared/prompt-resources.ts";
 import type { SubagentParamsLike } from "../../src/runs/foreground/subagent-executor.ts";
 
 const originalAgentDir = process.env.SELESAI_CODING_AGENT_DIR;
@@ -48,13 +49,13 @@ describe("prompt workflows", () => {
 	it("discovers project workflows over user workflows", () => {
 		writePrompt(path.join(agentDir, "prompts"), "native-test", `---
 description: User version
-subagent: commentator
+subagent: reviewer
 ---
 User body
 `);
 		writePrompt(path.join(cwd, ".selesai", "prompts"), "native-test", `---
 description: Project version
-subagent: builder
+subagent: worker
 model: openai/gpt-5-mini
 ---
 Project body $1
@@ -63,14 +64,36 @@ Project body $1
 		const workflow = discoverPromptWorkflows(cwd).find((entry) => entry.name === "native-test");
 
 		assert.equal(workflow?.description, "Project version");
-		assert.equal(workflow?.agent, "builder");
+		assert.equal(workflow?.agent, "worker");
 		assert.equal(workflow?.model, "openai/gpt-5-mini");
 	});
 
+	it("renders explicitly scoped prompt fragments with simple variables", () => {
+		writePrompt(path.join(agentDir, "prompts"), "writer-followup", `---
+description: User follow-up
+---
+User pass {{pass}}: {{previous}} {{missing}}
+`);
+		writePrompt(path.join(cwd, ".selesai", "prompts"), "writer-followup", "Project pass {{pass}}: {{previous}}");
+
+		assert.equal(renderWorkflowPrompt("user:writer-followup", { pass: 1, previous: "draft" }, cwd), "User pass 1: draft {{missing}}");
+		assert.equal(renderWorkflowPrompt("project:writer-followup", { pass: 2, previous: "revision" }, cwd), "Project pass 2: revision");
+		assert.match(renderWorkflowPrompt("package:review-loop", undefined, cwd), /^Run a parent-orchestrated review loop/);
+		assert.throws(() => renderWorkflowPrompt("writer-followup", {}, cwd), /package:<name>.*user:<name>.*project:<name>/);
+		assert.throws(() => renderWorkflowPrompt("project:../secret", {}, cwd), /ref must use/);
+		try {
+			fs.symlinkSync(path.join(agentDir, "prompts", "writer-followup.md"), path.join(cwd, ".selesai", "prompts", "linked.md"));
+			assert.throws(() => renderWorkflowPrompt("project:linked", {}, cwd), /not a regular file/);
+		} catch (error) {
+			if (!["EPERM", "EACCES", "ENOSYS"].includes((error as NodeJS.ErrnoException).code ?? "")) throw error;
+		}
+		assert.throws(() => renderWorkflowPrompt("project:writer-followup", { previous: { nested: true } }, cwd), /string, number, or boolean/);
+	});
+
 	it("runs a named workflow through native subagent execution", async () => {
 		writePrompt(path.join(cwd, ".selesai", "prompts"), "native-run", `---
 description: Run native prompt
-subagent: commentator
+subagent: reviewer
 model: anthropic/claude-sonnet-4
 skill: deslop,typescript-code
 ---
@@ -91,24 +114,35 @@ Review $1 with $ARGUMENTS
 
 		assert.equal(sent.length, 0);
 		assert.equal(runs.length, 1);
-		assert.equal(runs[0]?.agent, "commentator");
-		assert.equal(runs[0]?.model, "anthropic/claude-sonnet-4");
-		assert.deepEqual(runs[0]?.skill, ["deslop", "typescript-code"]);
-		assert.equal(runs[0]?.context, "fork");
-		assert.equal(runs[0]?.task, "Review target with target");
+		const params = runs[0];
+		assert.equal(params?.agent, undefined);
+		assert.equal(params?.task, undefined);
+		assert.equal(params?.clarify, undefined);
+		assert.equal(params?.model, undefined);
+		assert.equal(params?.skill, undefined);
+		assert.equal(params?.context, undefined);
+		assert.equal(params?.agentScope, "both");
+		assert.equal(params?.async, false);
+		const script = params?.workflowScript ?? "";
+		assert.match(script, /runs\.run\("prompt-1-native-run"/);
+		assert.match(script, /"agent":"reviewer"/);
+		assert.match(script, /"model":"anthropic\/claude-sonnet-4"/);
+		assert.match(script, /"skill":\["deslop","typescript-code"\]/);
+		assert.match(script, /"context":"fork"/);
+		assert.match(script, /Review target with target/);
 	});
 
 	it("runs declared prompt sequences through workflowScript", async () => {
 		writePrompt(path.join(cwd, ".selesai", "prompts"), "native-analyze", `---
 description: Analyze
-subagent: explorer
+subagent: scout
 chain: native-analyze -> native-fix
 ---
 Analyze $@
 `);
 		writePrompt(path.join(cwd, ".selesai", "prompts"), "native-fix", `---
 description: Fix
-subagent: builder
+subagent: worker
 ---
 Fix from {previous}: $@
 `);
@@ -125,9 +159,18 @@ Fix from {previous}: $@
 		await commands.get("prompt-workflow")!.handler("native-analyze bug report", makeCtx(cwd));
 
 		assert.equal(runs.length, 1);
-		assert.match(runs[0]?.workflowScript ?? "", /runs\.run\("prompt-1-native-analyze"/);
-		assert.match(runs[0]?.workflowScript ?? "", /runs\.run\("prompt-2-native-fix"/);
-		assert.match(runs[0]?.workflowScript ?? "", /replaceAll\("\{previous\}"/);
-		assert.equal(commands.has("chain-prompts"), false);
+		const params = runs[0];
+		assert.equal(params?.agent, undefined);
+		assert.equal(params?.task, undefined);
+		assert.equal(params?.clarify, undefined);
+		assert.equal(params?.agentScope, "both");
+		assert.equal(params?.async, false);
+		assert.match(params?.workflowScript ?? "", /runs\.run\("prompt-1-native-analyze"/);
+		assert.match(params?.workflowScript ?? "", /runs\.run\("prompt-2-native-fix"/);
+		assert.match(params?.workflowScript ?? "", /replaceAll\("\{previous\}"/);
+		assert.equal(commands.has("chain-prompts"), true);
+		assert.equal(commands.has("chain"), true);
+		assert.equal(commands.has("parallel"), true);
+		assert.equal(commands.has("run-chain"), true);
 	});
 });

package/dist/extensions/pi-subagents/test/unit/public-execution.test.ts

@@ -0,0 +1,51 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { normalizePublicSubagentExecution } from "../../src/extension/public-execution.ts";
+
+describe("public subagent execution normalization", () => {
+	it("accepts all four execution modes, management, and direct-field schedules", () => {
+		assert.deepEqual(normalizePublicSubagentExecution({ workflowScript: "return 1" }), { ok: true, params: { workflowScript: "return 1" } });
+		assert.deepEqual(normalizePublicSubagentExecution({ agent: "worker", task: "work" }), { ok: true, params: { agent: "worker", task: "work" } });
+		assert.deepEqual(normalizePublicSubagentExecution({ tasks: [{ agent: "worker" }] }), { ok: true, params: { tasks: [{ agent: "worker" }] } });
+		assert.deepEqual(normalizePublicSubagentExecution({ chain: [{ agent: "worker" }] }), { ok: true, params: { chain: [{ agent: "worker" }] } });
+		assert.deepEqual(normalizePublicSubagentExecution({ action: " list " }), { ok: true, params: { action: "list" } });
+		assert.deepEqual(
+			normalizePublicSubagentExecution({ action: " schedule.create ", every: "1h", workflowScript: "return 1" }),
+			{ ok: true, params: { action: "schedule.create", every: "1h", workflowScript: "return 1" } },
+		);
+		assert.deepEqual(
+			normalizePublicSubagentExecution({ action: "schedule.create", agent: "worker", task: "work" }),
+			{ ok: true, params: { action: "schedule.create", agent: "worker", task: "work" } },
+		);
+	});
+
+	it("rejects private run fan-out fields at the public boundary", () => {
+		for (const params of [
+			{ workflowScript: "return 1", runFanoutBudget: { version: 1 } },
+			{ workflowScript: "return 1", runFanoutAdmitted: true },
+		] as const) {
+			const result = normalizePublicSubagentExecution(params);
+			assert.equal(result.ok, false);
+			if (!result.ok) assert.match(result.error, /does not accept internal run fan-out fields/);
+		}
+	});
+
+	it("rejects removed public execution shapes", () => {
+		for (const params of [
+			{ action: " " },
+			{ action: "single" },
+			{ action: "parallel" },
+			{ action: "chain" },
+			{ parallel: [{ agent: "worker" }] },
+			{ concurrency: 2 },
+			{ clarify: true, workflowScript: "return 1" },
+			{ resume: "retained-run", workflowScript: "return 1" },
+			{},
+			{ workflowScript: " " },
+			{ action: "status", workflowScript: "return 1" },
+			{ action: "schedule.create", every: "1h" },
+		] as const) {
+			assert.equal(normalizePublicSubagentExecution(params).ok, false, JSON.stringify(params));
+		}
+	});
+});

package/dist/extensions/pi-subagents/test/unit/reads-resolution.test.ts

@@ -0,0 +1,66 @@
+import { describe, test, before, after } from "node:test";
+import * as assert from "node:assert";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { expandHomePath, resolveChainPath } from "../../src/shared/settings.ts";
+
+const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-reads-resolution-"));
+const homeDir = path.join(tmpDir, "home");
+const chainDir = path.join(tmpDir, "chain");
+const originalHome = process.env.HOME;
+const originalUserProfile = process.env.USERPROFILE;
+
+before(() => {
+	process.env.HOME = homeDir;
+	process.env.USERPROFILE = homeDir;
+	assert.equal(os.homedir(), homeDir);
+});
+
+after(() => {
+	if (originalHome === undefined) delete process.env.HOME;
+	else process.env.HOME = originalHome;
+	if (originalUserProfile === undefined) delete process.env.USERPROFILE;
+	else process.env.USERPROFILE = originalUserProfile;
+});
+
+describe("reads path resolution", () => {
+	describe("expandHomePath", () => {
+		test("expands bare ~ to the home directory", () => {
+			assert.equal(expandHomePath("~"), homeDir);
+		});
+
+		test("expands ~/ to the home directory", () => {
+			assert.equal(expandHomePath("~/"), homeDir);
+		});
+
+		test("expands ~/file to <home>/file", () => {
+			assert.equal(expandHomePath("~/.zprofile"), path.join(homeDir, ".zprofile"));
+		});
+
+		test("leaves absolute paths unchanged", () => {
+			assert.equal(expandHomePath("/etc/hosts"), "/etc/hosts");
+		});
+
+		test("leaves repository-relative paths unchanged", () => {
+			assert.equal(expandHomePath("docs/x.md"), "docs/x.md");
+		});
+	});
+
+	describe("resolveChainPath", () => {
+		test("expands ~ before resolving", () => {
+			assert.equal(
+				resolveChainPath("~/.zprofile", chainDir),
+				path.join(homeDir, ".zprofile"),
+			);
+		});
+
+		test("passes absolute paths through", () => {
+			assert.equal(resolveChainPath("/etc/hosts", chainDir), "/etc/hosts");
+		});
+
+		test("prepends chainDir to repository-relative paths", () => {
+			assert.equal(resolveChainPath("docs/x.md", chainDir), path.join(chainDir, "docs/x.md"));
+		});
+	});
+});