@appsoftwareltd/etherpk-mcp 0.11.1 → 0.12.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.12.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",
@@ -3616,6 +3616,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 +4586,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 +4618,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 +5200,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 +5313,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 +5334,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 +5387,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 +5450,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 +5656,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 +5757,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 +5990,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 +6159,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 +6191,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);
 		}
@@ -6937,7 +7004,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 +10191,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 +10229,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 +10529,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 +11593,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 +12120,6 @@ not here.
 wrangler.jsonc
 AGENTS.md
 README.md
-etherpk-publish.json
 `]
 	]);
 }
@@ -12058,7 +12139,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 +12159,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 +13129,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 +13203,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 +13381,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 +13532,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);
@@ -14925,26 +15116,9 @@ function parseISODate(value) {
 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;
+/** 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
@@ -15566,6 +15740,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 +15787,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 +15900,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 +15933,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 +16110,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 +16124,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 +16524,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
@@ -16804,7 +17226,7 @@ async function backlinks(graph, concept) {
 	await graph.store.refresh();
 	return {
 		concept: target,
-		sources: (await graph.index.backlinks(target)).map((group) => ({
+		sources: withoutTemplateContent(await graph.index.backlinks(target)).map((group) => ({
 			concept: group.sourceConcept,
 			kind: group.sourceKind,
 			references: group.refs.map((ref) => ({
@@ -16933,6 +17355,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) || documentProtection(body).kind === "document") 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 +17408,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 +17442,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();
@@ -18709,18 +19155,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 +19869,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 +19895,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);
@@ -19853,6 +20306,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 +21212,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 +22330,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 +23587,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 } : {}
 		};
 	}
 	/**