@shivaedev/work-fleet 0.0.0 → 0.1.1

package/src/engine/operationRecord.ts

@@ -0,0 +1,22 @@
+import { Effect } from "effect";
+import type { FleetRepository } from "#engine/repository.ts";
+import { allAttempts } from "#model.ts";
+
+export const operationRecord = Effect.fn("Fleet.operationRecord")(function* (store: typeof FleetRepository.Service, operationId: string) {
+	if (store.operationEntries === undefined) {
+		const matches = (yield* store.list()).flatMap((record) =>
+			allAttempts(record.value)
+				.filter((attempt) => attempt.operationId === operationId)
+				.map(() => record),
+		);
+		return matches.length === 1 ? matches[0] : undefined;
+	}
+	const entries = yield* store.operationEntries(operationId);
+	const entry = entries.length === 1 ? entries[0] : undefined;
+	const stored = entry === undefined ? undefined : yield* store.load(entry.workId);
+	return stored !== undefined
+		&& stored.version === entry?.version
+		&& allAttempts(stored.value).filter((attempt) => attempt.operationId === operationId).length === 1
+		? stored
+		: undefined;
+});

package/src/engine/originalWork.ts

@@ -0,0 +1,16 @@
+import type { FleetRecord } from "#model.ts";
+import type { BoardWork } from "#policy.ts";
+
+export function originalWork(record: FleetRecord): BoardWork | undefined {
+	if (record.boardContext === undefined || record.boardSourcePath === undefined) {
+		return undefined;
+	}
+	return {
+		approved: true,
+		context: record.boardContext,
+		dependsOn: [],
+		revision: record.boardRevision,
+		sourcePath: record.boardSourcePath,
+		workId: record.workId,
+	};
+}

package/src/engine/pendingAcknowledgements.ts

@@ -0,0 +1,52 @@
+import type { BoardDecisionAcknowledgement } from "#board/schema.ts";
+import type { FleetRecord } from "#model.ts";
+
+export function pendingAcknowledgements(record: FleetRecord) {
+	const pending: {
+		readonly cycle: number;
+		readonly response?: number;
+		readonly superseded?: number;
+		readonly input: BoardDecisionAcknowledgement;
+	}[] = [];
+	const cycles = [...(record.history ?? []), record];
+	for (const [cycle, value] of cycles.entries()) {
+		pending.push(...supersededAcknowledgements(value, cycle));
+		for (const [response, receipt] of (value.responses ?? []).entries()) {
+			if (
+				receipt.action !== undefined
+				&& receipt.published !== undefined
+				&& !receipt.boardAcknowledged
+				&& receipt.boardAcknowledgementDisposition === undefined
+			) {
+				pending.push({
+					cycle,
+					input: { decision: receipt.published, disposition: "applied", recordedAt: receipt.processedAt, responseId: receipt.responseId },
+					response,
+				});
+			}
+		}
+		if (
+			"archivedAt" in value
+			&& value.decision?.published !== undefined
+			&& !value.decisionAcknowledged
+			&& value.decision.boardAcknowledgementDisposition === undefined
+		) {
+			pending.push({ cycle, input: { decision: value.decision.published, disposition: "superseded", recordedAt: value.archivedAt } });
+		}
+	}
+	return pending;
+}
+
+function supersededAcknowledgements(value: FleetRecord | NonNullable<FleetRecord["history"]>[number], cycle: number) {
+	return (value.supersededDecisions ?? []).flatMap((receipt, superseded) =>
+		receipt.boardAcknowledged || receipt.boardAcknowledgementDisposition !== undefined
+			? []
+			: [
+					{
+						cycle,
+						input: { decision: receipt.published, disposition: "superseded" as const, recordedAt: receipt.supersededAt },
+						superseded,
+					},
+				],
+	);
+}

package/src/engine/persistTerminalReceipts.ts

@@ -0,0 +1,16 @@
+import { Effect } from "effect";
+import type { EngineState } from "#engine/makeState.ts";
+import type { FleetRecord } from "#model.ts";
+import type { SessionReceipt } from "#session/schema.ts";
+import type { Versioned } from "#storage/model.ts";
+
+export function persistTerminalReceipts(state: EngineState, stored: Versioned<FleetRecord>, receipts: readonly SessionReceipt[] | undefined) {
+	if (receipts === undefined) {
+		return Effect.succeed(stored);
+	}
+	const operationId = stored.value.attempts.at(-1)?.operationId;
+	return state.save(stored, {
+		...stored.value,
+		attempts: stored.value.attempts.map((attempt) => (attempt.operationId === operationId ? { ...attempt, terminalReceipts: receipts } : attempt)),
+	});
+}

package/src/engine/prepareCommand.ts

@@ -0,0 +1,80 @@
+import { Effect } from "effect";
+import { BadRequest, Forbidden } from "@shivaedev/platform/errors/taxonomy.ts";
+import { briefChanged } from "#engine/boardBrief.ts";
+import { ensurePublication } from "#engine/ensurePublication.ts";
+import { withFailureContext } from "#engine/failureContext.ts";
+import { inspectRenewal } from "#engine/inspectRenewal.ts";
+import type { EngineState } from "#engine/makeState.ts";
+import type { PrepareWork } from "#fleet.ts";
+import { executing, type FleetCycleSnapshot, type FleetRecord } from "#model.ts";
+import type { BoardWork } from "#policy.ts";
+import type { Versioned } from "#storage/model.ts";
+
+export function prepareCommand(state: EngineState) {
+	const { store, board, save } = state;
+	return Effect.fn("Fleet.prepare")(function* (input: PrepareWork) {
+		const work = yield* board.get(input.workId);
+		if (!work.approved) {
+			return yield* Effect.fail(
+				withFailureContext(new Forbidden({ message: "Current Board revision needs maintainer approval" }), { code: "approval-required" }),
+			);
+		}
+		if (!input.prompt.trim() || input.preparation.ownedPaths.length === 0) {
+			return yield* Effect.fail(new BadRequest({ message: "Preparation needs fixed prompt and owned paths" }));
+		}
+		const current: FleetRecord = {
+			areas: work.areas,
+			attempts: [],
+			boardContext: work.context,
+			boardRevision: work.revision,
+			boardSourcePath: work.sourcePath,
+			cwd: input.cwd,
+			...(work.deliverable === undefined ? {} : { deliverable: work.deliverable }),
+			...(input.launch === undefined ? {} : { launch: input.launch }),
+			preparation: input.preparation,
+			prompt: input.prompt,
+			stage: "prepared",
+			workId: work.workId,
+		};
+		const existing = yield* store.load(work.workId);
+		if (existing === undefined) {
+			return yield* store.insert(current);
+		}
+		if (unusedPreparation(existing.value)) {
+			return yield* save(existing, { ...current, history: existing.value.history });
+		}
+		return yield* renewPreparation(state, existing, current, work);
+	});
+}
+function unusedPreparation(record: FleetRecord): boolean {
+	return record.stage === "prepared" && record.attempts.length === 0 && record.decision === undefined && (record.responses?.length ?? 0) === 0;
+}
+const renewPreparation = Effect.fn("Fleet.renewPreparation")(function* (
+	state: EngineState,
+	input: Versioned<FleetRecord>,
+	current: FleetRecord,
+	work: BoardWork,
+) {
+	let existing = yield* ensurePublication(state)(input);
+	yield* renewable(existing.value, work);
+	existing = yield* inspectRenewal(state)(existing, work);
+	if (existing.value.result?.kind === "change" && existing.value.outcome === undefined) {
+		yield* state.store.reserveForeign(existing.value.result.pr, { backlog: true, executing: false });
+	}
+	return yield* state.save(existing, { ...current, history: [...(existing.value.history ?? []), snapshot(existing.value, state.policy.now())] });
+});
+const renewable = Effect.fn("Fleet.renewable")(function* (record: FleetRecord, work: BoardWork) {
+	if (record.decision !== undefined && record.decision.published === undefined) {
+		return yield* Effect.fail(new Forbidden({ message: "Reconcile the decision publication receipt before renewing preparation" }));
+	}
+	if (executing(record)) {
+		return yield* Effect.fail(new Forbidden({ message: "Reconcile and confirm terminal execution before renewing preparation" }));
+	}
+	if (record.stage === "completed" && !briefChanged(record, work)) {
+		return yield* Effect.fail(new Forbidden({ message: "Completed work needs a newly approved Board context before renewal" }));
+	}
+});
+function snapshot(record: FleetRecord, archivedAt: number): FleetCycleSnapshot {
+	const { workId: _workId, history: _history, ...cycle } = record;
+	return { ...cycle, archivedAt };
+}

package/src/engine/queueAnswerCommand.ts

@@ -0,0 +1,16 @@
+import { Effect } from "effect";
+import { BadRequest, Conflict } from "@shivaedev/platform/errors/taxonomy.ts";
+import type { EngineState } from "#engine/makeState.ts";
+
+export function queueAnswerCommand(state: EngineState) {
+	return Effect.fn("Fleet.queueAnswer")(function* (workId: string, text: string) {
+		if (!text.trim() || text.length > 32_768) {
+			return yield* new BadRequest({ message: "Supply a nonempty answer of at most 32768 characters" });
+		}
+		const stored = yield* state.load(workId);
+		if (!["repairing", "executing"].includes(stored.value.stage)) {
+			return yield* new Conflict({ message: "Decision changed" });
+		}
+		return yield* state.save(stored, { ...stored.value, pendingAnswers: [...(stored.value.pendingAnswers ?? []), text] });
+	});
+}

package/src/engine/readOrContinueReview.ts

@@ -0,0 +1,77 @@
+import { Effect, Result } from "effect";
+import { admit } from "#admit.ts";
+import { workRevision } from "#board/workRevision.ts";
+import type { EngineState } from "#engine/makeState.ts";
+import { submissionFailure } from "#engine/submissionFailure.ts";
+import type { Attempt, FleetRecord } from "#model.ts";
+import type { BoardWork, WorkResult } from "#policy.ts";
+import { policyGuidance } from "#policyGuidance.ts";
+import { readReviewerVerdict, reviewerPrompt } from "#prompt/reviewer.ts";
+import type { SessionReceipt } from "#session/schema.ts";
+import type { Versioned } from "#storage/model.ts";
+
+export function readOrContinueReview(state: EngineState) {
+	return Effect.fn("Fleet.readOrContinueReview")(function* (
+		stored: Versioned<FleetRecord>,
+		work: BoardWork,
+		result: WorkResult,
+		receipt: SessionReceipt,
+		output: string,
+	) {
+		const parsed = yield* readReviewerVerdict(output, receipt).pipe(Effect.result);
+		if (Result.isSuccess(parsed)) {
+			return parsed.success;
+		}
+		const turns = stored.value.attempts.filter(
+			(attempt) => attempt.role === "reviewer" && (attempt.sessionId ?? attempt.receipt?.sessionId) === receipt.sessionId,
+		);
+		if (turns.length > 1) {
+			return yield* Effect.fail(parsed.failure);
+		}
+		yield* continueReview(state)(stored, work, result, receipt);
+		return undefined;
+	});
+}
+
+function continueReview(state: EngineState) {
+	return Effect.fn("Fleet.continueReview")(function* (stored: Versioned<FleetRecord>, work: BoardWork, result: WorkResult, receipt: SessionReceipt) {
+		const { policy, store, board, save, sessions } = state;
+		const reviewerGuidance = yield* policyGuidance(policy, "reviewer");
+		const prompt = [
+			reviewerPrompt({
+				result,
+				...(reviewerGuidance === undefined ? {} : { reviewerGuidance }),
+				...(policy.sharedEnvironment === undefined ? {} : { sharedEnvironment: policy.sharedEnvironment }),
+				task: work.context,
+			}),
+			"Your previous reply did not contain a parseable verdict. Use the evidence you already inspected and end with exactly one FLEET_REVIEW: JSON line in the required format above. This is the only automatic follow-up; unavailable CI logs or artifacts alone must not withhold a verdict.",
+		].join("\n");
+		const settings = { ...policy.launch };
+		const attempt: Attempt = {
+			operationId: policy.operationId(),
+			prompt,
+			reviewHead: result.head,
+			reviewRevision: workRevision(work.revision, work.context),
+			role: "reviewer",
+			sessionId: receipt.sessionId,
+			settings,
+			status: "submitting",
+			submittedAt: policy.now(),
+		};
+		const quota = yield* policy.refreshQuota === undefined ? Effect.succeed(policy.quota) : policy.refreshQuota();
+		yield* admit(
+			work,
+			(yield* store.list()).map(({ value }) => value),
+			{ ...policy, quota },
+			board.get,
+		);
+		yield* save(stored, { ...stored.value, attempts: [...stored.value.attempts, attempt] }, { quota, role: "reviewer" });
+		yield* sessions
+			.continue({ access: "read-only", operationId: attempt.operationId, prompt, sessionId: receipt.sessionId, settings })
+			.pipe(
+				Effect.catch((error) =>
+					submissionFailure(state, stored.value.workId, attempt.operationId, error, "Restore provider access and retry this review"),
+				),
+			);
+	});
+}

package/src/engine/readResolution.ts

@@ -0,0 +1,53 @@
+import { Effect } from "effect";
+import { BadRequest, Conflict } from "@shivaedev/platform/errors/taxonomy.ts";
+import type { RecordedResponse } from "@shivaedev/work-board/integration/responses.ts";
+import { releaseOnly } from "#engine/releaseOnly.ts";
+import type { BoardGateway, Decision } from "#policy.ts";
+
+export const readResolution = Effect.fn("Fleet.readResolution")(function* (
+	board: typeof BoardGateway.Service,
+	decision: Decision,
+	responseId: string,
+) {
+	const published = decision.published;
+	if (published === undefined) {
+		return yield* Effect.fail(new Conflict({ message: "Board decision publication must be reconciled first" }));
+	}
+	const reading = yield* board.readDecision(published);
+	if (reading._tag !== "Response" || reading.response.id !== responseId) {
+		return yield* Effect.fail(new Conflict({ message: "Board response is missing, ambiguous, superseded or belongs to changed context" }));
+	}
+	const response = reading.response;
+	if (response.response.question !== published.questionId || response.response.reviewedRevision !== published.revision) {
+		return yield* Effect.fail(new Conflict({ message: "Response does not match the exact Board question" }));
+	}
+	if (response.response.type !== "answer") {
+		return { action: undefined, published, response };
+	}
+	if (decision.worker !== undefined && !releaseSelected(response)) {
+		if (response.body.trim().length === 0) {
+			return yield* Effect.fail(new BadRequest({ message: "Record a nonempty answer for the worker" }));
+		}
+		return { action: "continue", published, response } as const;
+	}
+	const action = yield* guidedAction(response);
+	const explanation = releaseOnly(decision.code);
+	if (action === "retry" && explanation !== undefined) {
+		return yield* new BadRequest({ message: explanation });
+	}
+	return { action, published, response } as const;
+});
+
+const guidedAction = Effect.fn("Fleet.guidedAction")(function* (response: RecordedResponse) {
+	const answers = response.response.answers?.filter((answer) => answer.prompt === "fleet-action") ?? [];
+	const selected = answers[0]?.selected;
+	const action = selected?.[0];
+	if (answers.length !== 1 || selected?.length !== 1 || (action !== "retry" && action !== "release")) {
+		return yield* Effect.fail(new BadRequest({ message: "Choose one guided Fleet retry or release action; free text cannot authorize it" }));
+	}
+	return action;
+});
+
+function releaseSelected(response: RecordedResponse) {
+	return response.response.answers?.some((answer) => answer.prompt === "fleet-action" && answer.selected.includes("release")) ?? false;
+}

package/src/engine/readRetry.ts

@@ -0,0 +1,104 @@
+import { Effect } from "effect";
+import { ServiceUnavailable } from "@shivaedev/platform/errors/taxonomy.ts";
+import { retryLostReview, retryMissingReview } from "#engine/capacityRetry.ts";
+import { failureCode } from "#engine/failureCode.ts";
+import { failureContext } from "#engine/failureContext.ts";
+import { failureMessage } from "#engine/failureMessage.ts";
+import type { EngineState } from "#engine/makeState.ts";
+import type { Attempt, FleetRecord } from "#model.ts";
+import { BoardFailure } from "#policy.ts";
+import { SessionFailure } from "#session/schema.ts";
+import { requestTimedOut, transientFailure } from "#session/transientFailure.ts";
+import type { Versioned } from "#storage/model.ts";
+
+function retryKind(error: unknown, record: FleetRecord) {
+	if (error instanceof SessionFailure && retryProviderRead(error, record)) {
+		return "provider";
+	}
+	return (error instanceof ServiceUnavailable && failureContext(error).retryable !== false)
+		|| (error instanceof BoardFailure && error.code === "incomplete-observation")
+		? "integration"
+		: undefined;
+}
+
+function retryProviderRead(error: SessionFailure, record: FleetRecord) {
+	return (
+		transientFailure(error)
+		|| requestTimedOut(error)
+		|| (error.reason === "unavailable" && record.attempts.at(-1)?.submissionUncertain === true)
+		|| (error.reason === "ambiguous"
+			&& (error.code === "session-unavailable" || (record.attempts.at(-1)?.readRetry !== undefined && error.code !== "duplicate-turns")))
+	);
+}
+
+function retryAttempts(record: FleetRecord, operationId: string | undefined, retry: Attempt["readRetry"], uncertainOperationId?: string) {
+	return record.attempts.map((attempt) =>
+		attempt.operationId === operationId
+			? { ...attempt, readRetry: retry, ...(attempt.operationId === uncertainOperationId ? { submissionUncertain: true } : {}) }
+			: attempt,
+	);
+}
+
+export const readRetry = Effect.fn("Fleet.readRetry")(function* (
+	state: EngineState,
+	current: Versioned<FleetRecord>,
+	error: unknown,
+	uncertainOperationId?: string,
+) {
+	const kind = retryKind(error, current.value);
+	if (kind === undefined) {
+		return yield* retryMissingReview(state, current.value, error);
+	}
+	if (current.value.decision !== undefined) {
+		return current;
+	}
+	if (current.value.launchRetry !== undefined) {
+		return current;
+	}
+	const attempt = current.value.attempts.at(-1);
+	if (kind === "provider" && (attempt === undefined || !["submitting", "accepted", "running"].includes(attempt.status))) {
+		return undefined;
+	}
+	const previous = kind === "provider" ? attempt?.readRetry : current.value.integrationRetry;
+	if (retryPending(state, current.value)) {
+		return current;
+	}
+	const failures = (previous?.failures ?? 0) + 1;
+	if (failures >= 5 && (yield* retryLostReview(state, current.value, error))) {
+		return yield* state.load(current.value.workId);
+	}
+	const retryAt = state.policy.now() + 30_000 * 2 ** (failures - 1);
+	const message = failureMessage(error);
+	const subject = { integration: "integration evidence", provider: "provider state" }[kind];
+	const retry = failures < 5 ? { error: message, failures, retryAt } : undefined;
+	const saved = yield* state.save(current, {
+		...current.value,
+		attempts: kind === "provider" ? retryAttempts(current.value, attempt?.operationId, retry, uncertainOperationId) : current.value.attempts,
+		attentionOwner: "automation",
+		blocker: `Waiting to read ${subject}: ${message}; read attempt ${failures} of 5; retry after ${new Date(retryAt).toISOString()}`,
+		integrationRetry: kind === "integration" ? retry : current.value.integrationRetry,
+	});
+	return failures < 5
+		? saved
+		: yield* state
+				.decision(
+					saved,
+					failureCode(error),
+					`${message}; ${kind} read failure after ${failures} attempts (${failures - 1} automatic retries); execution ownership retained`,
+					"Restore integration reads and reconcile this existing work before retrying or releasing",
+					undefined,
+					failureContext(error).attentionOwner,
+				)
+				.pipe(Effect.catchTag("BoardFailure", () => state.load(current.value.workId)));
+});
+
+export function retryPending(state: EngineState, record: FleetRecord) {
+	return [record.integrationRetry, record.attempts.at(-1)?.readRetry].some((retry) => retry !== undefined && state.policy.now() < retry.retryAt);
+}
+
+export const clearIntegrationRetry = Effect.fn("Fleet.clearIntegrationRetry")(function* (state: EngineState, current: Versioned<FleetRecord>) {
+	if (current.value.integrationRetry === undefined) {
+		return current;
+	}
+	return yield* state.save(current, { ...current.value, integrationRetry: undefined });
+});

package/src/engine/reassignCommand.ts

@@ -0,0 +1,45 @@
+import { Effect } from "effect";
+import { Conflict } from "@shivaedev/platform/errors/taxonomy.ts";
+import type { AttentionOwner } from "#attention.ts";
+import { closeDecisions } from "#engine/closeDecisions.ts";
+import { ensurePublication } from "#engine/ensurePublication.ts";
+import type { EngineState } from "#engine/makeState.ts";
+
+export function reassignCommand(state: EngineState) {
+	return Effect.fn("Fleet.reassign")(
+		function* (workId: string, decisionId: string, attentionOwner: AttentionOwner) {
+			let stored = yield* state.load(workId);
+			if (stored.value.stage !== "needs-human" || stored.value.decision?.id !== decisionId) {
+				const prior = stored.value.supersededDecisions?.find((receipt) => receipt.published.request === decisionId);
+				if (prior?.reassignedTo?.attentionOwner === attentionOwner && prior.reassignedTo.decisionId === stored.value.decision?.id) {
+					stored = yield* ensurePublication(state)(stored);
+					return yield* closeDecisions(state)(stored);
+				}
+				return yield* Effect.fail(new Conflict({ message: "The waiting decision changed" }));
+			}
+			stored = yield* ensurePublication(state)(stored);
+			const previous = stored.value.decision;
+			if (previous?.published === undefined) {
+				return yield* Effect.fail(new Conflict({ message: "Publish the current decision before reassignment" }));
+			}
+			if (stored.value.attentionOwner === attentionOwner && previous.attentionOwner === attentionOwner) {
+				return yield* closeDecisions(state)(stored);
+			}
+			const decision = { ...previous, attentionOwner, id: `${workId}.${stored.version}`, published: undefined };
+			stored = yield* state.save(stored, {
+				...stored.value,
+				attentionOwner,
+				blocker: undefined,
+				decision,
+				decisionPublished: false,
+				supersededDecisions: [
+					...(stored.value.supersededDecisions ?? []),
+					{ published: previous.published, reassignedTo: { attentionOwner, decisionId: decision.id }, supersededAt: state.policy.now() },
+				],
+			});
+			stored = yield* ensurePublication(state)(stored);
+			return yield* closeDecisions(state)(stored);
+		},
+		(effect) => effect.pipe(Effect.catchTag("StorageConflict", () => Effect.fail(new Conflict({ message: "The waiting decision changed" })))),
+	);
+}

package/src/engine/reconcileAttempt.ts

@@ -0,0 +1,29 @@
+import { Effect } from "effect";
+import { briefApproved, briefChanged } from "#engine/boardBrief.ts";
+import type { EngineState } from "#engine/makeState.ts";
+import type { Attempt, FleetRecord } from "#model.ts";
+import { reportPrompt } from "#prompt/worker.ts";
+import type { Versioned } from "#storage/model.ts";
+
+export function reconcileAttempt({ sessions, policy, board }: EngineState) {
+	return Effect.fn("Fleet.reconcileAttempt")(function* (stored: Versioned<FleetRecord>, attempt: Attempt) {
+		const work = yield* board.get(stored.value.workId);
+		const authorized = briefApproved(work) && !briefChanged(stored.value, work);
+		const preparedPrompt = stored.value.deliverable === "report" ? reportPrompt(stored.value.prompt) : stored.value.prompt;
+		const prompt = attempt.prompt ?? (attempt.role === "worker" ? preparedPrompt : undefined);
+		return yield* sessions.reconcile({
+			operationId: attempt.operationId,
+			sessionId: attempt.sessionId,
+			...(prompt === undefined || !authorized || attempt.submissionUncertain
+				? {}
+				: {
+						resume: {
+							...(attempt.role === "reviewer" ? { access: "read-only" as const } : {}),
+							afterTimeout: attempt.submissionTimedOut,
+							prompt,
+							settings: attempt.settings ?? { ...policy.launch, ...stored.value.launch },
+						},
+					}),
+		});
+	});
+}

package/src/engine/reconcileCommand.ts

@@ -0,0 +1,74 @@
+import { Effect } from "effect";
+import { completeBoardWork } from "#engine/completeBoardWork.ts";
+import { failureCode } from "#engine/failureCode.ts";
+import { failureContext } from "#engine/failureContext.ts";
+import { failureMessage } from "#engine/failureMessage.ts";
+import { failureOwner } from "#engine/failureOwner.ts";
+import type { makeAdvance } from "#engine/makeAdvance.ts";
+import type { EngineState } from "#engine/makeState.ts";
+import { persistTerminalReceipts } from "#engine/persistTerminalReceipts.ts";
+import { clearIntegrationRetry, readRetry, retryPending } from "#engine/readRetry.ts";
+import { refreshBrief } from "#engine/refreshBrief.ts";
+import type { FleetRecord } from "#model.ts";
+import { SessionFailure } from "#session/schema.ts";
+import { StorageAdmission, StorageCapacity, StorageConflict, StorageQuota } from "#storage/errors.ts";
+import type { Versioned } from "#storage/model.ts";
+
+function capacityFailure(error: unknown) {
+	return (
+		error instanceof StorageAdmission
+		|| error instanceof StorageQuota
+		|| error instanceof StorageCapacity
+		|| failureCode(error) === "provider-quota-unavailable"
+	);
+}
+export function reconcileCommand(state: EngineState, advance: ReturnType<typeof makeAdvance>) {
+	const { load, save, decision } = state;
+	const handleFailure = Effect.fn("Fleet.handleFailure")(function* (workId: string, error: unknown) {
+		let current = yield* load(workId);
+		if (error instanceof StorageConflict || ["completed", "released", "needs-human"].includes(current.value.stage)) {
+			return current;
+		}
+		if (failureCode(error) === "fleet-stale") {
+			const refreshed = yield* refreshBrief(state, current, yield* state.board.get(workId));
+			if (refreshed.version !== current.version) {
+				return refreshed;
+			}
+		}
+		if (capacityFailure(error)) {
+			return yield* save(current, { ...current.value, attentionOwner: failureOwner(error), blocker: failureMessage(error) });
+		}
+		const retrying = yield* readRetry(state, current, error);
+		if (retrying !== undefined) {
+			return retrying;
+		}
+		current = yield* persistTerminalReceipts(state, current, error instanceof SessionFailure ? error.terminalReceipts : undefined);
+		return yield* decision(
+			current,
+			failureCode(error),
+			failureMessage(error),
+			"Inspect this specific integration failure and retry the existing work",
+			undefined,
+			failureContext(error).attentionOwner,
+		).pipe(Effect.catchTag("BoardFailure", () => load(workId)));
+	});
+	return Effect.fn("Fleet.reconcile")(function* (
+		workId: string,
+	): Effect.fn.Return<
+		Versioned<FleetRecord>,
+		Effect.Error<ReturnType<typeof decision>> | Effect.Error<ReturnType<typeof load>> | Effect.Error<ReturnType<typeof refreshBrief>>
+	> {
+		let current = yield* load(workId);
+		if (current.value.stage !== "needs-human" && retryPending(state, current.value)) {
+			return current;
+		}
+		if (current.value.integrationRetry !== undefined) {
+			current = yield* save(current, { ...current.value, attentionOwner: undefined, blocker: undefined });
+		}
+		return yield* advance(workId).pipe(
+			Effect.flatMap((updated) => clearIntegrationRetry(state, updated)),
+			Effect.catch((error) => handleFailure(workId, error)),
+			Effect.flatMap(completeBoardWork(state)),
+		);
+	});
+}