isorite 0.13.0 → 0.14.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;
@@ -5102,7 +5114,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 +5172,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
@@ -6026,7 +6038,7 @@ var AcpFollower = class {
 };
 //#endregion
 //#region packages/server/src/version.ts
-const VERSION = "0.13.0";
+const VERSION = "0.14.0";
 //#endregion
 //#region packages/server/src/connect.ts
 const HARNESSES = [{
@@ -6224,6 +6236,87 @@ 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(" ,", ",") + "."
+		}];
+	});
+}
+/** 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 +6487,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. */
@@ -6765,6 +6860,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 detectAgents();
+		}));
 		app.get("/api/acp/registry", (c) => answer(c, async () => registryAgents().catch((e) => {
 			throw new EngineError(e.message, 502);
 		})));
@@ -7321,6 +7420,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;
@@ -7389,7 +7489,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 +7609,11 @@ 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 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 +7854,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 +7865,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 +7876,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 +7898,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
@@ -9141,10 +9246,123 @@ 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 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(io.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(io.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,9 +9442,80 @@ 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;
+		},
+		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]);
@@ -9358,7 +9647,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 +9697,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

package/docs/setup.md

@@ -35,14 +35,13 @@ If the company's authority isn't installed on the machine, name its certificate
 
 ## 2. Your notes
 
-A folder of Markdown files. To start from nothing:
+A folder of Markdown files. In your project's folder:
 
 ```sh
-isorite new ~/notes/my-project
-isorite serve ~/notes/my-project
+isorite
 ```
 
-`isorite new` makes the folder, empty but for isorite's own `.isorite/`. A folder of notes you have already is opened as it is, with `isorite serve`. It prints a link to click: `http://localhost:4767/`. isorite keeps what it needs in the folder's `.isorite/`.
+It opens the base it finds there (a folder with `.isorite/` in it, the project's top folder or its `notes/`); with none it offers to make `notes/`; from any other folder it lists the bases this machine knows, last used first, with a new base here and the guide. It opens your browser, and prints the link too: `http://localhost:4767/` (the next free port if that one is taken; `--port <n>` to choose, `--no-open` to leave the browser alone). To name a folder yourself: `isorite new ~/notes/my-project`, then `isorite serve ~/notes/my-project`. A folder of notes you have already is opened as it is. isorite keeps what it needs in the folder's `.isorite/`.
 
 How you want the base kept (your notation, the level, the language, how notes are named) goes in `AGENTS.md` at the top of the notes, which every agent you attach is given. Edit it in Iso's settings, the icon at the right of its pane's header, or in any editor. An agent may offer a line for it when you say how you want things done.
 
@@ -72,6 +71,8 @@ lend = true
 
 ## Search by meaning (optional)
 
+The first start without the model offers it, once; a no is remembered. Later, or by hand:
+
 ```sh
 isorite model
 ```

package/docs/terminal.md

@@ -9,7 +9,7 @@ Setting isorite up the first time is in [setup.md](setup.md).
 Keep the project's notes in a folder of their own, often inside the project's repository (`notes/`), or beside it (`~/notes/<project>`). It can start empty: `isorite new <folder>` makes it. isorite keeps what it needs in the folder's `.isorite/` (the journals of every change, the sessions it carried, and its settings), made the first time the folder is opened. Commit `.isorite/` with the notes, if they're in git.
 
 ```sh
-isorite serve ~/code/my-project/notes
+isorite          # in the project: finds its base, opens the browser (isorite serve <notes> names one yourself)
 ```
 
 ## Three ways in

package/guide/your-own-base/starting-a-base.md

@@ -8,14 +8,14 @@ isorite runs on your own machine, with Node 24 or later:
 
 ```sh
 npm install -g isorite
-isorite new ~/notes/physics
-isorite serve ~/notes/physics
+cd ~/code/my-project
+isorite
 ```
 
-`isorite new` makes an empty base, and `isorite serve` opens it in the browser. A folder of Markdown you have already is a base as it is.
+`isorite` opens the project's base in the browser. With none it offers to make a `notes/` folder, and from any other folder it lists the bases it knows and the guide. A folder of Markdown you have already is a base as it is.
 
 isorite calls no model itself: it attaches to the agent you already use, set up as it is for its own terminal, with its own key and model. From Iso's pane, choose one, or give isorite's MCP to the agent in its own terminal: see [your own agent](/terminal/your-own-agent.md "see also"). `isorite doctor` checks what isorite needs, and offers the project's MCP config. The steps are in the guide on GitHub: [setting up](https://github.com/lachlanjs/isorite/blob/main/docs/setup.md).
 
-`isorite guide` puts this guide in a folder of your own, where your own agent can be attached.
+`isorite guide` (or choosing the guide from the list `isorite` shows) puts this guide in a folder of your own, where your own agent can be attached.
 
 Then [keep it well](/your-own-base/keeping-a-base-well.md "see also").

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "isorite",
-  "version": "0.13.0",
+  "version": "0.14.0",
   "description": "An agentic harness for understanding: your notes as a knowledge base, an Atlas of them, an agent that reads them, and study.",
   "license": "MIT",
   "type": "module",