@shivaedev/work-board 0.13.0 → 0.14.1

package/src/client/react/readingState.ts

@@ -10,7 +10,6 @@ export const ReadingState = Schema.Struct({
 	sidebar: Schema.optional(Schema.Number),
 });
 export type ReadingState = typeof ReadingState.Type;
-const MISSING_PASSAGE = "This passage is no longer in the document.";
 let releaseScroll: (() => void) | undefined;
 function pathOf(node: Node, root: Node) {
 	const path: number[] = [];
@@ -36,7 +35,7 @@ function details(root: Element) {
 	});
 }
 function inForm() {
-	return document.activeElement?.closest("#response-form, #handoff-form");
+	return document.activeElement?.closest("[data-response-form], #response-form, #handoff-form");
 }
 export function captureReading(): ReadingState | undefined {
 	const root = document.getElementById("doc");
@@ -103,31 +102,3 @@ function restoreScroll(scroll: readonly [number, number]) {
 		releaseScroll = undefined;
 	};
 }
-export function scrollToPassage(hash: string) {
-	if (!hash) {
-		window.scrollTo(0, 0);
-		return "";
-	}
-	const target = passageTarget(hash);
-	if (!target) {
-		return MISSING_PASSAGE;
-	}
-	for (let parent = target.parentElement; parent; parent = parent.parentElement) {
-		if (parent instanceof HTMLDetailsElement) {
-			parent.open = true;
-		}
-	}
-	target.scrollIntoView();
-	target.focus({ preventScroll: true });
-	return "";
-}
-export function passageStatus(hash: string) {
-	return !hash || passageTarget(hash) ? "" : MISSING_PASSAGE;
-}
-function passageTarget(hash: string) {
-	try {
-		return document.getElementById(decodeURIComponent(hash.slice(1)));
-	} catch {
-		return null;
-	}
-}

package/src/client/react/remainingRoute.ts

@@ -1,9 +1,11 @@
 export function remainingRoute(pathname: string) {
 	switch (pathname) {
-		case "/_board/changes":
-			return "changes";
-		case "/_board/diagnostics":
-			return "diagnostics";
+		case "/_board/library":
+			return "library";
+		case "/_board/goals":
+			return "goals";
+		case "/_board/system":
+			return "system";
 		case "/_board/start":
 			return "start";
 		case "/_board/respond":

package/src/client/react/retryPage.ts

@@ -0,0 +1,15 @@
+import type * as AtomRegistry from "effect/reactivity/AtomRegistry";
+import { pageQueries } from "./pageQueries.ts";
+import type { ShellApi } from "./ShellApi.ts";
+
+export function retryPage(api: ShellApi, registry: AtomRegistry.AtomRegistry, url: string) {
+	const doc = document.getElementById("doc");
+	const queries = pageQueries(api, doc?.dataset.projection ?? "document", url);
+	if (Number(doc?.dataset.status ?? 200) < 400 && !queries.some((query) => registry.get(query)._tag === "Failure")) {
+		return false;
+	}
+	for (const query of queries) {
+		registry.refresh(query);
+	}
+	return true;
+}

package/src/client/react/scheduleReading.ts

@@ -1,5 +1,6 @@
 import { flushSync } from "react-dom";
-import { type captureReading, passageStatus, restoreReading, scrollToPassage } from "./readingState.ts";
+import { passageStatus, revealPassage, scrollToPassage } from "#client/react/readingPassage.ts";
+import { type captureReading, restoreReading } from "#client/react/readingState.ts";
 export function scheduleReading(
 	doc: HTMLElement,
 	reading: ReturnType<typeof captureReading> | null,
@@ -20,21 +21,25 @@ export function scheduleReading(
 		}
 		restored = true;
 		document.removeEventListener("board-reading-ready", restore);
-		if (focus && !document.activeElement?.closest("#response-form, #handoff-form")) {
+		if (focus && !document.activeElement?.closest("[data-response-form], #response-form, #handoff-form")) {
 			doc.focus({ preventScroll: true });
 		}
 		const passage = hash ? `#${hash}` : "";
 		if (reading) {
 			restoreReading(reading);
-			// Readiness can arrive from a React effect; commit the warning before the next paint.
-			queueMicrotask(() => {
-				if (active()) {
-					flushSync(() => setStatus(passageStatus(passage)));
-				}
-			});
-		} else {
-			setStatus(scrollToPassage(passage));
 		}
+		// Readiness can arrive from a React effect; reveal the target before scrolling or focusing it.
+		queueMicrotask(() => {
+			if (!active()) {
+				return;
+			}
+			flushSync(() => revealPassage(passage));
+			if (reading) {
+				flushSync(() => setStatus(passageStatus(passage)));
+			} else {
+				setStatus(scrollToPassage(passage));
+			}
+		});
 	}
 	document.addEventListener("board-reading-ready", restore);
 	requestAnimationFrame(restore);

package/src/client/react/searchCommands.ts

@@ -1,15 +1,40 @@
+import type { GoalsProjection } from "#browser/views/GoalsProjection.ts";
+
 export interface SearchItem {
 	readonly command?: string;
 	readonly file?: string;
 	readonly href?: string;
+	readonly id?: string | undefined;
+	readonly itemKind?: string | undefined;
 	readonly kind: string;
 	readonly line?: number | undefined;
 	readonly snippet?: string;
+	readonly status?: string | undefined;
 	readonly title: string;
 }
 export const searchCommands: readonly SearchItem[] = [
-	{ href: "/", kind: "command", title: "Open workspace" },
+	{ href: "/", kind: "command", title: "Go to Today" },
+	{ href: "/_board/goals", kind: "command", title: "Go to Goals" },
+	{ href: "/_board/work?view=board", kind: "command", title: "Go to Now" },
+	{ href: "/_board/library", kind: "command", title: "Go to Library" },
+	{ href: "/_board/system", kind: "command", title: "Go to System" },
 	{ command: "sidebar-toggle", kind: "command", title: "Show or hide files" },
 	{ command: "density", kind: "command", title: "Toggle compact density" },
 	{ command: "theme", kind: "command", title: "Toggle light or dark theme" },
 ];
+
+export function goalCommands(goals: GoalsProjection["goals"]): readonly SearchItem[] {
+	return goals.map((goal) => ({
+		href: `/_board/item/${encodeURIComponent(goal.id)}/`,
+		id: goal.id,
+		kind: "command",
+		title: `Go to ${goal.title}`,
+	}));
+}
+export function matchingCommands(goals: GoalsProjection["goals"], query: string): readonly SearchItem[] {
+	const terms = query.normalize("NFKC").toLowerCase().split(/\s+/u).filter(Boolean);
+	return [...searchCommands, ...goalCommands(goals)].filter((item) => {
+		const text = `${item.title} ${item.id ?? ""}`.normalize("NFKC").toLowerCase();
+		return terms.every((term) => text.includes(term));
+	});
+}

package/src/client/react/shellIds.ts

@@ -1,6 +1,5 @@
 export const shellIds = {
 	"breadcrumbs": "breadcrumbs",
-	changesContent: "changes-content",
 	clearSavedViews: "clear-saved-views",
 	"density": "density",
 	"doc": "doc",
@@ -14,9 +13,6 @@ export const shellIds = {
 	handoffPreviewContent: "handoff-preview-content",
 	handoffStatus: "handoff-status",
 	handoffSubmit: "handoff-submit",
-	historyClear: "history-clear",
-	historyMark: "history-mark",
-	historyStorage: "history-storage",
 	"homeOpen": "home-open",
 	"inboxCount": "inbox-count",
 	"inboxOpen": "inbox-open",
@@ -29,6 +25,8 @@ export const shellIds = {
 	"live": "live",
 	"navigationStatus": "navigation-status",
 	openSavedView: "open-saved-view",
+	phoneMore: "phone-more",
+	phoneMoreTitle: "phone-more-title",
 	"preferenceStatus": "preference-status",
 	"primaryNavigation": "primary-navigation",
 	readingLibrary: "reading-library",

package/src/client/react/storedReadings.ts

@@ -0,0 +1,31 @@
+import { Option, Schema } from "effect";
+import { ReadingState } from "./readingState.ts";
+
+const Entries = Schema.Record(Schema.String, ReadingState);
+const Entry = Schema.Struct({ id: Schema.String, reading: Schema.optional(Schema.NullOr(ReadingState)) });
+export function readingEntry(value: unknown) {
+	return Option.getOrUndefined(Schema.decodeUnknownOption(Entry)(value));
+}
+export function storedReadings() {
+	const key = `work-board:reading:${document.documentElement.dataset.workspace}`;
+	let entries: Record<string, ReadingState>;
+	try {
+		entries = Option.getOrElse(Schema.decodeUnknownOption(Entries)(JSON.parse(sessionStorage.getItem(key) ?? "{}")), () => ({}));
+	} catch {
+		entries = {};
+	}
+	return {
+		get: (id: string) => entries[id],
+		save: (id: string, reading: ReadingState) => {
+			delete entries[id];
+			entries[id] = reading;
+			entries = Object.fromEntries(Object.entries(entries).slice(-30));
+			try {
+				sessionStorage.setItem(key, JSON.stringify(entries));
+				return true;
+			} catch {
+				return false;
+			}
+		},
+	};
+}

package/src/client/react/useAppearance.ts

@@ -32,6 +32,7 @@ export function useAppearance() {
 		root.dataset.theme = value.theme;
 		root.dataset.density = value.density;
 		root.dataset.scheme = scheme;
+		root.classList.toggle("dark", scheme === "dark");
 		const doc = document.getElementById("doc");
 		if (doc) {
 			doc.dataset.scheme = scheme;

package/src/client/react/useBoardNavigation.ts

@@ -2,25 +2,27 @@ import { useRouter } from "@tanstack/react-router";
 import { useEffect, useState } from "react";
 import type { RouterShell } from "#client/react/loadBoardPage.ts";
 import { currentEntry, navigationFailure, readingKey, sameReadingLocation } from "#client/react/navigationLocation.ts";
-import { pageQuery } from "#client/react/pageQuery.ts";
 import { readerLink } from "#client/react/readerLink.ts";
-import { readingEntry, readingHistory } from "#client/react/readingHistory.ts";
 import { captureReading } from "#client/react/readingState.ts";
+import { retryPage } from "#client/react/retryPage.ts";
 import { scheduleReading } from "#client/react/scheduleReading.ts";
+import { readingEntry, storedReadings } from "#client/react/storedReadings.ts";
 
 export function useBoardNavigation(shell: RouterShell) {
 	const router = useRouter();
 	const [status, setStatus] = useState("");
 	useEffect(() => {
-		const readings = readingHistory();
+		const readings = storedReadings();
 		const initial = readingEntry(shell.reading ?? window.history.state?.workBoard);
 		const aliases = new Map<string, string>();
 		let displayed = "";
 		let route = "";
 		let hash = "";
 		let failure = "";
+		let interrupted = false;
 		function save() {
 			if (!displayed || document.getElementById("doc")?.dataset.route !== route) {
+				interrupted ||= displayed !== "";
 				return;
 			}
 			const reading = captureReading();
@@ -45,33 +47,23 @@ export function useBoardNavigation(shell: RouterShell) {
 			const key = location.state.key ?? nextRoute;
 			const entry = currentEntry(location.state, displayed, initial);
 			const id = readingKey(key, entry, aliases);
-			if (sameReadingLocation({ hash, id: displayed, route }, { hash: location.hash, id, route: nextRoute })) {
+			if (!interrupted && sameReadingLocation({ hash, id: displayed, route }, { hash: location.hash, id, route: nextRoute })) {
 				return;
 			}
+			interrupted = false;
 			const reading = readings.get(id) ?? entry?.reading;
 			const focus = displayed !== "";
 			displayed = id;
 			route = nextRoute;
 			hash = location.hash;
-			if (shell.client) {
-				recordEntry(router, nextRoute, id);
-			}
+			recordEntry(router, nextRoute, id, shell.client !== undefined);
 			scheduleReading(doc, reading, hash, () => displayed === id && doc.dataset.route === nextRoute, setStatus, focus);
 		}
 		async function open(target: URL) {
 			save();
 			document.dispatchEvent(new Event("board-navigate"));
 			const url = target.pathname + target.search + target.hash;
-			if (url === router.state.location.href && Number(document.getElementById("doc")?.dataset.status ?? 200) >= 400) {
-				const doc = document.getElementById("doc");
-				shell.registry.refresh(
-					pageQuery(
-						shell.api,
-						doc?.dataset.projection ?? "document",
-						target.pathname + target.search,
-						doc?.querySelector<HTMLElement>("[data-baseline]")?.dataset.baseline || null,
-					),
-				);
+			if (url === router.state.location.href && retryPage(shell.api, shell.registry, target.pathname + target.search)) {
 				await router.invalidate();
 			} else if (url !== router.state.location.href) {
 				await router.navigate({ to: url });
@@ -130,7 +122,10 @@ export function useBoardNavigation(shell: RouterShell) {
 	return status;
 }
 
-function recordEntry(router: ReturnType<typeof useRouter>, route: string, id: string) {
+function recordEntry(router: ReturnType<typeof useRouter>, route: string, id: string, native: boolean) {
+	if (!native) {
+		return;
+	}
 	router.history.flush?.();
 	if (window.location.pathname + window.location.search !== route || window.history.state?.workBoard?.id === id) {
 		return;

package/src/client/react/useDiagnosticsPolling.ts

@@ -3,13 +3,16 @@ import type * as Atom from "effect/reactivity/Atom";
 import { useContext, useEffect } from "react";
 import { session } from "#client/entry.ts";
 
-export function useDiagnosticsPolling<A>(atom: Atom.Atom<A>) {
+export function useDiagnosticsPolling<A, TFleet>(atom: Atom.Atom<A>, fleet?: Atom.Atom<TFleet>) {
 	const registry = useContext(RegistryContext);
 	useEffect(() => {
 		function refresh() {
 			const native = session(window);
 			if (!(document.hidden || native.registry.get(native.updates.paused))) {
 				registry.refresh(atom);
+				if (fleet) {
+					registry.refresh(fleet);
+				}
 			}
 		}
 		const timer = setInterval(refresh, 15_000);
@@ -20,5 +23,5 @@ export function useDiagnosticsPolling<A>(atom: Atom.Atom<A>) {
 			document.removeEventListener("board-updates-resumed", refresh);
 			document.removeEventListener("visibilitychange", refresh);
 		};
-	}, [atom, registry]);
+	}, [atom, fleet, registry]);
 }

package/src/client/react/useDocumentPage.ts

@@ -3,7 +3,7 @@ import { flushSync } from "react-dom";
 import type { Document } from "#browser/document/schema.ts";
 import { documentSourceId } from "#client/document/layout.ts";
 import { fileUrl } from "#files/url.ts";
-import type { MainLocation } from "./mainLocation.ts";
+import { displayedLocation, type MainLocation } from "./mainLocation.ts";
 export function useDocumentPage({
 	data,
 	pending,
@@ -25,6 +25,9 @@ export function useDocumentPage({
 		}
 		const main = element;
 		main.dataset.scheme = document.documentElement.dataset.scheme ?? "";
+		if (main.dataset.route !== url) {
+			delete main.dataset.route;
+		}
 		let active = true;
 		let scheduled = false;
 		function announce() {
@@ -69,7 +72,7 @@ function publishPage(main: HTMLElement, data: Document | undefined, status: stri
 	} else {
 		delete main.dataset.identity;
 	}
-	flushSync(() => onPage({ file: data?.file ?? "", view: "" }));
+	flushSync(() => onPage(displayedLocation(main)));
 	main.dataset.route = url;
 	main.dataset.status = status;
 	document.dispatchEvent(new Event("board-page"));

package/src/client/react/useFormFocus.ts

@@ -1,5 +1,5 @@
 import { Schema } from "effect";
-import { useCallback, useEffect, useLayoutEffect, useRef } from "react";
+import { type FocusEvent, useCallback, useEffect, useLayoutEffect, useRef } from "react";
 import { captureFocus, restoreFocus } from "#client/formFocus.ts";
 
 const Selection = Schema.Struct({
@@ -13,18 +13,21 @@ const Selection = Schema.Struct({
 export function useFormFocus(key: string) {
 	const ref = useRef<HTMLFormElement>(null);
 
-	const remember = useCallback(() => {
-		const selection = ref.current && captureFocus(ref.current);
-		if (!selection) {
-			return false;
-		}
-		try {
-			window.localStorage.setItem(`${key}:focus`, JSON.stringify(selection));
-			return true;
-		} catch {
-			return false;
-		}
-	}, [key]);
+	const remember = useCallback(
+		(control: Element | null = document.activeElement) => {
+			const selection = ref.current && captureFocus(ref.current, control);
+			if (!selection) {
+				return false;
+			}
+			try {
+				window.localStorage.setItem(`${key}:focus`, JSON.stringify(selection));
+				return true;
+			} catch {
+				return false;
+			}
+		},
+		[key],
+	);
 	useLayoutEffect(() => {
 		try {
 			const stored: unknown = JSON.parse(window.localStorage.getItem(`${key}:focus`) ?? "null");
@@ -39,8 +42,11 @@ export function useFormFocus(key: string) {
 		};
 	}, [key, remember]);
 	useEffect(() => {
-		window.addEventListener("pagehide", remember);
-		return () => window.removeEventListener("pagehide", remember);
+		function hide() {
+			remember();
+		}
+		window.addEventListener("pagehide", hide);
+		return () => window.removeEventListener("pagehide", hide);
 	}, [remember]);
-	return { onSelect: remember, ref };
+	return { onBlurCapture: (event: FocusEvent<HTMLFormElement>) => remember(event.target), onSelect: () => remember(), ref };
 }

package/src/client/react/useProjectionData.ts

@@ -0,0 +1,26 @@
+import { Cause, Option, Predicate } from "effect";
+import type * as AsyncResult from "effect/reactivity/AsyncResult";
+import type * as Atom from "effect/reactivity/Atom";
+import { useEffect, useState } from "react";
+import { useQuery } from "@shivaedev/effect-react/result-state.ts";
+import type { ProjectionRoute } from "./projectionRoute.ts";
+import type { RemainingRoute } from "./remainingRoute.ts";
+
+type Route = ProjectionRoute | RemainingRoute;
+export function useProjectionData<A, E>(atom: Atom.Atom<AsyncResult.AsyncResult<A, E>>, route: Route, url: string) {
+	const query = useQuery(atom);
+	const fresh = Option.getOrUndefined(query.data);
+	const [retained, setRetained] = useState<{ readonly data: A; readonly route: Route; readonly url: string }>();
+	useEffect(() => {
+		if (fresh !== undefined) {
+			setRetained({ data: fresh, route, url });
+		}
+	}, [fresh, route, url]);
+	const failure = Option.getOrUndefined(Option.flatMap(query.cause, Cause.findErrorOption));
+	const missing = Predicate.isTagged(failure, "NotFound");
+	const conflict = Predicate.isTagged(failure, "Conflict");
+	const terminal = missing || conflict;
+	const data = terminal ? undefined : (fresh ?? (retained?.url === url ? retained.data : undefined));
+	const content = terminal ? undefined : (data ?? (retained?.route === route ? retained.data : undefined));
+	return { conflict, content, data, failure, missing, query };
+}

package/src/client/react/useResponseForm.ts

@@ -11,7 +11,7 @@ import { authorLabel } from "#client/responses/authorLabel.ts";
 import { type ResponseInput, responseFormSchema } from "#client/responses/formSchema.ts";
 import { responsePreview } from "#client/responses/preview.ts";
 import { retainContext } from "#client/responses/retainContext.ts";
-import { responseReadiness, responseSummary } from "#client/responses/summary.ts";
+import { responseFeedback, responseSummary } from "#client/responses/summary.ts";
 import { sourceChanged } from "#client/sourceChanged.ts";
 import { createResponse } from "./createResponse.ts";
 
@@ -22,13 +22,14 @@ export function useResponseForm(source: QuestionPreview, prompts: readonly Promp
 	const [preview, setPreview] = useState<ResponseInput>();
 	const [outcome, setOutcome] = useState<string>();
 	const [status, setStatus] = useState("");
+	const [attempted, setAttempted] = useState(false);
 	const [label] = useState(() =>
 		authorLabel(() => window.localStorage, typeof document === "undefined" ? undefined : document.documentElement.dataset.workspace),
 	);
 	const [initial] = useState<ResponseInput>(() => ({
 		answerContext: undefined,
 		answers: prompts.length > 0 ? prompts.map((prompt) => ({ prompt: prompt.id, selected: [], text: "" })) : undefined,
-		author: label.read(""),
+		author: label.read("") || "maintainer",
 		body: "",
 		id: "",
 		question: "",
@@ -50,14 +51,11 @@ export function useResponseForm(source: QuestionPreview, prompts: readonly Promp
 	const values = useAtomRef(form.values);
 	useEffect(() => {
 		if (Option.isSome(created.created)) {
-			form.receive({ ...initial, author: label.read("") });
+			form.receive({ ...initial, author: label.read("") || "maintainer" });
 			if (created.dirty) {
 				retainContext(form, created.created.value);
 			}
 		}
-		for (const name of ["answerContext", "answers", "author", "body", "id", "question", "recovery", "revision", "supersedes", "type"] as const) {
-			form.blur(name);
-		}
 	}, [form, created.created, created.dirty, initial, label]);
 	modelRef.current = values;
 	const same = values.question === source.id && values.revision === source.reviewedRevision;
@@ -87,7 +85,8 @@ export function useResponseForm(source: QuestionPreview, prompts: readonly Promp
 		form.change("answerContext", JSON.stringify([source.id, source.reviewedRevision]));
 		edit();
 	}
-	function bind() {
+	function showPreview() {
+		setOutcome(undefined);
 		if (!form.values.value.id || form.values.value.question !== source.id || form.values.value.revision !== source.reviewedRevision) {
 			form.change("id", `response.${crypto.randomUUID()}`);
 		}
@@ -95,6 +94,11 @@ export function useResponseForm(source: QuestionPreview, prompts: readonly Promp
 		form.change("answerContext", JSON.stringify([source.id, source.reviewedRevision]));
 		form.change("question", source.id);
 		form.change("revision", source.reviewedRevision);
+		for (const name of ["answerContext", "answers", "author", "body", "id", "question", "recovery", "revision", "supersedes", "type"] as const) {
+			form.blur(name);
+		}
+		setPreview(form.values.value);
+		setStatus("");
 	}
 	function edit() {
 		if (!form.values.value.id) {
@@ -109,26 +113,23 @@ export function useResponseForm(source: QuestionPreview, prompts: readonly Promp
 			setStatus("");
 		}
 	}
-	function showPreview() {
-		setOutcome(undefined);
-		bind();
-		for (const name of ["answerContext", "answers", "author", "body", "id", "question", "recovery", "revision", "supersedes", "type"] as const) {
-			form.blur(name);
-		}
-		setPreview(form.values.value);
-		setStatus("");
-	}
 	function clear() {
+		setAttempted(false);
 		setOutcome(undefined);
 		created.revert();
 		setPreview(undefined);
 		setStatus("Draft cleared. Saved responses are unchanged.");
 	}
-	const valid = Schema.is(schema)(values);
 	const previewed = preview !== undefined && same && Equal.equals(preview, values);
-	const summary = responseSummary(values, prompts, answers(values));
+	const summary = responseSummary(values, prompts, answers(values), attempted);
 	return {
 		answers: answers(values),
+		attempt: () => {
+			setAttempted(true);
+			showPreview();
+			return Schema.is(schema)(form.values.value);
+		},
+		attempted,
 		clear,
 		created,
 		draft,
@@ -139,9 +140,6 @@ export function useResponseForm(source: QuestionPreview, prompts: readonly Promp
 		preview: previewed ? responsePreview(values, source.id, prompts) : undefined,
 		recovery: recoveryText(recovery),
 		showPreview,
-		status: [stale ? sourceChanged() : "", outcome || status.startsWith("Draft cleared") ? status : summary || responseReadiness(valid, previewed)]
-			.filter(Boolean)
-			.join(" "),
-		valid,
+		status: [stale ? sourceChanged() : "", responseFeedback(status, outcome, summary)].filter(Boolean).join(" "),
 	};
 }

package/src/client/react/useVirtualRows.ts

@@ -0,0 +1,14 @@
+import { type UIEvent, useState } from "react";
+
+export function useVirtualRows(count: number, rowHeight: number, enabled = count > 200) {
+	const [scroll, setScroll] = useState({ height: 600, top: 0 });
+	const start = enabled ? Math.min(Math.floor(scroll.top / rowHeight), Math.max(0, count - 1)) : 0;
+	const end = enabled ? Math.min(count, start + Math.ceil(scroll.height / rowHeight) + 4) : count;
+	return {
+		bottom: (count - end) * rowHeight,
+		end,
+		onScroll: (event: UIEvent<HTMLElement>) => setScroll({ height: event.currentTarget.clientHeight, top: event.currentTarget.scrollTop }),
+		start,
+		top: start * rowHeight,
+	};
+}

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/responses/summary.ts

@@ -1,7 +1,10 @@
 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) {
+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) => {
@@ -17,9 +20,6 @@ export function responseSummary(values: ResponseInput, prompts: readonly Prompt[
 		.join(" ");
 }
 
-export function responseReadiness(valid: boolean, previewed: boolean) {
-	if (!valid) {
-		return "This draft is invalid. Review the response fields before recording.";
-	}
-	return previewed ? "Preview ready. Record this response when you are ready." : "Draft ready. Preview the Markdown before recording it.";
+export function responseFeedback(status: string, outcome: string | undefined, summary: string) {
+	return outcome || status.startsWith("Draft cleared") ? status : summary || status;
 }

package/src/diagnostics/daemonContract.ts

@@ -2,6 +2,7 @@ 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";
 
 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;