isorite 0.7.0 → 0.8.1

package/dist/main.js

@@ -1622,7 +1622,7 @@ function locate$1(note, p) {
 }
 /** The note with a proposal written in. For a rewrite, `region` writes that one alone; without it, every region
 *  still open. Null when the place (or, for a rewrite, any of the places asked for) cannot be found. */
-function written(note, p, region) {
+function written$1(note, p, region) {
 	if (p.form === "rewrite") {
 		const places = (region !== void 0 ? [region] : p.open ?? p.regions.map((_, k) => k)).map((k) => ({
 			k,
@@ -2704,6 +2704,43 @@ say plainly what you would need to look up to say more.`;
 }));
 //#endregion
 //#region packages/engine/src/lookup.ts
+/** Which base a call names, and its arguments for that base: `base`, or a note's id written `memory:tools/x`. */
+function baseOf(args) {
+	const { base, ...rest } = args;
+	let named = typeof base === "string" ? base.trim() : "";
+	for (const k of ["id", "note"]) {
+		const m = typeof rest[k] === "string" ? /^([a-z0-9][a-z0-9-]{0,39}):(?!\/\/)(.+)$/.exec(rest[k]) : null;
+		if (m) {
+			named ||= m[1];
+			if (m[1] === named) rest[k] = m[2];
+		}
+	}
+	return {
+		base: named,
+		args: rest
+	};
+}
+/** The tools' definitions with `base`, for a request that has other bases lent to it. */
+function withBase(defs, names, always = false) {
+	if (!names.length && !always) return defs;
+	const base = {
+		type: "string",
+		description: `Another knowledge base lent to you, by name: ${names.length ? names.join(", ") : "one brief_base names"}. This base when not given. A note there may also be named <base>:folder/name.`
+	};
+	return defs.map((d) => ({
+		...d,
+		function: {
+			...d.function,
+			parameters: {
+				...d.function.parameters,
+				properties: {
+					...d.function.parameters.properties,
+					base
+				}
+			}
+		}
+	}));
+}
 /** A note's id from what a model writes for one: /basics/entropy.md, basics/entropy, [x](/basics/entropy.md). */
 function noteId(b, raw) {
 	const id = String(raw ?? "").trim().replace(/^.*\]\(/, "").replace(/\)$/, "").replace(/\s+"[^"]*"$/, "").split("#")[0].replace(/^\/+/, "").replace(/\.md$/i, "");
@@ -2779,17 +2816,19 @@ var init_lookup = __esmMin((() => {
 		named = /* @__PURE__ */ new Map();
 		b;
 		similar;
-		constructor(b, note, similar = null) {
+		away;
+		constructor(b, note, similar = null, away = null) {
 			this.b = b;
 			this.held = [note];
 			this.similar = similar;
+			this.away = away;
 		}
 		defs() {
-			return this.similar ? [
+			return withBase(this.similar ? [
 				TOOLS[0],
 				FIND_SIMILAR,
 				...TOOLS.slice(1)
-			] : TOOLS;
+			] : TOOLS, this.away?.lent().map((l) => l.name) ?? []);
 		}
 		/** The notes opened, each once, in order. */
 		read() {
@@ -2809,6 +2848,19 @@ var init_lookup = __esmMin((() => {
 				notes: []
 			};
 			let text;
+			const there = baseOf(args);
+			if (there.base) {
+				try {
+					text = await this.elsewhere(name, there.base, there.args, step);
+				} catch (err) {
+					text = this.fail(step, `That could not be looked up: ${err.message}`);
+				}
+				this.steps.push(step);
+				return {
+					text,
+					step
+				};
+			}
 			try {
 				text = name === "search_notes" ? this.search(args, step) : name === "find_similar" ? await this.meaning(args, step) : name === "outline_note" ? this.outline(args, step) : name === "read_note" ? this.section(args, step) : this.fail(step, `There is no tool ${name}.`);
 			} catch (err) {
@@ -2820,6 +2872,22 @@ var init_lookup = __esmMin((() => {
 				step
 			};
 		}
+		/** A look in another base lent to the request: what that base gives, said as being from there. */
+		async elsewhere(name, base, args, step) {
+			const lent = this.away?.lent().map((l) => l.name) ?? [];
+			if (!lent.includes(base)) return this.fail(step, lent.length ? `There is no base ${base} lent here: the bases are ${lent.join(", ")}. Leave base out for this one.` : `There is no base ${base} lent here: leave base out.`);
+			const note = typeof args.id === "string" ? args.id.replace(/^\/+/, "").replace(/\.md$/i, "") : void 0;
+			step.how = name === "search_notes" ? "keyword" : name === "find_similar" ? "meaning" : "read";
+			step.away = {
+				base,
+				...note ? { note } : {},
+				...typeof args.section === "string" && args.section ? { section: args.section } : {}
+			};
+			const query = String(args.query ?? args.text ?? "").trim();
+			if (query) step.query = query;
+			step.said = note ? `Read ${note} in ${base}` : query ? `Searched ${base} for "${query}"` : `Looked in ${base}`;
+			return this.away.look(base, name, args);
+		}
 		fail(step, why) {
 			step.failed = true;
 			step.said = why;
@@ -3147,6 +3215,7 @@ function turnMessages(a) {
 	const held = reads.length ? `# Notes you read earlier in this conversation\n\n${reads.map(sentText).join("\n\n")}` : "";
 	const aside = a.aside?.length ? `# Read earlier, set aside\n\n${a.aside.map((n) => `- ${n.title} (/${n.id}.md)`).join("\n")}` : "";
 	const agents = a.agents?.trim() ? `# Their instructions for this knowledge base (AGENTS.md)\n\n${a.agents.trim()}` : "";
+	const lent = a.lookup && a.lent?.length ? `# Other knowledge bases lent to you\n\nYou may read these with the same look-up tools, giving their base; you change notes only in this one. Look in them where what is asked may be there: how the person works, their tools, what was settled before.\n\n${a.lent.map((l) => `- ${l.name}: ${l.about}`).join("\n")}` : "";
 	const known = understood.length ? `# Their understanding, as you have recorded it\n\n${understood.map(sentText).join("\n\n")}` : "";
 	const broken = a.broken?.length ? `# Code links that no longer resolve\n\nSince you were last told, these links in their notes point to files no longer in their repository. Mention it only where it bears on what they ask.\n\n${a.broken.map((b) => `- in ${b.title} (/${b.id}.md): ${b.href}`).join("\n")}` : "";
 	const request = `# What they ask now\n\n${a.asked}`;
@@ -3161,6 +3230,7 @@ function turnMessages(a) {
 			role: "user",
 			content: [
 				agents,
+				lent,
 				earlier,
 				known,
 				gave,
@@ -3174,7 +3244,7 @@ function turnMessages(a) {
 			{
 				name: "instructions and tools",
 				detail: `${a.mode} mode${checking ? ", checking" : ""}${a.lookup ? "" : ", no look-ups"}`,
-				tokens: estimate(system) + (a.lookup ? 500 : 0) + turnTools(a.mode, a.sent).length * 120
+				tokens: estimate(system) + estimate(lent) + (a.lookup ? 500 : 0) + turnTools(a.mode, a.sent).length * 120
 			},
 			{
 				name: "earlier in this conversation",
@@ -3749,7 +3819,7 @@ function keepDone(before, next) {
 		return next;
 	}
 }
-var SIGN_IN_MS, REPLY_TOKENS, NOTE_TOKENS, DRAFT_PREFIX, DRAFT_DIR, isDraftId, bare, inBase, BAD_PART, TURN_ID, escapeRe, MAX_SENT, BRIEF, NOTE_ARG, MARKED, EDIT_NOTE, WRITE_NOTE, Engine;
+var SIGN_IN_MS, fromBase, REPLY_TOKENS, NOTE_TOKENS, DRAFT_PREFIX, DRAFT_DIR, isDraftId, bare, inBase, BAD_PART, TURN_ID, escapeRe, MAX_SENT, BRIEF, NOTE_ARG, MARKED, EDIT_NOTE, WRITE_NOTE, Engine;
 var init_engine = __esmMin((() => {
 	init_src$1();
 	init_api();
@@ -3762,6 +3832,7 @@ var init_engine = __esmMin((() => {
 	init_meaning();
 	init_provider();
 	SIGN_IN_MS = 6e5;
+	fromBase = (base, text) => `(From the base ${base}: name its notes ${base}:<id>, or give base "${base}".)\n${text}`;
 	REPLY_TOKENS = 2500;
 	NOTE_TOKENS = 6e3;
 	DRAFT_PREFIX = "@draft/";
@@ -4023,7 +4094,7 @@ var init_engine = __esmMin((() => {
 			}));
 		}
 		async agentTools() {
-			return [
+			const tools = [
 				BRIEF,
 				TOOLS[0],
 				...this.similar ? [FIND_SIMILAR] : [],
@@ -4031,9 +4102,48 @@ var init_engine = __esmMin((() => {
 				EDIT_NOTE,
 				WRITE_NOTE
 			];
+			return this.opts.elsewhere ? withBase(tools, this.lent().map((l) => l.name), true) : tools;
+		}
+		/** The bases lent to this one's sessions, not this one. */
+		lent() {
+			return (this.opts.elsewhere?.lent() ?? []).filter((l) => l.name !== this.opts.name);
+		}
+		/** Another base lent here, by name, or why there is none of that name. */
+		other(base) {
+			const lent = this.lent();
+			const engine = lent.some((l) => l.name === base) ? this.opts.elsewhere?.base(base) : null;
+			if (!engine) throw new EngineError(lent.length ? `there is no base ${base} lent here: the bases are ${lent.map((l) => l.name).join(", ")}; leave base out for ${this.opts.name}` : `there is no base ${base} lent here: leave base out`, 404);
+			return engine;
+		}
+		/** For Iso: a look in the other bases lent here, as their own look-ups give it, drawn on no Atlas. */
+		get away() {
+			if (!this.opts.elsewhere) return null;
+			return {
+				lent: () => this.lent(),
+				look: async (base, tool, args) => fromBase(base, (await new Lookup(this.other(base).bundle, "", this.other(base).similar).call(tool, JSON.stringify(args))).text)
+			};
+		}
+		/** What this base is, in a line: its AGENTS.md's first line of text, else its name and size. */
+		async about() {
+			return ((await this.agents()).text ?? "").split("\n").map((l) => l.replace(/^#+\s*/, "").trim()).find((l) => l && !l.startsWith("---")) ?? `${this.bundle.concepts.size} notes`;
 		}
 		async agentLook({ agent, session, tool, args, asked = "" }) {
-			if (tool === BRIEF.function.name) return { text: this.brief() };
+			const there = baseOf(args);
+			if (there.base && there.base !== this.opts.name) {
+				const done = await this.other(there.base).agentLook({
+					agent,
+					session,
+					tool,
+					args: there.args,
+					asked
+				});
+				return { text: fromBase(there.base, done.text) };
+			}
+			args = there.args;
+			if (tool === BRIEF.function.name) {
+				const lent = this.lent();
+				return { text: this.brief() + (lent.length ? `\n\nOther knowledge bases lent to you, each with its own practice (brief_base with its base, before you use it):\n${lent.map((l) => `- ${l.name}: ${l.about}`).join("\n")}\nPass base to any tool to look or write there.` : "") };
+			}
 			if (tool === EDIT_NOTE.function.name || tool === WRITE_NOTE.function.name) {
 				const str = (v, name) => {
 					if (typeof v !== "string") throw new EngineError(`${tool} needs ${name}, as text`, 400);
@@ -4075,6 +4185,7 @@ var init_engine = __esmMin((() => {
 					session
 				});
 			}
+			if (!busy) for (const l of this.lent()) await this.opts.elsewhere?.base(l.name)?.agentStatus(agent, session, false);
 		}
 		async agentWrite({ agent, session, note, asked, edit }) {
 			const who = `agent:${agent}`;
@@ -4600,7 +4711,7 @@ var init_engine = __esmMin((() => {
 				tier: req.tier,
 				place
 			});
-			const lookup = new Lookup(this.bundle, req.note, this.similar);
+			const lookup = new Lookup(this.bundle, req.note, this.similar, this.away);
 			(async () => {
 				let ran = null, offered = false;
 				try {
@@ -5203,6 +5314,7 @@ var init_engine = __esmMin((() => {
 				sent: [...sent, ...reads],
 				aside,
 				...agentsText ? { agents: agentsText } : {},
+				...this.lent().length ? { lent: this.lent() } : {},
 				asked: req.asked ?? ""
 			});
 			const ratio = hand.ratio ?? 1, scaled = (n) => Math.round(n * ratio);
@@ -5551,6 +5663,7 @@ var init_engine = __esmMin((() => {
 				sent,
 				aside: w.aside,
 				...w.agentsText ? { agents: w.agentsText } : {},
+				...this.lent().length ? { lent: this.lent() } : {},
 				asked: req.asked,
 				broken: await this.brokenNews("iso")
 			});
@@ -5600,7 +5713,7 @@ var init_engine = __esmMin((() => {
 				});
 			};
 			const who = `iso:${this.provider.name}/${this.provider.tiers[req.tier]}`;
-			const lookup = new Lookup(this.bundle, req.given.find((g) => g.kind !== "folder")?.id ?? "", this.similar);
+			const lookup = new Lookup(this.bundle, req.given.find((g) => g.kind !== "folder")?.id ?? "", this.similar, this.away);
 			const looks = new Set(lookup.defs().map((d) => d.function.name));
 			const tools = {
 				defs: () => [...lookupOn ? lookup.defs() : [], ...own],
@@ -5611,7 +5724,7 @@ var init_engine = __esmMin((() => {
 						try {
 							args = JSON.parse(raw || "{}");
 						} catch {}
-						const id = noteId(this.bundle, args.id), want = typeof args.section === "string" ? args.section.replace(/^#+\s*/, "").trim() : "";
+						const id = args.base ? null : noteId(this.bundle, args.id), want = typeof args.section === "string" ? args.section.replace(/^#+\s*/, "").trim() : "";
 						const held = id ? inHand.get(id) : void 0;
 						if (id && held && (held === "whole" || want && held.includes(want))) {
 							const step = {
@@ -5635,6 +5748,8 @@ var init_engine = __esmMin((() => {
 						if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) args = parsed;
 					} catch {}
 					if (!own.some((d) => d.function.name === name)) return { text: `There is no tool ${name} in ${mode} mode.` };
+					const there = baseOf(args);
+					if (there.base && there.base !== this.opts.name) return { text: `Notes are changed only in ${this.opts.name}, the base you are in: ${there.base} is lent to you to read.` };
 					return { text: await this.turnTool(name, args, {
 						turn,
 						conversation,
@@ -6224,10 +6339,10 @@ var init_engine = __esmMin((() => {
 				let text;
 				if (p.form === "rewrite") {
 					if (region !== void 0 && !p.open?.includes(region)) throw new EngineError("that change is no longer waiting: it was kept or removed", 409);
-					text = written(now, p, region);
+					text = written$1(now, p, region);
 					if (text === null) throw new EngineError(region === void 0 ? "a passage this would rewrite is no longer in the note as it was. Keep the others one by one." : "the passage this would rewrite is no longer in the note as it was", 409);
 				} else {
-					text = written(now, p) ?? written(now, {
+					text = written$1(now, p) ?? written$1(now, {
 						...p,
 						after: null,
 						before: null
@@ -6780,6 +6895,62 @@ function gatewayTlsFrom(config, dir, env = process.env) {
 async function hasModel$1(config = configPath()) {
 	return await new ConfigSecrets(config).get("provider.key") !== null || providerConfig(config).url !== OPENROUTER.url;
 }
+const BASE_NAME = /^[a-z0-9][a-z0-9-]{0,39}$/;
+const expand = (p) => p === "~" ? homedir() : p.startsWith("~/") ? join(homedir(), p.slice(2)) : resolve(p);
+/** A path as written in the file: under the home folder, with ~. */
+const written = (p) => {
+	const home = homedir();
+	return p === home ? "~" : p.startsWith(home + "/") ? "~" + p.slice(home.length) : p;
+};
+/** Where the bases are listed, beside the configuration. */
+const basesPath = (config = configPath()) => join(dirname(config), "bases.toml");
+/** The bases listed, in the order written. A row without a path, or with a name isorite
+*  would not give one, is passed over. */
+function knownBases(config = configPath()) {
+	return Object.entries(readConfig(basesPath(config))).flatMap(([name, v]) => {
+		const row = table(v);
+		return BASE_NAME.test(name) && typeof row.path === "string" && row.path ? [{
+			name,
+			path: expand(row.path),
+			lend: row.lend === true
+		}] : [];
+	});
+}
+/** A name for a base from its folder: small letters, digits and dashes. */
+function baseName(folder) {
+	return basename(folder).toLowerCase().replace(/[^a-z0-9-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 40) || "base";
+}
+/** 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. */
+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;
+	const bases = readConfig(basesPath(path));
+	let name = had?.name;
+	if (!name) {
+		const stem = as && BASE_NAME.test(as) ? as : baseName(at), taken = new Set(Object.keys(bases));
+		name = stem;
+		for (let n = 2; taken.has(name); n++) name = `${stem.slice(0, 36)}-${n}`;
+	}
+	bases[name] = {
+		...table(bases[name]),
+		path: written(at),
+		...lend === void 0 ? {} : { lend }
+	};
+	writeConfig(bases, basesPath(path));
+	return name;
+}
+/** 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));
+	if (!BASE_NAME.test(name) || !bases[name]) return false;
+	bases[name] = {
+		...table(bases[name]),
+		lend
+	};
+	writeConfig(bases, basesPath(path));
+	return true;
+}
 //#endregion
 //#region packages/server/src/model.ts
 /** Where the server looks for the model, in order, and why each place is there. */
@@ -6821,7 +6992,7 @@ function modelInfo(dir) {
 	} catch {}
 	const graph = sha(readFileSync(join(dir, "model.onnx"))), granite = graph === FILES[0][2];
 	const pooling = own.pooling === "mean" ? "mean" : "cls";
-	const name = typeof own.name === "string" && own.name ? own.name : granite ? NAME$1 : basename(dir);
+	const name = typeof own.name === "string" && own.name ? own.name : granite ? NAME$2 : basename(dir);
 	return {
 		dir,
 		name,
@@ -7003,11 +7174,11 @@ async function modelCommand(from, say = console.log, env = process.env, sources
 		return 1;
 	}
 }
-var NAME$1, MODEL, RELEASE, PACKAGE, HUB, FILES, sha, userModelsDir, userModelDir, hasModel, ModelFetchError, modelFiles;
+var NAME$2, MODEL, RELEASE, PACKAGE, HUB, FILES, sha, userModelsDir, userModelDir, hasModel, ModelFetchError, modelFiles;
 var init_model = __esmMin((() => {
 	init_src();
-	NAME$1 = "granite-embedding-small-english-r2";
-	MODEL = `${NAME$1}-q8`;
+	NAME$2 = "granite-embedding-small-english-r2";
+	MODEL = `${NAME$2}-q8`;
 	RELEASE = "https://github.com/lachlanjs/isorite/releases/download/model-granite-1.0.0/isorite-model-granite-1.0.0.tgz";
 	PACKAGE = "isorite-model-granite@1.0.0";
 	HUB = `https://huggingface.co/onnx-community/granite-embedding-small-english-r2-ONNX/resolve/1dc7835ba0cb9c76a3618d0bf0c427c97671b3c8`;
@@ -7035,7 +7206,7 @@ var init_model = __esmMin((() => {
 	];
 	sha = (buf) => createHash("sha256").update(buf).digest("hex");
 	userModelsDir = (env = process.env) => join(env.XDG_DATA_HOME || join(homedir(), ".local", "share"), "isorite", "models");
-	userModelDir = (env = process.env) => join(userModelsDir(env), NAME$1);
+	userModelDir = (env = process.env) => join(userModelsDir(env), NAME$2);
 	hasModel = (dir) => existsSync(join(dir, "model.onnx")) && existsSync(join(dir, "tokenizer.json"));
 	ModelFetchError = class extends Error {
 		tried;
@@ -7223,7 +7394,132 @@ function relay(live, key) {
 	};
 }
 //#endregion
+//#region packages/server/src/bases.ts
+const NAME$1 = /^[a-z0-9][a-z0-9-]{0,39}$/;
+var Bases = class {
+	first;
+	#config;
+	#make;
+	#open = /* @__PURE__ */ new Map();
+	#ready = /* @__PURE__ */ new Map();
+	#about = /* @__PURE__ */ new Map();
+	#holds = 0;
+	#idle;
+	/** `make` opens a base; `idle` is called when the last hold is let go (a server isorite term started). */
+	constructor({ config, first, make, idle }) {
+		this.#config = config;
+		this.first = first;
+		this.#make = make;
+		this.#idle = idle;
+	}
+	/** The first base, and every lent one. */
+	async start() {
+		await this.get(this.first);
+		await Promise.all(knownBases(this.#config).filter((b) => b.lend).map((b) => this.get(b.name)?.catch((e) => console.error(`isorite: ${b.name} (${b.path}) could not be opened: ${e.message}`))));
+	}
+	/** A known base, opened if it is not yet; null where none has that name. */
+	get(name) {
+		const had = this.#open.get(name);
+		if (had) return had;
+		const known = NAME$1.test(name) ? knownBases(this.#config).find((b) => b.name === name) : void 0;
+		if (!known) return null;
+		const opening = this.#make(known).then(async (opened) => {
+			this.#ready.set(name, opened);
+			this.#about.set(name, await opened.engine.about());
+			opened.engine.events((e) => {
+				if (e.type === "note-changed") opened.engine.about().then((a) => this.#about.set(name, a));
+			});
+			return opened;
+		});
+		opening.catch(() => this.#open.delete(name));
+		this.#open.set(name, opening);
+		return opening;
+	}
+	/** Every open base, for what is kept into use in all of them (the provider). */
+	each(fn) {
+		for (const o of this.#ready.values()) fn(o.engine);
+	}
+	lent() {
+		return knownBases(this.#config).filter((b) => b.lend && this.#ready.has(b.name)).map((b) => ({
+			name: b.name,
+			about: this.#about.get(b.name) ?? ""
+		}));
+	}
+	base(name) {
+		return this.#ready.get(name)?.engine ?? null;
+	}
+	list() {
+		return knownBases(this.#config).map((b) => ({
+			name: b.name,
+			path: b.path,
+			lend: b.lend,
+			open: this.#ready.has(b.name)
+		}));
+	}
+	async lend(name, on) {
+		if (!lendBase(name, on, this.#config)) return false;
+		if (on) await this.get(name);
+		return true;
+	}
+	async open(path) {
+		const name = rememberBase(resolve(path), { path: this.#config });
+		await this.get(name);
+		return {
+			name,
+			first: name === this.first
+		};
+	}
+	hold() {
+		this.#holds++;
+		let let_go = false;
+		return () => {
+			if (let_go) return;
+			let_go = true;
+			if (--this.#holds === 0) setTimeout(() => {
+				if (this.#holds === 0) this.#idle?.();
+			}, 1e3).unref();
+		};
+	}
+	/** A request to the server: to a base's API by its address, /b/<name>/api/…, or to the first. A base's page is
+	*  the app's own page with ?base=<name> (SvelteKit's hash router needs its page at the root it was built for):
+	*  /b/<name> is sent there. */
+	async fetch(req, env) {
+		const url = new URL(req.url);
+		const m = /^\/b\/([^/]+)(\/.*)?$/.exec(url.pathname);
+		if (!m || !NAME$1.test(m[1])) return (await this.get(this.first)).fetch(req, env);
+		const name = m[1];
+		if (!m[2]?.startsWith("/api/")) return new Response(null, {
+			status: 302,
+			headers: { Location: `/?base=${name}${m[2]?.startsWith("/#") ? m[2].slice(1) : ""}` }
+		});
+		const opening = this.get(name);
+		if (!opening) return new Response(JSON.stringify({ error: `no base ${name} is known here: isorite bases lists them` }), {
+			status: 404,
+			headers: { "Content-Type": "application/json" }
+		});
+		let opened;
+		try {
+			opened = await opening;
+		} catch (e) {
+			return new Response(JSON.stringify({ error: `${name} could not be opened: ${e.message}` }), {
+				status: 500,
+				headers: { "Content-Type": "application/json" }
+			});
+		}
+		url.pathname = m[2];
+		const body = req.method === "GET" || req.method === "HEAD" ? null : req.body;
+		return opened.fetch(new Request(url, {
+			method: req.method,
+			headers: req.headers,
+			body,
+			signal: req.signal,
+			...body ? { duplex: "half" } : {}
+		}), env);
+	}
+};
+//#endregion
 //#region packages/server/src/terminal.ts
+init_src();
 const OUTPUT = 4e3;
 const LOOKUPS = /* @__PURE__ */ new Set([
 	"search_notes",
@@ -7234,6 +7530,7 @@ const LOOKUPS = /* @__PURE__ */ new Set([
 ]);
 /** isorite's tools that change a note: their line opens it, where the agent's words are marked. */
 const CHANGES = /* @__PURE__ */ new Set(["edit_note", "write_note"]);
+const isorite = (name) => LOOKUPS.has(name) || CHANGES.has(name);
 /** What a tool call acted on, in a line. */
 function titleOf(name, input = {}) {
 	const s = (k) => typeof input[k] === "string" ? input[k] : "";
@@ -7281,16 +7578,21 @@ function toTurns(messages, { live = /* @__PURE__ */ new Map(), ours = /* @__PURE
 			const input = c.state.input ?? {};
 			const output = (c.state.content ?? []).map((x) => x.text ?? "").join("").slice(0, OUTPUT);
 			const status = c.state.status === "completed" ? "done" : /error|fail/.test(c.state.status) ? "failed" : "running";
+			const { base, args } = isorite(c.name) ? baseOf(input) : {
+				base: "",
+				args: input
+			};
 			const item = {
 				kind: "tool",
 				id: c.id,
 				name: c.name,
-				title: titleOf(c.name, input),
+				title: (base ? `${base}: ` : "") + titleOf(c.name, args),
 				status,
 				output
 			};
-			const named = LOOKUPS.has(c.name) ? input.id : CHANGES.has(c.name) ? input.note : void 0;
+			const named = LOOKUPS.has(c.name) ? args.id : CHANGES.has(c.name) ? args.note : void 0;
 			if (typeof named === "string" && named) item.note = named.replace(/^\//, "").replace(/\.md$/, "");
+			if (base) item.base = base;
 			const diff = diffOf(c.name, input);
 			if (diff) item.diff = diff;
 			turn.items.push(item);
@@ -7722,7 +8024,7 @@ const AgentStatus = z.object({
 	session: z.string().min(1).max(200),
 	busy: z.boolean()
 }).strict();
-function createApp({ api, token, loopback, web, allowHosts = [], notes, terminal, gateway, setup }) {
+function createApp({ api, token, loopback, web, allowHosts = [], notes, terminal, gateway, setup, bases, base }) {
 	const app = new Hono();
 	const allowed = new Set([...allowHosts].map((h) => h.toLowerCase()));
 	const reply = (c, status, value) => c.body(JSON.stringify(value), status, {
@@ -7925,9 +8227,52 @@ function createApp({ api, token, loopback, web, allowHosts = [], notes, terminal
 		post("/api/settings/provider/models", z.object({ draft: SetupDraft.nullable() }).strict(), async (c, b) => ({ models: await setup.models(local(c) ? b.draft : null) }));
 		post("/api/settings/report", z.object({}).strict(), async () => ({ text: await setup.report() }));
 	}
+	if (bases) {
+		app.get("/api/bases", (c) => answer(c, async () => ({
+			here: base ?? "",
+			local: local(c),
+			bases: bases.list()
+		})));
+		const mine = (c) => {
+			if (!local(c)) throw new EngineError("the bases are changed only from this machine", 403);
+		};
+		post("/api/bases/lend", z.object({
+			name: z.string().max(40),
+			lend: z.boolean()
+		}).strict(), async (c, b) => {
+			mine(c);
+			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/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);
+			return bases.open(b.path);
+		});
+		app.get("/api/server/hold", (c) => {
+			if (!local(c)) return refuse(c, 403, "held only from this machine");
+			return streamSSE(c, async (stream) => {
+				const release = bases.hold();
+				const beat = setInterval(() => {
+					stream.write(": held\n\n");
+				}, 25e3);
+				await stream.writeSSE({
+					event: "held",
+					data: "{}"
+				});
+				await new Promise((done) => stream.onAbort(done));
+				clearInterval(beat);
+				release();
+			});
+		});
+	}
 	app.get("/api/agent/tools", (c) => answer(c, () => api.agentTools()));
 	post("/api/agent/look", AgentLook, (_c, b) => api.agentLook(b));
-	app.get("/api/agent/base", (c) => answer(c, async () => ({ notes: notes ?? null })));
+	app.get("/api/agent/base", (c) => answer(c, async () => ({
+		notes: notes ?? null,
+		name: base ?? null,
+		lent: (bases?.list() ?? []).filter((b) => b.lend && b.name !== base).map((b) => b.name)
+	})));
 	post("/api/agent/write", AgentChange, (_c, b) => api.agentWrite(b));
 	post("/api/agent/send", z.object({
 		note: z.string().max(400),
@@ -8368,28 +8713,47 @@ var Setup = class {
 };
 //#endregion
 //#region packages/server/src/version.ts
-const VERSION = "0.7.0";
+const VERSION = "0.8.1";
 //#endregion
-//#region packages/server/src/studybase.ts
-init_src$1();
-function git(cwd, ...args) {
+//#region packages/server/src/git.ts
+/** The top of the repository `folder` is in, or null: the nearest folder holding `.git`, a directory or, in a
+*  worktree or submodule, a file. No `git` is run. */
+function repoOf(folder) {
+	for (let at = resolve(folder);; at = dirname(at)) {
+		if (existsSync(join(at, ".git"))) return at;
+		if (dirname(at) === at) return null;
+	}
+}
+/** The environment for a `git` isorite runs: none of the shell's GIT_* (a GIT_DIR would point it elsewhere), no
+*  system configuration (where a company's hooks and helpers are usually set), and no prompt for a password. */
+function plainGitEnv(env = process.env) {
+	return {
+		...Object.fromEntries(Object.entries(env).filter(([k]) => !k.startsWith("GIT_"))),
+		GIT_CONFIG_NOSYSTEM: "1",
+		GIT_TERMINAL_PROMPT: "0"
+	};
+}
+/** `git init` in a folder, given `timeout` ms; whether it was made a repository. */
+function gitInit(folder, { env = process.env, timeout = 1e4 } = {}) {
 	try {
-		return execFileSync("git", args, {
-			cwd,
-			encoding: "utf8",
-			stdio: [
-				"ignore",
-				"pipe",
-				"ignore"
-			]
-		}).trim();
+		execFileSync("git", ["init", "--quiet"], {
+			cwd: folder,
+			stdio: "ignore",
+			env: plainGitEnv(env),
+			timeout,
+			killSignal: "SIGKILL"
+		});
+		return existsSync(join(folder, ".git"));
 	} catch {
-		return null;
+		return false;
 	}
 }
+//#endregion
+//#region packages/server/src/studybase.ts
+init_src$1();
 /** Where format 1 put a study base when not told: beside the knowledge base's repository, named after it. */
 function defaultStudyPath(notes) {
-	const repo = git(notes, "rev-parse", "--show-toplevel") ?? notes;
+	const repo = repoOf(notes) ?? resolve(notes);
 	return join(dirname(repo), basename(repo) + "-study");
 }
 /** A study base's configuration, and its knowledge base's folder as an absolute path. */
@@ -8439,15 +8803,16 @@ function newBase(path) {
 	makeOwn(at);
 	return at;
 }
-async function openEngine({ notes }, device = deviceId(), config = configPath(), http, model = modelDir(), secrets = new ConfigSecrets(config)) {
+async function openEngine({ notes }, device = deviceId(), config = configPath(), http, model = modelDir(), secrets = new ConfigSecrets(config), extras = {}) {
 	const provider = providerConfig(config);
 	const own = makeOwn(notes);
+	const embedder = extras.embedder !== void 0 ? extras.embedder : model ? nodeEmbedder(model) : null;
 	return Engine.open({
 		notes: new NodeFiles(notes),
 		own: new NodeFiles(own),
 		clock: systemClock,
 		device,
-		name: basename(notes),
+		name: extras.name ?? basename(notes),
 		http: http ?? gatewayHttp(provider, gatewayTls(config)),
 		secrets,
 		provider,
@@ -8455,13 +8820,14 @@ async function openEngine({ notes }, device = deviceId(), config = configPath(),
 			const dir = resolve(notes, path);
 			return existsSync(dir) && statSync(dir).isDirectory() ? new NodeFiles(dir) : null;
 		},
-		...model ? {
-			embedder: nodeEmbedder(model),
+		...embedder ? {
+			embedder,
 			cache: {
 				files: new NodeFiles(cacheDir()),
 				name: `vectors-${createHash("sha256").update(notes).digest("hex").slice(0, 16)}.json`
 			}
-		} : {}
+		} : {},
+		...extras.elsewhere ? { elsewhere: extras.elsewhere } : {}
 	});
 }
 /** The guide's finder, as a provider: no key, no sign-in, and a name that says what it is. */
@@ -8486,16 +8852,49 @@ async function liveProvider(config, stand) {
 }
 /** A link most terminals let you click (OSC 8), when the output is a terminal; the address as it is otherwise. */
 const link$1 = (url, tty = Boolean(process.stdout.isTTY)) => tty ? `\x1b]8;;${url}\x1b\\${url}\x1b]8;;\x1b\\` : url;
-/** `stand`: in place of the provider, an answerer of its own, as the guide's finder is when no model is set up
-*  (M16). It is asked while there is no model here (no key, no provider of your own), and needs no key. */
-async function serve$1(path, { host = "127.0.0.1", port = 4767, allowHosts = [], stand } = {}) {
+/** The server's bases, opened: the one named (remembered in bases.toml, M20) and every lent one, each with its
+*  engine and app, and the server's answer to a request for any of them. `stand`: in place of the provider, an
+*  answerer of its own, as the guide's finder is when no model is set up (M16), asked while there is no model here.
+*  `idle`: what to do once the last of those holding the server lets it go. */
+async function openServer(path, { host = "127.0.0.1", port = 4767, allowHosts = [], stand, idle, config = configPath(), model = modelDir() } = {}) {
 	const opened = locate(path);
-	const config = configPath();
 	const current = () => liveProvider(config, stand);
 	let live = await current();
-	const secrets = new ConfigSecrets(config);
-	const api = await openEngine(opened, deviceId(config), config, live.http, modelDir(), secrets);
-	api.setProvider(live.provider, live.http);
+	const secrets = new ConfigSecrets(config), device = deviceId(config);
+	const first = rememberBase(opened.notes, { path: config });
+	const embedder = model ? nodeEmbedder(model) : null;
+	const token = randomBytes(24).toString("base64url"), loopback = LOOPBACK.has(host);
+	const gateway = loopback ? relay(() => live, () => secrets.get(KEY)) : void 0;
+	const web = existsSync(join(WEB_DIR, "index.html")) ? WEB_DIR : null;
+	const bases = new Bases({
+		config,
+		first,
+		...idle ? { idle } : {},
+		make: async (known) => {
+			const api = await openEngine({ notes: known.path }, device, config, live.http, model, secrets, {
+				name: known.name,
+				elsewhere: bases,
+				embedder
+			});
+			api.setProvider(live.provider, live.http);
+			return {
+				engine: api,
+				fetch: createApp({
+					api,
+					token,
+					loopback,
+					web,
+					allowHosts,
+					notes: known.path,
+					terminal: new Terminal(),
+					gateway,
+					setup,
+					bases,
+					base: known.name
+				}).fetch
+			};
+		}
+	});
 	const setup = new Setup({
 		config,
 		notes: opened.notes,
@@ -8503,25 +8902,29 @@ async function serve$1(path, { host = "127.0.0.1", port = 4767, allowHosts = [],
 		port,
 		kept: async () => {
 			live = await current();
-			api.setProvider(live.provider, live.http);
+			bases.each((api) => api.setProvider(live.provider, live.http));
 		}
 	});
-	const gateway = LOOPBACK.has(host) ? relay(() => live, () => secrets.get(KEY)) : void 0;
-	const web = existsSync(join(WEB_DIR, "index.html")) ? WEB_DIR : null;
-	const terminal = new Terminal();
-	const app = createApp({
-		api,
-		token: randomBytes(24).toString("base64url"),
-		loopback: LOOPBACK.has(host),
-		web,
-		allowHosts,
+	await bases.start();
+	return {
 		notes: opened.notes,
-		terminal,
-		gateway,
-		setup
+		bases,
+		embedder: Boolean(embedder),
+		fetch: (req, env) => bases.fetch(req, env)
+	};
+}
+/** `held`: started by isorite term or mcp, it stops once the last of them lets it go. */
+async function serve$1(path, { host = "127.0.0.1", port = 4767, allowHosts = [], stand, held = false } = {}) {
+	let stop = () => void 0;
+	const { notes, bases, embedder, fetch } = await openServer(path, {
+		host,
+		port,
+		allowHosts,
+		...stand ? { stand } : {},
+		...held ? { idle: () => stop() } : {}
 	});
 	const server = serve({
-		fetch: app.fetch,
+		fetch,
 		hostname: host,
 		port
 	});
@@ -8529,11 +8932,13 @@ async function serve$1(path, { host = "127.0.0.1", port = 4767, allowHosts = [],
 		console.error(e.code === "EADDRINUSE" ? `port ${port} is in use (isorite serve --port <n>)` : e.message);
 		process.exit(1);
 	});
-	console.log(`isorite: ${opened.notes}`);
-	console.log(api.meaning ? "  search by meaning: on" : "  search by meaning: off (isorite model fetches its model)");
-	console.log(web ? `  ${link$1(`http://localhost:${port}/`)}` : `  the app is not built (npm run build); the engine alone is at http://localhost:${port}/api/`);
+	console.log(`isorite: ${notes}`);
+	console.log(embedder ? "  search by meaning: on" : "  search by meaning: off (isorite model fetches its model)");
+	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$1(`http://localhost:${port}/`)}` : `  the app is not built (npm run build); the engine alone is at http://localhost:${port}/api/`);
 	if (process.env.SSH_CONNECTION && LOOPBACK.has(host)) console.log(`  over SSH, the link opens on this machine; from your own, first run: ssh -L ${port}:localhost:${port} ${hostname()}`);
-	const stop = () => {
+	stop = () => {
 		server.close();
 		process.exit(0);
 	};
@@ -8560,6 +8965,12 @@ function openBrowser(url) {
 		}).on("error", () => void 0).unref();
 	} catch {}
 }
+/** How long a step may take before it's said what is being waited for (M21), and where it's said: stderr, as
+*  `mcp` speaks on stdout. */
+const SLOW = 2e3;
+const waiting = (line) => {
+	process.stderr.write(line + "\n");
+};
 /** The name the server on this URL serves, or null when nothing answers. */
 async function serving(url) {
 	try {
@@ -8569,49 +8980,82 @@ async function serving(url) {
 		return null;
 	}
 }
-/** The isorite server on the port, and how to let it go: one already running for this base (or for any, when
-*  no base is named), or one started for the base, its output kept in a log, stopped when let go. */
-async function ensureServer(path, { port = 4767, env = process.env, wait = 12e4 } = {}) {
-	const url = `http://127.0.0.1:${port}`;
+/** The isorite server on the port, and how to let it go: one already running (for this base, or holding it as
+*  well from now on, M20; or for any, when no base is named), or one started for the base, its output kept in a
+*  log. `url` is the base's own address there. A server this started stops once the last of those using it lets it
+*  go; one you started yourself goes on. */
+async function ensureServer(path, { port = 4767, env = process.env, wait = 12e4, say = waiting } = {}) {
+	const root = `http://127.0.0.1:${port}`;
 	const opened = path === void 0 ? null : locate(path);
-	const name = await serving(url);
-	if (name !== null) {
-		if (opened && name !== basename(opened.notes)) throw new StudyError(`port ${port} is serving ${name}, not ${basename(opened.notes)}: stop it, or use another port (--port <n>)`);
-		return {
-			url,
-			release: () => void 0
-		};
-	}
-	if (!opened) throw new StudyError(`nothing is serving on port ${port}: name a base`);
-	const log = join(tmpdir(), `isorite-term-${port}.log`);
-	const out = openSync(log, "w");
-	const server = spawn(process.execPath, [
-		MAIN,
-		"serve",
-		path,
-		"--port",
-		String(port)
-	], {
-		stdio: [
-			"ignore",
-			out,
-			out
-		],
-		env
-	});
-	const exited = new Promise((done) => server.once("exit", () => done()));
-	const started = Date.now();
-	while (await serving(url) === null) {
-		if (server.exitCode !== null || Date.now() - started > wait) {
-			server.kill();
-			throw new StudyError(`the isorite server did not start; its output is in ${log}`);
+	let name = await serving(root), started = null;
+	if (name === null) {
+		if (!opened) throw new StudyError(`nothing is serving on port ${port}: name a base`);
+		const log = join(tmpdir(), `isorite-term-${port}.log`);
+		const out = openSync(log, "w");
+		started = spawn(process.execPath, [
+			MAIN,
+			"serve",
+			path,
+			"--port",
+			String(port),
+			"--held"
+		], {
+			stdio: [
+				"ignore",
+				out,
+				out
+			],
+			env,
+			detached: true
+		});
+		const exited = new Promise((done) => started.once("exit", () => done()));
+		const begun = Date.now();
+		let told = false;
+		while ((name = await serving(root)) === null) {
+			if (!told && Date.now() - begun > SLOW) {
+				say(`isorite: waiting for the isorite server; its output is in ${log}`);
+				told = true;
+			}
+			if (started.exitCode !== null || Date.now() - begun > wait) {
+				started.kill();
+				throw new StudyError(`the isorite server did not start; its output is in ${log}`);
+			}
+			await Promise.race([exited, new Promise((r) => setTimeout(r, 250))]);
 		}
-		await Promise.race([exited, new Promise((r) => setTimeout(r, 250))]);
+		started.unref();
 	}
+	let url = root;
+	if (opened) {
+		const at = await fetch(`${root}/api/bases/open`, {
+			method: "POST",
+			headers: {
+				"Content-Type": "application/json",
+				"x-isorite-token": await tokenOf(root),
+				Origin: root
+			},
+			body: JSON.stringify({ path: opened.notes })
+		}).catch(() => null);
+		if (at?.ok) {
+			const base = await at.json();
+			if (!base.first) url = `${root}/b/${base.name}`;
+		} else if (name !== basename(opened.notes)) throw new StudyError(`port ${port} is serving ${name}, not ${basename(opened.notes)}: stop it, or use another port (--port <n>)`);
+	}
+	const holding = new AbortController();
+	const held = fetch(`${root}/api/server/hold`, { signal: holding.signal }).then((r) => {
+		if (r.ok && r.body) (async () => {
+			try {
+				for await (const _ of r.body);
+			} catch {}
+		})();
+		return r.ok;
+	}, () => false);
 	return {
 		url,
 		release: () => {
-			server.kill();
+			holding.abort();
+			held.then((ok) => {
+				if (!ok && started) started.kill();
+			});
 		}
 	};
 }
@@ -8632,7 +9076,7 @@ async function tell(url, path, body) {
 		headers: {
 			"Content-Type": "application/json",
 			"x-isorite-token": token,
-			Origin: url
+			Origin: new URL(url).origin
 		},
 		body: JSON.stringify(body)
 	});
@@ -8640,7 +9084,7 @@ async function tell(url, path, body) {
 }
 /** OpenCode's own server, on this machine only, with a password of its own; its output kept in a log. The terminal
 *  attaches to it, and so does the isorite server, which shows its session in the Iso pane (M11). */
-async function startOpenCode(command, { cwd, env, wait = 6e4 }) {
+async function startOpenCode(command, { cwd, env, wait = 6e4, say = waiting }) {
 	const port = await freePort(), password = randomBytes(24).toString("base64url"), url = `http://127.0.0.1:${port}`;
 	const log = join(tmpdir(), `isorite-opencode-${port}.log`);
 	const out = openSync(log, "w");
@@ -8664,7 +9108,17 @@ async function startOpenCode(command, { cwd, env, wait = 6e4 }) {
 	});
 	const auth = { authorization: "Basic " + Buffer.from(`opencode:${password}`).toString("base64") };
 	const started = Date.now();
+	let told = 0;
 	for (;;) {
+		const waited = Date.now() - started;
+		if (told === 0 && waited > SLOW) {
+			say("isorite: waiting for OpenCode's server");
+			told = 1;
+		}
+		if (told === 1 && waited > 1e4) {
+			say(`isorite: OpenCode's server has not answered in 10 s (a git it runs may be waiting); its output is in ${log}`);
+			told = 2;
+		}
 		if (server.exitCode !== null || Date.now() - started > wait) {
 			server.kill();
 			throw new StudyError(`OpenCode's server did not start; its output is in ${log}`);
@@ -8723,9 +9177,9 @@ async function modelsFor(env, server) {
 }
 /** What `isorite term` says before OpenCode takes the screen, and again when it gives it back: where isorite is in
 *  the browser, which models the terminal uses and where they come from, and, over SSH, how to reach the browser. */
-function where(port, models, env, tty) {
+function where(port, models, env, tty, page = "/") {
 	const names = models.gateway?.models.join(", ");
-	const lines = [`isorite: ${link$1(`http://localhost:${port}/`, tty)}`, models.from === "environment" ? `  the terminal's models: ${names}, at ${models.gateway.url} (ISORITE_GATEWAY_URL)` : models.from === "config" ? `  the terminal's models: ${names}, as config.toml names them, through the isorite server` : "  the terminal's models: OpenCode's own, as no key or certificate is named in config.toml"];
+	const lines = [`isorite: ${link$1(`http://localhost:${port}${page}`, tty)}`, models.from === "environment" ? `  the terminal's models: ${names}, at ${models.gateway.url} (ISORITE_GATEWAY_URL)` : models.from === "config" ? `  the terminal's models: ${names}, as config.toml names them, through the isorite server` : "  the terminal's models: OpenCode's own, as no key or certificate is named in config.toml"];
 	if (env.SSH_CONNECTION) lines.push(`  over SSH, the link opens on this machine; from your own, first run: ssh -L ${port}:localhost:${port} ${hostname()}`);
 	return lines;
 }
@@ -8752,7 +9206,7 @@ async function term(path, { port = 4767, cwd = process.cwd(), env: given = proce
 		throw e;
 	}
 	const { gateway, env } = models;
-	const said = where(port, models, given);
+	const said = where(port, models, given, void 0, new URL(server.url).pathname.replace(/\/?$/, "/"));
 	for (const line of said) console.log(line);
 	const agents = path === void 0 ? null : join(locate(path).notes, AGENTS_FILE);
 	const home = writeHome(defaultHome(env), {
@@ -8762,7 +9216,8 @@ async function term(path, { port = 4767, cwd = process.cwd(), env: given = proce
 	const shared = {
 		...env,
 		OPENCODE_CONFIG_DIR: home,
-		ISORITE_URL: server.url
+		ISORITE_URL: server.url,
+		GIT_TERMINAL_PROMPT: "0"
 	};
 	let backend;
 	try {
@@ -8786,7 +9241,8 @@ async function term(path, { port = 4767, cwd = process.cwd(), env: given = proce
 			...given,
 			OPENCODE_CONFIG_DIR: home,
 			ISORITE_URL: server.url,
-			OPENCODE_PASSWORD: backend.password
+			OPENCODE_PASSWORD: backend.password,
+			GIT_TERMINAL_PROMPT: "0"
 		}
 	});
 	const forward = (signal) => () => child.kill(signal);
@@ -9225,7 +9681,7 @@ async function mcp(path, { port = 4767, agent = "mcp", quiet = QUIET_MS, input =
 			headers: {
 				"Content-Type": "application/json",
 				[TOKEN_HEADER]: await token,
-				Origin: url
+				Origin: new URL(url).origin
 			},
 			body: JSON.stringify(body)
 		});
@@ -9255,7 +9711,7 @@ async function mcp(path, { port = 4767, agent = "mcp", quiet = QUIET_MS, input =
 				name: "isorite",
 				version: "0.1.0"
 			},
-			instructions: "A knowledge base of notes. Call brief_base first, then look things up with search_notes, outline_note and read_note, following a note's links before searching again. Cite a note by its title and section."
+			instructions: "A knowledge base of notes. Call brief_base first, then look things up with search_notes, outline_note and read_note, following a note's links before searching again. Cite a note by its title and section. Other knowledge bases lent to you (the agent's memory among them) are named by brief_base: pass base to the same tools to look or write there, and follow the practice each one's brief gives."
 		};
 		if (rpc.method === "ping") return {};
 		if (rpc.method === "tools/list") return { tools: (await get("/api/agent/tools")).map(({ function: t }) => ({
@@ -10491,6 +10947,90 @@ async function writeGeometry(folder, now = Date.now()) {
 	return { notes };
 }
 //#endregion
+//#region packages/server/src/memory.ts
+init_src$1();
+const MEMORY_FOLDER = join(homedir(), "isorite-memory");
+/** The memory's practice, as the agent is to follow it: read with brief_base, whichever base a session is for. */
+const MEMORY_AGENTS = `# What you keep across projects: the person, their tools, and what you have learned working with them.
+
+This knowledge base is your memory. It is lent to every session, whatever project the session is for. Look in it,
+and keep it, with the knowledge base tools, giving \`base: "memory"\`.
+
+## When to look
+
+- At the start of a task: search for the person, the project's tools and the kind of work.
+- Before asking the person something they may have told you before.
+
+## What to keep
+
+Keep what will be useful in another project, or in a later session of this one:
+- **you/**: how the person likes to work, what they have corrected you on or confirmed, and why.
+- **tools/**: tools, services and machines, and how they are set up and reached.
+- **practice/**: ways of working that went well or badly, and mistakes not to repeat.
+- **projects/**: what is going on in each project that its own files don't say: goals, decisions, constraints,
+  with dates as dates.
+
+Don't keep what a project's own files, notes or history already say, what matters only to this conversation, or
+anything secret: keys, passwords, tokens.
+
+## How to keep it
+
+- One note for each thing worth keeping: its title says it, its first lines give the fact, then **Why:** and
+  **When it applies:**.
+- Link it to the notes it touches.
+- Update the note that is there rather than writing a second one, and delete a note that turns out to be wrong.
+- Write as you learn, not at the end: the person sees each note you write marked as yours, and can undo it.
+`;
+/** Make the memory, or say where it is: the folder (as isorite new makes it), a git repository of its own, its
+*  practice, and its row in bases.toml, lent. */
+function memory(folder = MEMORY_FOLDER, { config = configPath(), out = console.log, env = process.env } = {}) {
+	const at = resolve(folder), known = knownBases(config);
+	const had = known.find((b) => b.path === at) ?? (folder === MEMORY_FOLDER ? known.find((b) => b.name === "memory") : void 0);
+	if (had && existsSync(join(had.path, "AGENTS.md"))) {
+		out(`the memory is ${had.name}, at ${had.path}: ${had.lend ? "lent to every session" : `not lent (isorite bases lend ${had.name})`}`);
+		return 0;
+	}
+	if (!existsSync(join(at, "AGENTS.md"))) {
+		if (existsSync(at) && readdirSync(at).some((f) => f !== ".isorite" && f !== ".git")) throw new StudyError(`${at} has files in it already, and no ${AGENTS_FILE}: name another folder, isorite memory <folder>`);
+		newBase(at);
+		writeFileSync(join(at, AGENTS_FILE), MEMORY_AGENTS);
+		out(existsSync(join(at, ".git")) || gitInit(at, { env }) ? `isorite memory: made at ${at}, a private repository of its own: push it where you like` : `isorite memory: made at ${at}; not a git repository (git did not answer, or is not here): git init it yourself`);
+	}
+	const name = rememberBase(at, {
+		path: config,
+		as: "memory",
+		lend: true
+	});
+	out(`  ${name}: lent to every session's agent and Iso, as listed in ${basesPath(config)}`);
+	out(`  watch it learn: isorite serve ${at}, or switch to ${name} in the page of a running server`);
+	return 0;
+}
+/** isorite bases: the bases this device knows; `lend <name>` and `keep <name>` (lend it no longer). */
+function bases(args, { config = configPath(), out = console.log } = {}) {
+	const [verb, name] = args;
+	if (verb === "lend" || verb === "keep") {
+		const known = knownBases(config).find((b) => b.name === name);
+		if (!known) {
+			out(`no base ${name ?? ""} is known: isorite bases lists them`);
+			return 2;
+		}
+		rememberBase(known.path, {
+			path: config,
+			lend: verb === "lend"
+		});
+		out(`${known.name}: ${verb === "lend" ? "lent to every session" : "not lent"}`);
+		return 0;
+	}
+	const known = knownBases(config);
+	if (!known.length) {
+		out("no bases yet: each one you open is listed here (isorite serve, term, mcp); isorite memory makes the agent's memory");
+		return 0;
+	}
+	const width = Math.max(...known.map((b) => b.name.length));
+	for (const b of known) out(`${b.name.padEnd(width)}  ${b.lend ? "lent " : "     "}  ${b.path}${existsSync(b.path) ? "" : "  (not there)"}`);
+	return 0;
+}
+//#endregion
 //#region packages/server/src/main.ts
 init_src$1();
 init_model();
@@ -10519,6 +11059,10 @@ const USAGE = `isorite: an agentic harness for understanding
                                          provider (asked a few words, a few hundred tokens), the terminal and
                                          the notes; --report gives it as one block, secrets hidden, to paste
                                          to someone (or an AI) helping
+  isorite memory [<folder>]              the agent's memory: a knowledge base (~/isorite-memory unless named),
+                                         a git repository of its own, lent to every session's agent and Iso
+  isorite bases [lend|keep <name>]       the bases this device knows, each listed as it is opened; lend one to
+                                         every session, or keep it to itself
   isorite help setup                     how isorite is set up, every setting and failure: written for an AI
                                          helping you set it up (docs/setup.md is for people)
   isorite guide [<folder>] [--port <n>]  the guide: a knowledge base about isorite, with things to do in it,
@@ -10557,7 +11101,8 @@ function main(argv) {
 			const allowHosts = rest.flatMap((a, i) => a === "--allow-host" && rest[i + 1] ? [rest[i + 1]] : []);
 			return serve$1(rest[0], {
 				...port === void 0 ? {} : { port },
-				allowHosts
+				allowHosts,
+				held: rest.includes("--held")
 			}).then(() => new Promise(() => void 0), (e) => {
 				if (e instanceof StudyError) {
 					console.error(e.message);
@@ -10613,6 +11158,8 @@ function main(argv) {
 			}
 			return modelCommand(rest.includes("--from") ? from : void 0);
 		}
+		if (command === "memory") return memory(rest.find((a) => !a.startsWith("--")));
+		if (command === "bases") return bases(rest);
 		if (command === "--version" || command === "-v") {
 			console.log(VERSION);
 			return 0;
@@ -10669,11 +11216,32 @@ function main(argv) {
 	process.stdout.write(USAGE);
 	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
+*  seen to stall. To stderr, as `mcp` speaks on stdout; once, not again when the command runs itself again with
+*  the proxy on (ISORITE_STARTING). */
+const STARTS = /* @__PURE__ */ new Set([
+	"serve",
+	"term",
+	"mcp",
+	"guide",
+	"tutorial",
+	"--tutorial"
+]);
+function starting(argv, env = process.env, write = (s) => process.stderr.write(s)) {
+	if (!STARTS.has(argv[0] ?? "") || env.ISORITE_STARTING) return false;
+	write("isorite: starting…\n");
+	return true;
+}
 if (process.argv[1] && import.meta.url === pathToFileURL(realpathSync(resolve(process.argv[1]))).href) {
+	starting(process.argv.slice(2));
+	delete process.env.ISORITE_STARTING;
 	const env = proxied(process.env);
-	if (env) process.exit(await rerun(env));
+	if (env) process.exit(await rerun({
+		...env,
+		ISORITE_STARTING: "1"
+	}));
 	trustSystem();
 	process.exit(await main(process.argv.slice(2)));
 }
 //#endregion
-export { check, main };
+export { check, main, starting };