@shivaedev/work-board 0.13.0 → 0.14.0

package/src/rpc/PageUrl.ts

@@ -0,0 +1,32 @@
+import { Schema } from "effect";
+
+export const PageUrl = Schema.String.check(
+	Schema.isMaxLength(8192),
+	Schema.makeFilter((value) => {
+		if (!value.startsWith("/") || value.startsWith("//")) {
+			return "Expected a local reading URL";
+		}
+		try {
+			const path = new URL(value, "http://127.0.0.1").pathname;
+			return (
+				path === "/"
+				|| [
+					"/_board/inbox",
+					"/_board/system",
+					"/_board/work",
+					"/_board/overview",
+					"/_board/changes",
+					"/_board/start",
+					"/_board/respond",
+					"/_board/handoff",
+					"/_board/result",
+				].includes(path)
+				|| /^\/_board\/item\/[^/]+\/?$/u.exec(path) !== null
+				|| /\.md$/iu.exec(path) !== null
+				|| "Expected a local reading URL"
+			);
+		} catch {
+			return "Expected a local reading URL";
+		}
+	}),
+);

package/src/rpc/Server.ts

@@ -0,0 +1,3 @@
+import { Schema } from "effect";
+
+export const Server = Schema.Struct({ directory: Schema.String, url: Schema.String });

package/src/rpc/contract.ts

@@ -2,56 +2,33 @@ import { Schema } from "effect";
 import { contract } from "@shivaedev/effect-contract/contract.ts";
 import { LiveHint } from "@shivaedev/effect-contract/live.ts";
 import { query, stream } from "@shivaedev/effect-contract/operation.ts";
-import { InternalServerError } from "@shivaedev/platform/errors/taxonomy.ts";
+import { InternalServerError, ServiceUnavailable } from "@shivaedev/platform/errors/taxonomy.ts";
 import { RequestTracing } from "@shivaedev/platform/rpc/middleware.ts";
 import { Document } from "#browser/document/schema.ts";
-import { Navigation } from "#browser/navigation/schema.ts";
+import { Navigation } from "#browser/Navigation.ts";
+import { Library, LibraryInput } from "#browser/navigation/library.ts";
+import { FleetItemsProjection } from "#browser/views/FleetItemsProjection.ts";
+import { GoalsProjection } from "#browser/views/GoalsProjection.ts";
 import { ResultProjection } from "#browser/views/ResultProjection.ts";
 import { DiagnosticsProjection, HandoffProjection, RespondProjection, StartProjection } from "#browser/views/remaining.ts";
-import { BoardProjection, InboxProjection, OverviewProjection, WorkProjection } from "#browser/views/schema.ts";
-import { HistoryInput, HistoryOutput } from "#history/schema.ts";
+import { BoardProjection, InboxProjection, WorkProjection } from "#browser/views/schema.ts";
 import { handoffContract } from "#rpc/handoffContract.ts";
 import { responseContract } from "#rpc/responseContract.ts";
 import { index, navigation, watcher, workspace } from "./keys.ts";
+import { PageUrl } from "./PageUrl.ts";
 import { pageKeys } from "./pageKeys.ts";
 import { documentRejections } from "./rejections.ts";
+import { Server } from "./Server.ts";
 
-const PageUrl = Schema.String.check(
-	Schema.isMaxLength(8192),
-	Schema.makeFilter((value) => {
-		if (!value.startsWith("/") || value.startsWith("//")) {
-			return "Expected a local reading URL";
-		}
-		try {
-			const path = new URL(value, "http://127.0.0.1").pathname;
-			return (
-				path === "/"
-				|| [
-					"/_board/inbox",
-					"/_board/diagnostics",
-					"/_board/work",
-					"/_board/overview",
-					"/_board/changes",
-					"/_board/start",
-					"/_board/respond",
-					"/_board/handoff",
-					"/_board/result",
-				].includes(path)
-				|| /^\/_board\/item\/[^/]+\/$/u.exec(path) !== null
-				|| /\.md$/iu.exec(path) !== null
-				|| "Expected a local reading URL"
-			);
-		} catch {
-			return "Expected a local reading URL";
-		}
-	}),
-);
 const Entry = Schema.Struct({
 	file: Schema.String,
 	href: Schema.String,
+	id: Schema.optional(Schema.String),
+	itemKind: Schema.optional(Schema.String),
 	kind: Schema.Literals(["document", "heading", "passage"]),
 	line: Schema.optional(Schema.Number),
 	snippet: Schema.String,
+	status: Schema.optional(Schema.String),
 	text: Schema.String,
 	title: Schema.String,
 });
@@ -73,13 +50,11 @@ const ReadWork = query("work", {
 	rejections: documentRejections,
 	success: WorkProjection,
 });
-const ReadOverview = query("overview", {
-	reads: () => [workspace.list, index.list],
-	rejections: { InternalServerError },
-	success: OverviewProjection,
-});
 const ReadInbox = query("inbox", { reads: () => [workspace.list, index.list], rejections: { InternalServerError }, success: InboxProjection });
+const ReadServer = query("server", { reads: () => [], rejections: { ServiceUnavailable }, success: Server });
 const ReadDiagnostics = query("diagnostics", { reads: () => [workspace.list], rejections: { InternalServerError }, success: DiagnosticsProjection });
+const ReadFleetItems = query("fleetItems", { reads: () => [workspace.list, index.list], success: FleetItemsProjection });
+const ReadGoals = query("goals", { reads: () => [workspace.list, index.list], rejections: { InternalServerError }, success: GoalsProjection });
 const ReadStart = query("start", { reads: () => [workspace.list, index.list], rejections: { InternalServerError }, success: StartProjection });
 const ReadRespond = query("respond", {
 	payload: { url: PageUrl },
@@ -99,9 +74,15 @@ const ReadResult = query("result", {
 	rejections: documentRejections,
 	success: ResultProjection,
 });
+const ReadLibrary = query("library", {
+	payload: LibraryInput,
+	reads: () => [workspace.list, index.list],
+	rejections: { InternalServerError },
+	success: Library,
+});
 const ReadNavigation = query("navigation", {
 	payload: { current: Schema.String.check(Schema.isMaxLength(8192)) },
-	reads: () => [workspace.list, navigation.list],
+	reads: () => [workspace.list, navigation.list, index.list],
 	rejections: { InternalServerError },
 	success: Navigation,
 });
@@ -111,12 +92,6 @@ const ReadSearch = query("search", {
 	rejections: { InternalServerError },
 	success: Schema.Struct({ results: Schema.Array(Entry), total: Schema.Number, unavailable: Schema.Array(Schema.String) }),
 });
-const ReadHistory = query("history", {
-	payload: HistoryInput,
-	reads: () => [workspace.list, index.list],
-	rejections: { InternalServerError },
-	success: HistoryOutput,
-});
 const ReadWatcher = query("watcher", {
 	reads: () => [workspace.list, watcher.list],
 	rejections: { InternalServerError },
@@ -125,19 +100,21 @@ const ReadWatcher = query("watcher", {
 export const Subscribe = stream("subscribe", { reads: () => [workspace.list], rejections: { InternalServerError }, success: LiveHint });
 export const workContract = contract("work-board", {
 	queries: [
+		ReadServer,
 		ReadDocument,
 		ReadBoard,
 		ReadWork,
-		ReadOverview,
 		ReadInbox,
 		ReadDiagnostics,
+		ReadFleetItems,
+		ReadGoals,
 		ReadStart,
 		ReadRespond,
 		ReadHandoff,
 		ReadResult,
 		ReadNavigation,
+		ReadLibrary,
 		ReadSearch,
-		ReadHistory,
 		ReadWatcher,
 	],
 	streams: [Subscribe],

package/src/rpc/pageKeys.ts

@@ -3,7 +3,7 @@ import { documents, identities, index, workspace } from "./keys.ts";
 
 export function pageKeys(url: string): readonly Key[] {
 	const path = new URL(url, "http://127.0.0.1").pathname;
-	const item = /^\/_board\/item\/(?<id>[^/]+)\/$/u.exec(path)?.groups?.id;
+	const item = /^\/_board\/item\/(?<id>[^/]+)\/?$/u.exec(path)?.groups?.id;
 	let key: Key = documents.item(decodeURIComponent(path.slice(1)));
 	if (item) {
 		key = identities.item(decodeURIComponent(item));

package/src/server/attention/inbox.ts

@@ -3,14 +3,15 @@ import { responseUrl } from "#responses/url.ts";
 import { identityUrl } from "#server/metadata/links.ts";
 import type { MetadataDocument, MetadataModel } from "#server/metadata/model.ts";
 import type { Snapshot } from "#server/search/snapshot.ts";
-import { answeredQuestion, pendingQuestions } from "./questionState.ts";
-import { attentionRequests, isMaintainerRequest } from "./requests.ts";
+import { answeredQuestion } from "./questionState.ts";
+import { requestInbox } from "./requestInbox.ts";
+import { isMaintainerRequest } from "./requests.ts";
+import { closedItem } from "./status.ts";
 
-const closed = new Set(["closed", "done", "completed", "cancelled", "canceled", "resolved", "released"]);
-const automation = /^(?:codex|claude|fleet|agent|automation|bot|copilot)(?:$|[-_. /])/iu;
+const automation = /^(?:codex|claude|fleet|orchestrator|agent|automation|bot|copilot)(?:$|[-_. /])/iu;
 
 export function openItem(document: MetadataDocument): boolean {
-	return !closed.has(document.parsed.fields.status?.trim().toLowerCase() ?? "");
+	return !closedItem(document);
 }
 
 export function authoredQuestion(document: MetadataDocument): boolean {
@@ -54,22 +55,12 @@ function identityProblem(document: MetadataDocument, model: MetadataModel): stri
 	return model.ids.get(id)?.length === 1 ? undefined : `Duplicate item ID: ${id}`;
 }
 
-function unresolvedReason(document: MetadataDocument, problem: string | undefined, maintainer: string | undefined): string | undefined {
-	if (!problem) {
-		return undefined;
-	}
-	const requests =
-		document.parsed.fields.attention?.filter((request) => request.managed && request.state === "open" && isMaintainerRequest(request, maintainer))
-		?? [];
-	return requests.length > 0 ? `Managed decision: ${requests.map((request) => request.reason).join("; ")}` : undefined;
-}
-
-function inboxTarget(document: MetadataDocument, problem: string | undefined, request: string | undefined): string {
+function inboxTarget(document: MetadataDocument, problem: string | undefined): string {
 	if (problem) {
 		return fileUrl(document.file);
 	}
 	const item = document.parsed.fields.id ?? "";
-	const answer = request ?? (authoredQuestion(document) ? "answer" : undefined);
+	const answer = authoredQuestion(document) ? "answer" : undefined;
 	return answer ? responseUrl(item, answer) : identityUrl(item);
 }
 
@@ -78,35 +69,33 @@ export function inboxItems(snapshot: Snapshot) {
 		return [];
 	}
 	const titles = new Map(snapshot.entries.filter((entry) => entry.kind === "document").map((entry) => [entry.file, entry.title]));
-	const managed = attentionRequests(snapshot).entries.filter(
-		(entry) => entry.request.managed && isMaintainerRequest(entry.request, snapshot.maintainer),
-	);
-	const pending = pendingQuestions(snapshot);
-	const pendingLinks = new Map(pending.map((item) => [item.document.file, item.href]));
+	const requests = requestInbox(snapshot);
+	const you = requests.items.filter((item) => item.responseFrom.includes(snapshot.maintainer ?? "maintainer"));
 	const direct = snapshot.documents.flatMap((document) => {
+		if (requests.files.has(document.file)) {
+			return [];
+		}
 		const id = document.parsed.fields.id;
 		const problem = identityProblem(document, snapshot.model);
-		const requests = managed.filter((entry) => entry.document.file === document.file);
-		const reason =
-			waitingReason(document, snapshot.model, snapshot.maintainer)
-			?? (requests.length > 0 ? `Managed decision: ${requests.map((entry) => entry.request.reason).join("; ")}` : undefined)
-			?? unresolvedReason(document, problem, snapshot.maintainer);
+		const reason = waitingReason(document, snapshot.model, snapshot.maintainer);
 		return reason
 			? [
 					{
 						document,
-						href: pendingLinks.get(document.file) ?? inboxTarget(document, problem, requests[0]?.request.id),
+						href: inboxTarget(document, problem),
 						id: id ?? document.file,
 						problem,
 						reason,
 						title: titles.get(document.file) ?? document.file,
+						unblocks: [id ?? ""],
 					},
 				]
 			: [];
 	});
-	return [...new Map([...pending.map((item) => ({ ...item, problem: undefined })), ...direct].map((item) => [item.document.file, item])).values()]
-		.map((item) => ({ ...item, modified: snapshot.modified.get(item.document.file) }))
-		.sort((left, right) => (left.modified ?? 0) - (right.modified ?? 0) || left.id.localeCompare(right.id));
+	const ordinary = direct
+		.filter((item) => item.problem || !you.some((ask) => ask.id === item.id))
+		.map((item) => ({ ...item, earlierAsks: 0, modified: snapshot.modified.get(item.document.file) }));
+	return [...ordinary, ...you].sort((left, right) => (left.modified ?? 0) - (right.modified ?? 0) || left.id.localeCompare(right.id));
 }
 
 export function fleetRecords(model: MetadataModel): ReadonlySet<string> {
@@ -118,6 +107,7 @@ export function fleetRecords(model: MetadataModel): ReadonlySet<string> {
 		[
 			...decisions,
 			...questions,
+			...model.documents.filter((document) => document.parsed.fields.requestReceipt !== undefined),
 			...model.documents.filter((document) => document.parsed.fields.response && questionIds.has(document.parsed.fields.response.question)),
 		].map((document) => document.file),
 	);

package/src/server/attention/managedRequestReceipt.ts

@@ -1,8 +1,8 @@
 import type { RequestReceipt } from "#attention/RequestReceipt.ts";
 import type { Metadata } from "#metadata/schema.ts";
-import { currentResponses } from "#responses/current.ts";
 import type { MetadataDocument, MetadataModel } from "#server/metadata/model.ts";
-import { malformedResponse, questionFrom, questionId, responseFrom, responsesFor, revisionOf } from "#server/responses/records.ts";
+import { responseIndex } from "#server/responseIndex.ts";
+import { questionId, revisionOf } from "#server/responses/records.ts";
 
 type Request = NonNullable<Metadata["attention"]>[number];
 
@@ -11,25 +11,30 @@ function uniqueDocument(id: string, model: MetadataModel): MetadataDocument | un
 	return matches?.length === 1 ? matches[0] : undefined;
 }
 
+function registeredContext(document: MetadataDocument | undefined, model: MetadataModel) {
+	return document ? responseIndex(model).questions.get(document.file) : undefined;
+}
+
 function appliedAnswer(question: string, revision: string, responseId: string | undefined, model: MetadataModel): boolean {
 	if (responseId === undefined) {
 		return false;
 	}
 	const matches = model.ids.get(responseId);
-	const answer = matches?.length === 1 && matches[0] ? responseFrom(matches[0]) : undefined;
+	const index = responseIndex(model);
+	const answer = matches?.length === 1 && matches[0] ? index.responses.get(matches[0].file) : undefined;
 	if (answer?.response.type !== "answer" || answer.response.question !== question || answer.response.reviewedRevision !== revision) {
 		return false;
 	}
 	const registered = model.ids.get(question)?.[0];
-	const context = registered && questionFrom(registered);
-	if (!context || model.documents.some(malformedResponse)) {
+	const context = registered && index.questions.get(registered.file);
+	if (!context || index.malformed) {
 		return false;
 	}
-	const responses = responsesFor(model.documents, context).responses;
-	if (responses.some((response) => model.ids.get(response.id)?.length !== 1)) {
+	const group = index.responsesFor(context);
+	if (group.ambiguous) {
 		return false;
 	}
-	const current = currentResponses(responses);
+	const current = group.current;
 	return current.length === 1 && current[0]?.id === responseId;
 }
 
@@ -52,7 +57,8 @@ export function managedRequestReceipt(document: MetadataDocument, request: Reque
 	const revision = revisionOf(source);
 	const id = questionId(item, request.id, revision, document.file);
 	const archived = uniqueDocument(id, model);
-	const question = archived && questionFrom(archived);
+	const index = responseIndex(model);
+	const question = registeredContext(archived, model);
 	if (
 		archived?.parsed.diagnostics.length !== 0
 		|| !question
@@ -64,14 +70,10 @@ export function managedRequestReceipt(document: MetadataDocument, request: Reque
 	) {
 		return undefined;
 	}
-	if (
-		model.documents.some((entry) =>
-			entry.parsed.diagnostics.some((problem) => problem.field === "request_receipt" || problem.field === "requestReceipt"),
-		)
-	) {
+	if (index.receiptProblems) {
 		return undefined;
 	}
-	const receipts = model.documents.filter((entry) => entry.parsed.fields.requestReceipt?.question === id);
+	const receipts = index.receipts.get(id) ?? [];
 	const saved = receipts.length === 1 ? receipts[0] : undefined;
 	const receipt = saved?.parsed.fields.requestReceipt;
 	if (

package/src/server/attention/projection.ts

@@ -0,0 +1,32 @@
+import type { InboxProjection } from "#browser/views/schema.ts";
+import type { Snapshot } from "#server/search/snapshot.ts";
+import { inboxItems } from "./inbox.ts";
+import { requestInbox } from "./requestInbox.ts";
+import { attentionRequests } from "./requests.ts";
+
+const projections = new WeakMap<Snapshot, InboxProjection>();
+
+export function attentionProjection(snapshot: Snapshot): InboxProjection {
+	const cached = projections.get(snapshot);
+	if (cached) {
+		return cached;
+	}
+	const requests = requestInbox(snapshot);
+	function project({ document, unblocks: _unblocks, ...item }: ReturnType<typeof inboxItems>[number]) {
+		return { ...item, file: document.file };
+	}
+	const you = inboxItems(snapshot).map(project);
+	const issues = attentionRequests(snapshot).issues;
+	const projection = {
+		agents: requests.items.filter((item) => !item.responseFrom.includes(snapshot.maintainer ?? "maintainer")).map(project),
+		complete: snapshot.unavailable.length === 0,
+		issues,
+		items: you,
+		parked: requests.parked.map(project),
+		resolved: requests.resolved.map(project),
+		sourceIssues: issues.length > 0,
+		you,
+	} satisfies InboxProjection;
+	projections.set(snapshot, projection);
+	return projection;
+}

package/src/server/attention/questionState.ts

@@ -1,47 +1,36 @@
 import type { Question } from "#browser/responses/schema.ts";
 import { responseUrl } from "#responses/url.ts";
 import type { MetadataDocument, MetadataModel } from "#server/metadata/model.ts";
-import { metadataParse } from "#server/metadata/parse.ts";
-import { questionFrom, responseFrom } from "#server/responses/records.ts";
+import { responseIndex } from "#server/responseIndex.ts";
 import type { Snapshot } from "#server/search/snapshot.ts";
 import { attentionRequests, isMaintainerRequest } from "./requests.ts";
 
 function currentSource(question: Question, document: MetadataDocument): boolean {
-	const captured = metadataParse(question.context);
-	return question.question.source === document.file && captured.raw === document.parsed.raw && captured.body === document.parsed.body;
+	return question.question.source === document.file && question.context === (document.parsed.raw ?? "") + document.parsed.body;
 }
 
 function hasAnswer(question: Question, model: MetadataModel): boolean {
-	return model.documents.some((source) => {
-		const response = responseFrom(source);
-		return (
-			response?.response.question === question.id
-			&& response.response.type === "answer"
-			&& response.response.reviewedRevision === question.question.reviewedRevision
-			&& model.ids.get(response.id)?.length === 1
-		);
-	});
+	return responseIndex(model).responsesFor(question).answered;
 }
 
-export function answeredQuestion(document: MetadataDocument, model: MetadataModel): boolean {
-	return model.documents.some((candidate) => {
-		const question = questionFrom(candidate);
-		return (
-			question !== undefined
-			&& question.question.item === document.parsed.fields.id
-			&& model.ids.get(question.id)?.length === 1
-			&& currentSource(question, document)
-			&& hasAnswer(question, model)
+export function answeredQuestion(document: MetadataDocument, model: MetadataModel, request?: string): boolean {
+	return responseIndex(model)
+		.questionsFor(document.parsed.fields.id ?? "")
+		.some(
+			(question) =>
+				question.question.item === document.parsed.fields.id
+				&& (request === undefined || question.question.request === request)
+				&& model.ids.get(question.id)?.length === 1
+				&& currentSource(question, document)
+				&& hasAnswer(question, model),
 		);
-	});
 }
 
 export function pendingQuestions(snapshot: Snapshot) {
 	const open = attentionRequests(snapshot).entries.filter((entry) => isMaintainerRequest(entry.request, snapshot.maintainer));
 	const titles = new Map(snapshot.entries.filter((entry) => entry.kind === "document").map((entry) => [entry.file, entry.title]));
-	return snapshot.documents.flatMap((captured) => {
-		const question = questionFrom(captured);
-		if (!question || modelAmbiguous(question, snapshot.model) || hasAnswer(question, snapshot.model)) {
+	return [...responseIndex(snapshot.model).questions.values()].flatMap((question) => {
+		if (modelAmbiguous(question, snapshot.model) || hasAnswer(question, snapshot.model)) {
 			return [];
 		}
 		const source = snapshot.model.ids.get(question.question.item)?.[0];

package/src/server/attention/requestInbox.ts

@@ -0,0 +1,61 @@
+import { responseUrl } from "#responses/url.ts";
+import type { Snapshot } from "#server/search/snapshot.ts";
+import { answeredQuestion } from "./questionState.ts";
+import { type AttentionEntry, attentionRequests } from "./requests.ts";
+import { closedItem, deferredItem } from "./status.ts";
+
+function activeKey(entry: AttentionEntry, ids: readonly string[], maintainer = "maintainer"): string {
+	const audience = entry.request.responseFrom.includes(maintainer) ? "you" : "agents";
+	return JSON.stringify([audience, audience === "agents" ? [...entry.request.responseFrom].sort() : [], ids]);
+}
+
+export function requestInbox(snapshot: Snapshot) {
+	const entries = attentionRequests(snapshot).entries.filter(
+		(entry) => entry.request.managed || !answeredQuestion(entry.document, snapshot.model, entry.request.id),
+	);
+	const titles = new Map(snapshot.entries.filter((entry) => entry.kind === "document").map((entry) => [entry.file, entry.title]));
+	function targets(entry: AttentionEntry) {
+		return [...new Set(entry.request.unblocks.map((target) => target.split("#")[0] ?? ""))].sort();
+	}
+	function row(entry: AttentionEntry) {
+		const ids = targets(entry);
+		const target = ids.length === 1 ? snapshot.model.ids.get(ids[0] ?? "")?.[0] : undefined;
+		return {
+			document: entry.document,
+			earlierAsks: 0,
+			href: responseUrl(entry.itemId, entry.request.id),
+			id: target?.parsed.fields.id ?? entry.itemId,
+			modified: snapshot.modified.get(entry.document.file),
+			problem: undefined,
+			reason: entry.request.managed ? `Managed decision: ${entry.request.reason}` : entry.request.reason,
+			responseFrom: entry.request.responseFrom,
+			title: (target ? titles.get(target.file) : undefined) ?? entry.title,
+			unblocks: entry.request.unblocks,
+		};
+	}
+	const resolved: ReturnType<typeof row>[] = [];
+	const parked: ReturnType<typeof row>[] = [];
+	const active = new Map<string, ReturnType<typeof row>>();
+	entries.sort(
+		(left, right) =>
+			(snapshot.modified.get(left.document.file) ?? 0) - (snapshot.modified.get(right.document.file) ?? 0)
+			|| left.document.file.localeCompare(right.document.file)
+			|| left.line - right.line
+			|| left.request.id.localeCompare(right.request.id),
+	);
+	for (const entry of entries) {
+		const ids = targets(entry);
+		const documents = ids.flatMap((id) => snapshot.model.ids.get(id) ?? []);
+		const item = row(entry);
+		if (entry.request.managed && documents.length === ids.length && documents.every(closedItem)) {
+			resolved.push(item);
+		} else if (entry.request.managed && documents.length === ids.length && documents.every(deferredItem)) {
+			parked.push(item);
+		} else {
+			const key = activeKey(entry, ids, snapshot.maintainer);
+			item.earlierAsks = (active.get(key)?.earlierAsks ?? -1) + 1;
+			active.set(key, item);
+		}
+	}
+	return { files: new Set(entries.map((entry) => entry.document.file)), items: [...active.values()], parked, resolved };
+}

package/src/server/attention/requests.ts

@@ -52,7 +52,15 @@ function requestsFor(document: MetadataDocument, snapshot: Snapshot, title: stri
 	});
 }
 
-export function attentionRequests(snapshot: Snapshot) {
+interface AttentionResult {
+	complete: boolean;
+	entries: AttentionEntry[];
+	issues: SourceIssue[];
+}
+
+const cached = new WeakMap<Snapshot, AttentionResult>();
+
+function collectRequests(snapshot: Snapshot): AttentionResult {
 	const titles = new Map(snapshot.entries.filter((entry) => entry.kind === "document").map((entry) => [entry.file, entry.title]));
 	const issues: SourceIssue[] = snapshot.documents.flatMap((source) =>
 		(snapshot.model.diagnostics.get(source.file) ?? source.parsed.diagnostics).map((problem) => ({ ...problem, file: source.file })),
@@ -63,6 +71,15 @@ export function attentionRequests(snapshot: Snapshot) {
 	return { complete: snapshot.unavailable.length === 0, entries, issues };
 }
 
+export function attentionRequests(snapshot: Snapshot): AttentionResult {
+	let result = cached.get(snapshot);
+	if (!result) {
+		result = collectRequests(snapshot);
+		cached.set(snapshot, result);
+	}
+	return { ...result, entries: [...result.entries], issues: [...result.issues] };
+}
+
 export function attentionSource(document: MetadataDocument, index: number): string {
 	const requests = document.parsed.fields.attention ?? [];
 	const id = requests[index]?.id;

package/src/server/attention/status.ts

@@ -0,0 +1,15 @@
+import type { MetadataDocument } from "#server/metadata/model.ts";
+
+const closed = new Set(["closed", "done", "superseded", "completed", "cancelled", "canceled", "resolved", "released"]);
+
+function statusOf(document: MetadataDocument): string {
+	return document.parsed.fields.status?.trim().toLowerCase() ?? "";
+}
+
+export function closedItem(document: MetadataDocument): boolean {
+	return closed.has(statusOf(document));
+}
+
+export function deferredItem(document: MetadataDocument): boolean {
+	return statusOf(document) === "deferred";
+}

package/src/server/board.ts

@@ -13,7 +13,7 @@ import { RPC_PATH, rpcPolicy } from "#server/http/rpcPolicy.ts";
 import { Highlighter } from "#server/render/Highlighter.ts";
 
 export interface BoardOptions {
-	readonly fleetPort?: number;
+	readonly fleetPort?: number | null;
 	readonly home?: string | undefined;
 	readonly maintainer?: string | undefined;
 	readonly responses?: boolean;

package/src/server/boardRuntime.ts

@@ -8,10 +8,11 @@ import { watchChanges } from "#server/files/changes.ts";
 import { homeIn } from "#server/files/home.ts";
 import { checkBrowserAssets, mermaidRoot } from "#server/http/assets.ts";
 import { Highlighter } from "#server/render/Highlighter.ts";
+import type { HandlerOptions } from "#server/rpc/HandlerOptions.ts";
 import { handlers } from "#server/rpc/handlers.ts";
 import { type Snapshot, searchSnapshot } from "#server/search/snapshot.ts";
 
-export const boardRuntime = Effect.fn("WorkBoard.boardRuntime")(function* (options: BoardOptions) {
+export const boardRuntime = Effect.fn("WorkBoard.boardRuntime")(function* (options: BoardOptions, server?: HandlerOptions["server"]) {
 	const home = yield* homeIn(options.root, options.home);
 	const mermaid = yield* mermaidRoot();
 	yield* checkBrowserAssets();
@@ -34,6 +35,7 @@ export const boardRuntime = Effect.fn("WorkBoard.boardRuntime")(function* (optio
 	);
 	const context = Context.merge(platform, services);
 	const rpcHandlers = yield* handlers({
+		...(options.fleetPort === undefined ? {} : { fleetPort: options.fleetPort }),
 		changes,
 		document: (url) =>
 			Effect.provideContext(
@@ -48,6 +50,7 @@ export const boardRuntime = Effect.fn("WorkBoard.boardRuntime")(function* (optio
 			),
 		home,
 		index: Effect.provideContext(index, context),
+		...(server === undefined ? {} : { server }),
 		writable: options.responses === true,
 	}).pipe(Effect.provideContext(context));
 	return { changes, context, home, index, mermaid, rpcHandlers };