@shivaedev/work-board 0.13.0 → 0.14.0

package/src/server/boardSocket.ts

@@ -0,0 +1,81 @@
+import { createServer } from "node:http";
+import { createConnection } from "node:net";
+import { NodeHttpServer } from "@effect/platform-node";
+import { Effect, FileSystem, Layer, Path, Scope } from "effect";
+import { HttpServerRequest, HttpServerResponse } from "effect/http";
+import { RpcSerialization, RpcServer } from "effect/rpc";
+import { workRpcs } from "#rpc/contract.ts";
+import { RPC_PATH } from "#server/http/rpcPolicy.ts";
+import type { boardRuntime } from "./boardRuntime.ts";
+
+function socketState(path: string) {
+	return Effect.callback<"live" | "missing" | "stale", Error>((resume) => {
+		const socket = createConnection(path);
+		socket.once("connect", () => {
+			socket.destroy();
+			resume(Effect.succeed("live"));
+		});
+		socket.once("error", (cause: NodeJS.ErrnoException) => {
+			if (cause.code === "ENOENT") {
+				resume(Effect.succeed("missing"));
+			} else if (cause.code === "ECONNREFUSED") {
+				resume(Effect.succeed("stale"));
+			} else {
+				resume(Effect.fail(cause));
+			}
+		});
+		return Effect.sync(() => socket.destroy());
+	});
+}
+
+export const boardSocket = Effect.fn("WorkBoard.boardSocket")(function* (
+	root: string,
+	handlers: Effect.Success<ReturnType<typeof boardRuntime>>["rpcHandlers"],
+) {
+	const fs = yield* FileSystem.FileSystem;
+	const paths = yield* Path.Path;
+	const path = paths.join(root, "board.sock");
+	const scope = yield* Scope.Scope;
+	function occupied() {
+		return new Error(`Another board is already running at ${path}. Stop it before starting this board.`);
+	}
+	const context = yield* Layer.build(handlers.pipe(Layer.provideMerge(RpcSerialization.layerNdjson)));
+	const rpc = yield* RpcServer.toHttpEffect(workRpcs).pipe(Effect.provideContext(context));
+	yield* Effect.scoped(
+		Effect.gen(function* () {
+			const lock = paths.join(root, ".board.sock.starting");
+			yield* Effect.acquireRelease(
+				fs.makeDirectory(lock, { mode: 0o700 }).pipe(
+					Effect.catchIf(
+						(error) => error.reason._tag === "AlreadyExists",
+						() =>
+							Effect.fail(new Error(`${occupied().message} A startup lock exists at ${lock}; remove it only if its startup was forcibly killed.`)),
+					),
+				),
+				() => fs.remove(lock, { recursive: true }).pipe(Effect.orDie),
+			);
+			const state = yield* socketState(path);
+			if (state === "live") {
+				return yield* Effect.fail(occupied());
+			}
+			if (state === "stale") {
+				yield* fs.remove(path, { force: true });
+			}
+			// Short private names preserve owner-only access within board.sock's pathname budget.
+			const staging = yield* fs.makeTempDirectoryScoped({ directory: root, prefix: ".s" });
+			const pending = paths.join(staging, "s");
+			const server = yield* NodeHttpServer.make(createServer, { disablePreemptiveShutdown: true, path: pending }).pipe(Scope.provide(scope));
+			yield* fs.chmod(pending, 0o600);
+			yield* server
+				.serve(
+					Effect.gen(function* () {
+						const request = yield* HttpServerRequest.HttpServerRequest;
+						return request.method === "POST" && request.url === RPC_PATH ? yield* rpc : HttpServerResponse.empty({ status: 404 });
+					}),
+				)
+				.pipe(Scope.provide(scope));
+			// Unpublish while this listener still answers probes, before Node closes its private bind path.
+			yield* Effect.acquireRelease(fs.rename(pending, path), () => fs.remove(path, { force: true }).pipe(Effect.orDie)).pipe(Scope.provide(scope));
+		}),
+	);
+});

package/src/server/cli.ts

@@ -2,7 +2,10 @@
 import process from "node:process";
 
 const action = process.argv[2];
-if (action === "wait" || action === "response" || action === "question") {
+if (action === "mcp") {
+	const entry = await import("#server/mcp/run.ts");
+	entry.runMcp();
+} else if (action === "wait" || action === "response" || action === "question") {
 	try {
 		const entry: typeof import("#server/responses/agent-cli.ts") = await import(new URL("../../assets/agent.js", import.meta.url).href);
 		await entry.runAgent(process.argv.slice(2));

package/src/server/currentDocument.ts

@@ -0,0 +1,23 @@
+import type { MetadataDocument } from "#server/metadata/model.ts";
+import { metadataParse } from "#server/metadata/parse.ts";
+import { updateModel } from "#server/metadata/updateModel.ts";
+import type { Snapshot } from "#server/search/snapshot.ts";
+
+interface CurrentDocument {
+	readonly document: MetadataDocument;
+	readonly snapshot: Snapshot;
+}
+
+export function currentDocument(snapshot: Snapshot, file: string, source: string, rootFile?: string): CurrentDocument {
+	const indexed = snapshot.documents.find((entry) => entry.file === file);
+	if (indexed && source === (indexed.parsed.raw ?? "") + indexed.parsed.body) {
+		return { document: indexed, snapshot };
+	}
+	const document: MetadataDocument = { file, parsed: metadataParse(source) };
+	const documents = snapshot.documents.map((entry) => (entry.file === file ? document : entry));
+	if (!indexed) {
+		documents.push(document);
+	}
+	const model = updateModel(snapshot.model, documents, snapshot.unavailable, rootFile);
+	return { document, snapshot: { ...snapshot, documents, model } };
+}

package/src/server/diagnostics/daemon.ts

@@ -4,23 +4,23 @@ import { RpcClient, RpcSerialization } from "effect/rpc";
 import { RpcClientError } from "effect/rpc/RpcClientError";
 import { DAEMON_PORT, DAEMON_RPC_PATH, DiagnosticsContract, type DiagnosticsSnapshot } from "#diagnostics/daemonContract.ts";
 
-const daemonUnavailable = Effect.fn("WorkBoard.daemonUnavailable")(function* (error: unknown, port: number) {
+function makeDaemonClient() {
+	return RpcClient.make(DiagnosticsContract, { flatten: true });
+}
+type DaemonClient = Effect.Success<ReturnType<typeof makeDaemonClient>>;
+
+export function daemonUnavailableReason(error: unknown, port: number) {
 	const stopped = error instanceof RpcClientError && error.reason._tag === "HttpError" && error.reason.kind === "TransportError";
-	const observation = {
-		cause: stopped
-			? `No Fleet daemon is running at 127.0.0.1:${port}; start work-fleet serve <board-dir> --port ${port}`
-			: `Fleet daemon communication failed at 127.0.0.1:${port}`,
-		observedAt: yield* Clock.currentTimeMillis,
-		state: "error" as const,
-	};
-	return { codex: observation, fleet: observation, github: observation } satisfies DiagnosticsSnapshot;
-});
+	return stopped
+		? `No Fleet daemon is running at 127.0.0.1:${port}; start work-fleet serve <board-dir> --port ${port}`
+		: `Fleet daemon communication failed at 127.0.0.1:${port}`;
+}
 
-export function daemonDiagnostics(port = DAEMON_PORT) {
+export function readDaemon<A, E>(port: number, read: (client: DaemonClient) => Effect.Effect<A, E>) {
 	return Effect.scoped(
 		Effect.gen(function* () {
-			const client = yield* RpcClient.make(DiagnosticsContract, { flatten: true });
-			return yield* client("daemon.diagnostics", {});
+			const client = yield* makeDaemonClient();
+			return yield* read(client);
 		}).pipe(
 			Effect.provide(
 				RpcClient.layerProtocolHttp({ url: `http://127.0.0.1:${port}${DAEMON_RPC_PATH}` }).pipe(
@@ -28,7 +28,27 @@ export function daemonDiagnostics(port = DAEMON_PORT) {
 				),
 			),
 			Effect.timeout("5 seconds"),
-			Effect.catch((error) => daemonUnavailable(error, port)),
+		),
+	);
+}
+
+export function daemonDiagnostics(port: number | null = DAEMON_PORT) {
+	if (port === null) {
+		return Effect.gen(function* () {
+			const observation = {
+				cause: "Fleet daemon is not configured for this Board",
+				observedAt: yield* Clock.currentTimeMillis,
+				state: "not-configured" as const,
+			};
+			return { codex: observation, fleet: observation, github: observation } satisfies DiagnosticsSnapshot;
+		});
+	}
+	return readDaemon(port, (client) => client("daemon.diagnostics", {})).pipe(
+		Effect.catch((error) =>
+			Effect.gen(function* () {
+				const observation = { cause: daemonUnavailableReason(error, port), observedAt: yield* Clock.currentTimeMillis, state: "error" as const };
+				return { codex: observation, fleet: observation, github: observation } satisfies DiagnosticsSnapshot;
+			}),
 		),
 	);
 }

package/src/server/document/answerBody.ts

@@ -0,0 +1,96 @@
+import remarkDirective from "remark-directive";
+import remarkParse from "remark-parse";
+import { unified } from "unified";
+import type { DocumentRequest } from "#browser/document/schema.ts";
+import { reasonMarkdown } from "#browser/responses/reasonMarkdown.ts";
+import type { MetadataDocument } from "#server/metadata/model.ts";
+import { documentBody } from "./body.ts";
+
+export function answerBody(document: MetadataDocument, requests: readonly DocumentRequest[]): string {
+	const source = documentBody(document);
+	const cards = requests.filter((request) => request.open && request.preview?.source === document.file);
+	const managed = document.parsed.fields.attention?.some((request) => request.managed);
+	const title = managed ? requests[0]?.title : undefined;
+	if (cards.length === 0 && !title) {
+		return source;
+	}
+	const tree = unified().use(remarkParse).use(remarkDirective).parse(source);
+	const removed = repeatedReason(tree.children, source, cards);
+	return tree.children
+		.flatMap((node, index) => {
+			if (
+				removed.has(index)
+				|| promptInCard(node, cards)
+				|| (managed && cards.some((request) => request.preview !== undefined) && inCardSection(tree.children, index, source))
+			) {
+				return [];
+			}
+			if (index === 0 && node.type === "heading" && node.depth === 1 && title) {
+				return [`# ${title}`];
+			}
+			return [source.slice(node.position?.start.offset, node.position?.end.offset)];
+		})
+		.join("\n\n");
+}
+
+function repeatedReason(nodes: import("mdast").RootContent[], source: string, cards: readonly DocumentRequest[]) {
+	const reasons = cards.flatMap((request) => (request.preview ? [reasonMarkdown(request.preview.reason)] : []));
+	const removed = new Set<number>();
+	for (const [index] of nodes.entries()) {
+		const end = repeatedPassageEnd(nodes, source, index, reasons);
+		if (end === undefined) {
+			continue;
+		}
+		for (let position = index; position <= end; position += 1) {
+			removed.add(position);
+		}
+		const previous = nodes[index - 1];
+		const next = nodes[end + 1];
+		if (previous?.type === "heading" && previous.depth > 1 && (!next || (next.type === "heading" && next.depth <= previous.depth))) {
+			removed.add(index - 1);
+		}
+	}
+	return removed;
+}
+
+function repeatedPassageEnd(nodes: import("mdast").RootContent[], source: string, start: number, reasons: readonly string[]) {
+	let matched: number | undefined;
+	const first = nodes[start];
+	for (let end = start; end < nodes.length; end += 1) {
+		const text =
+			end === start && first?.type === "code" ? first.value : source.slice(first?.position?.start.offset, nodes[end]?.position?.end.offset);
+		const passage = reasonMarkdown(text);
+		if (!reasons.some((reason) => reason.startsWith(passage))) {
+			break;
+		}
+		if (reasons.includes(passage)) {
+			matched = end;
+		}
+	}
+	return matched;
+}
+
+function promptInCard(node: import("mdast").RootContent, cards: readonly DocumentRequest[]) {
+	if (node.type !== "containerDirective" || node.name !== "question") {
+		return false;
+	}
+	return cards.some(
+		(request) =>
+			!request.promptUnavailable
+			&& (node.attributes?.request === undefined || node.attributes.request === request.id)
+			&& request.prompts?.some((prompt) => prompt.id === node.attributes?.id),
+	);
+}
+
+function inCardSection(nodes: import("mdast").RootContent[], index: number, source: string) {
+	for (let position = index; position >= 0; position -= 1) {
+		const node = nodes[position];
+		if (node?.type === "containerDirective") {
+			return false;
+		}
+		if (node?.type === "heading" && node.depth <= 2) {
+			return ["## Recommendation", "## Relevant links"].includes(source.slice(node.position?.start.offset, node.position?.end.offset).trim());
+		}
+	}
+	return false;
+}

package/src/server/document/read.ts

@@ -1,14 +1,13 @@
 import { Effect, FileSystem } from "effect";
 import { Conflict, NotFound, ServiceUnavailable } from "@shivaedev/platform/errors/taxonomy.ts";
 import type { Document } from "#browser/document/schema.ts";
+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 { readingActions } from "#server/responses/readingActions.ts";
 import type { Snapshot } from "#server/search/snapshot.ts";
-import { documentBody } from "./body.ts";
+import { answerBody } from "./answerBody.ts";
 import { readingContext } from "./readingContext.ts";
 import { documentRequests } from "./requests.ts";
 import { documentTargets } from "./targets.ts";
@@ -29,7 +28,8 @@ const selected = Effect.fn("WorkBoard.selected")(function* (
 ) {
 	const pathname = new URL(url, "http://127.0.0.1").pathname;
 	const requested = decodeURIComponent(pathname.slice(1));
-	const item = /^_board\/item\/(?<id>[^/]+)\/$/u.exec(requested)?.groups?.id;
+	const encodedId = /^\/_board\/item\/(?<id>[^/]+)\/?$/u.exec(pathname)?.groups?.id;
+	const item = encodedId === undefined ? undefined : decodeURIComponent(encodedId);
 	if (item && snapshot.unavailable.length > 0) {
 		return yield* Effect.fail(new ServiceUnavailable({ message: "Document sources are unavailable." }));
 	}
@@ -56,23 +56,32 @@ export function readDocument({ changes, home, index, root, writable }: DocumentO
 		}
 		const fs = yield* FileSystem.FileSystem;
 		const source = yield* fs.readFileString(real);
-		const parsed = metadataParse(source);
-		const document = { file: file.path, parsed };
-		const documents = [...snapshot.documents.filter((entry) => entry.file !== file.path), document];
-		const model = metadataModel(documents, snapshot.unavailable, home ?? files[0]?.path);
+		const current = currentDocument(snapshot, file.path, source, home ?? files[0]?.path);
+		const { document } = current;
+		const { parsed } = document;
+		const { model } = current.snapshot;
 		const id = parsed.fields.id;
 		const identity = id && snapshot.unavailable.length === 0 && model.ids.get(id)?.length === 1 ? id : undefined;
 		if (item && identity !== item) {
 			return yield* Effect.fail(new NotFound({ message: "The document is missing." }));
 		}
 		const questionActions = yield* readingActions(document, source, writable, identity);
-		const reading = readingContext(document, model, file.path === home);
+		const titles = new Map(current.snapshot.entries.filter((entry) => entry.kind === "document").map((entry) => [entry.file, entry.title]));
+		const reading = readingContext(document, model, file.path === home, titles);
+		const targets = documentTargets(
+			document,
+			model,
+			Object.values(reading.receipts).map((receipt) => receipt.question),
+		);
+		const referenceDetails = Object.fromEntries(
+			Object.keys(targets.references).flatMap((target) => {
+				const referenced = model.ids.get(target.split("#")[0] ?? "")?.[0];
+				return referenced ? [[target, { status: referenced.parsed.fields.status, title: titles.get(referenced.file) ?? referenced.file }]] : [];
+			}),
+		);
+		const requests = documentRequests(document, source, current.snapshot);
 		return {
-			...documentTargets(
-				document,
-				model,
-				Object.values(reading.receipts).map((receipt) => receipt.question),
-			),
+			...targets,
 			diagnostics: model.diagnostics.get(file.path) ?? parsed.diagnostics,
 			file: file.path,
 			...(identity ? { identity } : {}),
@@ -80,8 +89,9 @@ export function readDocument({ changes, home, index, root, writable }: DocumentO
 			modified: file.modified,
 			questionActions: Object.fromEntries(questionActions ?? []),
 			reading,
-			requests: documentRequests(document, source, { ...snapshot, documents, model }),
-			source: documentBody(document),
+			referenceDetails,
+			requests,
+			source: answerBody(document, requests),
 			unavailable: snapshot.unavailable,
 			writable,
 		} satisfies Document;

package/src/server/document/readingContext.ts

@@ -1,20 +1,26 @@
+import { specificSources } from "#browser/document/sourceGroups.ts";
+import { fileUrl } from "#files/url.ts";
 import { managedRequestReceipt } from "#server/attention/managedRequestReceipt.ts";
 import { backlinksOf } from "#server/metadata/backlinks.ts";
 import { referenceTarget } from "#server/metadata/links.ts";
 import type { MetadataDocument, MetadataModel } from "#server/metadata/model.ts";
 import { relationshipLabel } from "#server/metadata/relationshipLabel.ts";
 import { sourceFile, sourceHref } from "#server/metadata/sourceLinks.ts";
-import { documentReference } from "#server/page/metadataLinks.ts";
 
-export function readingContext(document: MetadataDocument, model: MetadataModel, board: boolean) {
+export function readingContext(document: MetadataDocument, model: MetadataModel, board: boolean, titles: ReadonlyMap<string, string> = new Map()) {
 	const { fields, lines, raw, bodyLine } = document.parsed;
+	const sources = new Map(model.documents.map((entry) => [entry.file, entry]));
 	const backlinks = [...new Map(backlinksOf(document.file, model).map((link) => [`${link.file}:${link.kind}:${link.line ?? ""}`, link])).values()];
 	return {
-		backlinks: backlinks.map((link) => ({
-			href: documentReference(link.file, model),
-			kind: relationshipLabel(link.kind),
-			label: link.file + (link.line === undefined ? "" : `:${link.line}`),
-		})),
+		backlinks: specificSources(
+			backlinks.map((link) => ({
+				href: documentReference(link.file, model),
+				kind: relationshipLabel(link.kind),
+				label: link.file + (link.line === undefined ? "" : `:${link.line}`),
+				status: sources.get(link.file)?.parsed.fields.status,
+				title: titles.get(link.file) ?? link.file,
+			})),
+		),
 		board,
 		claims: criterionClaims(document, model),
 		evidenceSources: (fields.evidence ?? []).map((entry) => {
@@ -59,3 +65,8 @@ function criterionClaims(document: MetadataDocument, model: MetadataModel) {
 		]),
 	);
 }
+
+function documentReference(file: string, model: MetadataModel, hash = ""): string {
+	const id = model.documents.find((document) => document.file === file)?.parsed.fields.id;
+	return ((id ? referenceTarget(id, model) : undefined) ?? fileUrl(file)) + hash;
+}

package/src/server/document/requestTitle.ts

@@ -0,0 +1,10 @@
+import type { MetadataDocument } from "#server/metadata/model.ts";
+import type { Snapshot } from "#server/search/snapshot.ts";
+
+export function requestTitle(document: MetadataDocument, snapshot: Snapshot, request?: string): string {
+	const attention = document.parsed.fields.attention?.find((entry) => request === undefined || entry.id === request);
+	const target = snapshot.model.ids.get(attention?.unblocks[0]?.split("#")[0] ?? document.parsed.fields.id ?? "");
+	const file = target?.length === 1 ? target[0]?.file : document.file;
+	const title = snapshot.entries.find((entry) => entry.kind === "document" && entry.file === file)?.title;
+	return title && !/[a-f\d]{64}/iu.test(title) ? title : "Requested decision";
+}

package/src/server/document/requests.ts

@@ -1,14 +1,36 @@
 import { ServiceUnavailable } from "@shivaedev/platform/errors/taxonomy.ts";
 import type { DocumentRequest } from "#browser/document/schema.ts";
-import { authoredQuestion } from "#server/attention/inbox.ts";
+import { responseUrl } from "#responses/url.ts";
+import { authoredQuestion, openItem } from "#server/attention/inbox.ts";
+import { requestInbox } from "#server/attention/requestInbox.ts";
+import { attentionRequests } from "#server/attention/requests.ts";
 import type { MetadataDocument } from "#server/metadata/model.ts";
 import { responseHistory } from "#server/responses/history.ts";
 import { questionId, revisionOf } from "#server/responses/records.ts";
 import { requestSource } from "#server/responses/requestSource.ts";
 import { questionTemplate } from "#server/responses/template.ts";
 import type { Snapshot } from "#server/search/snapshot.ts";
+import { requestTitle } from "./requestTitle.ts";
 
 export function documentRequests(document: MetadataDocument, source: string, snapshot: Snapshot): readonly DocumentRequest[] {
+	const own = sourceRequests(document, source, snapshot);
+	const item = document.parsed.fields.id;
+	if (!openItem(document)) {
+		return own.map((request) => ({ ...request, open: false, preview: undefined }));
+	}
+	const linked = attentionRequests(snapshot).entries.flatMap((entry) => {
+		if (entry.document.file === document.file || !entry.request.unblocks.some((target) => target.split("#")[0] === item)) {
+			return [];
+		}
+		const context = (entry.document.parsed.raw ?? "") + entry.document.parsed.body;
+		return sourceRequests(entry.document, context, snapshot)
+			.filter((request) => request.open && request.id === entry.request.id)
+			.map((request) => ({ ...request, id: `${entry.itemId}/${request.id}` }));
+	});
+	return [...own, ...linked];
+}
+
+function sourceRequests(document: MetadataDocument, source: string, snapshot: Snapshot): readonly DocumentRequest[] {
 	const item = document.parsed.fields.id;
 	if (!item) {
 		return [];
@@ -18,7 +40,7 @@ export function documentRequests(document: MetadataDocument, source: string, sna
 	];
 	const reviewedRevision = revisionOf(source);
 	return ids.map((id) => {
-		const active = requestSource(snapshot, item, id);
+		const active = activeSource(document, snapshot, item, id);
 		const preview = {
 			context: source,
 			id: questionId(item, id, reviewedRevision, document.file),
@@ -28,7 +50,15 @@ export function documentRequests(document: MetadataDocument, source: string, sna
 			reviewedRevision,
 			source: document.file,
 		};
-		const request = { id, open: active !== undefined, ...(active ? { preview } : {}) };
+		const request = {
+			id,
+			open: active !== undefined,
+			options: document.parsed.fields.options,
+			recommended: document.parsed.fields.recommended,
+			sourceOpen: requestOpenInSource(document, id),
+			title: requestTitle(document, snapshot, id),
+			...(active ? { preview } : {}),
+		};
 		try {
 			if (snapshot.model.ids.get(item)?.length !== 1) {
 				throw new ServiceUnavailable({ message: "Item identity is ambiguous; response history is unknown. Give each item a unique ID, then retry." });
@@ -44,3 +74,16 @@ export function documentRequests(document: MetadataDocument, source: string, sna
 		}
 	});
 }
+
+function requestOpenInSource(document: MetadataDocument, id: string): boolean {
+	if (authoredQuestion(document) && id === "answer") {
+		return openItem(document);
+	}
+	return document.parsed.fields.attention?.find((entry) => entry.id === id)?.state === "open";
+}
+
+function activeSource(document: MetadataDocument, snapshot: Snapshot, item: string, id: string) {
+	const managed = document.parsed.fields.attention?.find((entry) => entry.id === id)?.managed;
+	const eligible = !managed || requestInbox(snapshot).items.some((entry) => entry.href === responseUrl(item, id));
+	return eligible ? requestSource(snapshot, item, id) : undefined;
+}

package/src/server/files/watchDirectories.ts

@@ -36,6 +36,9 @@ export const watchDirectories = Effect.fn("WorkBoard.watchDirectories")(function
 			);
 			const pending = new Set<string>();
 			const watch = Stream.mergeAll(streams, { concurrency: "unbounded" }).pipe(
+				Stream.filter(
+					(relative) => !relative.split("/").some((segment) => segment === ".board.sock.starting" || /^\.s[A-Za-z0-9]{6}$/u.test(segment)),
+				),
 				Stream.tap((relative) => (isMarkdown(relative) || attachmentType(relative) !== undefined ? observed : Effect.void)),
 				Stream.tap((relative) =>
 					Effect.gen(function* () {

package/src/server/http/assets.ts

@@ -2,10 +2,10 @@ import { createRequire } from "node:module";
 import { Effect, FileSystem, Path, Schema } from "effect";
 import type { HttpRouter, HttpServerRequest } from "effect/http";
 import { InternalServerError } from "@shivaedev/platform/errors/taxonomy.ts";
-import { style } from "#server/page/style.ts";
+import { INITIAL_THEME_SCRIPT, THEME_ROUTE } from "#server/page/initialTheme.ts";
 import { respond } from "./respond.ts";
 
-export const ASSETS: ReadonlyArray<readonly [HttpRouter.PathInput, string, string]> = [["/_board/style.css", style, "text/css"]];
+export const ASSETS: ReadonlyArray<readonly [HttpRouter.PathInput, string, string]> = [[THEME_ROUTE, INITIAL_THEME_SCRIPT, "text/javascript"]];
 
 const MERMAID = "/_board/mermaid/";
 

package/src/server/http/boardRoutes.ts

@@ -1,22 +1,19 @@
 import { Effect, type FileSystem, type Path, type Scope } from "effect";
-import { HttpRouter, type HttpServerRequest, type HttpServerResponse } from "effect/http";
+import { HttpRouter, type HttpServerRequest, HttpServerResponse } from "effect/http";
 import { loopbackOnly } from "@shivaedev/platform/rpc-server/local.ts";
 import type { Diagnostics } from "#diagnostics/source.ts";
 import type { BoardOptions } from "#server/board.ts";
 import type { boardRuntime } from "#server/boardRuntime.ts";
 import type { HandoffsService } from "#server/handoffs/Service.ts";
-import { navHtml } from "#server/page/nav.ts";
+import { identityUrl } from "#server/metadata/links.ts";
 import { shell } from "#server/page/shell.ts";
 import type { Highlighter } from "#server/render/Highlighter.ts";
-import type { Responses } from "#server/responses/service.ts";
+import { Responses } from "#server/responses/service.ts";
 import { ASSET_HANDLERS, MERMAID_ROUTE, mermaidFile } from "./assets.ts";
 import { attachment } from "./attachment.ts";
 import { identity } from "./identity.ts";
-import { inbox } from "./inbox.ts";
-import { overview } from "./overview.ts";
 import { page } from "./page.ts";
 import { respond } from "./respond.ts";
-import { work } from "./work.ts";
 
 type Services = Highlighter | Responses | HandoffsService | Diagnostics | FileSystem.FileSystem | Path.Path;
 type Handler<E> = (request: HttpServerRequest.HttpServerRequest) => Effect.Effect<HttpServerResponse.HttpServerResponse, E, Services | Scope.Scope>;
@@ -33,27 +30,31 @@ export function boardRoutes(options: BoardOptions, runtime: Effect.Success<Retur
 				);
 			}
 			yield* serve("/_board/attachment/*", attachment(options.root, changes.realRoot));
-			const inboxPage = inbox(index, changes, home);
-			yield* serve("/_board/inbox", inboxPage);
-			const workPage = work(index, changes, home);
-			const overviewPage = overview(index, changes, home);
-			yield* serve("/_board/work", workPage);
-			yield* serve("/_board/overview", overviewPage);
+			for (const [route, target] of [
+				["overview", "/"],
+				["inbox", "/"],
+				["changes", "/_board/library?view=recently-changed"],
+				["diagnostics", "/_board/system"],
+			] as const) {
+				yield* serve(`/_board/${route}`, () => Effect.succeed(HttpServerResponse.redirect(target)));
+			}
 			for (const [route, asset] of ASSET_HANDLERS) {
 				yield* serve(route, asset);
 			}
 			yield* serve(MERMAID_ROUTE, mermaidFile(mermaid));
-			for (const view of ["changes", "diagnostics", "start", "respond", "handoff", "result"] as const) {
-				yield* serve(`/_board/${view}`, () =>
-					Effect.gen(function* () {
-						const snapshot = yield* index;
-						const nav = navHtml(yield* changes.files, "", home, snapshot);
-						return respond(shell(view, nav, "", changes.realRoot, false, undefined, view === "respond" ? "response" : view, snapshot), "text/html");
-					}),
-				);
+			yield* serve("/_board/respond", (request) =>
+				Effect.gen(function* () {
+					const params = new URL(request.url, "http://127.0.0.1").searchParams;
+					const service = yield* Responses;
+					const preview = yield* service.locate(params.get("item") ?? "", params.get("request") ?? "");
+					return HttpServerResponse.redirect(`${identityUrl(preview.item)}#answer-card-${encodeURIComponent(preview.request)}`);
+				}).pipe(Effect.catch(() => Effect.succeed(respond("Response unavailable", "text/html", 409)))),
+			);
+			for (const view of ["system", "start", "handoff", "result", "library", "goals", "work"] as const) {
+				yield* serve(`/_board/${view}`, () => Effect.succeed(respond(shell(view, changes.realRoot), "text/html")));
 			}
 			const pages = page({ home, root: options.root, writable: options.responses === true }, changes, index);
-			const items = identity(index, pages, changes, home);
+			const items = identity(index, pages, changes);
 			yield* serve("/_board/item/*", items);
 			yield* serve("/", pages);
 			yield* serve("/*", pages);