@nikovirtala/adr 0.2.0 → 0.4.0

package/dist/server-CXCO5zfp.js

@@ -0,0 +1,938 @@
+import { I as resolveDecision, N as openDecisionLog, P as readDecisions, _ as withdrawDecision, a as stateHeader, d as proposeDecision, f as rejectDecision, g as updateDraft, h as supersedeDecision, i as showDecision, l as linkDecision, n as decisionsFor, o as acceptDecision, p as scopeDecision, r as listDecisions, s as deprecateDecision, t as searchDecisions, u as noteDecision, y as DECISION_INDEX } from "./search-CwIPlNGd.js";
+import { n as DECISION_STATUSES, t as adrKind } from "./kind-DjvA3dyA.js";
+import { t as listTemplates } from "./list-Dt4KGxvj.js";
+import { MAX_GLOB_LENGTH, UsageError, eventDir, parseOnBehalfOf, renderIndex, renderStateHeader, resolveSubjectInput } from "@nikovirtala/ledger";
+import { mcpAttribution, serveMcp } from "@nikovirtala/ledger/mcp";
+// src/mcp/policy.ts
+/** The tools that decide; listed only with `[policy] mcp_can_decide = true`. */
+const DECISION_TOOLS = [
+	"adr_accept",
+	"adr_reject",
+	"adr_deprecate",
+	"adr_supersede"
+];
+/** Whether `adr mcp` offers the decision tools (design §7.5, Table A). */
+function decisionToolsAvailable(adr) {
+	return adr.mcpCanDecide;
+}
+/**
+* Who a proposal is for (design D5): its `proposed` event's actor, `on_behalf_of` for an agent
+* and `email` for a human, lower-cased; `null` when the event or the address is missing.
+*/
+function proposalOwner(read, id) {
+	const actor = (read.folded.subjects.get(id)?.applied.find((a) => a.event.type === adrKind.machine.initial.type))?.event.actor;
+	if (actor === void 0) return null;
+	const owner = actor.kind === "agent" ? actor.on_behalf_of : actor.email;
+	return typeof owner === "string" && owner.trim() !== "" ? owner.trim().toLowerCase() : null;
+}
+/**
+* The MCP policy (design §7.5, Table B): `null` when the write may go ahead, else the
+* `decision/mcp-cannot-decide` finding. Without `mcp_can_decide` an agent may scope, edit and
+* withdraw only the proposals made for the person it acts for, and rescope no accepted or
+* deprecated decision.
+* Writes the state machine forbids anyway get `null`, so the library refuses them with the real
+* reason.
+*/
+function mcpWriteRefusal(o) {
+	const { view } = o;
+	if (o.tool === "adr_scope" && !adrKind.machine.allowed(view.status, "scoped")) return null;
+	if (o.tool === "adr_update_draft" && view.status !== "proposed") return null;
+	if (o.tool === "adr_withdraw" && !adrKind.machine.allowed(view.status, "withdrawn")) return null;
+	if (o.mcpCanDecide) return null;
+	const me = o.actor.on_behalf_of?.trim().toLowerCase() ?? null;
+	if (view.status === "proposed" && o.owner !== null && o.owner === me) return null;
+	const shown = o.display(view.id);
+	const named = shown === view.id ? view.id : `${shown} (${view.id})`;
+	const verb = o.tool === "adr_withdraw" ? "withdrawing" : "changing";
+	return {
+		severity: "error",
+		rule: "decision/mcp-cannot-decide",
+		message: view.status === "proposed" ? `${named} was proposed for ${o.owner ?? "someone else"}, and you act for ${o.actor.on_behalf_of ?? "nobody"}; ${verb} another person's proposal needs [policy] mcp_can_decide = true. Add a note with adr_note instead.` : `${named} is ${view.status}; rescoping it needs [policy] mcp_can_decide = true, because narrowing a scope can switch a decision off. Ask a human to run adr scope ${shown} …, or propose a superseding decision.`,
+		file: view.body_path ?? o.eventsDir,
+		line: null,
+		subject: view.id,
+		kind: adrKind.name
+	};
+}
+// src/mcp/resources.ts
+const MAX_ID = 64;
+/**
+* Where an MCP client reads a decision: `adr://decision/ADR-0012` when numbered, else
+* `adr://decision/<id>`. The `refer` of every header the MCP texts show.
+*/
+function decisionUri(read) {
+	return (id) => `adr://decision/${read.projection.views.get(id)?.display ?? id}`;
+}
+/** `adr://index`: the index table, numbered like every other read (design §7.7). */
+function indexResource(e) {
+	return {
+		uri: "adr://index",
+		name: "index",
+		title: "Decision index",
+		description: "All decisions, grouped by status, with numbers and dates",
+		mimeType: "text/markdown",
+		async read() {
+			const read = await readDecisions(await openLog(e));
+			const views = read.projection.views;
+			return {
+				header: null,
+				text: renderIndex(DECISION_INDEX(read.root, views), [...views.values()], read.numbering)
+			};
+		}
+	};
+}
+/**
+* `adr://decision/{id}`: the decision's state header, then its body. `{id}` is the id, the number
+* (`12`, `0012`) or `ADR-0012`; an unknown one is not found, a malformed or qualified one is the
+* caller's error.
+*/
+function decisionResource(e) {
+	return {
+		uriTemplate: "adr://decision/{id}",
+		name: "decision",
+		title: "Decision",
+		description: "One decision: its state header, then its body. {id} is the id (k3f9q8a1), the number (12) or ADR-0012",
+		mimeType: "text/markdown",
+		async read({ id = "" }) {
+			if (id.length > MAX_ID) throw new UsageError(`invalid decision ${JSON.stringify(`${id.slice(0, MAX_ID)}…`)}: an id or number is at most ${MAX_ID} characters`);
+			const read = await readDecisions(await openLog(e));
+			const r = resolveSubjectInput(id, {
+				subjects: new Set(read.folded.subjects.keys()),
+				kind: adrKind,
+				numbering: read.numbering
+			});
+			if (!r.ok && r.reason === "not-found") return null;
+			const doc = await showDecision(read, resolveDecision(read, id));
+			return {
+				header: mcpHeader(doc.decision, read),
+				text: doc.body === null ? "(no body file)\n" : doc.body
+			};
+		}
+	};
+}
+// src/mcp/text.ts
+/**
+* The readable text of each MCP tool result (design §7.4, last column). The documents are the
+* CLI's; these texts are MCP's own, and their state headers point at `adr://decision/…`.
+*/
+const display = (read) => (id) => read.projection.views.get(id)?.display ?? id;
+function named(read, id) {
+	const shown = display(read)(id);
+	return shown === id ? id : `${shown} (${id})`;
+}
+/** The decision's state header with MCP's `adr://` references. */
+function mcpHeader(view, read) {
+	return stateHeader(view, read, { refer: decisionUri(read) });
+}
+/** `adr_search`: each result's header, title and excerpt, then the counts. */
+function searchText(doc, read) {
+	if (doc.results.length === 0) return {
+		headers: [],
+		text: ["No decisions match.", ...doc.inactive_omitted > 0 ? [`${inactiveLine(doc.inactive_omitted)}; pass include_inactive`] : []].join("\n")
+	};
+	const lines = [];
+	for (const r of doc.results) {
+		lines.push(renderStateHeader(mcpHeader(r.decision, read)).trimEnd());
+		lines.push(`  ${r.decision.title}`);
+		const where = r.matched.filter((f) => f === "id" || f === "title").join(" and ");
+		lines.push(r.excerpt === null ? `  (${where} match)` : `  ${r.excerpt}`);
+	}
+	lines.push(`${doc.results.length} of ${doc.total} shown`);
+	if (doc.inactive_omitted > 0) lines.push(`${inactiveLine(doc.inactive_omitted)}; pass include_inactive`);
+	return {
+		headers: [],
+		text: lines.join("\n")
+	};
+}
+const inactiveLine = (k) => k === 1 ? "1 inactive decision also matches" : `${k} inactive decisions also match`;
+function listOf(read, ids) {
+	return ids.length === 0 ? "none" : ids.map((id) => named(read, id)).join(", ");
+}
+function historyLines(events) {
+	return events.map((e) => {
+		const a = e.actor;
+		const who = a.kind === "agent" ? `${a.name} (agent for ${a.on_behalf_of})` : a.name;
+		const why = typeof e.reason === "string" ? ` — ${e.reason}` : "";
+		return `  ${e.at}  ${e.type}  ${who}${why}`;
+	});
+}
+/** `adr_get`: the header, the decision's fields as `adr show` lists them, then the body. */
+function getText(doc, read) {
+	const v = doc.decision;
+	const lines = [
+		`Title: ${v.title}`,
+		`Status: ${v.status} (${v.status_at.slice(0, 10)})`,
+		`Effective: ${v.effective === null ? "none (supersession cycle)" : named(read, v.effective)}`,
+		`Chain: ${v.chain.map(display(read)).join(" → ")}`,
+		`Supersedes: ${listOf(read, v.supersedes)}`,
+		`Applies to: ${v.applies_to.length === 0 ? "no globs recorded" : v.applies_to.join(", ")}`
+	];
+	if (doc.events !== null) lines.push("History:", ...historyLines(doc.events));
+	lines.push("", doc.body === null ? "(no body file)" : doc.body.trimEnd());
+	return {
+		headers: [mcpHeader(v, read)],
+		text: lines.join("\n")
+	};
+}
+/** `adr_list`: one line per decision. */
+function listText(doc, read) {
+	if (doc.decisions.length === 0) return {
+		headers: [],
+		text: "No decisions."
+	};
+	return {
+		headers: [],
+		text: doc.decisions.map((v) => {
+			const head = v.number === null ? v.id : `${v.display} (${v.id})`;
+			const to = v.effective !== null && v.effective !== v.id ? ` → ${display(read)(v.effective)}` : "";
+			return `${head} · ${v.status} · ${v.title}${to}`;
+		}).join("\n")
+	};
+}
+/** `adr_templates`: each template, then its sections. */
+function templatesText(doc) {
+	const lines = doc.templates.flatMap((t) => [`${t.name} v${t.version} (${t.source})${t.name === doc.default ? " default" : ""}`, ...t.sections.map((s) => `  ${s.id}: ${s.heading} (${s.required ? "required" : "optional"})${s.guidance === null ? "" : ` — ${s.guidance}`}`)]);
+	return {
+		headers: [],
+		text: lines.length === 0 ? "No templates." : lines.join("\n")
+	};
+}
+/** `adr_for_path`: per path, each decision's header and how it matched. */
+function forText(doc, read) {
+	const lines = [];
+	for (const p of doc.paths) {
+		lines.push(p.tracked ? p.path : `${p.path} (not tracked)`);
+		if (p.decisions.length === 0 && p.unresolved.length === 0) lines.push("  no decisions");
+		for (const d of p.decisions) {
+			const view = read.projection.views.get(d.id);
+			const h = view === void 0 ? {
+				line: `${named(read, d.id)} · ${d.status}`,
+				warning: d.warning
+			} : mcpHeader(view, read);
+			lines.push(`  ${h.line}`);
+			if (h.warning !== null) lines.push(`    ${h.warning}`);
+			for (const via of d.via) lines.push(via.type === "glob" ? `    via glob ${via.glob}` : `    via anchor line ${via.line}`);
+		}
+		for (const u of p.unresolved) {
+			const why = u.reason === "other-log" ? "in another log" : "not in this log";
+			lines.push(`  unresolved: ${u.ref} (line ${u.line}, ${why})`);
+		}
+	}
+	return {
+		headers: [],
+		text: lines.join("\n")
+	};
+}
+const SECTION_FINDING = /^(?:required )?section (.+?) (is missing|is empty|still contains its guidance text)$/;
+const REASONS = {
+	"is missing": "missing",
+	"is empty": "empty",
+	"still contains its guidance text": "guidance"
+};
+/** Lint findings as `Fill in: <heading> (<reason>)`, others as `Draft: <message> [<rule>]`. */
+function lintLines(findings) {
+	return findings.map((f) => {
+		const m = SECTION_FINDING.exec(f.message);
+		if (m === null) return `Draft: ${f.message} [${f.rule}]`;
+		const [, heading = "", what = ""] = m;
+		return `Fill in: ${heading} (${REASONS[what] ?? what})`;
+	});
+}
+const noteLines = (doc) => doc.notes.map((n) => `Note: ${n}`);
+/** A write's text: `Refused:` and the findings, or what was written; then the notes. */
+function writeText(doc, o) {
+	const { read } = o;
+	const view = doc.decision === null ? null : read.projection.views.get(doc.decision.id) ?? doc.decision;
+	const headers = view === null ? [] : [mcpHeader(view, read), ...affectedHeaders(doc, read)];
+	if (!doc.ok) {
+		const again = doc.findings.length > 0 && doc.findings.every((f) => f.rule.startsWith("template/")) && (o.tool === "adr_propose" || o.tool === "adr_update_draft") ? [`Fill in every required section and call ${o.tool} again.`] : [];
+		return {
+			headers,
+			text: [
+				"Refused:",
+				...doc.findings.map((f) => `  ${f.file === null ? "" : `${f.file}: `}${f.message} [${f.rule}]`),
+				...again,
+				...noteLines(doc)
+			].join("\n")
+		};
+	}
+	if (view === null) return {
+		headers,
+		text: noteLines(doc).join("\n")
+	};
+	return {
+		headers,
+		text: [...bodyLines(doc, view, o), ...noteLines(doc)].join("\n")
+	};
+}
+function bodyLines(doc, v, o) {
+	const { read } = o;
+	const who = named(read, v.id);
+	const recorded = doc.commit === null ? [] : [`Committed ${doc.commit.slice(0, 7)}.`];
+	switch (doc.command) {
+		case "new": return [
+			`Proposed ${v.id}: ${v.title}`,
+			...v.body_path === null ? [] : [`  ${v.body_path}`],
+			...lintLines(doc.findings),
+			...recorded,
+			o.acceptRequiresHuman === true ? `Next: ask a human to review and accept it (adr accept ${v.id})` : `Next: adr_accept or adr accept ${v.id}`
+		];
+		case "update": return doc.written.length === 0 ? ["Unchanged"] : [
+			`Updated the draft of ${who}: ${(o.sections ?? []).join(", ")}`,
+			...lintLines(doc.findings),
+			...recorded
+		];
+		case "note": return [`Noted on ${who}`, ...recorded];
+		case "link": {
+			const link = doc.written.length === 0 ? void 0 : v.links.at(-1);
+			if (link === void 0) return [`Links of ${who} unchanged`];
+			return [`Linked ${who} ${link.rel} ${named(read, link.to)}`, ...recorded];
+		}
+		case "scope": {
+			const before = new Set(o.scopeBefore ?? []);
+			const after = new Set(v.applies_to);
+			if (doc.written.length === 0) return ["unchanged"];
+			return [
+				...v.applies_to.filter((g) => !before.has(g)).map((g) => `+ ${g}`),
+				...[...before].filter((g) => !after.has(g)).map((g) => `- ${g}`),
+				`= ${v.applies_to.length === 0 ? "no globs" : v.applies_to.join(", ")}`,
+				...recorded
+			];
+		}
+		case "accept": return [
+			`Accepted ${who}: ${v.title}`,
+			...doc.affected.map((a) => `Superseded ${named(read, a.id)}: ${a.title}`),
+			...recorded
+		];
+		case "reject": return [`Rejected ${who}`, ...recorded];
+		case "withdraw": return [`Withdrawn ${who}`, ...recorded];
+		case "deprecate": return [`Deprecated ${who}`, ...recorded];
+		case "supersede": return [`Superseded ${who} by ${named(read, v.superseded_by ?? "")}`, ...recorded];
+		default: return [`${doc.command} ${who}`, ...recorded];
+	}
+}
+/** The headers of the decisions a write affected (superseded), other than its own. */
+function affectedHeaders(doc, read) {
+	return doc.affected.filter((a) => a.id !== doc.decision?.id).map((a) => mcpHeader(read.projection.views.get(a.id) ?? a, read));
+}
+// src/mcp/tools.ts
+const ID = {
+	type: "string",
+	minLength: 1,
+	maxLength: 64
+};
+const TEXT = {
+	type: "string",
+	minLength: 1,
+	maxLength: 65536
+};
+const SECTIONS = {
+	type: "object",
+	propertyNames: {
+		type: "string",
+		pattern: "^[a-z][a-z0-9-]*$",
+		maxLength: 64
+	},
+	additionalProperties: {
+		type: "string",
+		maxLength: 65536
+	},
+	maxProperties: 50
+};
+const GLOBS = {
+	type: "array",
+	items: {
+		type: "string",
+		minLength: 1,
+		maxLength: MAX_GLOB_LENGTH
+	},
+	maxItems: 200
+};
+const object = (properties, required = []) => ({
+	type: "object",
+	properties,
+	...required.length === 0 ? {} : { required },
+	additionalProperties: false
+});
+const READ = {
+	readOnlyHint: true,
+	openWorldHint: false
+};
+const WRITE = {
+	readOnlyHint: false,
+	destructiveHint: false,
+	openWorldHint: false
+};
+/** The log for one call, opened again so outside edits and `[policy]` changes are seen. */
+const openLog = (e, ref = null) => openDecisionLog({
+	cwd: e.cwd,
+	root: e.root,
+	ref,
+	gitOptions: { env: e.env }
+});
+const str = (v) => typeof v === "string" ? v : void 0;
+const strings = (v) => Array.isArray(v) ? v.filter((x) => typeof x === "string") : void 0;
+const sectionsOf = (v) => typeof v === "object" && v !== null && !Array.isArray(v) ? Object.fromEntries(Object.entries(v).flatMap(([k, x]) => typeof x === "string" ? [[k, x]] : [])) : {};
+const doc = (d) => d;
+/**
+* A write tool's result: the library's document, and its text rendered from a read of the log
+* after the write.
+*/
+async function writeResult(log, d, o) {
+	const read = await readDecisions(log);
+	return {
+		document: doc(d),
+		...writeText(d, {
+			...o,
+			read
+		})
+	};
+}
+/** The `adr-write/v1` command of each policy tool, as the CLI names it. */
+const COMMAND = {
+	adr_scope: "scope",
+	adr_update_draft: "update",
+	adr_withdraw: "withdraw"
+};
+/**
+* The MCP policy step of `adr_scope`, `adr_update_draft` and `adr_withdraw` (design §7.5): the refusal document
+* when the agent may not make this write, else `null`.
+*/
+function policyRefusal(log, read, tool, id, attribution) {
+	const view = read.projection.views.get(id);
+	if (view === void 0) return null;
+	const finding = mcpWriteRefusal({
+		tool,
+		view,
+		owner: proposalOwner(read, id),
+		actor: attribution.actor,
+		mcpCanDecide: log.adr.mcpCanDecide,
+		display: (x) => read.projection.views.get(x)?.display ?? x,
+		eventsDir: eventDir(read.layout, id)
+	});
+	if (finding === null) return null;
+	return {
+		format: "adr-write/v1",
+		command: COMMAND[tool],
+		ok: false,
+		decision: view,
+		affected: [],
+		written: [],
+		commit: null,
+		findings: [finding],
+		notes: [...log.notes, ...attribution.notes]
+	};
+}
+/** The eleven tools `adr mcp` always lists (design §7.4). */
+function alwaysOnTools(e) {
+	return [
+		{
+			name: "adr_search",
+			title: "Search decisions",
+			description: "Full-text search of the decision log: every word must appear in a decision's id, title, body or notes. Returns active (proposed or accepted) decisions unless include_inactive is true, each with its state header and an excerpt.",
+			inputSchema: object({
+				query: {
+					type: "string",
+					minLength: 1,
+					maxLength: 200
+				},
+				include_inactive: { type: "boolean" },
+				limit: {
+					type: "integer",
+					minimum: 1,
+					maximum: 100
+				}
+			}, ["query"]),
+			annotations: READ,
+			async run(input) {
+				const read = await readDecisions(await openLog(e));
+				const d = searchDecisions(read, {
+					query: str(input.query) ?? "",
+					includeInactive: input.include_inactive === true,
+					limit: typeof input.limit === "number" ? input.limit : 10
+				});
+				return {
+					document: doc(d),
+					...searchText(d, read)
+				};
+			}
+		},
+		{
+			name: "adr_get",
+			title: "Get a decision",
+			description: "One decision with its state header, computed status, supersession chain, effective decision and body. Use this or adr://decision/{id} instead of reading files under docs/adr. A SUPERSEDED or DEPRECATED header means: don't apply it, follow the warning.",
+			inputSchema: object({
+				id: ID,
+				include_history: { type: "boolean" },
+				ref: {
+					type: "string",
+					minLength: 1,
+					maxLength: 256
+				}
+			}, ["id"]),
+			annotations: READ,
+			async run(input) {
+				const read = await readDecisions(await openLog(e, str(input.ref) ?? null));
+				const id = resolveDecision(read, str(input.id) ?? "");
+				const d = await showDecision(read, id, { history: input.include_history === true });
+				return {
+					document: doc(d),
+					...getText(d, read)
+				};
+			}
+		},
+		{
+			name: "adr_list",
+			title: "List decisions",
+			description: "All decisions with their computed status, for orientation. Filter by status; limit truncates.",
+			inputSchema: object({
+				status: {
+					type: "array",
+					items: {
+						type: "string",
+						enum: [...DECISION_STATUSES]
+					},
+					uniqueItems: true,
+					minItems: 1,
+					maxItems: DECISION_STATUSES.length
+				},
+				limit: {
+					type: "integer",
+					minimum: 1,
+					maximum: 1e3
+				}
+			}),
+			annotations: READ,
+			async run(input) {
+				const read = await readDecisions(await openLog(e));
+				const status = strings(input.status);
+				const d = listDecisions(read, {
+					...status === void 0 ? {} : { status },
+					...typeof input.limit === "number" ? { limit: input.limit } : {}
+				});
+				return {
+					document: doc(d),
+					...listText(d, read)
+				};
+			}
+		},
+		{
+			name: "adr_templates",
+			title: "List templates",
+			description: "The templates adr_propose can use, with each section's id, heading, whether it is required, and guidance for filling it in.",
+			inputSchema: object({}),
+			annotations: READ,
+			async run() {
+				const d = await listTemplates(await readDecisions(await openLog(e)));
+				return {
+					document: doc(d),
+					...templatesText(d)
+				};
+			}
+		},
+		{
+			name: "adr_propose",
+			title: "Propose a decision",
+			description: "Propose a decision: give the title and a sections map (section id → markdown) for the template; the tool renders and stages the draft. Lint findings come back in findings: fix them with adr_update_draft. With auto_commit on, an incomplete draft is refused; send every required section. You can't accept your own proposal; tell the user its id.",
+			inputSchema: object({
+				title: {
+					type: "string",
+					minLength: 1,
+					maxLength: 200
+				},
+				template: {
+					type: "string",
+					pattern: "^[a-z][a-z0-9-]*$",
+					maxLength: 64
+				},
+				sections: SECTIONS,
+				supersedes: {
+					type: "array",
+					items: ID,
+					maxItems: 20
+				}
+			}, ["title"]),
+			annotations: WRITE,
+			async run(input, ctx) {
+				const log = await openLog(e);
+				const { actor, notes } = await mcpAttribution(log.git, ctx);
+				const template = str(input.template);
+				const supersedes = strings(input.supersedes);
+				return writeResult(log, await proposeDecision(log, {
+					title: str(input.title) ?? "",
+					sections: sectionsOf(input.sections),
+					actor,
+					...template === void 0 ? {} : { template },
+					...supersedes === void 0 ? {} : { supersedes }
+				}, { notes }), {
+					tool: "adr_propose",
+					acceptRequiresHuman: log.adr.acceptRequiresHuman
+				});
+			}
+		},
+		{
+			name: "adr_update_draft",
+			title: "Update a draft",
+			description: "Replace sections of a proposed decision's draft (section id → markdown). Only your own proposals unless mcp_can_decide is on. Returns the lint result. With auto_commit on, an incomplete draft is refused; send every required section.",
+			inputSchema: object({
+				id: ID,
+				sections: {
+					...SECTIONS,
+					minProperties: 1
+				}
+			}, ["id", "sections"]),
+			annotations: WRITE,
+			async run(input, ctx) {
+				const log = await openLog(e);
+				const read = await readDecisions(log);
+				const id = resolveDecision(read, str(input.id) ?? "");
+				const attribution = await mcpAttribution(log.git, ctx);
+				const sections = sectionsOf(input.sections);
+				const o = {
+					tool: "adr_update_draft",
+					sections: Object.keys(sections)
+				};
+				const refused = policyRefusal(log, read, "adr_update_draft", id, attribution);
+				if (refused !== null) return writeResult(log, refused, o);
+				return writeResult(log, await updateDraft(log, {
+					id,
+					sections
+				}, { notes: attribution.notes }), o);
+			}
+		},
+		{
+			name: "adr_note",
+			title: "Note on a decision",
+			description: "Add a note to a decision in any state. Notes clarify; a changed decision needs a superseding proposal.",
+			inputSchema: object({
+				id: ID,
+				text: TEXT
+			}, ["id", "text"]),
+			annotations: WRITE,
+			async run(input, ctx) {
+				const log = await openLog(e);
+				const { actor, notes } = await mcpAttribution(log.git, ctx);
+				return writeResult(log, await noteDecision(log, {
+					id: str(input.id) ?? "",
+					text: str(input.text) ?? "",
+					actor
+				}, { notes }), { tool: "adr_note" });
+			}
+		},
+		{
+			name: "adr_link",
+			title: "Link decisions",
+			description: "Record a relation (relates-to, refines, depends-on) from one decision to another.",
+			inputSchema: object({
+				id: ID,
+				to: {
+					type: "string",
+					minLength: 1,
+					maxLength: 100
+				},
+				rel: {
+					type: "string",
+					enum: [
+						"relates-to",
+						"refines",
+						"depends-on"
+					]
+				}
+			}, ["id", "to"]),
+			annotations: WRITE,
+			async run(input, ctx) {
+				const log = await openLog(e);
+				const { actor, notes } = await mcpAttribution(log.git, ctx);
+				const rel = str(input.rel);
+				return writeResult(log, await linkDecision(log, {
+					id: str(input.id) ?? "",
+					to: str(input.to) ?? "",
+					actor,
+					...rel === void 0 ? {} : { rel }
+				}, { notes }), { tool: "adr_link" });
+			}
+		},
+		{
+			name: "adr_for_path",
+			title: "Decisions for paths",
+			description: "The decisions that govern each file, from scope globs and code anchors. Inactive ones carry a warning.",
+			inputSchema: object({ paths: {
+				type: "array",
+				items: {
+					type: "string",
+					minLength: 1,
+					maxLength: 4096
+				},
+				minItems: 1,
+				maxItems: 100
+			} }, ["paths"]),
+			annotations: READ,
+			async run(input) {
+				const log = await openLog(e);
+				const read = await readDecisions(log);
+				const d = await decisionsFor(read, log, { paths: strings(input.paths) ?? [] });
+				return {
+					document: doc(d),
+					...forText(d, read)
+				};
+			}
+		},
+		{
+			name: "adr_scope",
+			title: "Scope a decision",
+			description: "Set, add or remove the globs that map a decision to code. Allowed on your own proposals; rescoping someone else's proposal or an accepted or deprecated decision needs mcp_can_decide. If the decision's Scope section would no longer read true, propose a superseding decision instead.",
+			inputSchema: {
+				...object({
+					id: ID,
+					set: GLOBS,
+					add: GLOBS,
+					remove: GLOBS
+				}, ["id"]),
+				minProperties: 2
+			},
+			inputHint: "adr_scope needs id and at least one of set, add or remove",
+			annotations: WRITE,
+			async run(input, ctx) {
+				const log = await openLog(e);
+				const read = await readDecisions(log);
+				const id = resolveDecision(read, str(input.id) ?? "");
+				const attribution = await mcpAttribution(log.git, ctx);
+				const o = {
+					tool: "adr_scope",
+					scopeBefore: read.projection.views.get(id)?.applies_to ?? []
+				};
+				const refused = policyRefusal(log, read, "adr_scope", id, attribution);
+				if (refused !== null) return writeResult(log, refused, o);
+				const set = strings(input.set);
+				const op = {
+					...set === void 0 ? {} : { set },
+					add: strings(input.add) ?? [],
+					remove: strings(input.remove) ?? []
+				};
+				return writeResult(log, await scopeDecision(log, {
+					id,
+					op,
+					actor: attribution.actor
+				}, { notes: attribution.notes }), o);
+			}
+		},
+		{
+			name: "adr_withdraw",
+			title: "Withdraw a proposal",
+			description: "Withdraw a proposed decision, with an optional reason, for example your own proposal when the user decides against it. Withdrawing someone else's proposal needs mcp_can_decide. Only proposals can be withdrawn; an accepted decision needs a superseding proposal.",
+			inputSchema: object({
+				id: ID,
+				reason: TEXT
+			}, ["id"]),
+			annotations: WRITE,
+			async run(input, ctx) {
+				const log = await openLog(e);
+				const read = await readDecisions(log);
+				const id = resolveDecision(read, str(input.id) ?? "");
+				const attribution = await mcpAttribution(log.git, ctx);
+				const o = { tool: "adr_withdraw" };
+				const refused = policyRefusal(log, read, "adr_withdraw", id, attribution);
+				if (refused !== null) return writeResult(log, refused, o);
+				return writeResult(log, await withdrawDecision(log, {
+					id,
+					reason: str(input.reason) ?? null,
+					actor: attribution.actor
+				}, { notes: attribution.notes }), o);
+			}
+		}
+	];
+}
+/**
+* The log for a decision tool's call. The tool list was fixed at startup, so a call after
+* `mcp_can_decide` was turned off is a usage error telling the user to restart (design §7.3).
+*/
+async function decidingLog(e) {
+	const log = await openLog(e);
+	if (!log.adr.mcpCanDecide) throw new UsageError(`[policy] mcp_can_decide is now false in ${log.configPath ?? "adr.toml (not present)"}; restart adr mcp to update its tool list`);
+	return log;
+}
+/** The four tools `adr mcp` lists only with `[policy] mcp_can_decide = true` (design §7.4). */
+function decisionTools(e) {
+	return [
+		{
+			name: "adr_accept",
+			title: "Accept a decision",
+			description: "Accept a proposed decision (lints it, freezes the body, supersedes what it declares). Refused for agents while accept_requires_human is on.",
+			inputSchema: object({
+				id: ID,
+				copy_scope: { type: "boolean" }
+			}, ["id"]),
+			annotations: WRITE,
+			async run(input, ctx) {
+				const log = await decidingLog(e);
+				const { actor, notes } = await mcpAttribution(log.git, ctx);
+				const copyScope = input.copy_scope === true ? "copy" : input.copy_scope === false ? "skip" : "suggest";
+				return writeResult(log, await acceptDecision(log, {
+					id: str(input.id) ?? "",
+					actor
+				}, {
+					notes,
+					copyScope
+				}), { tool: "adr_accept" });
+			}
+		},
+		{
+			name: "adr_reject",
+			title: "Reject a decision",
+			description: "Reject a proposed decision, with a reason.",
+			inputSchema: object({
+				id: ID,
+				reason: TEXT
+			}, ["id", "reason"]),
+			annotations: WRITE,
+			async run(input, ctx) {
+				const log = await decidingLog(e);
+				const { actor, notes } = await mcpAttribution(log.git, ctx);
+				return writeResult(log, await rejectDecision(log, {
+					id: str(input.id) ?? "",
+					reason: str(input.reason) ?? "",
+					actor
+				}, { notes }), { tool: "adr_reject" });
+			}
+		},
+		{
+			name: "adr_deprecate",
+			title: "Deprecate a decision",
+			description: "Deprecate an accepted decision that nothing replaces, with a reason.",
+			inputSchema: object({
+				id: ID,
+				reason: TEXT
+			}, ["id", "reason"]),
+			annotations: WRITE,
+			async run(input, ctx) {
+				const log = await decidingLog(e);
+				const { actor, notes } = await mcpAttribution(log.git, ctx);
+				return writeResult(log, await deprecateDecision(log, {
+					id: str(input.id) ?? "",
+					reason: str(input.reason) ?? "",
+					actor
+				}, { notes }), { tool: "adr_deprecate" });
+			}
+		},
+		{
+			name: "adr_supersede",
+			title: "Supersede a decision",
+			description: "Mark an accepted or deprecated decision superseded by an accepted one.",
+			inputSchema: object({
+				id: ID,
+				by: ID,
+				reason: TEXT
+			}, ["id", "by"]),
+			annotations: WRITE,
+			async run(input, ctx) {
+				const log = await decidingLog(e);
+				const { actor, notes } = await mcpAttribution(log.git, ctx);
+				const reason = str(input.reason);
+				return writeResult(log, await supersedeDecision(log, {
+					id: str(input.id) ?? "",
+					by: str(input.by) ?? "",
+					actor,
+					...reason === void 0 ? {} : { reason }
+				}, { notes }), { tool: "adr_supersede" });
+			}
+		}
+	];
+}
+// src/mcp/prompt.ts
+/**
+* `adr_draft_from_discussion` (design §7.8): the steps from a discussion to a proposal, with the
+* template's sections spelled out, ending with a human's `adr accept`.
+*/
+function draftPrompt(e) {
+	return {
+		name: "adr_draft_from_discussion",
+		title: "Draft a decision from the discussion",
+		description: "Turn the current discussion into a proposed architecture decision, checking the existing ones first.",
+		arguments: [
+			{
+				name: "title",
+				description: "Working title of the decision",
+				required: false
+			},
+			{
+				name: "template",
+				description: "Template name; default [log] default_template",
+				required: false
+			},
+			{
+				name: "supersedes",
+				description: "A decision this proposal replaces: id or number",
+				required: false
+			}
+		],
+		async get(args) {
+			const read = await readDecisions(await openLog(e));
+			const templates = await listTemplates(read);
+			const name = args.template ?? templates.default;
+			const t = templates.templates.find((x) => x.name === name);
+			if (t === void 0) throw new UsageError(`unknown template ${name}; adr_templates lists them`);
+			const replaced = args.supersedes === void 0 ? null : resolveDecision(read, args.supersedes);
+			const shown = (id) => {
+				const display = read.projection.views.get(id)?.display ?? id;
+				return display === id ? id : `${display} (${id})`;
+			};
+			const title = args.title === void 0 ? "a short title that states the decision, such as \"Use PostgreSQL for orders\"" : JSON.stringify(args.title);
+			return [
+				"Turn the current discussion into an architecture decision proposal with adr.",
+				"",
+				"1. Call adr_search with the main subject of the discussion, and adr_for_path for the files it concerns. If an accepted decision already covers this, tell the user which one, and ask whether the proposal should supersede it.",
+				...replaced === null ? [] : [`1a. The user named ${shown(replaced)} as the decision this replaces; read it with adr_get first.`],
+				`2. Use the template ${t.name} (version ${t.version}). Its sections:`,
+				...t.sections.map((s) => `   - ${s.id}: ${s.heading}, ${s.required ? "required" : "optional"}.${s.guidance === null ? "" : ` ${s.guidance}`}`),
+				"3. Fill every required section with facts from the discussion and the code only. Where something wasn't settled, write it as an open question in that section instead of inventing an answer. If the template has an options section, list at least two options with their trade-offs, including those the discussion rejected.",
+				`4. Call adr_propose with the title ${title}, template "${t.name}", the sections map${replaced === null ? "" : `, and supersedes ["${replaced}"]`}.`,
+				"5. If the result has ok: true with findings, fix those sections with adr_update_draft and the new decision's id. If it was refused (ok: false), fill in every section the findings name and call adr_propose again.",
+				"6. Don't accept the proposal. Tell the user its id, and that they can review it and run: adr accept <id>"
+			].join("\n");
+		}
+	};
+}
+// src/mcp/server.ts
+const INSTRUCTIONS = "Architecture decisions in this repository are managed by adr. Decision files don't show their status: read decisions with adr_get or adr://decision/{id}, check adr_for_path and adr_search before changing architecture, and propose changes with adr_propose; a human accepts them.";
+/**
+* `adr mcp` (design §7.2): checks `ARK_ON_BEHALF_OF` and opens the log first, so a bad
+* environment exits 2 before serving, then serves adr's tools over stdio until the client goes.
+*/
+async function serveAdrMcp(o) {
+	parseOnBehalfOf(o.env.ARK_ON_BEHALF_OF);
+	const log = await openDecisionLog({
+		cwd: o.cwd,
+		root: o.root,
+		gitOptions: { env: o.env }
+	});
+	const e = {
+		cwd: o.cwd,
+		root: o.root,
+		env: o.env
+	};
+	const decide = decisionToolsAvailable(log.adr);
+	const tools = [...alwaysOnTools(e), ...decide ? decisionTools(e) : []];
+	const unavailable = {};
+	if (decide && log.adr.acceptRequiresHuman) o.stderr.write("adr: warning: adr_accept refuses agents while [policy] accept_requires_human is true\n");
+	if (!decide) {
+		const where = log.configPath ?? "adr.toml (not present)";
+		for (const name of DECISION_TOOLS) unavailable[name] = `[policy] mcp_can_decide is false in ${where}; a human decides with the adr CLI, or set it to true and restart adr mcp`;
+	}
+	await serveMcp({
+		name: "adr",
+		version: o.version,
+		instructions: INSTRUCTIONS,
+		tools,
+		unavailable,
+		resources: [indexResource(e)],
+		resourceTemplates: [decisionResource(e)],
+		prompts: [draftPrompt(e)]
+	}, {
+		env: o.env,
+		stderr: o.stderr,
+		...o.transport === void 0 ? {} : { transport: o.transport }
+	});
+}
+export { serveAdrMcp };
+
+//# sourceMappingURL=server-CXCO5zfp.js.map