isorite 0.17.0 → 0.18.1

package/dist/main.js

@@ -15,6 +15,9 @@ import { serve } from "@hono/node-server";
 import { Hono } from "hono";
 import { streamSSE } from "hono/streaming";
 import { z } from "zod";
+import { createModels } from "@earendil-works/pi-ai";
+import { Agent } from "@earendil-works/pi-agent-core";
+import { DEFAULT_COMPACTION_SETTINGS, createBashTool, createEditTool, createFindTool, createGrepTool, createLsTool, createReadTool, createWriteTool, estimateTokens, generateSummary, shouldCompact } from "@earendil-works/pi-coding-agent";
 import { appendFile, mkdir, readFile, readdir, rename, rm, rmdir, stat, writeFile } from "node:fs/promises";
 import { createInterface } from "node:readline";
 import { PassThrough } from "node:stream";
@@ -141,13 +144,13 @@ const COLUMN_ATTRS = [
 	"columns",
 	"at"
 ];
-const TAG = /<(iso-[\w-]+)\b([^>]*)>/gi;
+const TAG$1 = /<(iso-[\w-]+)\b([^>]*)>/gi;
 const attrsOf = (s) => Object.fromEntries([...s.matchAll(/([\w-]+)\s*=\s*"([^"]*)"/g)].map((m) => [m[1].toLowerCase(), m[2]]));
 /** The files an artifact reads, from its markup and script: data="…", an iso-model's src, iso.data/text/bytes("…"). */
 function readsOf(html) {
 	const own = html.replace(/<!--[\s\S]*?-->/g, ""), reads = /* @__PURE__ */ new Set();
 	for (const r of own.matchAll(/iso\.(?:data|text|bytes)\(\s*["'`]([^"'`$]+)["'`]/g)) reads.add(r[1]);
-	for (const t of own.matchAll(TAG)) {
+	for (const t of own.matchAll(TAG$1)) {
 		const a = attrsOf(t[2]);
 		(a.data ?? "").split(/[\s,]+/).filter(Boolean).forEach((f) => reads.add(f));
 		if (t[1].toLowerCase() === "iso-model" && a.src) reads.add(a.src);
@@ -173,7 +176,7 @@ function checkArtifact(html, ctx = {}) {
 	const reads = /* @__PURE__ */ new Set();
 	for (const r of own.matchAll(/iso\.(?:data|text|bytes)\(\s*["'`]([^"'`$]+)["'`]/g)) reads.add(r[1]);
 	const files = (a) => (a.data ?? "").split(/[\s,]+/).filter(Boolean);
-	for (const t of own.matchAll(TAG)) {
+	for (const t of own.matchAll(TAG$1)) {
 		const a = attrsOf(t[2]);
 		files(a).forEach((f) => reads.add(f));
 		if (t[1].toLowerCase() === "iso-model" && a.src) reads.add(a.src);
@@ -183,7 +186,7 @@ function checkArtifact(html, ctx = {}) {
 		for (const u of m.uses) if (!ctx.files.includes(u)) err(2, `${u} is in isorite:uses but there's no such file beside it${ctx.files.length ? ` (there are: ${ctx.files.join(", ")})` : ""}`);
 	}
 	if (ctx.uses && [...ctx.uses].sort().join() !== [...m.uses].sort().join()) err(2, `isorite:uses (${m.uses.join(" ") || "none"}) and the uses given (${ctx.uses.join(" ") || "none"}) differ`);
-	if (ctx.columns) for (const t of own.matchAll(TAG)) {
+	if (ctx.columns) for (const t of own.matchAll(TAG$1)) {
 		const a = attrsOf(t[2]), fs = files(a), known = fs.map((f) => ctx.columns[f]);
 		if (!fs.length || known.some((k) => !k)) continue;
 		const have = [...new Set(known.flat()), ...fs.length > 1 ? ["file"] : []];
@@ -2516,7 +2519,8 @@ function knownBases(config = configPath()) {
 			name,
 			path: expand(row.path),
 			lend: row.lend === true,
-			...typeof row.used === "string" ? { used: row.used } : {}
+			...typeof row.used === "string" ? { used: row.used } : {},
+			...typeof row.title === "string" && row.title ? { title: row.title } : {}
 		}] : [];
 	});
 }
@@ -2554,6 +2558,19 @@ function rememberBase(folder, { path = configPath(), as, lend } = {}) {
 	writeConfig(bases, basesPath(path));
 	return name;
 }
+/** Give a known base a title to be shown by (M37), or take it back with an empty one: its name stays, as it is the base's
+*  address and what the agent's sessions know it by. False when there is no base of that name. */
+function titleBase(name, title, path = configPath()) {
+	const bases = readConfig(basesPath(path));
+	if (!BASE_NAME.test(name) || !bases[name]) return false;
+	const { title: _was, ...rest } = table(bases[name]);
+	bases[name] = {
+		...rest,
+		...title.trim() ? { title: title.trim() } : {}
+	};
+	writeConfig(bases, basesPath(path));
+	return true;
+}
 /** Lend a known base to every session, or stop lending it. False when there is no base of that name. */
 function lendBase(name, lend, path = configPath()) {
 	const bases = readConfig(basesPath(path));
@@ -5469,7 +5486,8 @@ var Bases = class {
 			name: b.name,
 			path: b.path,
 			lend: b.lend,
-			open: this.#ready.has(b.name)
+			open: this.#ready.has(b.name),
+			title: b.title ?? b.name
 		}));
 	}
 	async lend(name, on) {
@@ -5477,6 +5495,9 @@ var Bases = class {
 		if (on) await this.get(name);
 		return true;
 	}
+	title(name, title) {
+		return titleBase(name, title, this.#config);
+	}
 	async open(path) {
 		const name = rememberBase(resolve(path), { path: this.#config });
 		await this.get(name);
@@ -5705,7 +5726,23 @@ function given(asked, parts, title) {
 	if (passages.length) out.push(passages.join("\n\n"));
 	return out.join("\n\n");
 }
-const OUTPUT = 4e3;
+/** The same for an agent that takes embedded context: notes and folders as text for the agent to read with isorite's
+*  tools, and each passage as a resource block (the note's address, the passage as its text) that the text points to. */
+function givenEmbedded(parts, title, base) {
+	const passages = parts.flatMap((p) => p.kind === "passage" ? [p] : []);
+	return {
+		text: [given("", parts.filter((p) => p.kind !== "passage"), title).trim(), passages.length ? `${passages.length === 1 ? "A passage I selected is" : `${passages.length} passages I selected are`} attached as ${passages.length === 1 ? "a resource" : "resources"}, named for the note ${passages.length === 1 ? "it is" : "each is"} from (the note may have changed since: read it for the current text):\n${passages.map((p) => `- from ${title(p.id)} (${p.id})`).join("\n")}` : ""].filter(Boolean).join("\n\n"),
+		blocks: passages.map((p) => ({
+			type: "resource",
+			resource: {
+				uri: `isorite://${base}/${p.id}`,
+				mimeType: "text/markdown",
+				text: p.text
+			}
+		}))
+	};
+}
+const OUTPUT$1 = 4e3;
 const NOTE_TOOLS = /(^|[_:./-])(read_note|outline_note|edit_note|write_note)$/;
 const CHANGES = /* @__PURE__ */ new Set([
 	"edit",
@@ -5721,7 +5758,7 @@ const ACTIONS = {
 	read: "read",
 	fetch: "webfetch"
 };
-const EMPTY = {
+const EMPTY$1 = {
 	connected: false,
 	agent: "",
 	session: null,
@@ -5737,7 +5774,7 @@ const EMPTY = {
 	model: "",
 	sessions: []
 };
-const textOf = (blocks) => (Array.isArray(blocks) ? blocks : [blocks]).map((b) => b?.type === "text" ? b.text ?? "" : b?.type === "resource_link" ? `@${b.name ?? b.uri ?? ""}` : "").join("");
+const textOf$1 = (blocks) => (Array.isArray(blocks) ? blocks : [blocks]).map((b) => b?.type === "text" ? b.text ?? "" : b?.type === "resource_link" ? `@${b.name ?? b.uri ?? ""}` : "").join("");
 const lines = (v) => v ? v.replace(/\n$/, "").split("\n") : [];
 const keyOf = (agent, session) => `${agent}\u0000${session}`;
 const str = (v) => typeof v === "string" ? v : "";
@@ -5790,7 +5827,7 @@ var AcpFollower = class {
 	#shown = null;
 	#chosen = false;
 	#reading = null;
-	#view = EMPTY;
+	#view = EMPTY$1;
 	#ours = 0;
 	/** Why what the pane last asked of an agent was refused (signing in, a session it does not have). */
 	#problem = "";
@@ -5863,12 +5900,13 @@ var AcpFollower = class {
 			size: live.size,
 			ours: this.#ours,
 			sessions: this.#sessions(),
+			...live.link.steer ? { steer: true } : {},
 			commands: live.commands,
 			settings: [...live.modes ? [live.modes] : [], ...live.configs],
 			...problem
 		};
 		else if (read) this.#view = {
-			...EMPTY,
+			...EMPTY$1,
 			connected,
 			reading: true,
 			agent: read.name,
@@ -5882,7 +5920,7 @@ var AcpFollower = class {
 		else {
 			const link = [...this.#links.values()].at(-1);
 			this.#view = {
-				...EMPTY,
+				...EMPTY$1,
 				connected,
 				agent: link?.name ?? "",
 				agentId: link?.agent ?? "",
@@ -5963,6 +6001,8 @@ var AcpFollower = class {
 				resume: false,
 				list: false
 			},
+			embedded: false,
+			steer: false,
 			toAgent: /* @__PURE__ */ new Map(),
 			fromAgent: /* @__PURE__ */ new Map(),
 			listed: [],
@@ -6017,11 +6057,36 @@ var AcpFollower = class {
 			type: "open",
 			...this.#reading ? { session: this.#reading.session } : {},
 			then: text,
-			...this.#unopened ? { give: this.#unopened.text } : {}
+			...this.#unopened ? {
+				give: this.#unopened.text,
+				...this.#unopened.blocks?.length ? { giveBlocks: this.#unopened.blocks } : {}
+			} : {}
 		});
 	}
+	/** Subagents the agent announced (`subagent_update`), by their session: each is a session of its own that the pane
+	*  does not list, and what it reads and changes in the base is told under its own name, `<agent>-<title>-<n>`. */
+	#children = /* @__PURE__ */ new Map();
+	#childCount = /* @__PURE__ */ new Map();
 	/** Given before a session was open: for the one the next prompt opens. */
 	#unopened = null;
+	async steer(text) {
+		const live = this.#need();
+		if (!live.link.steer) throw new Error(`${live.link.name || "this agent"} cannot be steered while it works: stop it and ask again`);
+		if (!live.busy) throw new Error("the agent is not working: ask it instead");
+		live.link.send({
+			type: "steer",
+			session: live.session,
+			text
+		});
+		this.#edit(live, (items) => [...items, {
+			kind: "message",
+			id: `steer-${live.turns.length}-${items.length}`,
+			text,
+			mode: "steer",
+			state: "sent"
+		}]);
+		this.#tell();
+	}
 	async interrupt() {
 		const live = this.#need();
 		live.link.send({
@@ -6030,24 +6095,31 @@ var AcpFollower = class {
 		});
 	}
 	/** Notes and passages given from the pane: those not given in the session yet go before its next prompt. */
-	async give(parts, render) {
+	async give(parts, render, embed) {
 		const live = this.#shownLive();
+		const made = (p, embedded) => {
+			const e = embedded && embed ? embed(p) : null;
+			return e ? {
+				parts: p,
+				text: e.text,
+				...e.blocks.length ? { blocks: e.blocks } : {}
+			} : {
+				parts: p,
+				text: render(p)
+			};
+		};
 		if (!live) {
-			this.#unopened = parts.length ? {
-				parts,
-				text: render(parts)
-			} : null;
+			const link = [...this.#links.values()].at(-1);
+			this.#unopened = parts.length ? made(parts, link?.embedded === true) : null;
 			return;
 		}
 		const fresh = parts.filter((g) => !live.given.has(givenKey(g)));
-		live.pending = fresh.length ? {
-			parts: fresh,
-			text: render(fresh)
-		} : null;
+		live.pending = fresh.length ? made(fresh, live.link.embedded) : null;
 		live.link.send({
 			type: "give",
 			session: live.session,
-			text: live.pending?.text ?? ""
+			text: live.pending?.text ?? "",
+			...live.pending?.blocks ? { blocks: live.pending.blocks } : {}
 		});
 	}
 	async reply(id, decision) {
@@ -6200,6 +6272,8 @@ var AcpFollower = class {
 				case "initialize": {
 					const info = m.result?.agentInfo;
 					const caps = m.result?.agentCapabilities ?? {};
+					link.embedded = caps.promptCapabilities?.embeddedContext === true;
+					link.steer = (m.result?._meta)?.steering?.supported === true;
 					link.agent = agentName(info?.name ?? "agent");
 					link.name = info?.title ?? info?.name ?? "The agent";
 					link.can = {
@@ -6278,7 +6352,7 @@ var AcpFollower = class {
 			return;
 		}
 		if (m.method === "session/update") {
-			const live = this.#lives.get(keyOf(link.agent, sessionId));
+			const live = this.#lives.get(keyOf(link.agent, sessionId)) ?? this.#children.get(keyOf(link.agent, sessionId));
 			if (live) this.#update(live, m.params?.update ?? {});
 		}
 	}
@@ -6354,7 +6428,7 @@ var AcpFollower = class {
 		live.busy = true;
 		live.turns = [...live.turns, {
 			id: key,
-			asked: textOf(given ? blocks.slice(1) : blocks),
+			asked: textOf$1(given ? blocks.slice(1) : blocks),
 			from: way === "ours" ? "here" : "terminal",
 			items: [],
 			state: "running",
@@ -6397,7 +6471,7 @@ var AcpFollower = class {
 		switch (u.sessionUpdate) {
 			case "user_message_chunk": {
 				if (!live.loading) break;
-				const text = textOf(u.content), t = live.turns.at(-1);
+				const text = textOf$1(u.content), t = live.turns.at(-1);
 				if (live.replaying && t && !t.items.length) live.turns = [...live.turns.slice(0, -1), {
 					...t,
 					asked: t.asked + text
@@ -6414,7 +6488,7 @@ var AcpFollower = class {
 			}
 			case "agent_message_chunk": {
 				live.replaying = false;
-				const text = textOf(u.content);
+				const text = textOf$1(u.content);
 				this.#edit(live, (items) => {
 					const end = items.at(-1);
 					if (end?.kind === "text") items[items.length - 1] = {
@@ -6429,6 +6503,24 @@ var AcpFollower = class {
 				});
 				break;
 			}
+			case "agent_thought_chunk": {
+				live.replaying = false;
+				const text = textOf$1(u.content);
+				if (!text) break;
+				this.#edit(live, (items) => {
+					const end = items.at(-1);
+					if (end?.kind === "thinking") items[items.length - 1] = {
+						kind: "thinking",
+						text: end.text + text
+					};
+					else items.push({
+						kind: "thinking",
+						text
+					});
+					return items;
+				});
+				break;
+			}
 			case "tool_call":
 			case "tool_call_update": {
 				live.replaying = false;
@@ -6446,7 +6538,7 @@ var AcpFollower = class {
 					} : items[at];
 					const content = Array.isArray(u.content) ? u.content : null;
 					const diff = content?.find((c) => c.type === "diff");
-					const output = content ? content.filter((c) => c.type === "content").map((c) => textOf(c.content)).join("\n").slice(0, OUTPUT) : was.output;
+					const output = content ? content.filter((c) => c.type === "content").map((c) => textOf$1(c.content)).join("\n").slice(0, OUTPUT$1) : was.output;
 					const input = u.rawInput ?? {};
 					kind = typeof u.kind === "string" ? u.kind : diff ? "edit" : "";
 					const name = typeof u.name === "string" ? u.name : kind && at < 0 ? kind : was.name;
@@ -6498,6 +6590,58 @@ var AcpFollower = class {
 			case "session_info_update":
 				if (typeof u.title === "string") live.title = u.title;
 				break;
+			case "subagent_update": {
+				const id = str(u.sessionId);
+				if (!id || live.link.agent === "") break;
+				const key = keyOf(live.link.agent, id), title = str(u.title) || str(u.description) || "subagent";
+				let child = this.#children.get(key);
+				if (!child) {
+					const n = (this.#childCount.get(live.link.agent) ?? 0) + 1;
+					this.#childCount.set(live.link.agent, n);
+					const agent = agentName(`${live.link.agent}-${title.split(/\s+/).slice(0, 3).join("-")}-${n}`);
+					child = {
+						...live,
+						link: {
+							...live.link,
+							agent
+						},
+						session: id,
+						title,
+						turns: [{
+							id,
+							asked: title,
+							from: live.from,
+							items: [],
+							state: "running"
+						}],
+						seen: /* @__PURE__ */ new Set(),
+						asking: /* @__PURE__ */ new Map(),
+						pending: null,
+						given: /* @__PURE__ */ new Set(),
+						loading: false,
+						replaying: false
+					};
+					this.#children.set(key, child);
+				}
+				const state = u.state ?? {};
+				const status = state.state === "idle" ? state.error || state.stopReason === "error" ? "failed" : "done" : "running";
+				this.#edit(live, (items) => {
+					const at = items.findIndex((i) => i.kind === "tool" && i.id === `subagent-${id}`);
+					const was = at < 0 ? null : items[at];
+					const now = {
+						kind: "tool",
+						id: `subagent-${id}`,
+						name: "subagent",
+						title: was?.title || title,
+						status,
+						output: str(u.description) || was?.output || ""
+					};
+					if (at < 0) items.push(now);
+					else items[at] = now;
+					return items;
+				});
+				break;
+			}
 			case "available_commands_update":
 				live.commands = commandsOf(u.availableCommands);
 				break;
@@ -6567,7 +6711,7 @@ var AcpFollower = class {
 };
 //#endregion
 //#region packages/server/src/version.ts
-const VERSION = "0.17.0";
+const VERSION = "0.18.1";
 //#endregion
 //#region packages/server/src/connect.ts
 const HARNESSES = [{
@@ -6593,9 +6737,13 @@ const HARNESSES = [{
 		]
 	}]
 }];
-/** Where the base's harness config goes: its repository, or the base's own folder when it is in none. */
+/** Where the base's harness config goes: its repository; in none, the folder holding a base named `notes` (what
+*  `isorite` makes in a project, M37), so agents are started in the project and not in its notes; else the base's own
+*  folder. Never a home folder or the root, which only look like a project's. */
 function projectOf(notes) {
-	const repo = repoOf(notes) ?? notes;
+	const up = dirname(resolve(notes));
+	const beside = basename(notes) === "notes" && up !== homedir() && dirname(up) !== up;
+	const repo = repoOf(notes) ?? (beside ? up : notes);
 	return {
 		repo,
 		rel: relative(repo, notes).split(sep).join("/") || "."
@@ -6870,8 +7018,8 @@ function missingKey(command, env = process.env) {
 //#region packages/server/src/agents.ts
 init_self();
 const FRESH = 36e5;
-const ID = /^[a-z0-9][a-z0-9._-]{0,63}$/;
-const dataDir = (env) => join(env.XDG_DATA_HOME || join(homedir(), ".local", "share"), "isorite", "agents");
+const ID$2 = /^[a-z0-9][a-z0-9._-]{0,63}$/;
+const dataDir$1 = (env) => join(env.XDG_DATA_HOME || join(homedir(), ".local", "share"), "isorite", "agents");
 /** The registry's name for this platform. */
 const platform$1 = () => `${process.platform === "win32" ? "windows" : process.platform}-${process.arch === "arm64" ? "aarch64" : process.arch === "x64" ? "x86_64" : process.arch}`;
 /** A word a shell takes as it is. */
@@ -6883,7 +7031,7 @@ async function readRegistry(env = process.env) {
 	const from = env.ISORITE_ACP_REGISTRY || "https://cdn.agentclientprotocol.com/registry/v1/latest/registry.json";
 	const parse = (text) => {
 		const agents = JSON.parse(text).agents;
-		return Array.isArray(agents) ? agents.filter((a) => typeof a?.id === "string" && ID.test(a.id) && typeof a.name === "string") : [];
+		return Array.isArray(agents) ? agents.filter((a) => typeof a?.id === "string" && ID$2.test(a.id) && typeof a.name === "string") : [];
 	};
 	if (!/^https?:/.test(from)) return parse(readFileSync(from, "utf8"));
 	const kept = join(cacheDir(env), "acp-registry.json");
@@ -6926,7 +7074,7 @@ async function commandOf(e, env = process.env) {
 	const d = e.distribution ?? {};
 	const bin = d.binary?.[platform$1()];
 	if (bin) {
-		const dir = join(dataDir(env), e.id, (e.version || "latest").replace(/[^\w.-]/g, "_"));
+		const dir = join(dataDir$1(env), e.id, (e.version || "latest").replace(/[^\w.-]/g, "_"));
 		const cmd = resolve(dir, bin.cmd);
 		if (!cmd.startsWith(dir)) throw new Error(`${e.name}: its program is outside its folder`);
 		if (!existsSync(cmd)) await fetchProgram(bin, dir);
@@ -7001,7 +7149,7 @@ async function fetchProgram(bin, dir) {
 /** What bases.toml says this base has chosen. */
 function chosenAgent(base, config) {
 	const row = table(readConfig(basesPath(config))[base]);
-	if (typeof row.agent === "string" && ID.test(row.agent)) return { id: row.agent };
+	if (typeof row.agent === "string" && ID$2.test(row.agent)) return { id: row.agent };
 	if (typeof row.agent_command === "string" && row.agent_command.trim()) return { command: row.agent_command.trim() };
 	return null;
 }
@@ -7291,7 +7439,8 @@ const AgentStatus = z.object({
 	session: z.string().min(1).max(200),
 	busy: z.boolean()
 }).strict();
-function createApp({ api, token, loopback, web, allowHosts = [], notes, acp, bases, base, agents, config }) {
+function createApp({ api, token, loopback, web, allowHosts = [], notes, acp, terminal, bases, base, agents, config, pi }) {
+	const pane = terminal ?? acp;
 	const app = new Hono();
 	const allowed = new Set([...allowHosts].map((h) => h.toLowerCase()));
 	const reply = (c, status, value) => c.body(JSON.stringify(value), status, {
@@ -7473,6 +7622,14 @@ function createApp({ api, token, loopback, web, allowHosts = [], notes, acp, bas
 			if (!await bases.lend(b.name, b.lend)) throw new EngineError(`no base ${b.name} is known here`, 404);
 			return { bases: bases.list() };
 		});
+		post("/api/bases/title", z.object({
+			name: z.string().max(40),
+			title: z.string().max(60)
+		}).strict(), async (c, b) => {
+			mine(c);
+			if (!bases.title(b.name, b.title)) throw new EngineError(`no base ${b.name} is known here`, 404);
+			return { bases: bases.list() };
+		});
 		post("/api/bases/open", z.object({ path: z.string().min(1).max(4e3) }).strict(), async (c, b) => {
 			mine(c);
 			if (!isAbsolute(b.path) || !existsSync(b.path) || !statSync(b.path).isDirectory()) throw new EngineError(`no folder at ${b.path}`, 404);
@@ -7550,8 +7707,54 @@ function createApp({ api, token, loopback, web, allowHosts = [], notes, acp, bas
 			return agents.choose(b.choice);
 		});
 	}
-	if (acp) {
-		app.get("/api/terminal", (c) => answer(c, async () => acp.view()));
+	if (pi) {
+		const mine = (c) => {
+			if (!local(c)) throw new EngineError("the model and keys are set only from this machine", 403);
+		};
+		app.get("/api/pi", (c) => answer(c, async () => {
+			mine(c);
+			return pi.state();
+		}));
+		const Provider = z.string().regex(/^[a-z0-9-]{1,40}$/);
+		const invalid = async (fn) => {
+			try {
+				await fn();
+			} catch (e) {
+				throw new EngineError(e.message, 400);
+			}
+		};
+		post("/api/pi/key", z.object({
+			provider: Provider,
+			key: z.string().max(2e3)
+		}).strict(), async (c, b) => {
+			mine(c);
+			await invalid(() => pi.creds.set(b.provider, b.key));
+		});
+		post("/api/pi/key/remove", z.object({ provider: Provider }).strict(), async (c, b) => {
+			mine(c);
+			await invalid(() => pi.creds.remove(b.provider));
+		});
+		post("/api/pi/reach", z.object({
+			files: z.enum([
+				"off",
+				"read",
+				"write"
+			]),
+			shell: z.boolean()
+		}).strict(), async (c, b) => {
+			mine(c);
+			await invalid(() => pi.setReach(b));
+		});
+		post("/api/pi/choose", z.object({
+			provider: Provider,
+			model: z.string().min(1).max(200)
+		}).strict(), async (c, b) => {
+			mine(c);
+			await invalid(() => pi.choose(b.provider, b.model));
+		});
+	}
+	if (pane) {
+		app.get("/api/terminal", (c) => answer(c, async () => pane.view()));
 		const failed = (e) => {
 			throw new EngineError(e.message, 409);
 		};
@@ -7563,11 +7766,22 @@ function createApp({ api, token, loopback, web, allowHosts = [], notes, acp, bas
 			const broken = await api.brokenNews();
 			const news = broken.length ? `\n\n(isorite: code links in the notes that no longer resolve: ${broken.map((x) => `${x.href} in /${x.id}.md`).join("; ")}.)` : "";
 			const title = (id) => titles.get(id) ?? id;
-			await acp.give(b.given, (parts) => given("", parts, title).trim()).catch(failed);
-			await acp.prompt(b.asked.trim() + news).catch(failed);
+			await pane.give(b.given, (parts) => given("", parts, title).trim(), (parts) => givenEmbedded(parts, title, base ?? "notes")).catch(failed);
+			await pane.prompt(b.asked.trim() + news).catch(failed);
 		});
+		post("/api/terminal/steer", z.object({
+			asked: z.string().min(1).max(8e3),
+			given: z.array(Given).max(40)
+		}).strict(), async (_c, b) => {
+			if (!pane.steer) throw new EngineError("this agent cannot be steered while it works: stop it and ask again", 409);
+			const titles = new Map((await api.notes()).notes.map((n) => [n.id, n.title]));
+			const title = (id) => titles.get(id) ?? id;
+			await pane.give(b.given, (parts) => given("", parts, title).trim(), (parts) => givenEmbedded(parts, title, base ?? "notes")).catch(failed);
+			await pane.steer(b.asked.trim()).catch(failed);
+		});
+		post("/api/terminal/withdraw", z.object({ given: Given }).strict(), async (_c, b) => ({ withdrawn: pane.withdraw ? await pane.withdraw(b.given) : false }));
 		post("/api/terminal/stop", z.object({}).strict(), async () => {
-			await acp.interrupt().catch(failed);
+			await pane.interrupt().catch(failed);
 		});
 		post("/api/terminal/permission", z.object({
 			id: z.string().max(200),
@@ -7577,7 +7791,7 @@ function createApp({ api, token, loopback, web, allowHosts = [], notes, acp, bas
 				"reject"
 			])
 		}).strict(), async (_c, b) => {
-			await acp.reply(b.id, b.decision).catch(failed);
+			await pane.reply(b.id, b.decision).catch(failed);
 		});
 	}
 	const endpoint = new McpEndpoint(api, {
@@ -7610,7 +7824,7 @@ function createApp({ api, token, loopback, web, allowHosts = [], notes, acp, bas
 		const quiet = Number(c.req.query("quiet"));
 		const who = (rpc) => {
 			const agent = named && /^[a-z0-9][a-z0-9-]{0,39}$/.test(named) ? named : agentName(clientName(rpc) ?? "mcp");
-			const asked = acp?.asked(agent) ?? "";
+			const asked = pane?.asked(agent) ?? "";
 			return {
 				agent,
 				session: (c.req.query("session") ?? "http").slice(0, 200),
@@ -7626,25 +7840,38 @@ function createApp({ api, token, loopback, web, allowHosts = [], notes, acp, bas
 	if (acp) {
 		const render = async () => {
 			const titles = new Map((await api.notes()).notes.map((n) => [n.id, n.title]));
-			return (parts) => given("", parts, (id) => titles.get(id) ?? id).trim();
+			const title = (id) => titles.get(id) ?? id;
+			return {
+				text: (parts) => given("", parts, title).trim(),
+				embed: (parts) => givenEmbedded(parts, title, base ?? "notes")
+			};
 		};
+		const host = pane ?? acp;
 		const refused = (e) => {
 			throw new EngineError(e.message, 409);
 		};
 		post("/api/acp/give", z.object({ given: z.array(Given).max(40) }).strict(), async (_c, b) => {
-			await acp.give(b.given, await render()).catch(refused);
+			const r = await render();
+			await host.give(b.given, r.text, r.embed).catch(refused);
 		});
 		post("/api/acp/follow", z.object({
 			agent: z.string().max(40),
 			session: z.string().min(1).max(200)
 		}).strict(), async (_c, b) => {
-			await acp.follow(b.agent, b.session).catch(refused);
+			await host.follow(b.agent, b.session).catch(refused);
+		});
+		post("/api/acp/fork", z.object({
+			agent: z.string().max(40),
+			session: z.string().min(1).max(200)
+		}).strict(), async (_c, b) => {
+			if (!host.fork) throw new EngineError("this agent's sessions cannot be forked here", 409);
+			await host.fork(b.agent, b.session).catch(refused);
 		});
 		post("/api/acp/forget", z.object({
 			agent: z.string().max(40),
 			session: z.string().min(1).max(200)
 		}).strict(), async (_c, b) => {
-			await acp.forget(b.agent, b.session).catch(refused);
+			await host.forget(b.agent, b.session).catch(refused);
 		});
 		post("/api/acp/set", z.object({
 			kind: z.enum(["mode", "config"]),
@@ -7652,16 +7879,16 @@ function createApp({ api, token, loopback, web, allowHosts = [], notes, acp, bas
 			value: z.string().max(200)
 		}).strict(), async (_c, b) => {
 			try {
-				acp.set(b.kind, b.id, b.value);
+				host.set(b.kind, b.id, b.value);
 			} catch (e) {
 				throw new EngineError(e.message, 409);
 			}
 		});
 		post("/api/acp/new", z.object({ agent: z.string().max(40) }).strict(), async (_c, b) => {
-			await acp.fresh(b.agent).catch(refused);
+			await host.fresh(b.agent).catch(refused);
 		});
 		post("/api/acp/list", z.object({}).strict(), async () => {
-			acp.refresh();
+			host.refresh();
 		});
 		post("/api/acp/tap", z.object({
 			link: z.string().min(1).max(100),
@@ -7733,7 +7960,7 @@ function createApp({ api, token, loopback, web, allowHosts = [], notes, acp, bas
 				})
 			}).catch(() => void 0);
 		};
-		const unfollow = acp?.listen(send);
+		const unfollow = pane?.listen(send);
 		const beat = setInterval(() => {
 			stream.write(": still here\n\n");
 		}, 25e3);
@@ -7741,7 +7968,7 @@ function createApp({ api, token, loopback, web, allowHosts = [], notes, acp, bas
 			event: "open",
 			data: "{}"
 		});
-		if (acp?.view().connected) send(acp.view());
+		if (pane?.view().connected) send(pane.view());
 		streams.set(stream, c.req.query("agent") === void 0);
 		watchers();
 		await new Promise((done) => stream.onAbort(done));
@@ -7775,6 +8002,1268 @@ function staticFile(c, web) {
 	});
 }
 //#endregion
+//#region packages/server/src/pi/store.ts
+/** Said when a saved session cannot be read: names the file, so the person can look at it or move it away. */
+var StoreError = class extends Error {
+	file;
+	constructor(file, why) {
+		super(`The saved pi session ${file} could not be read (${why}). It was left where it is.`);
+		this.file = file;
+	}
+};
+const ID$1 = /^[0-9a-f-]{8,64}$/i;
+var FileStore = class {
+	#dir;
+	constructor(dir) {
+		this.#dir = dir;
+	}
+	async save(r) {
+		if (!ID$1.test(r.session)) throw new Error("not a session id");
+		await mkdir(this.#dir, {
+			recursive: true,
+			mode: 448
+		});
+		const file = join(this.#dir, `${r.session}.json`), tmp = `${file}.${process.pid}.tmp`;
+		await writeFile(tmp, JSON.stringify(r), { mode: 384 });
+		await rename(tmp, file);
+	}
+	async latest() {
+		let names;
+		try {
+			names = (await readdir(this.#dir)).filter((n) => n.endsWith(".json"));
+		} catch {
+			return null;
+		}
+		const newest = (await Promise.all(names.map(async (n) => ({
+			n,
+			t: (await stat(join(this.#dir, n))).mtimeMs
+		})))).sort((a, b) => b.t - a.t)[0];
+		if (!newest) return null;
+		return this.#read(join(this.#dir, newest.n));
+	}
+	async #read(file) {
+		let record;
+		try {
+			record = JSON.parse(await readFile(file, "utf8"));
+		} catch (e) {
+			throw new StoreError(file, e.message);
+		}
+		const r = record;
+		if (!r || r.version !== 1 || typeof r.session !== "string" || !Array.isArray(r.turns) || !Array.isArray(r.messages)) throw new StoreError(file, "it is not a session this version of isorite wrote");
+		return r;
+	}
+	async list() {
+		let names;
+		try {
+			names = (await readdir(this.#dir)).filter((n) => n.endsWith(".json"));
+		} catch {
+			return {
+				records: [],
+				unreadable: []
+			};
+		}
+		const records = [], unreadable = [];
+		for (const n of names) try {
+			records.push(await this.#read(join(this.#dir, n)));
+		} catch (e) {
+			unreadable.push(e instanceof StoreError ? e.file : join(this.#dir, n));
+		}
+		return {
+			records: records.sort((a, b) => a.last < b.last ? 1 : -1),
+			unreadable
+		};
+	}
+	async load(session) {
+		if (!ID$1.test(session)) return null;
+		const file = join(this.#dir, `${session}.json`);
+		try {
+			await stat(file);
+		} catch {
+			return null;
+		}
+		return this.#read(file);
+	}
+	async remove(session) {
+		if (!ID$1.test(session)) throw new Error("not a session id");
+		await rm(join(this.#dir, `${session}.json`), { force: true });
+	}
+};
+/** Where a base's pi sessions are kept: isorite's data folder, apart from the notes and the repository. */
+function storeDir(notes, env = process.env) {
+	const key = createHash("sha1").update(notes).digest("hex").slice(0, 12);
+	return join(env.XDG_DATA_HOME || join(homedir(), ".local", "share"), "isorite", "pi", key);
+}
+//#endregion
+//#region packages/server/src/pi/tools.ts
+/** `who` names the agent and session as the base knows them; `asked` is what is being asked now, for a change the agent makes. */
+async function isoriteTools(api, who, asked) {
+	return (await api.agentTools()).map(({ function: f }) => ({
+		name: f.name,
+		label: f.name,
+		description: f.description,
+		parameters: f.parameters,
+		execute: async (_id, params) => {
+			const now = asked();
+			const { text } = await api.agentLook({
+				...who,
+				tool: f.name,
+				args: params,
+				...now ? { asked: now } : {}
+			});
+			return {
+				content: [{
+					type: "text",
+					text
+				}],
+				details: void 0
+			};
+		}
+	}));
+}
+/** What a call acted on, in a line: a query, a note, a path, a command. */
+function titleOf(args) {
+	if (!args || typeof args !== "object") return "";
+	const a = args;
+	for (const k of [
+		"query",
+		"note",
+		"id",
+		"path",
+		"command",
+		"question",
+		"text"
+	]) if (typeof a[k] === "string" && a[k]) return String(a[k]).slice(0, 200);
+	const first = Object.values(a).find((v) => typeof v === "string" && v);
+	return typeof first === "string" ? first.slice(0, 200) : "";
+}
+//#endregion
+//#region packages/server/src/pi/host.ts
+const OUTPUT = 4e3;
+/** What the summary of an earlier conversation begins with, in the message that stands for it. */
+const SUMMARY = "[The earlier part of this conversation, summarised to make room]\n";
+const EMPTY = {
+	connected: true,
+	agent: "",
+	session: null,
+	title: "",
+	busy: false,
+	turns: [],
+	asking: [],
+	cost: 0,
+	tokens: {
+		input: 0,
+		output: 0
+	},
+	model: "",
+	sessions: []
+};
+/** A block of context given from the tray is tagged with the chip it came from and the turn it came in with, so it can be
+*  taken back out of what the model is sent when the chip is removed (M36, step 10). */
+const TAG = /^\[context (\S+) @(\S+)\]\n/;
+const WITHDRAWN = "[Context the person gave earlier here was withdrawn: they took it out of the conversation. Do not rely on it; read the notes again if you need them.]";
+const tagged = (key, turn, block) => `[context ${encodeURIComponent(key)} @${turn}]\n${block}\n[/context]\n\n`;
+const textOf = (content) => (Array.isArray(content) ? content : []).map((b) => b?.type === "text" ? b.text ?? "" : "").join("");
+const userText = (content) => typeof content === "string" ? content : textOf(content);
+var PiHost = class {
+	#api;
+	#model;
+	#streamFn;
+	#getApiKey;
+	#id;
+	#name;
+	#ask;
+	#more;
+	#guard;
+	#now;
+	#store;
+	#compaction;
+	/** The thinking item the assistant message now streaming writes into. */
+	#thinkingAt = -1;
+	/** Cancels a summary being written. */
+	#summarising = null;
+	/** Why the last thing asked of the agent could not be done, shown in the pane. */
+	#problem = "";
+	/** The other sessions kept, by id (the one shown is in the fields below); and the last write, waited for before one is left. */
+	#kept = /* @__PURE__ */ new Map();
+	#saving = Promise.resolve();
+	#agent = null;
+	#session = "";
+	#at = "";
+	#title = "";
+	#turns = [];
+	#busy = false;
+	/** The person stopped it: an aborted run is then a stop, not a failure. */
+	#stopping = false;
+	#cost = 0;
+	#used = 0;
+	#asking = /* @__PURE__ */ new Map();
+	#allowed = /* @__PURE__ */ new Set();
+	#pending = null;
+	/** The blocks taken back out: `<key>@<turn>` of each, kept with the session. */
+	#withdrawn = /* @__PURE__ */ new Set();
+	#given = /* @__PURE__ */ new Set();
+	/** What was said while it worked and has not reached the model: the item's id, and the text as the model will have it. */
+	#queued = [];
+	/** The first user message of a run is the prompt itself: it is not a queued message landing. */
+	#primed = false;
+	/** The text item the assistant message now streaming writes into. */
+	#writing = -1;
+	#view = EMPTY;
+	#listeners = /* @__PURE__ */ new Set();
+	constructor({ api, model, streamFn, id = "pi", name = "pi", ask = () => false, more = () => [], guard = () => void 0, clock = Date.now, store, compaction, getApiKey }) {
+		this.#getApiKey = getApiKey;
+		this.#api = api;
+		this.#model = model;
+		this.#streamFn = streamFn;
+		this.#id = id;
+		this.#name = name;
+		this.#ask = ask;
+		this.#more = more;
+		this.#guard = guard;
+		this.#now = clock;
+		this.#store = store ?? null;
+		this.#compaction = {
+			enabled: compaction?.enabled ?? DEFAULT_COMPACTION_SETTINGS.enabled ?? true,
+			reserveTokens: compaction?.reserveTokens ?? DEFAULT_COMPACTION_SETTINGS.reserveTokens ?? 16384,
+			keepRecentTokens: compaction?.keepRecentTokens ?? DEFAULT_COMPACTION_SETTINGS.keepRecentTokens ?? 2e4
+		};
+		api.events?.((e) => {
+			if (e.type !== "agent-item" || e.agent !== this.#id || !this.#turns.length) return;
+			this.#edit((items) => [...items, e.item]);
+			this.#tell();
+		});
+		this.#tell();
+	}
+	/** Carry on with another model (and the way to reach it): the session stays, and the next request goes to it. */
+	use(model, streamFn, name) {
+		this.#model = model;
+		this.#streamFn = streamFn;
+		if (name) this.#name = name;
+		if (this.#agent) this.#agent.state.model = model;
+		this.#tell();
+	}
+	view() {
+		return this.#view;
+	}
+	listen(fn) {
+		this.#listeners.add(fn);
+		return () => {
+			this.#listeners.delete(fn);
+		};
+	}
+	asked(agent) {
+		const t = this.#turns.at(-1);
+		return agent === this.#id && t?.state === "running" ? t.asked : "";
+	}
+	async give(parts, render) {
+		const fresh = parts.filter((g) => !this.#given.has(givenKey(g)));
+		this.#pending = fresh.length ? {
+			parts: fresh,
+			blocks: fresh.map((g) => render([g]))
+		} : null;
+	}
+	async prompt(text) {
+		if (this.#busy) {
+			await this.#say(text, "followUp");
+			return;
+		}
+		this.#problem = "";
+		if (!this.#agent) this.#open();
+		const agent = this.#agent;
+		const pending = this.#pending;
+		this.#pending = null;
+		if (pending) for (const g of pending.parts) this.#given.add(givenKey(g));
+		agent.state.tools = [...await isoriteTools(this.#api, {
+			agent: this.#id,
+			session: this.#session
+		}, () => this.asked(this.#id)), ...this.#more()];
+		const turn = {
+			id: randomUUID(),
+			asked: text,
+			from: "here",
+			items: [],
+			state: "running",
+			...pending ? { given: pending.parts } : {},
+			at: new Date(this.#now()).toISOString()
+		};
+		this.#turns = [...this.#turns, turn];
+		if (!this.#title) this.#title = text.slice(0, 80);
+		this.#busy = true;
+		this.#primed = false;
+		this.#queued = [];
+		this.#writing = -1;
+		this.#thinkingAt = -1;
+		this.#api.agentStatus(this.#id, this.#session, true).catch(() => void 0);
+		this.#tell();
+		const message = this.#message(pending, turn.id.slice(0, 8), text);
+		(async () => {
+			await this.#compactIfNeeded(agent);
+			if (this.#stopping) throw new Error("stopped");
+			await agent.prompt(message);
+		})().then(() => void 0, (e) => {
+			if (this.#stopping) this.#set("stopped");
+			else this.#fail(e.message);
+		}).then(() => this.#end());
+	}
+	/** The person's message for the model: each block given with it, tagged, then what they asked. */
+	#message(pending, turn, text) {
+		return {
+			role: "user",
+			content: [...(pending?.parts ?? []).map((g, i) => tagged(givenKey(g), turn, pending.blocks[i] ?? "")), text].map((t) => ({
+				type: "text",
+				text: t
+			})),
+			timestamp: this.#now()
+		};
+	}
+	/** What the model is sent: the messages, with each withdrawn block replaced by a line saying so. */
+	#redact(messages) {
+		if (!this.#withdrawn.size) return messages;
+		return messages.map((m) => {
+			const msg = m;
+			if (msg.role !== "user" || !Array.isArray(msg.content)) return m;
+			let changed = false;
+			const content = msg.content.map((c) => {
+				const tag = c?.type === "text" && c.text ? TAG.exec(c.text) : null;
+				if (!tag || !this.#withdrawn.has(`${decodeURIComponent(tag[1])}@${tag[2]}`)) return c;
+				changed = true;
+				return {
+					type: "text",
+					text: WITHDRAWN
+				};
+			});
+			return changed ? {
+				...m,
+				content
+			} : m;
+		});
+	}
+	/** The person took a chip out of the tray: the block given with it comes out of everything the model is sent from now
+	*  on. The turns it came in stay as they were, marked. Says whether there was anything to take out. */
+	async withdraw(g) {
+		const key = givenKey(g);
+		if (this.#pending) {
+			const keep = this.#pending.parts.map((p, i) => ({
+				p,
+				b: this.#pending.blocks[i]
+			})).filter((x) => givenKey(x.p) !== key);
+			this.#pending = keep.length ? {
+				parts: keep.map((x) => x.p),
+				blocks: keep.map((x) => x.b)
+			} : null;
+		}
+		if (!this.#given.has(key)) return false;
+		this.#given.delete(key);
+		for (const m of this.#agent?.state.messages ?? []) {
+			const msg = m;
+			if (msg.role !== "user" || !Array.isArray(msg.content)) continue;
+			for (const c of msg.content) {
+				const tag = c?.type === "text" && c.text ? TAG.exec(c.text) : null;
+				if (tag && decodeURIComponent(tag[1]) === key) this.#withdrawn.add(`${key}@${tag[2]}`);
+			}
+		}
+		this.#turns = this.#turns.map((t) => {
+			const at = (t.given ?? []).flatMap((x, i) => givenKey(x) === key && !t.withdrawn?.includes(i) ? [i] : []);
+			return at.length ? {
+				...t,
+				withdrawn: [...t.withdrawn ?? [], ...at]
+			} : t;
+		});
+		this.#save();
+		this.#keep();
+		this.#tell();
+		return true;
+	}
+	async steer(text) {
+		if (!this.#busy) throw new Error("the agent is not working: ask it instead");
+		await this.#say(text, "steer");
+	}
+	/** Said while it works: a steer comes in after the step now running, a follow-up when it would otherwise stop. */
+	async #say(text, mode) {
+		const agent = this.#agent;
+		if (!agent) return;
+		const pending = this.#pending;
+		this.#pending = null;
+		if (pending) for (const g of pending.parts) this.#given.add(givenKey(g));
+		const id = randomUUID();
+		const message = this.#message(pending, (this.#turns.at(-1)?.id ?? id).slice(0, 8), text);
+		this.#queued.push({
+			id,
+			body: userText(message.content)
+		});
+		this.#edit((items) => [...items, {
+			kind: "message",
+			id,
+			text,
+			mode,
+			state: "queued"
+		}]);
+		if (mode === "steer") agent.steer(message);
+		else agent.followUp(message);
+		this.#tell();
+	}
+	async interrupt() {
+		this.#stopping = true;
+		this.#summarising?.abort();
+		this.#agent?.clearAllQueues();
+		for (const a of this.#asking.values()) a.wait("reject");
+		this.#agent?.abort();
+	}
+	async reply(id, decision) {
+		const asked = this.#asking.get(id);
+		if (!asked) throw new Error("the agent is not asking that");
+		asked.wait(decision);
+	}
+	/** Show another kept session, and carry on in it. The one left is already kept (it is written after each turn). */
+	async follow(_agent, session) {
+		if (session === this.#session) return;
+		if (this.#busy) throw new Error("the agent is working: stop it first");
+		const kept = await this.#fetch(session);
+		this.#restore(kept);
+	}
+	/** A new session from the pane; the one shown stays kept and can be shown again. */
+	async fresh(_agent) {
+		if (this.#busy) throw new Error("the agent is working: stop it first");
+		await this.#saving;
+		this.#blank();
+		this.#tell();
+	}
+	/** A new session that begins where `session` is (its turns and the model's messages), going its own way from there;
+	*  its cost starts again at nothing. The original is not changed. */
+	async fork(_agent, session) {
+		if (this.#busy) throw new Error("the agent is working: stop it first");
+		const from = session === this.#session && this.#agent ? this.#record() : await this.#fetch(session);
+		if (!from || !this.#store) throw new Error("that session is not kept, so there is nothing to fork");
+		const now = new Date(this.#now()).toISOString();
+		const copy = {
+			...JSON.parse(JSON.stringify(from)),
+			session: randomUUID(),
+			title: `${from.title || "A session"} (fork)`.slice(0, 90),
+			at: now,
+			last: now,
+			cost: 0
+		};
+		await this.#store.save(copy);
+		this.#kept.set(copy.session, this.#summary(copy));
+		this.#restore(copy);
+	}
+	set() {
+		throw new Error(`${this.#name} offers no modes or options yet`);
+	}
+	/** Remove what is kept of a session. The one shown is left first, for a new one. */
+	async forget(_agent, session) {
+		if (!this.#store) throw new Error("nothing is kept apart from the session shown");
+		if (session === this.#session) {
+			if (this.#busy) throw new Error("the agent is working: stop it first");
+			await this.#saving;
+			this.#blank();
+		}
+		await this.#store.remove(session);
+		this.#kept.delete(session);
+		this.#tell();
+	}
+	/** Read the list of kept sessions again. */
+	refresh() {
+		this.#index().then(() => this.#tell());
+	}
+	async #index() {
+		if (!this.#store) return;
+		const { records, unreadable } = await this.#store.list();
+		this.#kept = new Map(records.map((r) => [r.session, this.#summary(r)]));
+		if (unreadable.length) this.#problem = `${unreadable.length === 1 ? "A saved session" : `${unreadable.length} saved sessions`} could not be read (${unreadable.join(", ")}). ${unreadable.length === 1 ? "It was" : "They were"} left where ${unreadable.length === 1 ? "it is" : "they are"}.`;
+	}
+	#summary(r) {
+		return {
+			session: r.session,
+			title: r.title,
+			asked: r.turns[0]?.asked ?? "",
+			last: r.last,
+			turns: r.turns.length,
+			notes: 0,
+			live: false,
+			busy: false,
+			kept: true,
+			open: true
+		};
+	}
+	async #fetch(session) {
+		if (!this.#store) throw new Error("that session is not here to carry on");
+		await this.#saving;
+		const kept = await this.#store.load(session);
+		if (!kept) throw new Error("that session is not kept");
+		return kept;
+	}
+	/** No session shown: the next question begins a new one. Everything of the last is let go (it stays kept). */
+	#blank() {
+		this.#agent = null;
+		this.#session = "";
+		this.#at = "";
+		this.#turns = [];
+		this.#title = "";
+		this.#cost = 0;
+		this.#used = 0;
+		this.#given = /* @__PURE__ */ new Set();
+		this.#withdrawn = /* @__PURE__ */ new Set();
+		this.#pending = null;
+		this.#queued = [];
+		this.#problem = "";
+		this.#writing = -1;
+		this.#thinkingAt = -1;
+		this.#primed = false;
+		this.#stopping = false;
+	}
+	/** Show `kept` and carry on from it: its turns for the pane, its messages for the model. A turn that was running when
+	*  the server went down is shown as stopped: it never finished. */
+	#restore(kept) {
+		this.#blank();
+		this.#open(kept);
+		this.#turns = kept.turns.map((t) => t.state === "running" ? {
+			...t,
+			state: "stopped"
+		} : t);
+		this.#title = kept.title;
+		this.#cost = kept.cost;
+		this.#used = kept.used;
+		this.#given = new Set(kept.given);
+		this.#withdrawn = new Set(kept.withdrawn ?? []);
+		this.#tell();
+	}
+	/** Take up the session last kept, if there is one. An unreadable one is reported in the pane and left alone, and the
+	*  agent starts fresh. */
+	async resume() {
+		if (!this.#store || this.#agent) return;
+		let kept;
+		try {
+			kept = await this.#store.latest();
+		} catch (e) {
+			this.#problem = e.message;
+			this.#tell();
+			return;
+		}
+		try {
+			await this.#index();
+		} catch {}
+		if (!kept) {
+			this.#tell();
+			return;
+		}
+		this.#restore(kept);
+	}
+	#record() {
+		return {
+			version: 1,
+			session: this.#session,
+			title: this.#title,
+			at: this.#at,
+			last: this.#turns.at(-1)?.at ?? this.#at,
+			cost: this.#cost,
+			used: this.#used,
+			given: [...this.#given],
+			withdrawn: [...this.#withdrawn],
+			turns: this.#turns,
+			messages: JSON.parse(JSON.stringify(this.#agent.state.messages)).filter((m) => m.role !== "system")
+		};
+	}
+	#save() {
+		if (!this.#store || !this.#agent || !this.#turns.length) return;
+		const record = this.#record();
+		this.#kept.set(record.session, this.#summary(record));
+		const store = this.#store;
+		this.#saving = this.#saving.then(() => store.save(record)).catch((e) => {
+			this.#problem = `Could not keep this session: ${e.message}`;
+			this.#tell();
+		});
+	}
+	#open(kept) {
+		this.#session = kept?.session ?? randomUUID();
+		this.#at = kept?.at ?? new Date(this.#now()).toISOString();
+		this.#agent = new Agent({
+			initialState: {
+				systemPrompt: INSTRUCTIONS,
+				model: this.#model,
+				...kept ? { messages: kept.messages } : {}
+			},
+			transformContext: async (messages) => this.#redact(messages),
+			streamFn: ((...args) => this.#streamFn(...args)),
+			...this.#getApiKey ? { getApiKey: this.#getApiKey } : {},
+			sessionId: this.#session,
+			beforeToolCall: async ({ toolCall, args }) => {
+				let refused;
+				try {
+					refused = this.#guard({
+						tool: toolCall.name,
+						args
+					});
+				} catch {
+					refused = "that could not be checked";
+				}
+				if (refused) return {
+					block: true,
+					reason: refused
+				};
+				if (!this.#ask(toolCall.name) || this.#allowed.has(toolCall.name)) return void 0;
+				const id = randomUUID();
+				const decision = await new Promise((wait) => {
+					this.#asking.set(id, {
+						id,
+						action: toolCall.name,
+						resources: [titleOf(args)],
+						tool: toolCall.name,
+						wait
+					});
+					this.#tell();
+				});
+				this.#asking.delete(id);
+				this.#tell();
+				if (decision === "reject") return {
+					block: true,
+					reason: "The person declined this."
+				};
+				if (decision === "always") this.#allowed.add(toolCall.name);
+			}
+		});
+		this.#agent.subscribe((e) => this.#on(e));
+	}
+	#on(e) {
+		if (e.type === "message_start" && e.message.role === "user") {
+			if (!this.#primed) {
+				this.#primed = true;
+				return;
+			}
+			const said = userText(e.message.content);
+			const at = this.#queued.findIndex((q) => q.body === said);
+			if (at < 0) return;
+			const [q] = this.#queued.splice(at, 1);
+			this.#edit((items) => {
+				const was = items.find((i) => i.kind === "message" && i.id === q.id);
+				return was ? [...items.filter((i) => i !== was), {
+					...was,
+					state: "landed"
+				}] : items;
+			});
+		} else if (e.type === "message_start" && e.message.role === "assistant") {
+			this.#edit((items) => [...items, {
+				kind: "text",
+				text: ""
+			}]);
+			this.#writing = (this.#turns.at(-1)?.items.length ?? 1) - 1;
+		} else if (e.type === "message_update" && e.assistantMessageEvent.type === "thinking_delta") {
+			const delta = e.assistantMessageEvent.delta;
+			if (this.#thinkingAt < 0) {
+				const at = Math.max(this.#writing, 0);
+				this.#edit((items) => [
+					...items.slice(0, at),
+					{
+						kind: "thinking",
+						text: ""
+					},
+					...items.slice(at)
+				]);
+				this.#thinkingAt = at;
+				this.#writing = at + 1;
+			}
+			const t = this.#thinkingAt;
+			this.#edit((items) => items.map((i, k) => k === t && i.kind === "thinking" ? {
+				...i,
+				text: i.text + delta
+			} : i));
+		} else if (e.type === "message_update" && e.assistantMessageEvent.type === "text_delta") {
+			const at = this.#writing, delta = e.assistantMessageEvent.delta;
+			this.#edit((items) => items.map((i, k) => k === at && i.kind === "text" ? {
+				...i,
+				text: i.text + delta
+			} : i));
+		} else if (e.type === "message_end" && e.message.role === "assistant") {
+			const m = e.message;
+			const at = this.#writing, think = this.#thinkingAt, whole = textOf(m.content);
+			const thought = (Array.isArray(m.content) ? m.content : []).map((b) => b?.type === "thinking" ? b.thinking ?? "" : "").join("");
+			this.#edit((items) => items.flatMap((i, k) => k === think ? thought.trim() ? [{
+				kind: "thinking",
+				text: thought
+			}] : [] : k !== at ? [i] : whole ? [{
+				kind: "text",
+				text: whole
+			}] : []));
+			this.#writing = -1;
+			this.#thinkingAt = -1;
+			this.#cost += m.usage?.cost?.total ?? 0;
+			this.#used = m.usage?.totalTokens ?? this.#used;
+		} else if (e.type === "tool_execution_start") this.#edit((items) => [...items, {
+			kind: "tool",
+			id: e.toolCallId,
+			name: e.toolName,
+			title: titleOf(e.args),
+			status: "running",
+			output: ""
+		}]);
+		else if (e.type === "tool_execution_end") {
+			const out = textOf(e.result?.content).slice(0, OUTPUT);
+			this.#edit((items) => items.map((i) => i.kind === "tool" && i.id === e.toolCallId ? {
+				...i,
+				status: e.isError ? "failed" : "done",
+				output: out
+			} : i));
+		} else return;
+		this.#tell();
+	}
+	#fail(message) {
+		this.#edit((items) => [...items, {
+			kind: "text",
+			text: `(${message})`
+		}]);
+		this.#set("failed");
+	}
+	#end() {
+		this.#dropQueued();
+		const last = [...this.#agent?.state.messages ?? []].reverse().find((m) => m.role === "assistant");
+		if (this.#turns.at(-1)?.state === "running") {
+			if (this.#stopping || last?.stopReason === "aborted") this.#set("stopped");
+			else if (last?.stopReason === "error") this.#fail(last.errorMessage ?? "the model failed");
+			else this.#set("done");
+		}
+		this.#busy = false;
+		this.#stopping = false;
+		this.#api.agentStatus(this.#id, this.#session, false).catch(() => void 0);
+		this.#keep();
+		this.#save();
+		this.#tell();
+	}
+	/** What the model would be sent now: the last answer's own count, and an estimate for what came after it. */
+	#contextTokens(messages) {
+		let last = -1;
+		for (let i = messages.length - 1; i >= 0; i--) {
+			const m = messages[i];
+			if (m.role === "assistant" && m.usage?.totalTokens && m.stopReason !== "aborted" && m.stopReason !== "error") {
+				last = i;
+				break;
+			}
+		}
+		return (last >= 0 ? messages[last].usage.totalTokens : 0) + messages.slice(last + 1).reduce((n, m) => n + estimateTokens(m), 0);
+	}
+	/** Before a prompt: if what the model would be sent nears its window, summarise the earlier part of the conversation
+	*  and keep the recent part as it was (cut at a message of the person's, so a tool call and its result stay together).
+	*  The turn shows it. If the summary cannot be made the conversation goes on as it was and the turn says so. */
+	async #compactIfNeeded(agent) {
+		const window = this.#model.contextWindow, settings = this.#compaction;
+		if (!settings.enabled || !window) return;
+		const messages = [...agent.state.messages];
+		const before = this.#contextTokens(messages);
+		if (!shouldCompact(before, window, settings)) return;
+		const roleOf = (m) => m?.role;
+		let head = 0;
+		while (roleOf(messages[head]) === "system") head++;
+		const earlier = messages[head]?.content;
+		const previous = userText(earlier).startsWith(SUMMARY) ? userText(earlier).slice(65) : void 0;
+		const from = head + (previous === void 0 ? 0 : 1);
+		let acc = 0, cut = from;
+		for (let i = messages.length - 1; i >= from; i--) {
+			acc += estimateTokens(messages[i]);
+			if (acc >= settings.keepRecentTokens) {
+				cut = i;
+				break;
+			}
+		}
+		while (cut > from && roleOf(messages[cut]) !== "user") cut--;
+		if (cut <= from) return;
+		const id = this.#turns.at(-1)?.items.length ?? 0;
+		this.#edit((items) => [...items, {
+			kind: "compaction",
+			state: "running",
+			before
+		}]);
+		this.#tell();
+		this.#summarising = new AbortController();
+		try {
+			const summary = await generateSummary(this.#redact(messages.slice(from, cut)), this.#model, settings.reserveTokens, void 0, void 0, this.#summarising.signal, void 0, previous, void 0, this.#streamFn);
+			const stand = {
+				role: "user",
+				content: [{
+					type: "text",
+					text: SUMMARY + summary
+				}],
+				timestamp: this.#now()
+			};
+			const recent = messages.slice(cut).map((m) => m.role === "assistant" ? {
+				...m,
+				usage: {
+					...m.usage,
+					totalTokens: 0
+				}
+			} : m);
+			const kept = [
+				...messages.slice(0, head),
+				stand,
+				...recent
+			];
+			agent.state.messages = kept;
+			const after = this.#contextTokens(kept);
+			this.#used = after;
+			this.#edit((items) => items.map((i, k) => k === id && i.kind === "compaction" ? {
+				...i,
+				state: "done",
+				after,
+				summary
+			} : i));
+		} catch (e) {
+			const error = this.#stopping ? "stopped" : e.message;
+			this.#edit((items) => items.map((i, k) => k === id && i.kind === "compaction" ? {
+				...i,
+				state: "failed",
+				error
+			} : i));
+		} finally {
+			this.#summarising = null;
+			this.#tell();
+		}
+	}
+	/** Said but never taken up (the run ended or was stopped first). */
+	#dropQueued() {
+		if (!this.#queued.length) return;
+		const ids = new Set(this.#queued.map((q) => q.id));
+		this.#queued = [];
+		this.#agent?.clearAllQueues();
+		this.#edit((items) => items.map((i) => i.kind === "message" && ids.has(i.id) ? {
+			...i,
+			state: "dropped"
+		} : i));
+	}
+	#set(state) {
+		const turns = [...this.#turns], t = turns.at(-1);
+		if (t) turns[turns.length - 1] = {
+			...t,
+			state
+		};
+		this.#turns = turns;
+	}
+	#edit(fn) {
+		const turns = [...this.#turns], t = turns.at(-1);
+		if (!t) return;
+		turns[turns.length - 1] = {
+			...t,
+			items: fn([...t.items])
+		};
+		this.#turns = turns;
+	}
+	#keep() {
+		if (!this.#api.keepAgentRecord || !this.#turns.length) return;
+		const last = this.#turns.at(-1)?.at ?? this.#at;
+		this.#api.keepAgentRecord({
+			agent: this.#id,
+			name: this.#name,
+			session: this.#session,
+			title: this.#title,
+			at: this.#at,
+			last,
+			turns: this.#turns
+		}).catch(() => void 0);
+	}
+	/** The session shown, with the others kept, newest first. */
+	#sessions(entry) {
+		const others = [...this.#kept.values()].filter((k) => k.session !== this.#session).map((k) => ({
+			agent: this.#id,
+			name: this.#name,
+			...k
+		}));
+		return [...entry ? [entry] : [], ...others].sort((a, b) => a.last < b.last ? 1 : a.last > b.last ? -1 : 0);
+	}
+	#tell() {
+		const last = this.#turns.at(-1)?.at ?? this.#at;
+		const entry = this.#session ? {
+			agent: this.#id,
+			name: this.#name,
+			session: this.#session,
+			title: this.#title,
+			asked: this.#turns[0]?.asked ?? "",
+			last,
+			turns: this.#turns.length,
+			notes: 0,
+			live: true,
+			busy: this.#busy,
+			kept: Boolean(this.#store),
+			open: true
+		} : null;
+		this.#view = {
+			connected: true,
+			agent: this.#name,
+			agentId: this.#id,
+			session: this.#session || null,
+			title: this.#title,
+			busy: this.#busy,
+			turns: this.#turns,
+			asking: [...this.#asking.values()].map(({ wait: _, ...p }) => p),
+			cost: this.#cost,
+			tokens: {
+				input: this.#used,
+				output: 0
+			},
+			model: this.#model.id ?? "",
+			...this.#problem ? { problem: this.#problem } : {},
+			steer: true,
+			...this.#model.contextWindow ? { size: this.#model.contextWindow } : {},
+			fork: Boolean(this.#store),
+			sessions: this.#sessions(entry)
+		};
+		for (const fn of this.#listeners) fn(this.#view);
+	}
+};
+//#endregion
+//#region packages/server/src/pi/files.ts
+const READS = [
+	"read",
+	"grep",
+	"find",
+	"ls"
+];
+const WRITES = ["edit", "write"];
+function fileTools(cwd, { files, shell }) {
+	const tools = [];
+	if (files !== "off") tools.push(createReadTool(cwd), createGrepTool(cwd), createFindTool(cwd), createLsTool(cwd));
+	if (files === "write") tools.push(createEditTool(cwd), createWriteTool(cwd));
+	if (shell) tools.push(createBashTool(cwd));
+	return tools;
+}
+/** A reason to refuse the call, or undefined to let it through. Anything that cannot be checked is refused. */
+function pathGuard(cwd) {
+	const root = resolve(cwd);
+	return ({ tool, args }) => {
+		if (![...READS, ...WRITES].includes(tool)) return void 0;
+		const given = args?.path;
+		if (given === void 0 && (tool === "ls" || tool === "grep" || tool === "find")) return void 0;
+		if (typeof given !== "string" || !given) return `${tool} needs a path inside the project`;
+		const target = isAbsolute(given) ? resolve(given) : resolve(root, given);
+		const inside = relative(root, target);
+		if (inside.startsWith("..") || isAbsolute(inside)) return `${given} is outside the project folder`;
+		if (WRITES.includes(tool) && inside.split(sep).includes(".git")) return `${tool} does not reach .git`;
+	};
+}
+//#endregion
+//#region packages/server/src/pi/credentials.ts
+/** The providers the settings offer: those a person signs up to with a key of their own. Pi's subscription sign-ins
+*  (for a ChatGPT or Copilot plan) are not offered: their terms are the provider's, not isorite's to rely on. */
+const PROVIDERS = [
+	{
+		id: "openrouter",
+		name: "OpenRouter",
+		env: "OPENROUTER_API_KEY"
+	},
+	{
+		id: "anthropic",
+		name: "Anthropic (API key)",
+		env: "ANTHROPIC_API_KEY"
+	},
+	{
+		id: "openai",
+		name: "OpenAI (API key)",
+		env: "OPENAI_API_KEY"
+	},
+	{
+		id: "google",
+		name: "Google Gemini",
+		env: "GEMINI_API_KEY"
+	},
+	{
+		id: "mistral",
+		name: "Mistral",
+		env: "MISTRAL_API_KEY"
+	},
+	{
+		id: "groq",
+		name: "Groq",
+		env: "GROQ_API_KEY"
+	},
+	{
+		id: "xai",
+		name: "xAI",
+		env: "XAI_API_KEY"
+	},
+	{
+		id: "deepseek",
+		name: "DeepSeek",
+		env: "DEEPSEEK_API_KEY"
+	},
+	{
+		id: "together",
+		name: "Together",
+		env: "TOGETHER_API_KEY"
+	},
+	{
+		id: "fireworks",
+		name: "Fireworks",
+		env: "FIREWORKS_API_KEY"
+	},
+	{
+		id: "cerebras",
+		name: "Cerebras",
+		env: "CEREBRAS_API_KEY"
+	}
+];
+/** The default: the project's files to read, nothing to change them with, no shell. */
+const DEFAULT_REACH = {
+	files: "read",
+	shell: false
+};
+const ID = /^[a-z0-9-]{1,40}$/;
+/** Where isorite keeps what is its own, not the base's. */
+function dataDir(env = process.env) {
+	return join(env.XDG_DATA_HOME || join(homedir(), ".local", "share"), "isorite");
+}
+var Credentials = class {
+	#file;
+	#dir;
+	#env;
+	#kept = null;
+	#writing = Promise.resolve();
+	constructor(env = process.env) {
+		this.#env = env;
+		this.#dir = dataDir(env);
+		this.#file = join(this.#dir, "credentials.json");
+	}
+	async #load() {
+		if (this.#kept) return this.#kept;
+		let text;
+		try {
+			text = await readFile(this.#file, "utf8");
+		} catch (e) {
+			if (e.code === "ENOENT") return this.#kept = {
+				version: 1,
+				keys: {}
+			};
+			throw new Error(`The keys file ${this.#file} could not be read (${e.code ?? "unreadable"}). It was left where it is.`);
+		}
+		let parsed;
+		try {
+			parsed = JSON.parse(text);
+		} catch {
+			throw new Error(`The keys file ${this.#file} is not valid JSON. It was left where it is.`);
+		}
+		if (!parsed || parsed.version !== 1 || typeof parsed.keys !== "object" || parsed.keys === null) throw new Error(`The keys file ${this.#file} is not one this version of isorite wrote. It was left where it is.`);
+		return this.#kept = {
+			version: 1,
+			keys: parsed.keys,
+			...parsed.choice ? { choice: parsed.choice } : {},
+			...parsed.reach ? { reach: parsed.reach } : {}
+		};
+	}
+	async #save(next) {
+		const run = async () => {
+			await mkdir(this.#dir, {
+				recursive: true,
+				mode: 448
+			});
+			const tmp = `${this.#file}.${process.pid}.tmp`;
+			await writeFile(tmp, JSON.stringify(next), { mode: 384 });
+			await rename(tmp, this.#file);
+			this.#kept = next;
+		};
+		const turn = this.#writing.then(run, run);
+		this.#writing = turn.catch(() => void 0);
+		await turn;
+	}
+	/** The key to use for `provider`: the one saved here, else the provider's own variable in the environment. */
+	async key(provider) {
+		const kept = (await this.#load()).keys[provider];
+		if (kept) return kept;
+		const env = PROVIDERS.find((p) => p.id === provider)?.env;
+		return env && this.#env[env] || void 0;
+	}
+	/** Where each provider's key comes from, never the key. */
+	async sources() {
+		const kept = (await this.#load()).keys;
+		return Object.fromEntries(PROVIDERS.map((p) => [p.id, kept[p.id] ? "saved" : this.#env[p.env] ? "environment" : null]));
+	}
+	async set(provider, key) {
+		if (!PROVIDERS.some((p) => p.id === provider)) throw new Error(`"${provider}" is not a provider isorite offers`);
+		const k = key.trim();
+		if (!k || k.length > 1e3 || /\s/.test(k)) throw new Error("that does not look like a key (it is empty, has spaces, or is very long)");
+		const now = await this.#load();
+		await this.#save({
+			...now,
+			keys: {
+				...now.keys,
+				[provider]: k
+			}
+		});
+	}
+	async remove(provider) {
+		const now = await this.#load();
+		if (!(provider in now.keys)) return;
+		const { [provider]: _gone, ...keys } = now.keys;
+		await this.#save({
+			...now,
+			keys
+		});
+	}
+	/** What was chosen in the settings, else the default. Anything else in the file is not believed. */
+	async reach() {
+		const r = (await this.#load()).reach;
+		return r && [
+			"off",
+			"read",
+			"write"
+		].includes(r.files) && typeof r.shell === "boolean" ? {
+			files: r.files,
+			shell: r.shell
+		} : { ...DEFAULT_REACH };
+	}
+	async setReach(reach) {
+		if (![
+			"off",
+			"read",
+			"write"
+		].includes(reach.files) || typeof reach.shell !== "boolean") throw new Error("files is off, read or write; shell is on or off");
+		const now = await this.#load();
+		await this.#save({
+			...now,
+			reach: {
+				files: reach.files,
+				shell: reach.shell
+			}
+		});
+	}
+	async choice() {
+		return (await this.#load()).choice ?? null;
+	}
+	async choose(provider, model) {
+		if (!PROVIDERS.some((p) => p.id === provider) || !ID.test(provider)) throw new Error(`"${provider}" is not a provider isorite offers`);
+		if (!model.trim() || model.length > 200) throw new Error("a model is needed");
+		const now = await this.#load();
+		await this.#save({
+			...now,
+			choice: {
+				provider,
+				model: model.trim()
+			}
+		});
+	}
+};
+//#endregion
+//#region packages/server/src/pi/index.ts
+const camel = (s) => s.replace(/-([a-z0-9])/g, (_, c) => c.toUpperCase());
+/** The model `provider/model` and the way to reach it. Throws (naming what is wrong) where pi has no such provider or model. */
+async function modelFor(provider, model) {
+	if (!provider || !model || !/^[a-z0-9-]+$/.test(provider)) throw new Error(`a model is <provider>/<model>, as anthropic/claude-sonnet-4-6; it was "${provider}/${model}"`);
+	let make;
+	try {
+		make = (await import(`@earendil-works/pi-ai/providers/${provider}`))[`${camel(provider)}Provider`];
+	} catch {}
+	if (typeof make !== "function") throw new Error(`pi has no provider "${provider}"`);
+	const models = createModels();
+	models.setProvider(make());
+	const chosen = models.getModel(provider, model);
+	if (!chosen) throw new Error(`pi's ${provider} has no model "${model}"`);
+	return {
+		chosen,
+		streamFn: models.streamSimple.bind(models)
+	};
+}
+/** The model named by ISORITE_PI, else the one chosen in the settings; null where there is none. */
+async function wanted(env, creds) {
+	const named = env.ISORITE_PI?.trim();
+	if (named) {
+		const [provider, ...rest] = named.split("/");
+		if (!provider || !rest.length) throw new Error(`ISORITE_PI is <provider>/<model>, as anthropic/claude-sonnet-4-6; it was "${named}"`);
+		return {
+			choice: {
+				provider,
+				model: rest.join("/")
+			},
+			source: "environment"
+		};
+	}
+	const saved = await creds.choice();
+	return saved ? {
+		choice: saved,
+		source: "settings"
+	} : null;
+}
+/** What the settings read and change: which model the native agent uses and where its key comes from, for the
+*  hosts running (one for each base). It never hands out a key. */
+var PiControl = class {
+	creds;
+	#env;
+	#hosts = /* @__PURE__ */ new Set();
+	constructor(env = process.env, creds = new Credentials(env)) {
+		this.#env = env;
+		this.creds = creds;
+	}
+	/** What the agent may reach now, read synchronously where a prompt starts. Loaded by `load`. */
+	reach = { ...DEFAULT_REACH };
+	/** True where the environment (ISORITE_PI_FILES, ISORITE_PI_SHELL) sets it, and so wins. */
+	reachFromEnvironment = false;
+	async load() {
+		const files = this.#env.ISORITE_PI_FILES?.trim(), shell = this.#env.ISORITE_PI_SHELL?.trim();
+		if (files !== void 0 && files !== "" && ![
+			"off",
+			"read",
+			"write"
+		].includes(files)) throw new Error(`ISORITE_PI_FILES is off, read or write; it was "${files}"`);
+		this.reachFromEnvironment = Boolean(files) || shell !== void 0 && shell !== "";
+		const saved = await this.creds.reach();
+		this.reach = {
+			files: files || saved.files,
+			shell: shell ? [
+				"1",
+				"true",
+				"on"
+			].includes(shell) : saved.shell
+		};
+	}
+	async setReach(reach) {
+		await this.creds.setReach(reach);
+		if (!this.reachFromEnvironment) this.reach = { ...reach };
+	}
+	attach(host) {
+		this.#hosts.add(host);
+	}
+	async state() {
+		await this.load().catch(() => void 0);
+		const want = await wanted(this.#env, this.creds).catch(() => null);
+		return {
+			/** True where the pane of this base is the native agent's now. */
+			active: this.#hosts.size > 0,
+			choice: want?.choice ?? null,
+			/** Where the choice is made: the environment wins over the settings while it is set. */
+			source: want?.source ?? null,
+			providers: PROVIDERS.map((p) => ({
+				id: p.id,
+				name: p.name,
+				env: p.env
+			})),
+			keys: await this.creds.sources(),
+			reach: this.reach,
+			reachFromEnvironment: this.reachFromEnvironment
+		};
+	}
+	async choose(provider, model) {
+		const { chosen, streamFn } = await modelFor(provider, model.trim());
+		await this.creds.choose(provider, chosen.id);
+		if (!this.#env.ISORITE_PI?.trim()) for (const h of this.#hosts) h.use(chosen, streamFn, `pi (${chosen.id})`);
+	}
+};
+/** The pi host for `api`, or null where pi is not chosen. Throws (naming what is wrong) where it is chosen and cannot be had. */
+async function piHostFor(api, env = process.env, project = process.cwd(), notes = project, control = new PiControl(env)) {
+	const want = await wanted(env, control.creds);
+	if (!want) return null;
+	const { provider, model } = want.choice;
+	const { chosen, streamFn } = await modelFor(provider, model);
+	await control.load();
+	const asked = new Set((env.ISORITE_PI_ASK ?? "").split(",").map((t) => t.trim()).filter(Boolean));
+	const host = new PiHost({
+		api,
+		store: new FileStore(storeDir(notes, env)),
+		model: chosen,
+		streamFn,
+		name: `pi (${model})`,
+		getApiKey: (p) => control.creds.key(p),
+		...asked.size ? { ask: (tool) => asked.has(tool) } : {},
+		more: () => fileTools(project, control.reach),
+		guard: pathGuard(project)
+	});
+	await host.resume();
+	control.attach(host);
+	return host;
+}
+//#endregion
 //#region packages/server/src/nodefiles.ts
 const gone = (e) => ["ENOENT", "ENOTDIR"].includes(e.code ?? "");
 var NodeFiles = class {
@@ -8124,6 +9613,7 @@ async function openServer(path, { host = "127.0.0.1", port = 4767, allowHosts =
 	const embedder = model ? nodeEmbedder(model) : null;
 	const token = randomBytes(24).toString("base64url"), loopback = LOOPBACK.has(host);
 	const web = existsSync(join(WEB_DIR, "index.html")) ? WEB_DIR : null;
+	const pi = new PiControl();
 	const bases = new Bases({
 		config,
 		first,
@@ -8138,6 +9628,7 @@ async function openServer(path, { host = "127.0.0.1", port = 4767, allowHosts =
 				api,
 				notes: known.path
 			});
+			const terminal = await piHostFor(api, process.env, projectOf(known.path).repo, known.path, pi);
 			const agents = new AgentRunner({
 				base: known.name,
 				url: `http://127.0.0.1:${port}${known.name === first ? "" : `/b/${known.name}`}`,
@@ -8155,6 +9646,8 @@ async function openServer(path, { host = "127.0.0.1", port = 4767, allowHosts =
 					allowHosts,
 					notes: known.path,
 					acp,
+					...terminal ? { terminal } : {},
+					...loopback ? { pi } : {},
 					bases,
 					base: known.name,
 					...loopback ? { agents } : {},
@@ -8646,13 +10139,17 @@ async function acp(path, { agent, port = 4767, input, output, env = process.env,
 	const given = /* @__PURE__ */ new Map();
 	const withGiven = (session, prompt) => {
 		const blocks = Array.isArray(prompt) ? prompt : [];
-		const text = given.get(session);
-		if (!text) return blocks;
+		const g = given.get(session);
+		if (!g) return blocks;
 		given.delete(session);
-		return [{
-			type: "text",
-			text
-		}, ...blocks];
+		return [
+			{
+				type: "text",
+				text: g.text
+			},
+			...g.blocks ?? [],
+			...blocks
+		];
 	};
 	let batch = [];
 	let flushing = null;
@@ -8942,8 +10439,18 @@ async function acp(path, { agent, port = 4767, input, output, env = process.env,
 			});
 			sendWaiting();
 		}
+		if (c.type === "steer") ask("_session/steering", {
+			sessionId: c.session,
+			prompt: [{
+				type: "text",
+				text: c.text
+			}]
+		});
 		if (c.type === "give") {
-			if (c.text) given.set(c.session, c.text);
+			if (c.text) given.set(c.session, {
+				text: c.text,
+				...c.blocks?.length ? { blocks: c.blocks } : {}
+			});
 			else given.delete(c.session);
 		}
 		if (c.type === "cancel") {
@@ -8968,11 +10475,15 @@ async function acp(path, { agent, port = 4767, input, output, env = process.env,
 				cwd,
 				mcpServers: [isoriteMcp()]
 			};
-			if (!c.session) ask("session/new", params, c.then, c.give);
+			const give = c.give ? {
+				text: c.give,
+				...c.giveBlocks?.length ? { blocks: c.giveBlocks } : {}
+			} : void 0;
+			if (!c.session) ask("session/new", params, c.then, give);
 			else ask(can.load ? "session/load" : "session/resume", {
 				...params,
 				sessionId: c.session
-			}, c.then, c.give);
+			}, c.then, give);
 		}
 		if (c.type === "permission" && agentAsked.has(c.id)) {
 			const id = agentAsked.get(c.id);
@@ -9001,7 +10512,8 @@ async function acp(path, { agent, port = 4767, input, output, env = process.env,
 				readTextFile: false,
 				writeTextFile: false
 			},
-			terminal: false
+			terminal: false,
+			subagents: {}
 		},
 		clientInfo: {
 			name: "isorite",
@@ -10251,7 +11763,7 @@ function main(argv) {
 		if (command === "check" && rest.find((r) => !r.startsWith("--"))) return check(rest.find((r) => !r.startsWith("--")), console.log, rest.includes("--unused"), rest.includes("--fix"));
 		if (command === "new" && rest[0]) {
 			const made = newBase(rest[0]);
-			const next = `${made}: a knowledge base, empty. Open it in the browser, and attach your agent from Iso's pane:\n  isorite serve ${made}`;
+			const next = `${made}: a knowledge base, empty. Open it in the browser, and attach your agent from the Agent pane:\n  isorite serve ${made}`;
 			if (process.stdin.isTTY && process.stdout.isTTY && repoOf(made)) return (async () => {
 				const { createInterface } = await import("node:readline/promises");
 				const rl = createInterface({
@@ -10301,7 +11813,7 @@ function main(argv) {
 			});
 		}
 		if (command === "term" || command === "opencode") {
-			console.error("isorite term and isorite opencode are retired: attach OpenCode as any agent, from Iso's pane or with isorite acp --agent \"opencode acp\", or give it isorite's MCP (isorite doctor offers the project's config)");
+			console.error("isorite term and isorite opencode are retired: attach OpenCode as any agent, from the Agent pane or with isorite acp --agent \"opencode acp\", or give it isorite's MCP (isorite doctor offers the project's config)");
 			return 2;
 		}
 		if (command === "mcp") {