@shivaedev/work-board 0.3.0 → 0.4.1

package/src/history/baseline.ts

@@ -0,0 +1,43 @@
+import { Option, Schema } from "effect";
+import type { Snapshot } from "#search/snapshot.ts";
+import { MAX_AGE, MAX_BYTES } from "./limits.ts";
+import { Baseline } from "./schema.ts";
+
+const JsonBaseline = Schema.fromJsonString(Baseline);
+function byteLength(text: string): number {
+	return new TextEncoder().encode(text).length;
+}
+
+export function readBaseline(raw: string | null, now: number) {
+	if (raw === null) {
+		return { baseline: undefined, discard: false, reason: "No previous snapshot. Start remembering changes to compare future source observations." };
+	}
+	if (byteLength(raw) > MAX_BYTES) {
+		return { baseline: undefined, discard: true, reason: "Remembered snapshot exceeds 2 MiB; history is unavailable." };
+	}
+	const decoded = Schema.decodeUnknownOption(JsonBaseline, { onExcessProperty: "error" })(raw);
+	if (Option.isNone(decoded)) {
+		return { baseline: undefined, discard: true, reason: "Remembered snapshot is invalid or unsupported; history is unavailable." };
+	}
+	const elapsed = now - Date.parse(decoded.value.recordedAt);
+	if (elapsed < 0) {
+		return { baseline: undefined, discard: true, reason: "Remembered observation is in the future; history is unavailable." };
+	}
+	if (elapsed >= MAX_AGE) {
+		return { baseline: undefined, discard: true, reason: "Remembered snapshot expired after 30 days; start again to establish a new baseline." };
+	}
+	return { baseline: decoded.value, discard: false, reason: "" };
+}
+
+export function observeBaseline(snapshot: Snapshot, now: number): string | undefined {
+	if (snapshot.unavailable.length > 0) {
+		return undefined;
+	}
+	const baseline: Baseline = {
+		documents: snapshot.documents.map((document) => ({ file: document.file, source: (document.parsed.raw ?? "") + document.parsed.body })),
+		recordedAt: new Date(now).toISOString(),
+		version: 1,
+	};
+	const raw = Schema.encodeSync(JsonBaseline)(baseline);
+	return byteLength(raw) <= MAX_BYTES ? raw : undefined;
+}

package/src/history/compare.ts

@@ -0,0 +1,54 @@
+import { type HistoryDocument, historyDocuments, historyIdentities } from "./documents.ts";
+import { historyFields } from "./fields.ts";
+import type { Baseline } from "./schema.ts";
+
+export interface SourceChange {
+	readonly after?: HistoryDocument;
+	readonly before?: HistoryDocument;
+	readonly kind: "added" | "removed" | "changed";
+	readonly reasons: readonly string[];
+}
+
+export function compareHistory(baseline: Baseline, current: Baseline) {
+	const before = historyDocuments(baseline);
+	const after = historyDocuments(current);
+	const oldIds = historyIdentities(before);
+	const newIds = historyIdentities(after);
+	const paired = new Set<HistoryDocument>();
+	const remaining = new Set(after);
+	const changes: SourceChange[] = [];
+	function pair(old: HistoryDocument, next: HistoryDocument) {
+		paired.add(old);
+		remaining.delete(next);
+		if (old.source !== next.source || old.file !== next.file) {
+			changes.push({ after: next, before: old, kind: "changed", reasons: historyFields(old, next) });
+		}
+	}
+	for (const [id, old] of oldIds) {
+		const next = newIds.get(id);
+		if (old && next) {
+			pair(old, next);
+		}
+	}
+	const byFile = new Map([...remaining].map((document) => [document.file, document]));
+	for (const old of before) {
+		if (paired.has(old)) {
+			continue;
+		}
+		const next = byFile.get(old.file);
+		if (next) {
+			pair(old, next);
+		} else {
+			changes.push({ before: old, kind: "removed", reasons: ["Source absent from the complete current observation"] });
+		}
+	}
+	for (const next of remaining) {
+		changes.push({ after: next, kind: "added", reasons: ["Source added since the remembered observation"] });
+	}
+	const issues = [
+		...[...oldIds].filter(([, document]) => !document).map(([id]) => `Duplicate ID ${id} in remembered sources; no identity winner selected.`),
+		...[...newIds].filter(([, document]) => !document).map(([id]) => `Duplicate ID ${id} in current sources; no identity winner selected.`),
+	];
+	changes.sort((a, b) => (a.after?.file ?? a.before?.file ?? "").localeCompare(b.after?.file ?? b.before?.file ?? "", "en"));
+	return { changes, issues, newIds };
+}

package/src/history/documents.ts

@@ -0,0 +1,21 @@
+import { metadataParse, type ParsedMetadata } from "#metadata/parse.ts";
+import type { Baseline } from "./schema.ts";
+
+export interface HistoryDocument {
+	readonly file: string;
+	readonly parsed: ParsedMetadata;
+	readonly source: string;
+}
+export function historyDocuments(baseline: Baseline): readonly HistoryDocument[] {
+	return baseline.documents.map((document) => ({ ...document, parsed: metadataParse(document.source) }));
+}
+export function historyIdentities(documents: readonly HistoryDocument[]): ReadonlyMap<string, HistoryDocument | undefined> {
+	const ids = new Map<string, HistoryDocument | undefined>();
+	for (const document of documents) {
+		const id = document.parsed.fields.id;
+		if (id) {
+			ids.set(id, ids.has(id) ? undefined : document);
+		}
+	}
+	return ids;
+}

package/src/history/fields.ts

@@ -0,0 +1,32 @@
+import type { Metadata } from "#metadata/schema.ts";
+import type { HistoryDocument } from "./documents.ts";
+
+const labels: ReadonlyArray<readonly [keyof Metadata, string]> = [
+	["attention", "Recorded attention requests changed"],
+	["criteria", "Criteria changed"],
+	["evidence", "Recorded evidence changed (not verified acceptance)"],
+	["id", "Item ID changed"],
+	["items", "Declared board membership changed"],
+	["kind", "Item kind changed"],
+	["nextAction", "Next action changed"],
+	["owner", "Recorded owner changed (not authorship)"],
+	["relationships", "Explicit relationships changed"],
+	["status", "Recorded status changed (not acceptance)"],
+];
+
+export function historyFields(before: HistoryDocument, after: HistoryDocument): readonly string[] {
+	const changes = labels.flatMap(([field, label]) =>
+		JSON.stringify(before.parsed.fields[field]) === JSON.stringify(after.parsed.fields[field]) ? [] : [label],
+	);
+	if (before.parsed.body !== after.parsed.body) {
+		const decision = before.parsed.fields.kind === "decision" || after.parsed.fields.kind === "decision";
+		changes.push(decision ? "Decision Markdown changed" : "Markdown body changed");
+	}
+	if (changes.length === 0 && before.source !== after.source) {
+		changes.push("Other frontmatter content or source formatting changed; no further interpretation");
+	}
+	if (before.file !== after.file) {
+		changes.unshift("Source path changed for the same unique item ID");
+	}
+	return changes;
+}

package/src/history/html.ts

@@ -0,0 +1,23 @@
+import { fileUrl } from "#files/url.ts";
+import { escapeHtml } from "#page/escape.ts";
+import { compareHistory, type SourceChange } from "./compare.ts";
+import type { Baseline } from "./schema.ts";
+
+function source(label: string, text: string, key: string): string {
+	return `<details data-key="${escapeHtml(key)}:${label}" data-history-source="${label.toLowerCase()}"><summary>${label} source (plain text)</summary><pre class="history-source">${escapeHtml(text)}</pre></details>`;
+}
+function changeHtml(change: SourceChange): string {
+	const file = change.after?.file ?? change.before?.file ?? "";
+	const key = change.before ? `before:${change.before.file}` : `added:${file}`;
+	return `<article class="history-change" data-key="${escapeHtml(key)}"><h2>${change.kind}: ${escapeHtml(file)}</h2>${change.before && change.after && change.before.file !== file ? `<p>Previously ${escapeHtml(change.before.file)}</p>` : ""}<ul>${change.reasons.map((reason) => `<li>${escapeHtml(reason)}</li>`).join("")}</ul>${change.after ? `<a href="${escapeHtml(fileUrl(change.after.file))}">Read current source</a>` : "<p>Removed source; no current document link.</p>"}${change.before ? source("Remembered", change.before.source, key) : ""}${change.after ? source("Current", change.after.source, key) : ""}</article>`;
+}
+export function historyHtml(before: Baseline, current: Baseline): string {
+	const result = compareHistory(before, current);
+	const counts = ["added", "removed", "changed"]
+		.map((kind) => `${result.changes.filter((change) => change.kind === kind).length} ${kind}`)
+		.join(" · ");
+	return `<p>Compared with your observation at <time>${escapeHtml(before.recordedAt)}</time>.</p><p role="status">${counts}</p>${result.changes.length === 0 ? "<p>No source changes since that observation.</p>" : ""}${result.issues.length > 0 ? `<aside aria-label="Identity limitations"><ul>${result.issues.map((issue) => `<li>${escapeHtml(issue)}</li>`).join("")}</ul><p>Ambiguous identities are compared by source path only.</p></aside>` : ""}${result.changes.map(changeHtml).join("")}`;
+}
+export function changesHtml(): string {
+	return `<section class="history"><h1>Changes since seen</h1><p>Compare current Markdown with one observation you explicitly remember in this browser. This is an observed source comparison, not an event journal, Git history, authorship, or verified acceptance.</p><p>Remembered source can include old or deleted content. One snapshot per workspace, up to 2 MiB, expires after 30 days and is removed on your next workspace visit. Mark seen replaces it; Clear forgets it. No source writes or cloud storage.</p><div class="history-controls"><button id="history-mark" type="button" disabled>Start remembering changes</button><button id="history-clear" type="button" disabled>Clear remembered history</button><span id="history-storage" role="status"></span></div><noscript><p>Remembering and comparing changes requires JavaScript and browser storage. Markdown, Overview and Work remain readable.</p></noscript><div id="changes-content" aria-live="polite"><p>No comparison has been loaded.</p></div></section><style>.history-controls{display:flex;flex-wrap:wrap;gap:.6rem;align-items:center}.history-change{border-top:1px solid var(--border);padding:1rem 0}.history-source{white-space:pre-wrap;overflow-wrap:anywhere;max-height:32rem;overflow:auto}.history h2{overflow-wrap:anywhere}</style>`;
+}

package/src/history/limits.ts

@@ -0,0 +1,2 @@
+export const MAX_BYTES = 2 * 1024 * 1024;
+export const MAX_AGE = 30 * 24 * 60 * 60 * 1000;

package/src/history/response.ts

@@ -0,0 +1,23 @@
+import { escapeHtml } from "#page/escape.ts";
+import type { Snapshot } from "#search/snapshot.ts";
+import { observeBaseline, readBaseline } from "./baseline.ts";
+import { historyHtml } from "./html.ts";
+import type { HistoryOutput } from "./schema.ts";
+
+export function historyResponse(raw: string | null, now: number, snapshot?: Snapshot): HistoryOutput {
+	const prior = readBaseline(raw, now);
+	const output: HistoryOutput = { discardBaseline: prior.discard, html: `<p>${escapeHtml(prior.reason)}</p>`, reason: prior.reason, snapshot: null };
+	if (snapshot === undefined) {
+		return output;
+	}
+	const currentRaw = observeBaseline(snapshot, now);
+	if (currentRaw === undefined) {
+		const reason =
+			snapshot.unavailable.length > 0
+				? "Current workspace observation is incomplete; no comparison or removals are inferred. Your valid remembered snapshot is preserved."
+				: "Complete current snapshot exceeds 2 MiB; no comparison or partial history is retained.";
+		return { ...output, html: `<p role="status">${escapeHtml(reason)}</p>`, reason };
+	}
+	const current = readBaseline(currentRaw, now).baseline;
+	return { ...output, html: prior.baseline && current ? historyHtml(prior.baseline, current) : output.html, snapshot: currentRaw };
+}

package/src/history/schema.ts

@@ -0,0 +1,36 @@
+import { Schema } from "effect";
+import { isMarkdown } from "#files/list.ts";
+
+const File = Schema.String.check(
+	Schema.makeFilter(
+		(value) =>
+			(isMarkdown(value) && !value.includes("\\") && !value.includes("\0") && value.split("/").every((part) => part.length > 0 && part !== ".."))
+			|| "Expected a relative readable Markdown path",
+	),
+);
+const ObservedTime = Schema.String.check(
+	Schema.makeFilter(
+		(value) =>
+			(Number.isFinite(Date.parse(value)) && /^\d{4}-\d{2}-\d{2}T.*(?:Z|[+-]\d{2}:\d{2})$/u.exec(value) !== null)
+			|| "Expected an ISO observation time with timezone",
+	),
+);
+export const Baseline = Schema.Struct({
+	documents: Schema.Array(Schema.Struct({ file: File, source: Schema.String })).check(
+		Schema.makeFilter(
+			(values) => new Set(values.map((value) => value.file)).size === values.length || "Duplicate source paths are not a complete observation",
+		),
+	),
+	recordedAt: ObservedTime,
+	version: Schema.Literal(1),
+}).pipe(Schema.encodeKeys({ recordedAt: "recorded_at" }));
+export type Baseline = typeof Baseline.Type;
+
+export const HistoryInput = Schema.Struct({ action: Schema.Literals(["check", "compare", "observe"]), baseline: Schema.NullOr(Schema.String) });
+export const HistoryOutput = Schema.Struct({
+	discardBaseline: Schema.Boolean,
+	html: Schema.String,
+	reason: Schema.String,
+	snapshot: Schema.NullOr(Schema.String),
+});
+export type HistoryOutput = typeof HistoryOutput.Type;

package/src/history/script.ts

@@ -0,0 +1,124 @@
+export function historyScript(): string {
+	return `
+import { swap, remember } from "/_board/swap.js";
+import { captureReading, restoreReading } from "/_board/reading-state.js";
+const key = "work-board:changes:" + document.documentElement.dataset.workspace;
+let memory;
+let storageNotice = "";
+let unavailableHtml = "";
+let generation = 0;
+let controller;
+let observing = null;
+const baseline = () => {
+ if (memory !== undefined) return memory;
+ try { return localStorage.getItem(key); }
+ catch { memory = null; storageNotice = "Browser storage unavailable; history applies to this page only."; return memory; }
+};
+const forget = () => {
+ memory = null;
+ try { localStorage.removeItem(key); memory = undefined; }
+ catch { storageNotice = "Cleared for this page, but browser storage could not be cleared. Reload may restore older data."; }
+};
+const keep = (raw) => {
+ memory = raw;
+ try { localStorage.setItem(key, raw); memory = undefined; storageNotice = ""; }
+ catch {
+  storageNotice = "Snapshot remembered for this page only; browser storage is unavailable.";
+  try { localStorage.removeItem(key); }
+  catch { storageNotice += " Reload may restore older data."; }
+ }
+};
+const controls = (available, busy = false) => {
+ const mark = document.getElementById("history-mark");
+ const clear = document.getElementById("history-clear");
+ if (!mark || !clear) return;
+ const exists = baseline() !== null;
+ mark.textContent = exists ? "Mark current workspace seen" : "Start remembering changes";
+ mark.disabled = busy || !available;
+ clear.disabled = busy || !exists;
+ document.getElementById("history-storage").textContent = storageNotice;
+};
+const render = (html) => {
+ const content = document.getElementById("changes-content");
+ if (!content) return;
+ const reading = captureReading();
+ const next = content.cloneNode(false);
+ next.innerHTML = html;
+ swap(content, next);
+ remember(content);
+ restoreReading({ ...reading, selection: null }, false);
+};
+const query = async (action) => {
+ const mine = ++generation;
+ controller?.abort();
+ controller = new AbortController();
+ const raw = baseline();
+ const response = await fetch("/_board/history", {
+  method: "POST", headers: { "content-type": "application/json" },
+  body: JSON.stringify({ action, baseline: raw }), signal: controller.signal, cache: "no-store",
+ });
+ if (!response.ok) throw new Error("History query failed");
+ const result = await response.json();
+ if (mine !== generation) return null;
+ if (result.discardBaseline && baseline() === raw) { forget(); unavailableHtml = result.html; }
+ return result;
+};
+const refresh = async () => {
+ if (observing !== null) return;
+ const visible = document.getElementById("doc")?.dataset.view === "changes";
+ try {
+  const result = await query(visible ? "compare" : "check");
+  if (!result) return;
+  if (visible && document.getElementById("doc")?.dataset.view === "changes") {
+   render(baseline() === null && unavailableHtml ? unavailableHtml : result.html);
+   controls(result.snapshot !== null);
+  }
+ } catch (error) {
+  if (error.name === "AbortError") return;
+  if (visible) {
+   render("<p>History is unavailable: the current observation could not be loaded. No comparison or removals are inferred.</p>");
+   controls(false);
+  }
+ }
+};
+document.addEventListener("click", async (event) => {
+ if (event.target.closest?.("#history-clear")) {
+  observing = null;
+  ++generation;
+  controller?.abort();
+  forget();
+  unavailableHtml = "";
+  await refresh();
+ }
+ if (event.target.closest?.("#history-mark")) {
+  if (observing !== null) return;
+  const mine = generation + 1;
+  observing = mine;
+  controls(false, true);
+  try {
+   const result = await query("observe");
+   if (!result) return;
+   if (result.snapshot === null) { render(result.html); controls(false); return; }
+   keep(result.snapshot);
+   unavailableHtml = "";
+  } catch (error) {
+   if (error.name !== "AbortError") { render("<p>Could not remember the current observation. Your previous baseline is preserved.</p>"); controls(false); }
+   return;
+  } finally { if (observing === mine) observing = null; }
+  await refresh();
+ }
+});
+document.addEventListener("board-page", refresh);
+document.addEventListener("visibilitychange", () => { if (!document.hidden) refresh(); });
+window.addEventListener("storage", (event) => {
+ if (event.key === key || event.key === null) {
+  observing = null;
+  ++generation;
+  controller?.abort();
+  memory = undefined; storageNotice = ""; unavailableHtml = ""; refresh();
+ }
+});
+setInterval(() => { if (baseline() !== null) refresh(); }, 60000);
+refresh();
+`;
+}

package/src/http/assets.ts

@@ -1,6 +1,7 @@
 import { createRequire } from "node:module";
 import { Data, Effect, FileSystem, Path } from "effect";
 import type { HttpRouter, HttpServerRequest } from "effect/unstable/http";
+import { historyScript } from "#history/script.ts";
 import { client, preferences } from "#page/client.ts";
 import { diagrams } from "#page/diagrams.ts";
 import { libraryScript } from "#page/libraryScript.ts";
@@ -18,6 +19,7 @@ export const ASSETS: ReadonlyArray<readonly [HttpRouter.PathInput, string, strin
 	["/_board/style.css", style, "text/css"],
 	["/_board/saved-views.js", savedScript(), "text/javascript"],
 	["/_board/client.js", client, "text/javascript"],
+	["/_board/history.js", historyScript(), "text/javascript"],
 	["/_board/preferences.js", preferences, "text/javascript"],
 	["/_board/search.js", searchScript(), "text/javascript"],
 	["/_board/search-results.js", searchResultsScript(), "text/javascript"],

package/src/http/history.ts

@@ -0,0 +1,50 @@
+import { Clock, Effect, FileSystem, Schema } from "effect";
+import { HttpIncomingMessage, HttpServerRequest } from "effect/unstable/http";
+import type { Changes } from "#files/changes.ts";
+import { changesHtml } from "#history/html.ts";
+import { MAX_BYTES } from "#history/limits.ts";
+import { historyResponse } from "#history/response.ts";
+import { HistoryInput, HistoryOutput } from "#history/schema.ts";
+import { navHtml } from "#page/nav.ts";
+import { shell } from "#page/shell.ts";
+import type { searchSnapshot } from "#search/snapshot.ts";
+import { respond } from "./respond.ts";
+
+export function changesPage(changes: Changes, home: string | undefined) {
+	return Effect.fn("WorkBoard.changesPage")(function* () {
+		const nav = navHtml(yield* changes.files, "", home);
+		return respond(shell("Changes", nav, changesHtml(), changes.realRoot, true, undefined, "changes"), "text/html");
+	});
+}
+function sameOrigin(request: HttpServerRequest.HttpServerRequest): boolean {
+	const origin = request.headers.origin;
+	if (origin === undefined) {
+		return true;
+	}
+	try {
+		const url = new URL(origin);
+		return url.protocol === "http:" && url.host === request.headers.host;
+	} catch {
+		return false;
+	}
+}
+export function history(index: Effect.Success<ReturnType<typeof searchSnapshot>>) {
+	return Effect.fn("WorkBoard.history")(function* (request: HttpServerRequest.HttpServerRequest) {
+		if (!sameOrigin(request)) {
+			return respond("Local same-origin requests only", "text/plain", 403);
+		}
+		const decoded = yield* HttpServerRequest.schemaBodyJson(HistoryInput, { onExcessProperty: "error" }).pipe(
+			Effect.provideService(HttpServerRequest.HttpServerRequest, request),
+			Effect.provideService(HttpIncomingMessage.MaxBodySize, FileSystem.Size(4 * MAX_BYTES + 4096)),
+			Effect.result,
+		);
+		if (decoded._tag === "Failure") {
+			return respond("Invalid history query", "text/plain", 400);
+		}
+		const input = decoded.success;
+		const now = yield* Clock.currentTimeMillis;
+		const snapshot = input.action === "check" ? undefined : yield* index;
+		const output = historyResponse(input.baseline, now, snapshot);
+		return respond(Schema.encodeSync(Schema.fromJsonString(HistoryOutput))(output), "application/json");
+	});
+}

package/src/http/overview.ts

@@ -0,0 +1,19 @@
+import { Effect } from "effect";
+import { overviewHtml } from "#attention/overviewHtml.ts";
+import type { Changes } from "#files/changes.ts";
+import { navHtml } from "#page/nav.ts";
+import { shell } from "#page/shell.ts";
+import type { searchSnapshot } from "#search/snapshot.ts";
+import { respond } from "./respond.ts";
+
+export function overview(index: Effect.Success<ReturnType<typeof searchSnapshot>>, changes: Changes, home: string | undefined) {
+	return Effect.fn("WorkBoard.overview")(function* () {
+		const snapshot = yield* index;
+		const nav = navHtml(yield* changes.files, "", home);
+		return respond(
+			shell("Overview", nav, overviewHtml(snapshot), changes.realRoot, true, undefined, "overview"),
+			"text/html",
+			snapshot.unavailable.length > 0 ? 503 : 200,
+		);
+	});
+}

package/src/http/page.ts

@@ -1,7 +1,8 @@
-import { Effect, FileSystem, Option, Path } from "effect";
+import { Effect, FileSystem, Option } from "effect";
 import type { HttpServerRequest } from "effect/unstable/http";
 import type { Changes } from "#files/changes.ts";
-import { type MarkdownFile, within } from "#files/list.ts";
+import type { MarkdownFile } from "#files/list.ts";
+import { markdownPath } from "#files/markdownPath.ts";
 import { metadataModel } from "#metadata/model.ts";
 import { metadataParse } from "#metadata/parse.ts";
 import { boardHtml } from "#page/board.ts";
@@ -33,12 +34,11 @@ const message = (text: string): string => `<p class="empty">${escapeHtml(text)}<
 export const page = (options: PageOptions, changes: Changes, index: Effect.Success<ReturnType<typeof searchSnapshot>>) => {
 	const body = Effect.fn("WorkBoard.pageBody")(function* (file: MarkdownFile, expectedIdentity?: string) {
 		const fs = yield* FileSystem.FileSystem;
-		const path = yield* Path.Path;
-		const real = yield* Effect.option(fs.realPath(path.join(options.root, file.path)));
-		if (Option.isNone(real) || !within(changes.realRoot, path.sep, real.value)) {
+		const real = yield* markdownPath(options.root, changes.realRoot, file.path);
+		if (real === undefined) {
 			return Option.none();
 		}
-		const source = yield* fs.readFileString(real.value);
+		const source = yield* fs.readFileString(real);
 		const parsed = metadataParse(source);
 		let identity: string | undefined;
 		const snapshot = yield* index;

package/src/metadata/attentionProblems.ts

@@ -0,0 +1,18 @@
+import type { MetadataDocument } from "./model.ts";
+import type { Diagnostic } from "./parse.ts";
+
+export function attentionProblems(document: MetadataDocument): readonly Diagnostic[] {
+	const { fields, lines } = document.parsed;
+	const requests = fields.attention ?? [];
+	return requests.flatMap((request, index) => {
+		const line = lines[`attention.${index}.id`] ?? lines.attention ?? 2;
+		const problems: Diagnostic[] = [];
+		if (!fields.id) {
+			problems.push({ field: "attention", line, message: "Attention requests require an explicit item ID; this source remains unclassified." });
+		}
+		if (requests.filter((other) => other.id === request.id).length > 1) {
+			problems.push({ field: "attention", line, message: `Duplicate attention request ID ${request.id}; neither request is selected.` });
+		}
+		return problems;
+	});
+}

package/src/metadata/backlinks.ts

@@ -10,6 +10,13 @@ export interface Backlink {
 function references(document: MetadataDocument, model: MetadataModel) {
 	const { fields, lines } = document.parsed;
 	return [
+		...(fields.attention?.flatMap((request, index) =>
+			request.unblocks.map((target, targetIndex) => ({
+				kind: "attention target",
+				line: lines[`attention.${index}.unblocks.${targetIndex}`],
+				target: referenceFile(target, model),
+			})),
+		) ?? []),
 		...(fields.relationships?.map((link, index) => ({
 			kind: link.kind,
 			line: lines[`relationships.${index}.target`],

package/src/metadata/problems.ts

@@ -1,3 +1,4 @@
+import { attentionProblems } from "./attentionProblems.ts";
 import type { MetadataDocument } from "./model.ts";
 import type { Diagnostic } from "./parse.ts";
 
@@ -26,6 +27,9 @@ function criterionProblems(document: MetadataDocument): readonly Diagnostic[] {
 function referenceProblems(document: MetadataDocument, ids: ReadonlyMap<string, readonly MetadataDocument[]>): readonly Diagnostic[] {
 	const { fields, lines } = document.parsed;
 	const references = [
+		...(fields.attention?.flatMap((request, index) =>
+			request.unblocks.map((target, targetIndex) => ({ field: "attention", key: `attention.${index}.unblocks.${targetIndex}`, target })),
+		) ?? []),
 		...(fields.relationships?.map((link, index) => ({ field: "relationships", key: `relationships.${index}.target`, target: link.target })) ?? []),
 		...(fields.items?.map((target, index) => ({ field: "items", key: `items.${index}`, target })) ?? []),
 		...(fields.evidence?.flatMap((item, index) =>
@@ -39,7 +43,7 @@ function referenceProblems(document: MetadataDocument, ids: ReadonlyMap<string,
 }
 export function metadataProblems(document: MetadataDocument, ids: ReadonlyMap<string, readonly MetadataDocument[]>, unavailable: readonly string[]) {
 	const { parsed } = document;
-	const problems = [...parsed.diagnostics, ...criterionProblems(document)];
+	const problems = [...parsed.diagnostics, ...criterionProblems(document), ...attentionProblems(document)];
 	const matches = parsed.fields.id ? ids.get(parsed.fields.id) : undefined;
 	if (matches && matches.length > 1) {
 		problems.push({

package/src/metadata/relationshipLabel.ts

@@ -1,4 +1,5 @@
 const labels = new Map([
+	["attention target", "Attention request"],
 	["board member", "Board membership"],
 	["criterion evidence", "Criterion evidence"],
 	["depends_on", "Depends on"],

package/src/metadata/schema.ts

@@ -3,6 +3,14 @@ import { Schema } from "effect";
 export const Identity = Schema.String.check(Schema.isPattern(/^[a-zA-Z\d][a-zA-Z\d._-]*$/u));
 export const Reference = Schema.String.check(Schema.isPattern(/^[a-zA-Z\d][a-zA-Z\d._-]*(?:#[a-zA-Z\d][a-zA-Z\d._-]*)?$/u));
 const Text = Schema.String.check(Schema.isPattern(/\S/u));
+const Attention = Schema.Struct({
+	id: Identity,
+	kind: Schema.Literals(["decision", "review", "blocker"]),
+	reason: Text,
+	responseFrom: Schema.Array(Text).check(Schema.isMinLength(1)),
+	state: Schema.Literals(["open", "closed"]),
+	unblocks: Schema.Array(Reference).check(Schema.isMinLength(1)),
+}).pipe(Schema.encodeKeys({ responseFrom: "response_from" }));
 const Criterion = Schema.Struct({ id: Identity, text: Text });
 const Relationship = Schema.Struct({ kind: Schema.Literals(["implements", "informs", "depends_on", "relates_to"]), target: Reference });
 const Evidence = Schema.Struct({
@@ -23,6 +31,7 @@ const Evidence = Schema.Struct({
 }).pipe(Schema.encodeKeys({ checkedRevision: "checked_revision", observedAt: "observed_at" }));
 
 export const Metadata = Schema.Struct({
+	attention: Schema.optional(Schema.Array(Attention)),
 	criteria: Schema.optional(Schema.Array(Criterion)),
 	evidence: Schema.optional(Schema.Array(Evidence)),
 	id: Schema.optional(Identity),

package/src/page/attentionDetails.ts

@@ -0,0 +1,18 @@
+import { attentionSource } from "#attention/requests.ts";
+import type { MetadataModel } from "#metadata/model.ts";
+import type { ParsedMetadata } from "#metadata/parse.ts";
+import { escapeHtml } from "./escape.ts";
+import { referenceHtml } from "./metadataLinks.ts";
+
+export function attentionDetails(parsed: ParsedMetadata, file: string, model: MetadataModel): string {
+	const requests = parsed.fields.attention ?? [];
+	if (requests.length === 0) {
+		return "";
+	}
+	return `<h3>Recorded attention requests</h3><p>Open/closed is source state. Closing a request does not establish acceptance or record an answer.</p><ul>${requests
+		.map(
+			(request, index) =>
+				`<li id="${attentionSource({ file, parsed }, index)}" tabindex="-1"><b>${escapeHtml(request.kind)} · ${escapeHtml(request.id)} · ${escapeHtml(request.state)}</b><p>${escapeHtml(request.reason)}</p><p>Response needed from: ${request.responseFrom.map(escapeHtml).join(", ")}</p><p>Recorded to unblock: ${request.unblocks.map((target) => referenceHtml(target, target, model)).join(", ")}</p><p>Source: ${escapeHtml(file)}:${parsed.lines[`attention.${index}`] ?? parsed.lines.attention ?? 2}</p></li>`,
+		)
+		.join("")}</ul>`;
+}

package/src/page/client.ts

@@ -1,5 +1,6 @@
 export const client = `
 import "/_board/saved-views.js";
+import "/_board/history.js";
 import "/_board/preferences.js";
 import "/_board/search.js";
 import { renderDiagrams } from "/_board/diagrams.js";

package/src/page/metadataDetails.ts

@@ -1,6 +1,7 @@
 import type { MetadataModel } from "#metadata/model.ts";
 import type { ParsedMetadata } from "#metadata/parse.ts";
 import { relationshipLabel } from "#metadata/relationshipLabel.ts";
+import { attentionDetails } from "./attentionDetails.ts";
 import { criteriaEvidence } from "./criteriaEvidence.ts";
 import { escapeHtml } from "./escape.ts";
 import { referenceHtml, valueHtml } from "./metadataLinks.ts";
@@ -18,6 +19,7 @@ export function metadataDetails(parsed: ParsedMetadata, file: string, model: Met
 			: "",
 
 		criteriaEvidence(parsed, model),
+		attentionDetails(parsed, file, model),
 		recordedEvidence(parsed, file, model),
 	].join("");
 	return details;

package/src/page/navigationScript.ts

@@ -86,7 +86,7 @@ document.addEventListener("click", (event) => {
   const link = event.target.closest?.("a[href]");
   if (!link || event.defaultPrevented || event.button !== 0 || event.ctrlKey || event.metaKey || event.shiftKey || event.altKey || link.hasAttribute("download") || (link.target && link.target !== "_self")) return;
   const target = new URL(link.href, location.href);
-  if (target.origin !== location.origin || !(target.pathname === "/" || (target.pathname === "/_board/work" || target.pathname.startsWith("/_board/item/")) || /\\.md$/i.test(target.pathname))) return;
+  if (target.origin !== location.origin || !(target.pathname === "/" || (target.pathname === "/_board/changes" || target.pathname === "/_board/overview" || target.pathname === "/_board/work" || target.pathname.startsWith("/_board/item/")) || /\\.md$/i.test(target.pathname))) return;
   event.preventDefault();
   navigate(target);
 });