@shivaedev/work-board 0.12.0 → 0.13.0

package/src/client/responses/submit.ts

@@ -1,44 +0,0 @@
-import { Schema } from "effect";
-import { InternalServerError } from "@shivaedev/platform/errors/taxonomy.ts";
-import { session } from "#client/session.ts";
-import { PublicationUncertain, ResponseRejection } from "#rpc/rejections.ts";
-import type { draftSession } from "./draftSession.ts";
-import type { Draft } from "./drafts.ts";
-import type { ResponseSubmission } from "./formSchema.ts";
-
-export async function submitResponse(
-	form: HTMLFormElement,
-	status: HTMLParagraphElement,
-	drafts: ReturnType<typeof draftSession>,
-	pending: Draft,
-	values: ResponseSubmission,
-) {
-	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: values.revision }),
-		);
-		await native.mutate(native.responses.recordResponse.run({ ...values, question: question.id }));
-		if (form.isConnected) {
-			status.dataset.outcome = "saved";
-			status.textContent = `Saved: responses/${values.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 =
-				Schema.is(ResponseRejection)(error) && !(error instanceof PublicationUncertain) && !(error instanceof InternalServerError)
-					? "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.`;
-		}
-		throw error;
-	}
-}

package/src/client/views/savedScript.ts

@@ -1,88 +0,0 @@
-export function savedScript(): string {
-	return `
-const key = "work-board:views:" + document.documentElement.dataset.workspace;
-let views = [];
-let notice = "";
-let selectedName = "";
-const localUrl = (value) => {
-  if (typeof value !== "string" || value.length > 8192) return null;
-  try {
-    const url = new URL(value, location.href);
-    if (url.origin !== location.origin || url.pathname !== "/_board/work") return null;
-    for (const name of [...url.searchParams.keys()]) {
-      if (!["view", "board", "owner", "status", "q", "sort"].includes(name)) url.searchParams.delete(name);
-    }
-    return url.pathname + url.search;
-  } catch { return null; }
-};
-try {
-  const saved = JSON.parse(localStorage.getItem(key) ?? "[]");
-  if (Array.isArray(saved)) {
-    for (const entry of saved) {
-      const url = localUrl(entry?.url);
-      if (!url || typeof entry.name !== "string" || !entry.name.trim() || entry.name.length > 60 || views.some((view) => view.name === entry.name)) continue;
-      views.push({ name: entry.name, url });
-      if (views.length === 10) break;
-    }
-  }
-} catch { notice = "Saved views could not be restored; new views apply to this page until saved."; }
-const persist = () => {
-  try { localStorage.setItem(key, JSON.stringify(views)); notice = ""; }
-  catch { notice = "Saved views apply to this page only; browser storage is unavailable."; }
-};
-const selectedView = () => views.find((view) => view.name === document.getElementById("saved-view")?.value);
-const showSelection = () => {
-  const open = document.getElementById("open-saved-view");
-  if (!open) return;
-  const selected = selectedView();
-  open.hidden = !selected;
-  if (selected) open.href = selected.url; else open.removeAttribute("href");
-  document.getElementById("remove-saved-view").disabled = !selected;
-};
-const option = (label, value) => {
-  const node = document.createElement("option");
-  node.textContent = label; node.value = value;
-  return node;
-};
-const refresh = (chosen) => {
-  const tools = document.getElementById("saved-work-views");
-  if (!tools) return;
-  const picker = document.getElementById("saved-view");
-  const previous = chosen ?? selectedName;
-  const labels = views.map((view) => view.name);
-  if (JSON.stringify([...picker.options].slice(1).map((option) => option.value)) !== JSON.stringify(labels)) {
-    picker.replaceChildren(option(views.length ? "Choose a saved view" : "No saved views", ""), ...views.map((view) => option(view.name, view.name)));
-  }
-  picker.value = views.some((view) => view.name === previous) ? previous : "";
-  selectedName = picker.value;
-  picker.disabled = views.length === 0;
-  tools.querySelector('#save-work-view button').disabled = false;
-  document.getElementById("clear-saved-views").disabled = views.length === 0;
-  document.getElementById("saved-view-status").textContent = notice || "Save board, filters, sort, and layout locally. Up to 10 named views; saving the same name updates it. Item selection stays in the URL.";
-  showSelection();
-};
-document.addEventListener("submit", (event) => {
-  if (!event.target.matches?.("#save-work-view")) return;
-  event.preventDefault();
-  const name = document.getElementById("view-name").value.trim().slice(0, 60);
-  const url = localUrl(document.getElementById("saved-work-views").dataset.url);
-  if (!name || !url) return;
-  if (views.length === 10 && !views.some((view) => view.name === name)) {
-    notice = "You have 10 saved views. Remove one or update an existing name."; refresh(); return;
-  }
-  views = [{ name, url }, ...views.filter((view) => view.name !== name)];
-  persist(); refresh(name);
-});
-document.addEventListener("change", (event) => {
-  if (event.target.id === "saved-view") { selectedName = event.target.value; showSelection(); }
-});
-document.addEventListener("click", (event) => {
-  if (event.target.id === "remove-saved-view") views = views.filter((view) => view.name !== selectedView()?.name);
-  else if (event.target.id === "clear-saved-views") views = [];
-  else return;
-  persist(); refresh();
-});
-document.addEventListener("board-page", () => refresh());
-refresh();
-`;
-}

package/src/server/diagnostics/html.ts

@@ -1,93 +0,0 @@
-import { escapeHtml } from "#browser/escapeHtml.ts";
-import type { FleetHealth } from "#diagnostics/health.ts";
-import { resetLabel } from "#diagnostics/resetLabel.ts";
-import type { CodexLimits, GithubLimits, Observation, UsageWindow } from "#diagnostics/source.ts";
-
-function time(milliseconds: number | null): string {
-	return milliseconds === null
-		? "Not reported"
-		: `<time datetime="${new Date(milliseconds).toISOString()}">${new Date(milliseconds)
-				.toISOString()
-				.replace("T", " ")
-				.replace(/\.\d{3}Z$/u, " UTC")}</time>`;
-}
-function observed(at: number): string {
-	return `<p class="diagnostics-freshness">Observed ${time(at)}</p>`;
-}
-function card<A>(name: string, source: Observation<A>, render: (value: A) => string, attention = false, stale = false): string {
-	let state: Observation<A>["state"] | "attention" | "stale" = source.state;
-	if (state === "ready" && attention) {
-		state = "attention";
-	}
-	if (source.state === "ready" && stale) {
-		state = "stale";
-	}
-	const label = { attention: "Needs attention", error: "Unavailable", "not-configured": "Not configured", ready: "Available", stale: "Stale" }[state];
-	return `<section class="diagnostics-card" data-source="${name.toLowerCase()}" data-state="${state}" aria-labelledby="diagnostics-${name.toLowerCase()}"><header><h2 id="diagnostics-${name.toLowerCase()}">${name}</h2><span class="diagnostics-status">${label}</span></header>${source.state === "ready" ? render(source.value) : `<p role="status">${escapeHtml(source.cause)}</p>`}${observed(source.observedAt)}</section>`;
-}
-function reset(at: number | null, now: number): string {
-	return at === null ? "Not reported" : `<time data-reset datetime="${new Date(at).toISOString()}">${resetLabel(at, now)}</time>`;
-}
-function windowLabel(name: string, minutes: number | null): string {
-	if (minutes === null) {
-		return `${name} — duration not reported`;
-	}
-	if (minutes === 10_080) {
-		return "Weekly";
-	}
-	for (const [duration, unit] of [
-		[1440, "day"],
-		[60, "hour"],
-	] as const) {
-		if (minutes % duration === 0) {
-			return `${minutes / duration}-${unit}`;
-		}
-	}
-	return `${minutes}-minute`;
-}
-function usage(name: string, window: UsageWindow | null, now: number): string {
-	if (window === null) {
-		return `<li><h3>${name}</h3><p>Window not reported</p></li>`;
-	}
-	const label = windowLabel(name, window.windowDurationMins);
-	return `<li><h3>${label}</h3><p><strong>${window.usedPercent}% used</strong></p><meter min="0" max="100" value="${Math.min(window.usedPercent, 100)}" aria-label="${label} percent used">${window.usedPercent}%</meter><p>Resets ${reset(window.resetsAt === null ? null : window.resetsAt * 1000, now)}</p></li>`;
-}
-function codex(value: CodexLimits, now: number): string {
-	return `<ul class="diagnostics-windows">${usage("Primary", value.primary, now)}${usage("Secondary", value.secondary, now)}</ul>`;
-}
-function github(value: GithubLimits, now: number): string {
-	return `<dl class="diagnostics-metrics">${(
-		[
-			["REST", value.core],
-			["GraphQL", value.graphql],
-		] as const
-	)
-		.map(
-			([name, window]) =>
-				`<div><dt>${name}</dt><dd><strong>${window.remaining} / ${window.limit}</strong> remaining</dd><dd>Resets ${reset(window.reset * 1000, now)}</dd></div>`,
-		)
-		.join("")}</dl><p class="diagnostics-freshness">Cached for one minute across all tabs.</p>`;
-}
-function fleet(value: FleetHealth, now: number): string {
-	let freshness = "Current snapshot";
-	if (now < value.observedAt) {
-		freshness = "Publisher clock is ahead";
-	} else if (now - value.observedAt > value.staleAfterMs) {
-		freshness = "Stale snapshot — Fleet has not refreshed its health";
-	}
-	return `<p class="diagnostics-freshness">${freshness}</p><dl class="diagnostics-metrics"><div><dt>Running / concurrency cap</dt><dd><strong>${value.running} / ${value.concurrency}</strong></dd></div><div><dt>Queued</dt><dd><strong>${value.queued}</strong></dd></div>${Object.entries(
-		value.waiting,
-	)
-		.map(([owner, count]) => `<div><dt>Waiting on ${owner}</dt><dd><strong>${count}</strong></dd></div>`)
-		.join(
-			"",
-		)}<div><dt>Last scheduler pass</dt><dd>${time(value.lastSchedulerPass)}</dd></div><div><dt>Last provider capacity rejection</dt><dd>${value.lastCapacityRejection === null ? "None observed" : `${escapeHtml(value.lastCapacityRejection.cause)}<br>${time(value.lastCapacityRejection.at)}`}</dd></div></dl>`;
-}
-
-export function diagnosticsHtml(
-	sources: { readonly codex: Observation<CodexLimits>; readonly github: Observation<GithubLimits>; readonly fleet: Observation<FleetHealth> },
-	now: number,
-): string {
-	const fleetSource = sources.fleet.state === "ready" ? { ...sources.fleet, observedAt: sources.fleet.value.observedAt } : sources.fleet;
-	return `<div class="diagnostics"><h1>Diagnostics</h1><p>Agent usage and Fleet health. Refreshes every 15 seconds while this view is visible; Pause updates holds the current view.</p><div class="diagnostics-grid">${card("Codex", sources.codex, (value) => codex(value, now), sources.codex.state === "ready" && [sources.codex.value.primary, sources.codex.value.secondary].some((window) => window !== null && window.usedPercent >= 90))}${card("GitHub", sources.github, (value) => github(value, now), sources.github.state === "ready" && [sources.github.value.core, sources.github.value.graphql].some((window) => window.remaining === 0))}${card("Fleet", fleetSource, (value) => fleet(value, now), fleetSource.state === "ready" && (fleetSource.value.running >= fleetSource.value.concurrency || Object.values(fleetSource.value.waiting).some((count) => count > 0) || now < fleetSource.value.observedAt), fleetSource.state === "ready" && now - fleetSource.value.observedAt > fleetSource.value.staleAfterMs)}</div></div>`;
-}

package/src/server/diagnostics/page.ts

@@ -1,31 +0,0 @@
-import { Clock, Effect } from "effect";
-import type { diagnostics } from "#diagnostics/source.ts";
-import type { Changes } from "#server/files/changes.ts";
-import { respond } from "#server/http/respond.ts";
-import { navHtml } from "#server/page/nav.ts";
-import { shell } from "#server/page/shell.ts";
-import type { searchSnapshot } from "#server/search/snapshot.ts";
-import { diagnosticsHtml } from "./html.ts";
-
-export const diagnosticsPage = Effect.fn("WorkBoard.diagnosticsPage")(function* (
-	read: Effect.Success<ReturnType<typeof diagnostics>>,
-	changes: Changes,
-	home: string | undefined,
-	index?: Effect.Success<ReturnType<typeof searchSnapshot>>,
-) {
-	const result = yield* read;
-	const snapshot = index ? yield* index : undefined;
-	return respond(
-		shell(
-			"Diagnostics",
-			navHtml(yield* changes.files, "", home, snapshot),
-			diagnosticsHtml(result, yield* Clock.currentTimeMillis),
-			changes.realRoot,
-			true,
-			undefined,
-			"diagnostics",
-			snapshot,
-		),
-		"text/html",
-	);
-});

package/src/server/handoffs/html.ts

@@ -1,42 +0,0 @@
-import { Effect } from "effect";
-import { escapeHtml } from "#browser/escapeHtml.ts";
-import type { Handoff, HandoffPreview } from "#browser/handoffs/schema.ts";
-import { fileUrl } from "#files/url.ts";
-import type { RenderFailed } from "#render/failed.ts";
-import { metadataParse } from "#server/metadata/parse.ts";
-import type { Highlighter } from "#server/render/Highlighter.ts";
-import { renderMarkdown } from "#server/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/server/handoffs/page.ts

@@ -1,51 +0,0 @@
-import { Effect, type FileSystem, type Path, type PlatformError } from "effect";
-import type { HttpServerRequest, HttpServerResponse } from "effect/unstable/http";
-import { escapeHtml } from "#browser/escapeHtml.ts";
-import type { Changes } from "#server/files/changes.ts";
-import { handoffFormHtml, handoffHistoryHtml } from "#server/handoffs/html.ts";
-import { HandoffsService } from "#server/handoffs/Service.ts";
-import { respond } from "#server/http/respond.ts";
-import { navHtml } from "#server/page/nav.ts";
-import { shell } from "#server/page/shell.ts";
-import type { Highlighter } from "#server/render/Highlighter.ts";
-import type { searchSnapshot } from "#server/search/snapshot.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(changes: Changes, home: string | undefined, enabled: boolean, index?: Effect.Success<ReturnType<typeof searchSnapshot>>) {
-	return Effect.fn("WorkBoard.handoffPage")(function* (
-		request: HttpServerRequest.HttpServerRequest,
-	): Effect.fn.Return<
-		HttpServerResponse.HttpServerResponse,
-		PlatformError.PlatformError,
-		FileSystem.FileSystem | Path.Path | Highlighter | HandoffsService
-	> {
-		const service = yield* HandoffsService;
-		const item = new URL(request.url, "http://127.0.0.1").searchParams.get("item") ?? "";
-		const files = yield* changes.files;
-		const snapshot = index ? yield* index : undefined;
-		function layout(body: string, status = 200) {
-			return respond(
-				shell("Handoff", navHtml(files, "", home, snapshot), body, changes.realRoot, false, undefined, "handoff", snapshot),
-				"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/server/http/changesPage.ts

@@ -1,15 +0,0 @@
-import { Effect } from "effect";
-import type { Changes } from "#server/files/changes.ts";
-import { changesHtml } from "#server/history/html.ts";
-import { navHtml } from "#server/page/nav.ts";
-import { shell } from "#server/page/shell.ts";
-import type { searchSnapshot } from "#server/search/snapshot.ts";
-import { respond } from "./respond.ts";
-
-export function changesPage(changes: Changes, home: string | undefined, index?: Effect.Success<ReturnType<typeof searchSnapshot>>) {
-	return Effect.fn("WorkBoard.changesPage")(function* () {
-		const snapshot = index ? yield* index : undefined;
-		const nav = navHtml(yield* changes.files, "", home, snapshot);
-		return respond(shell("Changes", nav, changesHtml(), changes.realRoot, true, undefined, "changes", snapshot), "text/html");
-	});
-}

package/src/server/http/readPage.ts

@@ -1,13 +0,0 @@
-import type { Effect } from "effect";
-import { HttpServerRequest, type HttpServerResponse } from "effect/unstable/http";
-
-export function readPage<E, R>(
-	routes: Readonly<Record<string, (request: HttpServerRequest.HttpServerRequest) => Effect.Effect<HttpServerResponse.HttpServerResponse, E, R>>>,
-	fallback: (request: HttpServerRequest.HttpServerRequest) => Effect.Effect<HttpServerResponse.HttpServerResponse, E, R>,
-) {
-	return (url: string) => {
-		const request = HttpServerRequest.fromWeb(new Request(`http://127.0.0.1${url}`));
-		const path = new URL(url, "http://127.0.0.1").pathname;
-		return (routes[path] ?? fallback)(request);
-	};
-}

package/src/server/http/start.ts

@@ -1,27 +0,0 @@
-import { Effect } from "effect";
-import type { Changes } from "#server/files/changes.ts";
-import { navHtml } from "#server/page/nav.ts";
-import { shell } from "#server/page/shell.ts";
-import { startHtml } from "#server/page/startHtml.ts";
-import type { searchSnapshot } from "#server/search/snapshot.ts";
-import { respond } from "./respond.ts";
-
-export function start(changes: Changes, home: string | undefined, index?: Effect.Success<ReturnType<typeof searchSnapshot>>) {
-	return Effect.fn("WorkBoard.start")(function* () {
-		const files = yield* changes.files;
-		const snapshot = index ? yield* index : undefined;
-		return respond(
-			shell(
-				"Getting started",
-				navHtml(files, "", home, snapshot),
-				startHtml(files.length === 0),
-				changes.realRoot,
-				false,
-				undefined,
-				"start",
-				snapshot,
-			),
-			"text/html",
-		);
-	});
-}

package/src/server/page/startHtml.ts

@@ -1,10 +0,0 @@
-import { escapeHtml } from "#browser/escapeHtml.ts";
-import { startTemplates } from "./startTemplates.ts";
-
-export function startHtml(empty = false): string {
-	return `<article class="doc onboarding"><h1>${empty ? "Start your local workspace" : "Project and report templates"}</h1>
-<p>Work Board reads Markdown files from your workspace folder. Use your editor or existing agent tools to create and update them; this viewer does not write project files.</p>
-<ol><li>Choose a template below. Focus its text area, select all, and copy the Markdown.</li><li>Save it in the served folder with the suggested filename, or adjust its links to your chosen filenames.</li><li>Replace the example IDs with unique stable IDs and update every matching relationship and criterion reference. Frontmatter is optional; ordinary Markdown and existing heading boards also work.</li><li>Fill in real context and observations. Work Board discovers saved files automatically. Start with the project, then follow the investigation and result links.</li></ol>
-<p>Unknown checks stay unknown. Add criterion evidence only after a real observation; a finished agent run is not verified acceptance. No project content is created or marked seen by opening these templates.</p>
-${startTemplates.map((template) => `<section class="start-template"><h2>${template.label}</h2><p>Suggested file: <code>${template.file}</code></p><details data-key="template:${template.file}"><summary>Read and copy ${template.label.toLowerCase()} Markdown</summary><label for="template-${template.file}">${template.label} template Markdown</label><textarea id="template-${template.file}" readonly rows="16" spellcheck="false">${escapeHtml(template.source)}</textarea></details></section>`).join("")}</article>`;
-}

package/src/server/responses/page.ts

@@ -1,37 +0,0 @@
-import { Effect } from "effect";
-import type { HttpServerRequest } from "effect/unstable/http";
-import { escapeHtml } from "#browser/escapeHtml.ts";
-import type { Changes } from "#server/files/changes.ts";
-import { respond } from "#server/http/respond.ts";
-import { navHtml } from "#server/page/nav.ts";
-import { shell } from "#server/page/shell.ts";
-import type { searchSnapshot } from "#server/search/snapshot.ts";
-import { composerHtml } from "./composerHtml.ts";
-import { Responses } from "./service.ts";
-
-export function responsePage(
-	changes: Changes,
-	home: string | undefined,
-	enabled: boolean,
-	index?: Effect.Success<ReturnType<typeof searchSnapshot>>,
-) {
-	return Effect.fn("WorkBoard.responsePage")(function* (request: HttpServerRequest.HttpServerRequest) {
-		const service = yield* Responses;
-		const params = new URL(request.url, "http://127.0.0.1").searchParams;
-		const files = yield* changes.files;
-		const snapshot = index ? yield* index : undefined;
-		function layout(body: string, status = 200) {
-			return respond(
-				shell("Respond", navHtml(files, "", home, snapshot), body, changes.realRoot, false, undefined, "response", snapshot),
-				"text/html",
-				status,
-			);
-		}
-		return yield* Effect.gen(function* () {
-			const question = yield* service.locate(params.get("item") ?? "", params.get("request") ?? "");
-			yield* service.read(question.id).pipe(Effect.catch((error) => (error._tag === "NotFound" ? Effect.void : Effect.fail(error))));
-			const records = yield* service.history(question);
-			return layout(yield* composerHtml(question, records, enabled));
-		}).pipe(Effect.catch((error) => Effect.succeed(layout(`<h1>Response unavailable</h1><p>${escapeHtml(error.message)}</p>`, 409))));
-	});
-}

package/src/server/results/criteria.ts

@@ -1,37 +0,0 @@
-import { escapeHtml } from "#browser/escapeHtml.ts";
-import { referenceTarget } from "#server/metadata/links.ts";
-import type { MetadataDocument, MetadataModel } from "#server/metadata/model.ts";
-import { referenceHtml, sourceHtml, valueHtml } from "#server/page/metadataLinks.ts";
-
-function criterionRow(reference: string, text: string, result: MetadataDocument, model: MetadataModel): string {
-	if (!referenceTarget(reference, model)) {
-		return `<li>${escapeHtml(text)} — criterion identity is ambiguous; evidence association unavailable.</li>`;
-	}
-	const claims = result.parsed.fields.evidence?.filter((claim) => claim.criterion === reference) ?? [];
-	const evidence =
-		claims.length > 0
-			? `<p>${claims.length} recorded claim(s) in this result; not verified acceptance.</p><ul>${claims.map((claim) => `<li>${sourceHtml(claim.source, result.file, model)}<dl><dt>Checked Git revision (reported)</dt><dd>${valueHtml(claim.checkedRevision)}</dd><dt>Method</dt><dd>${valueHtml(claim.method)}</dd><dt>Outcome (reported)</dt><dd>${valueHtml(claim.outcome)}</dd><dt>Observed time</dt><dd>${valueHtml(claim.observedAt)}</dd></dl></li>`).join("")}</ul>`
-			: "<p>No recorded evidence in this result naming this criterion. Acceptance is not established.</p>";
-	return `<li>${referenceHtml(text, reference, model)}${evidence}</li>`;
-}
-function targetRow(target: string, result: MetadataDocument, model: MetadataModel): string {
-	const [id, criterion] = target.split("#");
-	const document = model.ids.get(id ?? "")?.[0];
-	if (!(document && referenceTarget(target, model))) {
-		return `<li>${referenceHtml(target, target, model)} — criteria unavailable.</li>`;
-	}
-	const criteria = (document.parsed.fields.criteria ?? []).filter((item) => !criterion || item.id === criterion);
-	const rows =
-		criteria.length > 0
-			? `<ul>${criteria.map((item) => criterionRow(`${id}#${item.id}`, item.text, result, model)).join("")}</ul>`
-			: "<p>No criteria declared in this source.</p>";
-	return `<li>${referenceHtml(target, target, model)} · source status: ${valueHtml(document.parsed.fields.status)}${rows}</li>`;
-}
-export function resultCriteria(result: MetadataDocument, model: MetadataModel): string {
-	const targets = new Set(result.parsed.fields.relationships?.map((link) => link.target));
-	if (result.parsed.fields.id) {
-		targets.add(result.parsed.fields.id);
-	}
-	const rows = [...targets].map((target) => targetRow(target, result, model));
-	return `<section id="result-criteria"><h2>Criteria and this result’s claims</h2><p>Only explicit relationships and criterion references are associated. Missing provenance stays missing. Git revisions are authored records; Work Board does not compare them with the current checkout. Evidence freshness is unknown.</p>${rows.length > 0 ? `<ul>${rows.join("")}</ul>` : "<p>No explicitly linked work or criteria.</p>"}<p>${escapeHtml(result.file)} does not change the linked work’s status.</p></section>`;
-}

package/src/server/results/feedback.ts

@@ -1,44 +0,0 @@
-import { Effect } from "effect";
-import { escapeHtml } from "#browser/escapeHtml.ts";
-import { fileUrl } from "#files/url.ts";
-import type { MetadataDocument } from "#integration/metadata.ts";
-import type { RenderFailed } from "#render/failed.ts";
-import type { Highlighter } from "#server/render/Highlighter.ts";
-import { renderMarkdown } from "#server/render/markdown.ts";
-import { readResponses } from "#server/responses/read.ts";
-import { malformedResponse, questionFrom, revisionOf } from "#server/responses/records.ts";
-import type { Snapshot } from "#server/search/snapshot.ts";
-
-export const resultFeedback = Effect.fn("WorkBoard.resultFeedback")(function* (
-	result: MetadataDocument,
-	data: Snapshot,
-): Effect.fn.Return<string, RenderFailed, Highlighter> {
-	const unknown =
-		data.unavailable.length > 0
-		|| data.documents.some((document) => malformedResponse(document) || (document.parsed.fields.kind === "question" && !questionFrom(document)));
-	const questions = data.documents.flatMap((document) => {
-		const question = questionFrom(document);
-		return question && question.question.item === result.parsed.fields.id ? [question] : [];
-	});
-	const read = readResponses(Effect.succeed(data));
-	const readings = yield* Effect.forEach(questions, (question) => Effect.result(read(question.id)));
-	if (unknown || readings.some((reading) => reading._tag === "Failure")) {
-		return '<section id="result-feedback"><h2>Recorded human feedback</h2><p role="status">Response history is unknown or ambiguous. Unreadable records do not establish that no feedback exists. Read the source files before relying on it.</p></section>';
-	}
-	const current = revisionOf((result.parsed.raw ?? "") + result.parsed.body);
-	const records = readings.flatMap((reading) =>
-		reading._tag === "Success" ? reading.success.responses.map((response) => ({ question: reading.success.question, response })) : [],
-	);
-	records.sort((a, b) => b.response.response.recordedAt - a.response.response.recordedAt || a.response.id.localeCompare(b.response.id));
-	const bodies = yield* Effect.forEach(records, ({ question, response }) =>
-		Effect.gen(function* () {
-			const matching = question.question.reviewedRevision === current && question.question.source === result.file;
-			const responseFile = data.model.ids.get(response.id)?.[0]?.file ?? `responses/${response.id}.md`;
-			const questionFile = data.model.ids.get(question.id)?.[0]?.file ?? `responses/${question.id}.md`;
-			const body = yield* renderMarkdown(response.body, { file: responseFile, safe: true });
-			const selected = response.response.answers?.map((answer) => `${answer.prompt}: ${answer.selected.join(", ") || "text only"}`).join("; ");
-			return `<article id="${escapeHtml(response.id)}"><h3>${escapeHtml(response.response.author)} · ${escapeHtml(response.response.type)}</h3><p><b>${matching ? "Feedback on this exact result revision" : "Earlier or moved result context — does not apply automatically to this revision"}</b></p><p>Reviewed source: ${escapeHtml(question.question.source)} · SHA-256 <code>${question.question.reviewedRevision}</code></p>${selected ? `<p>Recorded option IDs: ${escapeHtml(selected)}. Labels and reasoning are recorded below.</p>` : ""}${response.response.supersedes ? `<p>Explicitly supersedes <a href="${fileUrl(data.model.ids.get(response.response.supersedes)?.[0]?.file ?? `responses/${response.response.supersedes}.md`)}">${escapeHtml(response.response.supersedes)}</a>.</p>` : ""}${body}<p><a href="${fileUrl(responseFile)}">Response source</a> · <a href="${fileUrl(questionFile)}">Registered reviewed context</a></p><details><summary>Exact reviewed result source</summary><pre>${escapeHtml(question.context)}</pre></details></article>`;
-		}),
-	);
-	return `<section id="result-feedback"><h2>Recorded human feedback</h2><p>Human direction is pinned to its reviewed report. Option IDs and authored acceptance text are not a computed verified-acceptance state. Completing a run or receiving feedback does not change work status.</p>${bodies.join("") || "<p>No readable response is recorded for this result.</p>"}</section>`;
-});

package/src/server/results/page.ts

@@ -1,63 +0,0 @@
-import { Effect, type FileSystem, type Path, type PlatformError } from "effect";
-import type { HttpServerRequest, HttpServerResponse } from "effect/unstable/http";
-import { escapeHtml } from "#browser/escapeHtml.ts";
-import { fileUrl } from "#files/url.ts";
-import type { Changes } from "#server/files/changes.ts";
-import { respond } from "#server/http/respond.ts";
-import type { MetadataDocument } from "#server/metadata/model.ts";
-import { metadataHtml } from "#server/page/metadata.ts";
-import { navHtml } from "#server/page/nav.ts";
-import { shell } from "#server/page/shell.ts";
-import type { Highlighter } from "#server/render/Highlighter.ts";
-import { renderMarkdown } from "#server/render/markdown.ts";
-import { revisionOf } from "#server/responses/records.ts";
-import { resultCriteria } from "#server/results/criteria.ts";
-import { resultFeedback } from "#server/results/feedback.ts";
-import type { Snapshot } from "#server/search/snapshot.ts";
-
-function reviewActions(result: MetadataDocument) {
-	const requests = result.parsed.fields.attention ?? [];
-	const actions = requests
-		.filter(
-			(attention) => attention.kind === "review" && attention.state === "open" && requests.filter((other) => other.id === attention.id).length === 1,
-		)
-		.map(
-			(attention) =>
-				`<li><a href="/_board/respond?item=${encodeURIComponent(result.parsed.fields.id ?? "")}&amp;request=${encodeURIComponent(attention.id)}">Review ${escapeHtml(attention.id)}</a> — ${escapeHtml(attention.reason)}</li>`,
-		);
-	return `<section id="result-actions"><h2>Respond to this report</h2>${actions.length > 0 ? `<ul>${actions.join("")}</ul>` : "<p>No unique open review request is declared. The agent can add an explicit attention review and Markdown question packet with ordinary file editing. Work Board does not infer one from status.</p>"}</section>`;
-}
-
-export function resultPage(index: Effect.Effect<Snapshot, unknown, FileSystem.FileSystem | Path.Path>, changes: Changes, home: string | undefined) {
-	return Effect.fn("WorkBoard.resultPage")(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;
-		const snapshot = yield* index.pipe(Effect.catch(() => Effect.succeed(undefined)));
-		function layout(body: string, status = 200) {
-			return respond(
-				shell("Result review", navHtml(files, "", home, snapshot), body, changes.realRoot, false, undefined, "result", snapshot),
-				"text/html",
-				status,
-			);
-		}
-		return yield* Effect.gen(function* () {
-			const data = yield* index;
-			const matches = data.model.ids.get(item);
-			const result = matches?.length === 1 ? matches[0] : undefined;
-			if (result?.parsed.fields.kind !== "result" || data.unavailable.length > 0) {
-				return layout(
-					'<h1>Result unavailable</h1><p role="status">Choose one uniquely identified, readable result. Missing or ambiguous work is not accepted.</p>',
-					409,
-				);
-			}
-			const report = yield* renderMarkdown(result.parsed.body, { file: result.file, safe: true });
-			const feedback = yield* resultFeedback(result, data);
-			const revision = revisionOf((result.parsed.raw ?? "") + result.parsed.body);
-			return layout(
-				`<section class="response-panel"><h1>Review returned result · ${escapeHtml(item)}</h1><p>Result status (source): <b>${escapeHtml(result.parsed.fields.status ?? "Not recorded")}</b>. This is a supplied claim, not an execution receipt or work acceptance.</p><p>Current report SHA-256: <code>${revision}</code> · <a href="${fileUrl(result.file)}">Read source</a></p>${metadataHtml(result.parsed, result.file, data.model)}${reviewActions(result)}${resultCriteria(result, data.model)}<section id="result-report"><h2>Report, evidence and limitations</h2>${report}</section>${feedback}</section>`,
-			);
-		}).pipe(Effect.catch((error) => Effect.succeed(layout(`<h1>Result review unavailable</h1><p>${escapeHtml(String(error))}</p>`, 409))));
-	});
-}