@shivaedev/work-board 0.12.0 → 0.14.0

package/src/client/react/visualSources.ts

@@ -0,0 +1,105 @@
+import { Clock, Effect } from "effect";
+import { useEffect } from "react";
+
+export interface VisualSource {
+	readonly alt: string;
+	readonly local: string;
+	readonly src: string;
+}
+export interface VisualSelection {
+	readonly drawing?: SVGSVGElement;
+	readonly images: readonly VisualSource[];
+	readonly origin: HTMLElement;
+	readonly selected: number;
+}
+export function useVisualSources(inspect: (selection: VisualSelection) => void) {
+	useEffect(() => {
+		let revision = 0;
+		function refresh() {
+			revision += 1;
+			for (const graphic of document.querySelectorAll<HTMLImageElement>("#doc img[data-local-image]")) {
+				graphic.tabIndex = 0;
+				graphic.setAttribute("role", "button");
+				graphic.setAttribute("aria-label", `Inspect image: ${graphic.alt || "Local image"}`);
+				const url = new URL(graphic.dataset.localImage ?? graphic.src, location.href);
+				url.searchParams.set("_wb", `${Effect.runSync(Clock.currentTimeMillis)}-${revision}`);
+				graphic.src = url.href;
+				graphic.onerror = () => {
+					if (!graphic.isConnected || graphic.nextElementSibling?.hasAttribute("data-image-error")) {
+						return;
+					}
+					const error = document.createElement("span");
+					error.setAttribute("data-image-error", "");
+					error.setAttribute("role", "status");
+					error.textContent = "Image unavailable. Check the local path, supported type, workspace boundary and 16 MiB limit.";
+					graphic.after(error);
+				};
+				graphic.onload = () => {
+					if (graphic.nextElementSibling?.hasAttribute("data-image-error")) {
+						graphic.nextElementSibling.remove();
+					}
+				};
+			}
+		}
+		function image(source: HTMLImageElement) {
+			const images = [...document.querySelectorAll<HTMLImageElement>("#doc img[data-local-image]")];
+			inspect({
+				images: images.map((entry) => ({ alt: entry.alt, local: entry.dataset.localImage ?? entry.src, src: entry.src })),
+				origin: source,
+				selected: images.indexOf(source),
+			});
+		}
+		function click(event: MouseEvent) {
+			if (
+				event.defaultPrevented
+				|| event.button !== 0
+				|| event.ctrlKey
+				|| event.metaKey
+				|| event.shiftKey
+				|| event.altKey
+				|| !(event.target instanceof Element)
+			) {
+				return;
+			}
+			inspectTarget(event, event.target);
+		}
+		function inspectTarget(event: MouseEvent, target: Element) {
+			const trigger = target.closest<HTMLButtonElement>("#doc [data-inspect-diagram]");
+			const drawing = trigger?.closest("figure")?.querySelector("svg");
+			if (trigger && !trigger.disabled && drawing) {
+				inspect({ drawing, images: [], origin: trigger, selected: -1 });
+				return;
+			}
+			const link = target.closest<HTMLAnchorElement>('#doc a[href^="/_board/attachment/"]');
+			if (link && !link.hasAttribute("download") && (!link.target || link.target === "_self")) {
+				event.preventDefault();
+				inspect({
+					images: [{ alt: link.textContent ?? "", local: link.getAttribute("href") ?? link.href, src: link.href }],
+					origin: link,
+					selected: 0,
+				});
+				return;
+			}
+			const source = target.closest<HTMLImageElement>("#doc img[data-local-image]");
+			if (source) {
+				event.preventDefault();
+				image(source);
+			}
+		}
+		function key(event: KeyboardEvent) {
+			if (["Enter", " "].includes(event.key) && event.target instanceof HTMLImageElement && event.target.matches("#doc img[data-local-image]")) {
+				event.preventDefault();
+				image(event.target);
+			}
+		}
+		document.addEventListener("click", click);
+		document.addEventListener("keydown", key);
+		document.addEventListener("board-page", refresh);
+		refresh();
+		return () => {
+			document.removeEventListener("click", click);
+			document.removeEventListener("keydown", key);
+			document.removeEventListener("board-page", refresh);
+		};
+	}, [inspect]);
+}

package/src/client/react/workspaceDestinations.ts

@@ -0,0 +1,7 @@
+export const workspaceDestinations = [
+	{ href: "/", id: "home-open", label: "Today", view: "today" },
+	{ href: "/_board/goals", id: "goals-open", label: "Goals", view: "goals" },
+	{ href: "/_board/work", id: "work-open", label: "Now", view: "work" },
+	{ href: "/_board/library", id: "documents-open", label: "Library", view: "library" },
+	{ href: "/_board/system", id: "diagnostics-open", label: "System", view: "system" },
+] as const;

package/src/client/reconcile/normalized.ts

@@ -0,0 +1,46 @@
+export function flash(element: Element) {
+	if (element.matches("[data-modified]") || !element.matches("p, li, pre, blockquote, h1, h2, h3, h4, h5, h6, .item, .notes, .metadata-panel")) {
+		return;
+	}
+	element.setAttribute("data-live-change", "");
+	setTimeout(() => element.removeAttribute("data-live-change"), 2500);
+}
+export function normalized(element: Element) {
+	const copy = element.cloneNode(true);
+	if (!(copy instanceof Element)) {
+		throw new Error("Expected an element");
+	}
+	for (const form of [copy, ...copy.querySelectorAll("#response-form, #handoff-form")]) {
+		if (form.id === "response-form" || form.id === "handoff-form") {
+			form.replaceChildren();
+			form.removeAttribute("data-bound");
+		}
+	}
+	for (const tool of copy.querySelectorAll("[data-visual-tools], [data-image-error], [data-diagram-error]")) {
+		tool.remove();
+	}
+	for (const node of [copy, ...copy.querySelectorAll("*")]) {
+		normalizeNode(node);
+	}
+	return copy.outerHTML;
+}
+function normalizeNode(node: Element) {
+	node.removeAttribute("data-live-change");
+	if (node.tagName === "DETAILS") {
+		node.removeAttribute("open");
+	}
+	if (node.matches("figure.diagram")) {
+		node.querySelector(".diagram-svg")?.remove();
+		node.setAttribute("data-state", "pending");
+		node.removeAttribute("data-error");
+	}
+	if (node.matches("[data-modified]")) {
+		node.textContent = "";
+	}
+	if (node.matches("img[data-local-image]")) {
+		node.setAttribute("src", node.getAttribute("data-local-image") ?? "");
+		for (const attribute of ["tabindex", "role", "aria-label"]) {
+			node.removeAttribute(attribute);
+		}
+	}
+}

package/src/client/responses/answerRecovery.ts

@@ -0,0 +1,37 @@
+import { Schema } from "effect";
+import type { ResponseInput } from "./formSchema.ts";
+
+export const AnswerRecovery = Schema.Union([
+	Schema.String,
+	Schema.Struct({
+		contexts: Schema.Array(Schema.Struct({ context: Schema.String, text: Schema.String })),
+		legacy: Schema.optionalKey(Schema.String),
+	}),
+	Schema.Undefined,
+]);
+type Recovery = typeof AnswerRecovery.Encoded;
+const HEADING = "Earlier template answers (selections cleared; review before choosing again):";
+
+export function answerRecovery(draft: Pick<ResponseInput, "answers" | "question" | "revision" | "recovery">, same: boolean): Recovery {
+	if (same || !draft.answers?.some((answer) => answer.selected.length > 0 || answer.text.length > 0)) {
+		return draft.recovery;
+	}
+	const context = JSON.stringify([draft.question, draft.revision]);
+	const text = JSON.stringify(draft.answers, null, 2);
+	const recovered = typeof draft.recovery === "string" ? { contexts: [], legacy: draft.recovery } : (draft.recovery ?? { contexts: [] });
+	const existing = recovered.contexts.some((entry) => entry.context === context);
+	const contexts = existing
+		? recovered.contexts.map((entry) => (entry.context === context ? { context, text } : entry))
+		: [...recovered.contexts, { context, text }];
+	const legacy = recovered.legacy?.replaceAll(`${HEADING}\n${text}\n`, "");
+	return { contexts, ...(legacy ? { legacy } : {}) };
+}
+
+export function recoveryText(recovery: Recovery): string {
+	if (typeof recovery === "string") {
+		return recovery;
+	}
+	return [...(recovery?.contexts ?? []).map((entry) => `${HEADING}\nReviewed context: ${entry.context}\n${entry.text}`), recovery?.legacy ?? ""]
+		.filter(Boolean)
+		.join("\n");
+}

package/src/client/responses/authorLabel.ts

@@ -1,18 +1,18 @@
-export function authorLabel(storage: Storage | undefined, workspace: string | undefined) {
+export function authorLabel(storage: () => Storage, workspace: string | undefined) {
 	const key = `work-board:author:${workspace ?? ""}`;
 	function read(draft: string) {
 		if (draft) {
 			return draft;
 		}
 		try {
-			return storage?.getItem(key)?.slice(0, 200) ?? "";
+			return storage().getItem(key)?.slice(0, 200) ?? "";
 		} catch {
 			return "";
 		}
 	}
 	function save(value: string) {
 		try {
-			storage?.setItem(key, value.slice(0, 200));
+			storage().setItem(key, value.slice(0, 200));
 			return true;
 		} catch {
 			return false;

package/src/client/responses/failure.ts

@@ -0,0 +1,13 @@
+import { Schema } from "effect";
+import { InternalServerError } from "@shivaedev/platform/errors/taxonomy.ts";
+import { PublicationUncertain, ResponseRejection } from "#rpc/rejections.ts";
+export function responseFailure(error: unknown) {
+	const outcome =
+		Schema.is(ResponseRejection)(error) && !(error instanceof PublicationUncertain) && !(error instanceof InternalServerError)
+			? "rejected"
+			: "uncertain";
+	return {
+		outcome,
+		text: `${outcome === "rejected" ? "Rejected" : "Uncertain"}: ${String(error)}. Draft retained. Preview and retry with the same identity; saved content will be reconciled.`,
+	};
+}

package/src/client/responses/formSchema.ts

@@ -1,10 +1,13 @@
 import { Schema } from "effect";
 import { DraftInput, ResponseKind, Revision } from "#browser/responses/schema.ts";
+import { AnswerRecovery } from "./answerRecovery.ts";
 
 export function responseFormSchema(hasPrompts: boolean) {
 	return Schema.Struct({
 		...DraftInput.fields,
+		answerContext: Schema.optional(Schema.String),
 		body: hasPrompts ? DraftInput.fields.body : DraftInput.fields.body.check(Schema.isMinLength(1)),
+		recovery: Schema.optionalKey(AnswerRecovery),
 		revision: Revision,
 		type: Schema.String.pipe(Schema.decodeTo(ResponseKind)),
 	}).check(
@@ -21,3 +24,4 @@ export function responseFormSchema(hasPrompts: boolean) {
 }
 
 export type ResponseSubmission = ReturnType<typeof responseFormSchema>["Type"];
+export type ResponseInput = ReturnType<typeof responseFormSchema>["Encoded"];

package/src/client/responses/preview.ts

@@ -1,7 +1,7 @@
 import { answerBody } from "#browser/responses/answerBody.ts";
 import type { Prompt } from "#browser/responses/Prompt.ts";
-import type { Draft } from "./drafts.ts";
+import type { ResponseInput } from "./formSchema.ts";
 
-export function responsePreview(draft: Draft, question: string, prompts: readonly Prompt[] = []): string {
+export function responsePreview(draft: ResponseInput, question: string, prompts: readonly Prompt[] = []): string {
 	return `New file: responses/${draft.id}.md\nRegistration (if needed): responses/${question}.md\nRecorded time is assigned by the server when saving.\n\n---\n${JSON.stringify({ id: draft.id, kind: "response", response: { answers: draft.answers, author: draft.author, question, reviewedRevision: draft.revision, supersedes: draft.supersedes, type: draft.type } }, null, 2)}\n---\n${draft.answers ? answerBody(prompts, draft.answers, draft.body) : draft.body}`;
 }

package/src/client/responses/retainContext.ts

@@ -0,0 +1,15 @@
+import type { Form } from "@shivaedev/effect-form/shape.ts";
+import type { ResponseSubmission, responseFormSchema } from "./formSchema.ts";
+
+type ResponseForm = Form<ReturnType<typeof responseFormSchema>["fields"], ResponseSubmission, unknown, never>;
+export function retainContext(form: ResponseForm, saved: ResponseSubmission) {
+	if (form.values.value.id) {
+		return;
+	}
+	form.change("id", `response.${crypto.randomUUID()}`);
+	form.change("question", saved.question);
+	form.change("revision", saved.revision);
+	if (!form.values.value.answerContext) {
+		form.change("answerContext", saved.answerContext);
+	}
+}

package/src/client/responses/summary.ts

@@ -0,0 +1,25 @@
+import type { Prompt } from "#browser/responses/Prompt.ts";
+import type { PromptAnswer } from "#browser/responses/schema.ts";
+import type { ResponseInput } from "./formSchema.ts";
+export function responseSummary(values: ResponseInput, prompts: readonly Prompt[], answers: readonly PromptAnswer[] | undefined, attempted = true) {
+	if (!attempted) {
+		return "";
+	}
+	const missing =
+		values.type === "answer"
+			? prompts.filter((prompt) => {
+					const answer = answers?.find((entry) => entry.prompt === prompt.id);
+					return !(answer?.text.trim() || answer?.selected.length);
+				})
+			: [];
+	return [
+		values.author.trim() ? "" : "Add your local author label.",
+		missing.length > 0 ? `Unanswered prompts: ${missing.map((prompt) => `Question ${prompts.indexOf(prompt) + 1} · ${prompt.id}`).join("; ")}.` : "",
+	]
+		.filter(Boolean)
+		.join(" ");
+}
+
+export function responseFeedback(status: string, outcome: string | undefined, summary: string) {
+	return outcome || status.startsWith("Draft cleared") ? status : summary || status;
+}

package/src/client/sourceChanged.ts

@@ -0,0 +1,3 @@
+export function sourceChanged() {
+	return "Source changed since this draft. Your text is retained; review the new source and preview to bind it to this revision.";
+}

package/src/diagnostics/daemonContract.ts

@@ -1,8 +1,9 @@
 import { Schema } from "effect";
 import { contract } from "@shivaedev/effect-contract/contract.ts";
 import { query } from "@shivaedev/effect-contract/operation.ts";
+import { CodexLimits, GithubLimits } from "#browser/diagnostics/schema.ts";
+import { FleetItems } from "./fleetItems.ts";
 import { FleetHealth } from "./health.ts";
-import { CodexLimits, GithubLimits } from "./source.ts";
 
 const Timestamp = Schema.Number.check(Schema.isFinite(), Schema.isGreaterThanOrEqualTo(0), Schema.isLessThanOrEqualTo(8_640_000_000_000_000));
 
@@ -21,7 +22,10 @@ export const DiagnosticsSnapshot = Schema.Struct({
 export type DiagnosticsSnapshot = typeof DiagnosticsSnapshot.Type;
 
 export const DiagnosticsContract = contract("daemon", {
-	queries: [query("diagnostics", { payload: {}, reads: () => [], success: DiagnosticsSnapshot })],
+	queries: [
+		query("diagnostics", { payload: {}, reads: () => [], success: DiagnosticsSnapshot }),
+		query("fleetItems", { payload: {}, reads: () => [], success: FleetItems }),
+	],
 });
 export const DAEMON_RPC_PATH = "/_fleet/rpc";
 export const DAEMON_PORT = 3457;

package/src/diagnostics/fleetItems.ts

@@ -0,0 +1,26 @@
+import { Schema } from "effect";
+
+export const FleetStage = Schema.Literals([
+	"prepared",
+	"executing",
+	"adopting",
+	"reviewing",
+	"repairing",
+	"validating",
+	"delivering",
+	"completed",
+	"needs-human",
+	"released",
+]);
+export const FleetTimestamp = Schema.Number.check(Schema.isFinite(), Schema.isGreaterThanOrEqualTo(0));
+export const FleetItem = Schema.Struct({
+	attentionOwner: Schema.optional(Schema.Literals(["maintainer", "orchestrator", "automation"])),
+	prUrl: Schema.optional(Schema.String),
+	stage: FleetStage,
+	stageEnteredAt: Schema.NullOr(FleetTimestamp),
+	updatedAt: Schema.NullOr(FleetTimestamp),
+	workId: Schema.String,
+});
+export const CompletedFleetItem = Schema.Struct({ ...FleetItem.fields, completedAt: FleetTimestamp, stage: Schema.Literal("completed") });
+export const FleetItems = Schema.Struct({ completed: Schema.Array(CompletedFleetItem), items: Schema.Array(FleetItem) });
+export type FleetItems = typeof FleetItems.Type;

package/src/diagnostics/source.ts

@@ -1,5 +1,6 @@
 import { Clock, Context, Effect, Schema } from "effect";
 import { defineService } from "@shivaedev/effect-service/define-service.ts";
+import * as limits from "#browser/diagnostics/schema.ts";
 import type { FleetHealth } from "./health.ts";
 
 export class SourceFailure extends Schema.TaggedError<SourceFailure>()("SourceFailure", {
@@ -7,19 +8,11 @@ export class SourceFailure extends Schema.TaggedError<SourceFailure>()("SourceFa
 	message: Schema.String,
 }) {}
 
-export const UsageWindow = Schema.Struct({
-	resetsAt: Schema.NullOr(Schema.Int.check(Schema.isGreaterThanOrEqualTo(0), Schema.isLessThanOrEqualTo(8_640_000_000_000))),
-	usedPercent: Schema.Number.check(Schema.isFinite(), Schema.isGreaterThanOrEqualTo(0)),
-	windowDurationMins: Schema.NullOr(Schema.Int.check(Schema.isGreaterThan(0))),
-});
-export type UsageWindow = typeof UsageWindow.Type;
-export const CodexLimits = Schema.Struct({ primary: Schema.NullOr(UsageWindow), secondary: Schema.NullOr(UsageWindow) });
+export const { CodexLimits, GithubLimits, GithubWindow, UsageWindow } = limits;
 export type CodexLimits = typeof CodexLimits.Type;
-const Count = Schema.Int.check(Schema.isGreaterThanOrEqualTo(0));
-export const GithubWindow = Schema.Struct({ limit: Count, remaining: Count, reset: Count.check(Schema.isLessThanOrEqualTo(8_640_000_000_000)) });
-export type GithubWindow = typeof GithubWindow.Type;
-export const GithubLimits = Schema.Struct({ core: GithubWindow, graphql: GithubWindow });
 export type GithubLimits = typeof GithubLimits.Type;
+export type GithubWindow = typeof GithubWindow.Type;
+export type UsageWindow = typeof UsageWindow.Type;
 export type Source<A> = Effect.Effect<A, SourceFailure>;
 export interface Sources {
 	readonly codex: Source<CodexLimits>;
@@ -28,9 +21,7 @@ export interface Sources {
 }
 export class DiagnosticsSources extends Context.Service<DiagnosticsSources, Sources>()("WorkBoard/DiagnosticsSources") {}
 
-export type Observation<A> =
-	| { readonly state: "ready"; readonly observedAt: number; readonly value: A }
-	| { readonly state: "not-configured" | "error"; readonly observedAt: number; readonly cause: string };
+export type Observation<A> = limits.Observation<A>;
 
 export const observe = Effect.fn("WorkBoard.observe")(function* <A>(source: Source<A>): Generator<Effect.Effect<unknown>, Observation<A>, never> {
 	const result = yield* Effect.result(source);

package/src/metadata/schema.ts

@@ -43,7 +43,9 @@ export const Metadata = Schema.Struct({
 	handoff: Schema.optional(HandoffRecord),
 	id: Schema.optional(Identity),
 	items: Schema.optional(Schema.Array(Identity)),
-	kind: Schema.optional(Schema.Literals(["task", "investigation", "decision", "result", "project", "board", "question", "response", "handoff"])),
+	kind: Schema.optional(
+		Schema.Literals(["task", "investigation", "decision", "result", "project", "board", "question", "response", "handoff", "goal", "report"]),
+	),
 	nextAction: Schema.optional(Text),
 	options: Schema.optional(
 		Schema.Array(Schema.Struct({ description: Text.check(Schema.isMaxLength(8192)), label: Text.check(Schema.isMaxLength(128)) })).check(

package/src/render/visual.ts

@@ -42,7 +42,9 @@ function metric(node: ContainerDirective) {
 	if (!provenance(node)) {
 		throw new BadRequest({ message: "Name a source with a Source: Markdown link." });
 	}
-	node.children.splice(1, 0, paragraph(value === undefined || value === "unknown" ? "Not recorded" : `${value} ${unit}`, "visual-value"));
+	if (typeof value === "number") {
+		node.children.splice(1, 0, paragraph(`${value} ${unit}`, "visual-value"));
+	}
 }
 
 function progress(node: ContainerDirective, label: string) {
@@ -54,11 +56,11 @@ function progress(node: ContainerDirective, label: string) {
 	if (known && completed > total) {
 		throw new BadRequest({ message: "Completed count exceeds total. Reduce completed or correct total." });
 	}
-	function display(value: number | "unknown" | undefined) {
-		return typeof value === "number" ? String(value) : "Not recorded";
+	if (!known) {
+		return;
 	}
-	const tally = `Recorded tally: ${display(completed)} of ${display(total)}`;
-	node.children.splice(1, 0, paragraph(tally + (known && total > 0 ? "" : ". Percentage unavailable."), "visual-value"));
+	const tally = `Recorded tally: ${completed} of ${total}`;
+	node.children.splice(1, 0, paragraph(tally, "visual-value"));
 	if (known && total > 0) {
 		node.children.splice(2, 0, {
 			children: [{ type: "text", value: tally }],

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,67 +2,87 @@ 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 { HistoryInput, HistoryOutput } from "#history/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, 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 Page = Schema.Struct({ html: Schema.String, status: Schema.Number });
 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,
 });
-const ReadPage = query("page", { payload: { url: PageUrl }, reads: ({ url }) => pageKeys(url), rejections: { InternalServerError }, success: Page });
 const ReadDocument = query("document", {
 	payload: { url: PageUrl },
 	reads: ({ url }) => [...pageKeys(url), index.list],
 	rejections: documentRejections,
 	success: Document,
 });
+const ReadBoard = query("board", {
+	payload: { url: PageUrl },
+	reads: ({ url }) => pageKeys(url),
+	rejections: documentRejections,
+	success: BoardProjection,
+});
+const ReadWork = query("work", {
+	payload: { url: PageUrl },
+	reads: () => [workspace.list, index.list],
+	rejections: documentRejections,
+	success: WorkProjection,
+});
+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 },
+	reads: ({ url }) => [...pageKeys(url), index.list],
+	rejections: documentRejections,
+	success: RespondProjection,
+});
+const ReadHandoff = query("handoff", {
+	payload: { url: PageUrl },
+	reads: () => [workspace.list, index.list],
+	rejections: documentRejections,
+	success: HandoffProjection,
+});
+const ReadResult = query("result", {
+	payload: { url: PageUrl },
+	reads: () => [workspace.list, index.list],
+	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,
 });
@@ -72,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 },
@@ -85,7 +99,24 @@ const ReadWatcher = query("watcher", {
 });
 export const Subscribe = stream("subscribe", { reads: () => [workspace.list], rejections: { InternalServerError }, success: LiveHint });
 export const workContract = contract("work-board", {
-	queries: [ReadPage, ReadDocument, ReadNavigation, ReadSearch, ReadHistory, ReadWatcher],
+	queries: [
+		ReadServer,
+		ReadDocument,
+		ReadBoard,
+		ReadWork,
+		ReadInbox,
+		ReadDiagnostics,
+		ReadFleetItems,
+		ReadGoals,
+		ReadStart,
+		ReadRespond,
+		ReadHandoff,
+		ReadResult,
+		ReadNavigation,
+		ReadLibrary,
+		ReadSearch,
+		ReadWatcher,
+	],
 	streams: [Subscribe],
 }).middleware(RequestTracing);
 export const workRpcs = workContract.merge(responseContract).merge(handoffContract);

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));