@shivaedev/work-board 0.12.0 → 0.14.0

package/src/server/http/identity.ts

@@ -1,71 +1,32 @@
 import { Effect } from "effect";
-import type { HttpServerRequest } from "effect/unstable/http";
-import { escapeHtml } from "#browser/escapeHtml.ts";
-import { fileUrl } from "#files/url.ts";
+import type { HttpServerRequest } from "effect/http";
 import type { Changes } from "#server/files/changes.ts";
-import { navHtml } from "#server/page/nav.ts";
 import { shell } from "#server/page/shell.ts";
 import type { searchSnapshot } from "#server/search/snapshot.ts";
 import type { page } from "./page.ts";
 import { respond } from "./respond.ts";
 
-function requestedIdentity(pathname: string): string {
-	try {
-		return decodeURIComponent(pathname.slice("/_board/item/".length).replace(/\/$/u, ""));
-	} catch {
-		return "";
-	}
-}
-
-export function identity(
-	index: Effect.Success<ReturnType<typeof searchSnapshot>>,
-	pages: ReturnType<typeof page>,
-	changes: Changes,
-	home: string | undefined,
-) {
+export function identity(index: Effect.Success<ReturnType<typeof searchSnapshot>>, pages: ReturnType<typeof page>, changes: Changes) {
 	return Effect.fn("WorkBoard.identity")(function* (request: HttpServerRequest.HttpServerRequest) {
-		const pathname = new URL(request.url, "http://127.0.0.1").pathname;
-		const id = requestedIdentity(pathname);
-		if (!pathname.endsWith("/") && /\.md$/iu.exec(id) !== null) {
+		const encoded = /^\/_board\/item\/(?<id>[^/]+)\/?$/u.exec(new URL(request.url, "http://127.0.0.1").pathname)?.groups?.id;
+		if (encoded === undefined) {
 			return yield* pages(request);
 		}
+		let id: string;
+		try {
+			id = decodeURIComponent(encoded);
+		} catch {
+			id = "";
+		}
 		const snapshot = yield* index;
 		const matches = snapshot.model.ids.get(id) ?? [];
-		if (snapshot.unavailable.length > 0) {
-			return respond(
-				shell(
-					`Item ${id}`,
-					"",
-					`<p class="empty">The workspace index is incomplete. Could not read ${escapeHtml(snapshot.unavailable.join(", "))}; item identity could not be validated. Retry when the files are readable.</p>`,
-					changes.realRoot,
-					false,
-				),
-				"text/html",
-				503,
-			);
-		}
-		if (matches.length === 1 && matches[0]) {
+		if (snapshot.unavailable.length === 0 && matches.length === 1 && matches[0]) {
 			return yield* pages(request, matches[0].file, id);
 		}
-		const text =
-			matches.length > 0
-				? `The ID ${id} is duplicated. No document was selected.`
-				: `No item with ID ${id} is available. It may be missing, renamed, or invalid.`;
-		const choices = matches.map((document) => `<li><a href="${escapeHtml(fileUrl(document.file))}">${escapeHtml(document.file)}</a></li>`).join("");
-		const nav = navHtml(yield* changes.files, "", home, snapshot);
-		return respond(
-			shell(
-				`Item ${id}`,
-				nav,
-				`<p class="empty">${escapeHtml(text)}</p>${choices ? `<ul>${choices}</ul>` : ""}`,
-				changes.realRoot,
-				false,
-				undefined,
-				false,
-				snapshot,
-			),
-			"text/html",
-			matches.length > 0 ? 409 : 404,
-		);
+		let status = matches.length > 0 ? 409 : 404;
+		if (snapshot.unavailable.length > 0) {
+			status = 503;
+		}
+		return respond(shell(`Item ${id}`, changes.realRoot), "text/html", status);
 	});
 }

package/src/server/http/page.ts

@@ -1,23 +1,9 @@
-import { Effect, FileSystem, Option } from "effect";
-import type { HttpServerRequest } from "effect/unstable/http";
-import { escapeHtml } from "#browser/escapeHtml.ts";
-import { authoredQuestion } from "#server/attention/inbox.ts";
-import { documentBody } from "#server/document/body.ts";
+import { Effect, FileSystem } from "effect";
+import type { HttpServerRequest } from "effect/http";
+import { currentDocument } from "#server/currentDocument.ts";
 import type { Changes } from "#server/files/changes.ts";
-import type { MarkdownFile } from "#server/files/list.ts";
 import { markdownPath } from "#server/files/markdownPath.ts";
-import { metadataModel } from "#server/metadata/model.ts";
-import { metadataParse } from "#server/metadata/parse.ts";
-import { boardHtml } from "#server/page/boardHtml.ts";
-import { documentHtml } from "#server/page/documentHtml.ts";
-import { itemIntroduction } from "#server/page/itemIntroduction.ts";
-import { metadataHtml } from "#server/page/metadata.ts";
-import { navHtml } from "#server/page/nav.ts";
 import { shell } from "#server/page/shell.ts";
-import { startHtml } from "#server/page/startHtml.ts";
-import { boardOf } from "#server/render/board.ts";
-import { authoredQuestionHtml } from "#server/responses/authoredQuestionHtml.ts";
-import { readingActions } from "#server/responses/readingActions.ts";
 import type { searchSnapshot } from "#server/search/snapshot.ts";
 import { respond } from "./respond.ts";
 
@@ -26,7 +12,6 @@ export interface PageOptions {
 	readonly root: string;
 	readonly writable?: boolean;
 }
-
 function requestedPath(url: string): string {
 	const pathname = new URL(url, "http://127.0.0.1").pathname.replace(/^\/+/u, "");
 	try {
@@ -35,75 +20,33 @@ function requestedPath(url: string): string {
 		return pathname;
 	}
 }
-
-function message(text: string): string {
-	return `<p class="empty">${escapeHtml(text)}</p>`;
-}
-
 export function page(options: PageOptions, changes: Changes, index: Effect.Success<ReturnType<typeof searchSnapshot>>) {
-	const body = Effect.fn("WorkBoard.body")(function* (file: MarkdownFile, expectedIdentity?: string) {
-		const fs = yield* FileSystem.FileSystem;
-		const real = yield* markdownPath(options.root, changes.realRoot, file.path);
-		if (real === undefined) {
-			return Option.none();
-		}
-		const source = yield* fs.readFileString(real);
-		const parsed = metadataParse(source);
-		let identity: string | undefined;
-		const snapshot = yield* index;
-		const model = metadataModel(
-			[...snapshot.documents.filter((document) => document.file !== file.path), { file: file.path, parsed }],
-			snapshot.unavailable,
-			options.home ?? (yield* changes.files)[0]?.path,
-		);
-		const metadata = metadataHtml(parsed, file.path, model, file.path === options.home);
-		if (snapshot.unavailable.length === 0 && parsed.fields.id && model.ids.get(parsed.fields.id)?.length === 1) {
-			identity = parsed.fields.id;
-		}
-		if (expectedIdentity && identity !== expectedIdentity) {
-			return Option.none();
-		}
-		const actions = yield* readingActions({ file: file.path, parsed }, source, options.writable === true, identity);
-		const prose = documentBody({ file: file.path, parsed });
-		const html =
-			file.path === options.home
-				? yield* boardHtml(boardOf(prose), file.path, file.modified, metadata, actions)
-				: yield* documentHtml(prose, file, metadata, itemIntroduction(parsed), actions);
-		const question = identity && authoredQuestion({ file: file.path, parsed });
-		const answer = question ? yield* authoredQuestionHtml({ file: file.path, parsed }, source, options.writable === true) : "";
-		return Option.some({ html: html + answer, identity });
-	});
 	return Effect.fn("WorkBoard.page")(function* (request: HttpServerRequest.HttpServerRequest, resolved?: string, expectedIdentity?: string) {
-		const files = yield* changes.files;
-		const requested = resolved ?? (requestedPath(request.url) || options.home || files[0]?.path || "");
-		const file = files.find((candidate) => candidate.path === requested);
-		const snapshot = yield* index;
-		const nav = navHtml(files, requested, options.home, snapshot);
-		function layout(content: string, identity?: string) {
-			return shell(requested, nav, content, changes.realRoot, requested === options.home, identity, false, snapshot);
-		}
-		function missing() {
-			return respond(
-				layout(
-					message(
-						expectedIdentity
-							? `No item with ID ${expectedIdentity} at ${requested}; its source identity changed or is invalid.`
-							: `No markdown file at ${requested || options.root}.`,
-					),
-				),
-				"text/html",
-				404,
-			);
+		const requested = resolved ?? requestedPath(request.url);
+		function layout(status: number) {
+			return respond(shell(requested || "Today", changes.realRoot), "text/html", status);
 		}
-		if (files.length === 0 && requestedPath(request.url) === "" && resolved === undefined && expectedIdentity === undefined) {
-			return respond(layout(startHtml(true)), "text/html");
+		if (!(requested || expectedIdentity)) {
+			return layout(200);
 		}
-		if (file === undefined) {
-			return missing();
+		const file = (yield* changes.files).find((candidate) => candidate.path === requested);
+		if (!file) {
+			return layout(404);
 		}
-		return yield* body(file, expectedIdentity).pipe(
-			Effect.map(Option.match({ onNone: missing, onSome: (main) => respond(layout(main.html, main.identity), "text/html") })),
-			Effect.catch(() => Effect.succeed(respond(layout(message(`${file.path} could not be read.`)), "text/html", 500))),
-		);
+		return yield* Effect.gen(function* () {
+			const real = yield* markdownPath(options.root, changes.realRoot, file.path);
+			if (!real) {
+				return layout(404);
+			}
+			const fs = yield* FileSystem.FileSystem;
+			const source = yield* fs.readFileString(real);
+			if (expectedIdentity) {
+				const { document, snapshot } = currentDocument(yield* index, file.path, source, options.home);
+				if (document.parsed.fields.id !== expectedIdentity || snapshot.model.ids.get(expectedIdentity)?.length !== 1) {
+					return layout(404);
+				}
+			}
+			return layout(200);
+		}).pipe(Effect.catch(() => Effect.succeed(layout(500))));
 	});
 }

package/src/server/http/respond.ts

@@ -1,4 +1,4 @@
-import { HttpServerResponse } from "effect/unstable/http";
+import { HttpServerResponse } from "effect/http";
 
 const POLICY = [
 	"default-src 'self'",

package/src/server/http/rpcPolicy.ts

@@ -0,0 +1,18 @@
+import { Effect } from "effect";
+import { HttpRouter, HttpServerRequest, HttpServerResponse } from "effect/http";
+import { HEADERS } from "./respond.ts";
+
+export const RPC_PATH = "/_board/rpc";
+
+export const rpcPolicy = HttpRouter.middleware(
+	(http) =>
+		Effect.gen(function* () {
+			const request = yield* HttpServerRequest.HttpServerRequest;
+			return yield* request.url.split("?")[0] === RPC_PATH
+				? http.pipe(Effect.map((response) => HttpServerResponse.setHeaders(response, HEADERS)))
+				: http;
+		}),
+	{ global: true },
+);
+
+export const MAX_BYTES = 2 * 1024 * 1024;

package/src/server/integration/attention.ts

@@ -1,9 +1,14 @@
 import { RequestReceipt as RequestReceiptSchema } from "#attention/RequestReceipt.ts";
+import type { InboxProjection } from "#browser/views/schema.ts";
 import { managedRequestReceipt } from "#server/attention/managedRequestReceipt.ts";
+import { attentionProjection } from "#server/attention/projection.ts";
+
+export type AttentionProjection = InboxProjection;
 
 export type RequestReceipt = typeof RequestReceiptSchema.Type;
 
 export const attention = {
 	managedRequestReceipt,
+	projection: attentionProjection,
 	RequestReceipt: RequestReceiptSchema,
 } as const;

package/src/server/integration/diagnostics.ts

@@ -1,4 +1,5 @@
 import { DAEMON_PORT, DAEMON_RPC_PATH, DiagnosticsContract } from "#diagnostics/daemonContract.ts";
+import { FleetStage, FleetTimestamp } from "#diagnostics/fleetItems.ts";
 import { CapacityRejection as CapacityRejectionSchema, FLEET_HEALTH_NAME, FleetHealth as FleetHealthSchema } from "#diagnostics/health.ts";
 import type { SourceFailure as SourceFailureType } from "#diagnostics/source.ts";
 import { DiagnosticsSources, diagnostics as readDiagnostics, SourceFailure as SourceFailureClass } from "#diagnostics/source.ts";
@@ -22,6 +23,8 @@ export const diagnostics = {
 	diagnostics: readDiagnostics,
 	FLEET_HEALTH_NAME,
 	FleetHealth: FleetHealthSchema,
+	FleetStage,
+	FleetTimestamp,
 	fleetHealth,
 	githubLimits,
 	SourceFailure: SourceFailureClass,

package/src/server/mcp/client.ts

@@ -0,0 +1,43 @@
+import { connect } from "node:net";
+import { join } from "node:path";
+import { NodeHttpClient } from "@effect/platform-node";
+import { Effect, Layer, Schema } from "effect";
+import { HttpClient, HttpClientRequest } from "effect/http";
+import { RpcClient, RpcSerialization } from "effect/rpc";
+import { RpcClientError } from "effect/rpc/RpcClientError";
+import { workContract } from "#rpc/contract.ts";
+import { RPC_PATH } from "#server/http/rpcPolicy.ts";
+
+export class BoardToolError extends Schema.TaggedError<BoardToolError>()("BoardToolError", { message: Schema.String }) {}
+
+function makeClient() {
+	return RpcClient.make(workContract, { flatten: true });
+}
+export type BoardClient = Effect.Success<ReturnType<typeof makeClient>>;
+
+function toolError(directory: string, error: unknown) {
+	if (error instanceof RpcClientError || (error instanceof Error && "_tag" in error && error._tag === "TimeoutError")) {
+		return new BoardToolError({ message: `No board answers in ${directory}. Start one with: work-board '${directory.replaceAll("'", "'\\''")}'` });
+	}
+	return new BoardToolError({ message: error instanceof Error ? error.message : String(error) });
+}
+
+export function readBoard<A, E>(directory: string, read: (client: BoardClient) => Effect.Effect<A, E>) {
+	const agent = Layer.effect(
+		NodeHttpClient.HttpAgent,
+		Effect.map(NodeHttpClient.makeAgent({ keepAlive: true }), (agents) => {
+			agents.http.createConnection = () => connect(join(directory, "board.sock"));
+			return agents;
+		}),
+	);
+	const http = NodeHttpClient.layerNodeHttpNoAgent.pipe(Layer.provide(agent));
+	const protocol = RpcClient.layerProtocolHttp({
+		transformClient: HttpClient.mapRequest(HttpClientRequest.setUrl(`http://localhost${RPC_PATH}`)),
+		url: "http://localhost",
+	}).pipe(Layer.provide([http, RpcSerialization.layerNdjson]));
+	return Effect.scoped(Effect.flatMap(makeClient(), read)).pipe(
+		Effect.provide(protocol),
+		Effect.timeout("10 seconds"),
+		Effect.mapError((error) => toolError(directory, error)),
+	);
+}

package/src/server/mcp/queries.ts

@@ -0,0 +1,60 @@
+import { Clock, Effect } from "effect";
+import { cardStatus } from "#browser/views/now.ts";
+import type { InboxProjection } from "#browser/views/schema.ts";
+import { fileUrl } from "#files/url.ts";
+import { identityUrl } from "#server/metadata/links.ts";
+import type { BoardClient } from "./client.ts";
+
+export const needsYou = Effect.fn("BoardMcp.needsYou")(function* (client: BoardClient) {
+	const inbox = yield* client("work-board.inbox", undefined);
+	const now = yield* Clock.currentTimeMillis;
+	const you = yield* Effect.forEach(inbox.you, (row) =>
+		Effect.gen(function* () {
+			const document = yield* client("work-board.document", { url: fileUrl(row.file) });
+			const request = new URL(row.href, "http://localhost").searchParams.get("request");
+			const decision = document.requests.find((entry) => entry.id === request);
+			return {
+				...row,
+				ageMs: row.modified === undefined ? null : Math.max(0, now - row.modified),
+				options: (request ? decision?.options : document.metadata.options) ?? [],
+				prompts: decision?.prompts ?? [],
+				promptUnavailable: decision?.promptUnavailable,
+				recommended: decision?.recommended ?? document.metadata.recommended,
+			};
+		}),
+	);
+	return { complete: inbox.complete, issues: inbox.issues, you };
+});
+
+export const overview = Effect.fn("BoardMcp.overview")(function* (client: BoardClient) {
+	const { fleet, goals, needs } = yield* Effect.all(
+		{
+			fleet: client("work-board.fleetItems", undefined),
+			goals: client("work-board.goals", undefined),
+			needs: needsYou(client),
+		},
+		{ concurrency: "unbounded" },
+	);
+	return {
+		fleet: fleet.state === "ready" ? { items: fleet.items, state: fleet.state } : fleet,
+		goals: { closedGoals: goals.closedGoals, goals: goals.goals },
+		needsYou: { count: needs.you.length, ...needs },
+	};
+});
+
+export const item = Effect.fn("BoardMcp.item")(function* (client: BoardClient, id: string) {
+	const document = yield* client("work-board.document", { url: identityUrl(id) });
+	const fleet = yield* client("work-board.fleetItems", undefined);
+	const inbox: InboxProjection = yield* client("work-board.inbox", undefined);
+	const held =
+		fleet.state === "ready" ? [...fleet.items, ...fleet.completed].find((entry) => entry.workId === id && entry.stage !== "released") : undefined;
+	return {
+		criteria: document.metadata.criteria ?? [],
+		fleet: fleet.state === "ready" ? { item: held ?? null, state: fleet.state } : fleet,
+		id,
+		openDecisions: document.requests.filter((request) => request.open),
+		owner: document.metadata.owner,
+		relationships: document.metadata.relationships ?? [],
+		status: cardStatus(document.metadata, held, inbox.you.find((row) => row.id === id)?.reason),
+	};
+});

package/src/server/mcp/run.ts

@@ -0,0 +1,37 @@
+import process from "node:process";
+import { NodeRuntime, NodeServices } from "@effect/platform-node";
+import { Effect, Layer, Logger, Path } from "effect";
+import { McpProtocol, McpServer } from "effect/ai";
+import { Argument, Command } from "effect/cli";
+import { NAME, VERSION } from "#server/packageInfo.ts";
+import { mcpTools } from "./tools.ts";
+
+const command = Command.make(
+	"mcp",
+	{
+		dir: Argument.String("dir").pipe(Argument.withDescription("The directory of the running board")),
+	},
+	({ dir }) =>
+		Effect.gen(function* () {
+			const path = yield* Path.Path;
+			return yield* Layer.launch(
+				mcpTools(path.resolve(dir)).pipe(
+					Layer.provide(
+						McpServer.layerStdio({
+							name: NAME,
+							protocols: [McpProtocol.v2025_11_25, McpProtocol.v2025_06_18, McpProtocol.v2025_03_26, McpProtocol.v2024_11_05],
+							version: VERSION,
+						}),
+					),
+				),
+			);
+		}),
+);
+
+export function runMcp() {
+	Command.runWith(command, { version: VERSION })(process.argv.slice(3)).pipe(
+		Effect.provideService(Logger.LogToStderr, true),
+		Effect.provide(NodeServices.layer),
+		NodeRuntime.runMain,
+	);
+}

package/src/server/mcp/schema.ts

@@ -0,0 +1,46 @@
+import { Schema } from "effect";
+import { DocumentRequest } from "#browser/document/schema.ts";
+import { FleetItemsProjection } from "#browser/views/FleetItemsProjection.ts";
+import { GoalsProjection } from "#browser/views/GoalsProjection.ts";
+import { InboxProjection } from "#browser/views/schema.ts";
+import { FleetItem } from "#diagnostics/fleetItems.ts";
+import { Metadata } from "#metadata/schema.ts";
+
+const YouItem = Schema.Struct({
+	...InboxProjection.fields.you.value.fields,
+	ageMs: Schema.NullOr(Schema.Number),
+	options: Schema.required(Metadata.to.fields.options),
+	prompts: Schema.required(DocumentRequest.fields.prompts),
+	promptUnavailable: DocumentRequest.fields.promptUnavailable,
+	recommended: Metadata.to.fields.recommended,
+});
+const Needs = Schema.Struct({
+	complete: Schema.Boolean,
+	issues: InboxProjection.fields.issues,
+	you: Schema.Array(YouItem),
+});
+export const NeedsYou = Schema.toCodecJson(Needs);
+export const Overview = Schema.toCodecJson(
+	Schema.Struct({
+		fleet: Schema.Union([
+			Schema.Struct({ items: FleetItemsProjection.members[0].fields.items, state: Schema.Literal("ready") }),
+			FleetItemsProjection.members[1],
+		]),
+		goals: Schema.Struct({ closedGoals: GoalsProjection.fields.closedGoals, goals: GoalsProjection.fields.goals }),
+		needsYou: Schema.Struct({ ...Needs.fields, count: Schema.Number }),
+	}),
+);
+export const Item = Schema.toCodecJson(
+	Schema.Struct({
+		criteria: Schema.required(Metadata.to.fields.criteria),
+		fleet: Schema.Union([
+			Schema.Struct({ item: Schema.NullOr(FleetItem), state: Schema.Literal("ready") }),
+			Schema.Struct({ reason: Schema.String, state: Schema.Literal("unavailable") }),
+		]),
+		id: Schema.String,
+		openDecisions: Schema.Array(DocumentRequest),
+		owner: Schema.optional(Schema.String),
+		relationships: Schema.required(Metadata.to.fields.relationships),
+		status: Schema.optional(Schema.String),
+	}),
+);

package/src/server/mcp/tools.ts

@@ -0,0 +1,37 @@
+import { Layer, Schema } from "effect";
+import { McpServer, Tool, Toolkit } from "effect/ai";
+import { BoardToolError, readBoard } from "./client.ts";
+import { item, needsYou, overview } from "./queries.ts";
+import { Item, NeedsYou, Overview } from "./schema.ts";
+
+const result = { failure: BoardToolError };
+const tools = Toolkit.make(
+	Tool.make("board_overview", {
+		...result,
+		description: "Read needs-you items and count, in-flight Fleet stages and PRs, and goal progress counts.",
+		success: Overview,
+	}).annotate(Tool.Readonly, true),
+	Tool.make("needs_you", {
+		...result,
+		description: "Read the board's you lane with reason, age in milliseconds since source modification, and options.",
+		success: NeedsYou,
+	}).annotate(Tool.Readonly, true),
+	Tool.make("item", {
+		...result,
+		description: "Read an item's computed status, owner, criteria, relationships, Fleet stage and open decisions.",
+		parameters: Schema.Struct({ id: Schema.String }),
+		success: Item,
+	}).annotate(Tool.Readonly, true),
+);
+
+export function mcpTools(directory: string) {
+	return McpServer.toolkit(tools).pipe(
+		Layer.provide(
+			tools.toLayer({
+				"board_overview": () => readBoard(directory, overview),
+				item: ({ id }) => readBoard(directory, (client) => item(client, id)),
+				"needs_you": () => readBoard(directory, needsYou),
+			}),
+		),
+	);
+}

package/src/server/metadata/backlinks.ts

@@ -41,12 +41,28 @@ export function referencesFrom(document: MetadataDocument, model: MetadataModel)
 	];
 }
 
+const backlinks = new WeakMap<MetadataModel, ReadonlyMap<string, readonly Backlink[]>>();
+
+function indexBacklinks(model: MetadataModel) {
+	const next = new Map<string, Backlink[]>();
+	for (const document of model.documents) {
+		for (const reference of referencesFrom(document, model)) {
+			if (!reference.target || reference.target === document.file) {
+				continue;
+			}
+			const matches = next.get(reference.target) ?? [];
+			matches.push({ file: document.file, kind: reference.kind, ...(reference.line === undefined ? {} : { line: reference.line }) });
+			next.set(reference.target, matches);
+		}
+	}
+	return next;
+}
+
 export function backlinksOf(file: string, model: MetadataModel): readonly Backlink[] {
-	return model.documents.flatMap((document) =>
-		document.file === file
-			? []
-			: referencesFrom(document, model)
-					.filter((reference) => reference.target === file)
-					.map((reference) => ({ file: document.file, kind: reference.kind, ...(reference.line === undefined ? {} : { line: reference.line }) })),
-	);
+	let indexed = backlinks.get(model);
+	if (!indexed) {
+		indexed = indexBacklinks(model);
+		backlinks.set(model, indexed);
+	}
+	return indexed.get(file) ?? [];
 }

package/src/server/metadata/fields.ts

@@ -2,6 +2,10 @@ import { Option, Schema } from "effect";
 import { Metadata } from "#metadata/schema.ts";
 import type { Diagnostic } from "./parse.ts";
 
+const addonOwners: Readonly<Record<string, readonly string[]>> = {
+	fleet: ["fleet", "fleet-launch", "fleet-deliverable"],
+};
+const addonFields = new Set(Object.values(addonOwners).flat());
 const schemas: ReadonlyMap<string, Schema.ConstraintDecoder<unknown, never>> = new Map(Object.entries(Metadata.to.fields));
 const sourceKeys = new Map([
 	["next_action", "nextAction"],
@@ -15,6 +19,9 @@ export function metadataFields(data: object, lines: Readonly<Record<string, numb
 		const key = sourceKeys.get(field) ?? field;
 		const schema = field === "nextAction" || field === "requestReceipt" ? undefined : schemas.get(key);
 		if (!schema) {
+			if (addonFields.has(field)) {
+				continue;
+			}
 			diagnostics.push({ field, line: lines[field] ?? 2, message: `Unknown field ${field}; kept in the original frontmatter.` });
 			continue;
 		}

package/src/server/metadata/sourceLinks.ts

@@ -37,9 +37,9 @@ export function sourceFile(source: string, file: string, model: MetadataModel):
 		if (path === "/") {
 			return model.rootFile;
 		}
-		const identity = /^\/_board\/item\/(?<id>[^/]+)\/$/u.exec(path)?.groups?.id;
+		const identity = /^\/_board\/item\/(?<id>[^/]+)\/?$/u.exec(url.pathname)?.groups?.id;
 		if (identity) {
-			return referenceFile(identity, model);
+			return referenceFile(decodeURIComponent(identity), model);
 		}
 		return /\.md$/iu.exec(path) === null ? undefined : path.slice(1);
 	} catch {

package/src/server/navigation/libraryData.ts

@@ -0,0 +1,43 @@
+import type { Schema } from "effect";
+import type { Library, LibraryInput } from "#browser/navigation/library.ts";
+import { fileUrl } from "#files/url.ts";
+import { fleetRecords } from "#server/attention/inbox.ts";
+import type { MarkdownFile } from "#server/files/list.ts";
+import type { Snapshot } from "#server/search/snapshot.ts";
+
+export function libraryData(files: readonly MarkdownFile[], snapshot: Snapshot, input: Schema.Struct.Type<typeof LibraryInput>): Library {
+	const records = fleetRecords(snapshot.model);
+	const documents = new Map(snapshot.documents.map((document) => [document.file, document.parsed.fields]));
+	const titles = new Map(snapshot.entries.filter((entry) => entry.kind === "document").map((entry) => [entry.file, entry.title]));
+	const all = files.map((file) => ({
+		...file,
+		href: fileUrl(file.path),
+		kind: documents.get(file.path)?.kind ?? "document",
+		status: documents.get(file.path)?.status ?? "",
+		title: titles.get(file.path) ?? file.path,
+	}));
+	const visible = all.filter(
+		(file) =>
+			(input.showFleet || !records.has(file.path)) && (!input.kind || input.kind === file.kind) && (!input.status || input.status === file.status),
+	);
+	const prefix = input.folder ? `${input.folder}/` : "";
+	const folders = new Map<string, number>();
+	for (const file of visible) {
+		if (!file.path.startsWith(prefix)) {
+			continue;
+		}
+		const name = file.path.slice(prefix.length).split("/");
+		if (name.length > 1 && name[0]) {
+			folders.set(name[0], (folders.get(name[0]) ?? 0) + 1);
+		}
+	}
+	return {
+		files: visible
+			.filter((file) => input.folder === undefined || (file.path.startsWith(prefix) && !file.path.slice(prefix.length).includes("/")))
+			.toSorted((a, b) => a.title.localeCompare(b.title) || a.path.localeCompare(b.path)),
+		fleetCount: all.filter((file) => records.has(file.path)).length,
+		folders: [...folders].sort(([a], [b]) => a.localeCompare(b)).map(([name, count]) => ({ count, name, path: `${prefix}${name}` })),
+		kinds: [...new Set(all.map((file) => file.kind))].sort(),
+		statuses: [...new Set(all.map((file) => file.status).filter(Boolean))].sort(),
+	};
+}