@shivaedev/work-fleet 0.0.0 → 0.1.1

package/src/providers/readActiveTurn.ts

@@ -0,0 +1,26 @@
+import { Effect } from "effect";
+import type { TurnsResponse } from "#providers/codexProtocol.ts";
+import { failure } from "#providers/codexRpc.ts";
+import type { SessionFailure } from "#session/schema.ts";
+
+export type ReadTurnPage = (sessionId: string, cursor: string | null) => Effect.Effect<typeof TurnsResponse.Type, SessionFailure>;
+
+export function readActiveTurn(readPage: ReadTurnPage) {
+	return Effect.fn("Codex.hasActiveTurn")(function* (sessionId: string) {
+		let cursor: string | null = null;
+		let running = false;
+		const cursors = new Set<string>();
+		do {
+			const page: typeof TurnsResponse.Type = yield* readPage(sessionId, cursor);
+			running ||= page.data.some((turn) => turn.status === "inProgress");
+			cursor = page.nextCursor;
+			if (cursor !== null) {
+				if (cursors.has(cursor)) {
+					return yield* failure("protocol", "Codex repeated a turn pagination cursor");
+				}
+				cursors.add(cursor);
+			}
+		} while (cursor !== null);
+		return running;
+	});
+}

package/src/providers/recoverTurn.ts

@@ -0,0 +1,69 @@
+import { Clock, Effect, Semaphore } from "effect";
+import type { codexTurns } from "#providers/codexTurns.ts";
+import { type ContinueSession, type ReconcileSession, SessionFailure, type SessionReceipt } from "#session/schema.ts";
+
+interface Recovery {
+	readonly lock: Semaphore.Semaphore;
+	receipt?: SessionReceipt;
+}
+
+export function recoverTurn(
+	operationTurn: ReturnType<typeof codexTurns>["operationTurn"],
+	startTurn: (input: ContinueSession) => Effect.Effect<SessionReceipt, SessionFailure>,
+	graceMs?: number,
+) {
+	function missingTurn() {
+		return new SessionFailure({
+			code: "session-turn-missing",
+			message: "No matching accepted turn is observable; absence does not authorize replay",
+			reason: "ambiguous",
+		});
+	}
+	const operations = new Map<string, Recovery>();
+	function resumeMissingTurn(input: ContinueSession, replayable: boolean) {
+		return replayable ? startTurn(input) : Effect.fail(missingTurn());
+	}
+	const recover = Effect.fn("Codex.recover")(function* (input: ReconcileSession & { readonly sessionId: string }) {
+		const deadline = (yield* Clock.currentTimeMillis) + (graceMs ?? 0);
+		let emptyThread = true;
+		let idleThread = true;
+		while (true) {
+			const { empty, idle, turnId } = yield* operationTurn(input.sessionId, input.operationId);
+			emptyThread = emptyThread && empty;
+			idleThread = idleThread && idle;
+			if (turnId !== undefined) {
+				return { sessionId: input.sessionId, turnId };
+			}
+			if (graceMs === undefined || input.resume === undefined) {
+				return yield* Effect.fail(missingTurn());
+			}
+			const remaining = deadline - (yield* Clock.currentTimeMillis);
+			if (remaining <= 0) {
+				return yield* resumeMissingTurn(
+					{ ...input.resume, operationId: input.operationId, sessionId: input.sessionId },
+					replayableThread(input.resume.afterTimeout, emptyThread, idleThread),
+				);
+			}
+			yield* Effect.sleep(Math.min(250, remaining));
+		}
+	});
+	const recoverOnce = Effect.fn("Codex.recoverOnce")(function* (input: ReconcileSession & { readonly sessionId: string }, state: Recovery) {
+		if (state.receipt !== undefined) {
+			return state.receipt;
+		}
+		const receipt = yield* recover(input);
+		state.receipt = receipt;
+		return receipt;
+	});
+	return (input: ReconcileSession & { readonly sessionId: string }) =>
+		Effect.suspend(() => {
+			const key = JSON.stringify([input.sessionId, input.operationId]);
+			const state: Recovery = operations.get(key) ?? { lock: Semaphore.makeUnsafe(1) };
+			operations.set(key, state);
+			return Semaphore.withPermit(state.lock)(recoverOnce(input, state));
+		});
+}
+
+function replayableThread(afterTimeout: boolean | undefined, empty: boolean, idle: boolean) {
+	return empty || (afterTimeout === true && idle);
+}

package/src/providers/startCodexTurn.ts

@@ -0,0 +1,78 @@
+import { Clock, Effect, Result } from "effect";
+import { TurnResponse } from "#providers/codexProtocol.ts";
+import { decode } from "#providers/codexRpc.ts";
+import { type CodexRequest, codexTurns } from "#providers/codexTurns.ts";
+import { genericRejection } from "#providers/genericRejection.ts";
+import { SessionFailure } from "#session/schema.ts";
+import { busyThread, transientFailure } from "#session/transientFailure.ts";
+
+const contentionState = Effect.fn("Codex.contentionState")(function* (
+	error: SessionFailure,
+	sessionId: string,
+	deadline: number,
+	hasActiveTurn: ReturnType<typeof codexTurns>["hasActiveTurn"],
+) {
+	if (error.reason !== "rejected" || (error.code !== undefined && error.code !== "session-rejected")) {
+		return undefined;
+	}
+	if (
+		genericRejection(error)
+		|| (transientFailure(error) && !busyThread(error))
+		|| /credential|api key|unauthorized|unauthenticated|authentication|forbidden|policy|permission|access denied|invalid|quota/iu.test(error.message)
+	) {
+		return undefined;
+	}
+	const remaining = deadline - (yield* Clock.currentTimeMillis);
+	const active =
+		remaining > 0
+			? yield* hasActiveTurn(sessionId).pipe(
+					Effect.timeout(`${remaining} millis`),
+					Effect.catch(() => Effect.succeed(undefined)),
+				)
+			: undefined;
+	return active === false && !busyThread(error) ? undefined : active;
+});
+
+const waitForResubmission = Effect.fn("Codex.waitForResubmission")(function* (
+	sessionId: string,
+	deadline: number,
+	resubmissions: number,
+	active: boolean,
+	waitUntilIdle: ReturnType<typeof codexTurns>["waitUntilIdle"],
+) {
+	if (!active) {
+		const remaining = deadline - (yield* Clock.currentTimeMillis);
+		yield* Effect.sleep(Math.min(5000 * 2 ** resubmissions, 40_000, Math.max(0, remaining)));
+	}
+	return yield* waitUntilIdle(sessionId, deadline);
+});
+
+export function startCodexTurn(rpc: CodexRequest, waitUntilIdle: ReturnType<typeof codexTurns>["waitUntilIdle"]) {
+	const { hasActiveTurn } = codexTurns(rpc);
+	return Effect.fn("Codex.startCodexTurn")(function* (sessionId: string, params: Record<string, unknown>) {
+		const deadline = (yield* Clock.currentTimeMillis) + 300_000;
+		let resubmissions = 0;
+		while (true) {
+			const result = yield* rpc("turn/start", params, true).pipe(Effect.result);
+			if (Result.isSuccess(result)) {
+				return yield* decode(TurnResponse, result.success);
+			}
+			const active = yield* contentionState(result.failure, sessionId, deadline, hasActiveTurn);
+			if (active === undefined) {
+				return yield* result.failure;
+			}
+			const error = new SessionFailure({ ...result.failure, code: "session-active-turn", message: result.failure.message });
+			if (resubmissions >= 3) {
+				return yield* new SessionFailure({
+					...error,
+					code: "session-active-turn-exhausted",
+					message: `${error.message}; active-turn resubmission limit reached`,
+				});
+			}
+			if (!(yield* waitForResubmission(sessionId, deadline, resubmissions, active, waitUntilIdle))) {
+				return yield* new SessionFailure({ ...error, message: `${error.message}; active-turn wait deadline reached` });
+			}
+			resubmissions += 1;
+		}
+	});
+}

package/src/qualifyDependencies.ts

@@ -0,0 +1,54 @@
+import { Effect } from "effect";
+import { Forbidden } from "@shivaedev/platform/errors/taxonomy.ts";
+import { workRevision } from "#board/workRevision.ts";
+import { withFailureContext } from "#engine/failureContext.ts";
+import type { FleetRecord } from "#model.ts";
+import type { BoardFailure, BoardWork } from "#policy.ts";
+
+export const qualifyDependencies = Effect.fn("Fleet.qualifyDependencies")(function* (
+	references: readonly string[],
+	records: readonly FleetRecord[],
+	get: (workId: string) => Effect.Effect<BoardWork, BoardFailure>,
+) {
+	yield* Effect.forEach(references, (reference) =>
+		Effect.gen(function* () {
+			const [workId, criterion] = reference.split("#");
+			if (!workId) {
+				return yield* Effect.fail(new Forbidden({ message: `Dependency reference is invalid: ${reference}` }));
+			}
+			const current = yield* get(workId).pipe(
+				Effect.mapError((error) => new Forbidden({ message: `Dependency ${reference} is unavailable or ambiguous: ${error.message}` })),
+			);
+			if (current.workId !== workId) {
+				return yield* Effect.fail(new Forbidden({ message: `Dependency identity is ambiguous: ${reference}` }));
+			}
+			if (criterion !== undefined) {
+				return yield* Effect.fail(
+					new Forbidden({ message: `Dependency ${reference} needs criterion-specific accepted evidence; a whole-work outcome cannot satisfy it` }),
+				);
+			}
+			const hasFleetWork = records.some((record) => record.workId === workId);
+			const accepted = dependencyAccepted(workId, current, records);
+			const fallback = hasFleetWork ? "" : " or Board status done without Fleet work";
+			if (!accepted) {
+				return yield* Effect.fail(
+					withFailureContext(
+						new Forbidden({
+							message: `waiting for dependency ${reference}: needs an accepted outcome for current Board revision ${current.revision}${fallback}`,
+						}),
+						{ attentionOwner: "automation" },
+					),
+				);
+			}
+		}),
+	);
+});
+
+function dependencyAccepted(workId: string, current: BoardWork, records: readonly FleetRecord[]): boolean {
+	const record = records.find((entry) => entry.workId === workId);
+	return record === undefined
+		? current.status === "done"
+		: record.stage === "completed"
+				&& record.outcome !== undefined
+				&& workRevision(record.boardRevision, record.boardContext) === workRevision(current.revision, current.context);
+}

package/src/reportAttachments.ts

@@ -0,0 +1,26 @@
+export const REPORT_ATTACHMENT_DIRECTORY = "/tmp/fleet-report/attachments/";
+export const REPORT_ATTACHMENT_MARKER = "FLEET_ATTACHMENT:";
+
+export interface ReportFile {
+	readonly bytes: Uint8Array;
+	readonly path: string;
+}
+export interface UnavailableAttachment {
+	readonly path: string;
+	readonly reason: string;
+}
+export interface ReportAttachments {
+	readonly files: readonly ReportFile[];
+	readonly unavailable: readonly UnavailableAttachment[];
+}
+
+export function declaredAttachments(output: string) {
+	return [
+		...new Set(
+			output
+				.split(/\r?\n/u)
+				.filter((line) => line.startsWith(REPORT_ATTACHMENT_MARKER))
+				.map((line) => line.slice(REPORT_ATTACHMENT_MARKER.length).trim()),
+		),
+	];
+}

package/src/reportFileDirectory.ts

@@ -0,0 +1,33 @@
+import { constants } from "node:fs";
+import { type FileHandle, open } from "node:fs/promises";
+import { Effect } from "effect";
+import { publication } from "@shivaedev/work-board/integration/publication.ts";
+import { reportFileIo, withReportFile } from "#reportFileFailure.ts";
+
+export interface ReportDirectory {
+	readonly expected: string;
+	readonly file: FileHandle;
+	readonly folder: string;
+}
+
+export function validateReportDirectory(label: string, directory: ReportDirectory) {
+	return reportFileIo(label, () => publication.validateDirectory(directory.file, directory.folder, directory.expected));
+}
+
+export function withReportDirectory<A, E, R>(
+	label: string,
+	path: string,
+	expected: string,
+	use: (directory: ReportDirectory) => Effect.Effect<A, E, R>,
+) {
+	return withReportFile(
+		label,
+		() => open(path, constants.O_RDONLY | constants.O_DIRECTORY | constants.O_NOFOLLOW),
+		(file) =>
+			Effect.gen(function* () {
+				const directory = { expected, file, folder: publication.directoryPath(file, expected) };
+				yield* validateReportDirectory(label, directory);
+				return yield* use(directory);
+			}),
+	);
+}

package/src/reportFileFailure.ts

@@ -0,0 +1,27 @@
+import type { FileHandle } from "node:fs/promises";
+import { Effect, Schema } from "effect";
+
+export class ReportFileFailure extends Schema.TaggedError<ReportFileFailure>()("ReportFileFailure", {
+	cause: Schema.optional(Schema.Unknown),
+	path: Schema.String,
+	reason: Schema.String,
+}) {
+	override get message() {
+		return `${this.path}: ${this.reason}`;
+	}
+}
+
+export function reportFileIo<A>(path: string, operation: () => Promise<A>) {
+	return Effect.tryPromise({
+		catch: (cause) => new ReportFileFailure({ cause, path, reason: cause instanceof Error ? cause.message : "Filesystem operation failed" }),
+		try: operation,
+	});
+}
+
+export function withReportFile<A, E, R>(path: string, acquire: () => Promise<FileHandle>, use: (file: FileHandle) => Effect.Effect<A, E, R>) {
+	return Effect.acquireUseRelease(reportFileIo(path, acquire), use, (file) => reportFileIo(path, () => file.close()));
+}
+
+export function hasFileCode(cause: unknown, code: string) {
+	return cause instanceof Error && "code" in cause && cause.code === code;
+}

package/src/reportLimits.ts

@@ -0,0 +1,19 @@
+import { BadRequest } from "@shivaedev/platform/errors/taxonomy.ts";
+
+export const REPORT_LIMITS = {
+	attachmentBytes: 32 * 1024 * 1024,
+	attachmentCount: 64,
+	diffBytes: 8 * 1024 * 1024,
+	downloadBytes: 16 * 1024 * 1024,
+};
+
+const NAMES = {
+	attachmentBytes: "Total report attachment bytes",
+	attachmentCount: "Report attachment count",
+	diffBytes: "Downloaded report diff size",
+	downloadBytes: "Downloaded report task size",
+};
+
+export function reportLimit(limit: keyof typeof REPORT_LIMITS) {
+	return new BadRequest({ message: `${NAMES[limit]} limit exceeded (${REPORT_LIMITS[limit]})` });
+}

package/src/scheduling/areas.ts

@@ -0,0 +1,81 @@
+import { Effect } from "effect";
+import { allAttempts, executing, type FleetRecord } from "#model.ts";
+import { StorageAdmission } from "#storage/errors.ts";
+import type { AdmissionLimits } from "#storage/model.ts";
+
+export const DEFAULT_AREA_MERGE_WAIT_MS = 30 * 60 * 1000;
+
+export function mergeWaitExpired(record: FleetRecord, now: number, mergeWaitMs: number): boolean {
+	const ready = record.mergeReadyAt;
+	const head = record.result?.head;
+	return (
+		ready !== undefined
+		&& Number.isFinite(ready)
+		&& now - ready >= mergeWaitMs
+		&& record.stage === "needs-human"
+		&& !executing(record)
+		&& record.result?.kind === "change"
+		&& record.mergeReadyHead === head
+		&& record.review?.head === head
+		&& record.review?.verdict === "approved"
+		&& record.checks?.head === head
+		&& record.checks?.passed === true
+	);
+}
+
+function holdsAreas(record: FleetRecord, now: number, mergeWaitMs: number): boolean {
+	return (
+		!["completed", "released"].includes(record.stage)
+		&& record.attempts.length > 0
+		&& record.mergeAreasReleased !== true
+		&& !mergeWaitExpired(record, now, mergeWaitMs)
+	);
+}
+
+export function needsAreaRecords(record: FleetRecord, previous: FleetRecord | undefined, limits: AdmissionLimits): boolean {
+	return (
+		limits.scheduling !== undefined
+		&& (record.areas?.length ?? 0) > 0
+		&& allAttempts(record).length > (previous === undefined ? 0 : allAttempts(previous).length)
+	);
+}
+
+export const checkAreas = Effect.fn("Fleet.checkAreas")(function* (
+	record: FleetRecord,
+	previous: FleetRecord | undefined,
+	records: readonly FleetRecord[],
+	limits: AdmissionLimits,
+) {
+	const scheduling = limits.scheduling;
+	if (scheduling === undefined || !needsAreaRecords(record, previous, limits)) {
+		return;
+	}
+	const areas = record.areas ?? [];
+	const index = records.findIndex((entry) => entry.workId === record.workId);
+	const holder = records.find(
+		(entry) =>
+			entry.workId !== record.workId
+			&& holdsAreas(entry, scheduling.now, scheduling.areaMergeWaitMs)
+			&& entry.areas?.some((area) => areas.includes(area)),
+	);
+	if (holder !== undefined) {
+		const heldArea = areas.find((area) => holder.areas?.includes(area));
+		return yield* Effect.fail(new StorageAdmission({ message: `waiting for area ${heldArea} held by ${holder.workId}` }));
+	}
+	if (previous !== undefined && holdsAreas(previous, scheduling.now, scheduling.areaMergeWaitMs)) {
+		return;
+	}
+	const ahead = records
+		.slice(0, index)
+		.find((entry) => entry.stage === "prepared" && entry.admissionReady !== false && entry.areas?.some((area) => areas.includes(area)));
+	if (ahead !== undefined) {
+		const queuedArea = areas.find((area) => ahead.areas?.includes(area));
+		return yield* Effect.fail(new StorageAdmission({ message: `waiting for area ${queuedArea} queued ahead by ${ahead.workId}` }));
+	}
+});
+
+export function requeue(record: FleetRecord, previous: FleetRecord): boolean {
+	return (
+		record.stage === "prepared" && record.attempts.length === 0 && (previous.stage !== "prepared" || previous.boardRevision !== record.boardRevision)
+	);
+}

package/src/session/schema.ts

@@ -0,0 +1,66 @@
+import * as Schema from "effect/Schema";
+import { DecisionCode } from "#DecisionCode.ts";
+
+export const ProviderCapacity = Schema.Literals(["rateLimitExceeded", "flexUnavailable", "serverOverloaded"]);
+
+export const SessionReceipt = Schema.Struct({ sessionId: Schema.String, turnId: Schema.String });
+export type SessionReceipt = typeof SessionReceipt.Type;
+
+export const SessionObservation = Schema.Struct({
+	capacity: Schema.optional(ProviderCapacity),
+	error: Schema.optional(Schema.String),
+	execution: Schema.Literals(["accepted", "running", "completed", "failed", "interrupted"]),
+	output: Schema.String,
+	progress: Schema.optional(Schema.Array(Schema.Struct({ id: Schema.String, status: Schema.optional(Schema.String) }))),
+	provisioning: Schema.Literals(["unknown", "ready"]),
+	receipt: SessionReceipt,
+	turnMissing: Schema.optional(Schema.Boolean),
+});
+export type SessionObservation = typeof SessionObservation.Type;
+
+export class SessionFailure extends Schema.TaggedError<SessionFailure>()("SessionFailure", {
+	capacity: Schema.optional(ProviderCapacity),
+	code: Schema.optional(DecisionCode),
+	message: Schema.String,
+	reason: Schema.Literals(["unavailable", "rejected", "ambiguous", "protocol", "persistence"]),
+	terminalReceipts: Schema.optional(Schema.Array(SessionReceipt)),
+}) {}
+
+const Setting = Schema.String.check(Schema.isNonEmpty());
+// Providers echo or reject these; an omitted setting inherits the provider's own default.
+export const LaunchSettings = Schema.Struct({
+	effort: Schema.optional(Setting),
+	model: Schema.optional(Setting),
+	serviceTier: Schema.optional(Setting),
+});
+export type LaunchSettings = typeof LaunchSettings.Type;
+export const StartSession = Schema.Struct({
+	access: Schema.optional(Schema.Literal("read-only")),
+	cwd: Schema.String,
+	operationId: Schema.String,
+	prompt: Schema.String,
+	settings: Schema.optional(LaunchSettings),
+});
+export type StartSession = typeof StartSession.Type;
+export const ContinueSession = Schema.Struct({
+	access: Schema.optional(Schema.Literal("read-only")),
+	operationId: Schema.String,
+	prompt: Schema.String,
+	sessionId: Schema.String,
+	settings: Schema.optional(LaunchSettings),
+});
+export type ContinueSession = typeof ContinueSession.Type;
+export const ReconcileSession = Schema.Struct({
+	operationId: Schema.String,
+	resume: Schema.optional(
+		Schema.Struct({
+			access: ContinueSession.fields.access,
+			afterTimeout: Schema.optional(Schema.Boolean),
+			prompt: ContinueSession.fields.prompt,
+			settings: ContinueSession.fields.settings,
+		}),
+	),
+	sessionId: Schema.optional(Schema.String),
+	turnId: Schema.optional(Schema.String),
+});
+export type ReconcileSession = typeof ReconcileSession.Type;

package/src/session/service.ts

@@ -0,0 +1,103 @@
+import { Cause, Context, Effect } from "effect";
+import { defineService } from "@shivaedev/effect-service/define-service.ts";
+import {
+	type ContinueSession,
+	type ReconcileSession,
+	SessionFailure,
+	type SessionObservation,
+	type SessionReceipt,
+	type StartSession,
+} from "#session/schema.ts";
+import { validateReceipt } from "#session/validateReceipt.ts";
+
+export class SessionTransport extends Context.Service<
+	SessionTransport,
+	{
+		readonly steer?: (receipt: SessionReceipt, prompt: string) => Effect.Effect<void, SessionFailure>;
+		readonly nameSession?: (sessionId: string, name: string) => Effect.Effect<void, SessionFailure>;
+		readonly readSessionName?: (sessionId: string) => Effect.Effect<string | undefined, SessionFailure>;
+		readonly archive?: (sessionId: string) => Effect.Effect<void, SessionFailure>;
+		readonly startSession: (input: StartSession) => Effect.Effect<string, SessionFailure>;
+		readonly startTurn: (input: ContinueSession) => Effect.Effect<SessionReceipt, SessionFailure>;
+		readonly observe: (receipt: SessionReceipt) => Effect.Effect<SessionObservation, SessionFailure>;
+		readonly reconcile: (input: ReconcileSession) => Effect.Effect<SessionReceipt, SessionFailure>;
+		readonly interrupt: (receipt: SessionReceipt) => Effect.Effect<SessionReceipt, SessionFailure>;
+	}
+>()("@shivaedev/work-fleet/SessionTransport") {}
+
+export class SessionJournal extends Context.Service<
+	SessionJournal,
+	{
+		readonly sessionName?: (operationId: string) => Effect.Effect<string, SessionFailure>;
+		readonly acknowledgeSession: (operationId: string, sessionId: string) => Effect.Effect<void, SessionFailure>;
+		readonly acknowledgeTurn: (operationId: string, receipt: SessionReceipt) => Effect.Effect<void, SessionFailure>;
+	}
+>()("@shivaedev/work-fleet/SessionJournal") {}
+
+export const SessionService = defineService({
+	id: "@shivaedev/work-fleet/SessionService",
+	initialize: Effect.gen(function* () {
+		return { journal: yield* SessionJournal, transport: yield* SessionTransport };
+	}),
+	methods: ({ transport, journal }) => ({
+		archive: (sessionId: string) => transport.archive?.(sessionId) ?? Effect.void,
+		continue: (input: ContinueSession) =>
+			Effect.uninterruptibleMask((restore) =>
+				Effect.gen(function* () {
+					yield* journal.acknowledgeSession(input.operationId, input.sessionId);
+					const receipt = yield* restore(transport.startTurn(input));
+					yield* validateReceipt(receipt, input);
+					yield* journal.acknowledgeTurn(input.operationId, receipt);
+					return receipt;
+				}),
+			),
+		interrupt: Effect.fn("SessionService.interrupt")(function* (receipt: SessionReceipt) {
+			const acknowledged = yield* transport.interrupt(receipt);
+			yield* validateReceipt(acknowledged, receipt);
+			return acknowledged;
+		}),
+		observe: Effect.fn("SessionService.observe")(function* (receipt: SessionReceipt) {
+			const observation = yield* transport.observe(receipt);
+			yield* validateReceipt(observation.receipt, receipt);
+			return observation;
+		}),
+		reconcile: Effect.fn("SessionService.reconcile")(function* (input: ReconcileSession) {
+			const receipt = yield* transport.reconcile(input);
+			yield* validateReceipt(receipt, input);
+			yield* journal.acknowledgeTurn(input.operationId, receipt);
+			return receipt;
+		}),
+		start: (input: StartSession) =>
+			Effect.uninterruptibleMask((restore) =>
+				Effect.gen(function* () {
+					const sessionId = yield* restore(transport.startSession(input));
+					yield* journal.acknowledgeSession(input.operationId, sessionId);
+					const name = transport.nameSession;
+					yield* restore(
+						name === undefined || journal.sessionName === undefined
+							? Effect.void
+							: journal.sessionName(input.operationId).pipe(Effect.flatMap((title) => name(sessionId, title))),
+					).pipe(
+						Effect.catch((cause) =>
+							Effect.logWarning("Fleet session naming failed; starting the turn", Cause.fail(cause)).pipe(Effect.annotateLogs({ sessionId })),
+						),
+					);
+					const receipt = yield* restore(
+						transport.startTurn({
+							...(input.access === undefined ? {} : { access: input.access }),
+							operationId: input.operationId,
+							prompt: input.prompt,
+							sessionId,
+							...(input.settings === undefined ? {} : { settings: input.settings }),
+						}),
+					);
+					yield* validateReceipt(receipt, { sessionId });
+					yield* journal.acknowledgeTurn(input.operationId, receipt);
+					return receipt;
+				}),
+			),
+		steer: (receipt: SessionReceipt, prompt: string) =>
+			transport.steer?.(receipt, prompt) ?? Effect.fail(new SessionFailure({ message: "Provider does not support steering", reason: "protocol" })),
+	}),
+	requires: [SessionTransport, SessionJournal],
+});

package/src/session/transientFailure.ts

@@ -0,0 +1,32 @@
+import type { SessionFailure } from "./schema.ts";
+
+function providerMessage(message: string) {
+	return message
+		.toLowerCase()
+		.replace(/^codex rejected the protocol request: /u, "")
+		.replace(/\.$/u, "");
+}
+
+export function busyThread(error: Pick<SessionFailure, "code" | "message">) {
+	return (
+		error.code === "session-active-turn"
+		|| error.code === "session-active-turn-exhausted"
+		|| providerMessage(error.message) === "turn already active for thread"
+	);
+}
+
+export function transientFailure(error: SessionFailure) {
+	return (
+		error.reason === "rejected"
+		&& (error.capacity !== undefined
+			|| error.code === "session-queue-full"
+			|| busyThread(error)
+			|| providerMessage(error.message).startsWith("selected model is at capacity"))
+	);
+}
+
+export function requestTimedOut(error: SessionFailure) {
+	return (
+		(error.reason === "ambiguous" || error.reason === "unavailable") && error.message === "Codex request timed out; preserve submission ownership"
+	);
+}

package/src/session/validateReceipt.ts

@@ -0,0 +1,9 @@
+import { Effect } from "effect";
+import { type ReconcileSession, SessionFailure, type SessionReceipt } from "#session/schema.ts";
+export function validateReceipt(actual: SessionReceipt, known: Pick<ReconcileSession, "sessionId" | "turnId">) {
+	return (known.sessionId !== undefined && actual.sessionId !== known.sessionId) || (known.turnId !== undefined && actual.turnId !== known.turnId)
+		? Effect.fail(
+				new SessionFailure({ message: "Provider receipt differs from the persisted session or turn; retain reservation", reason: "ambiguous" }),
+			)
+		: Effect.void;
+}

package/src/storage/FleetStoreOptions.ts

@@ -0,0 +1,13 @@
+import type { Effect } from "effect";
+import type { StorageAdmission } from "#storage/errors.ts";
+import type { AdmissionLimits } from "#storage/model.ts";
+
+export interface FleetStoreOptions<A> {
+	readonly admission?: (record: A, previous: A | undefined, records: readonly A[], limits: AdmissionLimits) => Effect.Effect<void, StorageAdmission>;
+	readonly admissionNeedsRecords?: (record: A, previous: A | undefined, limits: AdmissionLimits) => boolean;
+	readonly backlog?: (record: A) => boolean;
+	readonly executing?: (record: A) => boolean;
+	readonly namespace?: string;
+	readonly requeue?: (record: A, previous: A) => boolean;
+	readonly submissions?: (record: A, since: number) => number;
+}