@shivaedev/work-board 0.16.0 → 0.17.0

package/src/server/handoffs/Service.ts

@@ -9,26 +9,27 @@ import { handoffFrom, handoffMarkdown, handoffPrompt, matchesHandoff } from "#se
 import { handoffSource } from "#server/handoffs/source.ts";
 import { publish } from "#server/responses/publish.ts";
 import { revisionOf } from "#server/responses/records.ts";
-import { ResponseConfig } from "#server/responses/service.ts";
+import { Workspace } from "#server/workspace.ts";
 
 export const HandoffsService = defineService({
 	id: "WorkBoard/HandoffsService",
 	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 locate = handoffSource(options.root, options.changes.realRoot, snapshot, fs);
+		const locate = handoffSource(options.root, options.realRoot, snapshot, fs);
 		const read = Effect.fn("WorkBoard.read")(function* (item: string) {
 			const data = yield* snapshot;
 			const unknown = [...data.unavailable];
 			const records = data.documents.flatMap((document) => {
-				const record = handoffFrom(document, options.changes.realRoot);
+				const record = handoffFrom(document, options.realRoot);
 				if (
 					(record && data.model.ids.get(record.id)?.length !== 1)
 					|| (document.parsed.fields.kind === "handoff" && !record)
@@ -45,7 +46,7 @@ export const HandoffsService = defineService({
 			if (!record || record.file !== `handoffs/${input.id}.md` || !matchesHandoff(record, input) || revisionOf(record.context) !== input.revision) {
 				return yield* Effect.fail(new Conflict({ message: "This handoff identity moved, is duplicated or records different direction." }));
 			}
-			const path = yield* markdownPath(options.root, options.changes.realRoot, record.file);
+			const path = yield* markdownPath(options.root, options.realRoot, record.file);
 			if (!path) {
 				return yield* Effect.fail(new NotFound({ message: "The prepared handoff moved or disappeared." }));
 			}
@@ -55,20 +56,20 @@ export const HandoffsService = defineService({
 					unexpected: (message) => new ServiceUnavailable({ message }),
 				}),
 			);
-			yield* publish(options.root, options.changes.realRoot, record.id, raw, "handoffs");
+			yield* publish(options.root, options.realRoot, record.id, raw, "handoffs");
 			return record;
 		});
 
 		function prepare(input: HandoffInput) {
 			return lock.withPermit(
 				Effect.gen(function* () {
-					if (!options.enabled) {
+					if (!options.writable) {
 						return yield* Effect.fail(new Forbidden({ message: "Restart with --responses to enable local response/handoff writes." }));
 					}
 					const data = yield* snapshot;
 					const existing = data.model.ids.get(input.id);
 					if (existing?.length) {
-						const record = existing.length === 1 ? handoffFrom(existing[0], options.changes.realRoot) : undefined;
+						const record = existing.length === 1 ? handoffFrom(existing[0], options.realRoot) : undefined;
 						return yield* reconcile(record, input);
 					}
 					const current = yield* locate(input.item);
@@ -91,21 +92,17 @@ export const HandoffsService = defineService({
 							state: "requested",
 						},
 						id: input.id,
-						prompt: handoffPrompt(join(options.changes.realRoot, file)),
+						prompt: handoffPrompt(join(options.realRoot, file)),
 					};
-					yield* publish(
-						options.root,
-						options.changes.realRoot,
-						record.id,
-						handoffMarkdown(record.id, record.handoff, record.context),
-						"handoffs",
-					).pipe(Effect.ensuring(options.changes.refresh ?? Effect.void));
+					yield* publish(options.root, options.realRoot, record.id, handoffMarkdown(record.id, record.handoff, record.context), "handoffs").pipe(
+						Effect.ensuring(options.changes.refresh ?? Effect.void),
+					);
 					return record;
 				}),
 			);
 		}
 		return { locate, prepare, read };
 	},
-	requires: [ResponseConfig, FileSystem.FileSystem, Path.Path],
+	requires: [Workspace, FileSystem.FileSystem, Path.Path],
 });
 export type HandoffsService = typeof HandoffsService.Identifier;

package/src/server/http/assets.ts

@@ -35,7 +35,6 @@ export function mermaidFile(root: string) {
 
 export const MERMAID_ROUTE: HttpRouter.PathInput = `${MERMAID}*`;
 
-export const NATIVE_ROUTE: HttpRouter.PathInput = "/_board/native.js";
 function missingBundle(file: string) {
 	return `Work Board browser bundle assets/${file} is missing. Run pnpm --filter @shivaedev/work-board build:browser from the repository root to build it.`;
 }
@@ -57,16 +56,11 @@ const checkAssets = Effect.fn("WorkBoard.checkAssets")(function* (files: readonl
 	}
 });
 
-export function checkNativeAsset() {
-	return checkAssets(["native.js"]);
-}
 export function checkBrowserAssets() {
-	return checkAssets(["native.js", "react.js", "react.css"]);
+	return checkAssets(["react.js", "react.css"]);
 }
-export const nativeAsset = bundledAsset("native.js", "text/javascript");
 
 const BUNDLED_ASSETS: ReadonlyArray<readonly [HttpRouter.PathInput, ReturnType<typeof bundledAsset>]> = [
-	[NATIVE_ROUTE, nativeAsset],
 	["/_board/react.js", bundledAsset("react.js", "text/javascript")],
 	["/_board/react.css", bundledAsset("react.css", "text/css")],
 ];

package/src/server/http/boardRoutes.ts

@@ -2,13 +2,13 @@ import { Effect, type FileSystem, type Path, type Scope } from "effect";
 import { HttpRouter, type HttpServerRequest, HttpServerResponse } from "effect/http";
 import { loopbackOnly } from "@shivaedev/platform/rpc-server/local.ts";
 import type { Diagnostics } from "#diagnostics/source.ts";
+import { responseUrl } from "#responses/url.ts";
 import type { BoardOptions } from "#server/board.ts";
 import type { boardRuntime } from "#server/boardRuntime.ts";
 import type { HandoffsService } from "#server/handoffs/Service.ts";
-import { identityUrl } from "#server/metadata/links.ts";
 import { shell } from "#server/page/shell.ts";
+import { Responses } from "#server/Responses.ts";
 import type { Highlighter } from "#server/render/Highlighter.ts";
-import { Responses } from "#server/responses/service.ts";
 import { ASSET_HANDLERS, MERMAID_ROUTE, mermaidFile } from "./assets.ts";
 import { attachment } from "./attachment.ts";
 import { identity } from "./identity.ts";
@@ -47,7 +47,7 @@ export function boardRoutes(options: BoardOptions, runtime: Effect.Success<Retur
 					const params = new URL(request.url, "http://127.0.0.1").searchParams;
 					const service = yield* Responses;
 					const preview = yield* service.locate(params.get("item") ?? "", params.get("request") ?? "");
-					return HttpServerResponse.redirect(`${identityUrl(preview.item)}#answer-card-${encodeURIComponent(preview.request)}`);
+					return HttpServerResponse.redirect(responseUrl(preview.item, preview.request));
 				}).pipe(Effect.catch(() => Effect.succeed(respond("Response unavailable", "text/html", 409)))),
 			);
 			for (const view of ["system", "start", "handoff", "result", "library", "goals", "work"] as const) {

package/src/server/integration/responses.ts

@@ -5,13 +5,14 @@ import {
 	RecordedResponse as RecordedResponseSchema,
 } from "#browser/responses/schema.ts";
 import { currentResponses } from "#responses/current.ts";
+import { Responses } from "#server/Responses.ts";
 import { makeResponse } from "#server/responses/make.ts";
 import { publish } from "#server/responses/publish.ts";
 import { readResponses } from "#server/responses/read.ts";
 import { questionFrom, questionId, questionMarkdown, responseMarkdown, revisionOf } from "#server/responses/records.ts";
-import { type ResponseOptions as InternalResponseOptions, ResponseConfig, Responses } from "#server/responses/service.ts";
+import { type WorkspaceOptions as InternalWorkspaceOptions, Workspace, WorkspaceConfig } from "#server/workspace.ts";
 
-export type ResponseOptions = InternalResponseOptions;
+export type WorkspaceOptions = InternalWorkspaceOptions;
 export type DraftInput = typeof DraftInputSchema.Type;
 export type Question = typeof QuestionSchema.Type;
 export type Reading = typeof ReadingSchema.Type;
@@ -28,9 +29,10 @@ export const responses = {
 	questionMarkdown,
 	Reading: ReadingSchema,
 	RecordedResponse: RecordedResponseSchema,
-	ResponseConfig,
 	Responses,
 	readResponses,
 	responseMarkdown,
 	revisionOf,
+	Workspace,
+	WorkspaceConfig,
 } as const;

package/src/server/mcp/queries.ts

@@ -2,6 +2,7 @@ import { Clock, Effect } from "effect";
 import { cardStatus } from "#browser/views/now.ts";
 import type { InboxProjection } from "#browser/views/schema.ts";
 import { fileUrl } from "#files/url.ts";
+import { responseUrl } from "#responses/url.ts";
 import { identityUrl } from "#server/metadata/links.ts";
 import type { BoardClient } from "./client.ts";
 
@@ -11,12 +12,11 @@ export const needsYou = Effect.fn("BoardMcp.needsYou")(function* (client: BoardC
 	const you = yield* Effect.forEach(inbox.you, (row) =>
 		Effect.gen(function* () {
 			const document = yield* client("work-board.document", { url: fileUrl(row.file) });
-			const request = new URL(row.href, "http://localhost").searchParams.get("request");
-			const decision = document.requests.find((entry) => entry.id === request);
+			const decision = document.requests.find((entry) => responseUrl(document.metadata.id ?? "", entry.id) === row.href);
 			return {
 				...row,
 				ageMs: row.modified === undefined ? null : Math.max(0, now - row.modified),
-				options: (request ? decision?.options : document.metadata.options) ?? [],
+				options: (decision ? decision.options : document.metadata.options) ?? [],
 				prompts: decision?.prompts ?? [],
 				promptUnavailable: decision?.promptUnavailable,
 				recommended: decision?.recommended ?? document.metadata.recommended,

package/src/server/packageInfo.ts

@@ -1,2 +1,2 @@
 export const NAME = "work-board";
-export const VERSION = "0.16.0";
+export const VERSION = "0.17.0";

package/src/server/responses/readingActions.ts

@@ -3,7 +3,7 @@ import { BadRequest } from "@shivaedev/platform/errors/taxonomy.ts";
 import { responseUrl } from "#responses/url.ts";
 import { authoredQuestion } from "#server/attention/inbox.ts";
 import type { MetadataDocument } from "#server/metadata/model.ts";
-import { Responses } from "./service.ts";
+import type { locate } from "./locate.ts";
 import { questionTemplate } from "./template.ts";
 
 export const readingActions = Effect.fn("WorkBoard.readingActions")(function* (
@@ -11,16 +11,16 @@ export const readingActions = Effect.fn("WorkBoard.readingActions")(function* (
 	source: string,
 	enabled: boolean,
 	identity: string | undefined,
+	locateQuestion: ReturnType<typeof locate>,
 ) {
 	if (!(enabled && identity)) {
 		return undefined;
 	}
-	const service = yield* Responses;
 	const item = identity;
 	const requests = authoredQuestion(document) ? ["answer"] : (document.parsed.fields.attention ?? []).map((request) => request.id);
 	const actions = new Map<string, string>();
 	for (const request of requests) {
-		const question = yield* service.locate(item, request).pipe(Effect.option);
+		const question = yield* locateQuestion(item, request).pipe(Effect.option);
 		if (question._tag === "Some" && question.value.context === source) {
 			const template = yield* Effect.try({
 				catch: (cause) => new BadRequest({ message: cause instanceof Error ? cause.message : "Review the question template and retry." }),

package/src/server/responses/registerQuestion.ts

@@ -2,21 +2,21 @@ import { Clock, Effect } from "effect";
 import { Conflict, Forbidden, PreconditionFailed, type ServiceUnavailable } from "@shivaedev/platform/errors/taxonomy.ts";
 import type { Question } from "#browser/responses/schema.ts";
 import type { Snapshot } from "#server/search/snapshot.ts";
+import type { WorkspaceSettings } from "#server/workspace.ts";
 import type { locate as locateQuestion } from "./locate.ts";
 import { publish } from "./publish.ts";
 import type { readResponses } from "./read.ts";
 import { questionMarkdown } from "./records.ts";
-import type { ResponseOptions } from "./service.ts";
 
 const HOURS_48 = 48 * 60 * 60 * 1000;
 export function registerQuestion(
-	options: ResponseOptions,
+	options: WorkspaceSettings,
 	snapshot: Effect.Effect<Snapshot, ServiceUnavailable>,
 	locate: ReturnType<typeof locateQuestion>,
 	read: ReturnType<typeof readResponses>,
 ) {
 	return Effect.fn("WorkBoard.registerQuestion")(function* (input: { readonly item: string; readonly request: string; readonly revision: string }) {
-		if (!options.enabled) {
+		if (!options.writable) {
 			return yield* Effect.fail(new Forbidden({ message: "Start with --responses to explicitly enable local question/response writes." }));
 		}
 		const preview = yield* locate(input.item, input.request);
@@ -32,7 +32,7 @@ export function registerQuestion(
 				);
 			}
 			const saved = (yield* read(preview.id)).question;
-			yield* publish(options.root, options.changes.realRoot, saved.id, questionMarkdown(saved));
+			yield* publish(options.root, options.realRoot, saved.id, questionMarkdown(saved));
 			return saved;
 		}
 		const now = yield* Clock.currentTimeMillis;
@@ -49,7 +49,7 @@ export function registerQuestion(
 				source: preview.source,
 			},
 		};
-		yield* publish(options.root, options.changes.realRoot, question.id, questionMarkdown(question)).pipe(
+		yield* publish(options.root, options.realRoot, question.id, questionMarkdown(question)).pipe(
 			Effect.ensuring(options.changes.refresh ?? Effect.void),
 		);
 		return question;

package/src/server/responses/retry.ts

@@ -3,15 +3,15 @@ import { Conflict } from "@shivaedev/platform/errors/taxonomy.ts";
 import type { DraftInput, RecordedResponse } from "#browser/responses/schema.ts";
 import type { ResponseRejection } from "#rpc/rejections.ts";
 import type { Snapshot } from "#server/search/snapshot.ts";
+import type { WorkspaceSettings } from "#server/workspace.ts";
 import { publish } from "./publish.ts";
 import { matchesResponse, responseMarkdown } from "./records.ts";
-import type { ResponseOptions } from "./service.ts";
 
 export const retryResponse = Effect.fn("WorkBoard.retryResponse")(function* (
 	existing: RecordedResponse,
 	input: DraftInput,
 	snapshot: Effect.Effect<Snapshot, ResponseRejection>,
-	options: ResponseOptions,
+	options: WorkspaceSettings,
 ) {
 	if (!matchesResponse(existing, input)) {
 		return yield* Effect.fail(new Conflict({ message: "The response identity already records different content." }));
@@ -19,5 +19,5 @@ export const retryResponse = Effect.fn("WorkBoard.retryResponse")(function* (
 	if ((yield* snapshot).model.ids.get(input.id)?.[0]?.file !== `responses/${input.id}.md`) {
 		return yield* Effect.fail(new Conflict({ message: "The saved response moved. Read its existing record instead of retrying a write." }));
 	}
-	yield* publish(options.root, options.changes.realRoot, existing.id, responseMarkdown(existing));
+	yield* publish(options.root, options.realRoot, existing.id, responseMarkdown(existing));
 });

package/src/server/rpc/HandlerOptions.ts

@@ -1,16 +1,8 @@
 import type { Effect } from "effect";
 import type { ServiceUnavailable } from "@shivaedev/platform/errors/taxonomy.ts";
-import type { Document } from "#browser/document/schema.ts";
 import type { Server } from "#rpc/Server.ts";
-import type { Changes } from "#server/files/changes.ts";
-import type { Snapshot } from "#server/search/snapshot.ts";
 
 export interface HandlerOptions {
-	readonly changes: Changes;
-	readonly document?: (url: string) => Effect.Effect<Document, unknown>;
 	readonly fleetPort?: number | null;
-	readonly home: string | undefined;
-	readonly index: Effect.Effect<Snapshot, unknown>;
 	readonly server?: Effect.Effect<typeof Server.Type, ServiceUnavailable>;
-	readonly writable?: boolean;
 }

package/src/server/rpc/handlers.ts

@@ -1,19 +1,19 @@
 import { Effect, Layer, Ref, Stream } from "effect";
-import { InternalServerError, NotFound, ServiceUnavailable } from "@shivaedev/platform/errors/taxonomy.ts";
+import { InternalServerError, ServiceUnavailable } from "@shivaedev/platform/errors/taxonomy.ts";
 import { rpcBoundary } from "@shivaedev/platform/rpc-server/boundary.ts";
 import { requestTracingLayer } from "@shivaedev/platform/rpc-server/tracing.ts";
-import { Diagnostics } from "#diagnostics/source.ts";
 import { workRpcs } from "#rpc/contract.ts";
 import { DocumentRejection, ResponseRejection } from "#rpc/rejections.ts";
 import { HandoffsService } from "#server/handoffs/Service.ts";
 import { libraryData } from "#server/navigation/libraryData.ts";
 import { navigationData } from "#server/navigation/model.ts";
-import { Responses } from "#server/responses/service.ts";
+import { Responses } from "#server/Responses.ts";
 import { searchMatch } from "#server/search/match.ts";
 import { fleetItems } from "#server/views/fleetItems.ts";
 import { goals } from "#server/views/goals.ts";
 import { projectionQueries } from "#server/views/projectionQueries.ts";
 import { remainingQueries } from "#server/views/remainingQueries.ts";
+import { Workspace } from "#server/workspace.ts";
 import type { HandlerOptions } from "./HandlerOptions.ts";
 import { hints } from "./hints.ts";
 
@@ -21,25 +21,29 @@ const readBoundary = rpcBoundary(InternalServerError, { unexpected: (message) =>
 const documentBoundary = rpcBoundary(DocumentRejection, { unexpected: (message) => new InternalServerError({ message }) });
 const responseBoundary = rpcBoundary(ResponseRejection, { unexpected: (message) => new InternalServerError({ message }) });
 
-export const handlers = Effect.fn("WorkBoard.handlers")(function* (options: HandlerOptions) {
-	const { changes, document, home, index } = options;
-	const projections = projectionQueries({ document, index });
+export const handlers = Effect.fn("WorkBoard.handlers")(function* (options: HandlerOptions = {}) {
+	const workspace = yield* Workspace;
+	const { changes, home } = yield* workspace.settings();
+	const index = workspace.index();
+	const document = workspace.document;
+	const projections = yield* projectionQueries;
 	const handoffs = yield* HandoffsService;
 	const responses = yield* Responses;
-	const diagnostics = yield* Diagnostics;
-	const remaining = remainingQueries(options, { diagnostics, handoffs, responses });
+	const remaining = yield* remainingQueries;
 	return workRpcs
 		.toLayer({
 			"work-board.awaitResponse": (input) => Effect.suspend(() => responses.awaitResponse(input)).pipe(responseBoundary),
 			"work-board.board": ({ url }) => Effect.suspend(() => projections.board(url)).pipe(documentBoundary),
 			"work-board.diagnostics": () => remaining.diagnostics().pipe(readBoundary),
-			"work-board.document": ({ url }) =>
-				Effect.suspend(() => (document ? document(url) : Effect.fail(new NotFound({ message: "The document is missing." })))).pipe(documentBoundary),
-			"work-board.fleetItems": () => fleetItems(options),
+			"work-board.document": ({ url }) => Effect.suspend(() => document(url)).pipe(documentBoundary),
+			"work-board.fleetItems": () => fleetItems(options.fleetPort).pipe(readBoundary),
 			"work-board.goals": () =>
 				Effect.gen(function* () {
 					const snapshot = yield* index;
-					return goals(snapshot, yield* fleetItems({ ...options, index: Effect.succeed(snapshot) }));
+					return goals(
+						snapshot,
+						yield* fleetItems(options.fleetPort).pipe(Effect.provideService(Workspace, { ...workspace, index: () => Effect.succeed(snapshot) })),
+					);
 				}).pipe(readBoundary),
 			"work-board.handoff": ({ url }) => remaining.handoff(url).pipe(documentBoundary),
 			"work-board.handoffSource": ({ item }) => Effect.suspend(() => handoffs.locate(item)).pipe(responseBoundary),
@@ -57,7 +61,6 @@ export const handlers = Effect.fn("WorkBoard.handlers")(function* (options: Hand
 			"work-board.question": ({ item, request }) => Effect.suspend(() => responses.locate(item, request)).pipe(responseBoundary),
 			"work-board.recordResponse": (input) => Effect.suspend(() => responses.record(input)).pipe(responseBoundary),
 			"work-board.registerQuestion": (input) => Effect.suspend(() => responses.register(input)).pipe(responseBoundary),
-			"work-board.respond": ({ url }) => remaining.respond(url).pipe(documentBoundary),
 			"work-board.responses": ({ question }) => Effect.suspend(() => responses.read(question)).pipe(responseBoundary),
 			"work-board.result": ({ url }) => remaining.result(url).pipe(documentBoundary),
 			"work-board.search": ({ query }) =>
@@ -66,8 +69,7 @@ export const handlers = Effect.fn("WorkBoard.handlers")(function* (options: Hand
 				),
 			"work-board.server": () => options.server ?? Effect.fail(new ServiceUnavailable({ message: "The board server address is unavailable." })),
 			"work-board.start": () => remaining.start().pipe(readBoundary),
-			"work-board.subscribe": () =>
-				hints(changes, index).pipe(Stream.catchCause((cause) => Stream.fromEffect(Effect.failCause(cause).pipe(readBoundary)))),
+			"work-board.subscribe": () => hints().pipe(Stream.catchCause((cause) => Stream.fromEffect(Effect.failCause(cause).pipe(readBoundary)))),
 			"work-board.watcher": () => Effect.map(Ref.get(changes.watching), (watching) => ({ watching })).pipe(readBoundary),
 			"work-board.work": ({ url }) => Effect.suspend(() => projections.work(url)).pipe(documentBoundary),
 		})

package/src/server/rpc/hints.ts

@@ -1,12 +1,15 @@
 import { Effect, PubSub, Stream } from "effect";
 import type { LiveHint } from "@shivaedev/effect-contract/live.ts";
-import type { Change, Changes } from "#server/files/changes.ts";
-import type { Snapshot } from "#server/search/snapshot.ts";
+import type { Change } from "#server/files/changes.ts";
+import { Workspace } from "#server/workspace.ts";
 import { affected } from "./affected.ts";
 
-export function hints(changes: Changes, index: Effect.Effect<Snapshot, unknown>) {
+export function hints() {
 	return Stream.unwrap(
 		Effect.gen(function* () {
+			const workspace = yield* Workspace;
+			const { changes } = yield* workspace.settings();
+			const index = workspace.index();
 			const subscription = yield* PubSub.subscribe(changes.events);
 			let sequence = changes.sequence ? yield* changes.sequence : undefined;
 			let previous = yield* Effect.option(index);

package/src/server/views/fleetItems.ts

@@ -2,10 +2,10 @@ import { Effect } from "effect";
 import type { FleetItemsProjection } from "#browser/views/FleetItemsProjection.ts";
 import { DAEMON_PORT } from "#diagnostics/daemonContract.ts";
 import { daemonUnavailableReason, readDaemon } from "#server/diagnostics/daemon.ts";
-import type { HandlerOptions } from "#server/rpc/HandlerOptions.ts";
 import { itemsOf } from "#server/views/items.ts";
+import { Workspace } from "#server/workspace.ts";
 
-export function fleetItems({ index, fleetPort = DAEMON_PORT }: Pick<HandlerOptions, "index" | "fleetPort">): Effect.Effect<FleetItemsProjection> {
+export function fleetItems(fleetPort: number | null = DAEMON_PORT): Effect.Effect<FleetItemsProjection, never, Workspace> {
 	if (fleetPort === null) {
 		return Effect.succeed({ reason: "Fleet daemon is not configured for this Board", state: "unavailable" });
 	}
@@ -15,7 +15,11 @@ export function fleetItems({ index, fleetPort = DAEMON_PORT }: Pick<HandlerOptio
 			return { reason: daemonUnavailableReason(result.failure, fleetPort), state: "unavailable" as const };
 		}
 		const data = result.success;
-		const snapshot = yield* index;
+		const workspace = yield* Workspace;
+		const snapshot = yield* workspace.index().pipe(Effect.catch(() => Effect.succeed(undefined)));
+		if (!snapshot) {
+			return { reason: "Board documents could not be read for Fleet items", state: "unavailable" as const };
+		}
 		const documents = new Map(
 			itemsOf(snapshot).map(({ id, document, title }) => [id, { file: document.file, metadata: document.parsed.fields, title }]),
 		);
@@ -24,5 +28,5 @@ export function fleetItems({ index, fleetPort = DAEMON_PORT }: Pick<HandlerOptio
 			items: data.items.map((item) => ({ ...item, document: documents.get(item.workId) ?? null })),
 			state: "ready" as const,
 		};
-	}).pipe(Effect.catchCause(() => Effect.succeed({ reason: "Board documents could not be read for Fleet items", state: "unavailable" as const })));
+	});
 }

package/src/server/views/projectionQueries.ts

@@ -1,21 +1,20 @@
 import { Effect } from "effect";
-import { NotFound } from "@shivaedev/platform/errors/taxonomy.ts";
 import type { BoardProjection, WorkProjection } from "#browser/views/schema.ts";
 import { stateOf } from "#browser/views/state.ts";
 import { inboxItems } from "#server/attention/inbox.ts";
 import { attentionProjection } from "#server/attention/projection.ts";
 import { identityUrl } from "#server/metadata/links.ts";
 import { boardOf, countsOf } from "#server/render/board.ts";
-import type { HandlerOptions } from "#server/rpc/HandlerOptions.ts";
 import type { Snapshot } from "#server/search/snapshot.ts";
+import { Workspace } from "#server/workspace.ts";
 import { fleetApproval } from "./fleetApproval.ts";
 import type { Item } from "./items.ts";
 import { projectItems } from "./projection.ts";
 
-export function projectionQueries({ index, document }: { readonly index: HandlerOptions["index"]; readonly document: HandlerOptions["document"] }) {
-	function read(url: string) {
-		return document ? document(url) : Effect.fail(new NotFound({ message: "The document is missing." }));
-	}
+export const projectionQueries = Effect.gen(function* () {
+	const workspace = yield* Workspace;
+	const index = workspace.index();
+	const read = workspace.document;
 	return {
 		board: (url: string) => Effect.map(read(url), (data): BoardProjection => ({ counts: countsOf(boardOf(data.source)), document: data })),
 		inbox: () => Effect.map(index, attentionProjection),
@@ -54,7 +53,7 @@ export function projectionQueries({ index, document }: { readonly index: Handler
 				} satisfies WorkProjection;
 			}),
 	};
-}
+});
 function selectionProblem(snapshot: Snapshot, item: string) {
 	return (snapshot.model.ids.get(item)?.length ?? 0) > 1 ? "has a duplicate ID" : "is missing or its identity changed";
 }

package/src/server/views/remainingQueries.ts

@@ -1,24 +1,18 @@
 import { Clock, Effect } from "effect";
-import { Conflict, NotFound } from "@shivaedev/platform/errors/taxonomy.ts";
-import type { Diagnostics } from "#diagnostics/source.ts";
-import type { HandoffsService } from "#server/handoffs/Service.ts";
+import { Conflict } from "@shivaedev/platform/errors/taxonomy.ts";
+import { Diagnostics } from "#diagnostics/source.ts";
+import { HandoffsService } from "#server/handoffs/Service.ts";
 import { identityUrl } from "#server/metadata/links.ts";
 import { metadataParse } from "#server/metadata/parse.ts";
 import { startTemplates } from "#server/page/startTemplates.ts";
-import type { Responses } from "#server/responses/service.ts";
-import type { HandlerOptions } from "#server/rpc/HandlerOptions.ts";
+import { Workspace } from "#server/workspace.ts";
 import { resultProjection } from "./resultProjection.ts";
-export function remainingQueries(
-	{ changes, document, index, writable }: HandlerOptions,
-	services: {
-		readonly diagnostics: typeof Diagnostics.Service;
-		readonly responses: typeof Responses.Service;
-		readonly handoffs: typeof HandoffsService.Service;
-	},
-) {
-	function read(url: string) {
-		return document ? document(url) : Effect.fail(new NotFound({ message: "The document is missing." }));
-	}
+export const remainingQueries = Effect.gen(function* () {
+	const workspace = yield* Workspace;
+	const { changes, writable } = yield* workspace.settings();
+	const index = workspace.index();
+	const read = workspace.document;
+	const services = { diagnostics: yield* Diagnostics, handoffs: yield* HandoffsService };
 	return {
 		diagnostics: () =>
 			Effect.gen(function* () {
@@ -42,20 +36,6 @@ export function remainingQueries(
 					writable: writable === true,
 				};
 			}),
-		respond: (url: string) =>
-			Effect.gen(function* () {
-				const params = new URL(url, "http://127.0.0.1").searchParams;
-				const service = services.responses;
-				const preview = yield* service.locate(params.get("item") ?? "", params.get("request") ?? "");
-				yield* service.read(preview.id).pipe(Effect.catch((error) => (error._tag === "NotFound" ? Effect.void : Effect.fail(error))));
-				const responses = yield* service.history(preview);
-				const data = yield* read(identityUrl(preview.item));
-				const request = data.requests.find((entry) => entry.id === preview.request);
-				if (!request) {
-					return yield* Effect.fail(new Conflict({ message: "The response request is unavailable." }));
-				}
-				return { document: data, request: { ...request, preview, responses } };
-			}),
 		result: (url: string) =>
 			Effect.gen(function* () {
 				const item = new URL(url, "http://127.0.0.1").searchParams.get("item") ?? "";
@@ -71,4 +51,4 @@ export function remainingQueries(
 			}),
 		start: () => Effect.map(changes.files, (files) => ({ empty: files.length === 0, templates: startTemplates })),
 	};
-}
+});

package/src/server/workspace.ts

@@ -0,0 +1,41 @@
+import { Context, Effect, FileSystem, Path, type PlatformError } from "effect";
+import { defineService } from "@shivaedev/effect-service/define-service.ts";
+import type { Document } from "#browser/document/schema.ts";
+import { readDocument } from "#server/document/read.ts";
+import type { Changes } from "#server/files/changes.ts";
+import type { Snapshot } from "#server/search/snapshot.ts";
+
+export interface WorkspaceOptions {
+	readonly changes: Changes;
+	readonly home?: string | undefined;
+	readonly index: Effect.Effect<Snapshot, PlatformError.PlatformError>;
+	readonly root: string;
+	readonly writable: boolean;
+}
+
+export interface WorkspaceSettings extends Omit<WorkspaceOptions, "index"> {
+	readonly realRoot: string;
+}
+
+export class WorkspaceConfig extends Context.Service<WorkspaceConfig, WorkspaceOptions>()("WorkBoard/WorkspaceConfig") {}
+
+export const Workspace = defineService({
+	id: "WorkBoard/Workspace",
+	initialize: Effect.gen(function* () {
+		return yield* WorkspaceConfig;
+	}),
+	methods: ({ index, ...options }) => {
+		const settings = { ...options, realRoot: options.changes.realRoot };
+		const read = readDocument(settings);
+		function document(url: string): Effect.Effect<Document, Effect.Error<ReturnType<typeof read>>, Effect.Services<ReturnType<typeof read>>> {
+			return Effect.flatMap(index, (snapshot) => read(url, snapshot));
+		}
+		return {
+			document,
+			index: () => index,
+			settings: () => Effect.succeed(settings),
+		};
+	},
+	requires: [WorkspaceConfig, FileSystem.FileSystem, Path.Path],
+});
+export type Workspace = typeof Workspace.Identifier;