pi-mono-all 1.0.0

package/node_modules/pi-mono-team-mode/__tests__/prompts.test.ts

@@ -0,0 +1,106 @@
+// Pi Team-Mode — Prompt addenda + notification XML
+
+import assert from "node:assert/strict";
+import { describe, test } from "node:test";
+
+import {
+	TEAMMATE_SYSTEM_PROMPT_ADDENDUM,
+	formatTaskNotification,
+	getCoordinatorSystemPrompt,
+	isCoordinatorMode,
+} from "../core/prompts.ts";
+
+describe("TEAMMATE_SYSTEM_PROMPT_ADDENDUM", () => {
+	test("instructs teammates to use send_message", () => {
+		assert.match(TEAMMATE_SYSTEM_PROMPT_ADDENDUM, /send_message/);
+		assert.match(TEAMMATE_SYSTEM_PROMPT_ADDENDUM, /team-wide broadcasts/);
+		assert.match(TEAMMATE_SYSTEM_PROMPT_ADDENDUM, /not visible to others/);
+	});
+});
+
+describe("getCoordinatorSystemPrompt", () => {
+	const prompt = getCoordinatorSystemPrompt();
+	test("teaches coordinator role", () => {
+		assert.match(prompt, /coordinator/i);
+		assert.match(prompt, /Your Role/);
+	});
+	test("references coordinator tools", () => {
+		for (const name of [
+			"agent",
+			"delegate",
+			"send_message",
+			"task_stop",
+			"task_create",
+			"task_list",
+		]) {
+			assert.match(prompt, new RegExp(`\\b${name}\\b`), `mentions ${name}`);
+		}
+	});
+	test("describes task-notification wake-up", () => {
+		assert.match(prompt, /<task-notification>/);
+		assert.match(prompt, /end your response/i);
+		assert.match(prompt, /Never fabricate or predict/);
+	});
+	test("avoids TODO overhead for a single task", () => {
+		assert.match(prompt, /single coherent task/i);
+		assert.match(prompt, /do not call task_create\/task_update/i);
+		assert.match(prompt, /Creating exactly one TODO item is overhead/i);
+	});
+});
+
+describe("formatTaskNotification", () => {
+	test("basic completion", () => {
+		const xml = formatTaskNotification({
+			taskId: "agent-researcher-abc",
+			status: "completed",
+			summary: 'Agent "research auth" completed',
+			result: "Found null pointer at validate.ts:42",
+			durationMs: 1234,
+		});
+		assert.match(xml, /<task-notification>/);
+		assert.match(xml, /<task-id>agent-researcher-abc<\/task-id>/);
+		assert.match(xml, /<status>completed<\/status>/);
+		assert.match(xml, /<duration_ms>1234<\/duration_ms>/);
+		assert.match(xml, /<result>Found null pointer at validate.ts:42<\/result>/);
+	});
+
+	test("escapes XML special chars", () => {
+		const xml = formatTaskNotification({
+			taskId: "agent-x",
+			status: "failed",
+			summary: "boom",
+			result: "<script>alert('xss')</script>",
+		});
+		assert.match(xml, /&lt;script&gt;/);
+		assert.doesNotMatch(xml, /<script>/);
+	});
+
+	test("omits optional sections", () => {
+		const xml = formatTaskNotification({
+			taskId: "agent-x",
+			status: "killed",
+			summary: "stopped by user",
+		});
+		assert.doesNotMatch(xml, /<result>/);
+		assert.doesNotMatch(xml, /<usage>/);
+	});
+});
+
+describe("isCoordinatorMode", () => {
+	test("reads PI_TEAM_MATE_COORDINATOR", () => {
+		const prev = process.env.PI_TEAM_MATE_COORDINATOR;
+		try {
+			process.env.PI_TEAM_MATE_COORDINATOR = "1";
+			assert.equal(isCoordinatorMode(), true);
+			process.env.PI_TEAM_MATE_COORDINATOR = "true";
+			assert.equal(isCoordinatorMode(), true);
+			process.env.PI_TEAM_MATE_COORDINATOR = "";
+			assert.equal(isCoordinatorMode(), false);
+			delete process.env.PI_TEAM_MATE_COORDINATOR;
+			assert.equal(isCoordinatorMode(), false);
+		} finally {
+			if (prev === undefined) delete process.env.PI_TEAM_MATE_COORDINATOR;
+			else process.env.PI_TEAM_MATE_COORDINATOR = prev;
+		}
+	});
+});

package/node_modules/pi-mono-team-mode/__tests__/store.test.ts

@@ -0,0 +1,164 @@
+/**
+ * Pi Team-Mode — Store Tests
+ */
+
+import assert from "node:assert/strict";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { describe, test } from "node:test";
+
+import {
+	TeamMateStore,
+	generateTeamId,
+	generateTeammateId,
+} from "../core/store.ts";
+import type { TeamRecord, TeammateRecord } from "../core/types.ts";
+
+async function setup(): Promise<{ store: TeamMateStore; dir: string }> {
+	const dir = await mkdtemp(join(tmpdir(), "pi-team-mode-"));
+	return { store: new TeamMateStore(dir), dir };
+}
+
+function makeTeammate(overrides: Partial<TeammateRecord> = {}): TeammateRecord {
+	const now = new Date().toISOString();
+	return {
+		id: "agent-researcher-abc12345",
+		name: "researcher",
+		isolation: "none",
+		cwd: "/tmp/fake",
+		status: "running",
+		background: false,
+		createdAt: now,
+		updatedAt: now,
+		...overrides,
+	};
+}
+
+function makeTeam(overrides: Partial<TeamRecord> = {}): TeamRecord {
+	return {
+		id: "billing-abc12345",
+		name: "billing",
+		createdAt: new Date().toISOString(),
+		defaultIsolation: "none",
+		...overrides,
+	};
+}
+
+describe("generateTeammateId", () => {
+	test("slugifies name under agent- prefix (Claude Code parity)", () => {
+		const id = generateTeammateId("Some Teammate!");
+		assert.match(id, /^agent-some-teammate-[0-9a-f]{8}$/);
+	});
+
+	test("falls back to agent-teammate when name is empty", () => {
+		const id = generateTeammateId("");
+		assert.match(id, /^agent-teammate-[0-9a-f]{8}$/);
+	});
+
+	test("falls back to agent-teammate when name is undefined", () => {
+		const id = generateTeammateId(undefined);
+		assert.match(id, /^agent-teammate-[0-9a-f]{8}$/);
+	});
+});
+
+describe("generateTeamId", () => {
+	test("slugifies and appends random suffix", () => {
+		const id = generateTeamId("Billing Team");
+		assert.match(id, /^billing-team-[0-9a-f]{8}$/);
+	});
+});
+
+describe("TeamMateStore.saveTeammate / loadTeammate", () => {
+	test("round-trips a teammate record", async () => {
+		const { store, dir } = await setup();
+		try {
+			const record = makeTeammate();
+			await store.saveTeammate(record);
+			const loaded = await store.loadTeammate(record.id);
+			assert.deepEqual(loaded, record);
+		} finally {
+			await rm(dir, { recursive: true, force: true });
+		}
+	});
+
+	test("loadTeammate returns null for missing id", async () => {
+		const { store, dir } = await setup();
+		try {
+			assert.equal(await store.loadTeammate("does-not-exist"), null);
+		} finally {
+			await rm(dir, { recursive: true, force: true });
+		}
+	});
+});
+
+describe("TeamMateStore.listTeammates", () => {
+	test("lists all saved teammates", async () => {
+		const { store, dir } = await setup();
+		try {
+			await store.saveTeammate(makeTeammate({ id: "agent-a-abc", name: "a" }));
+			await store.saveTeammate(makeTeammate({ id: "agent-b-abc", name: "b" }));
+			const list = await store.listTeammates();
+			const names = list.map((t) => t.name).sort();
+			assert.deepEqual(names, ["a", "b"]);
+		} finally {
+			await rm(dir, { recursive: true, force: true });
+		}
+	});
+
+	test("returns empty array when none exist", async () => {
+		const { store, dir } = await setup();
+		try {
+			assert.deepEqual(await store.listTeammates(), []);
+		} finally {
+			await rm(dir, { recursive: true, force: true });
+		}
+	});
+});
+
+describe("TeamMateStore team records", () => {
+	test("round-trips a team record", async () => {
+		const { store, dir } = await setup();
+		try {
+			const team = makeTeam();
+			await store.saveTeam(team);
+			const loaded = await store.loadTeam(team.id);
+			assert.deepEqual(loaded, team);
+		} finally {
+			await rm(dir, { recursive: true, force: true });
+		}
+	});
+});
+
+describe("TeamMateStore name index", () => {
+	test("round-trips the name index", async () => {
+		const { store, dir } = await setup();
+		try {
+			await store.setNameIndex("session-1", { researcher: "researcher-abc" });
+			const loaded = await store.getNameIndex("session-1");
+			assert.deepEqual(loaded, { researcher: "researcher-abc" });
+		} finally {
+			await rm(dir, { recursive: true, force: true });
+		}
+	});
+
+	test("returns empty object when index is missing", async () => {
+		const { store, dir } = await setup();
+		try {
+			assert.deepEqual(await store.getNameIndex("never-created"), {});
+		} finally {
+			await rm(dir, { recursive: true, force: true });
+		}
+	});
+
+	test("clearNameIndex removes the index", async () => {
+		const { store, dir } = await setup();
+		try {
+			await store.setNameIndex("s", { a: "x" });
+			await store.clearNameIndex("s");
+			assert.deepEqual(await store.getNameIndex("s"), {});
+		} finally {
+			await rm(dir, { recursive: true, force: true });
+		}
+	});
+});

package/node_modules/pi-mono-team-mode/__tests__/tasks.test.ts

@@ -0,0 +1,267 @@
+// Pi Team-Mode — Task Board Tests
+
+import assert from "node:assert/strict";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { describe, test } from "node:test";
+
+import { TaskStore, isUnblocked, type TaskRecord } from "../core/tasks.ts";
+import { TaskManager, VersionConflictError } from "../managers/task-manager.ts";
+
+function setup(): Promise<{ store: TaskStore; manager: TaskManager; dir: string; sessionId: string }> {
+	return mkdtemp(join(tmpdir(), "team-mode-tasks-")).then((dir) => {
+		const store = new TaskStore(dir);
+		const sessionId = "session-test";
+		const manager = new TaskManager({ store, getParentSessionId: () => sessionId });
+		return { store, manager, dir, sessionId };
+	});
+}
+
+async function cleanup(dir: string): Promise<void> {
+	await rm(dir, { recursive: true, force: true });
+}
+
+describe("TaskStore round-trip", () => {
+	test("save + load + list + delete", async () => {
+		const { store, dir, sessionId } = await setup();
+		try {
+			const now = new Date().toISOString();
+			const record: TaskRecord = {
+				id: "task-first-abcd1234",
+				subject: "first",
+				status: "pending",
+				owner: null,
+				blockedBy: [],
+				blocks: [],
+				parentSessionId: sessionId,
+				createdAt: now,
+				updatedAt: now,
+				version: 1,
+			};
+			await store.save(record);
+			assert.deepEqual(await store.load(sessionId, "task-first-abcd1234"), record);
+			assert.equal((await store.list(sessionId)).length, 1);
+			await store.delete(sessionId, "task-first-abcd1234");
+			assert.equal((await store.list(sessionId)).length, 0);
+		} finally {
+			await cleanup(dir);
+		}
+	});
+
+	test("list returns [] on missing dir", async () => {
+		const { store, dir } = await setup();
+		try {
+			assert.deepEqual(await store.list("never-created"), []);
+		} finally {
+			await cleanup(dir);
+		}
+	});
+});
+
+describe("isUnblocked", () => {
+	const makeTask = (o: Partial<TaskRecord>): TaskRecord => ({
+		id: o.id ?? "t",
+		subject: o.subject ?? "t",
+		status: o.status ?? "pending",
+		owner: o.owner ?? null,
+		blockedBy: o.blockedBy ?? [],
+		blocks: o.blocks ?? [],
+		parentSessionId: "s",
+		createdAt: "2026-01-01T00:00:00Z",
+		updatedAt: "2026-01-01T00:00:00Z",
+		version: 1,
+	});
+
+	test("unblocked when all deps completed", () => {
+		const task = makeTask({ id: "t", blockedBy: ["a"] });
+		const byId = new Map([
+			[task.id, task],
+			["a", makeTask({ id: "a", status: "completed" })],
+		]);
+		assert.equal(isUnblocked(task, byId), true);
+	});
+
+	test("blocked when any dep pending", () => {
+		const task = makeTask({ id: "t", blockedBy: ["a"] });
+		const byId = new Map([
+			[task.id, task],
+			["a", makeTask({ id: "a", status: "pending" })],
+		]);
+		assert.equal(isUnblocked(task, byId), false);
+	});
+
+	test("deleted deps treated as resolved", () => {
+		const task = makeTask({ id: "t", blockedBy: ["a"] });
+		const byId = new Map([
+			[task.id, task],
+			["a", makeTask({ id: "a", status: "deleted" })],
+		]);
+		assert.equal(isUnblocked(task, byId), true);
+	});
+});
+
+describe("TaskManager.create", () => {
+	test("creates pending + unassigned per Claude Code shape", async () => {
+		const { manager, dir } = await setup();
+		try {
+			const t = await manager.create({ subject: "a", description: "do a" });
+			assert.equal(t.status, "pending");
+			assert.equal(t.owner, null);
+			assert.deepEqual(t.blockedBy, []);
+			assert.deepEqual(t.blocks, []);
+			assert.equal(t.version, 1);
+			assert.match(t.id, /^task-a-[0-9a-f]{8}$/);
+		} finally {
+			await cleanup(dir);
+		}
+	});
+
+	test("captures activeForm and metadata", async () => {
+		const { manager, dir } = await setup();
+		try {
+			const t = await manager.create({
+				subject: "run tests",
+				description: "run the suite",
+				activeForm: "Running tests",
+				metadata: { priority: "high" },
+			});
+			assert.equal(t.activeForm, "Running tests");
+			assert.deepEqual(t.metadata, { priority: "high" });
+		} finally {
+			await cleanup(dir);
+		}
+	});
+});
+
+describe("TaskManager.update — assignment + deps + CAS", () => {
+	test("coordinator assigns owner via task_update", async () => {
+		const { manager, dir } = await setup();
+		try {
+			const t = await manager.create({ subject: "a" });
+			const assigned = await manager.update(t.id, { owner: "alice", status: "in_progress" });
+			assert.equal(assigned.owner, "alice");
+			assert.equal(assigned.status, "in_progress");
+		} finally {
+			await cleanup(dir);
+		}
+	});
+
+	test("addBlockedBy / addBlocks merges with existing arrays", async () => {
+		const { manager, dir } = await setup();
+		try {
+			const a = await manager.create({ subject: "a" });
+			const b = await manager.create({ subject: "b" });
+			const c = await manager.create({ subject: "c" });
+			const updated = await manager.update(c.id, { addBlockedBy: [a.id, b.id] });
+			assert.deepEqual(updated.blockedBy.sort(), [a.id, b.id].sort());
+		} finally {
+			await cleanup(dir);
+		}
+	});
+
+	test("CAS guard rejects stale version", async () => {
+		const { manager, dir } = await setup();
+		try {
+			const t = await manager.create({ subject: "a" });
+			await manager.update(t.id, { status: "in_progress" });
+			await assert.rejects(
+				() => manager.update(t.id, { expectedVersion: t.version, owner: "alice" }),
+				VersionConflictError,
+			);
+		} finally {
+			await cleanup(dir);
+		}
+	});
+
+	test("CAS guard accepts fresh version", async () => {
+		const { manager, dir } = await setup();
+		try {
+			const t = await manager.create({ subject: "a" });
+			const updated = await manager.update(t.id, {
+				expectedVersion: t.version,
+				owner: "alice",
+			});
+			assert.equal(updated.version, t.version + 1);
+		} finally {
+			await cleanup(dir);
+		}
+	});
+});
+
+describe("TaskManager — TaskCompleted hook", () => {
+	test("hook success keeps task completed", async () => {
+		const dir = await mkdtemp(join(tmpdir(), "team-mode-tasks-"));
+		try {
+			const store = new TaskStore(dir);
+			const manager = new TaskManager({
+				store,
+				getParentSessionId: () => "s",
+				getTaskCompletedHook: () => "exit 0",
+			});
+			const t = await manager.create({ subject: "a" });
+			const done = await manager.update(t.id, { status: "completed" });
+			assert.equal(done.status, "completed");
+		} finally {
+			await cleanup(dir);
+		}
+	});
+
+	test("hook failure reverts to failed with output", async () => {
+		const dir = await mkdtemp(join(tmpdir(), "team-mode-tasks-"));
+		try {
+			const store = new TaskStore(dir);
+			const manager = new TaskManager({
+				store,
+				getParentSessionId: () => "s",
+				getTaskCompletedHook: () => "echo 'test broke' >&2; exit 7",
+			});
+			const t = await manager.create({ subject: "a" });
+			const done = await manager.update(t.id, { status: "completed" });
+			assert.equal(done.status, "failed");
+			assert.match(done.result ?? "", /hook failed, exit 7/);
+			assert.match(done.hookOutput ?? "", /test broke/);
+		} finally {
+			await cleanup(dir);
+		}
+	});
+
+	test("hook only runs on transition INTO completed", async () => {
+		const dir = await mkdtemp(join(tmpdir(), "team-mode-tasks-"));
+		try {
+			const store = new TaskStore(dir);
+			let hookCalls = 0;
+			const manager = new TaskManager({
+				store,
+				getParentSessionId: () => "s",
+				getTaskCompletedHook: () => {
+					hookCalls++;
+					return "exit 0";
+				},
+			});
+			const t = await manager.create({ subject: "a" });
+			await manager.update(t.id, { status: "in_progress" });
+			await manager.update(t.id, { status: "failed" });
+			assert.equal(hookCalls, 0);
+		} finally {
+			await cleanup(dir);
+		}
+	});
+});
+
+describe("TaskManager.list filters", () => {
+	test("status + owner + teamId", async () => {
+		const { manager, dir } = await setup();
+		try {
+			const a = await manager.create({ subject: "a", teamId: "billing" });
+			await manager.create({ subject: "b", teamId: "billing" });
+			await manager.create({ subject: "c" });
+			await manager.update(a.id, { owner: "alice", status: "in_progress" });
+			assert.equal((await manager.list({ owner: "alice" })).length, 1);
+			assert.equal((await manager.list({ status: "in_progress" })).length, 1);
+			assert.equal((await manager.list({ teamId: "billing" })).length, 2);
+		} finally {
+			await cleanup(dir);
+		}
+	});
+});

package/node_modules/pi-mono-team-mode/__tests__/teammate-specs.test.ts

@@ -0,0 +1,114 @@
+/**
+ * Pi Team-Mode — Teammate Spec Loader Tests
+ */
+
+import assert from "node:assert/strict";
+import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { describe, test } from "node:test";
+
+import { listTeammateSpecs, loadTeammateSpec, parseSpec } from "../core/teammate-specs.ts";
+
+describe("parseSpec", () => {
+	test("parses frontmatter and body", () => {
+		const raw = `---
+name: researcher
+description: investigates the codebase
+needsWorktree: false
+hasMemory: true
+modelTier: sonnet:high
+thinkingLevel: high
+tools: read, bash, grep
+---
+You are a researcher.`;
+		const spec = parseSpec(raw, "researcher", "/tmp/x.md");
+		assert.equal(spec.name, "researcher");
+		assert.equal(spec.description, "investigates the codebase");
+		assert.equal(spec.needsWorktree, false);
+		assert.equal(spec.hasMemory, true);
+		assert.equal(spec.modelTier, "sonnet:high");
+		assert.equal(spec.thinkingLevel, "high");
+		assert.deepEqual(spec.tools, ["read", "bash", "grep"]);
+		assert.equal(spec.systemPrompt, "You are a researcher.");
+	});
+
+	test("falls back to role name when frontmatter is missing", () => {
+		const spec = parseSpec("You are a tester.", "tester", "/tmp/x.md");
+		assert.equal(spec.name, "tester");
+		assert.equal(spec.systemPrompt, "You are a tester.");
+		assert.equal(spec.description, undefined);
+		assert.equal(spec.tools, undefined);
+	});
+
+	test("handles single-quoted values", () => {
+		const spec = parseSpec(
+			`---\nname: 'quoted'\n---\nbody`,
+			"fallback",
+			"/tmp/x.md",
+		);
+		assert.equal(spec.name, "quoted");
+	});
+});
+
+describe("loadTeammateSpec", () => {
+	test("reads .pi/teammates/<role>.md first", async () => {
+		const dir = await mkdtemp(join(tmpdir(), "team-mode-specs-"));
+		try {
+			await mkdir(join(dir, ".pi", "teammates"), { recursive: true });
+			await writeFile(
+				join(dir, ".pi", "teammates", "researcher.md"),
+				"---\nname: researcher\n---\nsystem",
+				"utf8",
+			);
+			const spec = await loadTeammateSpec(dir, "researcher");
+			assert.ok(spec);
+			assert.equal(spec.name, "researcher");
+			assert.equal(spec.systemPrompt, "system");
+		} finally {
+			await rm(dir, { recursive: true, force: true });
+		}
+	});
+
+	test("falls back to .claude/teammates/<role>.md", async () => {
+		const dir = await mkdtemp(join(tmpdir(), "team-mode-specs-"));
+		try {
+			await mkdir(join(dir, ".claude", "teammates"), { recursive: true });
+			await writeFile(join(dir, ".claude", "teammates", "tester.md"), "body", "utf8");
+			const spec = await loadTeammateSpec(dir, "tester");
+			assert.ok(spec);
+			assert.equal(spec.systemPrompt, "body");
+		} finally {
+			await rm(dir, { recursive: true, force: true });
+		}
+	});
+
+	test("returns null when no spec exists", async () => {
+		const dir = await mkdtemp(join(tmpdir(), "team-mode-specs-"));
+		try {
+			assert.equal(await loadTeammateSpec(dir, "missing"), null);
+		} finally {
+			await rm(dir, { recursive: true, force: true });
+		}
+	});
+});
+
+describe("listTeammateSpecs", () => {
+	test("de-duplicates specs that exist in both locations", async () => {
+		const dir = await mkdtemp(join(tmpdir(), "team-mode-specs-"));
+		try {
+			await mkdir(join(dir, ".pi", "teammates"), { recursive: true });
+			await mkdir(join(dir, ".claude", "teammates"), { recursive: true });
+			await writeFile(join(dir, ".pi", "teammates", "a.md"), "body a pi", "utf8");
+			await writeFile(join(dir, ".claude", "teammates", "a.md"), "body a claude", "utf8");
+			await writeFile(join(dir, ".claude", "teammates", "b.md"), "body b", "utf8");
+			const specs = await listTeammateSpecs(dir);
+			const names = specs.map((s) => s.name).sort();
+			assert.deepEqual(names, ["a", "b"]);
+			const a = specs.find((s) => s.name === "a")!;
+			assert.equal(a.systemPrompt, "body a pi", ".pi takes precedence over .claude");
+		} finally {
+			await rm(dir, { recursive: true, force: true });
+		}
+	});
+});

package/node_modules/pi-mono-team-mode/__tests__/widget.test.ts

@@ -0,0 +1,41 @@
+import assert from "node:assert/strict";
+import { describe, test } from "node:test";
+
+import { renderTeamMateWidget } from "../ui/widget.ts";
+
+describe("renderTeamMateWidget", () => {
+	test("renders running rows + queued", () => {
+		const now = Date.now();
+		const lines = renderTeamMateWidget(
+			[
+				{
+					record: {
+						id: "a",
+						name: "worker",
+						isolation: "none",
+						cwd: "/tmp",
+						status: "running",
+						background: false,
+						createdAt: new Date(now).toISOString(),
+						updatedAt: new Date(now).toISOString(),
+					},
+					metrics: {
+						turns: 1,
+						toolUses: 2,
+						tokens: 1234,
+						startedAt: now - 1200,
+						activityHint: "editing files…",
+					},
+					transcriptPath: "/tmp/s.jsonl",
+				},
+			],
+			[],
+			2,
+			now,
+			0,
+		);
+		assert.equal(lines[0], "● Agents");
+		assert.match(lines.join("\n"), /worker/);
+		assert.match(lines.join("\n"), /2 queued/);
+	});
+});