@shivaedev/work-fleet 0.0.0 → 0.1.1

package/src/storage/admission.ts

@@ -0,0 +1,82 @@
+import { Effect } from "effect";
+import { StorageCapacity, StorageQuota } from "#storage/errors.ts";
+import type { FleetStoreOptions } from "#storage/FleetStoreOptions.ts";
+import type { AdmissionLimits, ForeignReservation, Versioned } from "#storage/model.ts";
+export function acquires<A>(predicate: ((record: A) => boolean) | undefined, record: A, previous: A | undefined): boolean {
+	return predicate?.(record) === true && (previous === undefined || !predicate(previous));
+}
+
+export const checkCapacity = Effect.fn("FleetStore.checkCapacity")(function* <A>(
+	kind: "execution" | "backlog",
+	limit: number | undefined,
+	predicate: ((record: A) => boolean) | undefined,
+	acquiring: boolean,
+	others: readonly Versioned<A>[],
+	external: number,
+) {
+	if (limit === undefined || predicate === undefined || !acquiring) {
+		return;
+	}
+	const occupied = others.filter(({ value }) => predicate(value)).length + external;
+	if (occupied >= limit) {
+		return yield* Effect.fail(new StorageCapacity({ kind, limit }));
+	}
+});
+
+export const checkQuota = Effect.fn("FleetStore.checkQuota")(function* <A>(
+	quota: AdmissionLimits["quota"],
+	submissions: ((record: A, since: number) => number) | undefined,
+	record: A,
+	previous: A | undefined,
+	others: readonly Versioned<A>[],
+) {
+	if (quota === undefined) {
+		return;
+	}
+	if (submissions === undefined) {
+		return yield* Effect.fail(new StorageQuota({ ...quota, reason: "unconfigured" }));
+	}
+	const candidate = submissions(record, quota.observedAt);
+	if (previous !== undefined && candidate <= submissions(previous, quota.observedAt)) {
+		return;
+	}
+	const submitted = others.reduce((total, entry) => total + submissions(entry.value, quota.observedAt), candidate);
+	if (submitted > quota.available) {
+		return yield* Effect.fail(new StorageQuota({ ...quota, reason: "exhausted", submitted }));
+	}
+});
+
+export const checkRecordAdmission = Effect.fn("FleetStore.checkRecordAdmission")(function* <A extends { readonly workId: string }>(
+	options: FleetStoreOptions<A>,
+	record: A,
+	previous: A | undefined,
+	entries: readonly Versioned<A>[],
+	external: readonly ForeignReservation[],
+	limits: AdmissionLimits,
+) {
+	yield* options.admission?.(
+		record,
+		previous,
+		entries.map(({ value }) => value),
+		limits,
+	) ?? Effect.void;
+	const others = entries.filter(({ value }) => value.workId !== record.workId);
+	const acquiringExecution = acquires(options.executing, record, previous);
+	yield* checkCapacity(
+		"execution",
+		limits.maxExecuting,
+		options.executing,
+		acquiringExecution,
+		others,
+		external.filter((entry) => entry.executing).length,
+	);
+	yield* checkCapacity(
+		"backlog",
+		limits.maxBacklog,
+		options.backlog,
+		acquiringExecution || acquires(options.backlog, record, previous),
+		others,
+		external.filter((entry) => entry.backlog).length,
+	);
+	yield* checkQuota(limits.quota, options.submissions, record, previous, others);
+});

package/src/storage/admissionReads.ts

@@ -0,0 +1,16 @@
+import { acquires } from "#storage/admission.ts";
+import type { FleetStoreOptions } from "#storage/FleetStoreOptions.ts";
+import type { AdmissionLimits } from "#storage/model.ts";
+
+export function admissionReads<A>(options: FleetStoreOptions<A>, record: A, previous: A | undefined, limits: AdmissionLimits) {
+	const executing = acquires(options.executing, record, previous);
+	const capacity =
+		(limits.maxExecuting !== undefined && options.executing !== undefined && executing)
+		|| (limits.maxBacklog !== undefined && options.backlog !== undefined && (executing || acquires(options.backlog, record, previous)));
+	const quota =
+		limits.quota !== undefined
+		&& options.submissions !== undefined
+		&& (previous === undefined || !(options.submissions(record, limits.quota.observedAt) <= options.submissions(previous, limits.quota.observedAt)));
+	const admission = options.admission !== undefined && (options.admissionNeedsRecords?.(record, previous, limits) ?? true);
+	return { foreign: capacity, records: admission || capacity || quota };
+}

package/src/storage/backfillDecisionCodes.ts

@@ -0,0 +1,89 @@
+import { Effect, Schema } from "effect";
+import { SqlClient } from "effect/sql";
+import type { DecisionCode } from "#DecisionCode.ts";
+
+// These are historical persisted values, frozen independently of runtime copy.
+const legacyCodes: Readonly<Record<string, DecisionCode>> = {
+	"Current Board revision needs maintainer approval": "approval-required",
+	"Delivered revision differs from reviewed head": "delivery-head-mismatch",
+	"Delivery requires the adopted GitHub PR URL": "delivery-pr-required",
+	"GitHub checks need a GitHub pull request URL and an exact commit SHA": "checks-result-invalid",
+	"incomplete-context": "incomplete-context",
+	"incomplete-observation": "incomplete-observation",
+	"Merged PR head differs from the reported head; inspect delivery before accepting this work": "worker-report-merged-head-mismatch",
+	"Multiple Codex turns match one operation; retain reservation": "duplicate-turns",
+	"No-change validation is not configured in this Fleet host; inspect the worker session": "no-change-checks-unconfigured",
+	"not-ancestor": "not-ancestor",
+	"PR conflicts with main; inspect the conflict repair before retrying or releasing this work": "pr-conflicting",
+	"PR head differs from the reviewed head; review the current revision before accepting delivery": "pr-head-moved",
+	"PR head moved after the worker report": "worker-report-head-moved",
+	"Report worker published to GitHub": "report-published",
+	"Report worker returned empty output": "empty-report",
+	"Reported PR must belong to the host repository": "foreign-pr",
+	"Result identity changed during review": "result-identity-changed",
+	"Review lacks the adopted worker receipt": "worker-receipt-missing",
+	"Reviewed PR is ready to merge": "reviewed-pr-ready",
+	"relevant-change": "relevant-change",
+	"Work is no longer approved or is done or superseded": "approval-required",
+	"Worker report exceeds Board’s 256 KiB context limit, including metadata and receipt; request a shorter report before retrying.":
+		"report-too-large",
+	"Worker report needs one FLEET_HEAD line with the exact full head SHA immediately before the final PR line": "worker-report-head-invalid",
+	"Worker report needs one final FLEET_PR line containing a GitHub PR URL or none": "worker-report-pr-invalid",
+};
+const ObjectValue = Schema.Record(Schema.String, Schema.Unknown);
+
+function historicalCode(reason: string): DecisionCode {
+	if (Object.hasOwn(legacyCodes, reason)) {
+		return legacyCodes[reason] ?? "integration-failure";
+	}
+	if (/\bturn already active for thread\b.*\bactive-turn resubmission limit reached\b/iu.test(reason)) {
+		return "session-active-turn-exhausted";
+	}
+	if (reason.startsWith("Provider turn ")) {
+		return "worker-terminal";
+	}
+	return reason.startsWith("Reviewer turn ") ? "reviewer-terminal" : "integration-failure";
+}
+
+function backfillCycle(cycle: Readonly<Record<string, unknown>>) {
+	const decision = cycle.decision;
+	if (!Schema.is(ObjectValue)(decision) || decision.code !== undefined) {
+		return cycle;
+	}
+	const reason = typeof decision.reason === "string" ? decision.reason : "";
+	const code = decision.worker === undefined ? historicalCode(reason) : "worker-question";
+	return { ...cycle, decision: { ...decision, code } };
+}
+
+function backfillHistory(history: unknown) {
+	if (!Array.isArray(history)) {
+		return history;
+	}
+	const updated = history.map((entry: unknown) => (Schema.is(ObjectValue)(entry) ? backfillCycle(entry) : entry));
+	return updated.every((entry, index) => entry === history[index]) ? history : updated;
+}
+
+function readJson(value: string | null) {
+	return value === null ? Effect.succeed(undefined) : Schema.decodeUnknownEffect(Schema.fromJsonString(Schema.Unknown))(value);
+}
+
+function writeJson(value: unknown) {
+	return value === undefined ? null : JSON.stringify(value);
+}
+
+export const backfillDecisionCodes = Effect.fn("FleetStore.backfillDecisionCodes")(function* (namespace: string) {
+	const sql = yield* SqlClient.SqlClient;
+	const rows = yield* sql<{ readonly workId: string; readonly decision: string | null; readonly history: string | null }>`
+		select work_id as "workId", decision, history from ${sql(`${namespace}_records`)} order by work_id for update`;
+	for (const row of rows) {
+		const decision = yield* readJson(row.decision);
+		const history = yield* readJson(row.history);
+		const cycle = backfillCycle({ decision });
+		const updatedHistory = backfillHistory(history);
+		if (cycle.decision === decision && updatedHistory === history) {
+			continue;
+		}
+		yield* sql`update ${sql(`${namespace}_records`)} set version = version + 1,
+			decision = ${writeJson(cycle.decision)}, history = ${writeJson(updatedHistory)} where work_id = ${row.workId}`;
+	}
+});

package/src/storage/errors.ts

@@ -0,0 +1,23 @@
+import { Schema } from "effect";
+import type { SqlError } from "effect/sql/SqlError";
+export class StorageConflict extends Schema.TaggedError<StorageConflict>()("StorageConflict", {
+	actualVersion: Schema.NullOr(Schema.Number),
+	expectedVersion: Schema.NullOr(Schema.Number),
+	workId: Schema.String,
+}) {}
+
+export class StorageCapacity extends Schema.TaggedError<StorageCapacity>()("StorageCapacity", {
+	kind: Schema.Literals(["execution", "backlog"]),
+	limit: Schema.Number,
+}) {}
+
+export class StorageQuota extends Schema.TaggedError<StorageQuota>()("StorageQuota", {
+	available: Schema.Number,
+	observedAt: Schema.Number,
+	reason: Schema.Literals(["exhausted", "unconfigured"]),
+	submitted: Schema.optional(Schema.Number),
+}) {}
+
+export class StorageAdmission extends Schema.TaggedError<StorageAdmission>()("StorageAdmission", { message: Schema.String }) {}
+
+export type StorageError = StorageAdmission | SqlError | Schema.SchemaError | StorageConflict | StorageCapacity | StorageQuota;

package/src/storage/fleetMigrations.ts

@@ -0,0 +1,60 @@
+import { Effect } from "effect";
+import { Migrator, SqlClient } from "effect/sql";
+import { backfillDecisionCodes } from "#storage/backfillDecisionCodes.ts";
+import { modelTableColumns, modelTables } from "#storage/modelTables.ts";
+import { pruneEmptyCycles } from "#storage/pruneEmptyCycles.ts";
+import { recordTimeColumns } from "#storage/recordTimes.ts";
+
+const releaseReasonColumn = { kind: "string", name: "releaseReason" } as const;
+
+// PostgreSQL text cannot distinguish scalar strings from serialized JSON.
+export const fleetMigrationColumns = {
+	...modelTableColumns,
+	[releaseReasonColumn.name]: releaseReasonColumn.kind,
+	...recordTimeColumns,
+	integrationRetry: "json",
+	pendingAnswers: "json",
+} as const;
+
+export const fleetMigrations = Effect.fn("FleetStore.fleetMigrations")(function* (namespace: string, legacyOnly = false) {
+	const sql = yield* SqlClient.SqlClient;
+	return yield* Migrator.fromRecord({
+		"1_fleet_records": Effect.gen(function* () {
+			yield* sql`create table ${sql(`${namespace}_records`)} (work_id text primary key, version integer not null check (version > 0), payload jsonb not null)`;
+			yield* sql`create table ${sql(`${namespace}_foreign_reservations`)} (owner text primary key, paths jsonb not null, executing boolean not null, backlog boolean not null)`;
+		}),
+		"2_occupancy_only_foreign_reservations": sql`alter table ${sql(`${namespace}_foreign_reservations`)} drop column paths`,
+		"3_admission_order": sql`alter table ${sql(`${namespace}_records`)} add column admission_order bigint generated always as identity`,
+		"4_attention_owner": sql`update ${sql(`${namespace}_records`)} set version = version + 1,
+				payload = case
+					when payload->>'stage' = 'needs-human' and payload->'decision' is not null
+						and (payload->'decision'->>'attentionOwner' is null or payload->'decision'->'published' is not null or payload->'decision'->>'reason' = 'Reviewed PR is ready to merge')
+					then jsonb_set(jsonb_set(payload, '{attentionOwner}', '"maintainer"'::jsonb), '{decision,attentionOwner}', '"maintainer"'::jsonb)
+					else jsonb_set(payload, '{attentionOwner}',
+						case when (payload->>'stage' = 'validating' and payload->'checks'->>'pending' = 'true')
+							or payload->'launchRetry' is not null
+							or payload->>'blocker' = 'Fresh available provider quota is required'
+							or payload->>'blocker' ~ '^(execution|backlog) capacity is occupied'
+							or payload->>'blocker' like 'waiting for area %'
+						then '"automation"'::jsonb else '"orchestrator"'::jsonb end)
+					end
+				where payload->>'attentionOwner' is null and
+					(payload->>'stage' = 'needs-human' or payload->>'blocker' is not null or payload->'launchRetry' is not null or
+					(payload->>'stage' = 'validating' and payload->'checks'->>'pending' = 'true'))`,
+		...(legacyOnly
+			? {}
+			: {
+					"5_model_tables": modelTables(namespace),
+					"6_decision_codes": backfillDecisionCodes(namespace),
+					"7_release_reason": sql`alter table ${sql(`${namespace}_records`)} add column if not exists ${sql(releaseReasonColumn.name)} text`,
+					"8_record_times": Effect.gen(function* () {
+						for (const name of Object.keys(recordTimeColumns)) {
+							yield* sql`alter table ${sql(`${namespace}_records`)} add column ${sql(name)} double precision`;
+						}
+					}),
+					"9_integration_retry": sql`alter table ${sql(`${namespace}_records`)} add column ${sql("integrationRetry")} text`,
+					"10_prune_empty_cycles": pruneEmptyCycles(namespace),
+					"11_pending_answers": sql`alter table ${sql(`${namespace}_records`)} add column ${sql("pendingAnswers")} text`,
+				}),
+	});
+});

package/src/storage/makeFleetTransaction.ts

@@ -0,0 +1,16 @@
+import { Effect } from "effect";
+import * as Reactivity from "effect/reactivity/Reactivity";
+import { SqlClient } from "effect/sql";
+import { invalidationKeys, type Key } from "@shivaedev/effect-contract/keys.ts";
+import { invalidateOnCommit, transact } from "@shivaedev/effect-sql/transact.ts";
+
+export const makeFleetTransaction = Effect.gen(function* () {
+	const sql = yield* SqlClient.SqlClient;
+	const current = yield* Effect.serviceOption(Reactivity.Reactivity);
+	const reactivity = current._tag === "Some" ? current.value : yield* Reactivity.make;
+	return <A, E, R>(keys: readonly Key[], body: Effect.Effect<A, E, R>) =>
+		transact(
+			Effect.tap(body, () => invalidateOnCommit(invalidationKeys(keys))),
+			{ onSqlError: (error) => error },
+		).pipe(Effect.provideService(SqlClient.SqlClient, sql), Effect.provideService(Reactivity.Reactivity, reactivity));
+});

package/src/storage/makePostgresFleetStore.ts

@@ -0,0 +1,147 @@
+import { Effect, Array as EffectArray, Schema } from "effect";
+import { SqlClient } from "effect/sql";
+import { makeRepository } from "@shivaedev/effect-sql/repository.ts";
+import { fleetRecords } from "#fleetRecords.ts";
+import { checkRecordAdmission } from "#storage/admission.ts";
+import { admissionReads } from "#storage/admissionReads.ts";
+import { StorageConflict } from "#storage/errors.ts";
+import type { FleetStoreOptions } from "#storage/FleetStoreOptions.ts";
+import { makeFleetTransaction } from "#storage/makeFleetTransaction.ts";
+import { migrateFleet } from "#storage/migrateFleet.ts";
+import { type AdmissionLimits, ForeignReservationRow, recordColumns, recordInput, recordModel, type Versioned } from "#storage/model.ts";
+import { nextAdmissionOrder } from "#storage/nextAdmissionOrder.ts";
+import { operationEntries } from "#storage/operationEntries.ts";
+import { withRecordTimes } from "#storage/recordTimes.ts";
+import { recordValue, recordValues } from "#storage/recordValue.ts";
+
+export const makePostgresFleetStore = Effect.fn("FleetStore.makePostgresFleetStore")(function* <
+	TSchema extends Schema.Top & {
+		readonly Type: { readonly workId: string };
+		readonly DecodingServices: never;
+		readonly EncodingServices: never;
+	},
+>(schema: TSchema, options: FleetStoreOptions<TSchema["Type"]>) {
+	const sql = yield* SqlClient.SqlClient;
+	const namespace = options.namespace ?? "work_fleet";
+	const commit = yield* makeFleetTransaction;
+	const records = `${namespace}_records`;
+	const foreign = `${namespace}_foreign_reservations`;
+	const columns = recordColumns(schema);
+	const model = recordModel(schema);
+	const rows = yield* makeRepository(model, { idColumn: "work_id", spanPrefix: "FleetRow", tableName: records, versionColumn: "version" });
+	const reservations = yield* makeRepository(ForeignReservationRow, { idColumn: "owner", spanPrefix: "FleetForeign", tableName: foreign });
+	const encodeRecord = Schema.encodeEffect(schema);
+	const decodeObject = Schema.decodeUnknownEffect(Schema.Record(Schema.String, Schema.Unknown));
+	const decodeInsert = Schema.decodeUnknownEffect(model.insert);
+	const decodeRecord = Schema.decodeUnknownEffect(schema);
+	const decodeRecords = Schema.decodeUnknownEffect(Schema.Array(schema));
+	function decode(row: { readonly "work_id": string; readonly version: number }) {
+		return recordValue(row, columns).pipe(
+			Effect.flatMap(decodeRecord),
+			Effect.map((value) => ({ value, version: row.version + 1 })),
+		);
+	}
+	const loadEntry = Effect.fn("FleetStore.loadEntry")(function* (workId: string) {
+		const found = yield* rows.findById(workId).pipe(Effect.catchTag("NoSuchElementError", () => Effect.succeed(undefined)));
+		return found === undefined ? undefined : { order: found.admission_order, stored: yield* decode(found) };
+	});
+	function load(workId: string) {
+		return loadEntry(workId).pipe(Effect.map((entry) => entry?.stored));
+	}
+	const list = Effect.fn("FleetStore.list")(function* () {
+		const found = yield* rows.findMany({ orderBy: { direction: "asc", field: "admission_order" } });
+		const values = yield* decodeRecords(yield* recordValues(found, columns));
+		return EffectArray.zipWith(values, found, (value, row) => ({ value, version: row.version + 1 }));
+	});
+	function foreignReservations() {
+		return reservations.findMany({ orderBy: { direction: "asc", field: "owner" } });
+	}
+	const lock = sql`select pg_advisory_xact_lock(hashtextextended(${`work_fleet_admission:${namespace}`}, 0))`.pipe(Effect.asVoid);
+	const persist = Effect.fn("FleetStore.persist")(function* (
+		workId: string,
+		expectedVersion: number | null,
+		record: TSchema["Type"],
+		encoded: object,
+		entry: { readonly order: bigint; readonly stored: Versioned<TSchema["Type"]> } | undefined,
+	) {
+		const requeue = entry !== undefined && options.requeue?.(record, entry.stored.value) === true;
+		const input = yield* decodeInsert({ ...recordInput(encoded, columns), "work_id": workId });
+		if (entry === undefined) {
+			yield* rows.insertVoid(input);
+		} else {
+			const order = requeue ? yield* nextAdmissionOrder(sql, records) : entry.order;
+			yield* rows.updateVoid({ ...input, "admission_order": order, version: expectedVersion === null ? 0 : expectedVersion - 1 });
+		}
+		return { value: record, version: (expectedVersion ?? 0) + 1 };
+	});
+	const write = Effect.fn("FleetStore.write")(function* (
+		workId: string,
+		expectedVersion: number | null,
+		record: TSchema["Type"],
+		limits: AdmissionLimits = {},
+	) {
+		const encoded = yield* decodeObject(yield* encodeRecord(record));
+		if (record.workId !== workId) {
+			return yield* Effect.fail(new StorageConflict({ actualVersion: null, expectedVersion, workId }));
+		}
+		return yield* commit(
+			[fleetRecords.item(workId), fleetRecords.list],
+			Effect.gen(function* () {
+				yield* lock;
+				const entry = yield* loadEntry(workId);
+				const previous = entry?.stored;
+				const actualVersion = previous?.version ?? null;
+				if (actualVersion !== expectedVersion) {
+					return yield* Effect.fail(new StorageConflict({ actualVersion, expectedVersion, workId }));
+				}
+				const reads = admissionReads(options, record, previous?.value, limits);
+				const entries = reads.records ? yield* list() : [];
+				const external = reads.foreign ? yield* foreignReservations() : [];
+				yield* checkRecordAdmission(options, record, previous?.value, entries, external, limits);
+				const timed = yield* withRecordTimes(schema, encoded, previous?.value);
+				return yield* persist(workId, expectedVersion, timed.value, timed.encoded, entry);
+			}),
+		).pipe(
+			Effect.catchTag("OptimisticConcurrencyError", () =>
+				Effect.flatMap(load(workId), (actual) =>
+					Effect.fail(new StorageConflict({ actualVersion: actual?.version ?? null, expectedVersion, workId })),
+				),
+			),
+		);
+	});
+	return {
+		compareAndSet: (workId: string, expectedVersion: number, record: TSchema["Type"], limits?: AdmissionLimits) =>
+			write(workId, expectedVersion, record, limits),
+		foreignReservations,
+		hasLaunchRetry: () => rows.findMany({ select: ["launchRetry"] }).pipe(Effect.map((entries) => entries.some((row) => row.launchRetry !== null))),
+		initialize: () => commit([fleetRecords.list], migrateFleet(namespace)),
+		insert: (record: TSchema["Type"], limits?: AdmissionLimits) => write(record.workId, null, record, limits),
+		list,
+		load,
+		operationEntries: (operationId: string) =>
+			rows
+				.findMany({ select: ["work_id", "version", "attempts", "history"] })
+				.pipe(Effect.flatMap((entries) => operationEntries(entries, operationId))),
+		releaseForeign: (owner: string) =>
+			commit(
+				[fleetRecords.list],
+				Effect.gen(function* () {
+					yield* lock;
+					yield* reservations.delete(owner);
+				}),
+			),
+		reserveForeign: (owner: string, occupancy: { readonly executing: boolean; readonly backlog: boolean } = { backlog: true, executing: true }) =>
+			commit(
+				[fleetRecords.list],
+				Effect.gen(function* () {
+					yield* lock;
+					const existing = yield* reservations.findMany({ where: { owner } });
+					if (existing.length === 0) {
+						yield* reservations.insertVoid({ owner, ...occupancy });
+					} else {
+						yield* reservations.updateVoid({ owner, ...occupancy });
+					}
+				}),
+			),
+	};
+});

package/src/storage/migrateFleet.ts

@@ -0,0 +1,11 @@
+import { Effect } from "effect";
+import { migratePostgres } from "@shivaedev/effect-sql/migrations.ts";
+import { fleetMigrations } from "#storage/fleetMigrations.ts";
+
+export const migrateFleet = Effect.fn("FleetStore.migrateFleet")(function* (namespace: string, legacyOnly = false) {
+	return yield* migratePostgres({
+		loader: fleetMigrations(namespace, legacyOnly),
+		lockTimeout: "5 seconds",
+		table: `${namespace}_migrations`,
+	});
+});

package/src/storage/model.ts

@@ -0,0 +1,115 @@
+import { Effect, Schema, SchemaAST } from "effect";
+import { Model } from "effect/schema";
+import { FleetRecord } from "#model.ts";
+import { recordValue } from "#storage/recordValue.ts";
+export interface Versioned<A> {
+	readonly value: A;
+	readonly version: number;
+}
+
+export interface AdmissionLimits {
+	readonly maxBacklog?: number;
+	readonly maxExecuting?: number;
+	readonly quota?: { readonly observedAt: number; readonly available: number };
+	readonly scheduling?: { readonly now: number; readonly areaMergeWaitMs: number };
+}
+
+function scalarKind(ast: SchemaAST.AST): "string" | "number" | "boolean" | "json" {
+	if (SchemaAST.isString(ast)) {
+		return "string";
+	}
+	if (SchemaAST.isNumber(ast)) {
+		return "number";
+	}
+	if (SchemaAST.isBoolean(ast)) {
+		return "boolean";
+	}
+	if (SchemaAST.isLiteral(ast)) {
+		if (typeof ast.literal === "string") {
+			return "string";
+		}
+		if (typeof ast.literal === "number") {
+			return "number";
+		}
+		if (typeof ast.literal === "boolean") {
+			return "boolean";
+		}
+	}
+	if (SchemaAST.isUnion(ast)) {
+		const kinds = new Set(ast.types.filter((type) => !SchemaAST.isUndefined(type)).map(scalarKind));
+		if (kinds.size === 1) {
+			return [...kinds][0] ?? "json";
+		}
+	}
+	return "json";
+}
+
+export function recordColumns(schema: Schema.Top = FleetRecord) {
+	const ast = SchemaAST.toEncoded(schema.ast);
+	const base = SchemaAST.toEncoded(FleetRecord.ast);
+	const properties = [...(SchemaAST.isObjects(base) ? base.propertySignatures : []), ...(SchemaAST.isObjects(ast) ? ast.propertySignatures : [])];
+	return Object.fromEntries(properties.filter((field) => field.name !== "workId").map((field) => [String(field.name), scalarKind(field.type)]));
+}
+
+function columnSchema(kind: string) {
+	if (kind === "number") {
+		return Schema.Number;
+	}
+	if (kind === "boolean") {
+		return Schema.Boolean;
+	}
+	return Schema.String;
+}
+
+const rowFields = {
+	"admission_order": Model.Field({ select: Schema.BigInt, update: Schema.BigInt }),
+	attempts: Schema.NullOr(Schema.String),
+	attentionOwner: Schema.NullOr(Schema.String),
+	blocker: Schema.NullOr(Schema.String),
+	checks: Schema.NullOr(Schema.String),
+	decision: Schema.NullOr(Schema.String),
+	history: Schema.NullOr(Schema.String),
+	launchRetry: Schema.NullOr(Schema.String),
+	outcome: Schema.NullOr(Schema.String),
+	stage: Schema.NullOr(Schema.String),
+	version: Model.Field({ select: Schema.Number, update: Schema.Number }),
+	"work_id": Schema.String,
+};
+class FleetRow extends Model.Class<FleetRow>("FleetRow")(rowFields) {}
+
+export function recordModel(schema: Schema.Top = FleetRecord): typeof FleetRow {
+	const fields = Object.fromEntries(Object.entries(recordColumns(schema)).map(([name, kind]) => [name, Schema.NullOr(columnSchema(kind))]));
+	// Explicit summary fields retain typed projections while the remaining fields come from the record schema.
+	class RecordRow extends Model.Class<RecordRow>("FleetRow")({ ...rowFields, ...fields }) {}
+	return RecordRow;
+}
+
+export const ForeignReservation = Schema.Struct({
+	backlog: Schema.Boolean,
+	executing: Schema.Boolean,
+	owner: Schema.String,
+});
+export type ForeignReservation = typeof ForeignReservation.Type;
+
+export class ForeignReservationRow extends Model.Class<ForeignReservationRow>("ForeignReservationRow")(ForeignReservation.fields) {}
+
+export function recordInput(value: string | object, columns: ReturnType<typeof recordColumns>) {
+	const encoded: Record<string, unknown> = typeof value === "string" ? JSON.parse(value) : { ...value };
+	return Object.fromEntries(
+		Object.entries(columns).map(([name, kind]) => {
+			if (encoded[name] === undefined) {
+				return [name, null];
+			}
+			return [name, kind === "json" ? JSON.stringify(encoded[name]) : encoded[name]];
+		}),
+	);
+}
+
+export function recordJson(row: object, columns: ReturnType<typeof recordColumns>) {
+	return recordValue(row, columns).pipe(Effect.map(JSON.stringify));
+}
+
+export interface StoredRow {
+	readonly value: string;
+	readonly version: number;
+}

package/src/storage/modelTables.ts

@@ -0,0 +1,57 @@
+import { Effect } from "effect";
+import { SqlClient } from "effect/sql";
+
+// Migration 5 is historical; future record fields belong in new numbered migrations.
+export const modelTableColumns = {
+	admissionReady: "boolean",
+	areas: "json",
+	attempts: "json",
+	attentionOwner: "string",
+	blocker: "string",
+	boardContext: "string",
+	boardRevision: "string",
+	boardSourcePath: "string",
+	checks: "json",
+	conflictRepairs: "json",
+	cwd: "string",
+	decision: "json",
+	decisionAcknowledged: "boolean",
+	decisionPublished: "boolean",
+	deliverable: "string",
+	history: "json",
+	launch: "json",
+	launchRetry: "json",
+	mergeAreasReleased: "boolean",
+	mergeReadyAt: "number",
+	mergeReadyHead: "string",
+	outcome: "json",
+	preparation: "json",
+	prompt: "string",
+	report: "json",
+	responses: "json",
+	result: "json",
+	resultObservations: "json",
+	review: "json",
+	stage: "string",
+	supersededDecisions: "json",
+} as const;
+
+export const modelTables = Effect.fn("FleetStore.modelTables")(function* (namespace: string) {
+	const sql = yield* SqlClient.SqlClient;
+	const table = `${namespace}_records`;
+	yield* sql`alter table ${sql(table)} alter column admission_order set generated by default`;
+	for (const [name, kind] of Object.entries(modelTableColumns)) {
+		const type = { boolean: "boolean", json: "text", number: "double precision", string: "text" }[kind];
+		yield* sql`alter table ${sql(table)} add column ${sql(name)} ${sql.literal(type)}`;
+		yield* sql`update ${sql(table)} set ${sql(name)} = ${kind === "json" ? sql`(payload->${name})::text` : sql`(payload->>${name})::${sql.literal(type)}`}`;
+	}
+	const checks = yield* sql<{
+		readonly conname: string;
+	}>`select c.conname from pg_constraint c join pg_attribute a on a.attrelid = c.conrelid and a.attnum = any(c.conkey) where c.conrelid = ${table}::regclass and c.contype = 'c' and a.attname = 'version'`;
+	for (const check of checks) {
+		yield* sql`alter table ${sql(table)} drop constraint ${sql(check.conname)}`;
+	}
+	yield* sql`update ${sql(table)} set version = version - 1`;
+	yield* sql`alter table ${sql(table)} add check (version >= 0)`;
+	yield* sql`alter table ${sql(table)} drop column payload`;
+});

package/src/storage/nextAdmissionOrder.ts

@@ -0,0 +1,8 @@
+import { Effect, Schema } from "effect";
+import type { SqlClient } from "effect/sql";
+
+// Requeueing needs the same database sequence as inserts; repositories cannot allocate sequence values.
+export const nextAdmissionOrder = Effect.fn("FleetStore.nextAdmissionOrder")(function* (sql: SqlClient.SqlClient, table: string) {
+	const rows = yield* sql`select nextval(pg_get_serial_sequence(${table}, 'admission_order')) as value`;
+	return yield* Schema.decodeUnknownEffect(Schema.Struct({ value: Schema.BigInt }))(rows[0]).pipe(Effect.map((row) => row.value));
+});

package/src/storage/operationEntries.ts

@@ -0,0 +1,24 @@
+import { Effect, Schema } from "effect";
+import { Attempt, FleetRecord } from "#model.ts";
+import { recordValues } from "#storage/recordValue.ts";
+
+const OperationAttempts = Schema.Array(Schema.Struct({ operationId: Attempt.fields.operationId }));
+const decode = Schema.decodeUnknownEffect(
+	Schema.Array(
+		Schema.Struct({
+			attempts: OperationAttempts,
+			history: Schema.optional(Schema.Array(Schema.Struct({ attempts: OperationAttempts }))),
+			version: Schema.Number,
+			workId: FleetRecord.fields.workId,
+		}),
+	),
+);
+
+export const operationEntries = Effect.fn("FleetRow.operationEntries")(function* (rows: readonly object[], operationId: string) {
+	const records = yield* decode(yield* recordValues(rows, { attempts: "json", history: "json", version: "number" }));
+	return records.flatMap((record) =>
+		[...(record.history ?? []).flatMap((cycle) => cycle.attempts), ...record.attempts]
+			.filter((attempt) => attempt.operationId === operationId)
+			.map(() => ({ version: record.version + 1, workId: record.workId })),
+	);
+});