@shivaedev/work-fleet 0.5.0 → 0.7.0

package/src/board/acknowledgeDecision.ts

@@ -1,7 +1,8 @@
 import { Effect } from "effect";
-import { attention } from "@shivaedev/work-board/integration/attention.ts";
-import { board as boardApi } from "@shivaedev/work-board/integration/board.ts";
-import { responses } from "@shivaedev/work-board/integration/responses.ts";
+import { attention } from "@shivaedev/work-board/server/integration/attention.ts";
+import { board as boardApi } from "@shivaedev/work-board/server/integration/board.ts";
+import { responses } from "@shivaedev/work-board/server/integration/responses.ts";
+import { closePublishedDecision } from "#board/closePublishedDecision.ts";
 import { type BoardSnapshot, recordBoardSource } from "#board/readPass.ts";
 import { BoardAcknowledgementStale, type BoardDecisionAcknowledgement } from "#board/schema.ts";
 import { BoardFailure } from "#policy.ts";
@@ -37,8 +38,10 @@ export function acknowledgeDecision(root: string, realRoot: string, snapshot: Ef
 		const content = `---\n${JSON.stringify({ id, kind: "result", "request_receipt": requestReceipt })}\n---\n# Managed request acknowledgement\n\nThis immutable receipt acknowledges request handling; it grants no execution, acceptance or delivery authority.\n`;
 		const file = `responses/${id}.md`;
 		const receiptDocument = { file, parsed: boardApi.metadataParse(content) };
-		const model = metadataModel([...all.filter((document) => document.file !== file), receiptDocument]);
-		if (!request || managedRequestReceipt(source, request, model) === undefined) {
+		const others = all.filter((document) => document.file !== file);
+		const acknowledged = others.some((document) => document.parsed.fields.requestReceipt?.question === decision.questionId);
+		const model = metadataModel([...others, receiptDocument]);
+		if (!request || acknowledged || managedRequestReceipt(source, request, model) === undefined) {
 			return yield* Effect.fail(
 				new BoardAcknowledgementStale({ message: "The exact managed question and applicable response cannot be qualified for acknowledgement." }),
 			);
@@ -47,5 +50,8 @@ export function acknowledgeDecision(root: string, realRoot: string, snapshot: Ef
 			Effect.mapError(() => new BoardFailure({ message: "The managed request acknowledgement could not be recorded on Board." })),
 		);
 		yield* recordBoardSource(realRoot, file, content, receiptDocument.parsed);
+		if (input.disposition === "superseded") {
+			yield* closePublishedDecision(root, realRoot, source);
+		}
 	});
 }

package/src/board/briefRevision.ts

@@ -1,5 +1,5 @@
-import type { ParsedMetadata } from "@shivaedev/work-board/integration/board.ts";
-import { responses } from "@shivaedev/work-board/integration/responses.ts";
+import type { ParsedMetadata } from "@shivaedev/work-board/server/integration/board.ts";
+import { responses } from "@shivaedev/work-board/server/integration/responses.ts";
 import { fleetDeliverable } from "#board/fleetField.ts";
 
 const { revisionOf } = responses;

package/src/board/closePublishedDecision.ts

@@ -0,0 +1,51 @@
+import { Effect } from "effect";
+import { parseDocument } from "yaml";
+import { board } from "@shivaedev/work-board/server/integration/board.ts";
+import type { BoardDocument } from "#board/documents.ts";
+import { recordBoardSource } from "#board/readPass.ts";
+import { writeCompletion } from "#board/writeCompletion.ts";
+import { BoardFailure } from "#policy.ts";
+
+export function publishedDecision(document: BoardDocument) {
+	const { fields, body, diagnostics } = document.parsed;
+	const workId = fields.relationships?.find((relation) => relation.kind === "relates_to")?.target;
+	const request = fields.attention?.[0];
+	if (
+		diagnostics.length > 0
+		|| fields.kind !== "decision"
+		|| !fields.id?.startsWith("decision.")
+		|| workId === undefined
+		|| !body.startsWith(`# Fleet decision for ${workId}\n`)
+		|| fields.attention?.length !== 1
+		|| request?.managed !== true
+		|| !request.id.startsWith(`${workId}.`)
+	) {
+		return;
+	}
+	const sequence = Number(request.id.slice(workId.length + 1));
+	return Number.isSafeInteger(sequence) ? { request, sequence, workId } : undefined;
+}
+
+export const closePublishedDecision = Effect.fn("FleetBoard.closePublishedDecision")(function* (
+	root: string,
+	realRoot: string,
+	document: BoardDocument,
+) {
+	const decision = publishedDecision(document);
+	if (decision === undefined || decision.request.state !== "open") {
+		return;
+	}
+	const header = document.parsed.raw;
+	if (header === undefined) {
+		return;
+	}
+	const metadata = parseDocument(header.replace(/^---\r?\n/u, "").replace(/---\r?\n?$/u, ""));
+	metadata.setIn(["attention", 0, "state"], "closed");
+	const content = `---\n${metadata.toString()}---\n${document.parsed.body}`;
+	yield* writeCompletion(root, realRoot, document.file, document.source, content).pipe(
+		Effect.mapError((error) => new BoardFailure({ message: error.message })),
+	);
+	const parsed = board.metadataParse(content);
+	yield* recordBoardSource(realRoot, document.file, content, parsed);
+	return { file: document.file, parsed, source: content };
+});

package/src/board/decisionAnswer.ts

@@ -1,12 +1,14 @@
-import { releaseOnly } from "#engine/releaseOnly.ts";
-import type { Decision } from "#policy.ts";
+import type { DecisionCopy } from "#engine/decisionCopy.ts";
+import type { Choice } from "#engine/situations/choices.ts";
 
-export function decisionAnswer(input: Decision) {
-	if (input.worker !== undefined) {
-		return "Record your answer on this item’s answer card to continue the worker in its existing thread. Use a guided release answer or the release command to free terminal ownership instead.";
+export function decisionAnswer({ question }: DecisionCopy) {
+	if (question === undefined) {
+		return undefined;
 	}
-	const explanation = releaseOnly(input.code);
-	const retryText = "### Request changes\nFleet keeps the branch and PR and works on your answer";
-	const retry = explanation === undefined ? `:::option{id="retry"}\n${retryText}\n:::\n\n` : "";
-	return `${explanation === undefined ? "" : `${explanation}\n\n`}::::question{id="fleet-action" select="one"}\n### How should Fleet proceed?\n\n${retry}:::option{id="release"}\n### Release\nFleet stops and hands the work back\n:::\n::::`;
+	const retry = question.retry === undefined ? "" : `${option("retry", question.retry)}\n`;
+	return `::::question{id="fleet-action" select="one"}\n### ${question.title}\n\n${retry}${option("release", question.release)}::::`;
+}
+
+function option(id: string, choice: Choice) {
+	return `:::option{id="${id}"}\n### ${choice.label}\n${choice.outcome}\n:::\n`;
 }

package/src/board/decisionReading.ts

@@ -1,7 +1,7 @@
 import { Effect } from "effect";
-import { board } from "@shivaedev/work-board/integration/board.ts";
-import type { Reading } from "@shivaedev/work-board/integration/responses.ts";
-import { responses } from "@shivaedev/work-board/integration/responses.ts";
+import { board } from "@shivaedev/work-board/server/integration/board.ts";
+import type { Reading } from "@shivaedev/work-board/server/integration/responses.ts";
+import { responses } from "@shivaedev/work-board/server/integration/responses.ts";
 import type { BoardDocument } from "#board/documents.ts";
 import type { BoardDecision, BoardDecisionReading } from "#board/schema.ts";
 import { BoardFailure } from "#policy.ts";

package/src/board/documents.ts

@@ -1,6 +1,6 @@
 import { Effect, FileSystem, Path } from "effect";
-import type { MetadataDocument } from "@shivaedev/work-board/integration/board.ts";
-import { board as boardApi } from "@shivaedev/work-board/integration/board.ts";
+import type { MetadataDocument } from "@shivaedev/work-board/server/integration/board.ts";
+import { board as boardApi } from "@shivaedev/work-board/server/integration/board.ts";
 import { readDocument } from "#board/readDocument.ts";
 import { BoardSnapshot, readSnapshot } from "#board/readPass.ts";
 import { BoardFailure } from "#policy.ts";
@@ -13,6 +13,9 @@ export const snapshotDocument = Effect.fn("FleetBoard.snapshotDocument")(functio
 	const matches = snapshot.model.ids.get(workId);
 	const found = matches?.length === 1 ? snapshot.files.get(matches[0]?.file ?? "") : undefined;
 	if (found === undefined) {
+		if (matches === undefined && snapshot.problems.size === 0) {
+			return yield* Effect.fail(new BoardFailure({ code: "board-item-missing", message: `Board item no longer exists: ${workId}`, workId }));
+		}
 		const message = [
 			`Board identity is missing or ambiguous: ${workId}`,
 			...Array.from(snapshot.problems.values(), (failure) => failure.message),
@@ -83,7 +86,3 @@ export function boardDocuments(root: string, realRoot: string) {
 export function boundSnapshot(root: string, realRoot: string, fs: FileSystem.FileSystem, path: Path.Path) {
 	return boardSnapshot(root, realRoot).pipe(Effect.provideService(FileSystem.FileSystem, fs), Effect.provideService(Path.Path, path));
 }
-
-export function boundDocuments(root: string, realRoot: string, fs: FileSystem.FileSystem, path: Path.Path) {
-	return boardDocuments(root, realRoot).pipe(Effect.provideService(FileSystem.FileSystem, fs), Effect.provideService(Path.Path, path));
-}

package/src/board/fleetField.ts

@@ -1,5 +1,5 @@
 import { parse } from "yaml";
-import type { ParsedMetadata } from "@shivaedev/work-board/integration/board.ts";
+import type { ParsedMetadata } from "@shivaedev/work-board/server/integration/board.ts";
 
 const APPROVAL = "fleet";
 const LAUNCH = "fleet-launch";

package/src/board/markdown.ts

@@ -1,15 +1,16 @@
 import { Context, Effect, FileSystem, Layer, Path, Schema } from "effect";
-import { defineService } from "@shivaedev/effect-service/define-service.ts";
-import { board as boardApi } from "@shivaedev/work-board/integration/board.ts";
+import { defineService } from "@shivaedev/effect-service/defineService.ts";
+import { board as boardApi } from "@shivaedev/work-board/server/integration/board.ts";
 import { acknowledgeDecision } from "#board/acknowledgeDecision.ts";
 import { briefRevision } from "#board/briefRevision.ts";
 import { completionMarkdown } from "#board/completionMarkdown.ts";
 import { decisionReading } from "#board/decisionReading.ts";
-import { boundDocuments, boundSnapshot, refreshSnapshotDocument, snapshotDocument } from "#board/documents.ts";
+import { boundSnapshot, refreshSnapshotDocument, snapshotDocument } from "#board/documents.ts";
 import { fleetApproved, fleetDeliverable, fleetPriority } from "#board/fleetField.ts";
 import { publishBoard } from "#board/publish.ts";
 import { publishReport } from "#board/publishReport.ts";
 import { workMetadata } from "#board/readPass.ts";
+import { upgradeDecisionClosure } from "#board/upgradeDecisionClosure.ts";
 import { workRevision } from "#board/workRevision.ts";
 import { writeCompletion } from "#board/writeCompletion.ts";
 import { BoardFailure, BoardGateway, Priority } from "#policy.ts";
@@ -24,8 +25,8 @@ const MarkdownBoard = defineService({
 		const fs = yield* FileSystem.FileSystem;
 		const path = yield* Path.Path;
 		const realRoot = yield* fs.realPath(root);
-		const documents = boundDocuments(root, realRoot, fs, path);
-		const snapshot = boundSnapshot(root, realRoot, fs, path);
+		const snapshot = boundSnapshot(root, realRoot, fs, path).pipe(Effect.tap((current) => upgradeDecisionClosure(root, realRoot, current, fs)));
+		const documents = snapshot.pipe(Effect.map((current) => current.documents.filter((document) => !current.problems.has(document.file))));
 		const get = Effect.fn("FleetBoard.get")(function* (workId: string, options?: { readonly fresh?: boolean }) {
 			const current = yield* snapshot;
 			const found = yield* options?.fresh

package/src/board/publish.ts

@@ -1,11 +1,12 @@
 import { relative } from "node:path";
 import { Clock, Effect } from "effect";
-import { board as boardApi } from "@shivaedev/work-board/integration/board.ts";
-import { responses } from "@shivaedev/work-board/integration/responses.ts";
+import { board as boardApi } from "@shivaedev/work-board/server/integration/board.ts";
+import { responses } from "@shivaedev/work-board/server/integration/responses.ts";
 import { decisionAnswer } from "#board/decisionAnswer.ts";
 import type { BoardDocument } from "#board/documents.ts";
 import { recordBoardSource } from "#board/readPass.ts";
 import type { BoardDecision } from "#board/schema.ts";
+import { type DecisionCopy, decisionCopy } from "#engine/decisionCopy.ts";
 import { BoardFailure, type BoardWork, type Decision } from "#policy.ts";
 
 const { publish, questionFrom, questionId, questionMarkdown, revisionOf } = responses;
@@ -23,14 +24,14 @@ function linked(text: string): string {
 	return url.protocol === "https:" || url.protocol === "http:" ? `<${url.href.replaceAll("<", "%3C").replaceAll(">", "%3E")}>` : quoted(text);
 }
 
-function decisionSource(itemId: string, work: BoardWork, input: Decision): string {
+function decisionSource(itemId: string, work: BoardWork, input: Decision, copy: DecisionCopy): string {
 	const metadata = {
 		attention: [
 			{
 				id: input.id,
 				kind: "decision",
 				managed: true,
-				reason: input.reason,
+				reason: copy.reason,
 				"response_from": [input.attentionOwner ?? "orchestrator"],
 				state: "open",
 				unblocks: [work.workId],
@@ -40,8 +41,8 @@ function decisionSource(itemId: string, work: BoardWork, input: Decision): strin
 		kind: "decision",
 		relationships: [{ kind: "relates_to", target: work.workId }],
 	};
-	const answer = decisionAnswer(input);
-	return `---\n${JSON.stringify(metadata)}\n---\n# Fleet decision for ${work.workId}\n\n## Decision\n\n${quoted(input.reason)}\n\n## Recommendation\n\n${quoted(input.recommendation)}\n\n## Relevant links\n\n${input.links.map(linked).join("\n\n")}\n\n${answer}\n\n## Reviewed Board work\n\n${quoted(work.context)}\n`;
+	const answer = decisionAnswer(copy);
+	return `---\n${JSON.stringify(metadata)}\n---\n# Fleet decision for ${work.workId}\n\n## Decision\n\n${quoted(copy.reason)}\n\n## Recommendation\n\n${quoted(copy.recommendation)}\n\n## Relevant links\n\n${input.links.map(linked).join("\n\n")}\n\n${answer === undefined ? "" : `${answer}\n\n`}## Reviewed Board work\n\n${quoted(work.context)}\n`;
 }
 
 export function publishBoard(root: string, realRoot: string, documents: Effect.Effect<readonly BoardDocument[], BoardFailure>) {
@@ -49,7 +50,8 @@ export function publishBoard(root: string, realRoot: string, documents: Effect.E
 		const workSourcePath = relative(realRoot, work.sourcePath);
 		const itemId = `decision.${revisionOf(JSON.stringify([work.workId, work.revision, workSourcePath, input.id, input.reason, input.recommendation, input.links, ...(input.worker === undefined ? [] : [input.worker])]))}`;
 		const existing = input.published === undefined ? undefined : (yield* documents).find((document) => document.file === input.published?.sourcePath);
-		const context = existing?.parsed.fields.id === itemId ? existing.source : decisionSource(itemId, work, input);
+		const copy = decisionCopy(input);
+		const context = existing?.parsed.fields.id === itemId ? existing.source : decisionSource(itemId, work, input, copy);
 		const parsed = boardApi.metadataParse(context);
 		if (new TextEncoder().encode(context).length > 256 * 1024 || parsed.diagnostics.length > 0) {
 			return yield* Effect.fail(new BoardFailure({ message: "Fleet decision context exceeds Board limits or contains invalid attention metadata." }));
@@ -82,7 +84,7 @@ export function publishBoard(root: string, realRoot: string, documents: Effect.E
 			question: {
 				deadline: registeredAt + 48 * 60 * 60 * 1000,
 				item: itemId,
-				reason: input.reason,
+				reason: copy.reason,
 				registeredAt,
 				request: input.id,
 				reviewedRevision: revision,

package/src/board/publishReport.ts

@@ -1,7 +1,7 @@
 import { relative } from "node:path";
 import { Effect } from "effect";
-import { board } from "@shivaedev/work-board/integration/board.ts";
-import { responses } from "@shivaedev/work-board/integration/responses.ts";
+import { board } from "@shivaedev/work-board/server/integration/board.ts";
+import { responses } from "@shivaedev/work-board/server/integration/responses.ts";
 import { briefRevision } from "#board/briefRevision.ts";
 import type { BoardDocument } from "#board/documents.ts";
 import { recordBoardSource, workMetadata } from "#board/readPass.ts";

package/src/board/readDocument.ts

@@ -1,5 +1,5 @@
 import { Effect, FileSystem } from "effect";
-import { board as boardApi } from "@shivaedev/work-board/integration/board.ts";
+import { board as boardApi } from "@shivaedev/work-board/server/integration/board.ts";
 import { STATUS_MARKER } from "#board/statusMarkdown.ts";
 import { BoardFailure } from "#policy.ts";
 

package/src/board/readPass.ts

@@ -1,7 +1,7 @@
 import { join } from "node:path";
 import { Context, Effect, type FileSystem, type Path } from "effect";
-import type { MetadataModel, ParsedMetadata } from "@shivaedev/work-board/integration/board.ts";
-import { board as boardApi } from "@shivaedev/work-board/integration/board.ts";
+import type { MetadataModel, ParsedMetadata } from "@shivaedev/work-board/server/integration/board.ts";
+import { board as boardApi } from "@shivaedev/work-board/server/integration/board.ts";
 import type { BoardDocument } from "#board/documents.ts";
 import type { BoardFailure, BoardWork } from "#policy.ts";
 

package/src/board/reportIdentity.ts

@@ -1,4 +1,4 @@
-import { responses } from "@shivaedev/work-board/integration/responses.ts";
+import { responses } from "@shivaedev/work-board/server/integration/responses.ts";
 import type { BoardWork } from "#policy.ts";
 import type { SessionReceipt } from "#session/schema.ts";
 

package/src/board/reportLinks.ts

@@ -1,5 +1,5 @@
 import { basename } from "node:path";
-import { responses } from "@shivaedev/work-board/integration/responses.ts";
+import { responses } from "@shivaedev/work-board/server/integration/responses.ts";
 import type { ReportFile, UnavailableAttachment } from "#reportAttachments.ts";
 
 const { revisionOf } = responses;

package/src/board/schema.ts

@@ -1,6 +1,6 @@
 import { Schema } from "effect";
-import { attention } from "@shivaedev/work-board/integration/attention.ts";
-import { responses } from "@shivaedev/work-board/integration/responses.ts";
+import { attention } from "@shivaedev/work-board/server/integration/attention.ts";
+import { responses } from "@shivaedev/work-board/server/integration/responses.ts";
 import { SessionReceipt } from "#session/schema.ts";
 
 const { RequestReceipt } = attention;

package/src/board/upgradeDecisionClosure.ts

@@ -0,0 +1,61 @@
+import { Effect, type FileSystem } from "effect";
+import { responses } from "@shivaedev/work-board/server/integration/responses.ts";
+import { closePublishedDecision, publishedDecision } from "#board/closePublishedDecision.ts";
+import type { BoardDocument } from "#board/documents.ts";
+import type { BoardSnapshot } from "#board/readPass.ts";
+import { writePublished } from "#board/writePublished.ts";
+import { BoardFailure } from "#policy.ts";
+
+const MARKER = ".fleet-decision-closure-v1.json";
+
+export const upgradeDecisionClosure = Effect.fn("FleetBoard.upgradeDecisionClosure")(function* (
+	root: string,
+	realRoot: string,
+	snapshot: BoardSnapshot,
+	fs: FileSystem.FileSystem,
+) {
+	if (yield* fs.exists(`${realRoot}/${MARKER}`).pipe(Effect.mapError((error) => new BoardFailure({ message: error.message })))) {
+		return;
+	}
+	if (snapshot.problems.size > 0) {
+		yield* Effect.logWarning("Fleet decision closure upgrade deferred because the Board has problems", { problems: snapshot.problems.size });
+		return;
+	}
+	const documents = snapshot.documents;
+	const latest = latestSequences(documents);
+	const superseded = new Set(
+		documents.flatMap((document) => {
+			const receipt = document.parsed.fields.requestReceipt;
+			return receipt?.disposition === "superseded" ? [receipt.question] : [];
+		}),
+	);
+	const questions = new Map(
+		documents.flatMap((document) => {
+			const question = responses.questionFrom(document);
+			return question === undefined ? [] : [[question.question.source, question.id] as const];
+		}),
+	);
+	for (const document of documents) {
+		const decision = publishedDecision(document);
+		if (decision !== undefined && (decision.sequence < (latest.get(decision.workId) ?? -1) || superseded.has(questions.get(document.file) ?? ""))) {
+			const closed = yield* closePublishedDecision(root, realRoot, document);
+			if (closed !== undefined) {
+				snapshot.record(closed);
+			}
+		}
+	}
+	yield* writePublished(root, realRoot, MARKER, '{"version":1}\n', (source) => source === '{"version":1}\n').pipe(
+		Effect.mapError((error) => new BoardFailure({ message: error.message })),
+	);
+});
+
+function latestSequences(documents: readonly BoardDocument[]) {
+	const latest = new Map<string, number>();
+	for (const document of documents) {
+		const decision = publishedDecision(document);
+		if (decision !== undefined) {
+			latest.set(decision.workId, Math.max(latest.get(decision.workId) ?? -1, decision.sequence));
+		}
+	}
+	return latest;
+}

package/src/board/workRevision.ts

@@ -1,5 +1,5 @@
-import { board as boardApi } from "@shivaedev/work-board/integration/board.ts";
-import { responses } from "@shivaedev/work-board/integration/responses.ts";
+import { board as boardApi } from "@shivaedev/work-board/server/integration/board.ts";
+import { responses } from "@shivaedev/work-board/server/integration/responses.ts";
 import { briefRevision } from "#board/briefRevision.ts";
 
 const { revisionOf } = responses;

package/src/board/writeHealth.ts

@@ -1,6 +1,6 @@
 import { Effect, Schema } from "effect";
-import type { FleetHealth as BoardFleetHealth } from "@shivaedev/work-board/integration/diagnostics.ts";
-import { diagnostics as diagnosticsApi } from "@shivaedev/work-board/integration/diagnostics.ts";
+import type { FleetHealth as BoardFleetHealth } from "@shivaedev/work-board/server/integration/diagnostics.ts";
+import { diagnostics as diagnosticsApi } from "@shivaedev/work-board/server/integration/diagnostics.ts";
 import { writePublished } from "#board/writePublished.ts";
 import { BoardFailure } from "#policy.ts";
 

package/src/board/writePublished.ts

@@ -4,7 +4,12 @@ import { Effect } from "effect";
 import { type ReportDirectory, validateReportDirectory, withReportDirectory } from "#reportFileDirectory.ts";
 import { hasFileCode, ReportFileFailure, reportFileIo, withReportFile } from "#reportFileFailure.ts";
 
-function unchanged(folder: string, name: "status.md" | "health.json", content: string, owns: (source: string) => boolean) {
+function unchanged(
+	folder: string,
+	name: "status.md" | "health.json" | ".fleet-decision-closure-v1.json",
+	content: string,
+	owns: (source: string) => boolean,
+) {
 	const label = `fleet/${name}`;
 	return withReportFile(
 		label,
@@ -27,7 +32,7 @@ function unchanged(folder: string, name: "status.md" | "health.json", content: s
 const publish = Effect.fnUntraced(function* (
 	directory: ReportDirectory,
 	target: ReportDirectory,
-	name: "status.md" | "health.json",
+	name: "status.md" | "health.json" | ".fleet-decision-closure-v1.json",
 	content: string,
 	owns: (source: string) => boolean,
 ) {
@@ -54,13 +59,17 @@ const publish = Effect.fnUntraced(function* (
 export const writePublished = Effect.fn("Fleet.writePublished")(function* (
 	root: string,
 	realRoot: string,
-	name: "status.md" | "health.json",
+	name: "status.md" | "health.json" | ".fleet-decision-closure-v1.json",
 	content: string,
 	owns: (source: string) => boolean,
 ) {
-	const label = `fleet/${name}`;
+	const upgrade = name === ".fleet-decision-closure-v1.json";
+	const label = upgrade ? name : `fleet/${name}`;
 	return yield* withReportDirectory(label, root, realRoot, (directory) =>
 		Effect.gen(function* () {
+			if (upgrade) {
+				return yield* publish(directory, directory, name, content, owns);
+			}
 			yield* reportFileIo(label, () => mkdir(`${directory.folder}/fleet`)).pipe(
 				Effect.catchTag("ReportFileFailure", (error) => (hasFileCode(error.cause, "EEXIST") ? Effect.void : Effect.fail(error))),
 			);

package/src/cli.ts

@@ -11,7 +11,7 @@ import * as Flag from "effect/cli/Flag";
 import * as Effect from "effect/Effect";
 import * as Option from "effect/Option";
 import { answerCommand, continueCommand, nameThreadsCommand, reassignCommand, releaseCommand } from "#host/actionCommands.ts";
-import { board, config, host, port } from "#host/cliOptions.ts";
+import { board, clientPort, config, host, port } from "#host/cliOptions.ts";
 import { waitCommand, watchCommand } from "#host/followCommands.ts";
 import { VERSION } from "#packageInfo.ts";
 
@@ -20,7 +20,7 @@ const serveCommand = Command.make(
 	{ board: Argument.Directory("board-dir"), config, port },
 	Effect.fn("WorkFleetCli.serve")(function* (input) {
 		const { serveFleet } = yield* Effect.promise(() => import("#host/daemon.ts"));
-		yield* serveFleet(yield* host(input.board, input.config), undefined, input.port);
+		yield* serveFleet(yield* host(input.board, input.config), undefined, Option.getOrUndefined(input.port));
 	}),
 ).pipe(Command.withDescription("Serve the local Fleet HTTP RPC daemon and schedule approved Board work"));
 
@@ -40,7 +40,7 @@ const dispatchCommand = Command.make(
 	Effect.fn("WorkFleetCli.dispatch")(function* (input) {
 		const { daemonRequest } = yield* Effect.promise(() => import("#host/daemonClient.ts"));
 		const value = yield* daemonRequest(
-			input.port,
+			yield* clientPort(input),
 			(client) => client("daemon.dispatch", { ignoreAreas: input.ignoreAreas, now: input.now, workId: input.workId }),
 			`dispatch ${input.workId}`,
 		);
@@ -62,12 +62,20 @@ const statusCommand = Command.make(
 			Promise.all([import("#host/daemonClient.ts"), import("#host/renderStatus.ts")]),
 		);
 		const workId = Option.getOrUndefined(input.workId);
+		const daemonPort = yield* clientPort(input);
 		const current = yield* daemonRequest(
-			input.port,
+			daemonPort,
 			(client) => client("daemon.status", workId === undefined ? {} : { workId }),
 			workId === undefined ? "status" : `status ${workId}`,
 		);
-		yield* Console.log(input.json ? JSON.stringify(current) : renderStatus(current, input.port));
+		yield* Console.log(
+			input.json
+				? JSON.stringify(current)
+				: renderStatus(current, {
+						board: input.board,
+						...Option.match(input.port, { onNone: () => ({}), onSome: (value) => ({ port: value }) }),
+					}),
+		);
 	}),
 ).pipe(Command.withDescription("Show active and completed Fleet work, and waiting work grouped by owner"));
 

package/src/engine/authorizeResolution.ts

@@ -17,7 +17,7 @@ export const authorizeResolution = Effect.fn("Fleet.authorizeResolution")(functi
 	if (executing(record)) {
 		return yield* Effect.fail(new Forbidden({ message: "Confirm terminal execution before releasing ownership" }));
 	}
-	if (record.result?.kind === "change") {
+	if (record.result?.kind === "change" && record.decision?.code !== "pr-closed") {
 		yield* state.store.reserveForeign(record.result.pr, { backlog: true, executing: false });
 	}
 });

package/src/engine/boardBrief.ts

@@ -1,14 +1,13 @@
 import { Effect } from "effect";
 import { Conflict, Forbidden } from "@shivaedev/platform/errors/taxonomy.ts";
 import { workRevision } from "#board/workRevision.ts";
-import { closeDecisions } from "#engine/closeDecisions.ts";
 import { withFailureContext } from "#engine/failureContext.ts";
 import type { EngineState } from "#engine/makeState.ts";
 import type { FleetRecord } from "#model.ts";
 import type { BoardWork } from "#policy.ts";
 import type { Versioned } from "#storage/model.ts";
 
-const CHANGED_BRIEF_REASON = "Board context changed";
+export const CHANGED_BRIEF_REASON = "Board context changed";
 
 export function briefChanged(record: Pick<FleetRecord, "boardRevision" | "boardContext">, work: BoardWork): boolean {
 	return workRevision(record.boardRevision, record.boardContext) !== workRevision(work.revision, work.context);
@@ -33,7 +32,7 @@ export const authorizeBriefContext = Effect.fn("Fleet.authorizeBriefContext")(fu
 ) {
 	yield* authorizeBrief(work);
 	if (briefChanged(record, work)) {
-		return yield* withFailureContext(new Conflict({ message: CHANGED_BRIEF_REASON }), { attentionOwner: "maintainer", code: "fleet-stale" });
+		return yield* withFailureContext(new Conflict({ message: CHANGED_BRIEF_REASON }), { code: "fleet-stale" });
 	}
 });
 
@@ -53,29 +52,22 @@ export function stopChangedBrief(state: EngineState) {
 		) {
 			return stored;
 		}
-		const published = stored.value.decision?.published;
 		const stopped = yield* state.save(stored, {
 			...stored.value,
 			checks: undefined,
 			mergeReadyAt: undefined,
 			mergeReadyHead: undefined,
 			review: undefined,
-			supersededDecisions:
-				published === undefined
-					? stored.value.supersededDecisions
-					: [...(stored.value.supersededDecisions ?? []), { published, supersededAt: state.policy.now() }],
 		});
-		return yield* state
-			.decision(
-				stopped,
-				"fleet-stale",
-				CHANGED_BRIEF_REASON,
-				"Dispatch to approve the current brief in place, retry this decision, or safely release this work",
-				undefined,
-				"maintainer",
-				work,
-			)
-			.pipe(Effect.flatMap(closeDecisions(state)));
+		return yield* state.decision(
+			stopped,
+			"fleet-stale",
+			CHANGED_BRIEF_REASON,
+			"Dispatch to approve the current brief in place, retry this decision, or safely release this work",
+			undefined,
+			undefined,
+			work,
+		);
 	});
 }
 

package/src/engine/decisionCopy.ts

@@ -0,0 +1,63 @@
+import type { DecisionCode } from "#DecisionCode.ts";
+import { CHANGED_BRIEF_REASON } from "#engine/boardBrief.ts";
+import { blocked, type Choice, RELEASE, type Situation } from "#engine/situations/choices.ts";
+import { serviceSituations } from "#engine/situations/service.ts";
+import { stopSituations } from "#engine/situations/stop.ts";
+import { workSituations } from "#engine/situations/work.ts";
+import type { Decision } from "#policy.ts";
+
+export interface DecisionCopy {
+	readonly question?: {
+		readonly title: string;
+		readonly retry?: Choice;
+		readonly release: Choice;
+	};
+	readonly reason: string;
+	readonly recommendation: string;
+}
+
+const situations: Readonly<Record<DecisionCode, Situation>> = { ...serviceSituations, ...stopSituations, ...workSituations };
+
+const changedBrief: Situation = {
+	happened: "The task was edited on the Board while this work was waiting.",
+	question: "Continue with the edited task?",
+	recommendation: "Fleet needs to know whether the edited task still fits the work done so far. If it does, continue. Otherwise stop here.",
+	retry: {
+		label: "Continue on the updated task",
+		outcome: "Fleet accepts the edited task and continues the same work with it, on the same branch and PR.",
+	},
+};
+
+const uncoded = blocked("Fleet stopped and needs your decision.", "Check the details, then let Fleet try again, or stop here.");
+
+const WORKER =
+	"The worker needs your answer to keep going. Write it on this card. Fleet passes it to the same worker, which continues where it stopped.";
+
+export function decisionCopy(decision: Pick<Decision, "code" | "publicationWork" | "reason" | "worker">): DecisionCopy {
+	if (decision.worker !== undefined) {
+		return { reason: decision.reason, recommendation: WORKER };
+	}
+	const situation = situationOf(decision);
+	const detailed = situation.details === true && decision.reason.trim() !== "" && decision.reason !== decision.code;
+	return {
+		question: {
+			release: situation.release ?? RELEASE,
+			title: situation.question ?? "What should Fleet do next?",
+			...(situation.retry === undefined ? {} : { retry: situation.retry }),
+		},
+		reason: detailed ? `${situation.happened}\n\nDetails: ${decision.reason}` : situation.happened,
+		recommendation: situation.recommendation,
+	};
+}
+
+export function releaseOnly(code: DecisionCode | undefined) {
+	const situation = code === undefined ? undefined : situations[code];
+	return situation?.retry === undefined ? situation?.recommendation : undefined;
+}
+
+function situationOf(decision: Pick<Decision, "code" | "publicationWork" | "reason">) {
+	if (decision.code === "fleet-stale" && decision.reason === CHANGED_BRIEF_REASON && decision.publicationWork !== undefined) {
+		return changedBrief;
+	}
+	return decision.code === undefined ? uncoded : situations[decision.code];
+}