@shivaedev/work-board 0.15.0 → 0.17.0

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

@@ -86,6 +86,7 @@ export function inboxItems(snapshot: Snapshot) {
 						id: id ?? document.file,
 						problem,
 						reason,
+						request: undefined,
 						title: titles.get(document.file) ?? document.file,
 						unblocks: [id ?? ""],
 					},

package/src/server/attention/projection.ts

@@ -12,7 +12,7 @@ export function attentionProjection(snapshot: Snapshot): InboxProjection {
 		return cached;
 	}
 	const requests = requestInbox(snapshot);
-	function project({ document, unblocks: _unblocks, ...item }: ReturnType<typeof inboxItems>[number]) {
+	function project({ document, request: _request, unblocks: _unblocks, ...item }: ReturnType<typeof inboxItems>[number]) {
 		return { ...item, file: document.file };
 	}
 	const you = inboxItems(snapshot).map(project);

package/src/server/attention/requestInbox.ts

@@ -28,6 +28,7 @@ export function requestInbox(snapshot: Snapshot) {
 			modified: snapshot.modified.get(entry.document.file),
 			problem: undefined,
 			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/board.ts

@@ -3,7 +3,7 @@ import { HttpRouter } from "effect/http";
 import { RpcSerialization, RpcServer } from "effect/rpc";
 import type { InternalServerError } from "@shivaedev/platform/errors/taxonomy.ts";
 import { localRpcGuard } from "@shivaedev/platform/rpc-server/local.ts";
-import type { RenderFailed } from "#render/failed.ts";
+import type { RenderFailed } from "#render/Failed.ts";
 import { workRpcs } from "#rpc/contract.ts";
 import { boardRuntime } from "#server/boardRuntime.ts";
 import type { HomeMissing } from "#server/files/home.ts";

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

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.15.0";
+export const VERSION = "0.17.0";

package/src/server/render/Highlighter.ts

@@ -2,7 +2,7 @@ import { Effect } from "effect";
 import { createHighlighter } from "shiki";
 import { defineService } from "@shivaedev/effect-service/define-service.ts";
 import { codeBlocks, THEMES } from "#render/code.ts";
-import { RenderFailed } from "#render/failed.ts";
+import { RenderFailed } from "#render/Failed.ts";
 
 export const Highlighter = defineService({
 	id: "WorkBoard/Highlighter",

package/src/server/render/markdown.ts

@@ -7,8 +7,8 @@ import type { PluggableList } from "unified";
 import type { documentHeadings } from "#render/documentHeadings.ts";
 import { documentLinks } from "#render/documentLinks.ts";
 import { documentPlugins } from "#render/documentPlugins.ts";
-import { RenderFailed } from "#render/failed.ts";
-import { footnoteIds } from "#render/footnotes.ts";
+import { RenderFailed } from "#render/Failed.ts";
+import { footnoteIds } from "#render/footnoteIds.ts";
 import { Highlighter } from "./Highlighter.ts";
 
 export interface RenderOptions {

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