@shivaedev/work-board 0.13.0 → 0.14.1

package/src/client/react/HistoryRetention.tsx

@@ -1,29 +0,0 @@
-import { Option } from "effect";
-import { useEffect, useState } from "react";
-import { useQuery } from "@shivaedev/effect-react/result-state.ts";
-import { historyStore } from "./historyStore.ts";
-import type { ShellApi } from "./ShellApi.ts";
-
-export function HistoryRetention({ api }: { readonly api: ShellApi }) {
-	const [store] = useState(historyStore);
-	const [baseline, setBaseline] = useState(store.read);
-	const query = useQuery(api.history.query({ action: "check", baseline }));
-	const data = Option.getOrUndefined(query.data);
-	useEffect(() => {
-		if (data?.discardBaseline && store.read() === baseline) {
-			store.write(null);
-			setBaseline(null);
-			document.documentElement.dataset.historyNotice = data.reason;
-		}
-	}, [baseline, data, store]);
-	useEffect(() => {
-		function sync(event: StorageEvent) {
-			if (event.key === store.key || event.key === null) {
-				setBaseline(store.read());
-			}
-		}
-		window.addEventListener("storage", sync);
-		return () => window.removeEventListener("storage", sync);
-	}, [store]);
-	return null;
-}

package/src/client/react/InboxPage.tsx

@@ -1,51 +0,0 @@
-import type { InboxProjection } from "#browser/views/schema.ts";
-import { Age } from "./Age.tsx";
-export function InboxPage({ data }: { readonly data: InboxProjection }) {
-	return (
-		<>
-			<header className="work-head">
-				<p className="work-eyebrow">WORKSPACE · INBOX</p>
-				<h1>Inbox</h1>
-				<p>Questions and work waiting on a person. Oldest changed source first.</p>
-			</header>
-			<p className="work-total" role="status">
-				{data.complete ? `${data.items.length} waiting` : "Count unavailable"}
-			</p>
-			<section aria-label="Waiting on you" className="inbox-list">
-				<h2>Waiting on you</h2>
-				<InboxContent data={data} />
-			</section>
-		</>
-	);
-}
-function InboxContent({ data }: { readonly data: InboxProjection }) {
-	if (!data.complete) {
-		return <p role="status">Workspace incomplete. Inbox membership and count are unavailable.</p>;
-	}
-	if (data.items.length === 0) {
-		return (
-			<p className="empty">
-				{data.sourceIssues ? "No classified waiting items. Check source issues in Overview." : "All quiet — nothing is waiting on a person."}
-			</p>
-		);
-	}
-	return data.items.map((item) => <InboxRow item={item} key={item.file} />);
-}
-function InboxRow({ item }: { readonly item: InboxProjection["items"][number] }) {
-	return (
-		<article className="inbox-row">
-			<div>
-				<h3>
-					<a href={item.href}>{item.title}</a>
-				</h3>
-				<p>{item.reason}</p>
-				{Boolean(item.problem) && (
-					<p className="inbox-problem" role="status">
-						{item.problem} — open the source to resolve it.
-					</p>
-				)}
-			</div>
-			<p className="inbox-age">{item.modified === undefined ? "Age unavailable" : <Age modified={item.modified} />}</p>
-		</article>
-	);
-}

package/src/client/react/NavigationTree.tsx

@@ -1,64 +0,0 @@
-import { useEffect, useRef } from "react";
-import type { Navigation, NavigationFile, NavigationFolder } from "#browser/navigation/schema.ts";
-import { Age } from "./Age.tsx";
-
-function Files({ files, current }: { readonly files: readonly NavigationFile[]; readonly current: string }) {
-	return files.map((file) => (
-		<li key={file.path}>
-			<a aria-current={file.path === current ? "page" : undefined} href={file.href}>
-				{file.name}
-			</a>
-			<Age modified={file.modified} short />
-		</li>
-	));
-}
-function Folder({ folder, current }: { readonly folder: NavigationFolder; readonly current: string }) {
-	const ref = useRef<HTMLDetailsElement>(null);
-	useEffect(() => {
-		if (current.startsWith(`${folder.path}/`) && ref.current) {
-			ref.current.open = true;
-		}
-	}, [current, folder.path]);
-	return (
-		<li className="file-folder">
-			<details data-key={`folder:${folder.path}`} ref={ref}>
-				<summary>
-					{folder.name}/ ({folder.count})
-				</summary>
-				<Tree current={current} folder={folder} />
-			</details>
-		</li>
-	);
-}
-function Tree({ folder, count, current }: { readonly folder: NavigationFolder; readonly count?: string; readonly current: string }) {
-	return (
-		<ul data-inbox-count={count}>
-			<Files current={current} files={folder.files} />
-			{folder.folders.map((child) => (
-				<Folder current={current} folder={child} key={child.path} />
-			))}
-		</ul>
-	);
-}
-export function NavigationTree({ data, current }: { readonly data: Navigation; readonly current: string }) {
-	const recordsRef = useRef<HTMLDetailsElement>(null);
-	const activeRecord = data.records.files.find((file) => file.path === current)?.path;
-	useEffect(() => {
-		if (activeRecord && recordsRef.current) {
-			recordsRef.current.open = true;
-		}
-	}, [activeRecord]);
-	return (
-		<>
-			<Tree count={String(data.inboxCount ?? "?")} current={current} folder={data.tree} />
-			{data.records.count > 0 && (
-				<details data-key="fleet-records" ref={recordsRef}>
-					<summary>Fleet records ({data.records.count})</summary>
-					<ul>
-						<Files current={current} files={data.records.files} />
-					</ul>
-				</details>
-			)}
-		</>
-	);
-}

package/src/client/react/OverviewGroups.tsx

@@ -1,61 +0,0 @@
-import type { OverviewProjection } from "#browser/views/schema.ts";
-import { fileUrl } from "#files/url.ts";
-
-const groups = [
-	{ empty: "No open decision requests.", kind: "decision", title: "Decisions" },
-	{ empty: "No open review requests.", kind: "review", title: "Reviews" },
-	{ empty: "No open blocker requests.", kind: "blocker", title: "Blockers" },
-];
-export function OverviewGroups({ entries }: { readonly entries: OverviewProjection["entries"] }) {
-	return (
-		<div className="attention-groups">
-			{groups.map((group) => (
-				<Group entries={entries.filter((entry) => entry.kind === group.kind)} group={group} key={group.kind} />
-			))}
-		</div>
-	);
-}
-function Group({ entries, group }: { readonly entries: OverviewProjection["entries"]; readonly group: (typeof groups)[number] }) {
-	return (
-		<section aria-labelledby={`attention-${group.kind}`} className="attention-group">
-			<h2 id={`attention-${group.kind}`} tabIndex={-1}>
-				{group.title}
-				<span>{entries.length}</span>
-			</h2>
-			{entries.length === 0 ? (
-				<p className="empty">{group.empty}</p>
-			) : (
-				entries.map((entry) => <Card entry={entry} key={`${entry.itemId}:${entry.id}`} />)
-			)}
-		</section>
-	);
-}
-function Card({ entry }: { readonly entry: OverviewProjection["entries"][number] }) {
-	const links = entry.unblocks.map((link, index) => (
-		<span key={link.label}>
-			{index > 0 && ", "}
-			{link.href ? <a href={link.href}>{link.label}</a> : link.label}
-		</span>
-	));
-	return (
-		<article className="attention-card" data-attention-item={entry.itemId} data-request={entry.id}>
-			<p className="work-kind">{entry.kind} request</p>
-			<h3>
-				<a href={entry.href}>{entry.title}</a>
-			</h3>
-			<p className="work-id">
-				{entry.itemId} / {entry.id}
-			</p>
-			<p className="attention-reason">{entry.reason}</p>
-			<dl>
-				<dt>Response needed from</dt>
-				<dd>{entry.responseFrom.join(", ")}</dd>
-				<dt>Recorded to unblock</dt>
-				<dd>{links}</dd>
-			</dl>
-			<a className="attention-source" href={`${fileUrl(entry.file)}#attention-request-${encodeURIComponent(entry.id)}`}>
-				Source: {entry.file}:{entry.line}
-			</a>
-		</article>
-	);
-}

package/src/client/react/OverviewPage.tsx

@@ -1,68 +0,0 @@
-import type { OverviewProjection } from "#browser/views/schema.ts";
-import { fileUrl } from "#files/url.ts";
-import { keyed } from "./keyed.ts";
-import { OverviewGroups } from "./OverviewGroups.tsx";
-
-export function OverviewPage({ data }: { readonly data: OverviewProjection }) {
-	let summary = data.inboxCount > 0 ? "No explicit open attention requests recorded." : "All quiet — no explicit open requests recorded.";
-	if (data.entries.length > 0) {
-		summary = `${data.entries.length} validated open request${data.entries.length === 1 ? "" : "s"}`;
-	} else if (data.issues.length > 0) {
-		summary = "No validated open requests. Check unresolved source issues before treating this workspace as quiet.";
-	}
-	const issues = data.issues.length > 0 && (
-		<details className="view-issues">
-			<summary>Unclassified requests and source issues ({data.issues.length})</summary>
-			<p>Ambiguous or invalid requests stay outside the queues. Read their original sources.</p>
-			<ul>
-				{keyed(data.issues, (issue) => `${issue.file}:${issue.line}:${issue.message}`).map(({ key, value: issue }) => (
-					<li key={key}>
-						<a href={fileUrl(issue.file)}>
-							{issue.file}:{issue.line}
-						</a>{" "}
-						— {issue.message}
-					</li>
-				))}
-			</ul>
-		</details>
-	);
-	return (
-		<>
-			<header className="work-head">
-				<p className="work-eyebrow">WORKSPACE · OVERVIEW</p>
-				<h1>What needs a response?</h1>
-				<p>Choose a recorded request to read its context, reasoning and evidence.</p>
-				<a href="/_board/work?view=board">Browse all work</a>
-			</header>
-			{data.complete ? (
-				<>
-					<section aria-label="Inbox summary">
-						<h2>Inbox</h2>
-						<p>
-							{data.inboxCount} waiting · <a href="/_board/inbox">Open Inbox</a>
-						</p>
-					</section>
-					<p className="attention-total" role="status">
-						{summary}
-					</p>
-					<p className="attention-order">
-						Decisions, reviews, then blockers. Within each group: source title, item ID, request ID. Recipients are recorded labels.
-					</p>
-					{issues}
-					<OverviewGroups entries={data.entries} />
-					<p className="attention-footnote">
-						These are authored requests. Closing one does not verify evidence or record an answer. The Inbox also shows human-owned next actions and
-						questions; file activity and finished runs do not create requests.
-					</p>
-				</>
-			) : (
-				<>
-					<p className="attention-incomplete" role="status">
-						Workspace incomplete. Could not read {data.unavailable.join(", ")}. Requests are not counted or classified until the index is complete.
-					</p>
-					{issues}
-				</>
-			)}
-		</>
-	);
-}

package/src/client/react/historyStore.ts

@@ -1,56 +0,0 @@
-const stores = new WeakMap<Document, Map<string, ReturnType<typeof createStore>>>();
-export function historyStore() {
-	const key = `work-board:changes:${document.documentElement.dataset.workspace}`;
-	let workspace = stores.get(document);
-	if (!workspace) {
-		workspace = new Map();
-		stores.set(document, workspace);
-	}
-	let store = workspace.get(key);
-	if (!store) {
-		store = createStore(key);
-		workspace.set(key, store);
-	}
-	return store;
-}
-function createStore(key: string) {
-	let memory: string | null | undefined;
-	let notice = "";
-	function read() {
-		if (memory !== undefined) {
-			return memory;
-		}
-		try {
-			return window.localStorage.getItem(key);
-		} catch {
-			memory = null;
-			notice = "Browser storage unavailable; history applies to this page only.";
-			return memory;
-		}
-	}
-	function write(raw: string | null) {
-		memory = raw;
-		try {
-			if (raw === null) {
-				window.localStorage.removeItem(key);
-			} else {
-				window.localStorage.setItem(key, raw);
-			}
-			memory = undefined;
-			notice = "";
-		} catch {
-			notice =
-				raw === null
-					? "Cleared for this page, but browser storage could not be cleared. Reload may restore older data."
-					: "Snapshot remembered for this page only; browser storage is unavailable.";
-			if (raw !== null) {
-				try {
-					window.localStorage.removeItem(key);
-				} catch {
-					notice += " Reload may restore older data.";
-				}
-			}
-		}
-	}
-	return { key, notice: () => notice, read, write };
-}

package/src/client/react/pageQuery.ts

@@ -1,38 +0,0 @@
-import type * as AsyncResult from "effect/reactivity/AsyncResult";
-import type * as Atom from "effect/reactivity/Atom";
-import { routeQueryOptions } from "#client/page/routeQuery.ts";
-import type { ShellApi } from "./ShellApi.ts";
-
-export function pageQuery(api: ShellApi, kind: string, url: string, baseline: string | null): Atom.Atom<AsyncResult.AsyncResult<unknown, unknown>> {
-	if (kind === "changes") {
-		return api.history.query({ action: "compare", baseline });
-	}
-	if (kind === "overview") {
-		return api.overview.query(undefined, routeQueryOptions);
-	}
-	if (kind === "inbox") {
-		return api.inbox.query(undefined, routeQueryOptions);
-	}
-	if (kind === "start") {
-		return api.start.query(undefined, routeQueryOptions);
-	}
-	if (kind === "diagnostics") {
-		return api.diagnostics.query(undefined, routeQueryOptions);
-	}
-	if (kind === "work") {
-		return api.work.query({ url }, routeQueryOptions);
-	}
-	if (kind === "board") {
-		return api.board.query({ url }, routeQueryOptions);
-	}
-	if (kind === "respond") {
-		return api.respond.query({ url }, routeQueryOptions);
-	}
-	if (kind === "handoff") {
-		return api.handoff.query({ url }, routeQueryOptions);
-	}
-	if (kind === "result") {
-		return api.result.query({ url }, routeQueryOptions);
-	}
-	return api.document.query({ url }, routeQueryOptions);
-}

package/src/client/react/readingHistory.ts

@@ -1,31 +0,0 @@
-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 readingHistory() {
-	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/readingLibrary.ts

@@ -1,22 +0,0 @@
-import { Option, Schema } from "effect";
-import { createContext } from "react";
-
-const Item = Schema.Struct({ file: Schema.NonEmptyString, title: Schema.String });
-export type Item = typeof Item.Type;
-const Saved = Schema.Struct({ favorites: Schema.optional(Schema.Unknown), recents: Schema.optional(Schema.Unknown) });
-function valid(value: unknown): Item[] {
-	return Array.isArray(value) ? value.flatMap((entry) => Option.toArray(Schema.decodeUnknownOption(Item)(entry))) : [];
-}
-export function restoreLibrary(key: string) {
-	try {
-		const saved = Option.getOrUndefined(Schema.decodeUnknownOption(Saved)(JSON.parse(localStorage.getItem(key) ?? "{}")));
-		return { favorites: valid(saved?.favorites), notice: "", recents: valid(saved?.recents) };
-	} catch {
-		return { favorites: [], notice: "Reading history applies to this page only.", recents: [] };
-	}
-}
-interface LibraryState {
-	readonly favorites: readonly Item[];
-	readonly toggle: (file: string, title: string) => void;
-}
-export const LibraryContext = createContext<LibraryState>({ favorites: [], toggle: () => undefined });

package/src/client/react/useHistoryComparison.ts

@@ -1,142 +0,0 @@
-import { RegistryContext } from "@effect/atom-react";
-import { Option } from "effect";
-import { useContext, useEffect, useRef, useState } from "react";
-import { useQuery } from "@shivaedev/effect-react/result-state.ts";
-import { loadQuery } from "@shivaedev/effect-react/router.ts";
-import { session } from "#client/entry.ts";
-import { historyStore } from "./historyStore.ts";
-import type { ShellApi } from "./ShellApi.ts";
-export function useHistoryComparison(api: ShellApi) {
-	const registry = useContext(RegistryContext);
-	const [store] = useState(historyStore);
-	const [baseline, setBaseline] = useState(store.read);
-	const [isBusy, setIsBusy] = useState(false);
-	const [failure, setFailure] = useState(() => document.documentElement.dataset.historyNotice ?? "");
-	const controllerRef = useRef<AbortController | undefined>(undefined);
-	const generationRef = useRef(0);
-	const atom = api.history.query({ action: "compare", baseline });
-	const query = useQuery(atom);
-	const data = Option.getOrUndefined(query.data);
-	function cancel() {
-		generationRef.current += 1;
-		controllerRef.current?.abort();
-		setIsBusy(false);
-	}
-	function clear() {
-		delete document.documentElement.dataset.historyNotice;
-		cancel();
-		store.write(null);
-		setBaseline(null);
-		setFailure("");
-		registry.refresh(api.history.query({ action: "compare", baseline: null }));
-	}
-	useEffect(() => {
-		if (data?.discardBaseline && baseline === store.read()) {
-			store.write(null);
-			setBaseline(null);
-			setFailure(data.reason);
-		}
-	}, [baseline, data, store]);
-	useEffect(() => {
-		function refresh() {
-			const native = session(window);
-			if (!(document.hidden || native.registry.get(native.updates.paused) || isBusy)) {
-				registry.refresh(atom);
-			}
-		}
-		function sync(event: StorageEvent) {
-			if (event.key === store.key || event.key === null) {
-				generationRef.current += 1;
-				controllerRef.current?.abort();
-				setIsBusy(false);
-				setBaseline(store.read());
-				setFailure("");
-				refresh();
-			}
-		}
-		const timer = setInterval(refresh, 60_000);
-		document.addEventListener("board-updates-resumed", refresh);
-		document.addEventListener("visibilitychange", refresh);
-		window.addEventListener("storage", sync);
-		return () => {
-			clearInterval(timer);
-			document.removeEventListener("board-updates-resumed", refresh);
-			document.removeEventListener("visibilitychange", refresh);
-			window.removeEventListener("storage", sync);
-		};
-	}, [atom, isBusy, registry, store]);
-	useEffect(() => {
-		async function validate() {
-			const raw = store.read();
-			try {
-				const check = api.history.query({ action: "check", baseline: raw });
-				registry.refresh(check);
-				const result = await loadQuery(registry, check, { abortController: new AbortController() });
-				if (raw !== store.read()) {
-					return;
-				}
-				if (result.discardBaseline) {
-					store.write(null);
-					setBaseline(null);
-					setFailure(result.reason);
-				} else if (raw !== baseline) {
-					setBaseline(raw);
-					registry.refresh(api.history.query({ action: "compare", baseline: raw }));
-				}
-			} catch {
-				setFailure("History validation is unavailable. Your remembered snapshot is preserved.");
-			}
-		}
-		document.addEventListener("board-page", validate);
-		return () => document.removeEventListener("board-page", validate);
-	}, [api, baseline, registry, store]);
-	useEffect(() => {
-		function stop() {
-			generationRef.current += 1;
-			controllerRef.current?.abort();
-		}
-		window.addEventListener("pagehide", stop);
-		return () => {
-			stop();
-			window.removeEventListener("pagehide", stop);
-		};
-	}, []);
-	async function observe() {
-		if (isBusy) {
-			return;
-		}
-		generationRef.current += 1;
-		const mine = generationRef.current;
-		controllerRef.current?.abort();
-		controllerRef.current = new AbortController();
-		setIsBusy(true);
-		try {
-			const native = session(window);
-			const next = await native.run(native.api.history.run({ action: "observe", baseline }), controllerRef.current.signal);
-			if (mine !== generationRef.current) {
-				return;
-			}
-			if (next.snapshot === null) {
-				setFailure(next.reason);
-				return;
-			}
-			delete document.documentElement.dataset.historyNotice;
-			store.write(next.snapshot);
-			setBaseline(next.snapshot);
-			setFailure("");
-			registry.refresh(api.history.query({ action: "compare", baseline: next.snapshot }));
-		} catch {
-			if (mine === generationRef.current) {
-				setFailure("Could not remember the current observation. Your previous baseline is preserved.");
-			}
-		} finally {
-			if (mine === generationRef.current) {
-				setIsBusy(false);
-			}
-		}
-	}
-	const message = Option.isSome(query.cause)
-		? "History is unavailable: the current observation could not be loaded. No comparison or removals are inferred."
-		: failure;
-	return { atom, available: Option.isNone(query.cause), baseline, busy: isBusy, clear, message, notice: store.notice(), observe };
-}

package/src/history/schema.ts

@@ -1,51 +0,0 @@
-import { Schema } from "effect";
-import { isMarkdown } from "#path/isMarkdown.ts";
-
-const File = Schema.String.check(
-	Schema.makeFilter(
-		(value) =>
-			(isMarkdown(value) && !value.includes("\\") && !value.includes("\0") && value.split("/").every((part) => part.length > 0 && part !== ".."))
-			|| "Expected a relative readable Markdown path",
-	),
-);
-const ObservedTime = Schema.String.check(
-	Schema.makeFilter(
-		(value) =>
-			(Number.isFinite(Date.parse(value)) && /^\d{4}-\d{2}-\d{2}T.*(?:Z|[+-]\d{2}:\d{2})$/u.exec(value) !== null)
-			|| "Expected an ISO observation time with timezone",
-	),
-);
-export const Baseline = Schema.Struct({
-	documents: Schema.Array(Schema.Struct({ file: File, source: Schema.String })).check(
-		Schema.makeFilter(
-			(values) => new Set(values.map((value) => value.file)).size === values.length || "Duplicate source paths are not a complete observation",
-		),
-	),
-	recordedAt: ObservedTime,
-	version: Schema.Literal(1),
-}).pipe(Schema.encodeKeys({ recordedAt: "recorded_at" }));
-export type Baseline = typeof Baseline.Type;
-
-export const HistoryInput = Schema.Struct({ action: Schema.Literals(["check", "compare", "observe"]), baseline: Schema.NullOr(Schema.String) });
-const Source = Schema.Struct({ file: Schema.String, source: Schema.String });
-export const HistoryComparison = Schema.Struct({
-	changes: Schema.Array(
-		Schema.Struct({
-			after: Schema.optional(Source),
-			before: Schema.optional(Source),
-			kind: Schema.Literals(["added", "removed", "changed"]),
-			reasons: Schema.Array(Schema.String),
-		}),
-	),
-	issues: Schema.Array(Schema.String),
-	recordedAt: Schema.String,
-});
-export type HistoryComparison = typeof HistoryComparison.Type;
-export const HistoryOutput = Schema.Struct({
-	comparison: Schema.optional(HistoryComparison),
-	discardBaseline: Schema.Boolean,
-	html: Schema.String,
-	reason: Schema.String,
-	snapshot: Schema.NullOr(Schema.String),
-});
-export type HistoryOutput = typeof HistoryOutput.Type;

package/src/server/attention/inboxHtml.ts

@@ -1,56 +0,0 @@
-import { escapeHtml } from "#browser/escapeHtml.ts";
-import type { Snapshot } from "#server/search/snapshot.ts";
-import { inboxItems } from "./inbox.ts";
-
-export function inboxHtml(snapshot: Snapshot, compact = false, now?: number): string {
-	const items = inboxItems(snapshot);
-	const total = snapshot.unavailable.length > 0 ? "Count unavailable" : `${items.length} waiting`;
-	const rows = items
-		.map(
-			(item) =>
-				`<article class="inbox-row" data-key="inbox:${escapeHtml(item.document.file)}"><div><h3><a href="${escapeHtml(item.href)}">${escapeHtml(item.title)}</a></h3><p>${escapeHtml(item.reason)}</p>${item.problem ? `<p class="inbox-problem" role="status">${escapeHtml(item.problem)} — open the source to resolve it.</p>` : ""}</div><p class="inbox-age">${item.modified === undefined ? "Age unavailable" : sourceAge(item.modified, now)}</p></article>`,
-		)
-		.join("");
-	const content =
-		snapshot.unavailable.length > 0
-			? '<p role="status">Workspace incomplete. Inbox membership and count are unavailable.</p>'
-			: rows
-				|| (snapshot.model.documents.some((document) => (snapshot.model.diagnostics.get(document.file)?.length ?? 0) > 0)
-					? '<p class="empty">No classified waiting items. Check source issues in Overview.</p>'
-					: '<p class="empty">All quiet — nothing is waiting on a person.</p>');
-	return compact
-		? `<section aria-label="Inbox summary"><h2>Inbox</h2><p>${total} · <a href="/_board/inbox">Open Inbox</a></p></section>`
-		: `<header class="work-head"><p class="work-eyebrow">WORKSPACE · INBOX</p><h1>Inbox</h1><p>Questions and work waiting on a person. Oldest changed source first.</p></header><p class="work-total" role="status">${total}</p><section class="inbox-list" aria-label="Waiting on you"><h2>Waiting on you</h2>${content}</section>`;
-}
-
-export const inboxStyle = `
-.inbox-row{display:flex;justify-content:space-between;gap:1rem;padding:1.2rem;margin:.75rem 0;border:1px solid var(--border);border-radius:10px;background:var(--card);overflow-wrap:anywhere}
-.inbox-row h3{margin:0 0 .5rem}.inbox-row p{margin:.4rem 0}.inbox-row>div{min-width:0}.inbox-age{flex-shrink:0}.waiting-badge{display:inline-block;font-size:.75rem;font-weight:600;border:1px solid var(--border);border-radius:1rem;padding:.1rem .5rem;color:var(--muted);background:var(--surface)}
-.inbox-link{display:flex;justify-content:space-between;gap:1rem;padding:12px;color:var(--sidebar-text);text-decoration:none}.inbox-count{border-radius:1rem;padding:0 .6rem;background:#385242}
-.question-choice{display:grid;grid-template-rows:subgrid;grid-row:span 2;align-content:start;align-items:start;gap:.4rem;text-align:left;padding:1rem;border:1px solid var(--border);border-radius:8px;color:var(--text);background:var(--card);font:inherit}.question-choice[aria-pressed=true]{border-color:var(--link);background:var(--surface)}.question-choice small{font:inherit;color:var(--muted)}
-.response-panel [data-clear-choices]{margin-bottom:1rem}
-.question-choices{display:grid;grid-template-columns:repeat(2,minmax(0,1fr));gap:.75rem;margin:1rem 0}.question-choice{width:100%;overflow-wrap:anywhere}.inbox-problem{color:var(--danger)}
-.bar .inbox-count{background:var(--surface);color:var(--text)}.bar .inbox-link{padding:0;flex-shrink:0;text-decoration:underline;text-underline-offset:4px;color:var(--link);white-space:nowrap;gap:.4rem}
-.bar .inbox-link[aria-current="page"]{font-weight:700}
-@media(max-width:600px){.inbox-row{flex-direction:column}.response-panel{padding:0}}
-@media(max-width:600px){.question-choices{grid-template-columns:minmax(0,1fr)}}
-`;
-
-function sourceAge(modified: number, now: number | undefined): string {
-	if (now === undefined) {
-		return `<span class="age" data-modified="${modified}">updated ${new Date(modified).toISOString()}</span>`;
-	}
-	const minutes = Math.max(0, Math.floor((now - modified) / 60_000));
-	const age = elapsedAge(minutes);
-	return `<span class="age" data-modified="${modified}">updated ${age} ago</span>`;
-}
-
-function elapsedAge(minutes: number): string {
-	if (minutes < 60) {
-		return `${minutes}m`;
-	}
-	if (minutes < 48 * 60) {
-		return `${Math.floor(minutes / 60)}h`;
-	}
-	return `${Math.round(minutes / (24 * 60))}d`;
-}