pi-roundtable 0.1.0 → 0.2.0

package/src/core/runtime/extensions/self-compact-guard.test.ts

@@ -1,50 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import {
-	COMPACT_TOOL,
-	selfCompactGuardExtension,
-} from "./self-compact-guard.ts";
-
-type Handler = (event: {
-	toolName: string;
-	input: unknown;
-}) => { block: true; reason: string } | undefined;
-
-function handler(): Handler {
-	let registered: Handler | undefined;
-	selfCompactGuardExtension()({
-		on: (event: string, h: Handler) => {
-			if (event === "tool_call") registered = h;
-		},
-	} as unknown as ExtensionAPI);
-	if (!registered) throw new Error("no tool_call handler");
-	return registered;
-}
-
-describe("selfCompactGuardExtension", () => {
-	test("refuses compact_session with resume, with the reason", () => {
-		const result = handler()({
-			toolName: COMPACT_TOOL,
-			input: { resume: "continue the report" },
-		});
-		expect(result?.block).toBe(true);
-		expect(result?.reason).toContain("without resume");
-	});
-
-	test("lets compact_session without resume, or with a blank one, run", () => {
-		const h = handler();
-		expect(h({ toolName: COMPACT_TOOL, input: {} })).toBeUndefined();
-		expect(
-			h({ toolName: COMPACT_TOOL, input: { instructions: "keep paths" } }),
-		).toBeUndefined();
-		expect(
-			h({ toolName: COMPACT_TOOL, input: { resume: "  " } }),
-		).toBeUndefined();
-	});
-
-	test("ignores other tools", () => {
-		expect(
-			handler()({ toolName: "bash", input: { resume: "x" } }),
-		).toBeUndefined();
-	});
-});

package/src/core/runtime/pending-confirmation-store.test.ts

@@ -1,52 +0,0 @@
-import { afterAll, beforeAll, expect, test } from "bun:test";
-import { SQL } from "bun";
-import type { PendingConfirmation } from "../domain/conversation.ts";
-import {
-	describeDb,
-	openTestStore,
-	type TestStore,
-	testDatabaseUrl,
-} from "../testing/database.ts";
-import { PendingConfirmationStore } from "./pending-confirmation-store.ts";
-
-const held: PendingConfirmation = {
-	profile: "workspace",
-	heldAt: new Date("2026-09-27T01:00:00Z"),
-	calls: [
-		{
-			tool: "google-send-gmail-message",
-			input: '{"subject":"hi","to":"a@b.c"}',
-			action: "send an email to a@b.c",
-		},
-	],
-};
-
-// Runs against a real PostgreSQL, only when ROUNDTABLE_TEST_DATABASE_URL is set.
-describeDb("PendingConfirmationStore", () => {
-	let store: TestStore<PendingConfirmationStore>;
-
-	beforeAll(async () => {
-		const admin = new SQL(testDatabaseUrl);
-		await admin`DROP TABLE IF EXISTS pending_confirmations`;
-		await admin.close();
-		store = await openTestStore(PendingConfirmationStore);
-	});
-
-	afterAll(async () => {
-		await store.close();
-	});
-
-	test("held actions survive a restart, are replaced, and are cleared", async () => {
-		expect(await store.load("discord:1")).toBeUndefined();
-		await store.save("discord:1", held);
-		expect(await store.load("discord:1")).toEqual(held);
-
-		const other = { ...held, calls: [] };
-		await store.save("discord:1", other);
-		expect(await store.load("discord:1")).toEqual(other);
-		expect(await store.load("discord:2")).toBeUndefined();
-
-		await store.save("discord:1", undefined);
-		expect(await store.load("discord:1")).toBeUndefined();
-	});
-});

package/src/core/runtime/session-archive.test.ts

@@ -1,20 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { mkdtempSync, readdirSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { archiveSessions } from "./session-archive.ts";
-
-describe("archiveSessions", () => {
-	test("moves the conversations out of the top level, keeping them", () => {
-		const dir = mkdtempSync(join(tmpdir(), "roundtable-archive-"));
-		writeFileSync(join(dir, "a.jsonl"), "{}\n");
-		writeFileSync(join(dir, "notes.txt"), "stay");
-		expect(archiveSessions(dir, new Date("2026-09-27T01:02:03Z"))).toBe(1);
-		expect(readdirSync(dir).sort()).toEqual(["archive", "notes.txt"]);
-		expect(
-			readdirSync(join(dir, "archive", "2026-09-27T01-02-03.000Z")),
-		).toEqual(["a.jsonl"]);
-		expect(archiveSessions(dir)).toBe(0);
-		expect(archiveSessions(join(dir, "missing"))).toBe(0);
-	});
-});

package/src/core/runtime/steerable-run.test.ts

@@ -1,264 +0,0 @@
-import { beforeEach, describe, expect, test } from "bun:test";
-import { mkdtempSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import {
-	type AssistantMessage,
-	createFauxCore,
-	type FauxResponseStep,
-	fauxAssistantMessage,
-	type TranscriptContext,
-} from "@earendil-works/pi-ai";
-import {
-	type AgentSession,
-	createAgentSession,
-	DefaultResourceLoader,
-	ModelRuntime,
-	SessionManager,
-	SettingsManager,
-} from "@earendil-works/pi-coding-agent";
-import { SteerableRun, type SteeringSession } from "./steerable-run.ts";
-
-/** A real Pi session on the faux provider, whose scripted answers may wait on the test. */
-async function fauxSession(steps: FauxResponseStep[]) {
-	const dir = mkdtempSync(join(tmpdir(), "roundtable-steer-"));
-	const core = createFauxCore({ provider: "faux", models: [{ id: "faux-1" }] });
-	core.setResponses(steps);
-	const modelRuntime = await ModelRuntime.create({
-		authPath: join(dir, "auth.json"),
-		modelsPath: null,
-		allowModelNetwork: false,
-		refreshOnCreate: false,
-	});
-	modelRuntime.registerProvider("faux", {
-		api: core.api,
-		apiKey: "test",
-		baseUrl: "http://faux.invalid",
-		streamSimple: core.streamSimple,
-		models: [
-			{
-				id: "faux-1",
-				name: "Faux",
-				reasoning: false,
-				input: ["text", "image"],
-				cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
-				contextWindow: 100_000,
-				maxTokens: 1_000,
-			},
-		],
-	});
-	const model = modelRuntime.getModel("faux", "faux-1");
-	if (!model) throw new Error("faux model not registered");
-	const resourceLoader = new DefaultResourceLoader({
-		cwd: dir,
-		agentDir: dir,
-		noExtensions: true,
-		noSkills: true,
-		noPromptTemplates: true,
-		noThemes: true,
-		noContextFiles: true,
-	});
-	await resourceLoader.reload();
-	const { session } = await createAgentSession({
-		cwd: dir,
-		agentDir: dir,
-		modelRuntime,
-		model,
-		resourceLoader,
-		sessionManager: SessionManager.inMemory(),
-		settingsManager: SettingsManager.inMemory({}),
-		noTools: "all",
-	});
-	return { session, core };
-}
-
-/** A promise the test resolves by hand. */
-function gate() {
-	let open = () => {};
-	const opened = new Promise<void>((resolve) => {
-		open = resolve;
-	});
-	return { opened, open };
-}
-
-const userTexts = (context: TranscriptContext) =>
-	context.messages
-		.filter((m) => m.role === "user")
-		.map((m) =>
-			typeof m.content === "string"
-				? m.content
-				: m.content.map((c) => (c.type === "text" ? c.text : "")).join(""),
-		);
-
-const answers = (session: AgentSession) =>
-	session.messages
-		.filter((m): m is AssistantMessage => m.role === "assistant")
-		.map((m) =>
-			m.content.map((c) => (c.type === "text" ? c.text : "")).join(""),
-		);
-
-describe("SteerableRun on a Pi session", () => {
-	let seen: string[][];
-	beforeEach(() => {
-		seen = [];
-	});
-
-	test("a steer during the run is answered in the same turn", async () => {
-		const thinking = gate();
-		const started = gate();
-		const { session } = await fauxSession([
-			async (context) => {
-				seen.push(userTexts(context));
-				started.open();
-				await thinking.opened;
-				return fauxAssistantMessage("first answer");
-			},
-			(context) => {
-				seen.push(userTexts(context));
-				return fauxAssistantMessage("answer after the addition");
-			},
-		]);
-		const run = new SteerableRun(session, () => true);
-		const done = run.run(() => session.prompt("look this up for me"));
-		await started.opened;
-		expect(await run.steer("also check journald", [])).toBe(true);
-		thinking.open();
-		await done;
-		expect(run.steered).toBe(true);
-		expect(seen[1]).toEqual(["look this up for me", "also check journald"]);
-		expect(answers(session)).toEqual([
-			"first answer",
-			"answer after the addition",
-		]);
-	});
-
-	test("a steer at agent_end is answered in the same turn by Pi itself", async () => {
-		const { session } = await fauxSession([
-			fauxAssistantMessage("first answer"),
-			(context) => {
-				seen.push(userTexts(context));
-				return fauxAssistantMessage("answer after the addition");
-			},
-		]);
-		const run = new SteerableRun(session, () => true);
-		let late: Promise<boolean> | undefined;
-		// agent_end fires after Pi's last look at its steering queue.
-		session.subscribe((event) => {
-			if (event.type === "agent_end" && !late)
-				late = run.steer("a late addition", []);
-		});
-		await run.run(() => session.prompt("look this up for me"));
-		expect(await late).toBe(true);
-		expect(seen.at(-1)).toContain("a late addition");
-		expect(session.getSteeringMessages()).toEqual([]);
-	});
-
-	test("stop aborts the run and drops its steers", async () => {
-		const started = gate();
-		const { session, core } = await fauxSession([
-			(_context, options) => {
-				started.open();
-				return new Promise<AssistantMessage>((resolve) =>
-					options?.signal?.addEventListener("abort", () =>
-						resolve(fauxAssistantMessage("", { stopReason: "aborted" })),
-					),
-				);
-			},
-			fauxAssistantMessage("must not appear"),
-		]);
-		const run = new SteerableRun(session, () => true);
-		const done = run.run(() => session.prompt("a long-running job"));
-		await started.opened;
-		expect(await run.steer("this line is dropped", [])).toBe(true);
-		expect(run.stop()).toBe(true);
-		await done;
-		expect(run.stopped).toBe(true);
-		expect(core.state.callCount).toBe(1);
-		expect(session.getSteeringMessages()).toEqual([]);
-		expect(run.stop()).toBe(false);
-	});
-
-	test("a turn that may not be steered, or has ended, takes nothing", async () => {
-		const started = gate();
-		const finish = gate();
-		const { session } = await fauxSession([
-			async () => {
-				started.open();
-				await finish.opened;
-				return fauxAssistantMessage("done");
-			},
-		]);
-		const run = new SteerableRun(session, () => false);
-		const done = run.run(() => session.prompt("a scheduled job"));
-		await started.opened;
-		expect(await run.steer("cannot be inserted", [])).toBe(false);
-		finish.open();
-		await done;
-		expect(await run.steer("too late", [])).toBe(false);
-		expect(session.getSteeringMessages()).toEqual([]);
-	});
-});
-
-/**
- * The window Pi leaves open: its input handling ends after the session settled, so the steer
- * sits in the queue with no run to take it.
- */
-class SettledSession {
-	isStreaming = true;
-	queue: string[] = [];
-	prompts: string[] = [];
-	async steer(text: string) {
-		this.queue.push(text);
-	}
-	getSteeringMessages() {
-		return this.queue;
-	}
-	clearQueue() {
-		const steering = this.queue;
-		this.queue = [];
-		return { steering, followUp: [] };
-	}
-	async abort() {}
-	async waitForIdle() {}
-	async prompt(text: string) {
-		this.prompts.push(text);
-	}
-}
-
-describe("SteerableRun leftovers", () => {
-	test("a steer Pi left queued as the run ended is prompted in the same turn", async () => {
-		const session = new SettledSession();
-		const run = new SteerableRun(
-			session as unknown as SteeringSession,
-			() => true,
-		);
-		await run.run(async () => {
-			expect(await run.steer("a late addition", [])).toBe(true);
-			session.isStreaming = false;
-		});
-		expect(session.prompts).toEqual(["a late addition"]);
-		expect(session.queue).toEqual([]);
-	});
-
-	test("a steer queued after the turn ended is taken back", async () => {
-		const session = new SettledSession();
-		const run = new SteerableRun(
-			session as unknown as SteeringSession,
-			() => true,
-		);
-		const settled = gate();
-		let late: Promise<boolean> | undefined;
-		session.steer = async (text: string) => {
-			// Pi's input handling finishes only after the turn is over.
-			await settled.opened;
-			session.queue.push(text);
-		};
-		await run.run(async () => {
-			late = run.steer("a late addition", []);
-		});
-		settled.open();
-		expect(await late).toBe(false);
-		expect(session.queue).toEqual([]);
-		expect(session.prompts).toEqual([]);
-	});
-});

package/src/core/runtime/text-tools.test.ts

@@ -1,110 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { Type } from "typebox";
-import { AgentError, ScheduleError } from "../domain/errors.ts";
-import {
-	optionalString,
-	requiredString,
-	stringList,
-	type TextToolDef,
-	textToolsExtension,
-} from "./text-tools.ts";
-
-interface Registered {
-	name: string;
-	label: string;
-	execute: (
-		id: string,
-		params: unknown,
-		signal: AbortSignal | undefined,
-	) => Promise<{
-		isError?: boolean;
-		content: { type: string; text: string }[];
-		details?: unknown;
-	}>;
-}
-
-async function registered(defs: TextToolDef[]): Promise<Registered[]> {
-	const tools: Registered[] = [];
-	await textToolsExtension(
-		defs,
-		AgentError,
-	)({
-		registerTool: (tool: Registered) => {
-			tools.push(tool);
-		},
-	} as unknown as ExtensionAPI);
-	return tools;
-}
-
-const def = (run: TextToolDef["run"]): TextToolDef => ({
-	name: "echo",
-	label: "Echo",
-	description: "Echo.",
-	parameters: Type.Object({}),
-	run,
-});
-
-describe("textToolsExtension", () => {
-	test("registers each tool and returns its text", async () => {
-		const [tool] = await registered([def((i) => `got ${String(i.word)}`)]);
-		expect(tool?.name).toBe("echo");
-		expect(tool?.label).toBe("Echo");
-		const result = await tool?.execute("1", { word: "hi" }, undefined);
-		expect(result).toEqual({
-			content: [{ type: "text", text: "got hi" }],
-			details: {},
-		});
-	});
-
-	test("passes the call's signal to the tool", async () => {
-		const signal = new AbortController().signal;
-		let seen: AbortSignal | undefined;
-		const [tool] = await registered([
-			def((_i, s) => {
-				seen = s;
-				return "ok";
-			}),
-		]);
-		await tool?.execute("1", {}, signal);
-		expect(seen).toBe(signal);
-	});
-
-	test("turns the refusal class into an error result", async () => {
-		const [tool] = await registered([
-			def(() => {
-				throw new AgentError("no such agent");
-			}),
-		]);
-		const result = await tool?.execute("1", {}, undefined);
-		expect(result?.isError).toBe(true);
-		expect(result?.content[0]?.text).toBe("no such agent");
-	});
-
-	test("lets any other error fail the call", async () => {
-		const [tool] = await registered([
-			def(() => {
-				throw new ScheduleError("wrong domain");
-			}),
-		]);
-		expect(tool?.execute("1", {}, undefined)).rejects.toThrow("wrong domain");
-	});
-});
-
-describe("tool input", () => {
-	test("reads strings and string lists", () => {
-		const input = { a: "x", n: 3, list: ["p", 4, "q"] };
-		expect(optionalString(input, "a")).toBe("x");
-		expect(optionalString(input, "n")).toBeUndefined();
-		expect(stringList(input, "list")).toEqual(["p", "q"]);
-		expect(stringList(input, "a")).toBeUndefined();
-	});
-
-	test("refuses a blank required string with AgentError", () => {
-		expect(requiredString({ a: " x " }, "a")).toBe(" x ");
-		expect(() => requiredString({ a: "  " }, "a")).toThrow(
-			new AgentError("a is required."),
-		);
-		expect(() => requiredString({}, "b")).toThrow(AgentError);
-	});
-});

package/src/core/runtime/turn-answer.test.ts

@@ -1,72 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { lastReply, thinkingOf, turnAnswer } from "./turn-answer.ts";
-
-const assistant = (
-	text: string,
-	stopReason = "stop",
-	thinking?: { thinking: string; redacted?: boolean },
-) => ({
-	role: "assistant",
-	stopReason,
-	content: [
-		...(thinking ? [{ type: "thinking", ...thinking }] : []),
-		{ type: "text", text },
-	],
-});
-const user = { role: "user", content: "hi" };
-
-describe("turnAnswer", () => {
-	test("answers with the last message's text and its visible thinking", () => {
-		expect(
-			turnAnswer(
-				[
-					user,
-					assistant("tool call", "toolUse", { thinking: " plan " }),
-					assistant(" done ", "stop", { thinking: "secret", redacted: true }),
-				],
-				false,
-			),
-		).toEqual({ ok: true, text: "done", thinking: "plan" });
-	});
-
-	test("keeps every final answer of a steered run", () => {
-		expect(
-			turnAnswer(
-				[
-					assistant("first"),
-					user,
-					assistant("tool", "toolUse"),
-					assistant("second"),
-				],
-				true,
-			),
-		).toEqual({ ok: true, text: "first\n\nsecond" });
-	});
-
-	test("fails without a usable answer", () => {
-		const none = turnAnswer([user], false);
-		expect(none.ok || none.error.message).toBe(
-			"the run produced no assistant message",
-		);
-		const blank = turnAnswer([assistant("  ")], false);
-		expect(blank.ok || blank.error.message).toBe(
-			"the final assistant message has no text",
-		);
-	});
-});
-
-describe("session helpers", () => {
-	test("lastReply is the last answer's text, or undefined", () => {
-		expect(lastReply([assistant("a"), user, assistant(" b ")])).toBe("b");
-		expect(lastReply([user])).toBeUndefined();
-	});
-
-	test("thinkingOf skips redacted thinking", () => {
-		expect(
-			thinkingOf([
-				assistant("x", "stop", { thinking: "one" }),
-				assistant("y", "stop", { thinking: "two", redacted: true }),
-			]),
-		).toBe("one");
-	});
-});

package/src/core/runtime/worker-task.test.ts

@@ -1,82 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { AgentRunError } from "../domain/errors.ts";
-import { lastAssistant, textOf } from "../shared/session-messages.ts";
-import { MAX_REPORT_CHARS, workerReport } from "./worker-task.ts";
-
-const user = { role: "user", content: "task" };
-const answer = (text: string, extra: Record<string, unknown> = {}) => ({
-	role: "assistant",
-	content: [
-		{ type: "thinking", thinking: "hm" },
-		{ type: "text", text },
-	],
-	stopReason: "stop",
-	...extra,
-});
-
-describe("textOf", () => {
-	test("joins text parts and passes a string through", () => {
-		expect(
-			textOf([
-				{ type: "text", text: "a" },
-				{ type: "image" },
-				{ type: "text", text: "b" },
-			]),
-		).toBe("a\nb");
-		expect(textOf("plain")).toBe("plain");
-		expect(textOf(undefined)).toBe("");
-	});
-});
-
-describe("lastAssistant", () => {
-	test("finds the last assistant message", () => {
-		const result = lastAssistant([user, answer("first"), answer("second")]);
-		expect(result.ok && textOf(result.message.content)).toBe("second");
-	});
-
-	test("says why there is no usable answer", () => {
-		expect(lastAssistant([user])).toEqual({
-			ok: false,
-			error: "the run produced no assistant message",
-		});
-		expect(
-			lastAssistant([answer("", { stopReason: "error", errorMessage: "503" })]),
-		).toEqual({ ok: false, error: "503" });
-		expect(lastAssistant([answer("", { stopReason: "error" })])).toEqual({
-			ok: false,
-			error: "the run stopped with error",
-		});
-		expect(lastAssistant([answer("", { stopReason: "aborted" })])).toEqual({
-			ok: false,
-			error: "the run stopped with aborted",
-		});
-		expect(
-			lastAssistant([answer("", { stopReason: "aborted" })], "timed out"),
-		).toEqual({ ok: false, error: "timed out" });
-	});
-});
-
-describe("workerReport", () => {
-	test("returns the trimmed answer", () => {
-		expect(workerReport([user, answer("  done  ")], "stopped")).toBe("done");
-	});
-
-	test("cuts a long report and says so", () => {
-		const report = workerReport(
-			[answer("x".repeat(MAX_REPORT_CHARS + 5))],
-			"stopped",
-		);
-		expect(report).toBe(
-			`${"x".repeat(MAX_REPORT_CHARS)}\n\n[report cut at ${MAX_REPORT_CHARS} characters]`,
-		);
-	});
-
-	test("throws AgentRunError without a usable answer", () => {
-		expect(() =>
-			workerReport([answer("", { stopReason: "aborted" })], "stopped"),
-		).toThrow(new AgentRunError("stopped"));
-		expect(() => workerReport([answer("   ")], "stopped")).toThrow(
-			new AgentRunError("the worker's answer is empty"),
-		);
-	});
-});

package/src/core/services.test.ts

@@ -1,28 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { PluginError } from "./errors.ts";
-import { CoreRegistry, type CoreStores } from "./services.ts";
-
-const stores = {} as CoreStores;
-
-describe("CoreRegistry", () => {
-	test("gives a plugin what a built-in one provided", () => {
-		const core = new CoreRegistry();
-		core.provide("stores", stores);
-		expect(core.stores).toBe(stores);
-	});
-
-	test("reading a service before it is provided names the service and the fix", () => {
-		expect(() => new CoreRegistry().stores).toThrow(PluginError);
-		expect(() => new CoreRegistry().stores).toThrow(
-			"core service stores is not provided yet. Register the built-in plugin that provides it before the plugin that reads it.",
-		);
-	});
-
-	test("a service provided twice is refused", () => {
-		const core = new CoreRegistry();
-		core.provide("stores", stores);
-		expect(() => core.provide("stores", stores)).toThrow(
-			"core service stores is provided twice. Register only one plugin that provides it.",
-		);
-	});
-});