@shivaedev/work-board 0.11.0 → 0.12.0

package/src/responses/service.ts

@@ -1,117 +0,0 @@
-import { Clock, Effect, FileSystem, Semaphore } from "effect";
-import { type DraftInput, type Question, ResponseFailed } from "#browser/responses/schema.ts";
-import type { Changes } from "#files/changes.ts";
-import type { Snapshot } from "#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 { questionMarkdown, responseMarkdown } from "./records.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;
-}
-function reject(code: ResponseFailed["code"], message: string) {
-	return Effect.fail(new ResponseFailed({ code, message }));
-}
-const HOURS_48 = 48 * 60 * 60 * 1000;
-export const responseService = Effect.fn("WorkBoard.responseService")(function* (options: ResponseOptions) {
-	const fs = yield* FileSystem.FileSystem;
-	const lock = yield* Semaphore.make(1);
-	const snapshot = options.index.pipe(Effect.catch(() => reject("Unavailable", "The workspace could not be indexed.")));
-	const enabled = options.enabled ? Effect.void : reject("Disabled", "Start with --responses to explicitly enable local question/response writes.");
-	const locate = locateQuestion(options.root, options.changes.realRoot, snapshot, fs);
-	const read = readResponses(snapshot);
-	function register(input: { readonly item: string; readonly request: string; readonly revision: string }) {
-		return lock.withPermit(
-			Effect.gen(function* () {
-				yield* enabled;
-				const preview = yield* locate(input.item, input.request);
-				if (preview.reviewedRevision !== input.revision) {
-					return yield* reject("Stale", "Source changed since review. Read it again before registering this question.");
-				}
-				const data = yield* snapshot;
-				const matches = data.model.ids.get(preview.id);
-				if (matches?.length) {
-					if (matches.length !== 1 || matches[0]?.file !== `responses/${preview.id}.md`) {
-						return yield* reject("Conflict", "The registered identity moved or is duplicated. Read the existing record instead of retrying a write.");
-					}
-					const saved = (yield* read(preview.id)).question;
-					yield* publish(options.root, options.changes.realRoot, saved.id, questionMarkdown(saved));
-					return saved;
-				}
-				const now = yield* Clock.currentTimeMillis;
-				const question: Question = {
-					context: preview.context,
-					id: preview.id,
-					question: {
-						deadline: now + HOURS_48,
-						item: preview.item,
-						reason: preview.reason,
-						registeredAt: now,
-						request: preview.request,
-						reviewedRevision: preview.reviewedRevision,
-						source: preview.source,
-					},
-				};
-				yield* publish(options.root, options.changes.realRoot, question.id, questionMarkdown(question)).pipe(
-					Effect.ensuring(options.changes.refresh ?? Effect.void),
-				);
-				return question;
-			}),
-		);
-	}
-	function record(draft: DraftInput) {
-		return lock.withPermit(
-			Effect.gen(function* () {
-				yield* enabled;
-				const result = yield* read(draft.question);
-				const input = yield* Effect.try({
-					catch: (cause) => new ResponseFailed({ code: "Conflict", message: String(cause) }),
-					try: () => validatedInput(draft, result.question.context, result.question.question.request, result.question.question.source),
-				});
-				const existing = result.responses.find((candidate) => candidate.id === input.id);
-				if (existing) {
-					yield* retryResponse(existing, input, snapshot, options);
-					return existing;
-				}
-				const { question } = result;
-				const current = yield* locate(question.question.item, question.question.request);
-				if (current.reviewedRevision !== question.question.reviewedRevision || current.source !== question.question.source) {
-					return yield* reject("Stale", "Source changed or moved. Keep the draft and review the new revision before responding.");
-				}
-				const data = yield* snapshot;
-				yield* validateSupersedes(input, question, data);
-				if (data.model.ids.has(input.id)) {
-					return yield* reject("Conflict", "This response identity is already used.");
-				}
-				const response = makeResponse(
-					input,
-					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(
-					Effect.ensuring(options.changes.refresh ?? Effect.void),
-				);
-				return response;
-			}),
-		);
-	}
-	function history(preview: Parameters<typeof responseHistory>[1]) {
-		return Effect.flatMap(snapshot, (data) =>
-			Effect.try({
-				catch: (cause) => new ResponseFailed({ code: "Unavailable", message: String(cause) }),
-				try: () => responseHistory(data, preview),
-			}),
-		);
-	}
-	return { awaitResponse: awaitResponse(read), history, locate, read, record, register };
-});

package/src/responses/template.ts

@@ -1,72 +0,0 @@
-import type { RootContent } from "mdast";
-import type { ContainerDirective } from "mdast-util-directive";
-import remarkDirective from "remark-directive";
-import remarkParse from "remark-parse";
-import { unified } from "unified";
-import type { Prompt } from "#browser/responses/Prompt.ts";
-import { metadataParse } from "#metadata/parse.ts";
-import { templateLinks } from "./templateLinks.ts";
-import { isContainer, promptFrom, sliceNode } from "./templateNodes.ts";
-
-export interface Template {
-	readonly context: string;
-	readonly prompts: readonly Prompt[];
-}
-function nestedControl(node: RootContent): boolean {
-	return (
-		((node.type === "leafDirective" || node.type === "textDirective" || node.type === "containerDirective")
-			&& ["question", "option"].includes(node.name))
-		|| ("children" in node && node.children.some(nestedControl))
-	);
-}
-function scopedPrompt(
-	node: ContainerDirective,
-	source: string,
-	requests: readonly { readonly id: string; readonly state: string }[],
-	request: string,
-) {
-	const result = promptFrom(node, source);
-	if (result.request !== undefined && !requests.some((entry) => entry.id === result.request)) {
-		throw new Error("A question's request= must name an attention request in this document.");
-	}
-	if (result.request === undefined && requests.filter((entry) => entry.state === "open").length > 1) {
-		throw new Error("Use request= on question directives when a document has several open attention requests.");
-	}
-	return result.request === undefined || result.request === request ? result.prompt : undefined;
-}
-export function questionTemplate(context: string, request: string, file?: string): Template {
-	const parsed = metadataParse(context);
-	const parser = unified().use(remarkParse).use(remarkDirective);
-	const body = parsed.body.replace(/\r\n?/gu, "\n");
-	const original = parser.parse(body);
-	const source = file === undefined ? body : templateLinks(body, original.children, file);
-	const tree = parser.parse(source);
-	const definitions = tree.children
-		.filter((node) => node.type === "definition")
-		.map((node) => sliceNode(source, node))
-		.join("\n\n");
-	const prompts: Prompt[] = [];
-	const plain: string[] = [];
-
-	for (const node of tree.children) {
-		if (isContainer(node) && node.name === "question") {
-			const prompt = scopedPrompt(node, source, parsed.fields.attention ?? [], request);
-			if (prompt) {
-				prompts.push({
-					...prompt,
-					options: prompt.options.map((option) => ({ ...option, source: `${option.source}\n\n${definitions}`.trim() })),
-					source: `${prompt.source}\n\n${definitions}`.trim(),
-				});
-			}
-		} else {
-			if (nestedControl(node)) {
-				throw new Error("Use top-level question containers with direct option children.");
-			}
-			plain.push(sliceNode(source, node));
-		}
-	}
-	if (prompts.length > 32 || new Set(prompts.map((prompt) => prompt.id)).size !== prompts.length) {
-		throw new Error("Use at most 32 questions with unique IDs per attention request.");
-	}
-	return { context: plain.join("\n\n"), prompts };
-}

package/src/responses/templateHtml.ts

@@ -1,26 +0,0 @@
-import { Effect } from "effect";
-import { escapeHtml } from "#page/escape.ts";
-import { renderMarkdown } from "#render/markdown.ts";
-import { questionTemplate } from "./template.ts";
-
-export const templateHtml = Effect.fn("WorkBoard.templateHtml")(function* (context: string, request: string, file: string) {
-	const template = questionTemplate(context, request, file);
-	function render(source: string) {
-		return renderMarkdown(source, { file, safe: true });
-	}
-	const background = yield* render(template.context);
-	const controls = yield* Effect.forEach(template.prompts, (prompt, index) =>
-		Effect.gen(function* () {
-			const description = yield* render(prompt.source);
-			const options = yield* Effect.forEach(prompt.options, (option, choice) =>
-				Effect.map(
-					render(option.source),
-					(html) =>
-						`<div class="question-option"><input id="question-${index}-${choice}" type="${prompt.mode === "one" ? "radio" : "checkbox"}" name="choice-${escapeHtml(prompt.id)}" value="${escapeHtml(option.id)}" data-option-source="${escapeHtml(option.source)}"><div><label for="question-${index}-${choice}">Option ${escapeHtml(option.id)}</label>${html}</div></div>`,
-				),
-			);
-			return `<fieldset data-prompt="${escapeHtml(prompt.id)}" data-mode="${prompt.mode}" data-source="${escapeHtml(prompt.source)}"><legend>Question ${index + 1} · ${escapeHtml(prompt.id)}</legend>${description}<p>${prompt.mode === "text" ? "Answer in your own words" : `${prompt.mode === "one" ? "Choose one option" : "Choose any combination"}, or answer in your own words`}. Nothing is selected for you.</p>${options.join("")}${prompt.mode === "text" ? "" : '<button type="button" data-clear-choices>Clear selections</button>'}<label>Additional text / another answer<textarea data-answer-text maxlength="8192" rows="3"></textarea></label></fieldset>`;
-		}),
-	);
-	return { background, controls: controls.join(""), hasPrompts: template.prompts.length > 0 };
-});

package/src/responses/templateNodes.ts

@@ -1,55 +0,0 @@
-import { Schema } from "effect";
-import type { RootContent } from "mdast";
-import type { ContainerDirective } from "mdast-util-directive";
-import type { Prompt } from "#browser/responses/Prompt.ts";
-import { Identity } from "#path/Identity.ts";
-
-const Id = Identity.check(Schema.isMaxLength(128));
-const PromptFields = Schema.Struct({ id: Id, request: Schema.optional(Identity), select: Schema.optional(Schema.Literals(["one", "many", "text"])) });
-const OptionFields = Schema.Struct({ id: Id });
-
-export function sliceNode(source: string, node: RootContent) {
-	return source.slice(node.position?.start.offset, node.position?.end.offset);
-}
-export function isContainer(node: RootContent): node is ContainerDirective {
-	return node.type === "containerDirective";
-}
-function hasControl(node: RootContent): boolean {
-	return (
-		((node.type === "containerDirective" || node.type === "leafDirective" || node.type === "textDirective")
-			&& ["question", "option"].includes(node.name))
-		|| ("children" in node && node.children.some(hasControl))
-	);
-}
-export function promptFrom(node: ContainerDirective, source: string) {
-	const attrs = Schema.decodeUnknownSync(PromptFields, { onExcessProperty: "error" })(node.attributes ?? {});
-	const options = node.children.filter((child) => isContainer(child) && child.name === "option");
-	const description = node.children.filter((child) => !(isContainer(child) && child.name === "option"));
-	if (
-		description.some(hasControl)
-		|| description.length === 0
-		|| options.length > 32
-		|| (attrs.select === "text" ? options.length > 0 : options.length === 0)
-	) {
-		throw new Error("A question needs Markdown context and 1–32 direct options (or select=text without options), without nested questions.");
-	}
-	const choices = options.map((option) => {
-		if (!isContainer(option) || option.children.some(hasControl) || option.children.length === 0) {
-			throw new Error("Options need Markdown descriptions and cannot nest response controls.");
-		}
-		const fields = Schema.decodeUnknownSync(OptionFields, { onExcessProperty: "error" })(option.attributes ?? {});
-		return { id: fields.id, source: option.children.map((child) => sliceNode(source, child)).join("\n\n") };
-	});
-	if (new Set(choices.map((option) => option.id)).size !== choices.length) {
-		throw new Error("Option IDs must be unique within each question.");
-	}
-	return {
-		prompt: {
-			id: attrs.id,
-			mode: attrs.select ?? "one",
-			options: choices,
-			source: description.map((child) => sliceNode(source, child)).join("\n\n"),
-		} satisfies Prompt,
-		request: attrs.request,
-	};
-}

package/src/responses/validateSupersedes.ts

@@ -1,24 +0,0 @@
-import { Effect } from "effect";
-import { type DraftInput, type Question, ResponseFailed } from "#browser/responses/schema.ts";
-import type { Snapshot } from "#search/snapshot.ts";
-import { questionFrom, responseFrom } from "./records.ts";
-
-export function validateSupersedes(input: DraftInput, question: Question, data: Snapshot) {
-	if (input.supersedes === undefined) {
-		return Effect.void;
-	}
-	const matches = data.model.ids.get(input.supersedes);
-	const previous = matches?.length === 1 && matches[0] ? responseFrom(matches[0]) : undefined;
-	const context = previous && data.model.ids.get(previous.response.question);
-	const old = context?.length === 1 && context[0] ? questionFrom(context[0]) : undefined;
-	return old
-		&& previous
-		&& previous.response.reviewedRevision === old.question.reviewedRevision
-		&& old.question.item === question.question.item
-		&& old.question.request === question.question.request
-		&& input.supersedes !== input.id
-		? Effect.void
-		: Effect.fail(
-				new ResponseFailed({ code: "Conflict", message: "Supersedes must identify one recorded response to this item's attention request." }),
-			);
-}

package/src/responses/validatedInput.ts

@@ -1,45 +0,0 @@
-import { answerBody } from "#browser/responses/answerBody.ts";
-import type { Prompt } from "#browser/responses/Prompt.ts";
-import type { DraftInput, PromptAnswer } from "#browser/responses/schema.ts";
-import { questionTemplate } from "./template.ts";
-
-function answerFor(prompt: Prompt, answer: PromptAnswer | undefined, required: boolean) {
-	if (!answer || answer.prompt !== prompt.id) {
-		throw new Error("Submit one answer per question, in template order.");
-	}
-	if (new Set(answer.selected).size !== answer.selected.length || (prompt.mode === "one" && answer.selected.length > 1)) {
-		throw new Error("The selected options do not match the question's selection mode.");
-	}
-	if (answer.selected.some((id) => !prompt.options.some((option) => option.id === id))) {
-		throw new Error("A selected option is not in the reviewed template.");
-	}
-	if (required && answer.selected.length === 0 && !answer.text.trim()) {
-		throw new Error("Answer every question with a selection or additional text, or use Clarify / Not now.");
-	}
-}
-export function validatedInput(input: DraftInput, context: string, request: string, file?: string): DraftInput {
-	const template = questionTemplate(context, request, file);
-	if (input.answers === undefined) {
-		if (template.prompts.length > 0 && input.type === "answer") {
-			throw new Error("This question packet requires answers for all prompts.");
-		}
-		if (!input.body.trim()) {
-			throw new Error("A response needs text or answers to the question packet.");
-		}
-		return input;
-	}
-	if (input.answers.length !== template.prompts.length || template.prompts.length === 0) {
-		throw new Error("The answer packet does not match the reviewed questions.");
-	}
-	template.prompts.forEach((prompt, index) => {
-		answerFor(prompt, input.answers?.[index], input.type === "answer");
-	});
-	if (input.type !== "answer" && !input.body.trim() && !input.answers.some((answer) => answer.text.trim())) {
-		throw new Error("Clarify / Not now needs explanatory text.");
-	}
-	const body = answerBody(template.prompts, input.answers, input.body);
-	if (body.length > 32_768) {
-		throw new Error("The complete recorded response exceeds 32768 characters. Shorten the response or split the source request.");
-	}
-	return { ...input, body };
-}

package/src/responses/waitFor.ts

@@ -1,58 +0,0 @@
-import * as Clock from "effect/Clock";
-import * as Effect from "effect/Effect";
-import type { RpcClientError } from "effect/unstable/rpc/RpcClientError";
-import { ResponseFailed, type WaitReading } from "#browser/responses/schema.ts";
-
-function resultFor(reading: WaitReading) {
-	if (reading.response) {
-		return Effect.succeed({ kind: "response", question: reading.question, response: reading.response } as const);
-	}
-	if (reading.expired) {
-		return Effect.fail(
-			new ResponseFailed({
-				code: "Unanswered",
-				message:
-					"The human left this unanswered for 48 hours. Check in with them; they may have forgotten or want to postpone. The request and late replies remain available.",
-			}),
-		);
-	}
-	return Effect.succeed(undefined);
-}
-
-function retryable(error: ResponseFailed | RpcClientError) {
-	return error._tag !== "ResponseFailed" || error.code === "Unavailable";
-}
-
-export const waitForResponse = Effect.fn("WorkBoard.waitForResponse")(function* (
-	read: () => Effect.Effect<WaitReading, ResponseFailed | RpcClientError>,
-	diagnostic: (text: string) => void,
-) {
-	let known: WaitReading | undefined;
-	const leaseEnd = (yield* Clock.currentTimeMillis) + 48 * 60 * 60 * 1000;
-	let unavailable = false;
-	while (true) {
-		const result = yield* read().pipe(Effect.result);
-		if (result._tag === "Failure") {
-			if (!retryable(result.failure)) {
-				return yield* Effect.fail(result.failure);
-			}
-			if ((yield* Clock.currentTimeMillis) >= (known?.question.question.deadline ?? leaseEnd)) {
-				return yield* Effect.fail(
-					new Error("The service is unavailable at the deadline; unanswered status could not be verified. Re-read this question when it returns."),
-				);
-			}
-			if (!unavailable) {
-				diagnostic("Local service unavailable; reconnecting to the same question.");
-			}
-			unavailable = true;
-			yield* Effect.sleep("2 seconds");
-			continue;
-		}
-		known = result.success;
-		unavailable = false;
-		const complete = yield* resultFor(known);
-		if (complete) {
-			return complete;
-		}
-	}
-});

package/src/results/criteria.ts

@@ -1,37 +0,0 @@
-import { referenceTarget } from "#metadata/links.ts";
-import type { MetadataDocument, MetadataModel } from "#metadata/model.ts";
-import { escapeHtml } from "#page/escape.ts";
-import { referenceHtml, sourceHtml, valueHtml } from "#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/results/feedback.ts

@@ -1,44 +0,0 @@
-import { Effect } from "effect";
-import { fileUrl } from "#files/url.ts";
-import type { MetadataDocument } from "#metadata/model.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";
-import { readResponses } from "#responses/read.ts";
-import { malformedResponse, questionFrom, revisionOf } from "#responses/records.ts";
-import type { Snapshot } from "#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/results/page.ts

@@ -1,58 +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 { fileUrl } from "#files/url.ts";
-import { respond } from "#http/respond.ts";
-import type { MetadataDocument } from "#metadata/model.ts";
-import { escapeHtml } from "#page/escape.ts";
-import { metadataHtml } from "#page/metadata.ts";
-import { navHtml } from "#page/nav.ts";
-import { shell } from "#page/shell.ts";
-import type { Highlighter } from "#render/highlighter.ts";
-import { renderMarkdown } from "#render/markdown.ts";
-import { revisionOf } from "#responses/records.ts";
-import { resultCriteria } from "#results/criteria.ts";
-import { resultFeedback } from "#results/feedback.ts";
-import type { Snapshot } from "#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;
-		function layout(body: string, status = 200) {
-			return respond(shell("Result review", navHtml(files, "", home), body, changes.realRoot, false, undefined, "result"), "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))));
-	});
-}

package/src/rpc/affected.ts

@@ -1,77 +0,0 @@
-import type { Key } from "@shivaedev/effect-contract/keys.ts";
-import { backlinksOf } from "#metadata/backlinks.ts";
-import type { MetadataModel } from "#metadata/model.ts";
-import { documents, identities, index, navigation } from "./keys.ts";
-
-function uncertain(previous: MetadataModel, current: MetadataModel, paths: readonly string[]) {
-	if (previous.unavailable.length > 0 || current.unavailable.length > 0) {
-		return true;
-	}
-	const before = new Map(previous.documents.map((doc) => [doc.file, doc.parsed]));
-	const after = new Map(current.documents.map((doc) => [doc.file, doc.parsed]));
-	const known = new Set([...before.keys(), ...after.keys()]);
-	if (paths.some((path) => !known.has(path))) {
-		return true;
-	}
-	const announced = new Set(paths);
-	return [...known].some((file) => {
-		const old = before.get(file);
-		const next = after.get(file);
-		return !announced.has(file) && (old?.body !== next?.body || old?.raw !== next?.raw || old?.bodyLine !== next?.bodyLine);
-	});
-}
-function connectIdentities(model: MetadataModel, connect: (from: string, to: string) => void) {
-	for (const duplicates of model.ids.values()) {
-		const first = duplicates[0];
-		if (first === undefined) {
-			continue;
-		}
-		for (const duplicate of duplicates.slice(1)) {
-			connect(first.file, duplicate.file);
-			connect(duplicate.file, first.file);
-		}
-	}
-}
-function linkedFiles(models: readonly MetadataModel[], paths: readonly string[]) {
-	const edges = new Map<string, Set<string>>();
-	function connect(from: string, to: string) {
-		const targets = edges.get(from) ?? new Set();
-		targets.add(to);
-		edges.set(from, targets);
-	}
-	for (const model of models) {
-		connectIdentities(model, connect);
-		for (const document of model.documents) {
-			for (const link of backlinksOf(document.file, model)) {
-				connect(document.file, link.file);
-				connect(link.file, document.file);
-			}
-		}
-	}
-	const files = new Set(paths);
-	for (const file of files) {
-		for (const linked of edges.get(file) ?? []) {
-			files.add(linked);
-		}
-	}
-	return files;
-}
-export function affected(previous: MetadataModel, current: MetadataModel, paths: readonly string[]): readonly Key[] | undefined {
-	if (uncertain(previous, current, paths)) {
-		return undefined;
-	}
-	const models = [previous, current];
-	const files = linkedFiles(models, paths);
-	const keys: Key[] = [index.list, navigation.list, ...[...files].map((file) => documents.item(file))];
-	for (const model of models) {
-		if (model.rootFile && files.has(model.rootFile)) {
-			keys.push(documents.item(""));
-		}
-		for (const document of model.documents) {
-			if (files.has(document.file) && document.parsed.fields.id) {
-				keys.push(identities.item(document.parsed.fields.id));
-			}
-		}
-	}
-	return keys;
-}