@shivaedev/work-board 0.12.0 → 0.14.0

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

@@ -1,140 +1,25 @@
-import { Context, Effect, FileSystem, Layer, Path, type PlatformError, type Scope } from "effect";
-import { HttpRouter, HttpServerRequest, type HttpServerResponse } from "effect/unstable/http";
+import { Effect, type FileSystem, Layer, type Path, type PlatformError } from "effect";
+import { HttpRouter } from "effect/http";
+import { RpcSerialization, RpcServer } from "effect/rpc";
 import type { InternalServerError } from "@shivaedev/platform/errors/taxonomy.ts";
-import { loopbackOnly } from "@shivaedev/platform/rpc-server/local.ts";
-import { Diagnostics, DiagnosticsSources } from "#diagnostics/source.ts";
+import { localRpcGuard } from "@shivaedev/platform/rpc-server/local.ts";
 import type { RenderFailed } from "#render/failed.ts";
-import { boardServices } from "#server/boardServices.ts";
-import { daemonDiagnostics } from "#server/diagnostics/daemon.ts";
-import { diagnosticsPage } from "#server/diagnostics/page.ts";
-import { readDocument } from "#server/document/read.ts";
-import { watchChanges } from "#server/files/changes.ts";
-import { type HomeMissing, homeIn } from "#server/files/home.ts";
-import { handoffPage } from "#server/handoffs/page.ts";
-import type { HandoffsService } from "#server/handoffs/Service.ts";
-import { ASSET_HANDLERS, checkBrowserAssets, MERMAID_ROUTE, type MermaidMissing, mermaidFile, mermaidRoot } from "#server/http/assets.ts";
-import { attachment } from "#server/http/attachment.ts";
-import { changesPage } from "#server/http/changesPage.ts";
-import { identity } from "#server/http/identity.ts";
-import { inbox } from "#server/http/inbox.ts";
-import { overview } from "#server/http/overview.ts";
-import { page } from "#server/http/page.ts";
-import { readPage } from "#server/http/readPage.ts";
-import { start } from "#server/http/start.ts";
-import { work } from "#server/http/work.ts";
+import { workRpcs } from "#rpc/contract.ts";
+import { boardRuntime } from "#server/boardRuntime.ts";
+import type { HomeMissing } from "#server/files/home.ts";
+import type { MermaidMissing } from "#server/http/assets.ts";
+import { boardRoutes } from "#server/http/boardRoutes.ts";
+import { RPC_PATH, rpcPolicy } from "#server/http/rpcPolicy.ts";
 import { Highlighter } from "#server/render/Highlighter.ts";
-import { responsePage } from "#server/responses/page.ts";
-import type { Responses } from "#server/responses/service.ts";
-import { resultPage } from "#server/results/page.ts";
-import { server } from "#server/rpc/transport.ts";
-import { searchSnapshot } from "#server/search/snapshot.ts";
 
 export interface BoardOptions {
-	readonly fleetPort?: number;
+	readonly fleetPort?: number | null;
 	readonly home?: string | undefined;
 	readonly maintainer?: string | undefined;
 	readonly responses?: boolean;
 	readonly root: string;
 }
 
-type Services = Highlighter | Responses | HandoffsService | Diagnostics | FileSystem.FileSystem | Path.Path;
-type Handler<E> = (request: HttpServerRequest.HttpServerRequest) => Effect.Effect<HttpServerResponse.HttpServerResponse, E, Services | Scope.Scope>;
-
-function routes(options: BoardOptions) {
-	return HttpRouter.use((router) =>
-		Effect.gen(function* () {
-			const home = yield* homeIn(options.root, options.home);
-			const mermaid = yield* mermaidRoot();
-			yield* checkBrowserAssets();
-			const changes = yield* watchChanges(options.root);
-			const platform = (yield* Effect.context<Highlighter | FileSystem.FileSystem | Path.Path>()).pipe(
-				Context.pick(Highlighter, FileSystem.FileSystem, Path.Path),
-			);
-			const index = yield* searchSnapshot(options.root, home, changes, options.maintainer);
-			const provided = yield* Effect.serviceOption(DiagnosticsSources);
-			const services = yield* Layer.build(
-				boardServices(
-					{ changes, enabled: options.responses === true, index: Effect.provideContext(index, platform), root: options.root },
-					provided._tag === "Some" ? { _tag: "Sources", sources: provided.value } : { _tag: "Read", read: daemonDiagnostics(options.fleetPort) },
-				),
-			);
-			const context = Context.merge(platform, services);
-			function serve<E>(route: HttpRouter.PathInput, handler: Handler<E>, method: "GET" | "POST" = "GET") {
-				return router.add(
-					method,
-					route,
-					loopbackOnly((request) => Effect.provideContext(handler(request), context)),
-				);
-			}
-			yield* serve("/_board/attachment/*", attachment(options.root, changes.realRoot));
-			const healthPage = diagnosticsPage(
-				Effect.flatMap(Diagnostics, (service) => service.read()).pipe(Effect.provideContext(context)),
-				changes,
-				home,
-				index,
-			);
-			yield* serve("/_board/diagnostics", () => healthPage);
-			const inboxPage = inbox(index, changes, home);
-			yield* serve("/_board/inbox", inboxPage);
-			const startPage = start(changes, home, index);
-			yield* serve("/_board/start", startPage);
-			const workPage = work(index, changes, home);
-			const result = resultPage(index, changes, home);
-			yield* serve("/_board/result", result);
-			const overviewPage = overview(index, changes, home);
-			const historyPage = changesPage(changes, home, index);
-			yield* serve("/_board/work", workPage);
-			yield* serve("/_board/overview", overviewPage);
-			yield* serve("/_board/changes", historyPage);
-			for (const [route, asset] of ASSET_HANDLERS) {
-				yield* serve(route, asset);
-			}
-			yield* serve(MERMAID_ROUTE, mermaidFile(mermaid));
-			const replyPage = responsePage(changes, home, options.responses === true, index);
-			yield* serve("/_board/respond", replyPage);
-			const handoff = handoffPage(changes, home, options.responses === true, index);
-			yield* serve("/_board/handoff", handoff);
-			const pages = page({ home, root: options.root, writable: options.responses === true }, changes, index);
-			const items = identity(index, pages, changes, home);
-			yield* serve("/_board/item/*", items);
-			const reading = readPage<PlatformError.PlatformError, Services>(
-				{
-					"/_board/changes": () => historyPage(),
-					"/_board/diagnostics": () => healthPage,
-					"/_board/handoff": handoff,
-					"/_board/inbox": () => inboxPage(),
-					"/_board/overview": () => overviewPage(),
-					"/_board/respond": replyPage,
-					"/_board/result": result,
-					"/_board/start": () => startPage(),
-					"/_board/work": workPage,
-				},
-				(request) => (new URL(request.url, "http://127.0.0.1").pathname.startsWith("/_board/item/") ? items(request) : pages(request)),
-			);
-			const rpc = yield* server({
-				changes,
-				document: (url) =>
-					Effect.provideContext(
-						readDocument({
-							changes,
-							home,
-							index: Effect.provideContext(index, context),
-							root: options.root,
-							writable: options.responses === true,
-						})(url),
-						context,
-					),
-				home,
-				index: Effect.provideContext(index, context),
-				page: (url) => Effect.provideContext(reading(url), context),
-			}).pipe(Effect.provideContext(context));
-			yield* serve("/_board/rpc", (request) => rpc.pipe(Effect.provideService(HttpServerRequest.HttpServerRequest, request)), "POST");
-			yield* serve("/", pages);
-			yield* serve("/*", pages);
-		}),
-	);
-}
-
 type BoardError = InternalServerError | HomeMissing | MermaidMissing | PlatformError.PlatformError | RenderFailed;
 type BoardServices =
 	| FileSystem.FileSystem
@@ -143,5 +28,18 @@ type BoardServices =
 	| HttpRouter.Request<"Error", InternalServerError | PlatformError.PlatformError>;
 
 export function boardLayer(options: BoardOptions): Layer.Layer<never, BoardError, BoardServices> {
-	return routes(options).pipe(Layer.provide(Highlighter.layer));
+	return Layer.unwrap(
+		Effect.gen(function* () {
+			const runtime = yield* boardRuntime(options);
+			const rpc = RpcServer.layerHttp({ group: workRpcs, path: RPC_PATH, protocol: "http" }).pipe(
+				Layer.provide([
+					runtime.rpcHandlers,
+					RpcSerialization.layerNdjson,
+					HttpRouter.middleware((http) => localRpcGuard(http).pipe(Effect.provideService(RpcSerialization.RpcSerialization, RpcSerialization.ndjson)))
+						.layer,
+				]),
+			);
+			return Layer.mergeAll(boardRoutes(options, runtime), rpc, rpcPolicy);
+		}),
+	).pipe(Layer.provide(Highlighter.layer));
 }

package/src/server/boardRuntime.ts

@@ -0,0 +1,57 @@
+import { Context, Effect, FileSystem, Layer, Path, type PlatformError } from "effect";
+import { DiagnosticsSources } from "#diagnostics/source.ts";
+import type { BoardOptions } from "#server/board.ts";
+import { boardServices } from "#server/boardServices.ts";
+import { daemonDiagnostics } from "#server/diagnostics/daemon.ts";
+import { readDocument } from "#server/document/read.ts";
+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, server?: HandlerOptions["server"]) {
+	const home = yield* homeIn(options.root, options.home);
+	const mermaid = yield* mermaidRoot();
+	yield* checkBrowserAssets();
+	const changes = yield* watchChanges(options.root);
+	const platform = (yield* Effect.context<Highlighter | FileSystem.FileSystem | Path.Path>()).pipe(
+		Context.pick(Highlighter, FileSystem.FileSystem, Path.Path),
+	);
+	const index: Effect.Effect<Snapshot, PlatformError.PlatformError, FileSystem.FileSystem | Path.Path> = yield* searchSnapshot(
+		options.root,
+		home,
+		changes,
+		options.maintainer,
+	);
+	const provided = yield* Effect.serviceOption(DiagnosticsSources);
+	const services = yield* Layer.build(
+		boardServices(
+			{ changes, enabled: options.responses === true, index: Effect.provideContext(index, platform), root: options.root },
+			provided._tag === "Some" ? { _tag: "Sources", sources: provided.value } : { _tag: "Read", read: daemonDiagnostics(options.fleetPort) },
+		),
+	);
+	const context = Context.merge(platform, services);
+	const rpcHandlers = yield* handlers({
+		...(options.fleetPort === undefined ? {} : { fleetPort: options.fleetPort }),
+		changes,
+		document: (url) =>
+			Effect.provideContext(
+				readDocument({
+					changes,
+					home,
+					index: Effect.provideContext(index, context),
+					root: options.root,
+					writable: options.responses === true,
+				})(url),
+				context,
+			),
+		home,
+		index: Effect.provideContext(index, context),
+		...(server === undefined ? {} : { server }),
+		writable: options.responses === true,
+	}).pipe(Effect.provideContext(context));
+	return { changes, context, home, index, mermaid, rpcHandlers };
+});