@selesai/code 0.3.0 → 0.3.1

package/dist/extensions/pi-subagents/test/unit/close-grace-timer.test.ts

@@ -0,0 +1,101 @@
+import assert from "node:assert/strict";
+import { spawn } 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 { attachPostExitStdioGuard, trySignalChild } from "../../src/shared/post-exit-stdio-guard.ts";
+
+function writeScript(name: string, lines: string[]): string {
+	const dir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-close-grace-"));
+	const script = path.join(dir, name);
+	fs.writeFileSync(script, lines.join("\n"), { mode: 0o755 });
+	return script;
+}
+
+function makeSilentLeakyScript(sleepSeconds: number): string {
+	return writeScript("silent-leak.sh", [
+		"#!/bin/bash",
+		"set -eu",
+		"echo done",
+		`sleep ${sleepSeconds} &`,
+		"disown || true",
+		"exit 0",
+	]);
+}
+
+function makeChattyLeakyScript(tickMs: number): string {
+	return writeScript("chatty-leak.sh", [
+		"#!/bin/bash",
+		"set -eu",
+		"echo start",
+		`( while true; do echo tick; sleep ${(tickMs / 1000).toFixed(3)}; done ) &`,
+		"disown || true",
+		"exit 0",
+	]);
+}
+
+interface RunResult {
+	resolvedMs: number;
+	exitCode: number | null;
+	stdout: string;
+}
+
+function runWithGuard(script: string, idleMs: number, hardMs: number, maxWaitMs: number): Promise<RunResult> {
+	return new Promise((resolve, reject) => {
+		const start = Date.now();
+		const child = spawn("bash", [script], { stdio: ["ignore", "pipe", "pipe"] });
+		let stdout = "";
+		const clearGuard = attachPostExitStdioGuard(child, { idleMs, hardMs });
+		const hardStop = setTimeout(() => {
+			try { child.kill("SIGKILL"); } catch {}
+			reject(new Error(`promise did not resolve within ${maxWaitMs}ms`));
+		}, maxWaitMs);
+		hardStop.unref?.();
+
+		child.stdout.on("data", (chunk: Buffer) => {
+			stdout += chunk.toString();
+		});
+		child.stderr.on("data", () => {});
+		child.on("close", (code) => {
+			clearTimeout(hardStop);
+			clearGuard();
+			resolve({ resolvedMs: Date.now() - start, exitCode: code, stdout });
+		});
+		child.on("error", reject);
+	});
+}
+
+describe("attachPostExitStdioGuard", () => {
+	it("reports whether a termination signal was actually delivered", () => {
+		assert.equal(trySignalChild({ kill: () => true }, "SIGTERM"), true);
+		assert.equal(trySignalChild({ kill: () => false }, "SIGTERM"), false);
+		assert.equal(trySignalChild({ kill: () => { throw new Error("gone"); } }, "SIGTERM"), false);
+	});
+
+	it("does not delay a clean exit", { skip: process.platform === "win32" ? "bash scripts unavailable on Windows" : undefined }, async () => {
+		const script = writeScript("clean.sh", ["#!/bin/bash", "set -eu", "echo hello", "exit 0"]);
+		const result = await runWithGuard(script, 2000, 8000, 5000);
+		assert.equal(result.exitCode, 0);
+		assert.match(result.stdout, /hello/);
+		assert.ok(result.resolvedMs < 500, `expected fast close, got ${result.resolvedMs}ms`);
+	});
+
+	it("cuts off a silent grandchild with the idle timer", { skip: process.platform === "win32" ? "bash scripts unavailable on Windows" : undefined }, async () => {
+		const idleMs = 1500;
+		const result = await runWithGuard(makeSilentLeakyScript(30), idleMs, 8000, 10000);
+		assert.equal(result.exitCode, 0);
+		assert.match(result.stdout, /done/);
+		assert.ok(result.resolvedMs >= idleMs, `resolved too early: ${result.resolvedMs}ms`);
+		assert.ok(result.resolvedMs < idleMs + 2000, `expected idle cutoff, got ${result.resolvedMs}ms`);
+	});
+
+	it("cuts off a chatty grandchild with the hard timer", { skip: process.platform === "win32" ? "bash scripts unavailable on Windows" : undefined }, async () => {
+		const hardMs = 2000;
+		const result = await runWithGuard(makeChattyLeakyScript(200), 1000, hardMs, 10000);
+		assert.equal(result.exitCode, 0);
+		assert.match(result.stdout, /start/);
+		assert.ok(result.resolvedMs >= hardMs - 500, `resolved too early: ${result.resolvedMs}ms`);
+		assert.ok(result.resolvedMs < hardMs + 2000, `expected hard cutoff, got ${result.resolvedMs}ms`);
+	});
+});

package/dist/extensions/pi-subagents/test/unit/completion-batcher.test.ts

@@ -0,0 +1,228 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import {
+	createCompletionBatcher,
+	DEFAULT_COMPLETION_BATCH_CONFIG,
+	resolveCompletionBatchConfig,
+} from "../../src/runs/background/completion-batcher.ts";
+
+interface FakeJob {
+	id: number;
+	fireAt: number;
+	handler: () => void;
+}
+
+function createFakeClock() {
+	let now = 0;
+	let nextId = 1;
+	const jobs = new Map<number, FakeJob>();
+	const api = {
+		setTimeout(handler: () => void, delayMs: number): unknown {
+			const id = nextId++;
+			jobs.set(id, { id, fireAt: now + delayMs, handler });
+			return id;
+		},
+		clearTimeout(handle: unknown): void {
+			if (typeof handle === "number") jobs.delete(handle);
+		},
+	};
+	return {
+		api,
+		now: () => now,
+		advance(ms: number): void {
+			now += ms;
+			const due = [...jobs.values()].filter((job) => job.fireAt <= now).sort((a, b) => a.fireAt - b.fireAt);
+			for (const job of due) {
+				if (!jobs.has(job.id)) continue;
+				jobs.delete(job.id);
+				job.handler();
+			}
+		},
+		pendingCount: () => jobs.size,
+	};
+}
+
+function item(label: string): { label: string } {
+	return { label };
+}
+
+describe("resolveCompletionBatchConfig", () => {
+	it("applies defaults when no config is provided", () => {
+		assert.deepEqual(resolveCompletionBatchConfig(), DEFAULT_COMPLETION_BATCH_CONFIG);
+	});
+
+	it("override wins over global config", () => {
+		const resolved = resolveCompletionBatchConfig({ debounceMs: 50, maxWaitMs: 200 }, { debounceMs: 80 });
+		assert.equal(resolved.debounceMs, 80);
+		assert.equal(resolved.maxWaitMs, 200);
+	});
+
+	it("rejects invalid booleans and non-positive or fractional integers", () => {
+		const resolved = resolveCompletionBatchConfig({ enabled: "false", debounceMs: 0, maxWaitMs: -5, stragglerDebounceMs: 1.5, stragglerWindowMs: Number.NaN } as never);
+		assert.equal(resolved.enabled, DEFAULT_COMPLETION_BATCH_CONFIG.enabled);
+		assert.equal(resolved.debounceMs, DEFAULT_COMPLETION_BATCH_CONFIG.debounceMs);
+		assert.equal(resolved.maxWaitMs, DEFAULT_COMPLETION_BATCH_CONFIG.maxWaitMs);
+		assert.equal(resolved.stragglerDebounceMs, DEFAULT_COMPLETION_BATCH_CONFIG.stragglerDebounceMs);
+		assert.equal(resolved.stragglerWindowMs, DEFAULT_COMPLETION_BATCH_CONFIG.stragglerWindowMs);
+	});
+
+	it("ignores invalid overrides instead of masking valid global config", () => {
+		const resolved = resolveCompletionBatchConfig(
+			{ enabled: false, debounceMs: 80 },
+			{ enabled: "false", debounceMs: "bad" } as never,
+		);
+		assert.equal(resolved.enabled, false);
+		assert.equal(resolved.debounceMs, 80);
+	});
+});
+
+describe("createCompletionBatcher", () => {
+	it("emits immediately when batching is disabled", () => {
+		const emitted: string[][] = [];
+		const batcher = createCompletionBatcher<{ label: string }>({
+			config: { ...DEFAULT_COMPLETION_BATCH_CONFIG, enabled: false },
+			emit: (items) => emitted.push(items.map((i) => i.label)),
+		});
+		batcher.push(item("a"));
+		batcher.push(item("b"));
+		assert.deepEqual(emitted, [["a"], ["b"]]);
+		batcher.dispose();
+	});
+
+	it("coalesces a burst into one grouped emit when the debounce fires", () => {
+		const clock = createFakeClock();
+		const emitted: string[][] = [];
+		const batcher = createCompletionBatcher<{ label: string }>({
+			config: { enabled: true, debounceMs: 150, maxWaitMs: 1000, stragglerDebounceMs: 75, stragglerMaxWaitMs: 400, stragglerWindowMs: 2000 },
+			emit: (items) => emitted.push(items.map((i) => i.label)),
+			timers: clock.api,
+			now: clock.now,
+		});
+
+		batcher.push(item("a"));
+		batcher.push(item("b"));
+		clock.advance(40);
+		batcher.push(item("c"));
+		assert.deepEqual(emitted, []);
+
+		clock.advance(150);
+		assert.deepEqual(emitted, [["a", "b", "c"]]);
+		assert.equal(clock.pendingCount(), 0);
+		batcher.dispose();
+	});
+
+	it("emits at the max-wait cap even when items keep arriving", () => {
+		const clock = createFakeClock();
+		const emitted: string[][] = [];
+		const batcher = createCompletionBatcher<{ label: string }>({
+			config: { enabled: true, debounceMs: 100, maxWaitMs: 300, stragglerDebounceMs: 50, stragglerMaxWaitMs: 150, stragglerWindowMs: 2000 },
+			emit: (items) => emitted.push(items.map((i) => i.label)),
+			timers: clock.api,
+			now: clock.now,
+		});
+
+		batcher.push(item("a"));
+		// Keep resetting the debounce so it never fires on its own, while staying
+		// under the max-wait cap (cumulative 250ms < 300ms).
+		for (let step = 0; step < 5; step++) {
+			batcher.push(item(`late-${step}`));
+			clock.advance(50);
+		}
+		assert.deepEqual(emitted, []);
+
+		// Cross the max-wait cap (300ms from the first arrival).
+		clock.advance(50);
+		assert.deepEqual(emitted, [["a", "late-0", "late-1", "late-2", "late-3", "late-4"]]);
+		batcher.dispose();
+	});
+
+	it("flush emits held items immediately and clears timers", () => {
+		const clock = createFakeClock();
+		const emitted: string[][] = [];
+		const batcher = createCompletionBatcher<{ label: string }>({
+			config: { ...DEFAULT_COMPLETION_BATCH_CONFIG, enabled: true, debounceMs: 150, maxWaitMs: 1000 },
+			emit: (items) => emitted.push(items.map((i) => i.label)),
+			timers: clock.api,
+			now: clock.now,
+		});
+
+		batcher.push(item("a"));
+		batcher.push(item("b"));
+		assert.equal(clock.pendingCount(), 2);
+		batcher.flush();
+		assert.deepEqual(emitted, [["a", "b"]]);
+		assert.equal(clock.pendingCount(), 0);
+
+		// A later timer fire must not re-emit.
+		clock.advance(1000);
+		assert.deepEqual(emitted, [["a", "b"]]);
+		batcher.dispose();
+	});
+
+	it("dispose clears timers without emitting", () => {
+		const clock = createFakeClock();
+		const emitted: string[][] = [];
+		const batcher = createCompletionBatcher<{ label: string }>({
+			config: { ...DEFAULT_COMPLETION_BATCH_CONFIG, enabled: true, debounceMs: 150, maxWaitMs: 1000 },
+			emit: (items) => emitted.push(items.map((i) => i.label)),
+			timers: clock.api,
+			now: clock.now,
+		});
+
+		batcher.push(item("a"));
+		batcher.dispose();
+		assert.deepEqual(emitted, []);
+		assert.equal(clock.pendingCount(), 0);
+		clock.advance(1000);
+		assert.deepEqual(emitted, []);
+	});
+
+	it("creates a shorter straggler group for late siblings", () => {
+		const clock = createFakeClock();
+		const emitted: string[][] = [];
+		const batcher = createCompletionBatcher<{ label: string }>({
+			config: { enabled: true, debounceMs: 200, maxWaitMs: 1000, stragglerDebounceMs: 50, stragglerMaxWaitMs: 150, stragglerWindowMs: 2000 },
+			emit: (items) => emitted.push(items.map((i) => i.label)),
+			timers: clock.api,
+			now: clock.now,
+		});
+
+		// First group emits via debounce.
+		batcher.push(item("a"));
+		clock.advance(200);
+		assert.deepEqual(emitted, [["a"]]);
+
+		// A sibling finishing soon after joins a straggler group with the
+		// shorter debounce window.
+		clock.advance(100);
+		batcher.push(item("b"));
+		assert.deepEqual(emitted, [["a"]]);
+		clock.advance(50);
+		assert.deepEqual(emitted, [["a"], ["b"]]);
+		batcher.dispose();
+	});
+
+	it("starts a fresh normal group after the straggler window passes", () => {
+		const clock = createFakeClock();
+		const emitted: string[][] = [];
+		const batcher = createCompletionBatcher<{ label: string }>({
+			config: { enabled: true, debounceMs: 200, maxWaitMs: 1000, stragglerDebounceMs: 50, stragglerMaxWaitMs: 150, stragglerWindowMs: 500 },
+			emit: (items) => emitted.push(items.map((i) => i.label)),
+			timers: clock.api,
+			now: clock.now,
+		});
+
+		batcher.push(item("a"));
+		clock.advance(200);
+		assert.deepEqual(emitted, [["a"]]);
+
+		// Past the straggler window: the next arrival is a normal group again.
+		clock.advance(600);
+		batcher.push(item("b"));
+		clock.advance(50);
+		assert.deepEqual(emitted, [["a"]]);
+		clock.advance(150);
+		assert.deepEqual(emitted, [["a"], ["b"]]);
+		batcher.dispose();
+	});
+});

package/dist/extensions/pi-subagents/test/unit/completion-dedupe.test.ts

@@ -0,0 +1,36 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { buildCompletionKey, getGlobalSeenMap, markSeenWithTtl } from "../../src/runs/background/completion-dedupe.ts";
+
+describe("buildCompletionKey", () => {
+	it("uses id as canonical key when present", () => {
+		const key = buildCompletionKey({ id: "run-123", agent: "reviewer", timestamp: 123 }, "fallback");
+		assert.equal(key, "id:run-123");
+	});
+
+	it("builds deterministic fallback key when id is missing", () => {
+		const a = buildCompletionKey({ agent: "reviewer", timestamp: 123, taskIndex: 1, totalTasks: 2, success: true }, "x");
+		const b = buildCompletionKey({ agent: "reviewer", timestamp: 123, taskIndex: 1, totalTasks: 2, success: true }, "x");
+		assert.equal(a, b);
+	});
+});
+
+describe("markSeenWithTtl", () => {
+	it("returns true only for duplicates within ttl", () => {
+		const seen = new Map<string, number>();
+		const ttlMs = 1000;
+		assert.equal(markSeenWithTtl(seen, "k", 100, ttlMs), false);
+		assert.equal(markSeenWithTtl(seen, "k", 200, ttlMs), true);
+		assert.equal(markSeenWithTtl(seen, "k", 1201, ttlMs), false);
+	});
+});
+
+describe("getGlobalSeenMap", () => {
+	it("returns the same map for the same global store key", () => {
+		const a = getGlobalSeenMap("__test_seen_key__");
+		a.set("x", 1);
+		const b = getGlobalSeenMap("__test_seen_key__");
+		assert.equal(b.get("x"), 1);
+		assert.equal(a, b);
+	});
+});

package/dist/extensions/pi-subagents/test/unit/completion-guard.test.ts

@@ -0,0 +1,152 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import type { Message } from "@earendil-works/pi-ai";
+
+import {
+	evaluateCompletionMutationGuard,
+	expectsImplementationMutation,
+	hasMutationToolCall,
+} from "../../src/runs/shared/completion-guard.ts";
+
+function assistantToolCall(name: string, args: Record<string, unknown> = {}): Message {
+	return {
+		role: "assistant",
+		content: [{ type: "toolCall", name, arguments: args }],
+	} as unknown as Message;
+}
+
+function assistantText(text: string): Message {
+	return {
+		role: "assistant",
+		content: [{ type: "text", text }],
+	} as unknown as Message;
+}
+
+test("implementation task with no mutation triggers the completion guard", () => {
+	const result = evaluateCompletionMutationGuard({
+		agent: "worker",
+		task: "Implement the approved fix",
+		messages: [assistantText("Plan: update the files...")],
+	});
+
+	assert.deepEqual(result, {
+		expectedMutation: true,
+		attemptedMutation: false,
+		triggered: true,
+	});
+});
+
+test("declared read-only builtin tools suppress implementation-word false positives", () => {
+	const result = evaluateCompletionMutationGuard({
+		agent: "architect",
+		task: "Produce a proposal that implements the approved fix",
+		messages: [assistantText("Proposal only")],
+		tools: ["read", "grep", "find", "ls"],
+	});
+
+	assert.deepEqual(result, {
+		expectedMutation: false,
+		attemptedMutation: false,
+		triggered: false,
+	});
+});
+
+test("omitted, empty, bash, unknown, write, and MCP tool capabilities stay conservative", () => {
+	const base = {
+		agent: "architect",
+		task: "Implement the approved source fix",
+		messages: [assistantText("Validation only")],
+	};
+
+	assert.equal(evaluateCompletionMutationGuard(base).triggered, true);
+	assert.equal(evaluateCompletionMutationGuard({ ...base, tools: [] }).triggered, true);
+	assert.equal(evaluateCompletionMutationGuard({ ...base, tools: ["read", "bash", "ls"] }).triggered, true);
+	assert.equal(evaluateCompletionMutationGuard({ ...base, tools: ["read", "custom_lookup"] }).triggered, true);
+	assert.equal(evaluateCompletionMutationGuard({ ...base, tools: ["read", "write"] }).triggered, true);
+	assert.equal(evaluateCompletionMutationGuard({ ...base, tools: ["read", "grep"], mcpDirectTools: ["github/search"] }).triggered, true);
+});
+
+test("worker with mutating-capable tools still triggers when no mutation is observed", () => {
+	const result = evaluateCompletionMutationGuard({
+		agent: "worker",
+		task: "Fix the test implementation",
+		messages: [assistantText("I will edit it next")],
+		tools: ["read", "edit"],
+	});
+
+	assert.deepEqual(result, {
+		expectedMutation: true,
+		attemptedMutation: false,
+		triggered: true,
+	});
+});
+
+test("review-only, research, and framework output instructions do not expect mutation", () => {
+	assert.equal(expectsImplementationMutation("worker", "Review only: return findings, do not edit"), false);
+	assert.equal(expectsImplementationMutation("worker", "Do not edit files. Tell me how to fix the bug."), false);
+	assert.equal(expectsImplementationMutation("worker", "Review the diff and suggest fixes only. Do not edit files."), false);
+	assert.equal(expectsImplementationMutation("worker", "Implement this. Do not edit files outside this repo. Do not edit files."), false);
+	assert.equal(expectsImplementationMutation("worker", "Investigate why this failed"), false);
+	assert.equal(expectsImplementationMutation("researcher", "Research the API behavior"), false);
+	assert.equal(expectsImplementationMutation("researcher", "Research this and patch the bug"), false);
+	assert.equal(expectsImplementationMutation("reviewer", "Review this and fix any real issues"), false);
+	assert.equal(expectsImplementationMutation("reviewer", "Review this and fix any real issues; regardless of findings, apply changes directly"), true);
+	assert.equal(expectsImplementationMutation("worker", "[Write to: /tmp/result.md]\n\nSummarize findings"), false);
+	assert.equal(expectsImplementationMutation("worker", "Write report"), false);
+	assert.equal(expectsImplementationMutation("worker", "Create a report"), false);
+	assert.equal(expectsImplementationMutation("worker", "Create a summary"), false);
+	assert.equal(expectsImplementationMutation("worker", "Add a report"), false);
+	assert.equal(expectsImplementationMutation("worker", "Update a summary"), false);
+	assert.equal(expectsImplementationMutation("worker", "Write to {chain_dir}"), false);
+	assert.equal(
+		expectsImplementationMutation("worker", "Do async work\nUpdate progress at: /tmp/progress.md\n**Output:**\nWrite your findings to exactly this path: /tmp/out.md\nThis path is authoritative for this run.\nIgnore any other output filename or output path mentioned elsewhere."),
+		false,
+	);
+});
+
+test("worker implementation verbs win over investigative wording", () => {
+	assert.equal(expectsImplementationMutation("worker", "Investigate why the worker did not edit files and fix it"), true);
+	assert.equal(expectsImplementationMutation("worker", "Research the current code path and patch the bug"), true);
+	assert.equal(expectsImplementationMutation("worker", "Fix the bug where no edits were made"), true);
+	assert.equal(expectsImplementationMutation("worker", "Implement the fix and return findings."), true);
+});
+
+test("worker edit intent covers common docs, config, and source tasks", () => {
+	assert.equal(expectsImplementationMutation("worker", "Update README to mention the native tool"), true);
+	assert.equal(expectsImplementationMutation("worker", "Remove share functionality and all Vercel references"), true);
+	assert.equal(expectsImplementationMutation("worker", "Replace the registered command with a render tool"), true);
+	assert.equal(expectsImplementationMutation("worker", "Create completion-guard.ts"), true);
+	assert.equal(expectsImplementationMutation("worker", "Add tests for the completion guard"), true);
+	assert.equal(expectsImplementationMutation("worker", "Implement the approved fixes. Do not edit files outside this repo."), true);
+	assert.equal(expectsImplementationMutation("worker", "Implement the fix. Do not edit unrelated files."), true);
+});
+
+test("edit and write tool calls count as mutation attempts", () => {
+	assert.equal(hasMutationToolCall([assistantToolCall("edit", { path: "a.ts" })]), true);
+	assert.equal(hasMutationToolCall([assistantToolCall("write", { path: "a.ts" })]), true);
+});
+
+test("obvious mutating bash commands count as mutation attempts", () => {
+	assert.equal(hasMutationToolCall([assistantToolCall("bash", { command: "mkdir -p src && cat > src/file.ts <<'EOF'\nhi\nEOF" })]), true);
+	assert.equal(hasMutationToolCall([assistantToolCall("bash", { command: "cat <<'EOF' > src/file.ts\nhi\nEOF" })]), true);
+	assert.equal(hasMutationToolCall([assistantToolCall("bash", { command: "python3 -c \"from pathlib import Path; Path('x').write_text('hi')\"" })]), true);
+	assert.equal(hasMutationToolCall([assistantToolCall("bash", { command: "node script.js > generated.txt" })]), true);
+	assert.equal(hasMutationToolCall([assistantToolCall("bash", { command: "echo 'a > b'" })]), false);
+	assert.equal(hasMutationToolCall([assistantToolCall("bash", { command: "node -e \"console.log(a > b)\"" })]), false);
+	assert.equal(hasMutationToolCall([assistantToolCall("bash", { command: "python3 <<'PY'\nprint('inspect only')\nPY" })]), false);
+	assert.equal(hasMutationToolCall([assistantToolCall("bash", { command: "echo 'rm file'" })]), false);
+	assert.equal(hasMutationToolCall([assistantToolCall("bash", { command: "printf \"mkdir x\"" })]), false);
+	assert.equal(hasMutationToolCall([assistantToolCall("bash", { command: "git apply patch.diff" })]), true);
+	assert.equal(hasMutationToolCall([assistantToolCall("bash", { command: "patch -p0 < fix.patch" })]), true);
+});
+
+test("implementation task with mutation attempts does not trigger", () => {
+	const result = evaluateCompletionMutationGuard({
+		agent: "worker",
+		task: "Fix the failing test",
+		messages: [assistantToolCall("edit", { path: "test.ts" })],
+	});
+
+	assert.equal(result.triggered, false);
+});

package/dist/extensions/pi-subagents/test/unit/config-dir-runtime.test.ts

@@ -0,0 +1,72 @@
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { afterEach, beforeEach, describe, it } from "node:test";
+import { fileURLToPath } from "node:url";
+import { getConfigDirName, PI_CODING_AGENT_PACKAGE_ROOT_ENV, resolveConfigDirName } from "../../src/shared/utils.ts";
+
+const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../..");
+let previousPackageRootEnv: string | undefined;
+
+describe("config directory resolution", () => {
+	beforeEach(() => {
+		previousPackageRootEnv = process.env[PI_CODING_AGENT_PACKAGE_ROOT_ENV];
+		delete process.env[PI_CODING_AGENT_PACKAGE_ROOT_ENV];
+	});
+
+	afterEach(() => {
+		if (previousPackageRootEnv === undefined) delete process.env[PI_CODING_AGENT_PACKAGE_ROOT_ENV];
+		else process.env[PI_CODING_AGENT_PACKAGE_ROOT_ENV] = previousPackageRootEnv;
+	});
+
+	it("falls back without importing the Pi peer package at runtime", () => {
+		assert.equal(resolveConfigDirName(), ".selesai");
+		assert.equal(getConfigDirName(), ".selesai");
+	});
+
+	it("honors an explicitly provided Pi module shape", () => {
+		assert.equal(resolveConfigDirName({ CONFIG_DIR_NAME: ".custom-pi" }), ".custom-pi");
+		assert.equal(resolveConfigDirName({ CONFIG_DIR_NAME: "" }), ".selesai");
+	});
+
+	it("honors Pi package metadata without importing the peer package", () => {
+		const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-config-dir-"));
+		try {
+			const packageRoot = path.join(tempDir, "coding-agent");
+			const distDir = path.join(packageRoot, "dist");
+			fs.mkdirSync(distDir, { recursive: true });
+			const cliPath = path.join(distDir, "cli.js");
+			fs.writeFileSync(cliPath, "", "utf-8");
+			fs.writeFileSync(path.join(packageRoot, "package.json"), JSON.stringify({
+				name: "@selesai/code",
+				piConfig: { configDir: ".custom-pi" },
+			}), "utf-8");
+
+			assert.equal(resolveConfigDirName(undefined, cliPath), ".custom-pi");
+		} finally {
+			fs.rmSync(tempDir, { recursive: true, force: true });
+		}
+	});
+
+	it("uses an explicit Pi package root before the process entrypoint walk", () => {
+		const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-config-root-"));
+		try {
+			const packageRoot = path.join(tempDir, "coding-agent-root");
+			fs.mkdirSync(packageRoot, { recursive: true });
+			fs.writeFileSync(path.join(packageRoot, "package.json"), JSON.stringify({
+				name: "@selesai/code",
+				piConfig: { configDir: ".root-pi" },
+			}), "utf-8");
+
+			assert.equal(resolveConfigDirName(undefined, undefined, packageRoot), ".root-pi");
+		} finally {
+			fs.rmSync(tempDir, { recursive: true, force: true });
+		}
+	});
+
+	it("does not runtime-import the coding agent peer from shared utils", () => {
+		const source = fs.readFileSync(path.join(repoRoot, "src/shared/utils.ts"), "utf-8");
+		assert.doesNotMatch(source, /import\s+[^;]*from\s+["']@earendil-works\/pi-coding-agent["']/);
+	});
+});