@shivaedev/work-fleet 0.0.0 → 0.1.1

package/src/engine/recoverStall.ts

@@ -0,0 +1,83 @@
+import { Effect } from "effect";
+import { briefChanged } from "#engine/boardBrief.ts";
+import type { EngineState } from "#engine/makeState.ts";
+import { resumeAttempt } from "#engine/resumeAttempt.ts";
+import type { Attempt, FleetRecord } from "#model.ts";
+import type { Versioned } from "#storage/model.ts";
+
+const STEER =
+	"There has been no visible progress. Continue the approved work now, or stop with a FLEET_QUESTION explaining what you need to proceed.";
+
+export const recoverStall = Effect.fn("Fleet.recoverStall")(function* (
+	state: EngineState,
+	stored: Versioned<FleetRecord>,
+	attempt: Attempt | undefined,
+) {
+	if (stored.value.stage === "needs-human" || attempt?.receipt === undefined) {
+		return undefined;
+	}
+	const now = state.policy.now();
+	const recovery = attempt.stallRecovery;
+	if (attempt.status === "interrupted" && recovery?.interruptRequestedAt !== undefined) {
+		return yield* resumeStalled(state, stored, attempt);
+	}
+	if (!stalled(attempt, now, state.policy.stallMinutes ?? 30)) {
+		return undefined;
+	}
+	const work = yield* state.board.get(stored.value.workId);
+	if (!work.approved || briefChanged(stored.value, work)) {
+		return undefined;
+	}
+	const count = recovery?.count ?? 0;
+	if (count >= 2) {
+		return yield* state.decision(
+			stored,
+			"session-stalled",
+			"Provider turn stalled after automatic steer and interrupt recovery",
+			"Inspect the worker thread and retry or safely release",
+		);
+	}
+	if (count === 0) {
+		const saved = yield* saveRecovery(state, stored, attempt, { ...recovery, count: 1, lastActionAt: now, steeredAt: now });
+		yield* state.sessions.steer(attempt.receipt, STEER);
+		return saved;
+	}
+	const requested = yield* saveRecovery(state, stored, attempt, { ...recovery, count: 2, interruptRequestedAt: now, lastActionAt: now });
+	yield* state.sessions.interrupt(attempt.receipt);
+	const interrupted = yield* saveRecovery(state, requested, attempt, {
+		...requested.value.attempts.at(-1)?.stallRecovery,
+		count: 2,
+		interruptedAt: now,
+		lastActionAt: now,
+	});
+	const observation = yield* state.sessions.observe(attempt.receipt);
+	if (observation.execution !== "interrupted") {
+		return interrupted;
+	}
+	const terminal = yield* state.save(interrupted, {
+		...interrupted.value,
+		attempts: interrupted.value.attempts.map((entry) =>
+			entry.operationId === attempt.operationId ? { ...entry, output: observation.output, status: observation.execution } : entry,
+		),
+	});
+	return yield* resumeStalled(state, terminal, attempt);
+});
+
+function saveRecovery(state: EngineState, stored: Versioned<FleetRecord>, attempt: Attempt, stallRecovery: NonNullable<Attempt["stallRecovery"]>) {
+	return state.save(stored, {
+		...stored.value,
+		attempts: stored.value.attempts.map((entry) => (entry.operationId === attempt.operationId ? { ...entry, stallRecovery } : entry)),
+	});
+}
+
+const resumeStalled = Effect.fn("Fleet.resumeStalled")(function* (state: EngineState, stored: Versioned<FleetRecord>, attempt: Attempt) {
+	return yield* resumeAttempt(state, stored, attempt, { stallRecovery: { count: 2, lastActionAt: state.policy.now() } });
+});
+
+function stalled(attempt: Attempt, now: number, minutes: number) {
+	return (
+		attempt.status === "running"
+		&& attempt.progress !== undefined
+		&& now - Math.max(attempt.progress.at, attempt.stallRecovery?.lastActionAt ?? attempt.submittedAt) >= minutes * 60_000
+	);
+}

package/src/engine/recoverUnobservable.ts

@@ -0,0 +1,39 @@
+import { Effect } from "effect";
+import { authorizeBriefContext } from "#engine/boardBrief.ts";
+import type { EngineState } from "#engine/makeState.ts";
+import { resumeAttempt } from "#engine/resumeAttempt.ts";
+import type { Attempt, FleetRecord } from "#model.ts";
+import type { Versioned } from "#storage/model.ts";
+
+const VISIBILITY_GRACE_MS = 5 * 60_000;
+
+export const recoverUnobservable = Effect.fn("Fleet.recoverUnobservable")(function* (
+	state: EngineState,
+	stored: Versioned<FleetRecord>,
+	attempt: Attempt | undefined,
+) {
+	if (attempt?.missingSince === undefined) {
+		return undefined;
+	}
+	if (stored.value.stage === "needs-human" || state.policy.now() - Math.max(attempt.missingSince, attempt.progress?.at ?? 0) < VISIBILITY_GRACE_MS) {
+		return stored;
+	}
+	if ((attempt.observationRetries ?? 0) >= 1) {
+		return yield* state.decision(
+			stored,
+			"session-turn-missing",
+			"The acknowledged Codex turn is not observable after the grace period and one automatic resume",
+			"Inspect the worker thread and retry or safely release",
+		);
+	}
+	yield* authorizeBriefContext(stored.value, yield* state.board.get(stored.value.workId));
+	// Retire the missing receipt and reserve its replacement in the same compare-and-set.
+	const retired = {
+		...stored,
+		value: {
+			...stored.value,
+			attempts: stored.value.attempts.map((entry) => (entry.operationId === attempt.operationId ? { ...entry, status: "failed" as const } : entry)),
+		},
+	};
+	return yield* resumeAttempt(state, retired, attempt, { observationRetries: 1, stallRecovery: attempt.stallRecovery });
+});

package/src/engine/refreshBrief.ts

@@ -0,0 +1,59 @@
+import { Effect } from "effect";
+import { workMetadata } from "#board/readPass.ts";
+import { approveBrief } from "#engine/approveBrief.ts";
+import { briefChanged, stopChangedBrief } from "#engine/boardBrief.ts";
+import { ensurePublication } from "#engine/ensurePublication.ts";
+import type { EngineState } from "#engine/makeState.ts";
+import { requestRework } from "#engine/requestRework.ts";
+import type { FleetRecord } from "#model.ts";
+import type { BoardWork } from "#policy.ts";
+import type { Versioned } from "#storage/model.ts";
+
+export const refreshBrief = Effect.fn("Fleet.refreshBrief")(function* (state: EngineState, stored: Versioned<FleetRecord>, work: BoardWork) {
+	const ready = stored.value.stage === "needs-human" && stored.value.decision?.code === "reviewed-pr-ready" && stored.value.result?.kind === "change";
+	const changed = briefChanged(stored.value, work) || preparedAreasChanged(stored.value, work);
+	if (
+		["completed", "released"].includes(stored.value.stage)
+		|| (!ready && (stored.value.stage === "needs-human" || stored.value.decision !== undefined))
+		|| !work.approved
+		|| ["done", "superseded", "deferred"].includes(work.status ?? "")
+		|| !changed
+	) {
+		return stored;
+	}
+	const owner = (yield* workMetadata(work)).fields.owner;
+	if (owner !== undefined && owner !== "codex") {
+		return stored;
+	}
+	if (!ready) {
+		return yield* approveBrief(state)(stored, work);
+	}
+	const published = yield* ensurePublication(state)(stored);
+	return yield* requestRework(state)(
+		{
+			...published,
+			value: {
+				...published.value,
+				areas: work.areas,
+				boardContext: work.context,
+				boardRevision: work.revision,
+				boardSourcePath: work.sourcePath,
+				mergeAreasReleased: undefined,
+			},
+		},
+		work.context,
+	);
+});
+
+function preparedAreasChanged(record: FleetRecord, work: BoardWork): boolean {
+	return record.stage === "prepared" && JSON.stringify(record.areas ?? []) !== JSON.stringify(work.areas ?? []);
+}
+
+export const reconcileBrief = Effect.fn("Fleet.reconcileBrief")(function* (state: EngineState, stored: Versioned<FleetRecord>) {
+	if (["completed", "released"].includes(stored.value.stage)) {
+		return stored;
+	}
+	const work = yield* state.board.get(stored.value.workId);
+	const refreshed = yield* refreshBrief(state, stored, work);
+	return briefChanged(refreshed.value, work) ? yield* stopChangedBrief(state)(refreshed) : refreshed;
+});

package/src/engine/refreshReviewResult.ts

@@ -0,0 +1,85 @@
+import { Effect } from "effect";
+import { BadRequest, Conflict } from "@shivaedev/platform/errors/taxonomy.ts";
+import { validateResult } from "#completion.ts";
+import { authorizeBriefContext } from "#engine/boardBrief.ts";
+import { withFailureContext } from "#engine/failureContext.ts";
+import type { EngineState } from "#engine/makeState.ts";
+import type { FleetRecord } from "#model.ts";
+import type { BoardWork, WorkResult } from "#policy.ts";
+import type { Versioned } from "#storage/model.ts";
+
+export function refreshReviewResult(state: EngineState) {
+	const { integrations, save, board, decision, policy } = state;
+	return Effect.fn("Fleet.refreshReviewResult")(function* (stored: Versioned<FleetRecord>, work: BoardWork, result: WorkResult, head = result.head) {
+		const currentWork = yield* board.get(work.workId);
+		yield* authorizeBriefContext(stored.value, currentWork);
+		const worker = reviewWorker(stored.value);
+		if (worker?.receipt === undefined) {
+			return yield* withFailureContext(new BadRequest({ message: "Review lacks the adopted worker receipt" }), { code: "worker-receipt-missing" });
+		}
+		const current = yield* integrations.result(work, {
+			execution: "completed",
+			output: result.kind === "change" ? `FLEET_HEAD: ${head}\nFLEET_PR: ${result.pr}` : (worker.output ?? ""),
+			provisioning: "unknown",
+			receipt: worker.receipt,
+		});
+		yield* validateResult(stored.value, current);
+		if (head !== result.head && current.head !== head) {
+			return yield* new Conflict({ message: "Current PR result does not match the observed delivery head" });
+		}
+		if (!sameResultIdentity(current, result)) {
+			return yield* decision(
+				stored,
+				"result-identity-changed",
+				"Result identity changed during review",
+				"Inspect ownership before adopting a replacement result",
+			);
+		}
+		if (current.head === result.head) {
+			return stored;
+		}
+		return yield* save(stored, {
+			...stored.value,
+			blocker: undefined,
+			checks: undefined,
+			decision: undefined,
+			mergeReadyAt: undefined,
+			mergeReadyHead: undefined,
+			result: current,
+			resultObservations: [...(stored.value.resultObservations ?? []), result],
+			stage: "reviewing",
+			supersededDecisions: supersedeDecision(stored.value, policy.now()),
+		});
+	});
+}
+
+function reviewWorker(record: FleetRecord) {
+	const cycles = [record, ...(record.history ?? []).toReversed()];
+	for (const cycle of cycles) {
+		if (
+			cycle.boardRevision !== record.boardRevision
+			|| cycle.result === undefined
+			|| record.result === undefined
+			|| !sameResultIdentity(cycle.result, record.result)
+		) {
+			continue;
+		}
+		const worker = cycle.attempts.findLast(
+			(attempt) => attempt.role !== "reviewer" && !(attempt.status === "failed" && attempt.receipt === undefined),
+		);
+		if (worker !== undefined) {
+			return worker;
+		}
+	}
+	return undefined;
+}
+
+function sameResultIdentity(current: WorkResult, result: WorkResult) {
+	return current.kind === result.kind && (current.kind !== "change" || result.kind !== "change" || current.pr === result.pr);
+}
+
+function supersedeDecision(record: FleetRecord, supersededAt: number) {
+	return record.decision?.published === undefined
+		? record.supersededDecisions
+		: [...(record.supersededDecisions ?? []), { published: record.decision.published, supersededAt }];
+}

package/src/engine/releaseClosedPreparation.ts

@@ -0,0 +1,31 @@
+import { Effect } from "effect";
+import type { EngineState } from "#engine/makeState.ts";
+import { releaseExecution } from "#engine/releaseExecution.ts";
+import { releaseFinishedWork } from "#engine/releaseFinishedWork.ts";
+import { executing, type FleetRecord } from "#model.ts";
+import type { BoardWork } from "#policy.ts";
+import type { Versioned } from "#storage/model.ts";
+
+export const releaseClosedPreparation = Effect.fn("Fleet.releaseClosedPreparation")(function* (
+	state: EngineState,
+	stored: Versioned<FleetRecord>,
+	work: BoardWork,
+) {
+	if (!(["prepared", "needs-human"].includes(stored.value.stage) && ["done", "superseded", "deferred"].includes(work.status ?? ""))) {
+		return undefined;
+	}
+	const settled = executing(stored.value)
+		? yield* releaseExecution(state, stored).pipe(
+				Effect.catchTag("Forbidden", () => Effect.succeed(undefined)),
+				Effect.catchTag("ServiceUnavailable", () => Effect.succeed(undefined)),
+			)
+		: stored;
+	if (settled === undefined) {
+		return undefined;
+	}
+	return yield* releaseFinishedWork(
+		state,
+		settled,
+		stored.value.stage === "prepared" ? `Not launched because current Board status is ${work.status}` : `Board status is ${work.status}`,
+	);
+});

package/src/engine/releaseExecution.ts

@@ -0,0 +1,66 @@
+import { Effect } from "effect";
+import { Conflict, Forbidden, ServiceUnavailable } from "@shivaedev/platform/errors/taxonomy.ts";
+import type { EngineState } from "#engine/makeState.ts";
+import { releaseReceipts } from "#engine/releaseReceipts.ts";
+import type { FleetRecord } from "#model.ts";
+import type { SessionFailure, SessionObservation } from "#session/schema.ts";
+import { validateReceipt } from "#session/validateReceipt.ts";
+import type { Versioned } from "#storage/model.ts";
+
+function missingObservation(observation: SessionObservation, singleReceipt: boolean) {
+	return singleReceipt && observation.turnMissing === true && observation.progress?.length === 0;
+}
+
+function observationFailure(error: SessionFailure) {
+	return new ServiceUnavailable({ message: error.message });
+}
+export const releaseExecution = Effect.fn("Fleet.releaseExecution")(function* (state: EngineState, stored: Versioned<FleetRecord>) {
+	let current = stored;
+	for (const attempt of stored.value.attempts) {
+		if (!["submitting", "accepted", "running"].includes(attempt.status)) {
+			continue;
+		}
+		const recoveredReceipts = yield* releaseReceipts(state, attempt);
+		current = yield* state.load(stored.value.workId);
+		if (current.value.stage !== "needs-human" || current.value.decision?.id !== stored.value.decision?.id) {
+			return yield* new Conflict({ message: "Decision changed" });
+		}
+		const acknowledged = current.value.attempts.find((saved) => saved.operationId === attempt.operationId) ?? attempt;
+		const receipts = yield* releaseReceipts(state, { ...acknowledged, terminalReceipts: recoveredReceipts });
+		current = yield* state.save(current, {
+			...current.value,
+			attempts: current.value.attempts.map((saved) => (saved.operationId === attempt.operationId ? { ...saved, terminalReceipts: receipts } : saved)),
+		});
+		const observations: SessionObservation[] = [];
+		for (const receipt of receipts) {
+			yield* validateReceipt(receipt, { sessionId: acknowledged.sessionId }).pipe(Effect.mapError(observationFailure));
+			const observation = yield* state.sessions.observe(receipt).pipe(
+				Effect.map((observed) => (missingObservation(observed, receipts.length === 1) ? undefined : observed)),
+				Effect.catch((error) =>
+					receipts.length === 1 && error.code === "session-turn-missing" && error.reason === "ambiguous"
+						? Effect.succeed(undefined)
+						: Effect.fail(observationFailure(error)),
+				),
+			);
+			if (observation !== undefined) {
+				observations.push(observation);
+			}
+		}
+		if (observations.some((item) => ["accepted", "running"].includes(item.execution))) {
+			return yield* new Forbidden({ message: "Confirm terminal execution before releasing ownership" });
+		}
+		const observation = observations[0];
+		const attempts = current.value.attempts.map((saved) =>
+			saved.operationId === attempt.operationId
+				? {
+						...saved,
+						output: observations.length === 1 ? observation?.output : undefined,
+						sessionUnusable: observations.length === 0 || saved.sessionUnusable,
+						status: observations.length === 1 ? (observation?.execution ?? "interrupted") : ("failed" as const),
+					}
+				: saved,
+		);
+		current = yield* state.save(current, { ...current.value, attempts });
+	}
+	return current;
+});

package/src/engine/releaseFinishedWork.ts

@@ -0,0 +1,31 @@
+import { Effect } from "effect";
+import { closeDecisions } from "#engine/closeDecisions.ts";
+import type { EngineState } from "#engine/makeState.ts";
+import type { FleetRecord } from "#model.ts";
+import type { Versioned } from "#storage/model.ts";
+
+export function releaseFinishedWork(state: EngineState, stored: Versioned<FleetRecord>, releaseReason: string) {
+	const record = stored.value;
+	const published = record.decision?.published;
+	return state
+		.save(stored, {
+			...record,
+			admissionReady: false,
+			attentionOwner: undefined,
+			blocker: undefined,
+			decision: undefined,
+			decisionAcknowledged: undefined,
+			decisionPublished: undefined,
+			launchRetry: undefined,
+			mergeReadyAt: undefined,
+			mergeReadyHead: undefined,
+			outcome: undefined,
+			releaseReason,
+			stage: "released",
+			supersededDecisions:
+				published === undefined
+					? record.supersededDecisions
+					: [...(record.supersededDecisions ?? []), { published, supersededAt: state.policy.now() }],
+		})
+		.pipe(Effect.flatMap(closeDecisions(state)));
+}

package/src/engine/releaseOnly.ts

@@ -0,0 +1,24 @@
+import type { DecisionCode } from "#DecisionCode.ts";
+
+const explanations: Readonly<Partial<Record<DecisionCode, string>>> = {
+	"checks-result-invalid": "Retry cannot validate a malformed adopted result; release and prepare with a valid PR identity and commit SHA.",
+	"delivery-pr-required": "Retry cannot replace an adopted PR identity; release and inspect ownership before preparing a valid GitHub result.",
+	"duplicate-turns": "Retry cannot select one result from duplicate accepted turns; release only after every matching turn is confirmed terminal.",
+	"foreign-pr": "Retry cannot move a PR into the configured repository; release this cycle and prepare work with the correct repository ownership.",
+	"incomplete-context": "Retry cannot reconstruct missing preparation context; release and prepare with complete context.",
+	"incomplete-observation": "Retry cannot establish preparation compatibility; release and prepare with a complete main observation.",
+	"no-change-checks-unconfigured":
+		"Retry cannot validate a no-change result in this host; release and prepare work in a runtime with configured no-change checks.",
+	"not-ancestor": "Retry cannot rebase preparation onto unrelated main history; release and prepare against current main.",
+	"relevant-change": "Retry cannot refresh affected preparation context; release and prepare against current main.",
+	"report-published":
+		"Retry cannot undo GitHub publication because closed pull requests remain publication evidence; release this report cycle and inspect the published work.",
+	"report-too-large": "Retry cannot shorten the immutable completed report; release and prepare a worker to produce a shorter report.",
+	"result-identity-changed": "Retry cannot transfer ownership to a different result; release and inspect the replacement before preparing again.",
+	"worker-receipt-missing":
+		"Retry cannot establish adopted worker ownership from the saved evidence; release and inspect ownership before preparing again.",
+};
+
+export function releaseOnly(code: DecisionCode | undefined) {
+	return code === undefined ? undefined : explanations[code];
+}

package/src/engine/releaseReceipts.ts

@@ -0,0 +1,25 @@
+import { Effect } from "effect";
+import { ServiceUnavailable } from "@shivaedev/platform/errors/taxonomy.ts";
+import type { EngineState } from "#engine/makeState.ts";
+import type { Attempt } from "#model.ts";
+
+export function releaseReceipts(state: EngineState, attempt: Attempt) {
+	if (attempt.terminalReceipts !== undefined && attempt.terminalReceipts.length > 0) {
+		const receipts = [...attempt.terminalReceipts, ...(attempt.receipt === undefined ? [] : [attempt.receipt])];
+		return Effect.succeed([...new Map(receipts.map((receipt) => [JSON.stringify([receipt.sessionId, receipt.turnId]), receipt])).values()]);
+	}
+	if (attempt.receipt !== undefined) {
+		return Effect.succeed([attempt.receipt]);
+	}
+	return state.sessions.reconcile({ operationId: attempt.operationId, sessionId: attempt.sessionId }).pipe(
+		Effect.map((receipt) => [receipt]),
+		Effect.catch((error) => {
+			if (error.terminalReceipts !== undefined && error.terminalReceipts.length > 0) {
+				return Effect.succeed(error.terminalReceipts);
+			}
+			return error.code === "session-turn-missing" && error.reason === "ambiguous"
+				? Effect.succeed([])
+				: Effect.fail(new ServiceUnavailable({ message: error.message }));
+		}),
+	);
+}

package/src/engine/repository.ts

@@ -0,0 +1,143 @@
+import { Context, Effect, Layer } from "effect";
+import { SqlClient } from "effect/sql";
+import { defineService } from "@shivaedev/effect-service/define-service.ts";
+import { operationRecord } from "#engine/operationRecord.ts";
+import { threadName } from "#engine/threadNames.ts";
+import { type Attempt, allAttempts, backlog, executing, FleetRecord } from "#model.ts";
+import { checkAreas, needsAreaRecords, requeue } from "#scheduling/areas.ts";
+import { SessionFailure, type SessionReceipt } from "#session/schema.ts";
+import { SessionJournal } from "#session/service.ts";
+import { makePostgresFleetStore } from "#storage/makePostgresFleetStore.ts";
+
+type Store = Effect.Success<ReturnType<typeof makePostgresFleetStore<typeof FleetRecord>>>;
+export class FleetRepository extends Context.Service<
+	FleetRepository,
+	Omit<Store, "initialize" | "operationEntries"> & Partial<Pick<Store, "operationEntries">>
+>()("@shivaedev/work-fleet/FleetRepository") {}
+class RepositoryNamespace extends Context.Service<RepositoryNamespace, string | undefined>()("Fleet/RepositoryNamespace") {}
+const PostgresFleetRepository = defineService({
+	id: "Fleet/PostgresFleetRepository",
+	initialize: Effect.gen(function* () {
+		const namespace = yield* RepositoryNamespace;
+		const store = yield* makePostgresFleetStore(FleetRecord, {
+			admission: checkAreas,
+			admissionNeedsRecords: needsAreaRecords,
+			backlog,
+			executing,
+			requeue,
+			submissions: (record, since) => allAttempts(record).filter((attempt) => attempt.submittedAt >= since).length,
+			...(namespace === undefined ? {} : { namespace }),
+		});
+		return store;
+	}),
+	methods: ({ initialize: _initialize, ...methods }) => methods,
+	requires: [SqlClient.SqlClient, RepositoryNamespace],
+});
+
+export function postgresFleetRepository(namespace?: string) {
+	return Layer.effect(FleetRepository)(PostgresFleetRepository).pipe(
+		Layer.provide(PostgresFleetRepository.layer.pipe(Layer.provide(Layer.succeed(RepositoryNamespace, namespace)))),
+	);
+}
+const FleetSessionJournal = defineService({
+	id: "Fleet/SessionJournal",
+	initialize: Effect.gen(function* () {
+		const store = yield* FleetRepository;
+		const namingWork = new Map<string, string>();
+		function acknowledge(
+			operationId: string,
+			sessionId: string,
+			receipt?: {
+				readonly sessionId: string;
+				readonly turnId: string;
+			},
+		) {
+			return Effect.gen(function* () {
+				const stored = yield* operationRecord(store, operationId);
+				if (stored === undefined) {
+					return yield* Effect.fail(new SessionFailure({ message: "Submission intent was not persisted", reason: "persistence" }));
+				}
+				const original = stored.value.attempts.find((attempt) => attempt.operationId === operationId);
+				if (
+					original === undefined
+					|| (original.sessionId === undefined && original.status !== "submitting")
+					|| (original.role === "reviewer"
+						&& allAttempts(stored.value).some((attempt) => attempt.role !== "reviewer" && attempt.sessionId === sessionId))
+					|| (original.sessionId !== undefined && original.sessionId !== sessionId)
+					|| (receipt !== undefined
+						&& original.receipt !== undefined
+						&& (original.receipt.sessionId !== receipt.sessionId || original.receipt.turnId !== receipt.turnId))
+				) {
+					return yield* Effect.fail(
+						new SessionFailure({
+							message: "Independent review or submission acknowledgement conflicts with the persisted exact receipt",
+							reason: "persistence",
+						}),
+					);
+				}
+				const attempts = stored.value.attempts.map((attempt) => acknowledgedAttempt(attempt, operationId, sessionId, receipt));
+				yield* store.compareAndSet(stored.value.workId, stored.version, { ...stored.value, attempts });
+				rememberNamingWork(namingWork, stored.value, operationId, sessionId, receipt);
+			}).pipe(
+				Effect.mapError((error) =>
+					error instanceof SessionFailure
+						? error
+						: new SessionFailure({ message: "Receipt persistence failed; reconcile the existing operation", reason: "persistence" }),
+				),
+			);
+		}
+		return { acknowledge, namingWork, store };
+	}),
+	methods: ({ acknowledge, namingWork, store }) =>
+		SessionJournal.of({
+			acknowledgeSession: (operationId: string, sessionId: string) => acknowledge(operationId, sessionId),
+			acknowledgeTurn: (
+				operationId: string,
+				receipt: {
+					readonly sessionId: string;
+					readonly turnId: string;
+				},
+			) => acknowledge(operationId, receipt.sessionId, receipt),
+			sessionName: (operationId: string) =>
+				Effect.gen(function* () {
+					const workId = namingWork.get(operationId);
+					namingWork.delete(operationId);
+					const stored = workId === undefined ? undefined : yield* store.load(workId);
+					return yield* operationThreadName(stored?.value, operationId);
+				}).pipe(Effect.mapError((error) => new SessionFailure({ message: error.message, reason: "persistence" }))),
+		}),
+	requires: [FleetRepository],
+});
+export const fleetSessionJournal = Layer.effect(SessionJournal)(FleetSessionJournal).pipe(Layer.provide(FleetSessionJournal.layer));
+
+function rememberNamingWork(work: Map<string, string>, record: FleetRecord, operationId: string, sessionId: string, receipt?: SessionReceipt) {
+	const continued = allAttempts(record).some((attempt) => attempt.operationId !== operationId && attempt.sessionId === sessionId);
+	if (receipt === undefined && !continued) {
+		work.set(operationId, record.workId);
+	} else {
+		work.delete(operationId);
+	}
+}
+
+function operationThreadName(record: FleetRecord | undefined, operationId: string) {
+	const matches =
+		record === undefined
+			? []
+			: record.attempts
+					.filter((attempt) => attempt.operationId === operationId)
+					.map((attempt) => threadName(record.workId, record.boardContext, attempt.role));
+	const [name] = matches;
+	return matches.length === 1 && name !== undefined
+		? Effect.succeed(name)
+		: Effect.fail(new SessionFailure({ message: "Submission intent is missing or ambiguous", reason: "persistence" }));
+}
+
+function acknowledgedAttempt(attempt: Attempt, operationId: string, sessionId: string, receipt?: SessionReceipt): Attempt {
+	if (attempt.operationId !== operationId) {
+		return attempt;
+	}
+	if (receipt === undefined) {
+		return { ...attempt, sessionId };
+	}
+	return { ...attempt, receipt, sessionId, status: attempt.status === "submitting" ? "accepted" : attempt.status };
+}

package/src/engine/requestConflictRepair.ts

@@ -0,0 +1,40 @@
+import { Effect } from "effect";
+import { failureContext } from "#engine/failureContext.ts";
+import { makeHuman } from "#engine/makeHuman.ts";
+import type { EngineState } from "#engine/makeState.ts";
+import { requestRework } from "#engine/requestRework.ts";
+import type { FleetError } from "#errors.ts";
+import { executing, type FleetRecord } from "#model.ts";
+import type { Versioned } from "#storage/model.ts";
+
+export const requestConflictRepair = Effect.fn("Fleet.requestConflictRepair")(function* (
+	state: EngineState,
+	stored: Versioned<FleetRecord>,
+	failure: FleetError,
+) {
+	const record = stored.value;
+	const { code, mainRevision } = failureContext(failure);
+	if (
+		code !== "pr-conflicting"
+		|| mainRevision === undefined
+		|| executing(record)
+		|| record.review?.verdict !== "approved"
+		|| record.review.head !== record.result?.head
+		|| record.checks?.passed !== true
+		|| record.checks.head !== record.result?.head
+		|| record.conflictRepairs?.includes(mainRevision)
+	) {
+		return undefined;
+	}
+	const resolved = record.decision?.code === "reviewed-pr-ready" ? yield* makeHuman(state)(stored) : stored;
+	if (resolved.value.stage === "released") {
+		return resolved;
+	}
+	const changes = resolved.value.stage === "repairing" ? `${resolved.value.prompt}\n\n` : "";
+	return yield* requestRework(state)(
+		resolved,
+		`${changes}GitHub reports a conflict with main at ${mainRevision}. Fetch and merge main once, resolve the conflicts, and retain the requested changes.`,
+		undefined,
+		mainRevision,
+	);
+});