@shivaedev/work-board 0.17.0 → 0.17.1

package/src/client/responses/summary.ts

@@ -1,3 +1,4 @@
+import { optionText, promptHeading } from "#browser/responses/cardContext.ts";
 import type { Prompt } from "#browser/responses/Prompt.ts";
 import type { PromptAnswer } from "#browser/responses/schema.ts";
 import type { ResponseInput } from "./formSchema.ts";
@@ -14,7 +15,9 @@ export function responseSummary(values: ResponseInput, prompts: readonly Prompt[
 			: [];
 	return [
 		values.author.trim() ? "" : "Add your local author label.",
-		missing.length > 0 ? `Unanswered prompts: ${missing.map((prompt) => `Question ${prompts.indexOf(prompt) + 1} · ${prompt.id}`).join("; ")}.` : "",
+		missing.length > 0
+			? `Unanswered: ${missing.map((prompt) => `“${promptHeading(prompt.source).title ?? `Question ${prompts.indexOf(prompt) + 1}`}”`).join(", ")}.`
+			: "",
 	]
 		.filter(Boolean)
 		.join(" ");
@@ -23,3 +26,12 @@ export function responseSummary(values: ResponseInput, prompts: readonly Prompt[
 export function responseFeedback(status: string, outcome: string | undefined, summary: string) {
 	return outcome || status.startsWith("Draft cleared") ? status : summary || status;
 }
+
+export function chosenLabels(prompts: readonly Prompt[], answers: readonly PromptAnswer[] | undefined) {
+	return prompts
+		.flatMap((prompt) => {
+			const selected = answers?.find((answer) => answer.prompt === prompt.id)?.selected ?? [];
+			return prompt.options.filter((option) => selected.includes(option.id)).map((option) => optionText(option.id, option.source, "").label);
+		})
+		.join(", ");
+}

package/src/server/attention/inbox.ts

@@ -6,7 +6,7 @@ import type { Snapshot } from "#server/search/snapshot.ts";
 import { answeredQuestion } from "./questionState.ts";
 import { requestInbox } from "./requestInbox.ts";
 import { isMaintainerRequest } from "./requests.ts";
-import { closedItem } from "./status.ts";
+import { closedItem, deferredItem } from "./status.ts";
 
 const automation = /^(?:codex|claude|fleet|orchestrator|agent|automation|bot|copilot)(?:$|[-_. /])/iu;
 
@@ -24,6 +24,10 @@ function addressedElsewhere(document: MetadataDocument, maintainer: string): boo
 }
 
 export function waitingReason(document: MetadataDocument, model: MetadataModel, maintainer = "maintainer"): string | undefined {
+	return deferredItem(document) ? undefined : attentionReason(document, model, maintainer);
+}
+
+function attentionReason(document: MetadataDocument, model: MetadataModel, maintainer: string): string | undefined {
 	const fields = document.parsed.fields;
 	if (!openItem(document) || fields.kind === "response" || fields.kind === "handoff" || fields.question) {
 		return undefined;
@@ -64,39 +68,59 @@ function inboxTarget(document: MetadataDocument, problem: string | undefined): s
 	return answer ? responseUrl(item, answer) : identityUrl(item);
 }
 
-export function inboxItems(snapshot: Snapshot) {
-	if (snapshot.unavailable.length > 0) {
-		return [];
-	}
+function directItems(snapshot: Snapshot, skipped: ReadonlySet<string>, reasonOf: (document: MetadataDocument) => string | undefined) {
 	const titles = new Map(snapshot.entries.filter((entry) => entry.kind === "document").map((entry) => [entry.file, entry.title]));
-	const requests = requestInbox(snapshot);
-	const you = requests.items.filter((item) => item.responseFrom.includes(snapshot.maintainer ?? "maintainer"));
-	const direct = snapshot.documents.flatMap((document) => {
-		if (requests.files.has(document.file)) {
+	return snapshot.documents.flatMap((document) => {
+		const reason = skipped.has(document.file) ? undefined : reasonOf(document);
+		if (!reason) {
 			return [];
 		}
 		const id = document.parsed.fields.id;
 		const problem = identityProblem(document, snapshot.model);
-		const reason = waitingReason(document, snapshot.model, snapshot.maintainer);
-		return reason
-			? [
-					{
-						document,
-						href: inboxTarget(document, problem),
-						id: id ?? document.file,
-						problem,
-						reason,
-						request: undefined,
-						title: titles.get(document.file) ?? document.file,
-						unblocks: [id ?? ""],
-					},
-				]
-			: [];
+		return [
+			{
+				document,
+				href: inboxTarget(document, problem),
+				id: id ?? document.file,
+				modified: snapshot.modified.get(document.file),
+				problem,
+				reason,
+				request: undefined,
+				title: titles.get(document.file) ?? document.file,
+				unblocks: [id ?? ""],
+			},
+		];
 	});
-	const ordinary = direct
+}
+
+function byAge(
+	left: { readonly id: string; readonly modified: number | undefined },
+	right: { readonly id: string; readonly modified: number | undefined },
+) {
+	return (left.modified ?? 0) - (right.modified ?? 0) || left.id.localeCompare(right.id);
+}
+
+export function inboxItems(snapshot: Snapshot) {
+	if (snapshot.unavailable.length > 0) {
+		return [];
+	}
+	const requests = requestInbox(snapshot);
+	const you = requests.items.filter((item) => item.responseFrom.includes(snapshot.maintainer ?? "maintainer"));
+	const ordinary = directItems(snapshot, requests.files, (document) => waitingReason(document, snapshot.model, snapshot.maintainer))
 		.filter((item) => item.problem || !you.some((ask) => ask.id === item.id))
-		.map((item) => ({ ...item, earlierAsks: 0, modified: snapshot.modified.get(item.document.file) }));
-	return [...ordinary, ...you].sort((left, right) => (left.modified ?? 0) - (right.modified ?? 0) || left.id.localeCompare(right.id));
+		.map((item) => ({ ...item, earlierAsks: 0 }));
+	return [...ordinary, ...you].sort(byAge);
+}
+
+export function laterItems(snapshot: Snapshot) {
+	if (snapshot.unavailable.length > 0) {
+		return [];
+	}
+	function parked(document: MetadataDocument) {
+		const reason = deferredItem(document) ? attentionReason(document, snapshot.model, snapshot.maintainer ?? "maintainer") : undefined;
+		return reason && (document.parsed.fields.nextAction ?? reason);
+	}
+	return directItems(snapshot, requestInbox(snapshot).files, parked).sort(byAge);
 }
 
 export function fleetRecords(model: MetadataModel): ReadonlySet<string> {

package/src/server/attention/managedRequestReceipt.ts

@@ -6,6 +6,13 @@ import { questionId, revisionOf } from "#server/responses/records.ts";
 
 type Request = NonNullable<Metadata["attention"]>[number];
 
+export type ManagedRequestState =
+	| { readonly _tag: "Open" }
+	| { readonly _tag: "Settled"; readonly receipt: RequestReceipt }
+	| { readonly _tag: "Conflicting"; readonly receipts: readonly string[] };
+
+const open: ManagedRequestState = { _tag: "Open" };
+
 function uniqueDocument(id: string, model: MetadataModel): MetadataDocument | undefined {
 	const matches = model.ids.get(id);
 	return matches?.length === 1 ? matches[0] : undefined;
@@ -38,7 +45,7 @@ function appliedAnswer(question: string, revision: string, responseId: string |
 	return current.length === 1 && current[0]?.id === responseId;
 }
 
-export function managedRequestReceipt(document: MetadataDocument, request: Request, model: MetadataModel): RequestReceipt | undefined {
+function registeredQuestion(document: MetadataDocument, request: Request, model: MetadataModel) {
 	const item = document.parsed.fields.id;
 	if (
 		request.managed !== true
@@ -57,7 +64,6 @@ export function managedRequestReceipt(document: MetadataDocument, request: Reque
 	const revision = revisionOf(source);
 	const id = questionId(item, request.id, revision, document.file);
 	const archived = uniqueDocument(id, model);
-	const index = responseIndex(model);
 	const question = registeredContext(archived, model);
 	if (
 		archived?.parsed.diagnostics.length !== 0
@@ -70,14 +76,13 @@ export function managedRequestReceipt(document: MetadataDocument, request: Reque
 	) {
 		return undefined;
 	}
-	if (index.receiptProblems) {
-		return undefined;
-	}
-	const receipts = index.receipts.get(id) ?? [];
-	const saved = receipts.length === 1 ? receipts[0] : undefined;
-	const receipt = saved?.parsed.fields.requestReceipt;
+	return { id, revision };
+}
+
+function qualified(saved: MetadataDocument, question: string, revision: string, model: MetadataModel): RequestReceipt | undefined {
+	const receipt = saved.parsed.fields.requestReceipt;
 	if (
-		!(saved && receipt)
+		!receipt
 		|| saved.parsed.fields.kind !== "result"
 		|| saved.parsed.diagnostics.length > 0
 		|| !saved.parsed.fields.id
@@ -89,5 +94,31 @@ export function managedRequestReceipt(document: MetadataDocument, request: Reque
 	if (receipt.disposition === "superseded") {
 		return receipt.response === undefined ? receipt : undefined;
 	}
-	return appliedAnswer(id, revision, receipt.response, model) ? receipt : undefined;
+	return appliedAnswer(question, revision, receipt.response, model) ? receipt : undefined;
+}
+
+function settling(receipts: readonly RequestReceipt[]): RequestReceipt | undefined {
+	return receipts.toSorted(
+		(left, right) => Number(right.disposition === "applied") - Number(left.disposition === "applied") || right.recordedAt - left.recordedAt,
+	)[0];
+}
+
+export function managedRequestState(document: MetadataDocument, request: Request, model: MetadataModel): ManagedRequestState {
+	const question = registeredQuestion(document, request, model);
+	const index = responseIndex(model);
+	if (!question || index.receiptProblems) {
+		return open;
+	}
+	const saved = index.receipts.get(question.id) ?? [];
+	const receipts = saved.flatMap((candidate) => qualified(candidate, question.id, question.revision, model) ?? []);
+	const receipt = receipts.length === saved.length ? settling(receipts) : undefined;
+	if (receipt) {
+		return { _tag: "Settled", receipt };
+	}
+	return receipts.length > 0 ? { _tag: "Conflicting", receipts: saved.map((candidate) => candidate.file) } : open;
+}
+
+export function managedRequestReceipt(document: MetadataDocument, request: Request, model: MetadataModel): RequestReceipt | undefined {
+	const state = managedRequestState(document, request, model);
+	return state._tag === "Settled" ? state.receipt : undefined;
 }

package/src/server/attention/projection.ts

@@ -1,6 +1,6 @@
 import type { InboxProjection } from "#browser/views/schema.ts";
 import type { Snapshot } from "#server/search/snapshot.ts";
-import { inboxItems } from "./inbox.ts";
+import { inboxItems, laterItems } from "./inbox.ts";
 import { requestInbox } from "./requestInbox.ts";
 import { attentionRequests } from "./requests.ts";
 
@@ -12,7 +12,9 @@ export function attentionProjection(snapshot: Snapshot): InboxProjection {
 		return cached;
 	}
 	const requests = requestInbox(snapshot);
-	function project({ document, request: _request, unblocks: _unblocks, ...item }: ReturnType<typeof inboxItems>[number]) {
+	function project<
+		TRow extends { readonly document: { readonly file: string }; readonly request: string | undefined; readonly unblocks: readonly string[] },
+	>({ document, request: _request, unblocks: _unblocks, ...item }: TRow) {
 		return { ...item, file: document.file };
 	}
 	const you = inboxItems(snapshot).map(project);
@@ -22,6 +24,7 @@ export function attentionProjection(snapshot: Snapshot): InboxProjection {
 		complete: snapshot.unavailable.length === 0,
 		issues,
 		items: you,
+		later: laterItems(snapshot).map(project),
 		parked: requests.parked.map(project),
 		resolved: requests.resolved.map(project),
 		sourceIssues: issues.length > 0,

package/src/server/attention/requestInbox.ts

@@ -23,10 +23,10 @@ export function requestInbox(snapshot: Snapshot) {
 		return {
 			document: entry.document,
 			earlierAsks: 0,
-			href: responseUrl(entry.itemId, entry.request.id),
+			href: entry.problem === undefined ? responseUrl(entry.itemId, entry.request.id) : entry.href,
 			id: target?.parsed.fields.id ?? entry.itemId,
 			modified: snapshot.modified.get(entry.document.file),
-			problem: undefined,
+			problem: entry.problem,
 			reason: entry.request.managed ? `Managed decision: ${entry.request.reason}` : entry.request.reason,
 			request: entry.request.id,
 			responseFrom: entry.request.responseFrom,

package/src/server/attention/requests.ts

@@ -1,5 +1,5 @@
 import type { Metadata } from "#metadata/schema.ts";
-import { managedRequestReceipt } from "#server/attention/managedRequestReceipt.ts";
+import { managedRequestState } from "#server/attention/managedRequestReceipt.ts";
 import { identityUrl, referenceTarget } from "#server/metadata/links.ts";
 import type { MetadataDocument } from "#server/metadata/model.ts";
 import type { Snapshot } from "#server/search/snapshot.ts";
@@ -10,6 +10,7 @@ export interface AttentionEntry {
 	readonly href: string;
 	readonly itemId: string;
 	readonly line: number;
+	readonly problem: string | undefined;
 	readonly request: Request;
 	readonly title: string;
 }
@@ -35,16 +36,20 @@ function requestsFor(document: MetadataDocument, snapshot: Snapshot, title: stri
 			request.state !== "open"
 			|| requests.filter((other) => other.id === request.id).length !== 1
 			|| request.unblocks.some((target) => !referenceTarget(target, snapshot.model))
-			|| managedRequestReceipt(document, request, snapshot.model) !== undefined
 		) {
 			return [];
 		}
+		const receipts = managedRequestState(document, request, snapshot.model);
+		if (receipts._tag === "Settled") {
+			return [];
+		}
 		return [
 			{
 				document,
 				href: `${identityUrl(itemId)}#attention-request-${encodeURIComponent(request.id)}`,
 				itemId,
 				line: lines[`attention.${index}`] ?? lines.attention ?? 2,
+				problem: receipts._tag === "Conflicting" ? `Request receipts disagree: ${receipts.receipts.join(", ")}` : undefined,
 				request,
 				title,
 			},

package/src/server/packageInfo.ts

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

package/dist/client/page/resolvedDocumentFailure.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"resolvedDocumentFailure.d.ts","sourceRoot":"","sources":["../../../src/client/page/resolvedDocumentFailure.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAqB,MAAM,QAAQ,CAAC;AAElD,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC,OAAO,CAAC,GAAG,OAAO,CAG5E"}

package/dist/client/page/resolvedDocumentFailure.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"resolvedDocumentFailure.js","sourceRoot":"","sources":["../../../src/client/page/resolvedDocumentFailure.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,QAAQ,CAAC;AAElD,MAAM,UAAU,uBAAuB,CAAC,KAA2B;IAClE,MAAM,KAAK,GAAG,MAAM,CAAC,cAAc,CAAC,KAAK,CAAC,eAAe,CAAC,KAAK,CAAC,CAAC,CAAC;IAClE,OAAO,SAAS,CAAC,QAAQ,CAAC,KAAK,EAAE,UAAU,CAAC,IAAI,SAAS,CAAC,QAAQ,CAAC,KAAK,EAAE,UAAU,CAAC,CAAC;AACvF,CAAC"}

package/dist/client/page/routeQuery.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"routeQuery.d.ts","sourceRoot":"","sources":["../../../src/client/page/routeQuery.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAEvD,UAAU,OAAO;IAChB,QAAQ,CAAC,QAAQ,EAAE,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC,UAAU,CAAC,EAAE,OAAO,CAAC,CAAC;CACnE;AAED,eAAO,MAAM,iBAAiB;IAAK,UAAU;CAAU,CAAC;AAExD,wBAAgB,aAAa,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6TAEtD;AAED,wBAAgB,eAAe,CAAC,GAAG,EAAE;IAAE,QAAQ,CAAC,UAAU,EAAE,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC,YAAY,CAAC,EAAE,OAAO,CAAC,CAAA;CAAE;;;;;;;;;;;;+HAE9G"}

package/dist/client/page/routeQuery.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"routeQuery.js","sourceRoot":"","sources":["../../../src/client/page/routeQuery.ts"],"names":[],"mappings":"AAMA,MAAM,CAAC,MAAM,iBAAiB,GAAG,EAAE,UAAU,EAAE,MAAM,EAAE,CAAC;AAExD,MAAM,UAAU,aAAa,CAAC,GAAY,EAAE,GAAW;IACtD,OAAO,GAAG,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,GAAG,EAAE,EAAE,iBAAiB,CAAC,CAAC;AACvD,CAAC;AAED,MAAM,UAAU,eAAe,CAAC,GAA+E;IAC9G,OAAO,GAAG,CAAC,UAAU,CAAC,KAAK,CAAC,EAAE,OAAO,EAAE,EAAE,EAAE,EAAE,iBAAiB,CAAC,CAAC;AACjE,CAAC"}