@nikovirtala/adr 0.4.0 → 0.5.0

package/dist/{search-CwIPlNGd.js → search-CTspg2pd.js}

@@ -1,5 +1,5 @@
-import { t as adrKind } from "./kind-DjvA3dyA.js";
-import { CommitFailedError, ConfigError, ENVELOPE_VERSION, EventExistsError, FileExistsError, InvalidArgumentError, MemoryTree, UsageError, applySetOp, bodyFileName, bodySha256, classifyPath, commitWithRecovery, compareEvents, compileKind, diffTrees, escapeMarkdown, eventDir, eventPath, extractSections, finding, foldLog, followRenames, globMatcher, historyTemplates, indexCheck, indexReader, invariantsCheck, isSubjectId, lintDocument, lintTemplate, loadFindings, loadLog, newSubjectId, nextEventIdentity, numberLog, openToolLog, overlayTree, parseCommitTemplate, parseEventFileName, parseGlob, parseTemplate, projectLog, projectNumbering, readCommitTemplate, readIndexNumbers, refReader, relateCheck, renderCommitMessage, renderIndex, renderTemplate, replaceFile, replaceSections, resolveSubjectInput, saveCommitRecovery, scanAnchors, scopeLookup, serializeEvent, slugify, sortFindings, stagedRenames, templateHistoryRef, transitions, verifyLog, worktreeReader, writeEvents, writeIndexFile, writeNewFile } from "@nikovirtala/ledger";
+import { t as adrKind } from "./kind-C3DiBuUp.js";
+import { CommitFailedError, ConfigError, ENVELOPE_VERSION, EventExistsError, FileExistsError, InvalidArgumentError, MemoryTree, NO_NUMBERING, UsageError, applySetOp, bodyFileName, bodySha256, classifyPath, commitWithRecovery, compareEvents, compileKind, diffTrees, escapeMarkdown, eventDir, eventPath, eventTrailers, extractSections, finding, firstLine, foldLog, followRenames, globMatcher, headBytes, headTree, historyTemplates, holdsText, indexCheck, indexReader, invariantsCheck, isSubjectId, joinActions, lintDocument, lintTemplate, loadFindings, loadLog, newSubjectId, nextEventIdentity, numberLog, openToolLog, overlayTree, parseCommitTemplate, parseEventFileName, parseGlob, parseTemplate, projectLog, projectNumbering, readCommitTemplate, readIndexNumbers, readSources, refReader, relateCheck, renderCommitMessage, renderIndex, renderTemplate, replaceFile, replaceSections, resolveSubjectInput, saveCommitRecovery, scanAnchors, scopeLookup, serializeEvent, slugify, sortFindings, sourceLogRef, sourcesOfKinds, stagedRenames, templateHistoryRef, transitions, verifyLog, withoutPaths, worktreeReader, writeEvents, writeIndexCopy, writeNewFile } from "@nikovirtala/ledger";
 import { lstat, readFile, realpath, rm, writeFile } from "node:fs/promises";
 import { isAbsolute, join, posix, relative, resolve, sep } from "node:path";
 // src/commit-actions.ts
@@ -45,9 +45,33 @@ const ACTIONS = {
 		names: "display"
 	}
 };
+/**
+* The verb of each display-named event type in a batch subject (?6, design §4.4), and the order
+* they are joined in: `link and scope ADR-0003`, `add a note to` last so it reads before the name.
+*/
+const BATCH_ACTIONS = {
+	deprecated: "deprecate",
+	superseded: "supersede",
+	linked: "link",
+	scoped: "scope",
+	noted: "add a note to"
+};
+const BATCH_ORDER = [
+	"deprecated",
+	"superseded",
+	"linked",
+	"scoped",
+	"noted"
+];
+/** `{action}` of a batch of more than three verbs. */
+const UPDATE_ACTION = "update";
 /** `{action}` of a draft update (`adr_update_draft`), whose title slot holds the display. */
 const DRAFT_ACTION = "update the draft of";
-/** The longest `{action}`, which `[commit] subject` must leave room for. */
+/**
+* The longest `{action}` that goes with a title, which `[commit] subject` must leave a title room
+* for. A batch action (up to `LONGEST_BATCH`) only ever goes with a display, so `COMMIT_NAMES`
+* covers it instead.
+*/
 const LONGEST_ACTION = Math.max(...Object.values(ACTIONS).map((a) => a.action.length), 10, 19);
 /** What a link's title slot names after the display when the target is in another log. */
 const CROSS_LOG_LINK = "to a decision in another log";
@@ -77,6 +101,10 @@ const COMMIT_NAMES = Object.freeze([
 	{
 		length: 18,
 		vars: { action: 10 }
+	},
+	{
+		length: 13,
+		vars: { action: 6 }
 	}
 ]);
 // src/config.ts
@@ -224,17 +252,17 @@ async function numberDecisions(log) {
 		} } : {}
 	});
 }
-const compiled$1 = compileKind(adrKind);
+const compiled$2 = compileKind(adrKind);
 /** The git-free core of `readDecisions`; tests pass a MemoryTree and a hand-made `Numbering`. */
 async function readDecisionsFrom(tree, o) {
 	const { layout, adr, numbering } = o;
 	const snapshot = await loadLog(tree, {
-		kind: compiled$1,
+		kind: compiled$2,
 		layout
 	});
 	const folded = foldLog(adrKind, snapshot);
 	const ctx = {
-		kind: compiled$1,
+		kind: compiled$2,
 		layout,
 		base: null,
 		head: snapshot,
@@ -246,7 +274,10 @@ async function readDecisionsFrom(tree, o) {
 			base: null
 		}
 	};
-	const options = { acceptRequiresHuman: adr.acceptRequiresHuman };
+	const options = {
+		acceptRequiresHuman: adr.acceptRequiresHuman,
+		sources: null
+	};
 	const findings = [];
 	for (const check of [
 		loadFindings,
@@ -269,16 +300,17 @@ async function readDecisionsFrom(tree, o) {
 			kind: adrKind.name
 		}))),
 		notes: o.notes ?? [],
-		sources: o.sources ?? []
+		sources: o.sources ?? [],
+		source: o.source ?? null
 	};
 }
 /**
-* The note listing reads add while only the local log is read: the logs of `[[sources]]` aren't
-* listed or searched until ark's step 4. `null` without sources.
+* The note listing reads add for a log with `[[sources]]`: the other logs are listed with
+* `--source`, from cached copies. `null` without sources, and for a `--source` read.
 */
 function sourcesNote(read) {
-	if (read.sources.length === 0) return null;
-	return `only this repository's decision log is read; the logs in [[sources]] (${read.sources.join(", ")}) aren't listed or searched until ark's step 4`;
+	if (read.sources.length === 0 || read.source !== null) return null;
+	return `the logs in [[sources]] (${read.sources.join(", ")}) are listed with --source <name>, from cached copies; run adr sources fetch to update them`;
 }
 /** `read.notes`, then the sources note when there is one. */
 function listingNotes(read) {
@@ -506,37 +538,6 @@ function decisionIndexCheck(log) {
 		}
 	};
 }
-const encoder$1 = new TextEncoder();
-/** Whether `bytes` (null: absent) hold exactly `text`. */
-function holdsText(bytes, text) {
-	if (bytes === null) return false;
-	const want = encoder$1.encode(text);
-	return bytes.byteLength === want.byteLength && bytes.every((x, i) => x === want[i]);
-}
-/** HEAD's copy of `path`; `null` when it is absent or HEAD is unborn. */
-async function headBytes(git, path) {
-	const head = await git.resolveCommit("HEAD");
-	return head === null ? null : (await refReader(git, head)).read(path);
-}
-/** HEAD's tree, or an empty tree on an unborn HEAD. */
-async function headTree(git, head) {
-	return head === null ? new MemoryTree({}) : refReader(git, head);
-}
-/**
-* Brings the work-tree copy of `path` to `text` (atomically, when it differs) and reports whether
-* the staged copy differs, so the caller stages it. `old` is the work-tree copy before the write
-* (`null` when absent), for rollback.
-*/
-async function writeIndexCopy(git, path, text) {
-	const old = await worktreeReader(git).read(path);
-	return {
-		wrote: !holdsText(old, text) && await writeIndexFile(git, path, text),
-		old,
-		stage: !holdsText(await (await indexReader(git)).read(path), text)
-	};
-}
-/** The first line of an error's message, for notes and headlines. */
-const firstLine = (err) => (err instanceof Error ? err.message : String(err)).split("\n")[0] ?? "";
 /**
 * `adr index` (design 2b §4.5) with what the text output needs; `indexDecisionLog` is the
 * library entry.
@@ -662,6 +663,117 @@ async function runDecisionIndex(log, o = {}) {
 async function indexDecisionLog(log, o = {}) {
 	return (await runDecisionIndex(log, o)).doc;
 }
+// src/sources.ts
+/** The kinds adr reads from `[[sources]]`: only decision logs. */
+const DECISION_SOURCE_KINDS = ["adr"];
+const compiled$1 = compileKind(adrKind);
+/** Numbers recorded in a source's committed index, as a `Numbering`. */
+function indexNumbering(byId) {
+	if (byId === null) return NO_NUMBERING;
+	return {
+		available: true,
+		reason: "index",
+		ref: null,
+		commit: null,
+		byId,
+		byNumber: new Map([...byId].map(([id, n]) => [n, id]))
+	};
+}
+/** The `[[sources]]` entries adr reads and the ones it skips, in config order. */
+function decisionSourceConfigs(log) {
+	const all = log.config?.sources ?? [];
+	const sources = sourcesOfKinds(all, DECISION_SOURCE_KINDS);
+	return {
+		sources,
+		skipped: all.filter((s) => !sources.includes(s))
+	};
+}
+/**
+* Reads the decision logs of the `kind = "adr"` `[[sources]]` entries (other kinds are never
+* fetched): from the local cache only with `fetch: "cache"` (the default), else fetched first
+* (`readSources`; a failed fetch throws `SourceFetchError`). A cached source's decisions are folded
+* with adr's kind and numbered from its committed `index.md` (the cache is a depth-1 clone, so
+* history numbering can't work), else shown by id.
+*/
+async function readDecisionSources(log, o = {}) {
+	const { sources } = decisionSourceConfigs(log);
+	const reads = await readSources(log.git, sources, { fetch: o.fetch ?? "cache" });
+	const logs = /* @__PURE__ */ new Map();
+	const notes = [];
+	for (const r of reads) {
+		if (r.source === null) {
+			logs.set(r.config.name, {
+				subjects: null,
+				commit: null
+			});
+			continue;
+		}
+		const ref = sourceLogRef(r.source, {
+			layout: adrKind.def.layout,
+			defaultRoot: adrKind.def.defaultRoot
+		});
+		const snapshot = await loadLog(ref.tree, {
+			kind: compiled$1,
+			layout: ref.layout
+		});
+		if (snapshot.subjects.size === 0) notes.push(`source ${r.config.name} has no decision log at ${ref.layout.root} in ${r.source.commit.slice(0, 12)}`);
+		const numbering = indexNumbering(await readIndexNumbers(ref.tree, `${ref.layout.root}/index.md`));
+		const projected = projectLog(adrKind, foldLog(adrKind, snapshot), { numbering }).views;
+		logs.set(r.config.name, {
+			commit: r.source.commit,
+			subjects: new Map([...projected].map(([id, v]) => [id, {
+				status: v.status,
+				display: v.display,
+				title: v.title
+			}]))
+		});
+	}
+	return {
+		logs,
+		statuses: reads.map((r) => r.status),
+		notes
+	};
+}
+const SOURCE_NAME$1 = /^[a-z][a-z0-9-]{0,31}$/;
+/**
+* The cached decision log of the `[[sources]]` entry `name`, as a `DecisionsRead` for `adr list
+* --source` and `adr search --source` (cache only, never the network). An uncached source reads as
+* an empty log with the note `<name> not fetched; run adr sources fetch`. Throws `UsageError` for a
+* name that isn't configured or whose kind adr doesn't read.
+*/
+async function readSourceDecisions(log, name) {
+	if (!SOURCE_NAME$1.test(name)) throw new UsageError(`--source must match ${SOURCE_NAME$1.source}: ${name}`);
+	const { sources, skipped } = decisionSourceConfigs(log);
+	const other = skipped.find((s) => s.name === name);
+	if (other !== void 0) throw new UsageError(`source ${name} has kind ${other.kind}, which adr doesn't read`);
+	const config = sources.find((s) => s.name === name);
+	if (config === void 0) {
+		const known = [...sources, ...skipped].map((s) => s.name);
+		throw new UsageError(known.length === 0 ? `unknown source ${name}; there are no sources` : `unknown source ${name}; the sources are ${known.join(", ")}`);
+	}
+	const [r] = await readSources(log.git, [config], { fetch: "cache" });
+	const base = {
+		adr: log.adr,
+		notes: [...log.notes],
+		source: name
+	};
+	if (r?.source === void 0 || r.source === null) return readDecisionsFrom(new MemoryTree({}), {
+		...base,
+		layout: adrKind.layoutAt(config.root ?? adrKind.def.defaultRoot),
+		numbering: NO_NUMBERING,
+		notes: [...base.notes, `${name} not fetched; run adr sources fetch`]
+	});
+	const ref = sourceLogRef(r.source, {
+		layout: adrKind.def.layout,
+		defaultRoot: adrKind.def.defaultRoot
+	});
+	return readDecisionsFrom(ref.tree, {
+		...base,
+		layout: ref.layout,
+		numbering: indexNumbering(await readIndexNumbers(ref.tree, `${ref.layout.root}/index.md`)),
+		commit: r.source.commit
+	});
+}
 /** The built-in templates by name: the file text `adr new` materializes. */
 const BUILTIN_TEMPLATES = Object.freeze({
 	nygard: `---
@@ -1250,9 +1362,12 @@ async function planAccept(read, input, c, o = {}) {
 	const involved = sorted([id, ...targets]);
 	const { scope, eventDirs } = commitScope(read, involved);
 	const bodyPath = view.body_path ?? "";
+	const globs = copied === null ? view.applies_to : copied.data.set;
+	const unmatched = o.tracked === void 0 ? [] : unmatchedGlobs(globs, o.tracked);
 	return {
 		ok: true,
 		plan: {
+			...unmatched.length === 0 ? {} : { notes: unmatched.map((g) => `${g} matches no tracked file; from this commit verify reports scope/glob-unmatched until a file matches, so commit the files with it or change the scope`) },
 			command: "accept",
 			subject: id,
 			files,
@@ -1480,8 +1595,9 @@ const LINK_RELS = [
 const SOURCE_NAME = /^[a-z][a-z0-9-]{0,31}$/;
 /**
 * Plans `adr link` (design §6.7): `linked` in every state. A qualified target must name one of
-* `o.sources` (the log's `[[sources]]` names); it isn't looked up in the other log. A link that
-* already exists plans nothing, with a note.
+* `o.sources` (the log's `[[sources]]` names) of kind `adr` (`o.logs`, from the local cache): a
+* cached source must hold the id, else `UsageError`; into an uncached one the link is written with
+* a note that it isn't checked. A link that already exists plans nothing, with a note.
 */
 async function planLink(read, input, c, o = {}) {
 	const rel = input.rel ?? "relates-to";
@@ -1493,12 +1609,19 @@ async function planLink(read, input, c, o = {}) {
 	let shown;
 	let described;
 	let named;
+	let foreignNote = null;
 	const at = target.indexOf(":");
 	if (at >= 0) {
 		const source = target.slice(0, at);
 		const local = target.slice(at + 1);
 		if (!SOURCE_NAME.test(source) || !isSubjectId(local)) throw new UsageError(`invalid decision ${JSON.stringify(input.to)}`);
 		if (!(o.sources ?? []).includes(source)) throw new UsageError(`unknown source ${source}; add a [[sources]] entry named ${source}`);
+		const kind = o.kinds?.get(source);
+		if (kind !== void 0 && kind !== "adr") throw new UsageError(`source ${source} has kind ${kind}, which adr doesn't read`);
+		const cached = o.logs?.get(source);
+		if (cached?.subjects !== null && cached?.subjects !== void 0) {
+			if (!cached.subjects.has(local)) throw new UsageError(`${target} is not in source ${source} (pinned at ${(cached.commit ?? "").slice(0, 12)})`);
+		} else if (o.logs !== void 0) foreignNote = `${source} not fetched; the reference isn't checked`;
 		to = target;
 		shown = target;
 		described = `${rel} ${target}.`;
@@ -1549,7 +1672,8 @@ async function planLink(read, input, c, o = {}) {
 				...r.plan.commit,
 				title: named,
 				body: [described]
-			}
+			},
+			notes: [...r.plan.notes ?? [], ...foreignNote === null ? [] : [foreignNote]]
 		}
 	};
 }
@@ -1608,7 +1732,7 @@ async function planScope(read, input, c, o = {}) {
 		}
 	};
 	if (o.tracked !== void 0) {
-		const checked = (adrKind.def.scope?.activeIn ?? []).includes(view.status) ? "; verify (hooks and CI) reports scope/glob-unmatched until a file matches" : "";
+		const checked = (adrKind.def.scope?.requireMatchIn ?? []).includes(view.status) ? "; verify (hooks and CI) reports scope/glob-unmatched until a file matches" : view.status === "proposed" ? `; verify reports scope/glob-unmatched once ${view.display} is accepted, until a file matches` : "";
 		notes.push(...unmatchedGlobs(result.set, o.tracked).map((g) => `${g} matches no tracked file${checked}`));
 	}
 	if (result.removed.length > 0 && (view.status === "accepted" || view.status === "deprecated")) notes.push("this narrows the scope of an accepted decision; if its Scope section no longer reads true, propose a superseding decision instead");
@@ -1797,7 +1921,8 @@ async function unstagedIndexNote(log, at, staged, history, render) {
 */
 async function applyPlan(log, plan, o) {
 	const { git } = log;
-	if (o.commit && o.message === void 0) throw new InvalidArgumentError("applyPlan needs a message to commit");
+	if (o.commit && o.message === void 0 && o.compose === void 0) throw new InvalidArgumentError("applyPlan needs a message to commit");
+	if (o.message !== void 0 && o.compose !== void 0) throw new InvalidArgumentError("applyPlan takes a message or compose, not both");
 	const stage = new Set(plan.stage);
 	if (o.commit) {
 		const unstaged = new Set(await git.unstagedPaths(plan.commitScope));
@@ -1902,16 +2027,24 @@ async function applyPlan(log, plan, o) {
 	}
 	const stale = (err) => `${at} may be stale: ${firstLine(err)}; run adr index`;
 	let sha = null;
+	let rendered = null;
 	if (commit) {
 		const extra = await extraOf();
-		const staged = extra.filter(isYaml).flatMap((p) => {
-			const c = classifyPath(log.layout, p);
-			const name = c.area === "event" && !c.file.includes("/") ? parseEventFileName(c.file) : null;
-			return c.area === "event" && c.subject !== null && name !== null ? [["ADR", c.subject], ["ADR-Event", name.type]] : [];
+		const extraRefs = stagedEventRefs(log.layout, extra);
+		const planRefs = plan.events.map((e) => ({
+			subject: e.subject,
+			type: e.type
+		}));
+		rendered = o.compose === void 0 ? null : o.compose({
+			plan: planRefs,
+			extra: extraRefs,
+			tree: await commitTree(extra)
 		});
-		const message = o.message ?? "";
+		const message = rendered?.message ?? o.message ?? "";
 		const mergeTrailers = o.mergeTrailers === true;
-		const trailers = [...staged, ...plan.trailers];
+		const pairs = eventTrailers([...extraRefs, ...planRefs], TRAILER_KEYS);
+		const named = new Set(pairs.filter(([k]) => k === "ADR").map(([, v]) => v));
+		const trailers = [...pairs, ...plan.events.length === 0 ? plan.trailers.filter(([k, v]) => k !== "ADR" || !named.has(v)) : []];
 		const sameEvents = sorted(extra.filter(isYaml)).join("\0") === sorted(extra0.filter(isYaml)).join("\0");
 		if (text !== null && o.index !== void 0 && o.afterStage !== void 0 && !sameEvents) try {
 			const again = await o.index(await commitTree(extra), head);
@@ -1990,22 +2123,40 @@ async function applyPlan(log, plan, o) {
 		],
 		commit: sha,
 		findings,
-		notes
+		notes,
+		rendered
 	};
 }
+/** The `ADR`/`ADR-Event` trailer keys. */
+const TRAILER_KEYS = {
+	subject: "ADR",
+	event: "ADR-Event"
+};
+/**
+* The staged event files among `paths` as (decision, type) refs, in path order (by decision,
+* then event time), deduplicated by decision and type.
+*/
+function stagedEventRefs(layout, paths) {
+	const found = [];
+	for (const p of sorted(paths.filter(isYaml))) {
+		const c = classifyPath(layout, p);
+		if (c.area !== "event" || c.subject === null || c.file.includes("/")) continue;
+		const name = parseEventFileName(c.file);
+		if (name !== null) found.push({
+			subject: c.subject,
+			type: name.type
+		});
+	}
+	const seen = /* @__PURE__ */ new Set();
+	return found.filter((r) => {
+		const key = `${r.subject}\0${r.type}`;
+		if (seen.has(key)) return false;
+		seen.add(key);
+		return true;
+	});
+}
 /** The new bytes of each file a plan replaces. */
 const replaceBytes = (plan) => Object.fromEntries(Object.entries(plan.replace ?? {}).map(([p, r]) => [p, r.bytes]));
-/** `tree` without the paths in `gone` (a staged deletion in a commit's `only` list). */
-function withoutPaths(tree, gone) {
-	if (gone.size === 0) return tree;
-	return {
-		label: tree.label,
-		commit: null,
-		list: async (prefix) => (await tree.list(prefix)).filter((e) => !gone.has(e.path)),
-		read: async (path) => gone.has(path) ? null : tree.read(path),
-		readMany: (paths) => tree.readMany(paths.filter((p) => !gone.has(p)))
-	};
-}
 const DEFAULT_DEPS = {
 	now: Date.now,
 	apply: applyPlan
@@ -2031,7 +2182,6 @@ async function viewsAfter(log, plan, sha) {
 		affected: plan.affected.map(view)
 	};
 }
-const SHORTENED_NOTE = "commit subject shortened to 72 characters; the full title is in the commit body";
 /**
 * `--commit` needs an author and a committer identity; checked before anything is written, since
 * `GIT_AUTHOR_*` alone satisfies the author while `git commit` still fails on the committer.
@@ -2039,24 +2189,63 @@ const SHORTENED_NOTE = "commit subject shortened to 72 characters; the full titl
 async function checkCommitIdentity(log) {
 	if (await log.git.identity() === null || await log.git.committerIdentity() === null) throw new ConfigError("--commit needs a git identity; set git user.name and user.email");
 }
-/** The plan's commit message from `[commit] subject` (design §4), and whether it was shortened. */
-function commitMessage(log, command, plan) {
+const STATUS_TYPES = /* @__PURE__ */ new Set([
+	"proposed",
+	"accepted",
+	"rejected",
+	"withdrawn"
+]);
+/**
+* The commit's action and title slot (ADR-0008, ?6), chosen once the staged events the commit
+* sweeps in are known: when `plan` or `extra` holds a status event (proposed, accepted, rejected,
+* withdrawn), the title form of the last one, since that is what the commit decides. Otherwise
+* the plan's own subject when the extra events add no other verb; with two or three verbs those
+* joined (`link and scope ADR-0003`), and beyond three (or where the joined verbs don't fit a
+* custom template) `update ADR-0003`. Every single-action subject stays the plan's own, byte for
+* byte.
+*/
+function composeSubject(read, parts, c) {
+	const status = [...c.extra, ...c.plan].filter((e) => STATUS_TYPES.has(e.type)).at(-1);
+	if (status !== void 0) {
+		if (c.plan.some((e) => e.subject === status.subject && e.type === status.type)) return {
+			action: parts.action,
+			title: parts.title
+		};
+		return {
+			action: ACTIONS[status.type].action,
+			title: read.projection.views.get(status.subject)?.title ?? status.subject
+		};
+	}
+	const primary = c.plan[0]?.type;
+	const verbs = /* @__PURE__ */ new Set();
+	for (const t of [primary, ...c.extra.map((e) => e.type)]) if (t !== void 0 && Object.hasOwn(BATCH_ACTIONS, t)) verbs.add(t);
+	if (verbs.size <= 1 || primary === void 0 || !verbs.has(primary)) return {
+		action: parts.action,
+		title: parts.title
+	};
+	const ordered = BATCH_ORDER.filter((t) => verbs.has(t)).map((t) => BATCH_ACTIONS[t]);
+	return {
+		action: ordered.length > 3 ? UPDATE_ACTION : joinActions(ordered),
+		title: parts.display
+	};
+}
+/** The plan's commit message from `[commit] subject` (design §4), with `composeSubject`'s slot. */
+function commitMessage(log, command, read, plan, c) {
 	const parts = plan.commit;
 	if (parts === null) throw new InvalidArgumentError("this write can't be committed");
-	const r = renderCommitMessage(log.adr.commitSubject, {
-		title: parts.title,
+	const { action, title } = composeSubject(read, parts, c);
+	const render = (a) => renderCommitMessage(log.adr.commitSubject, {
+		title,
 		vars: {
-			action: parts.action,
+			action: a,
 			id: parts.id,
 			display: parts.display,
 			command
 		},
 		body: parts.body
 	});
-	return {
-		message: r.message,
-		shortened: r.shortened
-	};
+	const r = render(action);
+	return r.shortened && title === parts.display && action !== parts.action ? render(UPDATE_ACTION) : r;
 }
 /**
 * Plan, then apply, with the single `EventExistsError` retry (§5.4 steps 1–5). `o.message`
@@ -2101,15 +2290,15 @@ async function write(log, command, plan, o, deps, afterStage) {
 			findings: r.plan.findings,
 			notes: [...notes, ...r.plan.notes ?? []]
 		};
-		const rendered = commit ? commitMessage(log, command, r.plan) : null;
+		if (commit && r.plan.commit === null) throw new InvalidArgumentError("this write can't be committed");
 		const given = o.message ?? null;
 		try {
 			const applied = await deps.apply(log, r.plan, {
 				commit,
-				...rendered === null ? {} : {
-					message: given ?? rendered.message,
-					mergeTrailers: given !== null
-				},
+				...!commit ? {} : given !== null ? {
+					message: given,
+					mergeTrailers: true
+				} : { compose: (c) => commitMessage(log, command, read, r.plan, c) },
 				...afterStage === void 0 ? {} : { afterStage: afterStage(r.plan, commit) },
 				...log.adr.index === "committed" && o.index !== "skip" ? { index: (tree, history) => renderDecisionIndex(log.git, {
 					layout: log.layout,
@@ -2122,7 +2311,7 @@ async function write(log, command, plan, o, deps, afterStage) {
 			const own = [
 				...r.plan.notes ?? [],
 				...applied.notes,
-				...applied.commit !== null && given === null && rendered?.shortened === true ? [SHORTENED_NOTE] : []
+				...applied.commit !== null && applied.rendered?.note != null ? [applied.rendered.note] : []
 			];
 			return {
 				format: "adr-write/v1",
@@ -2225,14 +2414,18 @@ async function proposeDecision(log, input, o = {}, deps = DEFAULT_DEPS) {
 async function acceptDecision(log, input, o = {}, deps = DEFAULT_DEPS) {
 	const copyScope = o.copyScope ?? "suggest";
 	let copy = null;
+	const tracked = await trackedFiles(log);
 	return write(log, "accept", async (read, c) => {
-		const plain = await planAccept(read, input, c);
+		const plain = await planAccept(read, input, c, { tracked });
 		if (!plain.ok) return plain;
 		const id = plain.plan.subject;
 		const offer = scopeToCopy(read, id);
 		if (offer.globs.length === 0) return plain;
 		if (copy === null) copy = typeof copyScope === "function" ? await copyScope(offer) : copyScope === "copy";
-		if (copy) return planAccept(read, input, c, { copyGlobs: offer.globs });
+		if (copy) return planAccept(read, input, c, {
+			copyGlobs: offer.globs,
+			tracked
+		});
 		if (copyScope === "skip") return plain;
 		const notes = [...plain.plan.notes ?? [], copyScopeNote(id, offer)];
 		return {
@@ -2275,8 +2468,15 @@ async function noteDecision(log, input, o = {}, deps = DEFAULT_DEPS) {
 * Qualified targets name the log's `[[sources]]`; a link that exists already writes nothing.
 */
 async function linkDecision(log, input, o = {}, deps = DEFAULT_DEPS) {
-	const sources = (log.config?.sources ?? []).map((s) => s.name);
-	return write(log, "link", (read, c) => planLink(read, input, c, { sources }), o, deps);
+	const configs = log.config?.sources ?? [];
+	const sources = configs.map((s) => s.name);
+	const kinds = new Map(configs.map((s) => [s.name, s.kind]));
+	const logs = input.to.includes(":") ? (await readDecisionSources(log, { fetch: "cache" })).logs : void 0;
+	return write(log, "link", (read, c) => planLink(read, input, c, {
+		sources,
+		kinds,
+		...logs === void 0 ? {} : { logs }
+	}), o, deps);
 }
 /**
 * `adr scope <id> --set|--add|--remove …`: writes one `scoped` event with the new set, stages it,
@@ -2362,6 +2562,7 @@ function listDecisions(read, o = {}) {
 	const listed = new Set(decisions.map((v) => v.id));
 	return {
 		format: "adr-list/v1",
+		source: read.source,
 		root: read.root,
 		ref: read.ref,
 		commit: read.commit,
@@ -2746,6 +2947,7 @@ function searchDecisions(read, o) {
 	const listed = new Set(results.map((r) => r.decision.id));
 	return {
 		format: "adr-search/v1",
+		source: read.source,
 		root: read.root,
 		ref: read.ref,
 		commit: read.commit,
@@ -2760,6 +2962,6 @@ function searchDecisions(read, o) {
 		notes: listingNotes(read)
 	};
 }
-export { changedSince as A, headTree as C, renderDecisionIndex as D, indexPath as E, readDecisionsFrom as F, resolveDecision as I, sourcesNote as L, numberingNote as M, openDecisionLog as N, runDecisionIndex as O, readDecisions as P, DEFAULT_ADR_CONFIG as R, firstLine as S, indexDecisionLog as T, withdrawDecision as _, stateHeader as a, INDEX_AFTER as b, followScopeRenames as c, proposeDecision as d, rejectDecision as f, updateDraft as g, supersedeDecision as h, showDecision as i, numberDecisions as j, writeIndexCopy as k, linkDecision as l, scopeToCopy as m, decisionsFor as n, acceptDecision as o, scopeDecision as p, listDecisions as r, deprecateDecision as s, searchDecisions as t, noteDecision as u, BUILTIN_TEMPLATES as v, holdsText as w, decisionIndexCheck as x, DECISION_INDEX as y, parseAdrConfig as z };
+export { numberDecisions as A, INDEX_AFTER as C, renderDecisionIndex as D, indexPath as E, resolveDecision as F, sourcesNote as I, DEFAULT_ADR_CONFIG as L, openDecisionLog as M, readDecisions as N, runDecisionIndex as O, readDecisionsFrom as P, parseAdrConfig as R, DECISION_INDEX as S, indexDecisionLog as T, withdrawDecision as _, stateHeader as a, readDecisionSources as b, followScopeRenames as c, proposeDecision as d, rejectDecision as f, updateDraft as g, supersedeDecision as h, showDecision as i, numberingNote as j, changedSince as k, linkDecision as l, scopeToCopy as m, decisionsFor as n, acceptDecision as o, scopeDecision as p, listDecisions as r, deprecateDecision as s, searchDecisions as t, noteDecision as u, BUILTIN_TEMPLATES as v, decisionIndexCheck as w, readSourceDecisions as x, decisionSourceConfigs as y };
 
-//# sourceMappingURL=search-CwIPlNGd.js.map
+//# sourceMappingURL=search-CTspg2pd.js.map