isorite 0.13.0 → 0.15.0

package/dist/main.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { chmodSync, closeSync, copyFileSync, existsSync, mkdirSync, mkdtempSync, openSync, readFileSync, readSync, readdirSync, realpathSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
-import { basename, dirname, extname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { basename, delimiter, dirname, extname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { Document, Scalar, isMap, isScalar, isSeq, parseDocument, stringify } from "yaml";
 import MarkdownIt from "markdown-it";
@@ -18,6 +18,7 @@ import { z } from "zod";
 import { appendFile, mkdir, readFile, readdir, rename, rm, stat, writeFile } from "node:fs/promises";
 import { createInterface } from "node:readline";
 import { PassThrough } from "node:stream";
+import { createServer } from "node:net";
 //#region \0rolldown/runtime.js
 var __defProp = Object.defineProperty;
 var __esmMin = (fn, res, err) => () => {
@@ -2276,7 +2277,8 @@ function knownBases(config = configPath()) {
 		return BASE_NAME.test(name) && typeof row.path === "string" && row.path ? [{
 			name,
 			path: expand(row.path),
-			lend: row.lend === true
+			lend: row.lend === true,
+			...typeof row.used === "string" ? { used: row.used } : {}
 		}] : [];
 	});
 }
@@ -2286,6 +2288,16 @@ function baseName(folder) {
 }
 /** The base at `folder` by its name in the configuration, listed first if it is not: under its folder's name, or
 *  that name with -2, -3… where another folder has it. `as` names it, and `lend` lends it. */
+/** A base opened now: when it was last used is kept (`used`), for `isorite` to list the bases last used first. */
+function touchBase(folder, { path = configPath(), now = /* @__PURE__ */ new Date() } = {}) {
+	const at = resolve(folder), bases = readConfig(basesPath(path)), name = knownBases(path).find((b) => b.path === at)?.name;
+	if (!name) return;
+	bases[name] = {
+		...table(bases[name]),
+		used: now.toISOString()
+	};
+	writeConfig(bases, basesPath(path));
+}
 function rememberBase(folder, { path = configPath(), as, lend } = {}) {
 	const at = resolve(folder), had = knownBases(path).find((b) => b.path === at);
 	if (had && lend === void 0) return had.name;
@@ -2853,7 +2865,7 @@ var Conflict = class extends EngineError {
 };
 //#endregion
 //#region packages/engine/src/lookup.ts
-const str$1 = { type: "string" };
+const str$2 = { type: "string" };
 const fn$1 = (name, description, properties, required) => ({
 	type: "function",
 	function: {
@@ -2869,9 +2881,9 @@ const fn$1 = (name, description, properties, required) => ({
 });
 const TOOLS = [
 	fn$1("search_notes", "Keyword search over the knowledge base. Returns note ids, titles, types, one-sentence descriptions and a one-line snippet. Search by the words a note would use.", {
-		query: str$1,
+		query: str$2,
 		under: {
-			...str$1,
+			...str$2,
 			description: "Only notes in this folder."
 		},
 		limit: {
@@ -2880,24 +2892,24 @@ const TOOLS = [
 		}
 	}, ["query"]),
 	fn$1("outline_note", "A note's description, its headings, the notes it links to and the notes that link to it, without its body. Use it to choose a section to read.", { id: {
-		...str$1,
+		...str$2,
 		description: "The note's id or path: basics/entropy or /basics/entropy.md."
 	} }, ["id"]),
 	fn$1("read_note", "Read one section of a note, by its heading, or the whole note when no section is named. Prefer a section. A picture in it is ![what it shows](path): you have its words, not the picture.", {
-		id: str$1,
+		id: str$2,
 		section: {
-			...str$1,
+			...str$2,
 			description: "A heading's text, as outline_note gives it."
 		}
 	}, ["id"])
 ];
 const FIND_SIMILAR = fn$1("find_similar", "Find notes by meaning: notes that say something like the text you give, even in quite other words. Slower and vaguer than search_notes: use it after search_notes and the links of the notes in hand have not found what you need, or when you cannot guess the words a note would use. Give a question or a sentence, not keywords. Returns each note's nearest section, with how alike it is (0 to 1).", {
 	text: {
-		...str$1,
+		...str$2,
 		description: "A question, or a sentence saying what you are looking for."
 	},
 	under: {
-		...str$1,
+		...str$2,
 		description: "Only notes in this folder."
 	},
 	limit: {
@@ -3267,7 +3279,7 @@ or try; not for what an answer or a note says as well.
    problem, fix that and write the whole file again.
 4. Say in a sentence what it shows, linked: [what it shows](/folder/name.html).
    Link it from the note it belongs to if they want it there.`;
-const str = { type: "string" };
+const str$1 = { type: "string" };
 const fn = (name, description, properties, required) => ({
 	type: "function",
 	function: {
@@ -3283,16 +3295,16 @@ const fn = (name, description, properties, required) => ({
 });
 const ASK_QUESTION = fn("ask_question", "Ask them a question back, kept as an open question in their base, about one or more of their notes.", {
 	title: {
-		...str,
+		...str$1,
 		description: "The question, short, ending in a question mark."
 	},
 	text: {
-		...str,
+		...str$1,
 		description: "A line or two on what is asked, or empty."
 	},
 	about: {
 		type: "array",
-		items: str,
+		items: str$1,
 		description: "The ids of the notes it is about."
 	}
 }, [
@@ -3301,7 +3313,7 @@ const ASK_QUESTION = fn("ask_question", "Ask them a question back, kept as an op
 	"about"
 ]);
 const READ_DATA = fn("read_data", "A data file's shape: its columns with their types and ranges, the row count and the first rows. Read it before writing anything that uses the file, so the column names are real.", { path: {
-	...str,
+	...str$1,
 	description: "The file's path in the base: folder/name.csv."
 } }, ["path"]);
 const ARTIFACT_RECIPE = fn("artifact_recipe", "A recipe for an artifact: a complete working one to start from, the kit's reference, and the rules write_artifact checks. dashboard: numbers, charts and a table of one data file. compare: two data files side by side. simulation: a model with parameters and play. explorable: inputs, derived numbers and linked views. viewer: a 3D model.", { name: {
@@ -3316,21 +3328,21 @@ const ARTIFACT_RECIPE = fn("artifact_recipe", "A recipe for an artifact: a compl
 } }, ["name"]);
 const WRITE_ARTIFACT = fn("write_artifact", "Write an artifact: a whole HTML file on the kit. The title, description and uses given here are written into it. It is checked, and run where it can be; the result says what to fix. Nothing is written while a rule is broken.", {
 	path: {
-		...str,
+		...str$1,
 		description: "Where: folder/name.html, beside the notes it belongs to."
 	},
-	title: str,
+	title: str$1,
 	description: {
-		...str,
+		...str$1,
 		description: "One sentence: what it shows, and what can be done with it."
 	},
 	uses: {
 		type: "array",
-		items: str,
+		items: str$1,
 		description: "The data or model files it reads, relative to it (runs.csv). Those its markup and script name are added."
 	},
 	html: {
-		...str,
+		...str$1,
 		description: "The whole file."
 	}
 }, [
@@ -3341,16 +3353,16 @@ const WRITE_ARTIFACT = fn("write_artifact", "Write an artifact: a whole HTML fil
 	"html"
 ]);
 const READ_ARTIFACT = fn("read_artifact", "An artifact's whole file, to change it and write it again.", { path: {
-	...str,
+	...str$1,
 	description: "folder/name.html"
 } }, ["path"]);
 const OFFER_TEXT = fn("offer_text", "Offer them their own answers, lightly joined, to insert at the end of a note as their writing. Only their words.", {
 	id: {
-		...str,
+		...str$1,
 		description: "The note's id, or AGENTS.md for a line of their instructions for the base."
 	},
 	text: {
-		...str,
+		...str$1,
 		description: "The passage, in Markdown."
 	}
 }, ["id", "text"]);
@@ -4220,6 +4232,10 @@ var Engine = class Engine {
 			return null;
 		}
 	}
+	async deleteAgentRecord(agent, session) {
+		if (!AGENT_ID.test(agent) || !session || session.length > 200) throw new EngineError("an agent's session is named by the agent and its session's id");
+		await this.opts.own.remove(agentRecordPath(agent, session));
+	}
 	async agentRecords() {
 		const own = this.opts.own, all = [];
 		for (const a of await own.list(AGENTS_DIR).catch(() => [])) {
@@ -4636,6 +4652,10 @@ var Engine = class Engine {
 			turns: readTurns(text)
 		};
 	}
+	async deleteConversation(id) {
+		if (!TURN_ID.test(id)) throw new EngineError("not a conversation's id");
+		await this.opts.own.remove(conversationPath(id));
+	}
 	async conversations() {
 		const study = this.opts.own;
 		const names = await study.list(CONVERSATIONS_DIR).catch(() => []);
@@ -5102,7 +5122,7 @@ var Bases = class {
 	}
 };
 /** The revisions answered, newest first: a client asking for one of these gets it. */
-const KNOWN = [
+const KNOWN$1 = [
 	"2026-07-28",
 	"2025-11-25",
 	"2025-06-18",
@@ -5160,13 +5180,13 @@ var McpEndpoint = class {
 		const p = rpc.params ?? {};
 		switch (rpc.method) {
 			case "initialize": return {
-				protocolVersion: typeof p.protocolVersion === "string" && KNOWN.includes(p.protocolVersion) ? p.protocolVersion : KNOWN[1],
+				protocolVersion: typeof p.protocolVersion === "string" && KNOWN$1.includes(p.protocolVersion) ? p.protocolVersion : KNOWN$1[1],
 				capabilities: this.#capabilities(),
 				serverInfo: this.#info(),
 				instructions: INSTRUCTIONS
 			};
 			case "server/discover": return {
-				supportedVersions: KNOWN,
+				supportedVersions: KNOWN$1,
 				capabilities: this.#capabilities(),
 				serverInfo: this.#info(),
 				instructions: INSTRUCTIONS
@@ -5308,6 +5328,47 @@ const EMPTY = {
 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 lines = (v) => v ? v.replace(/\n$/, "").split("\n") : [];
 const keyOf = (agent, session) => `${agent}\u0000${session}`;
+const str = (v) => typeof v === "string" ? v : "";
+/** The agent's slash commands, from available_commands_update. */
+const commandsOf = (v) => (Array.isArray(v) ? v : []).filter((c) => str(c.name)).map((c) => {
+	const hint = str(c.input?.hint);
+	return {
+		name: str(c.name).replace(/^\//, ""),
+		description: str(c.description),
+		...hint ? { hint } : {}
+	};
+});
+/** The agent's modes, from a session's answer or a current_mode_update. */
+const modesOf = (v) => {
+	const m = v;
+	const options = (m?.availableModes ?? []).filter((o) => str(o.id)).map((o) => ({
+		value: str(o.id),
+		name: str(o.name) || str(o.id),
+		...str(o.description) ? { description: str(o.description) } : {}
+	}));
+	return options.length ? {
+		kind: "mode",
+		id: "mode",
+		name: "Mode",
+		current: str(m?.currentModeId),
+		options
+	} : null;
+};
+/** The agent's options (the model, say), whose choices may be grouped. */
+const configsOf = (v) => (Array.isArray(v) ? v : []).filter((o) => str(o.id) && Array.isArray(o.options)).flatMap((o) => {
+	const options = o.options.flatMap((x) => Array.isArray(x.options) ? x.options : [x]).filter((x) => str(x.value)).map((x) => ({
+		value: str(x.value),
+		name: str(x.name) || str(x.value),
+		...str(x.description) ? { description: str(x.description) } : {}
+	}));
+	return options.length ? [{
+		kind: "config",
+		id: str(o.id),
+		name: str(o.name) || str(o.id),
+		current: str(o.currentValue),
+		options
+	}] : [];
+});
 /** The sessions the wrappers carry, as the pane draws them. One is shown: the one you chose, else the last to start. */
 var AcpFollower = class {
 	#links = /* @__PURE__ */ new Map();
@@ -5390,6 +5451,8 @@ var AcpFollower = class {
 			size: live.size,
 			ours: this.#ours,
 			sessions: this.#sessions(),
+			commands: live.commands,
+			settings: [...live.modes ? [live.modes] : [], ...live.configs],
 			...problem
 		};
 		else if (read) this.#view = {
@@ -5623,6 +5686,42 @@ var AcpFollower = class {
 		link.opening = "";
 		link.send({ type: "open" });
 	}
+	/** Set a mode or option of the session shown (the agent's own: its model, its plan mode). Optimistic: the agent's
+	*  answer or update settles it. */
+	set(kind, id, value) {
+		const live = this.#need();
+		const setting = kind === "mode" ? live.modes : live.configs.find((c) => c.id === id);
+		if (!setting || !setting.options.some((o) => o.value === value)) throw new Error(`${live.link.name || "The agent"} offers no such choice`);
+		if (kind === "mode") live.modes = {
+			...setting,
+			current: value
+		};
+		else live.configs = live.configs.map((c) => c.id === id ? {
+			...c,
+			current: value
+		} : c);
+		live.link.send({
+			type: "set",
+			session: live.session,
+			kind,
+			id,
+			value
+		});
+		this.#tell();
+	}
+	/** Remove what isorite kept of a session that is not live. What the agent keeps of its own is not touched. */
+	async forget(agent, session) {
+		const key = keyOf(agent, session);
+		if (this.#lives.has(key)) throw new Error("that session is live: stop it before removing what is kept of it");
+		if (!this.#api?.deleteAgentRecord) throw new Error("nothing is kept here");
+		await this.#api.deleteAgentRecord(agent, session);
+		if (this.#shown === key) {
+			this.#shown = null;
+			this.#chosen = false;
+			this.#reading = null;
+		}
+		await this.#readKept();
+	}
 	/** Ask the attached agents for their sessions again: the drawer is being looked at. */
 	refresh() {
 		for (const link of this.#links.values()) if (link.can.list) link.send({ type: "list" });
@@ -5701,7 +5800,11 @@ var AcpFollower = class {
 					break;
 				}
 				case "session/new":
-					if (typeof m.result?.sessionId === "string") this.#open(link, m.result.sessionId, key.startsWith("isorite-") ? "ours" : "in", typeof params.cwd === "string" ? params.cwd : "");
+					if (typeof m.result?.sessionId === "string") {
+						const opened = this.#open(link, m.result.sessionId, key.startsWith("isorite-") ? "ours" : "in", typeof params.cwd === "string" ? params.cwd : "");
+						opened.modes = modesOf(m.result.modes);
+						opened.configs = configsOf(m.result.configOptions);
+					}
 					break;
 				case "session/load":
 				case "session/resume":
@@ -5710,9 +5813,20 @@ var AcpFollower = class {
 							this.#lives.delete(keyOf(link.agent, live.session));
 							break;
 						}
+						if (m.result?.modes) live.modes = modesOf(m.result.modes);
+						if (m.result?.configOptions) live.configs = configsOf(m.result.configOptions);
 						this.#loaded(live);
 					}
 					break;
+				case "session/set_mode":
+					if (live && !m.error && live.modes) live.modes = {
+						...live.modes,
+						current: str(params.modeId)
+					};
+					break;
+				case "session/set_config_option":
+					if (live && !m.error && m.result?.configOptions) live.configs = configsOf(m.result.configOptions);
+					break;
 				case "session/prompt":
 					if (live) {
 						const stop = m.error ? "failed" : m.result?.stopReason === "cancelled" ? "stopped" : m.result?.stopReason === "end_turn" ? "done" : "failed";
@@ -5776,7 +5890,10 @@ var AcpFollower = class {
 			loading: false,
 			replaying: false,
 			pending: null,
-			given: /* @__PURE__ */ new Set()
+			given: /* @__PURE__ */ new Set(),
+			commands: [],
+			modes: null,
+			configs: []
 		};
 		live.link = link;
 		if (cwd) live.cwd = cwd;
@@ -5966,7 +6083,19 @@ var AcpFollower = class {
 				if (typeof cost === "number") live.cost = cost;
 				break;
 			}
-			case "session_info_update": if (typeof u.title === "string") live.title = u.title;
+			case "session_info_update":
+				if (typeof u.title === "string") live.title = u.title;
+				break;
+			case "available_commands_update":
+				live.commands = commandsOf(u.availableCommands);
+				break;
+			case "current_mode_update":
+				if (live.modes && typeof u.currentModeId === "string") live.modes = {
+					...live.modes,
+					current: u.currentModeId
+				};
+				break;
+			case "config_option_update": live.configs = configsOf(u.configOptions);
 		}
 	}
 	/** The note a path names, if it is a Markdown file of the base (relative paths read from the session's folder). */
@@ -6026,7 +6155,7 @@ var AcpFollower = class {
 };
 //#endregion
 //#region packages/server/src/version.ts
-const VERSION = "0.13.0";
+const VERSION = "0.15.0";
 //#endregion
 //#region packages/server/src/connect.ts
 const HARNESSES = [{
@@ -6224,6 +6353,108 @@ async function tokenOf(url) {
 	return (await (await fetch(`${url}/api/session`)).json()).token;
 }
 //#endregion
+//#region packages/server/src/detect.ts
+const KNOWN = [
+	{
+		id: "claude",
+		name: "Claude Code",
+		bin: "claude",
+		command: "npx -y @agentclientprotocol/claude-agent-acp",
+		needs: "npx",
+		keys: ["ANTHROPIC_API_KEY"],
+		signedIn: true
+	},
+	{
+		id: "codex",
+		name: "Codex",
+		bin: "codex",
+		command: "npx -y @agentclientprotocol/codex-acp",
+		needs: "npx",
+		keys: ["CODEX_API_KEY", "OPENAI_API_KEY"]
+	},
+	{
+		id: "opencode",
+		name: "OpenCode",
+		bin: "opencode",
+		command: "opencode acp",
+		keys: []
+	},
+	{
+		id: "omp",
+		name: "omp",
+		bin: "omp",
+		command: "omp acp",
+		keys: []
+	},
+	{
+		id: "hermes",
+		name: "Hermes",
+		bin: "hermes",
+		command: "hermes acp",
+		keys: []
+	}
+];
+/** The first file called `name` on PATH (with the extensions Windows tries), or null. */
+function onPath(name, env = process.env) {
+	const exts = process.platform === "win32" ? ["", ...(env.PATHEXT ?? ".EXE;.CMD;.BAT").split(";")] : [""];
+	for (const dir of (env.PATH ?? "").split(delimiter).filter(Boolean)) for (const ext of exts) {
+		const file = join(dir, name + ext);
+		try {
+			if (existsSync(file) && statSync(file).isFile()) return file;
+		} catch {}
+	}
+	return null;
+}
+function detectAgents(env = process.env) {
+	return KNOWN.flatMap((k) => {
+		const path = onPath(k.bin, env);
+		if (!path) return [];
+		const keySet = k.keys.some((v) => Boolean(env[v]));
+		const ready = !k.needs || onPath(k.needs, env) !== null;
+		const parts = [`${k.name} is installed`];
+		if (!ready) parts.push(`but it needs ${k.needs}, which isn't on PATH`);
+		else if (k.keys.length && keySet) parts.push(`and ${k.keys.find((v) => env[v])} is set here`);
+		else if (k.keys.length) parts.push(k.signedIn ? `; ${k.keys[0]} isn't set here, which is fine if you've signed in with it` : `, but ${k.keys.join(" or ")} isn't set in the terminal isorite was started from`);
+		return [{
+			id: k.id,
+			name: k.name,
+			command: k.command,
+			path,
+			keys: k.keys,
+			keySet,
+			ready,
+			note: parts.join(" ").replace(" ;", ";").replace(" ,", ",") + "."
+		}];
+	});
+}
+function listAgents(env = process.env) {
+	const found = detectAgents(env).map((d) => ({
+		...d,
+		found: true
+	}));
+	const have = new Set(found.map((d) => d.id));
+	const rest = KNOWN.filter((k) => !have.has(k.id)).map((k) => ({
+		id: k.id,
+		name: k.name,
+		command: k.command,
+		path: "",
+		keys: k.keys,
+		keySet: false,
+		ready: false,
+		found: false,
+		note: `${k.name} isn't on this machine's PATH.`
+	}));
+	return [...found, ...rest];
+}
+/** The ACP command of an agent known by name (`isorite acp omp`), or null. */
+const knownCommand = (id) => KNOWN.find((k) => k.id === id)?.command ?? null;
+/** Why an agent that stopped may have: the key it reads isn't set where isorite was started, for the command run. */
+function missingKey(command, env = process.env) {
+	const k = KNOWN.find((x) => x.command === command);
+	if (!k || !k.keys.length || k.keys.some((v) => env[v])) return "";
+	return `${k.keys.join(" or ")} is not set in the terminal isorite was started from. Set it there (export ${k.keys[0]}=…) and start isorite again${k.signedIn ? ", or sign in with `claude` first" : ""}.`;
+}
+//#endregion
 //#region packages/server/src/agents.ts
 init_self();
 const FRESH = 36e5;
@@ -6394,12 +6625,14 @@ var AgentRunner = class {
 		process.once("exit", () => this.#child?.kill());
 	}
 	state() {
+		const hint = this.#problem && this.#command ? missingKey(this.#command, this.#env) : "";
 		return {
 			choice: chosenAgent(this.#base, this.#config),
 			running: this.#child !== null,
 			command: this.#command,
 			problem: this.#problem,
-			said: this.#said
+			said: this.#said,
+			hint
 		};
 	}
 	/** Kept, and started in place of the one running; with none, the one running is stopped. */
@@ -6468,6 +6701,108 @@ var AgentRunner = class {
 	}
 };
 //#endregion
+//#region packages/server/src/own-repo.ts
+const q = (s) => /^[\w@%+=:,./-]+$/.test(s) ? s : `"${s.replace(/(["\\$`])/g, "\\$1")}"`;
+const slashes = (p) => p.split("\\").join("/");
+function git(cwd, args, env) {
+	return execFileSync("git", args, {
+		cwd,
+		env: plainGitEnv(env),
+		timeout: 1e4,
+		killSignal: "SIGKILL",
+		encoding: "utf8",
+		stdio: [
+			"ignore",
+			"pipe",
+			"pipe"
+		]
+	});
+}
+/** What this machine chose for a base, from bases.toml. */
+function historyChoice(base, config) {
+	const v = table(readConfig(basesPath(config))[base]).history;
+	return v === "project" || v === "separate" ? v : null;
+}
+function setHistoryChoice(base, choice, config) {
+	const bases = readConfig(basesPath(config));
+	if (!bases[base]) throw new Error(`${base} is not among the bases`);
+	bases[base] = {
+		...table(bases[base]),
+		history: choice
+	};
+	writeConfig(bases, basesPath(config));
+}
+/** Where isorite's own folder is kept, and the commands for the person to run. Runs `git ls-files`, `remote` and
+*  `rev-parse`, which only read. */
+function ownRepoInfo(own, choice = null, env = process.env) {
+	const project = repoOf(dirname(own));
+	const base = {
+		state: "none",
+		path: own,
+		project,
+		remotes: [],
+		choice,
+		ask: false,
+		commands: [],
+		problem: ""
+	};
+	try {
+		if (existsSync(join(own, ".git"))) {
+			const remotes = git(own, ["remote"], env).split("\n").filter(Boolean);
+			return {
+				...base,
+				state: "own",
+				remotes,
+				commands: remotes.length ? [`git -C ${q(own)} push`] : [`git -C ${q(own)} remote add origin <the address of your private repository>`, `git -C ${q(own)} push -u origin HEAD`]
+			};
+		}
+		if (!project) return base;
+		const rel = slashes(relative(project, own));
+		const tracked = git(project, [
+			"ls-files",
+			"--",
+			rel
+		], env).trim() !== "";
+		const path = git(project, [
+			"rev-parse",
+			"--git-path",
+			"info/exclude"
+		], env).trim();
+		const exclude = isAbsolute(path) ? path : resolve(project, path);
+		const apart = [
+			`git -C ${q(own)} init`,
+			`echo ${q(rel + "/")} >> ${q(exclude)}`,
+			`git -C ${q(own)} add -A`,
+			`git -C ${q(own)} commit -m "isorite: start"`
+		];
+		return {
+			...base,
+			state: tracked ? "tracked" : "shared",
+			ask: choice === null,
+			commands: tracked ? [
+				`git -C ${q(project)} rm -r --cached ${q(rel)}`,
+				...apart,
+				`git -C ${q(project)} commit -m "stop tracking isorite's own files"`
+			] : apart
+		};
+	} catch (e) {
+		return {
+			...base,
+			state: "unavailable",
+			problem: e.message.split("\n")[0] ?? "git did not answer"
+		};
+	}
+}
+/** For a base just made in a git project: ask whether its own files stay with the project or apart, keep the answer
+*  for this machine, and say the commands for apart. Asks nothing outside a project. isorite runs none of it. */
+async function askWhereFilesLive(notes, ask, out, config, env = process.env) {
+	if (!repoOf(notes)) return null;
+	const choice = (await ask(`${notes} is in a git project. isorite's own files (.isorite/: journals, kept sessions, settings) can be committed with the project, or kept apart from it, so the people sharing it don't have them.\nKeep them [p]roject / [a]part? (p) `)).trim().toLowerCase().startsWith("a") ? "separate" : "project";
+	setHistoryChoice(rememberBase(notes, { path: config }), choice, config);
+	if (choice === "separate") out(`\nTo keep them apart, run these (isorite runs no git itself):\n${ownRepoInfo(join(notes, ".isorite"), "separate", env).commands.map((c) => `  ${c}`).join("\n")}\n`);
+	return choice;
+}
+//#endregion
 //#region packages/server/src/http.ts
 const LOOPBACK = /* @__PURE__ */ new Set([
 	"localhost",
@@ -6544,7 +6879,7 @@ 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 }) {
+function createApp({ api, token, loopback, web, allowHosts = [], notes, acp, bases, base, agents, config }) {
 	const app = new Hono();
 	const allowed = new Set([...allowHosts].map((h) => h.toLowerCase()));
 	const reply = (c, status, value) => c.body(JSON.stringify(value), status, {
@@ -6678,6 +7013,7 @@ function createApp({ api, token, loopback, web, allowHosts = [], notes, acp, bas
 	app.get("/api/agents/notes", (c) => answer(c, () => api.agentNotes()));
 	post("/api/agents/notes", z.object({ may: z.boolean() }).strict(), (_c, b) => api.setAgentNotes(b.may));
 	app.get("/api/conversations", (c) => answer(c, () => api.conversations()));
+	post("/api/conversation/delete", z.object({ id: z.string().max(64) }).strict(), (_c, b) => api.deleteConversation(b.id));
 	app.get("/api/conversation", (c) => answer(c, async () => await api.conversation(c.req.query("id") || void 0) ?? {
 		id: "",
 		turns: []
@@ -6756,6 +7092,16 @@ function createApp({ api, token, loopback, web, allowHosts = [], notes, acp, bas
 	}).strict(), (_c, b) => api.agentReceived(b.id, b.agent));
 	post("/api/agent/status", AgentStatus, (_c, b) => api.agentStatus(b.agent, b.session, b.busy));
 	post("/api/agent/take", z.object({ id: z.string().max(64) }).strict(), (_c, b) => api.agentTake(b.id));
+	if (notes) {
+		const configFile = config ?? configPath();
+		app.get("/api/own/repo", (c) => answer(c, async () => local(c) ? ownRepoInfo(join(notes, ".isorite"), base ? historyChoice(base, configFile) : null) : null));
+		post("/api/own/choose", z.object({ choice: z.enum(["project", "separate"]) }).strict(), async (c, b) => {
+			if (!local(c)) throw new EngineError("this is chosen only from this machine", 403);
+			if (!base) throw new EngineError("this base has no name here", 409);
+			setHistoryChoice(base, b.choice, configFile);
+			return ownRepoInfo(join(notes, ".isorite"), b.choice);
+		});
+	}
 	if (notes) {
 		app.get("/api/connect", (c) => answer(c, async () => proposal(notes)));
 		post("/api/connect", z.object({ files: z.array(z.string().max(200)).max(10).optional() }).strict(), async (c, b) => {
@@ -6765,6 +7111,10 @@ function createApp({ api, token, loopback, web, allowHosts = [], notes, acp, bas
 	}
 	if (agents) {
 		app.get("/api/acp/agent", (c) => answer(c, async () => agents.state()));
+		app.get("/api/acp/detected", (c) => answer(c, async () => {
+			if (!local(c)) throw new EngineError("agents are looked for only from this machine", 403);
+			return listAgents();
+		}));
 		app.get("/api/acp/registry", (c) => answer(c, async () => registryAgents().catch((e) => {
 			throw new EngineError(e.message, 502);
 		})));
@@ -6868,6 +7218,23 @@ function createApp({ api, token, loopback, web, allowHosts = [], notes, acp, bas
 		}).strict(), async (_c, b) => {
 			await acp.follow(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);
+		});
+		post("/api/acp/set", z.object({
+			kind: z.enum(["mode", "config"]),
+			id: z.string().max(100),
+			value: z.string().max(200)
+		}).strict(), async (_c, b) => {
+			try {
+				acp.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);
 		});
@@ -7321,6 +7688,7 @@ async function openServer(path, { host = "127.0.0.1", port = 4767, allowHosts =
 	const opened = locate(path);
 	const device = deviceId(config);
 	const first = rememberBase(opened.notes, { path: config });
+	touchBase(opened.notes, { path: config });
 	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;
@@ -7357,7 +7725,8 @@ async function openServer(path, { host = "127.0.0.1", port = 4767, allowHosts =
 					acp,
 					bases,
 					base: known.name,
-					...loopback ? { agents } : {}
+					...loopback ? { agents } : {},
+					config
 				}).fetch
 			};
 		}
@@ -7389,7 +7758,7 @@ async function serve$1(path, { host = "127.0.0.1", port = 4767, allowHosts = [],
 		process.exit(1);
 	});
 	console.log(`isorite: ${notes}`);
-	console.log(embedder ? "  search by meaning: on" : "  search by meaning: off (isorite model fetches its model)");
+	console.log(embedder ? "  search by meaning: on" : "  search by meaning: off (isorite model fetches its model, 53 MB)");
 	const lent = bases.lent().filter((l) => l.name !== bases.first).map((l) => l.name);
 	if (lent.length) console.log(`  lent to every session: ${lent.join(", ")} (isorite bases)`);
 	console.log(existsSync(join(WEB_DIR, "index.html")) ? `  ${link(`http://localhost:${port}/`)}` : `  the app is not built (npm run build); the engine alone is at http://localhost:${port}/api/`);
@@ -7509,6 +7878,13 @@ async function doctor(folder, o = {}) {
 		const { notes } = locate(folder);
 		const own = join(notes, OWN_DIR), settings = join(own, SETTINGS_FILE);
 		say("notes", "ok", existsSync(own) ? `${notes}, with its ${OWN_DIR}/` : `${notes}: its ${OWN_DIR}/ is made the first time it is opened`);
+		if (existsSync(notes) && statSync(notes).isDirectory()) {
+			const bundle = loadBundle(notes), issues = bundle.lint(), cycles = bundle.requiresCycles();
+			const errors = issues.filter((i) => i.level === "error");
+			say("links", errors.length ? "fail" : issues.length || cycles.length ? "warn" : "ok", `${bundle.concepts.size} notes; ${errors.length} errors, ${issues.length - errors.length} warnings, ${cycles.length} requires cycles${issues.length ? `: ${issues.slice(0, 3).map((i) => `${i.path}: ${i.message}`).join("; ")}${issues.length > 3 ? `; and ${issues.length - 3} more (isorite check ${notes})` : ""}` : ""}`);
+		}
+		const kept = ownRepoInfo(own, null, env);
+		if (existsSync(own)) say("history", kept.state === "own" ? "ok" : kept.state === "unavailable" ? "skip" : kept.state === "none" ? "skip" : "ok", kept.state === "own" ? `${OWN_DIR}/ is a repository of its own${kept.remotes.length ? `, remote ${kept.remotes.join(", ")}` : `; to keep it elsewhere: git -C ${own} remote add origin <address>`}` : kept.state === "tracked" ? `${OWN_DIR}/ is tracked by the project's repository, so everyone sharing it has isorite's files; to keep them apart, run:\n    ${kept.commands.join("\n    ")}` : kept.state === "shared" ? `${OWN_DIR}/ is in the project's folder, to be committed with it; to keep it apart, run:\n    ${kept.commands.join("\n    ")}` : kept.state === "unavailable" ? `${OWN_DIR}/: git did not answer (${kept.problem})` : `${OWN_DIR}/ is in no git repository`);
 		const repository = existsSync(settings) ? parseSettings(readFileSync(settings, "utf8")).repository : void 0;
 		const found = repoOf(notes);
 		if (!repository && found) say("repository", "ok", `${found}: code links point here`);
@@ -7749,7 +8125,7 @@ const OPENS = /* @__PURE__ */ new Set([
 	"session/resume",
 	"session/fork"
 ]);
-const SKIP = /* @__PURE__ */ new Set([
+const SKIP$1 = /* @__PURE__ */ new Set([
 	"node_modules",
 	".git",
 	OWN_DIR,
@@ -7760,7 +8136,7 @@ const SKIP = /* @__PURE__ */ new Set([
 ]);
 /** The base for a session started in `cwd`: the folder itself or one above it holding .isorite/, else the first
 *  below it, three levels down at most (a base inside the repository, as notes/); or none. */
-function findBase(cwd) {
+function findBase$1(cwd) {
 	for (let at = cwd;; at = dirname(at)) {
 		if (existsSync(join(at, ".isorite"))) return at;
 		if (dirname(at) === at) break;
@@ -7771,7 +8147,7 @@ function findBase(cwd) {
 		for (const dir of level) {
 			let names = [];
 			try {
-				names = readdirSync(dir, { withFileTypes: true }).filter((d) => d.isDirectory() && !SKIP.has(d.name) && !d.name.startsWith(".")).map((d) => d.name).sort();
+				names = readdirSync(dir, { withFileTypes: true }).filter((d) => d.isDirectory() && !SKIP$1.has(d.name) && !d.name.startsWith(".")).map((d) => d.name).sort();
 			} catch {
 				continue;
 			}
@@ -7793,7 +8169,7 @@ async function tokenWhenUp(url, wait = 6e4) {
 	}
 }
 async function acp(path, { agent, port = 4767, input, output, env = process.env, pane = false, url: at }) {
-	if (!at) path ??= findBase(process.cwd()) ?? void 0;
+	if (!at) path ??= findBase$1(process.cwd()) ?? void 0;
 	const server = at ? {
 		url: at,
 		release: () => void 0
@@ -8139,6 +8515,14 @@ async function acp(path, { agent, port = 4767, input, output, env = process.env,
 			toAgent(m);
 		}
 		if (c.type === "list" && can.list) ask("session/list", { cwd });
+		if (c.type === "set") ask(c.kind === "mode" ? "session/set_mode" : "session/set_config_option", c.kind === "mode" ? {
+			sessionId: c.session,
+			modeId: c.value
+		} : {
+			sessionId: c.session,
+			configId: c.id,
+			value: c.value
+		});
 		if (c.type === "open") {
 			const params = {
 				cwd,
@@ -9141,10 +9525,128 @@ function bases(args, { config = configPath(), out = console.log } = {}) {
 	return 0;
 }
 //#endregion
+//#region packages/server/src/start.ts
+const SKIP = /* @__PURE__ */ new Set([
+	"node_modules",
+	"dist",
+	"build",
+	"target",
+	"vendor"
+]);
+const isBase = (dir) => existsSync(join(dir, ".isorite")) && statSync(join(dir, ".isorite")).isDirectory();
+/** The base `from` is in or beside: a folder holding .isorite/ on the way up to the repository's top (or `from`
+*  alone, outside a repository), else the one folder just inside that top that holds one. */
+function findBase(from) {
+	const start = resolve(from), repo = repoOf(start), top = repo ?? start;
+	for (let at = start;; at = dirname(at)) {
+		if (isBase(at)) return {
+			kind: "base",
+			notes: at
+		};
+		if (at === top || dirname(at) === at) break;
+	}
+	let inside = [];
+	try {
+		inside = readdirSync(top, { withFileTypes: true }).filter((e) => e.isDirectory() && !e.name.startsWith(".") && !SKIP.has(e.name) && isBase(join(top, e.name))).map((e) => join(top, e.name)).sort();
+	} catch {}
+	if (inside.length === 1) return {
+		kind: "base",
+		notes: inside[0]
+	};
+	if (inside.length > 1) return {
+		kind: "several",
+		notes: inside
+	};
+	return repo ? {
+		kind: "repo",
+		repo
+	} : { kind: "none" };
+}
+/** The first port from `from` that nothing is listening on, so a second `isorite` starts beside the first. */
+async function freePort(from = 4767, host = "127.0.0.1") {
+	for (let port = from; port < from + 20; port++) if (await new Promise((done) => {
+		const probe = createServer().once("error", () => done(false)).once("listening", () => probe.close(() => done(true)));
+		probe.listen(port, host);
+	})) return port;
+	return from;
+}
+/** The bases this machine knows that are still there, the last used first (those never used by name). */
+function recent(config = configPath()) {
+	return knownBases(config).filter((b) => existsSync(b.path)).sort((a, b) => (b.used ?? "").localeCompare(a.used ?? "") || a.name.localeCompare(b.name));
+}
+/** A base as the list shows it: its name with its project's, where two share a name. */
+function label(b, all) {
+	const same = all.filter((o) => o.name.replace(/-\d+$/, "") === b.name.replace(/-\d+$/, "")).length > 1;
+	const project = basename(repoOf(b.path) ?? dirname(b.path));
+	return `${basename(b.path)}${same || basename(b.path) !== project ? `  (${project})` : ""}`;
+}
+/** The choice `isorite` makes, and what it says. */
+async function start(io) {
+	const make = async (folder) => {
+		const notes = io.make(folder);
+		await io.made?.(notes);
+		return notes;
+	};
+	const found = findBase(io.cwd);
+	if (found.kind === "base") return io.open(found.notes);
+	if (found.kind === "several") {
+		io.out(`isorite: more than one base here:`);
+		found.notes.forEach((n, i) => io.out(`  ${i + 1}  ${n}`));
+		const pick = await io.choose("Open which?", found.notes.length);
+		return pick === null ? 2 : io.open(found.notes[pick]);
+	}
+	if (found.kind === "repo") {
+		const notes = join(found.repo, "notes");
+		io.out(`isorite: no base in ${found.repo} yet.`);
+		if (!existsSync(notes) && await io.confirm(`Make one at ${notes}?`)) return io.open(await make(notes));
+		if (existsSync(notes)) io.out(`  ${notes} is there already: open it as it is with  isorite serve ${notes}`);
+	}
+	const known = recent(io.config);
+	if (!known.length && found.kind === "none") {
+		io.out("isorite: no bases yet on this machine.");
+		return await io.confirm("Open the guide, a small base about isorite?") ? io.guide() : 0;
+	}
+	const rows = [
+		...known.map((b) => label(b, known)),
+		`a new base here (${join(io.cwd, "notes")})`,
+		"the guide"
+	];
+	io.out(known.length ? "isorite: the bases on this machine, last used first:" : "isorite:");
+	rows.forEach((r, i) => io.out(`  ${i + 1}  ${r}`));
+	const pick = await io.choose("Open which?", rows.length);
+	if (pick === null) return 2;
+	if (pick < known.length) return io.open(known[pick].path);
+	if (pick === known.length) return io.open(await make(join(io.cwd, "notes")));
+	return io.guide();
+}
+/** The model for search by meaning, offered on the first start without one (M26): asked once, fetched on a yes,
+*  and a no remembered so it isn't asked again (`isorite model` fetches it whenever wanted). A failed fetch is said
+*  and the start goes on: search by words works without it. */
+async function offerModel(o) {
+	if (o.installed || o.off || o.declined) return;
+	if (!await o.confirm("Fetch the 53 MB model for search by meaning, once? Without it search is by words.")) {
+		o.decline();
+		o.out("  not fetched; isorite model fetches it whenever you want it");
+		return;
+	}
+	if (await o.fetch()) o.out("  search by words, for now: isorite doctor says what stopped the fetch");
+}
+//#endregion
 //#region packages/server/src/main.ts
 init_network();
 init_self();
+init_embedder();
 init_model();
+const SHORT = `isorite: an agentic harness for understanding
+
+  isorite                 open the base here, or choose one (a terminal; --no-open, --port <n>)
+  isorite doctor          whether isorite can work here, and what to change if not (--report to paste to
+                          someone helping; run in a project it checks that project's base)
+  isorite help            this; isorite help all lists every command
+  isorite --version
+
+Notes are plain Markdown in a folder of your project; your own agent reads and writes them with you.
+`;
 const USAGE = `isorite: an agentic harness for understanding
 
   isorite new <folder>                   start a knowledge base: the folder, empty, with isorite's .isorite/
@@ -9224,13 +9726,102 @@ function check(notes, out = console.log, unused = false) {
 	}
 	return errors ? 1 : 0;
 }
+/** `isorite` at a terminal: asks on stdin, starts a server on the first free port (4767 up) and opens the page. */
+async function terminalStart({ port, noOpen }) {
+	const { createInterface } = await import("node:readline/promises");
+	const ask = async (question) => {
+		const rl = createInterface({
+			input: process.stdin,
+			output: process.stdout
+		});
+		try {
+			return (await rl.question(question)).trim();
+		} finally {
+			rl.close();
+		}
+	};
+	const browser = !noOpen && !process.env.SSH_CONNECTION && process.env.ISORITE_NO_BROWSER !== "1";
+	const confirm = async (q) => /^y(es)?$/i.test(await ask(`${q} [y/N] `));
+	const declined = join(cacheDir(), "model-declined");
+	const model = () => offerModel({
+		installed: modelDir() !== null,
+		off: process.env.ISORITE_EMBED === "off",
+		declined: existsSync(declined),
+		confirm,
+		fetch: () => modelCommand(void 0, console.log),
+		out: console.log,
+		decline: () => {
+			try {
+				mkdirSync(dirname(declined), { recursive: true });
+				writeFileSync(declined, "");
+			} catch {}
+		}
+	});
+	const serving = async (notes, at = "") => {
+		await model();
+		const use = port ?? await freePort();
+		await serve$1(notes, { port: use });
+		if (browser) openBrowser(`http://localhost:${use}/${at}`);
+		return new Promise(() => void 0);
+	};
+	return start({
+		cwd: process.cwd(),
+		config: configPath(),
+		out: console.log,
+		confirm,
+		choose: async (q, count) => {
+			const n = Number(await ask(`${q} [1-${count}] `));
+			return Number.isInteger(n) && n >= 1 && n <= count ? n - 1 : null;
+		},
+		open: (notes) => serving(notes),
+		make: (folder) => {
+			const made = newBase(folder);
+			console.log(`  made ${made}`);
+			return made;
+		},
+		made: async (notes) => {
+			await askWhereFilesLive(notes, ask, console.log, configPath());
+		},
+		guide: async () => {
+			await model();
+			await guide(void 0, { port: port ?? await freePort() });
+			return new Promise(() => void 0);
+		}
+	});
+}
 function main(argv) {
 	const [command, ...rest] = argv;
 	try {
+		if ((!command || command === "--no-open" || command === "--port") && process.stdin.isTTY && process.stdout.isTTY) {
+			const args = command ? [command, ...rest] : rest, at = args.indexOf("--port"), asked = at < 0 ? void 0 : Number(args[at + 1]);
+			if (asked !== void 0 && !(Number.isInteger(asked) && asked > 0 && asked < 65536)) {
+				console.error("--port takes a number");
+				return 2;
+			}
+			return terminalStart({
+				port: asked,
+				noOpen: args.includes("--no-open")
+			});
+		}
 		if (command === "check" && rest.find((r) => !r.startsWith("--"))) return check(rest.find((r) => !r.startsWith("--")), console.log, rest.includes("--unused"));
 		if (command === "new" && rest[0]) {
 			const made = newBase(rest[0]);
-			console.log(`${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 Iso's 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({
+					input: process.stdin,
+					output: process.stdout
+				});
+				try {
+					await askWhereFilesLive(made, (q) => rl.question(q), console.log, configPath());
+				} finally {
+					rl.close();
+				}
+				console.log(next);
+				return 0;
+			})();
+			console.log(next);
 			return 0;
 		}
 		if (command === "serve" && rest[0]) {
@@ -9297,9 +9888,15 @@ function main(argv) {
 				const at = rest.indexOf(name);
 				return at < 0 ? void 0 : rest[at + 1];
 			};
-			const agent = flag("--agent"), port = flag("--port") === void 0 ? void 0 : Number(flag("--port"));
+			const positional = rest.filter((a, i) => !a.startsWith("--") && ![
+				"--port",
+				"--agent",
+				"--url"
+			].includes(rest[i - 1] ?? ""));
+			const named = !flag("--agent") && positional[0] && !existsSync(positional[0]) ? knownCommand(positional[0]) : null;
+			const agent = flag("--agent") ?? named ?? void 0, port = flag("--port") === void 0 ? void 0 : Number(flag("--port"));
 			if (!agent) {
-				console.error("isorite acp --agent \"<the agent's ACP command>\" [<notes>] [--port <n>] [--pane]");
+				console.error("isorite acp <omp|opencode|claude|codex|hermes> [<notes>] [--port <n>]\nisorite acp --agent \"<the agent's ACP command>\" [<notes>] [--port <n>] [--pane]");
 				return 2;
 			}
 			if (port !== void 0 && !(Number.isInteger(port) && port > 0 && port < 65536)) {
@@ -9311,11 +9908,7 @@ function main(argv) {
 				console.error("--url takes a base's address on this machine");
 				return 2;
 			}
-			return acp(rest.find((a, i) => !a.startsWith("--") && ![
-				"--port",
-				"--agent",
-				"--url"
-			].includes(rest[i - 1] ?? "")), {
+			return acp(named ? positional[1] : positional[0], {
 				agent,
 				pane,
 				...port === void 0 ? {} : { port },
@@ -9358,7 +9951,9 @@ function main(argv) {
 				console.error("--port takes a number");
 				return 2;
 			}
-			const folder = rest.find((a, i) => !a.startsWith("--") && rest[i - 1] !== "--port");
+			const named = rest.find((a, i) => !a.startsWith("--") && rest[i - 1] !== "--port");
+			const here = named ? void 0 : findBase(process.cwd());
+			const folder = named ?? (here?.kind === "base" ? here.notes : void 0);
 			const ask = process.stdin.isTTY && process.stdout.isTTY ? async (question) => {
 				const { createInterface } = await import("node:readline/promises");
 				const rl = createInterface({
@@ -9406,7 +10001,7 @@ function main(argv) {
 		}
 		throw e;
 	}
-	process.stdout.write(USAGE);
+	process.stdout.write(command === "help" && rest[0] === "all" ? USAGE : command && command !== "help" && command !== "--help" ? USAGE : SHORT);
 	return command && command !== "help" && command !== "--help" ? 2 : 0;
 }
 /** The commands that start something, which say so at once (M21): a subprocess that stalls after this is then