@shivaedev/work-board 0.16.0 → 0.17.1

package/src/client/react/readerLink.ts

@@ -2,7 +2,7 @@ export function readerLink(target: URL) {
 	return (
 		target.origin === location.origin
 		&& (target.pathname === "/"
-			|| /^\/_board\/(?:library|goals|system|diagnostics|handoff|result|respond|start|changes|inbox|overview|work)$/u.test(target.pathname)
+			|| /^\/_board\/(?:library|goals|system|diagnostics|handoff|result|start|changes|inbox|overview|work)$/u.test(target.pathname)
 			|| target.pathname.startsWith("/_board/item/")
 			|| /\.md$/iu.test(target.pathname))
 	);

package/src/client/react/remainingRoute.ts

@@ -8,8 +8,6 @@ export function remainingRoute(pathname: string) {
 			return "system";
 		case "/_board/start":
 			return "start";
-		case "/_board/respond":
-			return "respond";
 		case "/_board/handoff":
 			return "handoff";
 		case "/_board/result":

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 { responseFeedback, responseSummary } from "#client/responses/summary.ts";
+import { chosenLabels, responseFeedback, responseSummary } from "#client/responses/summary.ts";
 import { sourceChanged } from "#client/sourceChanged.ts";
 import { createResponse } from "./createResponse.ts";
 import { useFormClient } from "./FormContext.ts";
@@ -116,7 +116,9 @@ export function useResponseForm(source: QuestionPreview, prompts: readonly Promp
 		setInteraction("cleared");
 	}
 	const previewed = preview !== undefined && same && Equal.equals(preview, values);
-	const { outcome, text: status } = formStatus(created, interaction, "response", (saved) => responseSaved(saved.id, created.dirty));
+	const { outcome, text: status } = formStatus(created, interaction, "response", (saved) =>
+		responseSaved(saved.id, created.dirty, chosenLabels(prompts, saved.answers)),
+	);
 	const summary = responseSummary(values, prompts, answers(values), attempted);
 	return {
 		answers: answers(values),

package/src/client/responses/summary.ts

@@ -1,3 +1,4 @@
+import { optionText, promptHeading } from "#browser/responses/cardContext.ts";
 import type { Prompt } from "#browser/responses/Prompt.ts";
 import type { PromptAnswer } from "#browser/responses/schema.ts";
 import type { ResponseInput } from "./formSchema.ts";
@@ -14,7 +15,9 @@ export function responseSummary(values: ResponseInput, prompts: readonly Prompt[
 			: [];
 	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("; ")}.` : "",
+		missing.length > 0
+			? `Unanswered: ${missing.map((prompt) => `“${promptHeading(prompt.source).title ?? `Question ${prompts.indexOf(prompt) + 1}`}”`).join(", ")}.`
+			: "",
 	]
 		.filter(Boolean)
 		.join(" ");
@@ -23,3 +26,12 @@ export function responseSummary(values: ResponseInput, prompts: readonly Prompt[
 export function responseFeedback(status: string, outcome: string | undefined, summary: string) {
 	return outcome || status.startsWith("Draft cleared") ? status : summary || status;
 }
+
+export function chosenLabels(prompts: readonly Prompt[], answers: readonly PromptAnswer[] | undefined) {
+	return prompts
+		.flatMap((prompt) => {
+			const selected = answers?.find((answer) => answer.prompt === prompt.id)?.selected ?? [];
+			return prompt.options.filter((option) => selected.includes(option.id)).map((option) => optionText(option.id, option.source, "").label);
+		})
+		.join(", ");
+}

package/src/responses/url.ts

@@ -1,3 +1,3 @@
 export function responseUrl(item: string, request: string): string {
-	return `/_board/respond?item=${encodeURIComponent(item)}&request=${encodeURIComponent(request)}`;
+	return `/_board/item/${encodeURIComponent(item)}/#${encodeURIComponent(`answer-card-${request}`)}`;
 }

package/src/rpc/PageUrl.ts

@@ -17,7 +17,6 @@ export const PageUrl = Schema.String.check(
 					"/_board/overview",
 					"/_board/changes",
 					"/_board/start",
-					"/_board/respond",
 					"/_board/handoff",
 					"/_board/result",
 				].includes(path)

package/src/rpc/contract.ts

@@ -10,7 +10,7 @@ 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 { DiagnosticsProjection, HandoffProjection, 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";
@@ -53,15 +53,13 @@ const ReadWork = query("work", {
 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 ReadFleetItems = query("fleetItems", {
+	reads: () => [workspace.list, index.list],
+	rejections: { InternalServerError },
+	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],
@@ -109,7 +107,6 @@ export const workContract = contract("work-board", {
 		ReadFleetItems,
 		ReadGoals,
 		ReadStart,
-		ReadRespond,
 		ReadHandoff,
 		ReadResult,
 		ReadNavigation,

package/src/server/{responses/service.ts → Responses.ts}

@@ -1,29 +1,20 @@
-import { Clock, Context, Effect, FileSystem, Path, Schema, Semaphore } from "effect";
+import { Clock, Effect, FileSystem, Path, Schema, Semaphore } from "effect";
 import { defineService } from "@shivaedev/effect-service/define-service.ts";
 import { Conflict, Forbidden, PreconditionFailed, ServiceUnavailable } from "@shivaedev/platform/errors/taxonomy.ts";
 import { rpcBoundary } from "@shivaedev/platform/rpc-server/boundary.ts";
 import type { DraftInput } from "#browser/responses/schema.ts";
-import type { Changes } from "#server/files/changes.ts";
-import type { Snapshot } from "#server/search/snapshot.ts";
-import { awaitResponse } from "./await.ts";
-import { responseHistory } from "./history.ts";
-import { locate as locateQuestion } from "./locate.ts";
-import { makeResponse } from "./make.ts";
-import { publish } from "./publish.ts";
-import { readResponses } from "./read.ts";
-import { responseMarkdown } from "./records.ts";
-import { registerQuestion } from "./registerQuestion.ts";
-import { retryResponse } from "./retry.ts";
-import { validatedInput } from "./validatedInput.ts";
-import { validateSupersedes } from "./validateSupersedes.ts";
-
-export interface ResponseOptions {
-	readonly changes: Changes;
-	readonly enabled: boolean;
-	readonly index: Effect.Effect<Snapshot, unknown>;
-	readonly root: string;
-}
-export class ResponseConfig extends Context.Service<ResponseConfig, ResponseOptions>()("WorkBoard/ResponseConfig") {}
+import { awaitResponse } from "#server/responses/await.ts";
+import { responseHistory } from "#server/responses/history.ts";
+import { locate as locateQuestion } from "#server/responses/locate.ts";
+import { makeResponse } from "#server/responses/make.ts";
+import { publish } from "#server/responses/publish.ts";
+import { readResponses } from "#server/responses/read.ts";
+import { responseMarkdown } from "#server/responses/records.ts";
+import { registerQuestion } from "#server/responses/registerQuestion.ts";
+import { retryResponse } from "#server/responses/retry.ts";
+import { validatedInput } from "#server/responses/validatedInput.ts";
+import { validateSupersedes } from "#server/responses/validateSupersedes.ts";
+import { Workspace } from "#server/workspace.ts";
 
 function invalidResponse(cause: unknown): Conflict {
 	return Schema.is(Conflict)(cause)
@@ -34,19 +25,20 @@ function invalidResponse(cause: unknown): Conflict {
 export const Responses = defineService({
 	id: "WorkBoard/Responses",
 	initialize: Effect.gen(function* () {
-		return { fs: yield* FileSystem.FileSystem, lock: yield* Semaphore.make(1), options: yield* ResponseConfig };
+		const workspace = yield* Workspace;
+		return { fs: yield* FileSystem.FileSystem, lock: yield* Semaphore.make(1), options: yield* workspace.settings(), workspace };
 	}),
-	methods: ({ options, fs, lock }) => {
-		const snapshot = options.index.pipe(
+	methods: ({ options, fs, lock, workspace }) => {
+		const snapshot = workspace.index().pipe(
 			rpcBoundary(ServiceUnavailable, {
 				message: "The workspace could not be indexed.",
 				unexpected: (message) => new ServiceUnavailable({ message }),
 			}),
 		);
-		const enabled = options.enabled
+		const enabled = options.writable
 			? Effect.void
 			: Effect.fail(new Forbidden({ message: "Start with --responses to explicitly enable local question/response writes." }));
-		const locate = locateQuestion(options.root, options.changes.realRoot, snapshot, fs);
+		const locate = locateQuestion(options.root, options.realRoot, snapshot, fs);
 		const read = readResponses(snapshot);
 		const register = registerQuestion(options, snapshot, locate, read);
 		function record(draft: DraftInput) {
@@ -80,7 +72,7 @@ export const Responses = defineService({
 						question,
 						result.responses.reduce((time, saved) => Math.max(time, saved.response.recordedAt + 1), yield* Clock.currentTimeMillis),
 					);
-					yield* publish(options.root, options.changes.realRoot, response.id, responseMarkdown(response)).pipe(
+					yield* publish(options.root, options.realRoot, response.id, responseMarkdown(response)).pipe(
 						Effect.ensuring(options.changes.refresh ?? Effect.void),
 					);
 					return response;
@@ -107,6 +99,6 @@ export const Responses = defineService({
 			register: (input: Parameters<typeof register>[0]) => lock.withPermit(register(input)),
 		};
 	},
-	requires: [ResponseConfig, FileSystem.FileSystem, Path.Path],
+	requires: [Workspace, FileSystem.FileSystem, Path.Path],
 });
 export type Responses = typeof Responses.Identifier;

package/src/server/attention/inbox.ts

@@ -6,7 +6,7 @@ import type { Snapshot } from "#server/search/snapshot.ts";
 import { answeredQuestion } from "./questionState.ts";
 import { requestInbox } from "./requestInbox.ts";
 import { isMaintainerRequest } from "./requests.ts";
-import { closedItem } from "./status.ts";
+import { closedItem, deferredItem } from "./status.ts";
 
 const automation = /^(?:codex|claude|fleet|orchestrator|agent|automation|bot|copilot)(?:$|[-_. /])/iu;
 
@@ -24,6 +24,10 @@ function addressedElsewhere(document: MetadataDocument, maintainer: string): boo
 }
 
 export function waitingReason(document: MetadataDocument, model: MetadataModel, maintainer = "maintainer"): string | undefined {
+	return deferredItem(document) ? undefined : attentionReason(document, model, maintainer);
+}
+
+function attentionReason(document: MetadataDocument, model: MetadataModel, maintainer: string): string | undefined {
 	const fields = document.parsed.fields;
 	if (!openItem(document) || fields.kind === "response" || fields.kind === "handoff" || fields.question) {
 		return undefined;
@@ -64,38 +68,59 @@ function inboxTarget(document: MetadataDocument, problem: string | undefined): s
 	return answer ? responseUrl(item, answer) : identityUrl(item);
 }
 
-export function inboxItems(snapshot: Snapshot) {
-	if (snapshot.unavailable.length > 0) {
-		return [];
-	}
+function directItems(snapshot: Snapshot, skipped: ReadonlySet<string>, reasonOf: (document: MetadataDocument) => string | undefined) {
 	const titles = new Map(snapshot.entries.filter((entry) => entry.kind === "document").map((entry) => [entry.file, entry.title]));
-	const requests = requestInbox(snapshot);
-	const you = requests.items.filter((item) => item.responseFrom.includes(snapshot.maintainer ?? "maintainer"));
-	const direct = snapshot.documents.flatMap((document) => {
-		if (requests.files.has(document.file)) {
+	return snapshot.documents.flatMap((document) => {
+		const reason = skipped.has(document.file) ? undefined : reasonOf(document);
+		if (!reason) {
 			return [];
 		}
 		const id = document.parsed.fields.id;
 		const problem = identityProblem(document, snapshot.model);
-		const reason = waitingReason(document, snapshot.model, snapshot.maintainer);
-		return reason
-			? [
-					{
-						document,
-						href: inboxTarget(document, problem),
-						id: id ?? document.file,
-						problem,
-						reason,
-						title: titles.get(document.file) ?? document.file,
-						unblocks: [id ?? ""],
-					},
-				]
-			: [];
+		return [
+			{
+				document,
+				href: inboxTarget(document, problem),
+				id: id ?? document.file,
+				modified: snapshot.modified.get(document.file),
+				problem,
+				reason,
+				request: undefined,
+				title: titles.get(document.file) ?? document.file,
+				unblocks: [id ?? ""],
+			},
+		];
 	});
-	const ordinary = direct
+}
+
+function byAge(
+	left: { readonly id: string; readonly modified: number | undefined },
+	right: { readonly id: string; readonly modified: number | undefined },
+) {
+	return (left.modified ?? 0) - (right.modified ?? 0) || left.id.localeCompare(right.id);
+}
+
+export function inboxItems(snapshot: Snapshot) {
+	if (snapshot.unavailable.length > 0) {
+		return [];
+	}
+	const requests = requestInbox(snapshot);
+	const you = requests.items.filter((item) => item.responseFrom.includes(snapshot.maintainer ?? "maintainer"));
+	const ordinary = directItems(snapshot, requests.files, (document) => waitingReason(document, snapshot.model, snapshot.maintainer))
 		.filter((item) => item.problem || !you.some((ask) => ask.id === item.id))
-		.map((item) => ({ ...item, earlierAsks: 0, modified: snapshot.modified.get(item.document.file) }));
-	return [...ordinary, ...you].sort((left, right) => (left.modified ?? 0) - (right.modified ?? 0) || left.id.localeCompare(right.id));
+		.map((item) => ({ ...item, earlierAsks: 0 }));
+	return [...ordinary, ...you].sort(byAge);
+}
+
+export function laterItems(snapshot: Snapshot) {
+	if (snapshot.unavailable.length > 0) {
+		return [];
+	}
+	function parked(document: MetadataDocument) {
+		const reason = deferredItem(document) ? attentionReason(document, snapshot.model, snapshot.maintainer ?? "maintainer") : undefined;
+		return reason && (document.parsed.fields.nextAction ?? reason);
+	}
+	return directItems(snapshot, requestInbox(snapshot).files, parked).sort(byAge);
 }
 
 export function fleetRecords(model: MetadataModel): ReadonlySet<string> {

package/src/server/attention/managedRequestReceipt.ts

@@ -6,6 +6,13 @@ import { questionId, revisionOf } from "#server/responses/records.ts";
 
 type Request = NonNullable<Metadata["attention"]>[number];
 
+export type ManagedRequestState =
+	| { readonly _tag: "Open" }
+	| { readonly _tag: "Settled"; readonly receipt: RequestReceipt }
+	| { readonly _tag: "Conflicting"; readonly receipts: readonly string[] };
+
+const open: ManagedRequestState = { _tag: "Open" };
+
 function uniqueDocument(id: string, model: MetadataModel): MetadataDocument | undefined {
 	const matches = model.ids.get(id);
 	return matches?.length === 1 ? matches[0] : undefined;
@@ -38,7 +45,7 @@ function appliedAnswer(question: string, revision: string, responseId: string |
 	return current.length === 1 && current[0]?.id === responseId;
 }
 
-export function managedRequestReceipt(document: MetadataDocument, request: Request, model: MetadataModel): RequestReceipt | undefined {
+function registeredQuestion(document: MetadataDocument, request: Request, model: MetadataModel) {
 	const item = document.parsed.fields.id;
 	if (
 		request.managed !== true
@@ -57,7 +64,6 @@ export function managedRequestReceipt(document: MetadataDocument, request: Reque
 	const revision = revisionOf(source);
 	const id = questionId(item, request.id, revision, document.file);
 	const archived = uniqueDocument(id, model);
-	const index = responseIndex(model);
 	const question = registeredContext(archived, model);
 	if (
 		archived?.parsed.diagnostics.length !== 0
@@ -70,14 +76,13 @@ export function managedRequestReceipt(document: MetadataDocument, request: Reque
 	) {
 		return undefined;
 	}
-	if (index.receiptProblems) {
-		return undefined;
-	}
-	const receipts = index.receipts.get(id) ?? [];
-	const saved = receipts.length === 1 ? receipts[0] : undefined;
-	const receipt = saved?.parsed.fields.requestReceipt;
+	return { id, revision };
+}
+
+function qualified(saved: MetadataDocument, question: string, revision: string, model: MetadataModel): RequestReceipt | undefined {
+	const receipt = saved.parsed.fields.requestReceipt;
 	if (
-		!(saved && receipt)
+		!receipt
 		|| saved.parsed.fields.kind !== "result"
 		|| saved.parsed.diagnostics.length > 0
 		|| !saved.parsed.fields.id
@@ -89,5 +94,31 @@ export function managedRequestReceipt(document: MetadataDocument, request: Reque
 	if (receipt.disposition === "superseded") {
 		return receipt.response === undefined ? receipt : undefined;
 	}
-	return appliedAnswer(id, revision, receipt.response, model) ? receipt : undefined;
+	return appliedAnswer(question, revision, receipt.response, model) ? receipt : undefined;
+}
+
+function settling(receipts: readonly RequestReceipt[]): RequestReceipt | undefined {
+	return receipts.toSorted(
+		(left, right) => Number(right.disposition === "applied") - Number(left.disposition === "applied") || right.recordedAt - left.recordedAt,
+	)[0];
+}
+
+export function managedRequestState(document: MetadataDocument, request: Request, model: MetadataModel): ManagedRequestState {
+	const question = registeredQuestion(document, request, model);
+	const index = responseIndex(model);
+	if (!question || index.receiptProblems) {
+		return open;
+	}
+	const saved = index.receipts.get(question.id) ?? [];
+	const receipts = saved.flatMap((candidate) => qualified(candidate, question.id, question.revision, model) ?? []);
+	const receipt = receipts.length === saved.length ? settling(receipts) : undefined;
+	if (receipt) {
+		return { _tag: "Settled", receipt };
+	}
+	return receipts.length > 0 ? { _tag: "Conflicting", receipts: saved.map((candidate) => candidate.file) } : open;
+}
+
+export function managedRequestReceipt(document: MetadataDocument, request: Request, model: MetadataModel): RequestReceipt | undefined {
+	const state = managedRequestState(document, request, model);
+	return state._tag === "Settled" ? state.receipt : undefined;
 }

package/src/server/attention/projection.ts

@@ -1,6 +1,6 @@
 import type { InboxProjection } from "#browser/views/schema.ts";
 import type { Snapshot } from "#server/search/snapshot.ts";
-import { inboxItems } from "./inbox.ts";
+import { inboxItems, laterItems } from "./inbox.ts";
 import { requestInbox } from "./requestInbox.ts";
 import { attentionRequests } from "./requests.ts";
 
@@ -12,7 +12,9 @@ export function attentionProjection(snapshot: Snapshot): InboxProjection {
 		return cached;
 	}
 	const requests = requestInbox(snapshot);
-	function project({ document, unblocks: _unblocks, ...item }: ReturnType<typeof inboxItems>[number]) {
+	function project<
+		TRow extends { readonly document: { readonly file: string }; readonly request: string | undefined; readonly unblocks: readonly string[] },
+	>({ document, request: _request, unblocks: _unblocks, ...item }: TRow) {
 		return { ...item, file: document.file };
 	}
 	const you = inboxItems(snapshot).map(project);
@@ -22,6 +24,7 @@ export function attentionProjection(snapshot: Snapshot): InboxProjection {
 		complete: snapshot.unavailable.length === 0,
 		issues,
 		items: you,
+		later: laterItems(snapshot).map(project),
 		parked: requests.parked.map(project),
 		resolved: requests.resolved.map(project),
 		sourceIssues: issues.length > 0,

package/src/server/attention/requestInbox.ts

@@ -23,11 +23,12 @@ export function requestInbox(snapshot: Snapshot) {
 		return {
 			document: entry.document,
 			earlierAsks: 0,
-			href: responseUrl(entry.itemId, entry.request.id),
+			href: entry.problem === undefined ? responseUrl(entry.itemId, entry.request.id) : entry.href,
 			id: target?.parsed.fields.id ?? entry.itemId,
 			modified: snapshot.modified.get(entry.document.file),
-			problem: undefined,
+			problem: entry.problem,
 			reason: entry.request.managed ? `Managed decision: ${entry.request.reason}` : entry.request.reason,
+			request: entry.request.id,
 			responseFrom: entry.request.responseFrom,
 			title: (target ? titles.get(target.file) : undefined) ?? entry.title,
 			unblocks: entry.request.unblocks,

package/src/server/attention/requests.ts

@@ -1,5 +1,5 @@
 import type { Metadata } from "#metadata/schema.ts";
-import { managedRequestReceipt } from "#server/attention/managedRequestReceipt.ts";
+import { managedRequestState } from "#server/attention/managedRequestReceipt.ts";
 import { identityUrl, referenceTarget } from "#server/metadata/links.ts";
 import type { MetadataDocument } from "#server/metadata/model.ts";
 import type { Snapshot } from "#server/search/snapshot.ts";
@@ -10,6 +10,7 @@ export interface AttentionEntry {
 	readonly href: string;
 	readonly itemId: string;
 	readonly line: number;
+	readonly problem: string | undefined;
 	readonly request: Request;
 	readonly title: string;
 }
@@ -35,16 +36,20 @@ function requestsFor(document: MetadataDocument, snapshot: Snapshot, title: stri
 			request.state !== "open"
 			|| requests.filter((other) => other.id === request.id).length !== 1
 			|| request.unblocks.some((target) => !referenceTarget(target, snapshot.model))
-			|| managedRequestReceipt(document, request, snapshot.model) !== undefined
 		) {
 			return [];
 		}
+		const receipts = managedRequestState(document, request, snapshot.model);
+		if (receipts._tag === "Settled") {
+			return [];
+		}
 		return [
 			{
 				document,
 				href: `${identityUrl(itemId)}#attention-request-${encodeURIComponent(request.id)}`,
 				itemId,
 				line: lines[`attention.${index}`] ?? lines.attention ?? 2,
+				problem: receipts._tag === "Conflicting" ? `Request receipts disagree: ${receipts.receipts.join(", ")}` : undefined,
 				request,
 				title,
 			},

package/src/server/boardRuntime.ts

@@ -1,16 +1,15 @@
 import { Context, Effect, FileSystem, Layer, Path, type PlatformError } from "effect";
-import { DiagnosticsSources } from "#diagnostics/source.ts";
+import { DiagnosticsConfig, DiagnosticsSources } from "#diagnostics/source.ts";
 import type { BoardOptions } from "#server/board.ts";
 import { boardServices } from "#server/boardServices.ts";
 import { daemonDiagnostics } from "#server/diagnostics/daemon.ts";
-import { readDocument } from "#server/document/read.ts";
 import { watchChanges } from "#server/files/changes.ts";
 import { homeIn } from "#server/files/home.ts";
 import { checkBrowserAssets, mermaidRoot } from "#server/http/assets.ts";
 import { Highlighter } from "#server/render/Highlighter.ts";
 import type { HandlerOptions } from "#server/rpc/HandlerOptions.ts";
-import { handlers } from "#server/rpc/handlers.ts";
 import { type Snapshot, searchSnapshot } from "#server/search/snapshot.ts";
+import { Workspace, WorkspaceConfig } from "#server/workspace.ts";
 
 export const boardRuntime = Effect.fn("WorkBoard.boardRuntime")(function* (options: BoardOptions, server?: HandlerOptions["server"]) {
 	const home = yield* homeIn(options.root, options.home);
@@ -28,30 +27,26 @@ export const boardRuntime = Effect.fn("WorkBoard.boardRuntime")(function* (optio
 	);
 	const provided = yield* Effect.serviceOption(DiagnosticsSources);
 	const services = yield* Layer.build(
-		boardServices(
-			{ changes, enabled: options.responses === true, index: Effect.provideContext(index, platform), root: options.root },
-			provided._tag === "Some" ? { _tag: "Sources", sources: provided.value } : { _tag: "Read", read: daemonDiagnostics(options.fleetPort) },
-		),
-	);
-	const context = Context.merge(platform, services);
-	const rpcHandlers = yield* handlers({
-		...(options.fleetPort === undefined ? {} : { fleetPort: options.fleetPort }),
-		changes,
-		document: (url) =>
-			Effect.provideContext(
-				readDocument({
+		boardServices({
+			...(options.fleetPort === undefined ? {} : { fleetPort: options.fleetPort }),
+			...(server === undefined ? {} : { server }),
+		}).pipe(
+			Layer.provideMerge(Workspace.layer),
+			Layer.provide([
+				Layer.succeed(WorkspaceConfig, {
 					changes,
 					home,
-					index: Effect.provideContext(index, context),
+					index: Effect.provideContext(index, platform),
 					root: options.root,
 					writable: options.responses === true,
-				})(url),
-				context,
-			),
-		home,
-		index: Effect.provideContext(index, context),
-		...(server === undefined ? {} : { server }),
-		writable: options.responses === true,
-	}).pipe(Effect.provideContext(context));
-	return { changes, context, home, index, mermaid, rpcHandlers };
+				}),
+				Layer.succeed(
+					DiagnosticsConfig,
+					provided._tag === "Some" ? { _tag: "Sources", sources: provided.value } : { _tag: "Read", read: daemonDiagnostics(options.fleetPort) },
+				),
+			]),
+		),
+	);
+	const context = Context.merge(platform, services);
+	return { changes, context, home, index, mermaid, rpcHandlers: Layer.succeedContext(services) };
 });

package/src/server/boardServices.ts

@@ -1,10 +1,10 @@
-import { type Context, Layer } from "effect";
-import { Diagnostics, DiagnosticsConfig } from "#diagnostics/source.ts";
+import { Layer } from "effect";
+import { Diagnostics } from "#diagnostics/source.ts";
 import { HandoffsService } from "#server/handoffs/Service.ts";
-import { ResponseConfig, type ResponseOptions, Responses } from "#server/responses/service.ts";
+import { Responses } from "#server/Responses.ts";
+import type { HandlerOptions } from "#server/rpc/HandlerOptions.ts";
+import { handlers } from "#server/rpc/handlers.ts";
 
-export function boardServices(options: ResponseOptions, diagnostics: Context.Service.Shape<typeof DiagnosticsConfig>) {
-	return Layer.mergeAll(Responses.layer, HandoffsService.layer, Diagnostics.layer).pipe(
-		Layer.provide(Layer.merge(Layer.succeed(ResponseConfig, options), Layer.succeed(DiagnosticsConfig, diagnostics))),
-	);
+export function boardServices(options: HandlerOptions = {}) {
+	return Layer.unwrap(handlers(options)).pipe(Layer.provideMerge(Layer.mergeAll(Responses.layer, HandoffsService.layer, Diagnostics.layer)));
 }

package/src/server/document/read.ts

@@ -2,24 +2,17 @@ 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 { locate } from "#server/responses/locate.ts";
 import { readingActions } from "#server/responses/readingActions.ts";
 import type { Snapshot } from "#server/search/snapshot.ts";
+import type { WorkspaceSettings } from "#server/workspace.ts";
 import { answerBody } from "./answerBody.ts";
 import { readingContext } from "./readingContext.ts";
 import { documentRequests } from "./requests.ts";
 import { documentTargets } from "./targets.ts";
 
-export interface DocumentOptions {
-	readonly changes: Changes;
-	readonly home: string | undefined;
-	readonly index: Effect.Effect<Snapshot, unknown>;
-	readonly root: string;
-	readonly writable: boolean;
-}
-
 const selected = Effect.fn("WorkBoard.selected")(function* (
 	url: string,
 	snapshot: Snapshot,
@@ -45,12 +38,11 @@ const selected = Effect.fn("WorkBoard.selected")(function* (
 	return { file, item };
 });
 
-export function readDocument({ changes, home, index, root, writable }: DocumentOptions) {
-	return Effect.fn("WorkBoard.document")(function* (url: string) {
-		const snapshot = yield* index;
+export function readDocument({ changes, home, root, realRoot, writable }: WorkspaceSettings) {
+	return Effect.fn("WorkBoard.document")(function* (url: string, snapshot: Snapshot) {
 		const files = yield* changes.files;
 		const { file, item } = yield* selected(url, snapshot, files, home);
-		const real = yield* markdownPath(root, changes.realRoot, file.path);
+		const real = yield* markdownPath(root, realRoot, file.path);
 		if (!real) {
 			return yield* Effect.fail(new NotFound({ message: "The document is missing." }));
 		}
@@ -65,7 +57,7 @@ export function readDocument({ changes, home, index, root, writable }: DocumentO
 		if (item && identity !== item) {
 			return yield* Effect.fail(new NotFound({ message: "The document is missing." }));
 		}
-		const questionActions = yield* readingActions(document, source, writable, identity);
+		const questionActions = yield* readingActions(document, source, writable, identity, locate(root, realRoot, Effect.succeed(snapshot), fs));
 		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(

package/src/server/document/requests.ts

@@ -1,6 +1,5 @@
 import { ServiceUnavailable } from "@shivaedev/platform/errors/taxonomy.ts";
 import type { DocumentRequest } from "#browser/document/schema.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";
@@ -84,6 +83,6 @@ function requestOpenInSource(document: MetadataDocument, id: string): boolean {
 
 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));
+	const eligible = !managed || requestInbox(snapshot).items.some((entry) => entry.document.file === document.file && entry.request === id);
 	return eligible ? requestSource(snapshot, item, id) : undefined;
 }