@shivaedev/work-fleet 0.0.0 → 0.1.1

package/src/board/statusMarkdown.ts

@@ -0,0 +1,40 @@
+import { sessionStatus } from "#engine/sessionStatus.ts";
+import { views } from "#engine/views.ts";
+import type { FleetRecord, FleetView } from "#model.ts";
+
+export const STATUS_MARKER = "<!-- Generated by Work Fleet. -->";
+
+function text(value: string): string {
+	return value.replaceAll(/\s+/gu, " ").replaceAll(/[\\`*_[\]<>#!|]/gu, "\\$&");
+}
+
+function card(item: typeof FleetView.Type): string {
+	const task = `/_board/item/${encodeURIComponent(item.workId)}`;
+	const links = item.links.flatMap((link) => {
+		if (!URL.canParse(link)) {
+			return [];
+		}
+		const url = new URL(link);
+		return ["http:", "https:"].includes(url.protocol) ? [`[PR](<${url.href.replaceAll("<", "%3C").replaceAll(">", "%3E")}>)`] : [];
+	});
+	const progress = item.sessions.filter((session) => session.lastProgressAt !== undefined).map((session) => text(sessionStatus(session)));
+	return `### ${text(item.workId)}\n\n[Task](<${task}>)${links.map((link) => ` · ${link}`).join("")}\n\nStage: ${text(item.stage)}${item.blocker ? `\n\n${text(item.blocker)}` : ""}${progress.length === 0 ? "" : `\n\n${progress.join("\n\n")}`}`;
+}
+
+export function statusMarkdown(records: readonly FleetRecord[]): string {
+	const current = views([...records].sort((left, right) => left.workId.localeCompare(right.workId)));
+	return `${[
+		STATUS_MARKER,
+		"# Fleet status",
+		"Generated from Fleet execution records. Task status remains authored in the task source.",
+		...(
+			[
+				["Active", current.active],
+				["Waiting on maintainer", current.waiting.maintainer],
+				["Waiting on orchestrator", current.waiting.orchestrator],
+				["Waiting on automation", current.waiting.automation],
+				["Done", current.completed],
+			] as const
+		).flatMap(([heading, items]) => [`## ${heading}`, ...items.map(card)]),
+	].join("\n\n")}\n`;
+}

package/src/board/workRevision.ts

@@ -0,0 +1,9 @@
+import { board as boardApi } from "@shivaedev/work-board/integration/board.ts";
+import { responses } from "@shivaedev/work-board/integration/responses.ts";
+import { briefRevision } from "#board/briefRevision.ts";
+
+const { revisionOf } = responses;
+
+export function workRevision(revision: string, context?: string): string {
+	return context !== undefined && revision === revisionOf(context) ? briefRevision(boardApi.metadataParse(context)) : revision;
+}

package/src/board/writeCompletion.ts

@@ -0,0 +1,69 @@
+import { constants } from "node:fs";
+import { open, readFile, rename, rm } from "node:fs/promises";
+import { Effect } from "effect";
+import { type ReportDirectory, validateReportDirectory, withReportDirectory } from "#reportFileDirectory.ts";
+import { reportFileIo, withReportFile } from "#reportFileFailure.ts";
+
+function current(folder: string, name: string, source: string) {
+	return withReportFile(
+		name,
+		() => open(`${folder}/${name}`, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK),
+		(file) =>
+			Effect.gen(function* () {
+				const stat = yield* reportFileIo(name, () => file.stat());
+				return stat.isFile() && stat.size <= 8 * 1024 * 1024 && (yield* reportFileIo(name, () => readFile(file, "utf8"))) === source;
+			}),
+	);
+}
+
+const replace = Effect.fnUntraced(function* (
+	directories: readonly ReportDirectory[],
+	target: ReportDirectory,
+	name: string,
+	source: string,
+	content: string,
+) {
+	if (source === content || !(yield* current(target.folder, name, source))) {
+		return;
+	}
+	const temporary = `${target.folder}/.${name}-${crypto.randomUUID()}.tmp`;
+	yield* Effect.acquireUseRelease(
+		reportFileIo(name, () => open(temporary, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL, 0o600)),
+		(file) =>
+			Effect.gen(function* () {
+				yield* reportFileIo(name, () => file.writeFile(content, "utf8"));
+				yield* reportFileIo(name, () => file.sync());
+				for (const directory of directories) {
+					yield* validateReportDirectory(name, directory);
+				}
+				if (!(yield* current(target.folder, name, source))) {
+					return;
+				}
+				yield* reportFileIo(name, () => rename(temporary, `${target.folder}/${name}`));
+				yield* reportFileIo(name, () => target.file.sync());
+			}),
+		(file) => reportFileIo(name, () => file.close()).pipe(Effect.onExit(() => reportFileIo(name, () => rm(temporary, { force: true })))),
+	);
+});
+
+export function writeCompletion(root: string, realRoot: string, relative: string, source: string, content: string) {
+	const parts = relative.split("/");
+	const name = parts.pop();
+	if (name === undefined || !name.endsWith(".md") || parts.some((part) => part === "" || part === "." || part === "..")) {
+		return Effect.void;
+	}
+	function descend(
+		directory: ReportDirectory,
+		parents: readonly ReportDirectory[],
+		index: number,
+	): Effect.Effect<void, Effect.Error<ReturnType<typeof replace>>> {
+		const directories = [...parents, directory];
+		const part = parts[index];
+		return part === undefined
+			? replace(directories, directory, name ?? "", source, content)
+			: withReportDirectory(relative, `${directory.folder}/${part}`, `${directory.expected}/${part}`, (child) =>
+					descend(child, directories, index + 1),
+				);
+	}
+	return withReportDirectory(relative, root, realRoot, (directory) => descend(directory, [], 0));
+}

package/src/board/writeHealth.ts

@@ -0,0 +1,30 @@
+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 { writePublished } from "#board/writePublished.ts";
+import { BoardFailure } from "#policy.ts";
+
+const { FLEET_HEALTH_NAME, FleetHealth } = diagnosticsApi;
+
+export function writeHealth(root: string, realRoot: string, snapshot: BoardFleetHealth) {
+	const Json = Schema.fromJsonString(FleetHealth);
+	const Previous = Schema.fromJsonString(
+		Schema.Struct({
+			concurrency: FleetHealth.fields.concurrency,
+			lastCapacityRejection: FleetHealth.fields.lastCapacityRejection,
+			lastSchedulerPass: FleetHealth.fields.lastSchedulerPass,
+			observedAt: FleetHealth.fields.observedAt,
+			queued: FleetHealth.fields.queued,
+			running: FleetHealth.fields.running,
+			staleAfterMs: FleetHealth.fields.staleAfterMs,
+			version: Schema.Literal(1),
+		}),
+	);
+	return writePublished(
+		root,
+		realRoot,
+		FLEET_HEALTH_NAME,
+		`${Schema.encodeSync(Json)(snapshot)}\n`,
+		(source) => Schema.decodeUnknownOption(Json)(source)._tag === "Some" || Schema.decodeUnknownOption(Previous)(source)._tag === "Some",
+	).pipe(Effect.mapError((error) => new BoardFailure({ message: error.message })));
+}

package/src/board/writePublished.ts

@@ -0,0 +1,72 @@
+import { constants } from "node:fs";
+import { mkdir, open, readFile, rename, rm } from "node:fs/promises";
+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) {
+	const label = `fleet/${name}`;
+	return withReportFile(
+		label,
+		() => open(`${folder}/${name}`, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK),
+		(previous) =>
+			Effect.gen(function* () {
+				const stat = yield* reportFileIo(label, () => previous.stat());
+				if (!stat.isFile() || stat.size > 8 * 1024 * 1024) {
+					return yield* Effect.fail(new ReportFileFailure({ path: label, reason: "Publication target must be a regular file under 8 MiB" }));
+				}
+				const source = yield* reportFileIo(label, () => readFile(previous, "utf8"));
+				if (!owns(source)) {
+					return yield* Effect.fail(new ReportFileFailure({ path: label, reason: "Publication target contains authored content" }));
+				}
+				return source === content;
+			}),
+	).pipe(Effect.catchTag("ReportFileFailure", (error) => (hasFileCode(error.cause, "ENOENT") ? Effect.succeed(false) : Effect.fail(error))));
+}
+
+const publish = Effect.fnUntraced(function* (
+	directory: ReportDirectory,
+	target: ReportDirectory,
+	name: "status.md" | "health.json",
+	content: string,
+	owns: (source: string) => boolean,
+) {
+	const label = `fleet/${name}`;
+	if (yield* unchanged(target.folder, name, content, owns)) {
+		return;
+	}
+	const temporary = `${target.folder}/.${name}-${crypto.randomUUID()}.tmp`;
+	yield* Effect.acquireUseRelease(
+		reportFileIo(label, () => open(temporary, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL, 0o600)),
+		(file) =>
+			Effect.gen(function* () {
+				yield* reportFileIo(label, () => file.writeFile(content, "utf8"));
+				yield* reportFileIo(label, () => file.sync());
+				yield* validateReportDirectory(label, directory);
+				yield* validateReportDirectory(label, target);
+				yield* reportFileIo(label, () => rename(temporary, `${target.folder}/${name}`));
+				yield* reportFileIo(label, () => target.file.sync());
+			}),
+		(file) => reportFileIo(label, () => file.close()).pipe(Effect.onExit(() => reportFileIo(label, () => rm(temporary, { force: true })))),
+	);
+});
+
+export const writePublished = Effect.fn("Fleet.writePublished")(function* (
+	root: string,
+	realRoot: string,
+	name: "status.md" | "health.json",
+	content: string,
+	owns: (source: string) => boolean,
+) {
+	const label = `fleet/${name}`;
+	return yield* withReportDirectory(label, root, realRoot, (directory) =>
+		Effect.gen(function* () {
+			yield* reportFileIo(label, () => mkdir(`${directory.folder}/fleet`)).pipe(
+				Effect.catchTag("ReportFileFailure", (error) => (hasFileCode(error.cause, "EEXIST") ? Effect.void : Effect.fail(error))),
+			);
+			return yield* withReportDirectory(label, `${directory.folder}/fleet`, `${realRoot}/fleet`, (target) =>
+				publish(directory, target, name, content, owns),
+			);
+		}),
+	);
+});

package/src/board/writeStatus.ts

@@ -0,0 +1,11 @@
+import { Effect } from "effect";
+import { STATUS_MARKER, statusMarkdown } from "#board/statusMarkdown.ts";
+import { writePublished } from "#board/writePublished.ts";
+import type { FleetRecord } from "#model.ts";
+import { BoardFailure } from "#policy.ts";
+
+export function writeStatus(root: string, realRoot: string, records: readonly FleetRecord[]) {
+	return writePublished(root, realRoot, "status.md", statusMarkdown(records), (source) => source.startsWith(`${STATUS_MARKER}\n`)).pipe(
+		Effect.mapError((error) => new BoardFailure({ message: error.message })),
+	);
+}

package/src/cli.ts

@@ -0,0 +1,97 @@
+#!/usr/bin/env node
+import process from "node:process";
+import * as NodeRuntime from "@effect/platform-node/NodeRuntime";
+import * as NodeServices from "@effect/platform-node/NodeServices";
+import * as Cause from "effect/Cause";
+import * as Console from "effect/Console";
+import * as Argument from "effect/cli/Argument";
+import * as CliError from "effect/cli/CliError";
+import * as Command from "effect/cli/Command";
+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 { waitCommand, watchCommand } from "#host/followCommands.ts";
+import { VERSION } from "#packageInfo.ts";
+
+const serveCommand = Command.make(
+	"serve",
+	{ 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);
+	}),
+).pipe(Command.withDescription("Serve the local Fleet HTTP RPC daemon and schedule approved Board work"));
+
+const dispatchCommand = Command.make(
+	"dispatch",
+	{ board, config, port, workId: Argument.String("id") },
+	Effect.fn("WorkFleetCli.dispatch")(function* (input) {
+		const { daemonClient, daemonError } = yield* Effect.promise(() => import("#host/daemonClient.ts"));
+		const value = yield* Effect.scoped(
+			daemonClient(input.port).pipe(Effect.flatMap((client) => client("daemon.dispatch", { workId: input.workId }))),
+		).pipe(Effect.mapError((error) => daemonError(error, input.port)));
+		yield* Console.log(`${value.workId} ${value.stage}${value.blocker === undefined ? "" : `: ${value.blocker}`}`);
+	}),
+).pipe(Command.withDescription("Prepare the current approved revision of one Board item and launch it"));
+
+const statusCommand = Command.make(
+	"status",
+	{
+		board,
+		config,
+		json: Flag.Boolean("json").pipe(Flag.withDefault(false), Flag.withDescription("Print the views as JSON")),
+		port,
+		workId: Argument.String("id").pipe(Argument.optional),
+	},
+	Effect.fn("WorkFleetCli.status")(function* (input) {
+		const [{ daemonClient, daemonError }, { renderStatus }] = yield* Effect.promise(() =>
+			Promise.all([import("#host/daemonClient.ts"), import("#host/renderStatus.ts")]),
+		);
+		const workId = Option.getOrUndefined(input.workId);
+		const current = yield* Effect.scoped(
+			daemonClient(input.port).pipe(Effect.flatMap((client) => client("daemon.status", workId === undefined ? {} : { workId }))),
+		).pipe(Effect.mapError((error) => daemonError(error, input.port)));
+		yield* Console.log(input.json ? JSON.stringify(current) : renderStatus(current, input.port));
+	}),
+).pipe(Command.withDescription("Show active and completed Fleet work, and waiting work grouped by owner"));
+
+const cli = Command.make("work-fleet").pipe(
+	Command.withDescription("Run approved Work Board items through Work Fleet"),
+	Command.withSubcommands([
+		serveCommand,
+		dispatchCommand,
+		continueCommand,
+		releaseCommand,
+		answerCommand,
+		statusCommand,
+		reassignCommand,
+		waitCommand,
+		watchCommand,
+		nameThreadsCommand,
+	]),
+);
+
+const main = Command.run(cli, { version: VERSION }).pipe(
+	Effect.catchCauseIf(
+		(cause) => !Cause.hasInterrupts(cause),
+		(cause) => {
+			const error = Cause.squash(cause);
+			return (
+				CliError.isCliError(error)
+					? Effect.void
+					: Console.error(`work-fleet: ${(error instanceof Error ? error.message : String(error)).replace(/[\r\n]+/gu, " ")}`)
+			).pipe(
+				Effect.andThen(
+					Effect.sync(() => {
+						process.exitCode = 1;
+					}),
+				),
+			);
+		},
+	),
+	Effect.provide(NodeServices.layer),
+);
+
+NodeRuntime.runMain(main);

package/src/completion.ts

@@ -0,0 +1,27 @@
+import { Effect } from "effect";
+import { BadRequest } from "@shivaedev/platform/errors/taxonomy.ts";
+import type { FleetRecord } from "#model.ts";
+import type { Checks, Review, WorkResult } from "#policy.ts";
+export function validateResult(record: FleetRecord, result: WorkResult) {
+	const valid =
+		result.kind === "no-change"
+			? result.evidence.length > 0
+			: result.paths.length > 0
+				&& result.paths.every((path) =>
+					record.preparation.ownedPaths.some((owned) => owned === "." || path === owned || path.startsWith(`${owned}/`)),
+				)
+				&& result.paths.every((path) => !(path.startsWith("/") || path.split("/").some((part) => ["", ".", ".."].includes(part))));
+	return valid ? Effect.void : Effect.fail(new BadRequest({ message: "Result needs evidence and known reserved scope" }));
+}
+export function validateReview(record: FleetRecord, review: Review, head: string) {
+	return review.head === head
+		&& review.evidence.length > 0
+		&& !record.attempts.some((attempt) => attempt.role !== "reviewer" && attempt.receipt?.sessionId === review.receipt.sessionId)
+		? Effect.void
+		: Effect.fail(new BadRequest({ message: "Independent review must bind evidence to the actual head" }));
+}
+export function validateChecks(checks: Checks, head: string) {
+	return checks.head === head && checks.passed && !checks.pending && checks.evidence.length > 0
+		? Effect.void
+		: Effect.fail(new BadRequest({ message: "Required validation has not passed for the actual head" }));
+}

package/src/engine/ReportInspection.ts

@@ -0,0 +1,10 @@
+import { Context, type Effect } from "effect";
+import type { FleetError } from "#errors.ts";
+import type { BoardWork } from "#policy.ts";
+
+export class ReportInspection extends Context.Service<
+	ReportInspection,
+	{
+		readonly check: (work: BoardWork) => Effect.Effect<void, FleetError>;
+	}
+>()("@shivaedev/work-fleet/ReportInspection") {}

package/src/engine/applyResolution.ts

@@ -0,0 +1,117 @@
+import { Effect } from "effect";
+import { approveBrief } from "#engine/approveBrief.ts";
+import { authorizeBriefContext, isChangedBriefDecision } from "#engine/boardBrief.ts";
+import { closeDecisions } from "#engine/closeDecisions.ts";
+import { continueWorker } from "#engine/continueWorker.ts";
+import type { EngineState } from "#engine/makeState.ts";
+import { requestRework } from "#engine/requestRework.ts";
+import { resolveExecution } from "#engine/resolveExecution.ts";
+import { correctWorkerReport, workerReportFailure } from "#engine/workerReport.ts";
+import { executing, type FleetRecord } from "#model.ts";
+import type { DecisionResponse } from "#policy.ts";
+import type { Versioned } from "#storage/model.ts";
+
+export function applyResolution(state: EngineState) {
+	const { save } = state;
+	return Effect.fn("Fleet.applyResolution")(function* (
+		stored: Versioned<FleetRecord>,
+		responses: readonly DecisionResponse[],
+		action: DecisionResponse["action"],
+		body: string,
+		responseId: string,
+	) {
+		if (action === undefined) {
+			const blocker =
+				responses.at(-1)?.type === "clarify" ? `Human requested clarification: ${responseId}` : `Human deferred this decision: ${responseId}`;
+			return yield* save(stored, { ...stored.value, blocker, responses });
+		}
+		if (action === "continue") {
+			return yield* continueWorker(state)(stored, responses, body).pipe(Effect.flatMap(closeDecisions(state)));
+		}
+		return yield* retryOrRelease(state)(stored, action, responses, body).pipe(Effect.flatMap(closeDecisions(state)));
+	});
+}
+
+function retryOrRelease(state: EngineState) {
+	return Effect.fn("Fleet.retryOrRelease")(function* (
+		stored: Versioned<FleetRecord>,
+		action: "retry" | "release",
+		responses: readonly DecisionResponse[],
+		body: string,
+	) {
+		const publicationWork = stored.value.decision?.publicationWork;
+		if (action === "retry" && isChangedBriefDecision(stored.value) && publicationWork !== undefined) {
+			const work = yield* state.board.get(stored.value.workId);
+			yield* authorizeBriefContext({ boardContext: publicationWork.context, boardRevision: publicationWork.revision }, work);
+			return yield* approveBrief(state)(stored, work, undefined, responses);
+		}
+		const current = yield* resolveExecution(state, stored, action);
+		if (action === "retry") {
+			const rework = yield* retryRework(state)(current, responses, body);
+			if (rework !== undefined) {
+				return rework;
+			}
+		}
+		const stage = resolutionStage(current.value, action);
+		const reportFailure =
+			action === "retry" && stage !== "delivering" ? yield* workerReportFailure(current.value, current.value.decision?.code) : undefined;
+		if (reportFailure !== undefined) {
+			return yield* correctWorkerReport(state)(current, reportFailure, responses);
+		}
+		return yield* state.save(current, { ...current.value, blocker: undefined, decision: undefined, responses, stage });
+	});
+}
+
+function retryRework(state: EngineState) {
+	return Effect.fn("Fleet.retryRework")(function* (stored: Versioned<FleetRecord>, responses: readonly DecisionResponse[], body: string) {
+		const record = stored.value;
+		if (record.result?.kind !== "change" || executing(record)) {
+			return undefined;
+		}
+		const latest = record.attempts.at(-1);
+		let changes = body.trim();
+		if (record.decision?.code === "pr-conflicting") {
+			changes = ["GitHub reports a conflict with main. Fetch and merge main, resolve the conflicts, and retain the requested changes.", changes]
+				.filter(Boolean)
+				.join("\n\n");
+		} else if (latest?.sessionUnusable) {
+			changes = [latest.prompt ?? record.prompt, changes].filter(Boolean).join("\n\n");
+		} else if (record.decision?.code !== "reviewed-pr-ready" || !changes) {
+			return undefined;
+		}
+		return yield* requestRework(state)(stored, changes, responses);
+	});
+}
+
+function resolutionStage(record: FleetRecord, action: "retry" | "release"): FleetRecord["stage"] {
+	if (action === "release") {
+		return "released";
+	}
+	if (deliveryRetry(record)) {
+		return "delivering";
+	}
+	if (record.attempts.at(-1)?.status === "completed" && record.attempts.at(-1)?.receipt === undefined) {
+		return "executing";
+	}
+	if (record.deliverable === "report" && !executing(record)) {
+		const latest = record.attempts.at(-1);
+		return latest?.status === "completed" && latest.output?.trim() ? "adopting" : "prepared";
+	}
+	if (record.attempts.at(-1)?.role === "reviewer") {
+		return "reviewing";
+	}
+	if (executing(record)) {
+		return "executing";
+	}
+	if (record.result !== undefined) {
+		return "reviewing";
+	}
+	return record.attempts.at(-1)?.status === "completed" ? "adopting" : "prepared";
+}
+
+function deliveryRetry(record: FleetRecord) {
+	return (
+		record.result?.kind === "change"
+		&& (record.decision?.code === "pr-head-moved" || (!executing(record) && record.review?.verdict === "approved" && record.checks?.passed === true))
+	);
+}

package/src/engine/approveBrief.ts

@@ -0,0 +1,97 @@
+import { Effect } from "effect";
+import { workRevision } from "#board/workRevision.ts";
+import { authorizeBrief, briefChanged } from "#engine/boardBrief.ts";
+import { closeDecisions } from "#engine/closeDecisions.ts";
+import { ensurePublication } from "#engine/ensurePublication.ts";
+import { launchPrompt } from "#engine/makeLaunch.ts";
+import type { EngineState } from "#engine/makeState.ts";
+import { executing, type FleetRecord } from "#model.ts";
+import type { BoardWork, DecisionResponse } from "#policy.ts";
+import type { Versioned } from "#storage/model.ts";
+
+export function approveBrief(state: EngineState) {
+	return Effect.fn("Fleet.approveBrief")(function* (
+		input: Versioned<FleetRecord>,
+		work: BoardWork,
+		prompt?: string,
+		responses?: readonly DecisionResponse[],
+	) {
+		yield* authorizeBrief(work);
+		const stored = yield* ensurePublication(state)(input);
+		const record = stored.value;
+		const published = record.decision?.published;
+		const approvedPrompt = prompt ?? revisedPrompt(record, work);
+		return yield* state
+			.save(stored, {
+				...record,
+				areas: work.areas,
+				attempts: record.attempts.map((attempt) =>
+					attempt.role === "reviewer" && attempt.reviewRevision === undefined
+						? { ...attempt, reviewRevision: workRevision(record.boardRevision, record.boardContext) }
+						: attempt,
+				),
+				blocker: undefined,
+				boardContext: work.context,
+				boardRevision: work.revision,
+				boardSourcePath: work.sourcePath,
+				checks: undefined,
+				decision: undefined,
+				decisionAcknowledged: undefined,
+				decisionPublished: undefined,
+				launchRetry: revisedRetry(record, approvedPrompt, state.policy.workerGuidance),
+				mergeAreasReleased: undefined,
+				mergeReadyAt: undefined,
+				mergeReadyHead: undefined,
+				prompt: approvedPrompt,
+				responses: responses ?? record.responses,
+				review: undefined,
+				stage: resumedStage(record),
+				supersededDecisions:
+					published === undefined
+						? record.supersededDecisions
+						: [...(record.supersededDecisions ?? []), { published, supersededAt: state.policy.now() }],
+			})
+			.pipe(Effect.flatMap(closeDecisions(state)));
+	});
+}
+
+function revisedPrompt(record: FleetRecord, work: BoardWork) {
+	return record.boardContext && record.prompt.includes(record.boardContext)
+		? record.prompt.replace(record.boardContext, () => work.context)
+		: work.context;
+}
+
+function resumedStage(record: FleetRecord): FleetRecord["stage"] {
+	if (record.stage === "adopting") {
+		return "adopting";
+	}
+	const latest = record.attempts.at(-1);
+	if (executing(record)) {
+		return latest?.role === "reviewer" ? "reviewing" : "executing";
+	}
+	if (latest?.role !== "reviewer" && latest?.status === "completed") {
+		return "executing";
+	}
+	if (record.result !== undefined) {
+		return "reviewing";
+	}
+	return "prepared";
+}
+
+export function approveDispatchedBrief(state: EngineState, stored: Versioned<FleetRecord>, work: BoardWork, prompt?: string) {
+	const record = stored.value;
+	return !["completed", "released"].includes(record.stage)
+		&& briefChanged(record, work)
+		&& (prompt !== undefined || (record.stage !== "prepared" && record.attempts.length > 0))
+		? approveBrief(state)(stored, work, prompt)
+		: Effect.succeed(stored);
+}
+
+function revisedRetry(record: FleetRecord, prompt: string, guidance?: string) {
+	return record.launchRetry === undefined
+		? undefined
+		: {
+				...record.launchRetry,
+				prompt: launchPrompt(record, prompt, undefined, guidance),
+			};
+}

package/src/engine/authorizeResolution.ts

@@ -0,0 +1,23 @@
+import { Effect } from "effect";
+import { Forbidden } from "@shivaedev/platform/errors/taxonomy.ts";
+import { authorizeBriefContext } from "#engine/boardBrief.ts";
+import type { EngineState } from "#engine/makeState.ts";
+import { executing, type FleetRecord } from "#model.ts";
+
+export const authorizeResolution = Effect.fn("Fleet.authorizeResolution")(function* (
+	state: EngineState,
+	record: FleetRecord,
+	action: "retry" | "release",
+) {
+	if (action === "retry") {
+		const work = yield* state.board.get(record.workId);
+		yield* authorizeBriefContext(record, work);
+		return;
+	}
+	if (executing(record)) {
+		return yield* Effect.fail(new Forbidden({ message: "Confirm terminal execution before releasing ownership" }));
+	}
+	if (record.result?.kind === "change") {
+		yield* state.store.reserveForeign(record.result.pr, { backlog: true, executing: false });
+	}
+});