@shivaedev/work-board 0.11.0 → 0.12.0

package/src/browser/responses/questionnaireControls.ts

@@ -1,74 +0,0 @@
-import type { Draft } from "./drafts.ts";
-import type { Prompt } from "./Prompt.ts";
-import type { PromptAnswer } from "./schema.ts";
-
-function restoreAnswers(fields: readonly HTMLFieldSetElement[], draft: Draft, same: boolean) {
-	for (const field of fields) {
-		const answer = draft.answers?.find((entry) => entry.prompt === field.dataset.prompt);
-		for (const input of field.querySelectorAll<HTMLInputElement>("input")) {
-			input.checked = same && (answer?.selected.includes(input.value) ?? false);
-		}
-		const text = field.querySelector<HTMLTextAreaElement>("textarea");
-		if (text) {
-			text.value = answer?.text ?? "";
-		}
-	}
-}
-export function questionnaireControls(form: HTMLFormElement) {
-	function modeOf(field: HTMLFieldSetElement) {
-		if (field.dataset.mode === "text") {
-			return "text";
-		}
-		return field.dataset.mode === "many" ? "many" : "one";
-	}
-	const fields = [...form.querySelectorAll<HTMLFieldSetElement>("fieldset[data-prompt]")];
-	const models: Prompt[] = fields.map((field) => ({
-		id: field.dataset.prompt ?? "",
-		mode: modeOf(field),
-		options: [...field.querySelectorAll<HTMLInputElement>("input[data-option-source]")].map((input) => ({
-			id: input.value,
-			source: input.dataset.optionSource ?? "",
-		})),
-		source: field.dataset.source ?? "",
-	}));
-	function read(): readonly PromptAnswer[] | undefined {
-		return fields.length === 0
-			? undefined
-			: fields.map((field) => ({
-					prompt: field.dataset.prompt ?? "",
-					selected: [...field.querySelectorAll<HTMLInputElement>("input:checked")].map((input) => input.value),
-					text: field.querySelector<HTMLTextAreaElement>("textarea")?.value ?? "",
-				}));
-	}
-	function restore(draft: Draft, revision: string) {
-		const same = draft.revision === revision && (draft.question === undefined || draft.question === form.dataset.question);
-		restoreAnswers(fields, draft, same);
-		const recovery = form.querySelector<HTMLPreElement>("#response-draft-recovery");
-		const retained =
-			!same && draft.answers
-				? `Earlier template answers (selections cleared; review before choosing again):\n${JSON.stringify(draft.answers, null, 2)}\n${draft.recovery ?? ""}`
-				: draft.recovery;
-		if (recovery) {
-			recovery.textContent = retained ?? "";
-			recovery.hidden = !retained;
-		}
-		return retained;
-	}
-	function validate(type: string) {
-		for (const field of fields) {
-			const text = field.querySelector<HTMLTextAreaElement>("textarea");
-			text?.setCustomValidity(
-				type === "answer" && !text.value.trim() && !field.querySelector("input:checked") ? "Choose an option or answer in your own words." : "",
-			);
-		}
-	}
-	for (const field of fields) {
-		field.querySelector("[data-clear-choices]")?.addEventListener("click", () => {
-			for (const input of field.querySelectorAll<HTMLInputElement>("input")) {
-				input.checked = false;
-			}
-			form.dispatchEvent(new Event("input", { bubbles: true }));
-		});
-	}
-	return { models, read, restore, validate };
-}

package/src/browser/responses/setup.ts

@@ -1,132 +0,0 @@
-import { draftSession } from "./draftSession.ts";
-import { responsePreview } from "./preview.ts";
-import { questionnaireControls } from "./questionnaireControls.ts";
-import { submitResponse } from "./submit.ts";
-
-function attach() {
-	const doc = document.getElementById("doc");
-	if (doc?.dataset.view !== "response") {
-		return;
-	}
-	const form = doc.querySelector<HTMLFormElement>("#response-form");
-	if (!form || form.dataset.bound === "true") {
-		return;
-	}
-	form.dataset.bound = "true";
-	const status = form.querySelector<HTMLParagraphElement>("#response-status");
-	const author = form.elements.namedItem("author");
-	const body = form.elements.namedItem("body");
-	const type = form.elements.namedItem("type");
-	const supersedes = form.elements.namedItem("supersedes");
-	const submit = form.querySelector<HTMLButtonElement>("#response-submit");
-	const preview = form.querySelector<HTMLPreElement>("#response-preview-content");
-	const clear = form.querySelector<HTMLButtonElement>("#response-clear");
-	const previewButton = form.querySelector<HTMLButtonElement>("#response-preview");
-	if (
-		!(
-			status
-			&& author instanceof HTMLInputElement
-			&& body instanceof HTMLTextAreaElement
-			&& type instanceof HTMLSelectElement
-			&& submit
-			&& preview
-			&& clear
-			&& previewButton
-		)
-	) {
-		return;
-	}
-	if (status.textContent?.includes("JavaScript is required")) {
-		status.textContent = "Draft ready. Preview the Markdown before recording it.";
-	}
-	const item = form.dataset.item ?? "";
-	const request = form.dataset.request ?? "";
-	const revision = form.dataset.revision ?? "";
-	const questionId = form.dataset.question ?? "";
-	const key = `${item}/${request}`;
-	const storage = `work-board:drafts:${document.documentElement.dataset.workspace}`;
-	let storageApi: Storage | undefined;
-	try {
-		storageApi = window.localStorage;
-	} catch {
-		storageApi = undefined;
-	}
-	const drafts = draftSession(key, revision, storageApi, storage, (message) => {
-		status.textContent = message;
-	});
-	let draft = drafts.current();
-	const controls = questionnaireControls(form);
-	let recovery = controls.restore(draft, revision);
-	if (draft.question && draft.question !== questionId && draft.revision === revision) {
-		status.textContent = "Source moved since this draft. Text is retained and selections cleared; review the source and preview before responding.";
-	}
-	if (supersedes instanceof HTMLSelectElement) {
-		supersedes.value = draft.supersedes ?? "";
-	}
-	author.value = draft.author;
-	body.value = draft.body;
-	type.value = draft.type;
-	const fields = { author, body, type };
-	function save() {
-		draft = drafts.update({
-			answers: controls.read(),
-			author: fields.author.value,
-			body: fields.body.value,
-			question: draft.question ?? questionId,
-			recovery,
-			revision: draft.revision,
-			supersedes: supersedes instanceof HTMLSelectElement ? supersedes.value || undefined : undefined,
-			type: fields.type.value,
-		});
-	}
-	form.addEventListener("input", () => {
-		save();
-		preview.hidden = true;
-		submit.disabled = true;
-	});
-	previewButton.disabled = false;
-	clear.disabled = false;
-	previewButton.addEventListener("click", () => {
-		controls.validate(type.value);
-		draft = drafts.update({
-			answers: controls.read(),
-			author: author.value,
-			body: body.value,
-			id: draft.revision === revision && (!draft.question || draft.question === questionId) ? drafts.current().id : `response.${crypto.randomUUID()}`,
-			question: questionId,
-			recovery,
-			revision,
-			supersedes: supersedes instanceof HTMLSelectElement ? supersedes.value || undefined : undefined,
-			type: type.value,
-		});
-		preview.textContent = responsePreview(draft, questionId ?? "", controls.models);
-		preview.hidden = false;
-		submit.disabled = form.dataset.writable !== "true" || !form.checkValidity();
-	});
-	clear.addEventListener("click", drafts.clear);
-	form.addEventListener("submit", async (event) => {
-		event.preventDefault();
-		if (submit.disabled || draft.revision !== revision || draft.question !== questionId || !form.reportValidity()) {
-			return;
-		}
-		submit.disabled = true;
-		previewButton.disabled = true;
-		if (await submitResponse(form, status, drafts, draft)) {
-			draft = drafts.current();
-			recovery = draft.recovery;
-			if (form.isConnected) {
-				body.value = "";
-				controls.restore(draft, revision);
-				if (supersedes instanceof HTMLSelectElement) {
-					supersedes.value = "";
-				}
-			}
-		}
-		previewButton.disabled = false;
-	});
-}
-export function setupResponses() {
-	document.addEventListener("board-page", attach);
-	window.addEventListener("pageshow", attach);
-	attach();
-}

package/src/browser/responses/submissionFields.ts

@@ -1,15 +0,0 @@
-import { Schema } from "effect";
-import type { Draft } from "./drafts.ts";
-import { ResponseKind } from "./schema.ts";
-
-export function submissionFields(pending: Draft, question: string) {
-	return {
-		...(pending.answers === undefined ? {} : { answers: pending.answers }),
-		...(pending.supersedes === undefined ? {} : { supersedes: pending.supersedes }),
-		author: pending.author,
-		body: pending.body,
-		id: pending.id,
-		question,
-		type: Schema.decodeUnknownSync(ResponseKind)(pending.type),
-	};
-}

package/src/browser/responses/submit.ts

@@ -1,33 +0,0 @@
-import { session } from "#browser/session.ts";
-import type { draftSession } from "./draftSession.ts";
-import type { Draft } from "./drafts.ts";
-import { ResponseFailed } from "./schema.ts";
-import { submissionFields } from "./submissionFields.ts";
-
-export async function submitResponse(form: HTMLFormElement, status: HTMLParagraphElement, drafts: ReturnType<typeof draftSession>, pending: Draft) {
-	status.dataset.outcome = "pending";
-	status.textContent = "Pending: registering reviewed context, then recording response…";
-	const native = session(window);
-	try {
-		const question = await native.mutate(
-			native.responses.registerQuestion.run({ item: form.dataset.item ?? "", request: form.dataset.request ?? "", revision: pending.revision }),
-		);
-		await native.mutate(native.responses.recordResponse.run(submissionFields(pending, question.id)));
-		if (form.isConnected) {
-			status.dataset.outcome = "saved";
-			status.textContent = `Saved: responses/${pending.id}.md. This records feedback, not acceptance.`;
-		}
-		const cleared = drafts.saved(pending);
-		if (!cleared && form.isConnected) {
-			status.textContent += " Your current draft remains unsaved.";
-		}
-		return cleared;
-	} catch (error) {
-		if (form.isConnected) {
-			const outcome = error instanceof ResponseFailed && error.code !== "Uncertain" ? "rejected" : "uncertain";
-			status.dataset.outcome = outcome;
-			status.textContent = `${outcome === "rejected" ? "Rejected" : "Uncertain"}: ${String(error)}. Draft retained. Preview and retry with the same identity; saved content will be reconciled.`;
-		}
-		return false;
-	}
-}

package/src/cli.ts

@@ -1,16 +0,0 @@
-#!/usr/bin/env node
-const action = process.argv[2];
-if (action === "wait" || action === "response" || action === "question") {
-	try {
-		const entry: typeof import("#responses/agent-cli.ts") = await import(new URL("../assets/agent.js", import.meta.url).href);
-		await entry.runAgent(process.argv.slice(2));
-	} catch (error) {
-		process.stderr.write(`${String(error)}\n`);
-		process.exitCode ??= 1;
-	}
-} else {
-	const entry = await import("./serve-cli.ts");
-	entry.runServe();
-}
-
-export {};

package/src/files/changes.ts

@@ -1,71 +0,0 @@
-import { Deferred, Effect, FileSystem, Option, Path, type PlatformError, PubSub, Ref, Schedule } from "effect";
-import { listMarkdown, type MarkdownFile } from "./list.ts";
-import { watchDirectories } from "./watchDirectories.ts";
-
-export type Change = ({ readonly _tag: "Changed"; readonly paths: readonly string[] } | { readonly _tag: "Watching"; readonly watching: boolean }) & {
-	readonly sequence?: number;
-};
-
-export interface Changes {
-	readonly events: PubSub.PubSub<Change>;
-	readonly files: Effect.Effect<readonly MarkdownFile[], PlatformError.PlatformError>;
-	readonly realRoot: string;
-	readonly refresh?: Effect.Effect<void>;
-	readonly revision: Effect.Effect<number>;
-	readonly sequence?: Effect.Effect<number>;
-	readonly watching: Ref.Ref<boolean>;
-}
-
-interface Cached {
-	readonly files: readonly MarkdownFile[];
-	readonly generation: number;
-}
-
-const BACKLOG = 16;
-const RETRY = Schedule.min([Schedule.exponential("100 millis"), Schedule.spaced("5 seconds")]);
-
-export const watchChanges = Effect.fn("WorkBoard.watchChanges")(function* (root: string) {
-	const fs = yield* FileSystem.FileSystem;
-	const path = yield* Path.Path;
-	const realRoot = yield* fs.realPath(root);
-	const events = yield* Effect.acquireRelease(PubSub.sliding<Change>(BACKLOG), PubSub.shutdown);
-	const watching = yield* Ref.make(false);
-	const generation = yield* Ref.make(0);
-	const sequence = yield* Ref.make(0);
-	function publish(change: Change) {
-		return Effect.flatMap(
-			Ref.updateAndGet(sequence, (value) => value + 1),
-			(value) => PubSub.publish(events, { ...change, sequence: value }),
-		);
-	}
-	const cached = yield* Ref.make(Option.none<Cached>());
-	const settled = yield* Deferred.make<void>();
-	const stale = Ref.update(generation, (count) => count + 1);
-	const setWatching = (now: boolean) =>
-		Effect.andThen(
-			Effect.flatMap(Ref.getAndSet(watching, now), (was) =>
-				was === now ? Effect.void : Effect.andThen(stale, publish({ _tag: "Watching", watching: now })),
-			),
-			Deferred.succeed(settled, undefined),
-		);
-	const attempt = watchDirectories(root, realRoot, stale, setWatching, (paths) => publish({ _tag: "Changed", paths }));
-	yield* attempt.pipe(
-		Effect.sandbox,
-		Effect.tapError((cause) => Effect.andThen(setWatching(false), Effect.logWarning("Watching the folder failed; retrying", cause))),
-		Effect.retry(RETRY),
-		Effect.forkScoped,
-	);
-	yield* Deferred.await(settled);
-	const files = Effect.gen(function* () {
-		const now = yield* Ref.get(generation);
-		const hit = Option.filter(yield* Ref.get(cached), (entry) => entry.generation === now);
-		if ((yield* Ref.get(watching)) && Option.isSome(hit)) {
-			return hit.value.files;
-		}
-		const listed = yield* listMarkdown(root, realRoot).pipe(Effect.provideService(FileSystem.FileSystem, fs), Effect.provideService(Path.Path, path));
-		yield* Ref.set(cached, Option.some({ files: listed, generation: now }));
-		return listed;
-	});
-	const changes: Changes = { events, files, realRoot, refresh: stale, revision: Ref.get(generation), sequence: Ref.get(sequence), watching };
-	return changes;
-});

package/src/files/home.ts

@@ -1,41 +0,0 @@
-import { Data, Effect, FileSystem, Option, Path } from "effect";
-import { listMarkdown } from "./list.ts";
-
-export class HomeMissing extends Data.TaggedError("HomeMissing")<{ readonly message: string }> {}
-
-export const homeIn = Effect.fn("WorkBoard.homeIn")(function* (root: string, home: string | undefined) {
-	if (home === undefined) {
-		return undefined;
-	}
-	const fs = yield* FileSystem.FileSystem;
-	const path = yield* Path.Path;
-	const missing = new HomeMissing({ message: `The home file ${home} is not a markdown file in ${root}` });
-	const realRoot = yield* fs.realPath(root);
-	const real = yield* Effect.option(fs.realPath(path.resolve(root, home)));
-	if (Option.isNone(real)) {
-		return yield* missing;
-	}
-	const target = yield* Effect.option(fs.stat(real.value));
-	if (Option.isNone(target)) {
-		return yield* missing;
-	}
-	const files = yield* listMarkdown(root, realRoot);
-	const logical = path.relative(root, path.resolve(root, home)).split(path.sep).join("/");
-	if (files.some((file) => file.path === logical)) {
-		return logical;
-	}
-	const relative = path.relative(realRoot, real.value).split(path.sep).join("/");
-	if (files.some((file) => file.path === relative)) {
-		return relative;
-	}
-	const inode = Option.getOrUndefined(target.value.ino);
-	const same = (info: FileSystem.File.Info) => inode !== undefined && info.dev === target.value.dev && Option.getOrUndefined(info.ino) === inode;
-	const matches = yield* Effect.filter(files, (file) =>
-		Effect.map(Effect.option(fs.stat(path.join(realRoot, file.path))), (info) => Option.isSome(info) && same(info.value)),
-	);
-	const direct = yield* Effect.filter(matches, (file) =>
-		Effect.map(Effect.option(fs.realPath(path.join(realRoot, file.path))), (real) => Option.contains(real, path.join(realRoot, file.path))),
-	);
-	const chosen = matches.find((file) => file.path.toLowerCase() === relative.toLowerCase()) ?? direct[0] ?? matches[0];
-	return chosen === undefined ? yield* missing : chosen.path;
-});

package/src/files/list.ts

@@ -1,67 +0,0 @@
-import { Effect, FileSystem, Option, Path, type PlatformError } from "effect";
-import { isMarkdown as markdown } from "#path/isMarkdown.ts";
-
-export interface MarkdownFile {
-	readonly modified: number;
-	readonly path: string;
-}
-
-export function isMarkdown(path: string): boolean {
-	return markdown(path);
-}
-
-export const within = (realRoot: string, separator: string, real: string): boolean => real === realRoot || real.startsWith(`${realRoot}${separator}`);
-
-const folderOf = (path: string): string => path.slice(0, Math.max(0, path.lastIndexOf("/")));
-
-const byFolder = (left: string, right: string): number => folderOf(left).localeCompare(folderOf(right)) || left.localeCompare(right);
-
-type Listing = Effect.Effect<readonly MarkdownFile[], PlatformError.PlatformError>;
-
-export const scanMarkdown = Effect.fn("WorkBoard.scanMarkdown")(function* (root: string, realRoot: string) {
-	const fs = yield* FileSystem.FileSystem;
-	const path = yield* Path.Path;
-	const roots: Array<{ readonly real: string; readonly relative: string }> = [{ real: realRoot, relative: "" }];
-	const entry = (relative: string, boundary: string, ancestors: ReadonlySet<string>, parent: string): Listing =>
-		Effect.gen(function* () {
-			const real = yield* Effect.option(fs.realPath(path.join(root, relative)));
-			if (Option.isNone(real)) {
-				return [];
-			}
-			const info = yield* Effect.option(fs.stat(real.value));
-			if (Option.isNone(info)) {
-				return [];
-			}
-			if (info.value.type === "Directory") {
-				return yield* directory(relative, real.value, boundary, ancestors, real.value !== path.join(parent, path.basename(relative)));
-			}
-			const modified = Option.match(info.value.mtime, { onNone: () => 0, onSome: (date) => date.getTime() });
-			return info.value.type === "File" && relative.endsWith(".md") && within(boundary, path.sep, real.value) ? [{ modified, path: relative }] : [];
-		});
-	function directory(relative: string, real: string, boundary: string, ancestors: ReadonlySet<string>, alias: boolean): Listing {
-		if (ancestors.has(real) || within(real, path.sep, realRoot)) {
-			return Effect.succeed([]);
-		}
-		const linked = !within(boundary, path.sep, real);
-		if (alias) {
-			roots.push({ real, relative });
-		}
-		return Effect.orElseSucceed(folder(relative, real, linked ? real : boundary, ancestors), () => []);
-	}
-	const folder = (relative: string, real: string, boundary: string, ancestors: ReadonlySet<string>): Listing =>
-		Effect.gen(function* () {
-			const branch = new Set([...ancestors, real]);
-			const names = yield* fs.readDirectory(real);
-			const found = yield* Effect.forEach(
-				names.filter((name) => !name.startsWith(".") && name !== "node_modules"),
-				(name) => entry(relative === "" ? name : `${relative}/${name}`, boundary, branch, real),
-			);
-			return found.flat();
-		});
-	const files = yield* folder("", realRoot, realRoot, new Set());
-	return { files: files.toSorted((left, right) => byFolder(left.path, right.path)), roots };
-});
-
-export const listMarkdown = Effect.fn("WorkBoard.listMarkdown")(function* (root: string, realRoot: string) {
-	return (yield* scanMarkdown(root, realRoot)).files;
-});

package/src/files/watchDirectories.ts

@@ -1,61 +0,0 @@
-import { Data, Deferred, Effect, FileSystem, Option, Path, Stream } from "effect";
-import { attachmentType } from "#path/attachment.ts";
-import { isMarkdown, scanMarkdown } from "./list.ts";
-
-class WatchEnded extends Data.TaggedError("WatchEnded") {}
-
-const SETTLE = "100 millis";
-const BATCH = 256;
-
-export const watchDirectories = Effect.fn("WorkBoard.watchDirectories")(function* (
-	root: string,
-	realRoot: string,
-	stale: Effect.Effect<void>,
-	setWatching: (watching: boolean) => Effect.Effect<unknown>,
-	publish: (paths: readonly string[]) => Effect.Effect<unknown>,
-) {
-	const fs = yield* FileSystem.FileSystem;
-	const path = yield* Path.Path;
-	const cycle = Effect.scoped(
-		Effect.gen(function* () {
-			const { roots } = yield* scanMarkdown(root, realRoot);
-			const topology = yield* Deferred.make<void>();
-			// Node's recursive watcher can miss replacement of directory symlinks.
-			const parents = yield* Effect.forEach(
-				roots.filter((folder) => folder.relative !== ""),
-				(folder) =>
-					Effect.map(fs.realPath(path.dirname(path.join(root, folder.relative))), (real) => ({ real, relative: path.dirname(folder.relative) })),
-			);
-			const watched = [...roots.map((folder) => ({ ...folder, recursive: true })), ...parents.map((folder) => ({ ...folder, recursive: false }))];
-			const streams = watched.map((folder) =>
-				fs.watch(folder.real, { recursive: folder.recursive }).pipe(
-					Stream.map((event) => {
-						const local = path.isAbsolute(event.path) ? path.relative(folder.real, event.path) : event.path;
-						return path.join(folder.relative, local).split(path.sep).join("/");
-					}),
-				),
-			);
-			const watch = Stream.mergeAll(streams, { concurrency: "unbounded" }).pipe(
-				Stream.tap(() => stale),
-				Stream.tap((relative) =>
-					Effect.gen(function* () {
-						const info = yield* Effect.option(fs.stat(path.join(root, relative)));
-						const removedLink = roots.some((folder) => folder.relative === relative || folder.relative.startsWith(`${relative}/`));
-						if (Option.match(info, { onNone: () => removedLink, onSome: (value) => value.type === "Directory" })) {
-							yield* Effect.forkScoped(Effect.delay(Deferred.succeed(topology, undefined), SETTLE));
-						}
-					}),
-				),
-				Stream.filter((relative) => isMarkdown(relative) || attachmentType(relative) !== undefined),
-				Stream.interruptWhen(Deferred.await(topology)),
-				Stream.groupedWithin(BATCH, SETTLE),
-				Stream.runForEach((paths) => publish([...new Set(paths)])),
-				Effect.andThen(Effect.flatMap(Deferred.isDone(topology), (changed) => (changed ? Effect.void : Effect.fail(new WatchEnded())))),
-			);
-			yield* Effect.forkScoped(Effect.delay(setWatching(true), SETTLE));
-			yield* watch;
-			yield* setWatching(false);
-		}),
-	);
-	yield* Effect.forever(cycle);
-});

package/src/handoffs/html.ts

@@ -1,42 +0,0 @@
-import { Effect } from "effect";
-import type { Handoff, HandoffPreview } from "#browser/handoffs/schema.ts";
-import { fileUrl } from "#files/url.ts";
-import { metadataParse } from "#metadata/parse.ts";
-import { escapeHtml } from "#page/escape.ts";
-import type { RenderFailed } from "#render/failed.ts";
-import type { Highlighter } from "#render/highlighter.ts";
-import { renderMarkdown } from "#render/markdown.ts";
-
-export function promptHtml(id: string, prompt: string) {
-	return `<div class="handoff-copy"><label>Prompt for your existing agent session<textarea id="handoff-prompt-${escapeHtml(id)}" readonly rows="3">${escapeHtml(prompt)}</textarea></label><button type="button" data-handoff-copy="handoff-prompt-${escapeHtml(id)}">Copy tiny prompt</button><p role="status" data-copy-status>Copy and paste this into your agent session. Preparing a file does not notify an agent.</p></div>`;
-}
-function receiptNote(h: Handoff["handoff"]) {
-	if (!(h.by || h.note)) {
-		return "";
-	}
-	return `<p>${escapeHtml(h.by ?? "Attribution not recorded")}${h.note ? ` · ${escapeHtml(h.note)}` : ""}</p>`;
-}
-export const handoffHistoryHtml = Effect.fn("WorkBoard.handoffHistoryHtml")(function* (
-	records: readonly Handoff[],
-	current?: HandoffPreview,
-): Effect.fn.Return<string[], RenderFailed, Highlighter> {
-	return yield* Effect.forEach(records, (record) =>
-		Effect.gen(function* () {
-			const h = record.handoff;
-			const goal = yield* renderMarkdown(h.goal, { file: h.source, safe: true });
-			const constraints = yield* renderMarkdown(h.constraints, { file: h.source, safe: true });
-			const next = yield* renderMarkdown(h.nextAction, { file: h.source, safe: true });
-			const same = current?.reviewedRevision === h.reviewedRevision && current.source === h.source;
-			return `<article id="${escapeHtml(record.id)}"><h3><a href="${fileUrl(record.file)}">${escapeHtml(record.id)}</a> · ${escapeHtml(h.recipient)}</h3><p><b>Receipt: ${escapeHtml(h.state)}</b>${h.state === "requested" ? " — prepared; receipt not confirmed" : ""}. Execution and acceptance are not recorded by this state.</p><p>${same ? "Current reviewed source" : "Earlier or unavailable reviewed source; recheck before acting"} · <a href="${fileUrl(h.source)}">${escapeHtml(h.source)}</a> · <code>${h.reviewedRevision}</code></p>${receiptNote(h)}<h4>Goal</h4>${goal}<h4>Constraints</h4>${constraints || "<p>None recorded.</p>"}<h4>Next action</h4>${next}${promptHtml(record.id, record.prompt)}<details><summary>Exact reviewed source snapshot</summary><pre>${escapeHtml(record.context)}</pre></details></article>`;
-		}),
-	);
-});
-export const handoffFormHtml = Effect.fn("WorkBoard.handoffFormHtml")(function* (
-	source: HandoffPreview,
-	enabled: boolean,
-): Effect.fn.Return<string, RenderFailed, Highlighter> {
-	const parsed = metadataParse(source.context);
-	const background = yield* renderMarkdown(parsed.body, { file: source.source, safe: true });
-	const goal = /^#\s+(?<title>.+)$/mu.exec(parsed.body)?.groups?.title ?? source.item;
-	return `<section class="response-context">${background}</section><details><summary>Exact source being reviewed</summary><pre>${escapeHtml(source.context)}</pre></details><form id="handoff-form" data-item="${escapeHtml(source.item)}" data-source="${escapeHtml(source.source)}" data-revision="${source.reviewedRevision}" data-question="${source.id}" data-writable="${enabled}"><label>Recipient — local agent label<input name="recipient" required maxlength="200"></label><label>Goal<textarea name="goal" required maxlength="8192" rows="3">${escapeHtml(goal)}</textarea></label><label>Constraints (optional)<textarea name="constraints" maxlength="8192" rows="4"></textarea></label><label>Next action<textarea name="nextAction" required maxlength="8192" rows="3">${escapeHtml(parsed.fields.nextAction ?? "")}</textarea></label><p>The file includes the full reviewed source and its declared acceptance criteria. Preparing it does not change the item or start an agent. Drafts use the existing 30-day/2-MiB workspace store.</p><button id="handoff-preview" type="button" disabled>Preview Markdown</button><pre id="handoff-preview-content" hidden></pre><button id="handoff-submit" type="submit" disabled>Prepare handoff</button><button id="handoff-clear" type="button" disabled>Clear workspace drafts</button><p id="handoff-status" role="status">${enabled ? "JavaScript is required to prepare a handoff." : "Read-only mode. Restart with --responses to enable local writes."}</p><section id="handoff-prepared" hidden></section></form>`;
-});

package/src/handoffs/page.ts

@@ -1,45 +0,0 @@
-import { Effect, type FileSystem, type Path, type PlatformError } from "effect";
-import type { HttpServerRequest, HttpServerResponse } from "effect/unstable/http";
-import type { Changes } from "#files/changes.ts";
-import { handoffFormHtml, handoffHistoryHtml } from "#handoffs/html.ts";
-import type { handoffService } from "#handoffs/service.ts";
-import { respond } from "#http/respond.ts";
-import { escapeHtml } from "#page/escape.ts";
-import { navHtml } from "#page/nav.ts";
-import { shell } from "#page/shell.ts";
-import type { Highlighter } from "#render/highlighter.ts";
-
-function unknownHistory(files: readonly string[]) {
-	return files.length > 0
-		? `<p role="status">Some handoff history is unavailable: ${files.map(escapeHtml).join(", ")}. Missing records do not establish that no receipt exists.</p>`
-		: "";
-}
-export function handoffPage(
-	service: Effect.Success<ReturnType<typeof handoffService>>,
-	changes: Changes,
-	home: string | undefined,
-	enabled: boolean,
-) {
-	return Effect.fn("WorkBoard.handoffPage")(function* (
-		request: HttpServerRequest.HttpServerRequest,
-	): Effect.fn.Return<HttpServerResponse.HttpServerResponse, PlatformError.PlatformError, FileSystem.FileSystem | Path.Path | Highlighter> {
-		const item = new URL(request.url, "http://127.0.0.1").searchParams.get("item") ?? "";
-		const files = yield* changes.files;
-		function layout(body: string, status = 200) {
-			return respond(shell("Handoff", navHtml(files, "", home), body, changes.realRoot, false, undefined, "handoff"), "text/html", status);
-		}
-		return yield* Effect.gen(function* () {
-			const source = yield* Effect.result(service.locate(item));
-			const current = source._tag === "Success" ? source.success : undefined;
-			const reading = yield* service.read(item);
-			const history = yield* handoffHistoryHtml(reading.records, current);
-			const form = current
-				? yield* handoffFormHtml(current, enabled)
-				: `<p role="status">Source unavailable: ${escapeHtml(String(source._tag === "Failure" ? source.failure : ""))}. Existing handoffs remain readable.</p>`;
-			return layout(
-				`<section class="response-panel"><h1>Agent handoff · ${escapeHtml(item)}</h1><p>Prepare a Markdown file, then copy a tiny prompt into your existing agent session. Sessions may poll or wait for human answers. Agents record receipt with ordinary file edits.</p>${form}<section id="handoff-history"><h2>Prepared handoffs</h2>${unknownHistory(reading.unknown)}${history.join("") || "<p>No readable handoff is recorded for this item.</p>"}</section></section>`,
-				current || reading.records.length > 0 ? 200 : 409,
-			);
-		}).pipe(Effect.catch((error) => Effect.succeed(layout(`<h1>Handoff unavailable</h1><p>${escapeHtml(String(error))}</p>`, 409))));
-	});
-}

package/src/handoffs/records.ts

@@ -1,34 +0,0 @@
-import { join } from "node:path";
-import { Schema } from "effect";
-import { stringify } from "yaml";
-import type { Handoff, HandoffInput, HandoffRecord } from "#browser/handoffs/schema.ts";
-import { HandoffRecord as RecordSchema } from "#browser/handoffs/schema.ts";
-import type { MetadataDocument } from "#metadata/model.ts";
-
-export function handoffFrom(document: MetadataDocument | undefined, root: string): Handoff | undefined {
-	if (!document) {
-		return undefined;
-	}
-	const { id, kind, handoff } = document.parsed.fields;
-	return id && kind === "handoff" && handoff
-		? { context: document.parsed.body, file: document.file, handoff, id, prompt: handoffPrompt(join(root, document.file)) }
-		: undefined;
-}
-export function handoffPrompt(path: string): string {
-	return `Read the handoff at ${JSON.stringify(path)}. Record receipt by editing its handoff.state and add handoff.by/note; then follow its instructions.`;
-}
-export function handoffMarkdown(id: string, handoff: HandoffRecord, context: string): string {
-	return `---\n${stringify({ handoff: Schema.encodeSync(RecordSchema)(handoff), id, kind: "handoff" })}---\n${context}`;
-}
-export function matchesHandoff(record: Handoff, input: HandoffInput) {
-	const saved = record.handoff;
-	return (
-		saved.item === input.item
-		&& saved.source === input.source
-		&& saved.reviewedRevision === input.revision
-		&& saved.recipient === input.recipient
-		&& saved.goal === input.goal
-		&& saved.constraints === input.constraints
-		&& saved.nextAction === input.nextAction
-	);
-}