@appsoftwareltd/etherpk-mcp 0.11.1 → 0.13.0

package/dist/main.js

@@ -717,7 +717,7 @@ function looksLikeAgentSetupCode(value) {
 }
 var package_default = {
 	name: "@appsoftwareltd/etherpk-mcp",
-	version: "0.11.1",
+	version: "0.13.0",
 	license: "Elastic-2.0",
 	description: "EtherPK Headless Client: an MCP server over a synced knowledge graph, run beside the agent on the user's own machine.",
 	type: "module",
@@ -1541,6 +1541,7 @@ async function openVault(envelope, key) {
 	};
 	throw new EnvelopeError(`unexpected vault envelope kind ${envelope[1] ?? "none"}`);
 }
+contextAad("settings-vault", "v1");
 var PAD_TO = 64;
 var LENGTH_PREFIX = 2;
 function graphNameAad(graphId) {
@@ -1743,6 +1744,19 @@ function createSyncApi(deps) {
 			method: "PUT",
 			body: JSON.stringify(write)
 		}).then((r) => r.version),
+		/**
+		* The person's Settings Vault (ADR 0148), or null while the account has none. An agent
+		* token is refused it: only the account's own devices read it.
+		*/
+		getSettingsVault: () => call("/api/v1/sync/settings-vault").catch((e) => {
+			if (e instanceof SyncApiError && e.status === 404) return null;
+			throw e;
+		}),
+		/** Write the Settings Vault, signed. Resolves to the new version. A stale `expectedVersion` rejects with status 409. */
+		putSettingsVault: (write) => call("/api/v1/sync/settings-vault", {
+			method: "PUT",
+			body: JSON.stringify(write)
+		}).then((r) => r.version),
 		/** Key Replacement (ADR 0128): new keys, and everything an old copy of them reached cut off. */
 		replaceKeys: (replacement) => call("/api/v1/sync/keys/replace", {
 			method: "POST",
@@ -2560,7 +2574,7 @@ var TLS_CODES = /* @__PURE__ */ new Set([
 function describeConnectionFailure(error, syncServer) {
 	if (error instanceof SyncApiError) {
 		if (error.status === 404 && error.message === "HTTP 404") return `${syncServer} is not a Sync Server (it may be the EtherPK app). Use the Sync Server address shown in EtherPK under a synced graph's Settings > Agents.`;
-		if (error.status === 401) return `${syncServer} did not accept the token: it may have been revoked, mistyped, or left unused for 30 days. Make a setup code in EtherPK (a synced graph's Settings > Agents) and run login again.`;
+		if (error.status === 401) return `${syncServer} did not accept the token: it may have been revoked, mistyped, or left unused for 30 days. Create an Agent Setup Code in EtherPK (the Graphs page's Agents tab, or a synced graph's Settings > Agents) and run login again.`;
 		return null;
 	}
 	if (error instanceof TypeError && error.message === "fetch failed") {
@@ -2638,9 +2652,9 @@ function resolveGraphById(graphs, vault, graphId) {
 /**
 * How the Headless Client gets and gives up its agent token (ADR 0132), against the Sync Server's
 * own routes. Separate from the shared REST bridge (`sync-api.ts`), which always sends a token:
-* redeeming a setup code is the one call made before this computer holds any.
+* redeeming an Agent Setup Code is the one call made before this computer holds any.
 *
-* - `redeemSetupCode`: `login --code` trades the one-time code for the agent token.
+* - `redeemSetupCode`: `login --code` trades the one-time Agent Setup Code for the agent token.
 * - `exchangeForAgentToken`: a standard token, pasted into `login` or left in the login file by
 *   an older version, is traded for an agent token; the Sync Server revokes the standard one.
 * - `revokeHeldToken`: `logout` revokes the token it is about to forget, so no token is left on
@@ -2656,7 +2670,6 @@ var AgentTokenError = class extends Error {
 		this.name = "AgentTokenError";
 	}
 };
-var OLDER_SERVER = "This Sync Server runs an older version of EtherPK that cannot give agent tokens. Ask whoever runs it to update it, or log in with an access token from its Access tokens page.";
 function base(syncServer) {
 	return syncServer.replace(/\/+$/, "");
 }
@@ -2666,38 +2679,31 @@ async function tokenFrom(response) {
 	if (response.ok && typeof body?.token === "string") return body.token;
 	throw new AgentTokenError(body?.error?.message ?? `HTTP ${response.status}`, response.status, body?.error?.code);
 }
-/** Trade a one-time setup code for an agent token named `name` ("Agent on <hostname>"). */
+/** Trade a one-time Agent Setup Code for an agent token named `name` ("Agent on <hostname>"). */
 async function redeemSetupCode(call) {
-	const response = await (call.fetch ?? fetch)(`${base(call.syncServer)}/api/v1/sync/agent-tokens`, {
+	return tokenFrom(await (call.fetch ?? fetch)(`${base(call.syncServer)}/api/v1/sync/agent-tokens`, {
 		method: "POST",
 		headers: { "content-type": "application/json" },
 		body: JSON.stringify({
 			setupCode: call.code,
 			name: call.name
 		})
-	});
-	if (response.status === 404 && !response.headers.get("content-type")?.includes("json")) throw new AgentTokenError(OLDER_SERVER, 404);
-	return tokenFrom(response);
+	}));
 }
-/**
-* Trade the standard token `token` for an agent token named `name`; the server revokes `token`.
-* Null on a server from before agent tokens, where the standard token simply goes on working.
-*/
+/** Trade the standard token `token` for an agent token named `name`; the server revokes `token`. */
 async function exchangeForAgentToken(call) {
-	const response = await (call.fetch ?? fetch)(`${base(call.syncServer)}/api/v1/sync/agent-tokens`, {
+	return tokenFrom(await (call.fetch ?? fetch)(`${base(call.syncServer)}/api/v1/sync/agent-tokens`, {
 		method: "POST",
 		headers: {
 			"content-type": "application/json",
 			authorization: `Bearer ${call.token}`
 		},
 		body: JSON.stringify({ name: call.name })
-	});
-	if (response.status === 404 && !response.headers.get("content-type")?.includes("json")) return null;
-	return tokenFrom(response);
+	}));
 }
 /**
 * Revoke the token this computer holds. True once the server has revoked it; false when it could
-* not be reached or refused (already revoked, expired, or a server from before this route), which
+* not be reached or refused (already revoked or expired), which
 * a logout reports but does not stop for: the local copy is forgotten either way.
 */
 async function revokeHeldToken(call) {
@@ -3017,8 +3023,8 @@ async function forgetLoginSecrets(syncServer, stored, keychain) {
 /**
 * A login an older Headless Client made holds a standard token, which reaches everything a
 * signed-in session does. Trade it for an agent token, which the Sync Server revokes the standard
-* one for, and save that in its place. Anything that stops the trade (a server from before agent
-* tokens, no network) leaves the login as it was, to be tried again on the next run.
+* one for, and save that in its place. A trade that fails (no network, a server not answering)
+* leaves the login as it was, to be tried again on the next run.
 */
 async function upgradeToAgentToken(opts) {
 	const { path, credentials, keychain, name, say } = opts;
@@ -3036,7 +3042,6 @@ async function upgradeToAgentToken(opts) {
 				token: current.pat,
 				name
 			});
-			if (!agentToken) return current;
 			const where = await saveLogin({
 				config,
 				path,
@@ -3055,7 +3060,7 @@ async function upgradeToAgentToken(opts) {
 		});
 	} catch (error) {
 		const reason = error instanceof Error ? error.message : String(error);
-		if (opts.stillWorks && !await opts.stillWorks(credentials.pat).catch(() => true)) say(`etherpk-mcp: could not replace the access token for ${credentials.syncServer} with an agent token (${reason}), and the old token no longer works. Make a setup code in EtherPK (a synced graph's Settings > Agents) and run login again.`);
+		if (opts.stillWorks && !await opts.stillWorks(credentials.pat).catch(() => true)) say(`etherpk-mcp: could not replace the access token for ${credentials.syncServer} with an agent token (${reason}), and the old token no longer works. Create an Agent Setup Code in EtherPK (the Graphs page's Agents tab, or a synced graph's Settings > Agents) and run login again.`);
 		else say(`etherpk-mcp: could not replace the access token for ${credentials.syncServer} with an agent token this time (${reason}). It goes on working, and the next run tries again.`);
 		return credentials;
 	}
@@ -3616,6 +3621,28 @@ function compareGroups$1(a, b) {
 	return conceptKey$1(a.sourceConcept).localeCompare(conceptKey$1(b.sourceConcept));
 }
 //#endregion
+//#region ../client/src/lib/document/backlinks/shown-backlinks.ts
+/**
+* The groups with a Template's body links left out and its title kept. A Template whose only
+* links are in its body drops out whole.
+*/
+function withoutTemplateContent(groups) {
+	const kept = [];
+	for (const group of groups) {
+		if (!group.sourceIsTemplate) {
+			kept.push(group);
+			continue;
+		}
+		const refs = group.refs.filter((ref) => ref.kind === "title");
+		if (refs.length > 0) kept.push({
+			...group,
+			refs,
+			bodyNames: []
+		});
+	}
+	return kept;
+}
+//#endregion
 //#region ../client/src/lib/document/index-db-sqlite.ts
 /**
 * Adapter from the `@sqlite.org/sqlite-wasm` oo1 DB to the engine-agnostic
@@ -4564,7 +4591,8 @@ function blocksAndLinks(text) {
 	};
 }
 /** Derive the index rows for a single document's text. Pure. */
-function deriveDoc(text) {
+function deriveDoc(text, options = {}) {
+	if (options.template) return deriveTemplate(text);
 	const { blocks, links, lineToBlock } = blocksAndLinks(text);
 	const candidateTasks = blocks.filter((b) => b.kind === "task");
 	const fenced = candidateTasks.length === 0 ? () => false : fencedLines(text);
@@ -4595,6 +4623,21 @@ function deriveDoc(text) {
 		searchText: withoutExtensionFences(text, blocks, lineToBlock, maps.searchText)
 	};
 }
+/** A variable's opening braces in a link target: `[[{{date}}]]` names no concept until copied. */
+var VARIABLE_IN_TARGET = /\{\{/;
+function deriveTemplate(text) {
+	const { blocks, links, lineToBlock } = blocksAndLinks(text);
+	const maps = deriveMaps(text, blocks, links, lineToBlock);
+	return {
+		blocks,
+		links: links.filter((link) => !VARIABLE_IN_TARGET.test(link.concept)),
+		tasks: [],
+		taskConcepts: [],
+		mapItems: [],
+		mapConcepts: [],
+		searchText: withoutExtensionFences(text, blocks, lineToBlock, maps.searchText)
+	};
+}
 /**
 * What search and Semantic Search read for each block holding an [[Extension Fence]] (ADR 0138):
 * the block's text with the fence's lines left out, so an extension's data (a drawing's elements)
@@ -5162,10 +5205,12 @@ CREATE TABLE IF NOT EXISTS index_metadata (
   key TEXT PRIMARY KEY, value INTEGER NOT NULL);
 -- protected: the stored text holds a cipher fence (fence-info.ts). Kept on the page row so a
 -- listing can wear a padlock without opening the document - the one cheap answer the tab has.
+-- template: the page is a [[Template]] (ADR 0144). Its links are kept for a rename and marked
+-- by this, so the views that show relations can leave them out. Never set on a protected page.
 CREATE TABLE IF NOT EXISTS pages (
   id INTEGER PRIMARY KEY, concept TEXT NOT NULL, concept_key TEXT NOT NULL, kind TEXT NOT NULL,
   text_hash TEXT NOT NULL DEFAULT '', generation INTEGER NOT NULL DEFAULT 1,
-  protected INTEGER NOT NULL DEFAULT 0);
+  protected INTEGER NOT NULL DEFAULT 0, template INTEGER NOT NULL DEFAULT 0);
 CREATE TABLE IF NOT EXISTS aliases (
   page_id INTEGER NOT NULL, alias_key TEXT NOT NULL, display TEXT NOT NULL);
 -- A publication page's includes (ADR 0082), one row per slot: page_id is the PUBLICATION
@@ -5273,7 +5318,7 @@ function createSchema(db) {
 	db.exec(SCHEMA$1);
 	db.run("INSERT OR IGNORE INTO index_metadata (key, value) VALUES ('active_generation', 1)");
 	db.run("INSERT OR IGNORE INTO index_metadata (key, value) VALUES ('revision', 0)");
-	db.exec(`PRAGMA user_version = 16`);
+	db.exec(`PRAGMA user_version = 17`);
 }
 function activeIndexGeneration(db) {
 	return db.all("SELECT value FROM index_metadata WHERE key = 'active_generation'")[0]?.value ?? 1;
@@ -5294,7 +5339,7 @@ function advanceIndexRevision(db) {
 */
 function isUsableIndex(db) {
 	try {
-		return db.all("PRAGMA user_version")[0]?.user_version === 16;
+		return db.all("PRAGMA user_version")[0]?.user_version === 17;
 	} catch {
 		return false;
 	}
@@ -5347,10 +5392,11 @@ function indexDocHash(doc) {
 	const includes = doc.includes ?? [];
 	const properties = doc.properties ?? [];
 	const aliases = doc.aliases ?? [];
-	if (includes.length === 0 && properties.length === 0 && aliases.length === 0) return hashText(doc.text);
+	if (includes.length === 0 && properties.length === 0 && aliases.length === 0 && !doc.template) return hashText(doc.text);
 	const includeText = includes.map((i) => `${i.publication}\u0001${i.slot}\u0001${i.concept}`).join("\0");
 	const propertyText = properties.map((p) => `${p.key}\u0001${p.value ?? ""}`).join("\0");
-	return hashText(`${doc.text}\u0000${includeText}\u0003${propertyText}\u0004${aliases.join("\0")}`);
+	const templateMark = doc.template ? "template" : "";
+	return hashText(`${doc.text}\u0000${includeText}\u0003${propertyText}\u0004${aliases.join("\0")}${templateMark}`);
 }
 function hashText(text) {
 	let h1 = 3735928559;
@@ -5409,7 +5455,7 @@ function insertDerived(db, pageId, doc) {
 		t.matchEnd,
 		null
 	]);
-	const { blocks, links, tasks, taskConcepts, mapItems, mapConcepts, searchText } = deriveDoc(doc.text);
+	const { blocks, links, tasks, taskConcepts, mapItems, mapConcepts, searchText } = deriveDoc(doc.text, { template: templateFlag(doc) === 1 });
 	for (const b of blocks) {
 		db.run("INSERT INTO blocks (page_id, local_id, parent_local_id, ord, kind, depth, done, start_line, end_line, label, text) VALUES (?,?,?,?,?,?,?,?,?,?,?)", [
 			pageId,
@@ -5615,15 +5661,23 @@ function purgeIfProtected(db, generation) {
 function protectedFlag(doc) {
 	return containsCipherFence(doc.text) ? 1 : 0;
 }
+/**
+* The `template` column as stored. A [[Protected Document]] is never a [[Template]] (ADR 0144):
+* its text cannot be read for a copy, and the index holds none of its frontmatter's meaning.
+*/
+function templateFlag(doc) {
+	return doc.template === true && doc.kind === "page" && protectedFlag(doc) === 0 ? 1 : 0;
+}
 function insertPage(db, pageId, generation, doc) {
-	db.run("INSERT INTO pages (id, concept, concept_key, kind, text_hash, generation, protected) VALUES (?,?,?,?,?,?,?)", [
+	db.run("INSERT INTO pages (id, concept, concept_key, kind, text_hash, generation, protected, template) VALUES (?,?,?,?,?,?,?,?)", [
 		pageId,
 		doc.concept,
 		conceptKey$1(doc.concept),
 		doc.kind,
 		indexDocHash(doc),
 		generation,
-		protectedFlag(doc)
+		protectedFlag(doc),
+		templateFlag(doc)
 	]);
 	insertDerived(db, pageId, doc);
 }
@@ -5708,23 +5762,25 @@ function ingestOne(db, doc) {
 		if (found.length > 0) {
 			pageId = found[0].id;
 			deleteDerivedRows(db, pageId);
-			db.run("UPDATE pages SET concept = ?, kind = ?, text_hash = ?, protected = ? WHERE id = ?", [
+			db.run("UPDATE pages SET concept = ?, kind = ?, text_hash = ?, protected = ?, template = ? WHERE id = ?", [
 				doc.concept,
 				doc.kind,
 				indexDocHash(doc),
 				protectedFlag(doc),
+				templateFlag(doc),
 				pageId
 			]);
 		} else {
 			pageId = (db.all("SELECT COALESCE(MAX(id), 0) AS n FROM pages")[0]?.n ?? 0) + 1;
-			db.run("INSERT INTO pages (id, concept, concept_key, kind, text_hash, generation, protected) VALUES (?,?,?,?,?,?,?)", [
+			db.run("INSERT INTO pages (id, concept, concept_key, kind, text_hash, generation, protected, template) VALUES (?,?,?,?,?,?,?,?)", [
 				pageId,
 				doc.concept,
 				key,
 				doc.kind,
 				indexDocHash(doc),
 				generation,
-				protectedFlag(doc)
+				protectedFlag(doc),
+				templateFlag(doc)
 			]);
 		}
 		const written = new Set(insertDerived(db, pageId, doc));
@@ -5939,10 +5995,25 @@ function conceptFamilyKeys(db, key) {
 function indexDocumentFactKeys(doc) {
 	return {
 		aliases: doc.aliases.map(conceptKey$1),
-		linkTargets: [.../* @__PURE__ */ new Set([...deriveTitleLinks(doc.concept).map((link) => conceptKey$1(link.concept)), ...deriveDoc(doc.text).links.map((link) => conceptKey$1(link.concept))])],
+		linkTargets: [.../* @__PURE__ */ new Set([...deriveTitleLinks(doc.concept).map((link) => conceptKey$1(link.concept)), ...deriveDoc(doc.text, { template: templateFlag(doc) === 1 }).links.map((link) => conceptKey$1(link.concept))])],
 		includeTargets: [...new Set((doc.includes ?? []).map((include) => conceptKey$1(include.concept)))].sort()
 	};
 }
+/**
+* The graph's [[Template]]s (ADR 0144), ordered by name as it reads with the brackets of a
+* [[Scope]] left out, so `[[Templates]] Daily` sorts among the Ts. One query over rows the index
+* already holds: no document is opened to list them.
+*/
+function templatePages(db) {
+	const generation = activeIndexGeneration(db);
+	const rows = db.all(`SELECT p.concept, (SELECT b.label FROM blocks b WHERE b.page_id = p.id ORDER BY b.local_id LIMIT 1) AS firstLine
+         FROM pages p WHERE p.generation = ? AND p.template = 1`, [generation]);
+	const sortKey = (concept) => concept.replace(/\[\[|\]\]/g, "").toLowerCase();
+	return rows.map((row) => ({
+		concept: row.concept,
+		firstLine: row.firstLine ?? ""
+	})).sort((a, b) => sortKey(a.concept).localeCompare(sortKey(b.concept)));
+}
 /** The canonical page id a concept resolves to (by its own name or an alias), or null. */
 function canonicalPageId(db, key) {
 	const generation = activeIndexGeneration(db);
@@ -6093,7 +6164,7 @@ function backlinksFor(db, concept) {
 	const placeholders = names.map(() => "?").join(",");
 	const generation = activeIndexGeneration(db);
 	const hits = db.all(`SELECT l.page_id, l.concept_key, p.concept AS sourceConcept, p.kind AS sourceKind, l.line, l.line_text,
-                l.match_start, l.match_end, l.block_local_id, l.in_title
+                l.match_start, l.match_end, l.block_local_id, l.in_title, p.template
          FROM links l JOIN pages p ON p.id = l.page_id
          WHERE p.generation=? AND l.concept_key IN (${placeholders})
          ORDER BY l.page_id, l.line, l.match_start`, [generation, ...names]);
@@ -6125,7 +6196,8 @@ function backlinksFor(db, concept) {
 				sourceKind: h.sourceKind,
 				refs: [],
 				bodyNames: [],
-				sourceIsTarget: h.page_id === pageId
+				sourceIsTarget: h.page_id === pageId,
+				sourceIsTemplate: h.template === 1
 			};
 			groups.set(h.sourceConcept, group);
 		}
@@ -6159,7 +6231,7 @@ var SNIPPET_TOKENS = 24;
 * scores merely reintroduces the long-document bias bm25 exists to remove. Counting is cruder,
 * robust, and explainable in one sentence - and it orders by a number the row displays.
 */
-function searchText$1(db, query, offset, limit, filters = []) {
+function searchText$2(db, query, offset, limit, filters = []) {
 	const match = buildFtsMatch(query);
 	if (match === null) return {
 		groups: [],
@@ -6937,7 +7009,7 @@ function cacheRoot(env) {
 * recovered from a joined path (see there).
 */
 var CACHE_FILE_NAME = `local-cache.v${CACHE_DB_VERSION}.bin`;
-var INDEX_FILE_NAME = `index.v16.sqlite`;
+var INDEX_FILE_NAME = `index.v17.sqlite`;
 var VECTORS_FILE_NAME = `vectors.v1.sqlite`;
 function cacheFile(dir) {
 	return join(dir, CACHE_FILE_NAME);
@@ -10124,10 +10196,13 @@ function createGraphSync(deps) {
 	let forceToken = false;
 	let credentialRefusals = 0;
 	let reconnectTimer;
+	/** True while a retry waits on `reconnectTimer`: no socket is open or being made. */
+	let retryWaiting = false;
 	const retryDelay = deps.retryDelayMs ?? ((attempt) => reconnectDelayMs(attempt));
 	function scheduleConnect(delayMs) {
 		if (disposed || lost || protocolMismatch) return;
 		clearTimeout(reconnectTimer);
+		retryWaiting = true;
 		reconnectTimer = setTimeout(connect, delayMs);
 	}
 	function backOff() {
@@ -10159,6 +10234,7 @@ function createGraphSync(deps) {
 	* on open. Only rebuildable snapshot uploads use a volatile queue.
 	*/
 	function connect() {
+		retryWaiting = false;
 		if (disposed || lost || protocolMismatch) return;
 		const force = forceToken;
 		forceToken = false;
@@ -10458,6 +10534,11 @@ function createGraphSync(deps) {
 			refusalTimer = void 0;
 			resendRefused();
 		},
+		reconnectNow() {
+			if (!retryWaiting || disposed || lost || protocolMismatch) return;
+			attempts = 0;
+			scheduleConnect(0);
+		},
 		async flushAll({ onProgress } = {}) {
 			const all = [...engines.values()];
 			let flushed = 0;
@@ -11517,19 +11598,25 @@ function publicDocumentsInNoPublication(documents, publications) {
 //#endregion
 //#region ../client/src/lib/document/publish/host/site-writer.ts
 /**
-* Stale files are removed only from the places the publisher owns. `etherpk-publish.json` is not
-* produced but stays owned, so the first publish after the upgrade deletes the copy an older
-* build left in the folder.
+* The folders the publisher writes into, whole: the graph's assets, the theme, and the pictures
+* it draws for maps (`maps/`) and for extension blocks (`pictures/`). Those pictures are named by
+* their content, so a changed map or an unpublished page leaves the old one behind as a stray.
 */
+var OWNED_FOLDERS = [
+	"assets/",
+	"theme/",
+	"maps/",
+	"pictures/"
+];
+/** Stale files are removed only from the places the publisher owns. */
 function isOwnedPath(path) {
-	if (path.startsWith("assets/") || path.startsWith("theme/")) return true;
+	if (OWNED_FOLDERS.some((folder) => path.startsWith(folder))) return true;
 	if (path.includes("/")) return false;
 	return /\.html$/.test(path) || [
 		"search.json",
 		"search-index.js",
 		"sitemap.xml",
 		"feed.xml",
-		"etherpk-publish.json",
 		".nojekyll"
 	].includes(path);
 }
@@ -12038,7 +12125,6 @@ not here.
 wrangler.jsonc
 AGENTS.md
 README.md
-etherpk-publish.json
 `]
 	]);
 }
@@ -12058,7 +12144,7 @@ and files that are no longer produced are deleted.
   frontmatter says \`public: true\` and names this publication in \`publications: [${publication.id}]\`
   (unless the publication takes every public document).
 - The navigation is the outline of the publication page in EtherPK - the theme and the include
-  slots (head, logo, header, footer, before-content, after-content, scripts, styles) are chosen
+  slots (head, favicon, logo, header, footer, before-content, after-content, scripts, styles) are chosen
   and edited there too, in the Publish settings and the Theme editor.
 - \`index.html\` opens from disk for a preview. \`.github/workflows/pages.yaml\` deploys the folder
   to GitHub Pages, \`wrangler.jsonc\` deploys it to Cloudflare Workers, and any static host serves it
@@ -12078,6 +12164,80 @@ function agentsMdWithManagedSection(existing, publication) {
 	return `${existing.trimEnd()}\n\n${section}`;
 }
 //#endregion
+//#region ../client/src/lib/document/fence-answer.ts
+var PICTURE_TYPES = /* @__PURE__ */ new Set([
+	"image/svg+xml",
+	"image/png",
+	"image/webp"
+]);
+/** An `https` address as written, or null for any other. */
+function httpsAddress(value) {
+	if (typeof value !== "string") return null;
+	try {
+		return new URL(value).protocol === "https:" ? value : null;
+	} catch {
+		return null;
+	}
+}
+/** A positive, finite size, or undefined. */
+function size(value) {
+	return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : void 0;
+}
+/**
+* The answer as it may be used, or null where the extension said there is nothing to show. Throws,
+* saying why, for anything else: an answer missing altogether among them, which is a mistake rather
+* than a choice.
+*/
+function checkedFenceAnswer(out) {
+	if (out === null) return null;
+	if (typeof out !== "object") throw new Error("it answered with something that is neither a picture nor a link");
+	const answer = out;
+	const kind = answer.kind;
+	if (kind === "picture") {
+		const { type, bytes, alt } = answer;
+		const width = size(answer.width);
+		const height = size(answer.height);
+		if (typeof type !== "string" || !PICTURE_TYPES.has(type) || !(bytes instanceof Uint8Array)) throw new Error("its picture is not an SVG, PNG or WebP file");
+		if (width === void 0 || height === void 0) throw new Error("its picture has no size");
+		return {
+			kind: "picture",
+			type,
+			bytes: new Uint8Array(bytes),
+			width,
+			height,
+			alt: String(alt ?? "")
+		};
+	}
+	if (kind === "link") {
+		const href = httpsAddress(answer.href);
+		if (!href) throw new Error("its link is not an https address");
+		const text = answer.text;
+		const image = answer.image;
+		let picture;
+		if (image !== null && typeof image === "object") {
+			const { src: rawSrc, alt, width: rawWidth, height: rawHeight } = image;
+			const src = httpsAddress(rawSrc);
+			const width = size(rawWidth);
+			const height = size(rawHeight);
+			if (src) picture = {
+				src,
+				alt: String(alt ?? ""),
+				...width !== void 0 && height !== void 0 ? {
+					width,
+					height
+				} : {}
+			};
+		}
+		return {
+			kind: "link",
+			href,
+			text: String(text ?? href),
+			...picture ? { image: picture } : {}
+		};
+	}
+	throw new Error("it answered with something that is neither a picture nor a link");
+}
+//#endregion
 //#region ../client/src/lib/document/publish/derived.ts
 function searchIndexJson(entries) {
 	return `${JSON.stringify({
@@ -12974,6 +13134,59 @@ function linkGroups(match) {
 	return match.groups;
 }
 //#endregion
+//#region ../client/src/lib/document/line-endings.ts
+/** `text` with every `\r\n` and every lone `\r` written as `\n`; `text` itself when it holds no `\r`. */
+function lineFeedsOnly(text) {
+	return text.includes("\r") ? text.replace(/\r\n?/g, "\n") : text;
+}
+/**
+* The changes that turn `text` into {@link lineFeedsOnly}`(text)`, in document order and each
+* against `text` as it is: one per `\r`, deleting it before a `\n` and replacing it with `\n`
+* anywhere else. For a writer that must change a shared text in place rather than replace it,
+* applying them from the last to the first.
+*/
+function lineFeedChanges(text) {
+	const changes = [];
+	for (let at = text.indexOf("\r"); at !== -1; at = text.indexOf("\r", at + 1)) changes.push({
+		from: at,
+		to: at + 1,
+		insert: text[at + 1] === "\n" ? "" : "\n"
+	});
+	return changes;
+}
+//#endregion
+//#region ../client/src/lib/document/templates/template-page.ts
+/**
+* What makes a document a [[Template]], and the part of it a copy takes (ADR 0144).
+*
+* One predicate for every reader, so the index, the `/Template` picker, the Journal Template's
+* setting and the Headless Client cannot disagree about which pages are Templates.
+*/
+/**
+* True for a [[Page]] whose frontmatter says `template: true`. The value must be the boolean, as
+* `public` must be (publication.ts), so a quoted `"true"` or a name is not a Template. A
+* [[Journal Entry]] is never one: a day is not a pattern.
+*/
+function isTemplate(frontmatter, kind) {
+	return kind === "page" && frontmatter.template === true;
+}
+/**
+* The text a copy of the Template takes: everything below its frontmatter, without the blank
+* lines before and after it. The frontmatter itself is never copied, so a Template that says
+* `public: true` cannot make a copy public.
+*/
+function templateBody(text) {
+	return withoutBlankEnds(parseFrontmatter(text).body);
+}
+/**
+* The body in the form the editor holds text: line feeds only (ADR 0112), since a file another app
+* wrote may end its lines otherwise and a copy is offset by the editor's own lines. Then without
+* the blank lines before and after it.
+*/
+function withoutBlankEnds(body) {
+	return lineFeedsOnly(body).replace(/^(?:[ \t]*\n)+/, "").replace(/\s+$/, "");
+}
+//#endregion
 //#region ../client/src/lib/document/publish/resolve.ts
 /**
 * The publication's resolver: concept → destination inside one [[Published Site]]. Alias folding
@@ -12995,12 +13208,15 @@ function titleText(concept) {
 	return concept.replace(/\[\[|\]\]/g, "");
 }
 function createPublicationResolver(input) {
-	const index = buildBacklinkIndex(input.included.map((doc) => ({
-		concept: doc.concept,
-		kind: doc.kind,
-		aliases: [...doc.aliases],
-		text: parseFrontmatter(doc.text).body
-	})));
+	const index = buildBacklinkIndex(input.included.map((doc) => {
+		const { data, body } = parseFrontmatter(doc.text);
+		return {
+			concept: doc.concept,
+			kind: doc.kind,
+			aliases: [...doc.aliases],
+			text: isTemplate(data, doc.kind) ? "" : body
+		};
+	}));
 	const graphIndex = buildBacklinkIndex(input.allDocuments.map((doc) => ({
 		concept: doc.concept,
 		kind: doc.kind,
@@ -13170,12 +13386,15 @@ function buildNav(outline, resolver) {
 * an address keeps it whatever order the source listed it in. The generated files' names are
 * reserved.
 */
-/** Names the publisher writes itself; a document wanting one is suffixed instead. */
+/**
+* The pages the publisher writes itself (the home page, the 404 page, and the journal and posts
+* archives); a document wanting one of their names is suffixed instead.
+*/
 var RESERVED_SLUGS = [
 	"index",
 	"404",
 	"journal",
-	"search"
+	"posts"
 ];
 /** The document's `slug:` key normalised like any slug, or null when it has none. */
 function explicitSlugOf(text) {
@@ -13318,57 +13537,34 @@ var PICTURE_EXTENSIONS = {
 	"image/png": "png",
 	"image/webp": "webp"
 };
-/** An `https` address as written, or null for any other. */
-function httpsAddress(value) {
-	if (typeof value !== "string") return null;
-	try {
-		return new URL(value).protocol === "https:" ? value : null;
-	} catch {
-		return null;
-	}
-}
 /**
-* What an extension's `publish` answered for a fence, checked, its picture kept for the site under
-* a name taken from its bytes: a picture, a link (`https` only, as is any picture in it), null when
-* it is left out, or undefined when it could not be made, after which an ordinary fence is published
-* as code and an Extension Fence left out, with a warning either way.
+* What an extension's `publish` answered for a fence, checked (`fence-answer.ts`), its picture kept
+* for the site under a name taken from its bytes: a picture, a link (`https` only, as is any picture
+* in it), null when it is left out, or undefined when it could not be made, after which an ordinary
+* fence is published as code and an Extension Fence left out, with a warning either way.
 */
 async function publishedFence(asked, info, concept, pictures, warnings) {
 	try {
-		const out = await asked;
+		const out = checkedFenceAnswer(await asked);
 		if (out === null) return null;
 		if (out.kind === "picture") {
-			const extension = PICTURE_EXTENSIONS[out.type];
-			if (!(out.bytes instanceof Uint8Array) || !extension) throw new Error("its picture is not an SVG, PNG or WebP file");
 			const digest = await crypto.subtle.digest("SHA-256", out.bytes);
-			const path = `pictures/${[...new Uint8Array(digest)].slice(0, 8).map((byte) => byte.toString(16).padStart(2, "0")).join("")}.${extension}`;
+			const path = `pictures/${[...new Uint8Array(digest)].slice(0, 8).map((byte) => byte.toString(16).padStart(2, "0")).join("")}.${PICTURE_EXTENSIONS[out.type]}`;
 			pictures.set(path, out.bytes);
 			return {
 				kind: "picture",
 				src: path,
-				alt: String(out.alt ?? ""),
+				alt: out.alt,
 				width: Math.round(out.width),
 				height: Math.round(out.height)
 			};
 		}
-		if (out.kind === "link") {
-			const href = httpsAddress(out.href);
-			if (!href) throw new Error("its link is not an https address");
-			const src = httpsAddress(out.image?.src);
-			const image = src && out.image ? {
-				src,
-				alt: String(out.image.alt ?? ""),
-				width: out.image.width,
-				height: out.image.height
-			} : void 0;
-			return {
-				kind: "link",
-				href,
-				text: String(out.text ?? href),
-				...image ? { image } : {}
-			};
-		}
-		throw new Error("it answered with something that is neither a picture nor a link");
+		return {
+			kind: "link",
+			href: out.href,
+			text: out.text,
+			...out.image ? { image: out.image } : {}
+		};
 	} catch (error) {
 		const why = error instanceof Error ? error.message : String(error);
 		const extensionFence = isExtensionFenceInfo(info);
@@ -14897,88 +15093,6 @@ function withPublishFolder(folders, graphKey, publicationId, folder) {
 	} };
 }
 //#endregion
-//#region ../client/src/lib/document/calendar/month-grid-core.ts
-/** `YYYY-MM-DD` for a local date — the journal file-name format (fs/identity.ts). */
-function formatISODate(date) {
-	return `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, "0")}-${String(date.getDate()).padStart(2, "0")}`;
-}
-/** Today, as the ISO day the user is living in. The app's single definition of "today". */
-function todayISO(now = /* @__PURE__ */ new Date()) {
-	return formatISODate(now);
-}
-var ISO_SHAPE = /^(\d{4})-(\d{2})-(\d{2})$/;
-/**
-* The local `Date` a `YYYY-MM-DD` string names, or `null` when it names no day that exists.
-*
-* The shape test alone is not enough: `2026-02-30` and `2026-13-01` match it and are not days.
-* Round-tripping through `Date` catches both, because JS silently rolls an out-of-range field
-* forward (31 February becomes 3 March) and the re-format then disagrees with the input.
-*/
-function parseISODate(value) {
-	const match = ISO_SHAPE.exec(value.trim());
-	if (!match) return null;
-	const [, y, m, d] = match;
-	const date = new Date(Number(y), Number(m) - 1, Number(d));
-	return formatISODate(date) === value.trim() ? date : null;
-}
-/** True when `value` names a calendar day that actually exists. */
-function isCalendarDay(value) {
-	return parseISODate(value) !== null;
-}
-//#endregion
-//#region ../client/src/lib/document/line-endings.ts
-/** `text` with every `\r\n` and every lone `\r` written as `\n`; `text` itself when it holds no `\r`. */
-function lineFeedsOnly(text) {
-	return text.includes("\r") ? text.replace(/\r\n?/g, "\n") : text;
-}
-/**
-* The changes that turn `text` into {@link lineFeedsOnly}`(text)`, in document order and each
-* against `text` as it is: one per `\r`, deleting it before a `\n` and replacing it with `\n`
-* anywhere else. For a writer that must change a shared text in place rather than replace it,
-* applying them from the last to the first.
-*/
-function lineFeedChanges(text) {
-	const changes = [];
-	for (let at = text.indexOf("\r"); at !== -1; at = text.indexOf("\r", at + 1)) changes.push({
-		from: at,
-		to: at + 1,
-		insert: text[at + 1] === "\n" ? "" : "\n"
-	});
-	return changes;
-}
-//#endregion
-//#region ../client/src/lib/document/journal-concept.ts
-/**
-* What makes a [[Concept]] a [[Journal Concept]] — the one predicate that decides where a
-* promoting [[Draft]] writes, and which concepts refuse to be renamed (ADR 0056).
-*
-* It is deliberately **not** the `\d{4}-\d{2}-\d{2}` shape it grew out of. While the shape only
-* guarded rename, letting `2026-13-45` through cost nothing; now that the same answer decides
-* whether a file lands in `journals/` or `pages/`, a loose test would mint a journal entry for a
-* day no calendar can display or reach again.
-*
-* Pure; no DOM, no I/O.
-*/
-/**
-* True when `concept` names a calendar day that exists — a [[Journal Entry]]'s identity.
-*
-* Journal identity is the day itself, so this is case- and alias-free: there is nothing to
-* normalise beyond surrounding whitespace.
-*/
-function isJournalConcept(concept) {
-	return isCalendarDay(concept);
-}
-/**
-* Why a [[Page]] cannot be called `day`: a day is the name of that day's [[Journal Entry]].
-*
-* A page given one sits in `pages/` answering to the day, which is what an older version left
-* behind when a Draft for a date promoted to a page. Creating a page and renaming one both
-* refuse with this, on both backends, so the copy is the same wherever the user meets it.
-*/
-function dayIsNotAPageName(day) {
-	return `“${day.trim()}” is a date, and a date is the name of that day's journal entry, so a page cannot be called that. Choose a different name.`;
-}
-//#endregion
 //#region ../client/src/lib/document/protection/cipher-fence.ts
 /**
 * The `etherpk-cipher` fence as it appears in document *text* — finding one, reading what it holds
@@ -15061,6 +15175,157 @@ function lastNonBlank(lines) {
 	return -1;
 }
 //#endregion
+//#region ../client/src/lib/agent-read/read-rules.ts
+/**
+* What an agent may read of a graph, and how much, for both readers that give a language model the
+* graph's text: the [[Headless Client]]'s MCP tools (`apps/mcp/src/tools.ts`) and an [[Agent Chat]]
+* in the browser (`documents-reader.ts`, ADR 0147). Kept in one place so the size caps, the test for
+* protected text and the shape of a search or backlinks answer cannot drift between the two.
+*
+* The two differ in one rule, which each reader states for itself: the Headless Client lists a
+* [[Protected Document]] by name, while an Agent Chat leaves it out entirely, because what it reads
+* may be sent to a model provider.
+*/
+/** UTF-16 units of one document's text given before the rest is cut and the answer says so. */
+var READ_TEXT_CAP = 2e5;
+/** UTF-16 units across one bulk read before the rest is cut. */
+var READ_MANY_TEXT_CAP = 4e5;
+/** `text` cut at `cap`, and whether it was. */
+function capText(text, cap = READ_TEXT_CAP) {
+	return text.length > cap ? {
+		text: text.slice(0, cap),
+		truncated: true
+	} : {
+		text,
+		truncated: false
+	};
+}
+/** Whether `text` is a Protected Document's: its whole body one encrypted fence. */
+function isProtectedDocumentText(text) {
+	return documentProtection(text).kind === "document";
+}
+/**
+* A page of the documents whose text matches `query`, as [[Search]] reads it: a `key:value` term
+* whose key some unprotected document carries is a [[Property Filter]] (ADR 0107), and anything
+* else is words. The index holds no protected text, so no answer here can quote one.
+*/
+async function searchText$1(index, query, offset, limit) {
+	const keys = await index.propertyKeys();
+	const { words, filters } = parseSearchQuery(query, new Set(keys.map((info) => info.key.toLowerCase())));
+	if (filters.length > 0 && words.trim() === "") {
+		const documents = await index.propertyMatch(filters);
+		return {
+			results: documents.slice(offset, offset + limit).map((doc) => ({
+				concept: doc.concept,
+				kind: doc.kind,
+				matches: 0,
+				hits: [],
+				properties: doc.properties
+			})),
+			total: documents.length,
+			totalCapped: false,
+			hasMore: offset + limit < documents.length
+		};
+	}
+	const [result, count] = await Promise.all([index.searchText(words, offset, limit, filters), index.searchTextCount(words, filters)]);
+	return {
+		results: result.groups.map((group) => ({
+			concept: group.concept,
+			kind: group.kind,
+			matches: group.matches,
+			hits: group.hits.map((hit) => ({
+				line: hit.line,
+				breadcrumb: hit.breadcrumb,
+				snippet: hit.snippet.map((segment) => segment.text).join("")
+			}))
+		})),
+		total: count.total,
+		totalCapped: count.capped,
+		hasMore: result.hasMore
+	};
+}
+/**
+* The documents that link to a concept, each with the places it does. A [[Template]]'s body is a
+* pattern rather than a reference (ADR 0144), so only its name is reported.
+*/
+function backlinkSources(groups) {
+	return withoutTemplateContent(groups).map((group) => ({
+		concept: group.sourceConcept,
+		kind: group.sourceKind,
+		references: group.refs.map((ref) => ({
+			kind: ref.kind,
+			line: ref.line,
+			breadcrumb: ref.breadcrumb,
+			text: ref.kind === "block" ? ref.subtree.map((node) => node.text).join("\n") : ref.context?.text ?? ""
+		}))
+	}));
+}
+//#endregion
+//#region ../client/src/lib/document/calendar/month-grid-core.ts
+/** `YYYY-MM-DD` for a local date — the journal file-name format (fs/identity.ts). */
+function formatISODate(date) {
+	return `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, "0")}-${String(date.getDate()).padStart(2, "0")}`;
+}
+/** Today, as the ISO day the user is living in. The app's single definition of "today". */
+function todayISO(now = /* @__PURE__ */ new Date()) {
+	return formatISODate(now);
+}
+var ISO_SHAPE = /^(\d{4})-(\d{2})-(\d{2})$/;
+/**
+* The local `Date` a `YYYY-MM-DD` string names, or `null` when it names no day that exists.
+*
+* The shape test alone is not enough: `2026-02-30` and `2026-13-01` match it and are not days.
+* Round-tripping through `Date` catches both, because JS silently rolls an out-of-range field
+* forward (31 February becomes 3 March) and the re-format then disagrees with the input.
+*/
+function parseISODate(value) {
+	const match = ISO_SHAPE.exec(value.trim());
+	if (!match) return null;
+	const [, y, m, d] = match;
+	const date = new Date(Number(y), Number(m) - 1, Number(d));
+	return formatISODate(date) === value.trim() ? date : null;
+}
+/** True when `value` names a calendar day that actually exists. */
+function isCalendarDay(value) {
+	return parseISODate(value) !== null;
+}
+/** A new Date `days` after `date` (normalises across month/year boundaries). */
+function shiftDate(date, days) {
+	return new Date(date.getFullYear(), date.getMonth(), date.getDate() + days);
+}
+//#endregion
+//#region ../client/src/lib/document/journal-concept.ts
+/**
+* What makes a [[Concept]] a [[Journal Concept]] — the one predicate that decides where a
+* promoting [[Draft]] writes, and which concepts refuse to be renamed (ADR 0056).
+*
+* It is deliberately **not** the `\d{4}-\d{2}-\d{2}` shape it grew out of. While the shape only
+* guarded rename, letting `2026-13-45` through cost nothing; now that the same answer decides
+* whether a file lands in `journals/` or `pages/`, a loose test would mint a journal entry for a
+* day no calendar can display or reach again.
+*
+* Pure; no DOM, no I/O.
+*/
+/**
+* True when `concept` names a calendar day that exists — a [[Journal Entry]]'s identity.
+*
+* Journal identity is the day itself, so this is case- and alias-free: there is nothing to
+* normalise beyond surrounding whitespace.
+*/
+function isJournalConcept(concept) {
+	return isCalendarDay(concept);
+}
+/**
+* Why a [[Page]] cannot be called `day`: a day is the name of that day's [[Journal Entry]].
+*
+* A page given one sits in `pages/` answering to the day, which is what an older version left
+* behind when a Draft for a date promoted to a page. Creating a page and renaming one both
+* refuse with this, on both backends, so the copy is the same wherever the user meets it.
+*/
+function dayIsNotAPageName(day) {
+	return `“${day.trim()}” is a date, and a date is the name of that day's journal entry, so a page cannot be called that. Choose a different name.`;
+}
+//#endregion
 //#region ../client/src/lib/document/types.ts
 var DocumentNotFoundError = class extends Error {
 	target;
@@ -15566,6 +15831,17 @@ function isTransient(error) {
 function isTransientStatus(status) {
 	return status === 401 || status === 408 || status === 429 || status >= 500;
 }
+/**
+* The Sync Server gave no answer about an upload, once its retries were spent: the connection
+* failed, or it answered with a status that means "try again later". A refusal (the plan, the
+* account, the graph) and a cancellation are answers, and a file is never queued for them.
+*/
+function cannotReach(error) {
+	if (error instanceof AssetRefusedError) return false;
+	if (error instanceof DOMException && error.name === "AbortError") return false;
+	if (error instanceof HttpFailure) return error.status === 408 || error.status === 429 || error.status >= 500;
+	return true;
+}
 function kebabStem(name) {
 	return name.replace(/\.[^.]+$/, "").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "asset";
 }
@@ -15602,6 +15878,7 @@ function assetIdFromRef(ref) {
 }
 function createServerAssetStore(deps) {
 	const f = deps.fetch ?? fetch;
+	const online = deps.online ?? (() => typeof navigator === "undefined" || navigator.onLine !== false);
 	const base = deps.baseUrl.replace(/\/$/, "");
 	const newAssetId = deps.newAssetId ?? (() => crypto.randomUUID());
 	const objectUrls = [];
@@ -15714,24 +15991,20 @@ function createServerAssetStore(deps) {
 			return fetchAssetBytesOnce(ref);
 		}
 	}
-	async function fetchAssetBytesOnce(ref) {
-		const assetId = assetIdFromRef(ref);
-		if (!assetId) return null;
-		const body = await requestAsset(assetId);
-		if (!body) return null;
-		const metadata = await openMetadata(assetId, body.encryptedMetadata);
-		if (typeof metadata.chunkCount === "number" && body.downloadUrls.length !== metadata.chunkCount) throw new AssetIntegrityError();
+	/**
+	* Decrypt an asset's chunks under the per-asset key its opened metadata carries, and join them.
+	* The metadata is the uploader's own record of what was stored, so the chunk count, the size
+	* and the hash are checked against it, and a mismatch is an `AssetIntegrityError`: the bytes
+	* are never handed over in part (ADR 0027, amended 2026-10-05).
+	*/
+	async function openChunks(ref, assetId, metadata, encrypted) {
+		if (typeof metadata.chunkCount === "number" && encrypted.length !== metadata.chunkCount) throw new AssetIntegrityError();
 		const perAssetKey = fromBase64Url(metadata.perAssetKey);
 		const parts = [];
-		for (let n = 0; n < body.downloadUrls.length; n++) {
-			const chunkRes = await readRequest(body.downloadUrls[n]);
-			if (!chunkRes.ok) {
-				if (chunkRes.status !== 401 && isTransientStatus(chunkRes.status)) throw new AssetUnavailableError(`Storage could not hand over the file just now (HTTP ${chunkRes.status}).`, { status: chunkRes.status });
-				return null;
-			}
+		for (let n = 0; n < encrypted.length; n++) {
 			const { plaintext } = await openSymmetric({
 				keyForEpoch: () => perAssetKey,
-				envelope: new Uint8Array(await chunkRes.arrayBuffer()),
+				envelope: encrypted[n],
 				aad: contextAad("asset", `id:${assetId}`, `chunk:${n}`)
 			});
 			parts.push(plaintext);
@@ -15751,6 +16024,166 @@ function createServerAssetStore(deps) {
 			type: assetTypeFor(ref)
 		};
 	}
+	/**
+	* The asset from this device's copy (ADR 0143), or null when there is none. A copy that will
+	* not open is passed over, and the network is asked instead: a good download replaces it.
+	*/
+	async function fromCopy(ref, assetId) {
+		if (!deps.copies) return null;
+		try {
+			const copy = await deps.copies.read(deps.graphId, assetId);
+			if (!copy) return null;
+			return await openChunks(ref, assetId, await openMetadata(assetId, copy.encryptedMetadata), copy.chunks);
+		} catch (error) {
+			console.warn(`[assets] the copy of ${assetId} on this device would not open; fetching it again`, error);
+			return null;
+		}
+	}
+	/** Keep `asset` on this device. A failure costs only a later download, so it is logged and passed over. */
+	async function keepCopy(assetId, asset) {
+		await deps.copies?.keep(deps.graphId, assetId, asset).catch((error) => {
+			console.warn(`[assets] could not keep a copy of ${assetId} on this device`, error);
+		});
+	}
+	async function fetchAssetBytesOnce(ref) {
+		const assetId = assetIdFromRef(ref);
+		if (!assetId) return null;
+		const copied = await fromCopy(ref, assetId);
+		if (copied) return copied;
+		const body = await requestAsset(assetId);
+		if (!body) return null;
+		const metadata = await openMetadata(assetId, body.encryptedMetadata);
+		if (typeof metadata.chunkCount === "number" && body.downloadUrls.length !== metadata.chunkCount) throw new AssetIntegrityError();
+		const encrypted = [];
+		for (let n = 0; n < body.downloadUrls.length; n++) {
+			const chunkRes = await readRequest(body.downloadUrls[n]);
+			if (!chunkRes.ok) {
+				if (chunkRes.status !== 401 && isTransientStatus(chunkRes.status)) throw new AssetUnavailableError(`Storage could not hand over the file just now (HTTP ${chunkRes.status}).`, { status: chunkRes.status });
+				return null;
+			}
+			encrypted.push(new Uint8Array(await chunkRes.arrayBuffer()));
+		}
+		const asset = await openChunks(ref, assetId, metadata, encrypted);
+		await keepCopy(assetId, {
+			encryptedMetadata: body.encryptedMetadata,
+			chunks: encrypted
+		});
+		return asset;
+	}
+	/**
+	* Begin an upload: record the metadata and get one presigned PUT URL per chunk, OR learn that a
+	* complete asset in this graph already carries the dedup token. Safe to retry - the server
+	* records (graph, asset) ON CONFLICT DO NOTHING, so a second attempt stores nothing new,
+	* double-counts no storage, and simply re-presigns.
+	*/
+	function begin(upload, dedupToken) {
+		return step(async (fresh) => {
+			const res = await f(`${base}/api/v1/sync/assets`, {
+				method: "POST",
+				headers: await authHeaders(fresh),
+				body: JSON.stringify({
+					graphId: deps.graphId,
+					assetId: upload.assetId,
+					size: upload.size,
+					chunkCount: upload.chunkCount,
+					encryptedMetadata: upload.encryptedMetadata,
+					...dedupToken ? { dedupToken } : {}
+				})
+			});
+			if (!res.ok) throw await beginFailure(res);
+			return await res.json();
+		});
+	}
+	/** Chunk the bytes and encrypt each chunk under the per-asset key (AAD binds asset id + index). */
+	async function sealChunks(bytes, assetId, perAssetKey) {
+		const chunkCount = assetChunkCount(bytes.length);
+		const chunks = [];
+		for (let n = 0; n < chunkCount; n++) chunks.push(await sealSymmetric({
+			key: perAssetKey,
+			epochId: 0,
+			plaintext: bytes.subarray(n * CHUNK_SIZE, (n + 1) * CHUNK_SIZE),
+			aad: contextAad("asset", `id:${assetId}`, `chunk:${n}`)
+		}));
+		return chunks;
+	}
+	/**
+	* Upload each encrypted chunk straight to S3 via its presigned URL. Already parallel: a single
+	* large asset is not the serial part - the outer asset-to-asset loop is. Each chunk retries on
+	* its own: one blip must not cost the whole asset, let alone (via the import's unwind) the whole
+	* graph. `report` hears the SOURCE bytes of each chunk as it lands.
+	*/
+	async function putChunks(uploadUrls, chunks, size, report) {
+		await Promise.all(uploadUrls.map((u, n) => step(async () => {
+			let r;
+			try {
+				r = await f(u, {
+					method: "PUT",
+					body: chunks[n]
+				});
+			} catch {
+				throw new Error(!online() ? "The connection dropped while uploading to the storage bucket." : "Uploading to the storage bucket was blocked. The bucket's CORS policy must allow this app's address, which whoever runs the Sync Server sets.");
+			}
+			if (!r.ok) throw new HttpFailure(r.status, `chunk ${n} upload failed: ${r.status}`);
+			report?.(Math.min(CHUNK_SIZE, size - n * CHUNK_SIZE));
+		})));
+	}
+	/**
+	* Complete: flips the row to 'complete', which is INFORMATIONAL - nothing reads it to serve an
+	* asset. Retried, but a persistent failure is swallowed: the chunks and metadata are already
+	* durable, and forfeiting a twenty-minute import over a cosmetic flag is precisely the trade
+	* this retry exists to prevent. A cancellation still propagates.
+	*/
+	async function complete(assetId) {
+		await step(async (fresh) => {
+			const res = await f(`${base}/api/v1/sync/assets/${deps.graphId}/${assetId}`, {
+				method: "POST",
+				headers: await authHeaders(fresh)
+			});
+			if (!res.ok) throw new HttpFailure(res.status, `asset complete failed: ${res.status}`);
+		}).catch((err) => {
+			if (deps.signal?.aborted) throw err;
+		});
+	}
+	/**
+	* Send the uploads queued on this device for this graph, oldest first (ADR 0143). Each goes up
+	* under the id its reference already names, with no dedup token, so the server cannot answer
+	* with another file. Stops at the first that fails: one the server cannot be reached for waits
+	* for the next try, and one it refuses waits too, with the refusal handed back to be said.
+	*/
+	async function sendQueued() {
+		if (!deps.copies) return {
+			sent: 0,
+			waiting: 0
+		};
+		const waiting = await deps.copies.queued(deps.graphId);
+		let sent = 0;
+		for (const asset of waiting) {
+			let beginning = true;
+			try {
+				const begun = await begin(asset, null);
+				if ("reuse" in begun) throw new Error("The sync server answered an upload with a file it was not asked for.");
+				beginning = false;
+				await putChunks(begun.uploadUrls, asset.chunks, asset.size);
+				await complete(asset.assetId);
+			} catch (error) {
+				if (!(error instanceof HttpFailure && error.status === 409)) {
+					const away = !online() || beginning && cannotReach(error);
+					return {
+						sent,
+						waiting: waiting.length - sent,
+						...away ? {} : { refusal: error }
+					};
+				}
+			}
+			await deps.copies.sent(deps.graphId, asset.assetId);
+			sent += 1;
+		}
+		return {
+			sent,
+			waiting: 0
+		};
+	}
+	let sending = null;
 	return {
 		async save({ name, bytes, type }, onBytes) {
 			const ring = keyring();
@@ -15768,7 +16201,11 @@ function createServerAssetStore(deps) {
 				isImage,
 				...reused ? { reused } : {}
 			});
-			const dedupToken = await assetDedupToken(await dedupSecret(ring), hash);
+			let reported = 0;
+			const report = (n) => {
+				reported += n;
+				onBytes?.(n);
+			};
 			const metadata = {
 				name,
 				type,
@@ -15778,73 +16215,66 @@ function createServerAssetStore(deps) {
 				size: bytes.length,
 				chunkCount
 			};
-			const encryptedMetadata = await sealSymmetric({
-				key: currentEpoch(ring).key,
-				epochId: currentEpoch(ring).epochId,
-				plaintext: utf8(JSON.stringify(metadata)),
-				aad: contextAad("asset-meta", `graph:${deps.graphId}`, `id:${assetId}`)
-			});
-			const begin = (withToken) => step(async (fresh) => {
-				const res = await f(`${base}/api/v1/sync/assets`, {
-					method: "POST",
-					headers: await authHeaders(fresh),
-					body: JSON.stringify({
-						graphId: deps.graphId,
-						assetId,
-						size: bytes.length,
-						chunkCount,
-						encryptedMetadata: toBase64Url(encryptedMetadata),
-						...withToken ? { dedupToken } : {}
-					})
+			const upload = {
+				assetId,
+				size: bytes.length,
+				chunkCount,
+				encryptedMetadata: toBase64Url(await sealSymmetric({
+					key: currentEpoch(ring).key,
+					epochId: currentEpoch(ring).epochId,
+					plaintext: utf8(JSON.stringify(metadata)),
+					aad: contextAad("asset-meta", `graph:${deps.graphId}`, `id:${assetId}`)
+				}))
+			};
+			const queue = async (chunks) => {
+				await deps.copies.queue(deps.graphId, {
+					...upload,
+					chunks: chunks ?? await sealChunks(bytes, assetId, perAssetKey)
 				});
-				if (!res.ok) throw await beginFailure(res);
-				return await res.json();
-			});
-			let begun = await begin(true);
+				report(bytes.length - reported);
+				return {
+					...saved(assetId, false),
+					queued: true
+				};
+			};
+			if (deps.copies && !online()) return queue();
+			const dedupToken = await assetDedupToken(await dedupSecret(ring), hash);
+			let begun;
+			try {
+				begun = await begin(upload, dedupToken);
+			} catch (error) {
+				if (deps.copies && !deps.signal?.aborted && cannotReach(error)) return queue();
+				throw error;
+			}
 			if ("reuse" in begun) {
 				if (await holdsSameBytes(begun.reuse.assetId, hash)) {
-					onBytes?.(bytes.length);
+					report(bytes.length);
 					return saved(begun.reuse.assetId, true);
 				}
 				console.warn(`[sync] the server offered asset ${begun.reuse.assetId} for reuse, but its hash differs; uploading a fresh copy`);
-				begun = await begin(false);
+				begun = await begin(upload, null);
 				if ("reuse" in begun) throw new Error("The sync server answered an upload with a file it was not asked for.");
 			}
-			const { uploadUrls } = begun;
-			const chunks = [];
-			for (let n = 0; n < chunkCount; n++) {
-				const slice = bytes.subarray(n * CHUNK_SIZE, (n + 1) * CHUNK_SIZE);
-				chunks.push(await sealSymmetric({
-					key: perAssetKey,
-					epochId: 0,
-					plaintext: slice,
-					aad: contextAad("asset", `id:${assetId}`, `chunk:${n}`)
-				}));
+			const chunks = await sealChunks(bytes, assetId, perAssetKey);
+			try {
+				await putChunks(begun.uploadUrls, chunks, bytes.length, report);
+			} catch (error) {
+				if (deps.copies && !deps.signal?.aborted && !online()) return queue(chunks);
+				throw error;
 			}
-			await Promise.all(uploadUrls.map((u, n) => step(async () => {
-				let r;
-				try {
-					r = await f(u, {
-						method: "PUT",
-						body: chunks[n]
-					});
-				} catch {
-					throw new Error(typeof navigator !== "undefined" && navigator.onLine === false ? "The connection dropped while uploading to the storage bucket." : "Uploading to the storage bucket was blocked. The bucket's CORS policy must allow this app's origin - see \"Asset storage\" in the Synced Graphs doc.");
-				}
-				if (!r.ok) throw new HttpFailure(r.status, `chunk ${n} upload failed: ${r.status}`);
-				onBytes?.(Math.min(CHUNK_SIZE, bytes.length - n * CHUNK_SIZE));
-			})));
-			await step(async (fresh) => {
-				const res = await f(`${base}/api/v1/sync/assets/${deps.graphId}/${assetId}`, {
-					method: "POST",
-					headers: await authHeaders(fresh)
-				});
-				if (!res.ok) throw new HttpFailure(res.status, `asset complete failed: ${res.status}`);
-			}).catch((err) => {
-				if (deps.signal?.aborted) throw err;
+			await complete(assetId);
+			await keepCopy(assetId, {
+				encryptedMetadata: upload.encryptedMetadata,
+				chunks
 			});
 			return saved(assetId, false);
 		},
+		uploadQueued() {
+			sending ??= sendQueued().finally(() => {
+				sending = null;
+			});
+			return sending;
+		},
 		readBytes: (ref) => fetchAssetBytes(ref).catch((error) => error instanceof AssetUnavailableError && error.status !== void 0 || error instanceof AssetIntegrityError ? null : Promise.reject(error)),
 		async resolve(ref) {
 			const asset = await fetchAssetBytes(ref);
@@ -16185,6 +16615,89 @@ async function taskLinesWith(lines, fingerprint) {
 	return out;
 }
 //#endregion
+//#region ../client/src/lib/document/templates/template-variables.ts
+/**
+* [[Template Variable]]s: the `{{name}}` text in a [[Template]] that is filled in when the
+* Template is copied (ADR 0144).
+*
+* Every variable gives plain text, so a link is written around one (`[[{{date}}]]`). The date
+* variables read the context's `day`, which is the receiving [[Journal Entry]]'s own day or
+* today anywhere else; the time variables read the clock. A name this module does not know is
+* copied as written, so `{{name}}` in a Handlebars sample survives a copy, and a backslash before
+* the braces (`\{{date}}`) writes the braces literally.
+*
+* Pure and framework-free: the Client's insert command, the Journal Template's [[Draft]] and the
+* Headless Client all render through `renderTemplate`.
+*/
+/**
+* Double braces around anything without a brace, with an optional backslash before them. One
+* pass with this pattern is the whole renderer, so a value it writes is never read again.
+*/
+var VARIABLE = /(\\?)\{\{([^{}]+)\}\}/g;
+/** The format tokens, longest first so `YYYY` is never read as two `YY`s. Case-sensitive. */
+var FORMAT_TOKEN = /YYYY|YY|MM|DD|HH|mm|ss/g;
+var FORMAT_PREFIX = /^(date|time):(.+)$/i;
+/** The context for copying a Template into the document named `concept`, at `now`. */
+function templateContextFor(concept, now = /* @__PURE__ */ new Date()) {
+	return {
+		day: isJournalConcept(concept) ? concept.trim() : todayISO(now),
+		now,
+		title: concept
+	};
+}
+/** Fill in `body`'s variables for `context`. */
+function renderTemplate(body, context) {
+	const day = parseISODate(context.day) ?? context.now;
+	let cursor = null;
+	let text = "";
+	let last = 0;
+	for (const match of body.matchAll(VARIABLE)) {
+		const [whole, backslash, inner] = match;
+		text += body.slice(last, match.index);
+		last = match.index + whole.length;
+		if (backslash) {
+			text += whole.slice(1);
+			continue;
+		}
+		if (inner.trim().toLowerCase() === "cursor") {
+			cursor ??= text.length;
+			continue;
+		}
+		text += valueOf(inner.trim(), day, context) ?? whole;
+	}
+	return {
+		text: text + body.slice(last),
+		cursor
+	};
+}
+/** The text a variable stands for, or null for a name this module does not know. */
+function valueOf(inner, day, context) {
+	switch (inner.toLowerCase()) {
+		case "date": return formatISODate(day);
+		case "yesterday": return formatISODate(shiftDate(day, -1));
+		case "tomorrow": return formatISODate(shiftDate(day, 1));
+		case "time": return format("HH:mm", day, context.now);
+		case "datetime": return `${formatISODate(day)} ${format("HH:mm", day, context.now)}`;
+		case "title": return context.title;
+	}
+	const custom = FORMAT_PREFIX.exec(inner);
+	return custom ? format(custom[2], day, context.now) : null;
+}
+function format(pattern, day, now) {
+	const pad = (n) => String(n).padStart(2, "0");
+	return pattern.replace(FORMAT_TOKEN, (token) => {
+		switch (token) {
+			case "YYYY": return String(day.getFullYear());
+			case "YY": return pad(day.getFullYear() % 100);
+			case "MM": return pad(day.getMonth() + 1);
+			case "DD": return pad(day.getDate());
+			case "HH": return pad(now.getHours());
+			case "mm": return pad(now.getMinutes());
+			default: return pad(now.getSeconds());
+		}
+	});
+}
+//#endregion
 //#region ../../extensions/graph-view/src/model/graph-model.ts
 /**
 * The [[Graph View]]'s model: the index's {@link LinkGraph} turned into a graphology graph the
@@ -16553,8 +17066,34 @@ function taskLineWith(line, changes) {
 function sameTags(a, b) {
 	return a.priority === b.priority && a.waiting === b.waiting && a.doing === b.doing && a.cancelled === b.cancelled && a.due === b.due && a.scheduled === b.scheduled && a.completion === b.completion;
 }
-/** UTF-16 units of document text returned before `truncated` is set. */
-var READ_TEXT_CAP = 2e5;
+//#endregion
+//#region src/tools.ts
+/**
+* The eight tools an agent gets, as plain functions over an open {@link HeadlessGraph}. The MCP
+* layer (`mcp-server.ts`) only serialises these; everything an agent can and cannot do is
+* decided here, and tested here over both backends - the loopback relay standing in for the
+* Sync Server, and an in-memory folder - without a server or a transport. The tools see only
+* `HeadlessDocuments`: every one starts with `refresh()` so a folder is re-read before it is
+* answered from, and a write ends with `settle()` so success means durable.
+*
+* The rules (ADR 0072, [[2026-09-15 Headless Client And MCP]]):
+*
+* - A [[Protected Document]] is listed by name and nothing else. Reading refuses; every write
+*   refuses, frontmatter included. The Headless Client never holds a Protection Key, so this is
+*   a courtesy to the agent rather than the guarantee - the guarantee is that there is nothing
+*   here to serve.
+* - Edits are anchored: `edit_document` replaces one exact, unique occurrence and lands as one
+*   `applyChange` range, which the sync engine carries as one `Y.Text` change that merges with
+*   whoever is typing elsewhere in the page. There is no whole-page replace.
+* - Every write passes through the paste / import indent normaliser, so an agent that writes
+*   four-space bullets lands on the grid like everyone else.
+* - Every result is bounded: pages are paged, a document read is capped and says so.
+* - `search` has a `mode`: `text` (the index's FTS, the default), `semantic` (nearest
+*   [[Passage]]s by [[Embedding]], ADR 0076) and `hybrid` (both, as two labelled groups rather
+*   than one fused ranking - the same choice the Search modal makes, so the agent can see WHY
+*   something matched). Semantic mode needs the model set up on this machine; without it the
+*   refusal says what to run.
+*/
 /** A refusal the agent can act on: a stable code first, a sentence second. */
 var ToolError = class extends Error {
 	code;
@@ -16564,8 +17103,6 @@ var ToolError = class extends Error {
 		this.name = "ToolError";
 	}
 };
-/** UTF-16 units across one `read_documents` call before the rest is cut. */
-var READ_MANY_TEXT_CAP = 4e5;
 /** Keys the frontmatter tools never read or write; each has a tool of its own. */
 var OWNED_KEYS = /* @__PURE__ */ new Set([
 	"title",
@@ -16655,7 +17192,7 @@ async function liveText(graph, identity) {
 	return graph.store.open(identity.concept).getText();
 }
 function refuseIfProtected(concept, text) {
-	if (documentProtection(text).kind === "document") throw new ToolError("protected_document", `"${concept}" is a protected document. Its content is encrypted under a key this client never holds, so it cannot be read or changed here - the user can unlock it in EtherPK.`);
+	if (isProtectedDocumentText(text)) throw new ToolError("protected_document", `"${concept}" is a protected document. Its content is encrypted under a key this client never holds, so it cannot be read or changed here - the user can unlock it in EtherPK.`);
 }
 function page$1(items, offset, limit) {
 	return {
@@ -16701,13 +17238,14 @@ async function readDocument(graph, concept) {
 	const identity = requireIdentity(graph, concept);
 	const text = await liveText(graph, identity);
 	refuseIfProtected(identity.concept, text);
+	const capped = capText(text, READ_TEXT_CAP);
 	return {
 		concept: identity.concept,
 		kind: identity.kind,
 		aliases: identity.aliases,
-		text: text.length > 2e5 ? text.slice(0, READ_TEXT_CAP) : text,
+		text: capped.text,
 		frontmatter: agentFrontmatter(graph.store.openRaw(identity.concept).getText()),
-		truncated: text.length > READ_TEXT_CAP
+		truncated: capped.truncated
 	};
 }
 async function search(graph, args) {
@@ -16763,40 +17301,9 @@ async function searchSemantic(graph, query, offset, limit) {
 function round(similarity) {
 	return Math.round(similarity * 1e3) / 1e3;
 }
-async function searchText(graph, query, offset, limit) {
-	const keys = await graph.index.propertyKeys();
-	const { words, filters } = parseSearchQuery(query, new Set(keys.map((info) => info.key.toLowerCase())));
-	if (filters.length > 0 && words.trim() === "") {
-		const documents = await graph.index.propertyMatch(filters);
-		return {
-			results: documents.slice(offset, offset + limit).map((doc) => ({
-				concept: doc.concept,
-				kind: doc.kind,
-				matches: 0,
-				hits: [],
-				properties: doc.properties
-			})),
-			total: documents.length,
-			totalCapped: false,
-			hasMore: offset + limit < documents.length
-		};
-	}
-	const [result, count] = await Promise.all([graph.index.searchText(words, offset, limit, filters), graph.index.searchTextCount(words, filters)]);
-	return {
-		results: result.groups.map((group) => ({
-			concept: group.concept,
-			kind: group.kind,
-			matches: group.matches,
-			hits: group.hits.map((hit) => ({
-				line: hit.line,
-				breadcrumb: hit.breadcrumb,
-				snippet: hit.snippet.map((segment) => segment.text).join("")
-			}))
-		})),
-		total: count.total,
-		totalCapped: count.capped,
-		hasMore: result.hasMore
-	};
+/** The index's text group, read as Search reads it (shared with the browser's Agent Chat). */
+function searchText(graph, query, offset, limit) {
+	return searchText$1(graph.index, query, offset, limit);
 }
 async function backlinks(graph, concept) {
 	const target = concept.trim() === "today" ? todayISO() : concept.trim();
@@ -16804,16 +17311,7 @@ async function backlinks(graph, concept) {
 	await graph.store.refresh();
 	return {
 		concept: target,
-		sources: (await graph.index.backlinks(target)).map((group) => ({
-			concept: group.sourceConcept,
-			kind: group.sourceKind,
-			references: group.refs.map((ref) => ({
-				kind: ref.kind,
-				line: ref.line,
-				breadcrumb: ref.breadcrumb,
-				text: ref.kind === "block" ? ref.subtree.map((node) => node.text).join("\n") : ref.context?.text ?? ""
-			}))
-		}))
+		sources: backlinkSources(await graph.index.backlinks(target))
 	};
 }
 /**
@@ -16933,6 +17431,30 @@ async function tasks(graph, args = {}) {
 	};
 }
 /**
+* What a tool writes from `template` and `text`: the named [[Template]]'s body with its variables
+* filled in for the document called `into`, then the text, each in the form EtherPK writes
+* (ADR 0144). `{{cursor}}` marks where a person's caret would go, so here it is only removed.
+* The Journal Template is never applied on its own: an agent's write holds what it asked for.
+*/
+async function withTemplate(graph, template, into, text) {
+	const parts = [];
+	if (template !== void 0) parts.push(asWritten(renderTemplate(await templateBodyFor(graph, template), templateContextFor(into)).text));
+	if (text !== void 0 && text !== "") parts.push(asWritten(text));
+	return parts.join("\n");
+}
+/** The body a copy of the Template named `name` takes, or a refusal that says how to find one. */
+async function templateBodyFor(graph, name) {
+	const identity = resolveIdentity(graph, name.trim());
+	let raw = "";
+	if (identity) {
+		await graph.store.whenReady(identity.concept);
+		raw = graph.store.openRaw(identity.concept).getText();
+	}
+	const { data, body } = parseFrontmatter(raw);
+	if (!identity || !isTemplate(data, identity.kind) || isProtectedDocumentText(body)) throw new ToolError("invalid_argument", `"${name}" is not a Template. A page is a Template when its frontmatter says template: true; search for template:true to list them.`);
+	return templateBody(raw);
+}
+/**
 * Text an agent sent, in the form EtherPK writes: line feeds only (ADR 0112), then the
 * two-space Indent Unit (ADR 0067). Line endings go first so the normaliser reads whole lines.
 */
@@ -16962,10 +17484,10 @@ async function editDocument(graph, args) {
 	};
 }
 async function appendDocument(graph, args) {
-	const text = asWritten(args.text);
-	if (text.trim() === "") throw new ToolError("invalid_argument", "text must not be empty.");
 	const target = args.concept.trim() === "today" ? todayISO() : args.concept.trim();
 	await graph.store.refresh();
+	const text = await withTemplate(graph, args.template, target, args.text);
+	if (text.trim() === "") throw new ToolError("invalid_argument", "Give text, a template, or both.");
 	const existing = resolveIdentity(graph, target);
 	if (!existing) {
 		if (!isJournalConcept(target)) throw new ToolError("not_found", `No document is named "${target}". Use create_page to start a new page.`);
@@ -16996,7 +17518,7 @@ async function createPage(graph, args) {
 	if (isJournalConcept(title)) throw new ToolError("invalid_argument", `"${title}" is a calendar day, so it names a journal entry - use append_document to write to it.`);
 	await graph.store.refresh();
 	if (resolveIdentity(graph, title)) throw new ToolError("already_exists", `A document already answers to "${title}". Use edit_document or append_document instead.`);
-	await graph.store.createPage(title, asWritten(args.text ?? ""));
+	await graph.store.createPage(title, await withTemplate(graph, args.template, title, args.text));
 	if (args.frontmatter && Object.keys(args.frontmatter).length > 0) {
 		await graph.store.whenReady(title);
 		const raw = graph.store.openRaw(title).getText();
@@ -17355,7 +17877,7 @@ async function readDocuments(graph, args) {
 			continue;
 		}
 		const text = await liveText(graph, identity);
-		if (documentProtection(text).kind === "document") {
+		if (isProtectedDocumentText(text)) {
 			documents.push({
 				concept: identity.concept,
 				error: "protected_document",
@@ -17452,7 +17974,7 @@ function referenceSources(graph) {
 			const identity = resolveIdentity(graph, document);
 			if (!identity) return null;
 			const text = await liveText(graph, identity);
-			return documentProtection(text).kind === "document" ? null : text;
+			return isProtectedDocumentText(text) ? null : text;
 		},
 		allTasks: () => everyIndexedTask(graph.index, todayISO())
 	};
@@ -18709,18 +19231,20 @@ function createMcpServer(source, info) {
 	}, async (args) => run((graph) => editDocument(graph, args)));
 	server.registerTool("append_document", {
 		title: "Append to a document",
-		description: "Add text at the end of a page or a journal entry, on a new line. A journal day that has no entry yet is created (\"today\" is accepted). A page that does not exist is not created: use create_page.",
+		description: "Add text at the end of a page or a journal entry, on a new line. A journal day that has no entry yet is created (\"today\" is accepted). A page that does not exist is not created: use create_page. With template, a Template's body is added first, its variables ({{date}}, {{title}}, ...) filled in for this document; a journal day takes its own date. The graph's Journal Template is never added on its own.",
 		inputSchema: {
 			concept,
-			text: z.string().min(1)
+			text: z.string().min(1).optional(),
+			template: z.string().min(1).optional().describe("The name of a Template: a page whose frontmatter says template: true. Search for template:true to list them.")
 		}
 	}, async (args) => run((graph) => appendDocument(graph, args)));
 	server.registerTool("create_page", {
 		title: "Create a page",
-		description: "Create a new page with the given title, optional markdown body and optional frontmatter (the same keys and rules as set_frontmatter). Refuses a title that already names a page or an alias, or that is a calendar day (use append_document for journal entries).",
+		description: "Create a new page with the given title, optional markdown body and optional frontmatter (the same keys and rules as set_frontmatter). With template, the page starts with that Template's body, its variables ({{date}}, {{title}}, ...) filled in for the new page, then the text. Refuses a title that already names a page or an alias, or that is a calendar day (use append_document for journal entries).",
 		inputSchema: {
 			title: z.string().min(1),
 			text: z.string().optional(),
+			template: z.string().min(1).optional().describe("The name of a Template: a page whose frontmatter says template: true. Search for template:true to list them."),
 			frontmatter: z.record(z.string(), frontmatterValue).optional().describe("Frontmatter keys for the new page, e.g. {\"public\": true, \"publications\": [\"blog\"], \"date\": \"2026-01-31\"}.")
 		}
 	}, async (args) => run((graph) => createPage(graph, args)));
@@ -19421,14 +19945,19 @@ function sameNames(a, b) {
 //#region ../client/src/lib/document/index-link-graph.ts
 function linkGraph(db) {
 	const generation = activeIndexGeneration(db);
-	const pages = db.all("SELECT concept, concept_key AS key, kind, protected FROM pages WHERE generation = ? ORDER BY id", [generation]);
+	const pages = db.all("SELECT concept, concept_key AS key, kind, protected, template FROM pages WHERE generation = ? ORDER BY id", [generation]);
 	const aliases = db.all("SELECT a.alias_key AS key, p.concept_key AS page FROM aliases a JOIN pages p ON p.id = a.page_id WHERE p.generation = ? ORDER BY a.page_id", [generation]);
 	const rows = db.all(`SELECT p.concept_key AS source, json_group_array(json_array(l.concept_key, l.concept, l.in_title)) AS links
          FROM links l JOIN pages p ON p.id = l.page_id
          WHERE p.generation = ?
          GROUP BY p.id`, [generation]);
 	const concepts = /* @__PURE__ */ new Map();
+	const templates = /* @__PURE__ */ new Set();
 	for (const page of pages) {
+		if (page.template) {
+			templates.add(page.key);
+			continue;
+		}
 		if (concepts.has(page.key)) continue;
 		const concept = {
 			key: page.key,
@@ -19442,15 +19971,15 @@ function linkGraph(db) {
 		} : concept);
 	}
 	const pageOfAlias = /* @__PURE__ */ new Map();
-	for (const alias of aliases) if (!concepts.has(alias.key) && !pageOfAlias.has(alias.key)) pageOfAlias.set(alias.key, alias.page);
+	for (const alias of aliases) if (!concepts.has(alias.key) && !templates.has(alias.key) && !pageOfAlias.has(alias.key)) pageOfAlias.set(alias.key, alias.page);
 	const resolve = (key) => concepts.has(key) ? key : pageOfAlias.get(key) ?? key;
-	const parsed = rows.map((row) => ({
+	const parsed = rows.filter((row) => !templates.has(row.source)).map((row) => ({
 		source: row.source,
 		links: JSON.parse(row.links)
 	}));
 	const spellings = /* @__PURE__ */ new Map();
 	for (const row of parsed) for (const [key, written] of row.links) {
-		if (concepts.has(resolve(key))) continue;
+		if (concepts.has(resolve(key)) || templates.has(resolve(key))) continue;
 		const counts = spellings.get(key) ?? /* @__PURE__ */ new Map();
 		counts.set(written, (counts.get(written) ?? 0) + 1);
 		spellings.set(key, counts);
@@ -19825,7 +20354,7 @@ function createIndexCore(host) {
 				}];
 			}
 			case "search-text": {
-				const page = db ? searchText$1(db, request.query, request.offset, request.limit, request.filters ?? []) : {
+				const page = db ? searchText$2(db, request.query, request.offset, request.limit, request.filters ?? []) : {
 					groups: [],
 					hasMore: false
 				};
@@ -19853,6 +20382,11 @@ function createIndexCore(host) {
 				id: request.id,
 				keys: db ? propertyKeys(db) : []
 			}];
+			case "templates": return [{
+				type: "templates",
+				id: request.id,
+				templates: db ? templatePages(db) : []
+			}];
 			case "property-values": return [{
 				type: "property-values",
 				id: request.id,
@@ -20754,6 +21288,12 @@ function createRemoteGraphIndex(source, transport, options) {
 				id
 			}))).keys;
 		},
+		async templates() {
+			return (await request((id) => ({
+				type: "templates",
+				id
+			}))).templates;
+		},
 		async propertyValues(key) {
 			return (await request((id) => ({
 				type: "property-values",
@@ -21866,7 +22406,8 @@ function indexSnapshotOf(identity, text) {
 		aliases: aliasesOf(fm),
 		text: fm.body,
 		...includes.length > 0 ? { includes } : {},
-		...properties.length > 0 ? { properties } : {}
+		...properties.length > 0 ? { properties } : {},
+		...isTemplate(fm.data, identity.kind) ? { template: true } : {}
 	};
 }
 function applyTextChange(text, change) {
@@ -23122,14 +23663,16 @@ function createServerDocumentStore(graph, options) {
 			text,
 			aliases: []
 		}) : [];
-		const properties = propertiesOf(parseFrontmatter(text).data);
+		const frontmatter = parseFrontmatter(text).data;
+		const properties = propertiesOf(frontmatter);
 		return {
 			concept,
 			kind: entry.kind,
 			aliases: entry.aliases ?? [],
 			text: bodyForIndex(text),
 			...includes.length > 0 ? { includes } : {},
-			...properties.length > 0 ? { properties } : {}
+			...properties.length > 0 ? { properties } : {},
+			...isTemplate(frontmatter, entry.kind) ? { template: true } : {}
 		};
 	}
 	/**
@@ -24942,11 +25485,12 @@ async function pollDeviceApproval(api, request) {
 * (ADR 0072). Two routes, both already served by the Sync Server for every new device:
 *
 * - **Device Approval** (ADR 0125), the default: this process posts a commitment to a one-time
-*   key; once an unlocked EtherPK tab answers, it prints the code both screens show. The user
-*   approves in the tab AND presses y here: a server can play the approving device itself, and
+*   key; once EtherPK answers on a device where the account's Encryption Keys are unlocked, it
+*   prints the code both screens show. The user approves on that device AND presses y here: a
+*   server can play the approving device itself, and
 *   only the user, comparing the two screens, can tell. The key that arrives is checked against
 *   the vault before it is used. No secret passes through the terminal.
-* - **Recovery Code**, behind a flag, for a box with no tab to hand: the code derives the wrap
+* - **Recovery Code**, behind a flag, for a box with no unlocked device to hand: the code derives the wrap
 *   key, which opens the vault; what is cached is the vault key, never the code.
 *
 * Pure over an injected clock and output so the flow is testable without a terminal.
@@ -24973,8 +25517,8 @@ var SIGNAL_EXIT_CODES = {
 * The keys the approval wait answers to. `y` confirms the codes match; `n` says they do not, which
 * cancels the request; `r` switches to the Recovery Code; Ctrl-C (a key while the terminal is in
 * raw mode) and SIGINT, SIGTERM or SIGHUP quit. Every way out aborts the wait, so it cancels its
-* approval server-side before anything exits: a login left pending showed its stale code in every
-* unlocked tab for ten minutes. `exitCode` is set once the user has quit.
+* approval server-side before anything exits: a login left pending showed its stale code on every
+* unlocked device for ten minutes. `exitCode` is set once the user has quit.
 */
 function approvalWaitControls() {
 	const abort = new AbortController();
@@ -25042,8 +25586,8 @@ async function unlockByDeviceApproval(api, io) {
 	const request = await beginDeviceApproval(api);
 	const where = io.clientUrl ? `open EtherPK at ${io.clientUrl}` : "open EtherPK in a browser";
 	io.say("");
-	io.say(`To approve this device, ${where} (any page - it need not be a note), connected to this account`);
-	io.say("with its Encryption Keys unlocked. A prompt will appear there, and this terminal then shows a code to compare.");
+	io.say(`To approve this device, ${where} (any page - it need not be a note) on any device where this account's`);
+	io.say("Encryption Keys are unlocked. A prompt will appear there, and this terminal then shows a code to compare.");
 	io.say("");
 	io.say("Waiting (up to ten minutes)…");
 	const abandon = async () => {
@@ -25297,13 +25841,12 @@ var VERSION = package_default.version;
 var CMD = /[\\/]_npx[\\/]/.test(process.argv[1] ?? "") ? "npx @appsoftwareltd/etherpk-mcp" : "etherpk-mcp";
 var USAGE = `etherpk-mcp - EtherPK Headless Client (an MCP server over one synced graph)
 
-  ${CMD} login --sync-server <url> [--code <setup code>] [--recovery-code]
-      Sign this machine in as a device of your account. Make a setup code in EtherPK
-      (a synced graph's Settings > Agents, or <url>/account/tokens) and pass it with --code:
-      it works once, within 10 minutes, and gets this machine an agent token of its own,
-      which can do only what an agent needs. Then unlock your Encryption Keys by Device
-      Approval: open EtherPK in a browser connected to the account with its Encryption Keys
-      unlocked, approve there if it shows the same code, then press y. Press r while waiting,
+  ${CMD} login --sync-server <url> [--code <Agent Setup Code>] [--recovery-code]
+      Sign in this computer as a device of your account. Create an Agent Setup Code in EtherPK
+      (the Graphs page's Agents tab, or a synced graph's Settings > Agents, or <url>/account/tokens) and pass it with --code: it works once, within 10
+      minutes, and gets this computer an Agent Token limited to the routes an agent needs. Then
+      unlock your Encryption Keys by Device Approval: confirm the matching code in EtherPK on
+      any device where your Encryption Keys are unlocked, then press y. Press r while waiting,
       or pass --recovery-code, to type your Recovery Code instead (or ETHERPK_RECOVERY_CODE,
       for a scripted setup).
       For a script, --pat <token> or ETHERPK_PAT takes an account-wide access token instead,
@@ -25505,11 +26048,11 @@ async function login(args) {
 	const syncServer = normaliseSyncServer(args["sync-server"] ?? (known.length === 1 ? known[0] : await ask("Sync Server URL: ", { hint: "pass --sync-server <url>" })));
 	if (!/^https?:\/\//.test(syncServer)) fail("The Sync Server must be an http(s) URL.");
 	const previous = config.servers[syncServer];
-	const given = (args.code ?? args.pat ?? process.env.ETHERPK_PAT ?? await ask("Setup code (make one in EtherPK: a synced graph's Settings > Agents): ", {
+	const given = (args.code ?? args.pat ?? process.env.ETHERPK_PAT ?? await ask(`Agent Setup Code (create one in EtherPK: the Graphs page's Agents tab, or a synced graph's Settings > Agents): `, {
 		secret: true,
-		hint: "pass --code <setup code>"
+		hint: "pass --code <Agent Setup Code>"
 	})).trim();
-	if (!given) fail("A setup code is required. Make one in EtherPK: a synced graph's Settings > Agents.");
+	if (!given) fail(`An Agent Setup Code is required. Create one in EtherPK: the Graphs page's Agents tab, or a synced graph's Settings > Agents.`);
 	const name = agentTokenName();
 	let token;
 	let redeemed = false;
@@ -25521,7 +26064,7 @@ async function login(args) {
 		}).catch((error) => fail(describeLoginFailure(error, syncServer)));
 		redeemed = true;
 	} else if (accessTokenKind(given) !== null) token = given;
-	else fail("That is neither a setup code (epk_setup_...) nor an access token (epk_pat_...). Make a setup code in EtherPK: a synced graph's Settings > Agents.");
+	else fail(`That is neither an Agent Setup Code (epk_setup_...) nor an access token (epk_pat_...). Create an Agent Setup Code in EtherPK: the Graphs page's Agents tab, or a synced graph's Settings > Agents.`);
 	const abandon = async (error) => {
 		if (redeemed) await revokeHeldToken({
 			syncServer,
@@ -25541,18 +26084,16 @@ async function login(args) {
 	const vaultKey = await (args["recovery-code"] ? byRecoveryCode() : approveOrFallBack(account, byRecoveryCode)).catch(abandon);
 	if (accessTokenKind(token) === "standard") {
 		const given = token;
-		const agentToken = await exchangeForAgentToken({
+		token = await exchangeForAgentToken({
 			syncServer,
 			token,
 			name
 		}).catch(async (error) => {
-			if (!await tokenStillWorks(syncServer, given)) fail(`Could not swap the access token for an agent token (${describeLoginFailure(error, syncServer)}), and the access token you gave no longer works. Run login again with a setup code.`);
-			console.log(`Could not swap the access token for an agent token (${describeLoginFailure(error, syncServer)}), so this computer keeps the access token you gave. Run login again to try again.`);
+			const reason = describeLoginFailure(error, syncServer);
+			if (!await tokenStillWorks(syncServer, given)) return fail(`Could not swap the access token for an Agent Token (${reason}), and the access token you gave no longer works. Run login again with an Agent Setup Code.`);
+			return fail(`Could not swap the access token for an Agent Token (${reason}). Nothing was kept on this computer: run login again.`);
 		});
-		if (agentToken) {
-			token = agentToken;
-			console.log(`The access token you gave has been revoked. This computer now holds an agent token of its own, which can do only what an agent needs. If you used that access token anywhere else, make a new one at ${syncServer}/account/tokens.`);
-		} else if (agentToken === null) console.log("This Sync Server runs an older version of EtherPK that cannot give agent tokens, so this computer keeps the access token you gave.");
+		console.log(`The access token you gave has been revoked. This computer now holds an Agent Token, limited to the routes an agent needs. If you used that access token anywhere else, create a new one at ${syncServer}/account/tokens.`);
 	}
 	if (previous) {
 		const before = await loginCredentials(syncServer, previous, keychain()).catch(() => null);