@shivaedev/work-fleet 0.0.0 → 0.1.1

package/src/host/runtime.ts

@@ -0,0 +1,129 @@
+import * as NodeServices from "@effect/platform-node/NodeServices";
+import { Clock, Effect, Layer, Redacted } from "effect";
+import { defineService } from "@shivaedev/effect-service/define-service.ts";
+import { appDatabase } from "@shivaedev/platform/appHost.ts";
+import { ServiceUnavailable } from "@shivaedev/platform/errors/taxonomy.ts";
+import type { DecisionCode } from "#DecisionCode.ts";
+import { withFailureContext } from "#engine/failureContext.ts";
+import type { ReportInspection } from "#engine/ReportInspection.ts";
+import { fleetSessionJournal, postgresFleetRepository } from "#engine/repository.ts";
+import { Fleet } from "#fleet.ts";
+import { type FleetHost, HostFailure } from "#host/config.ts";
+import { githubChecks } from "#host/githubChecks.ts";
+import { githubDelivery } from "#host/githubDelivery.ts";
+import { githubResult } from "#host/githubResult.ts";
+import { hostGuidance } from "#host/guidance.ts";
+import { localOnlyBoardPath } from "#host/localOnlyBoardPath.ts";
+import { MainSource } from "#host/mainSource.ts";
+import { providerHealth } from "#host/providerHealth.ts";
+import { hostQuota } from "#host/quota.ts";
+import { hostReportBoard } from "#host/reportBoard.ts";
+import { type BoardGateway, FleetIntegrations, FleetPolicy } from "#policy.ts";
+import { SessionService, type SessionTransport } from "#session/service.ts";
+import { fleetMigrations } from "#storage/fleetMigrations.ts";
+
+function unconfigured(message: string, code: DecisionCode = "fleet-integration") {
+	return Effect.fail(withFailureContext(new ServiceUnavailable({ message }), { attentionOwner: "automation", code, retryable: false }));
+}
+
+export function hostIntegrations(host: FleetHost) {
+	const HostIntegrations = defineService({
+		id: "Fleet/HostIntegrations",
+		initialize: MainSource,
+		methods: (main) =>
+			FleetIntegrations.of({
+				checks: (_work, result) =>
+					result.kind === "no-change"
+						? unconfigured("No-change validation is not configured in this Fleet host; inspect the worker session", "no-change-checks-unconfigured")
+						: githubChecks(result, host.repository.branch).pipe(Effect.provide(NodeServices.layer)),
+				delivery: githubDelivery(main.repositoryRoot),
+				main: main.observe,
+				result:
+					host.result === "github"
+						? githubResult(host, main)
+						: () => unconfigured("Worker result adoption is not configured in this Fleet host; inspect the worker session"),
+			}),
+		requires: [MainSource],
+	});
+	return Layer.effect(FleetIntegrations)(HostIntegrations).pipe(Layer.provide(HostIntegrations.layer));
+}
+
+export function hostPolicy(host: FleetHost) {
+	return Layer.effect(FleetPolicy)(
+		Effect.gen(function* () {
+			const clock = yield* Clock.Clock;
+			const main = yield* MainSource;
+			const localPath = host.provider === "cloud" ? yield* localOnlyBoardPath(host.boardDir, main.repositoryRoot) : undefined;
+			const reviewerGuidance = yield* hostGuidance(host, "reviewer");
+			const workerGuidance = yield* hostGuidance(host, "worker");
+			function now() {
+				return clock.currentTimeMillisUnsafe();
+			}
+			return FleetPolicy.of({
+				areaMergeWaitMs: host.areaMergeWaitMs,
+				deliveryBacklog: host.backlog,
+				executionConcurrency: host.concurrency,
+				launch: host.launch,
+				...(localPath === undefined ? {} : { localOnlyBoardPath: localPath }),
+				now,
+				operationId: () => crypto.randomUUID(),
+				quota: { expiresAt: 0, observedAt: 0 },
+				readGuidance: (role) =>
+					(role === "worker" ? workerGuidance : reviewerGuidance).pipe(
+						Effect.mapError((error: HostFailure) => new ServiceUnavailable({ message: error.message })),
+					),
+				refreshQuota: hostQuota(host, now),
+				stallMinutes: host.stallMinutes,
+				...(host.worker === undefined ? {} : { sharedEnvironment: host.worker.sharedEnvironment }),
+			});
+		}),
+	);
+}
+
+export function hostSql(host: FleetHost) {
+	return appDatabase({
+		config: {
+			applicationName: "work-fleet",
+			changes: { channel: `${host.namespace}_changes` },
+			databaseUrl: Redacted.make(host.databaseUrl),
+			maxConnections: host.maxConnections,
+		},
+		migrations: { loader: fleetMigrations(host.namespace), table: `${host.namespace}_migrations` },
+	}).pipe(
+		Layer.provide(
+			Layer.effectDiscard(
+				Effect.gen(function* () {
+					if (host.maxConnections < 2) {
+						return yield* Effect.fail(
+							new HostFailure({ message: "Fleet database.maxConnections must be at least 2 for queries and the change listener" }),
+						);
+					}
+				}),
+			),
+		),
+	);
+}
+
+export function fleetHostLayer<TProvider, TMain>(
+	host: FleetHost,
+	parts: {
+		readonly board?: Layer.Layer<BoardGateway | ReportInspection, unknown, MainSource>;
+		readonly integrations?: Layer.Layer<FleetIntegrations, unknown, MainSource>;
+		readonly main: Layer.Layer<MainSource, TMain>;
+		readonly policy?: Layer.Layer<FleetPolicy>;
+		readonly provider: Layer.Layer<SessionTransport, TProvider>;
+	},
+) {
+	const repository = postgresFleetRepository(host.namespace);
+	const sessions = SessionService.layer.pipe(
+		Layer.provideMerge([fleetSessionJournal.pipe(Layer.provide(repository)), providerHealth.pipe(Layer.provide(parts.provider))]),
+	);
+	const board = (parts.board ?? hostReportBoard(host)).pipe(Layer.provide(parts.main), Layer.provide(NodeServices.layer));
+	const integrations = (parts.integrations ?? hostIntegrations(host)).pipe(Layer.provide(parts.main));
+	return Fleet.layer.pipe(
+		Layer.provideMerge(
+			Layer.mergeAll(repository, sessions, board, parts.policy ?? hostPolicy(host).pipe(Layer.provide(parts.main)), integrations, parts.main),
+		),
+		Layer.provideMerge(hostSql(host)),
+	);
+}

package/src/host/snapshotStream.ts

@@ -0,0 +1,21 @@
+import { Stream } from "effect";
+import type { FleetError } from "#errors.ts";
+import type { State } from "#host/waitOutcome.ts";
+
+type States = readonly (typeof State.Type)[];
+
+export function snapshotStream(snapshots: Stream.Stream<States, FleetError>, ids: readonly string[], continuous = false) {
+	return Stream.suspend(() => {
+		let selected = ids.length === 0 ? undefined : new Set(ids);
+		return snapshots.pipe(
+			Stream.map((states) => {
+				if (continuous && selected === undefined) {
+					return states;
+				}
+				selected ??= new Set(states.filter((state) => !["completed", "needs-human", "released"].includes(state.stage)).map((state) => state.workId));
+				const selection = selected;
+				return states.filter((state) => selection.has(state.workId));
+			}),
+		);
+	});
+}

package/src/host/status.ts

@@ -0,0 +1,16 @@
+import { Effect, Schema } from "effect";
+import { views } from "#engine/views.ts";
+import type { FleetHost } from "#host/config.ts";
+import { recordPayloads } from "#host/recordPayloads.ts";
+import { FleetRecord, type FleetViews } from "#model.ts";
+import { renderStatus as render } from "./renderStatus.ts";
+
+export function renderStatus(current: typeof FleetViews.Type) {
+	return render(current);
+}
+
+export const fleetStatus = Effect.fn("FleetHost.fleetStatus")(function* (host: FleetHost, workId?: string) {
+	const payloads = yield* recordPayloads(host.namespace, workId);
+	const records = yield* Effect.forEach(payloads, (payload) => Schema.decodeUnknownEffect(Schema.fromJsonString(FleetRecord))(payload));
+	return views(records);
+});

package/src/host/statusLayer.ts

@@ -0,0 +1,101 @@
+import { Clock, Console, Context, Effect, FileSystem, Layer, type Option, Ref, Semaphore } from "effect";
+import { defineService } from "@shivaedev/effect-service/define-service.ts";
+import type { FleetHealth } from "@shivaedev/work-board/integration/diagnostics.ts";
+import { diagnostics as diagnosticsApi } from "@shivaedev/work-board/integration/diagnostics.ts";
+import { publishAfterBoardPass } from "#board/readPass.ts";
+import { writeHealth } from "#board/writeHealth.ts";
+import { writeStatus } from "#board/writeStatus.ts";
+import { Health, HealthPublication, HealthSnapshot } from "#engine/health.ts";
+import { views } from "#engine/views.ts";
+import { Fleet } from "#fleet.ts";
+import { executing } from "#model.ts";
+
+const { SourceFailure } = diagnosticsApi;
+
+class StatusHealth extends Context.Service<StatusHealth, Option.Option<Health["Service"]>>()("Fleet/StatusHealth") {}
+
+export function statusLayer(root: string, healthConfig?: { readonly concurrency: number; readonly staleAfterMs: number }) {
+	const StatusPublication = defineService({
+		id: "Fleet/StatusPublication",
+		initialize: Effect.gen(function* () {
+			const fleet = yield* Fleet;
+			const health = yield* StatusHealth;
+			const fs = yield* FileSystem.FileSystem;
+			const realRoot = yield* fs.realPath(root);
+			const lock = yield* Semaphore.make(1);
+			const snapshot = yield* Ref.make<FleetHealth | null>(null);
+			const publish = Semaphore.withPermits(
+				lock,
+				1,
+			)(
+				Effect.gen(function* () {
+					const records = yield* fleet.list();
+					yield* writeStatus(
+						root,
+						realRoot,
+						records.map(({ value }) => value),
+					).pipe(Effect.catch((error) => Console.error(`work-fleet: status publication failed: ${error.message}`)));
+					if (healthConfig !== undefined) {
+						const state = health._tag === "Some" ? yield* Ref.get(health.value) : { lastCapacityRejection: null, lastSchedulerPass: null };
+						const nextHealth: FleetHealth = {
+							observedAt: yield* Clock.currentTimeMillis,
+							version: 2,
+							...healthConfig,
+							...state,
+							queued: records.filter(({ value }) => value.stage === "prepared").length,
+							running: records.filter(({ value }) => executing(value)).length,
+							waiting: waitingCounts(records.map(({ value }) => value)),
+						};
+						yield* Ref.set(snapshot, nextHealth);
+						yield* writeHealth(root, realRoot, nextHealth);
+					}
+				}),
+			).pipe(Effect.catch((error) => Console.error(`work-fleet: publication failed: ${error.message}`)));
+			if (healthConfig !== undefined) {
+				yield* publish;
+			}
+			return { fleet, publish, snapshot };
+		}),
+		methods: ({ fleet, publish, snapshot }) => {
+			function after<A, E, R>(effect: Effect.Effect<A, E, R>) {
+				return effect.pipe(Effect.ensuring(publishAfterBoardPass(publish)));
+			}
+			return {
+				...fleet,
+				continue: (workId: string, message: string) => after(fleet.continue(workId, message)),
+				dispatch: (...args: Parameters<typeof fleet.dispatch>) => after(fleet.dispatch(...args)),
+				list: () => after(fleet.list()),
+				prepare: (input: Parameters<typeof fleet.prepare>[0]) => after(fleet.prepare(input)),
+				publishDecision: (workId: string) => after(fleet.publishDecision(workId)),
+				publishHealth: () => publishAfterBoardPass(publish),
+				readHealth: () => readSnapshot(snapshot),
+				reassign: (...args: Parameters<typeof fleet.reassign>) => after(fleet.reassign(...args)),
+				reconcile: (workId: string) => after(fleet.reconcile(workId)),
+				resolve: (...args: Parameters<typeof fleet.resolve>) => after(fleet.resolve(...args)),
+			};
+		},
+		requires: [Fleet, FileSystem.FileSystem, StatusHealth],
+	});
+	return Layer.unwrap(
+		Effect.map(Effect.serviceOption(Health), (health) =>
+			Layer.unwrap(
+				Effect.map(StatusPublication, ({ readHealth, publishHealth, ...fleet }) =>
+					Layer.mergeAll(Layer.succeed(HealthSnapshot, readHealth()), Layer.succeed(HealthPublication, publishHealth()), Layer.succeed(Fleet, fleet)),
+				),
+			).pipe(Layer.provide(StatusPublication.layer.pipe(Layer.provide(Layer.succeed(StatusHealth, health))))),
+		),
+	);
+}
+
+function waitingCounts(records: Parameters<typeof views>[0]) {
+	const { waiting } = views(records);
+	return { automation: waiting.automation.length, maintainer: waiting.maintainer.length, orchestrator: waiting.orchestrator.length };
+}
+
+function readSnapshot(snapshot: Ref.Ref<FleetHealth | null>) {
+	return Ref.get(snapshot).pipe(
+		Effect.flatMap((value) =>
+			value === null ? Effect.fail(new SourceFailure({ kind: "error", message: "Fleet health has not been observed" })) : Effect.succeed(value),
+		),
+	);
+}

package/src/host/wait.ts

@@ -0,0 +1,38 @@
+import { Deferred, Effect, Stream } from "effect";
+import { waitingOwner } from "#attention.ts";
+import { type FollowOptions, follow } from "#host/follow.ts";
+import * as Outcome from "#host/waitOutcome.ts";
+
+export const WAIT_EXIT = Outcome.WAIT_EXIT;
+export const WaitState = Outcome.WaitState;
+export type WaitState = typeof WaitState.Type;
+export const settled = Outcome.settled;
+export type WaitOutcome = Outcome.WaitOutcome;
+
+export interface WaitOptions extends FollowOptions {
+	readonly workId: string;
+}
+
+export const waitFor = Effect.fn("FleetWait.waitFor")(function* (options: WaitOptions) {
+	const ready = yield* Deferred.make<void>();
+	let last = "not yet known to Fleet";
+	let outcome: WaitOutcome | undefined;
+	const consume = follow(options, [options.workId]).pipe(
+		Stream.tap(() => Deferred.succeed(ready, undefined)),
+		Stream.map((states) => states[0]),
+		Stream.tap((state) =>
+			Effect.sync(() => {
+				if (state !== undefined) {
+					last = `${state.stage}${waitingOwner(state) === undefined ? "" : ` (waiting on ${waitingOwner(state)})`}${state.blocker === undefined ? "" : `: ${state.blocker}`}`;
+					outcome = settled(options.workId, state);
+				}
+			}),
+		),
+		Stream.takeUntil(() => outcome !== undefined),
+		Stream.runDrain,
+	);
+	yield* options.timeoutMs === undefined
+		? consume
+		: Effect.raceFirst(consume, Deferred.await(ready).pipe(Effect.andThen(Effect.sleep(options.timeoutMs))));
+	return outcome ?? ({ code: WAIT_EXIT.timeout, summary: `${options.workId} still ${last}: wait timed out` } satisfies WaitOutcome);
+});

package/src/host/waitOutcome.ts

@@ -0,0 +1,47 @@
+import * as Schema from "effect/Schema";
+import { AttentionOwner, waitingOwner } from "#attention.ts";
+
+export const WAIT_EXIT = { completed: 0, error: 1, released: 3, timeout: 4, waitingDecision: 2 } as const;
+
+export interface WaitOutcome {
+	readonly code: (typeof WAIT_EXIT)[keyof typeof WAIT_EXIT];
+	readonly summary: string;
+}
+
+export const WaitState = Schema.Struct({
+	attentionOwner: Schema.optional(AttentionOwner),
+	blocker: Schema.optional(Schema.String),
+	checks: Schema.optional(Schema.Struct({ pending: Schema.optional(Schema.Boolean) })),
+	decision: Schema.optional(
+		Schema.Struct({
+			attentionOwner: Schema.optional(AttentionOwner),
+			code: Schema.optional(Schema.String),
+			id: Schema.optional(Schema.String),
+			reason: Schema.String,
+		}),
+	),
+	outcome: Schema.optional(Schema.Struct({ evidence: Schema.optional(Schema.Array(Schema.String)), url: Schema.optional(Schema.String) })),
+	stage: Schema.String,
+});
+export type WaitState = typeof WaitState.Type;
+
+export const State = Schema.Struct({ ...WaitState.fields, workId: Schema.String });
+
+export function settled(workId: string, state: WaitState): WaitOutcome | undefined {
+	const owner = waitingOwner(state);
+	const attention = owner === undefined ? "" : ` (waiting on ${owner})`;
+	if (state.stage === "completed") {
+		const outcome = state.outcome?.url ?? state.outcome?.evidence?.join("; ");
+		return { code: WAIT_EXIT.completed, summary: `${workId} completed${attention}${outcome ? `: ${outcome}` : ""}` };
+	}
+	if (state.stage === "needs-human") {
+		return {
+			code: WAIT_EXIT.waitingDecision,
+			summary: `${workId} needs-human${attention}: ${state.decision?.reason ?? state.blocker ?? "a Board decision is pending"}`,
+		};
+	}
+	if (state.stage === "released") {
+		return { code: WAIT_EXIT.released, summary: `${workId} released${attention}` };
+	}
+	return undefined;
+}

package/src/host/watch.ts

@@ -0,0 +1,68 @@
+import { Console, Deferred, Effect, Stream } from "effect";
+import { waitingOwner } from "#attention.ts";
+import { follow } from "#host/follow.ts";
+import { type FollowState, followOutcome, unrecognizedState } from "#host/followState.ts";
+import type { WaitOptions } from "#host/wait.ts";
+import { type State, settled, WAIT_EXIT } from "#host/waitOutcome.ts";
+
+export interface WatchOptions extends Omit<WaitOptions, "workId"> {
+	readonly workIds: readonly string[];
+}
+
+export const watchFor = Effect.fn("FleetWatch.watchFor")(function* (options: WatchOptions) {
+	const ready = yield* Deferred.make<void>();
+	let initialSnapshot = true;
+	let pending = options.workIds.length === 0 ? undefined : new Set(options.workIds);
+	const outcomeFor = options.follow
+		? transitionOutcome()
+		: (state: typeof State.Type) => {
+				const outcome = settled(state.workId, state);
+				return outcome !== undefined && pending?.delete(state.workId) ? outcome : undefined;
+			};
+	const order = ["maintainer", "orchestrator", "automation", undefined];
+	const consume = follow(options, options.workIds).pipe(
+		Stream.tap(() => Deferred.succeed(ready, undefined)),
+		Stream.tap((states) =>
+			Effect.gen(function* () {
+				pending ??= new Set(states.map((state) => state.workId));
+				for (const state of [...states].sort((left, right) => order.indexOf(waitingOwner(left)) - order.indexOf(waitingOwner(right)))) {
+					const outcome = outcomeFor(state);
+					if (outcome !== undefined && !(options.follow && initialSnapshot && state.stage !== "needs-human" && !unrecognizedState(state))) {
+						yield* Console.log(outcome.summary.replace(/[\r\n]+/gu, " "));
+					}
+				}
+				initialSnapshot = false;
+			}),
+		),
+		Stream.takeUntil(() => !options.follow && pending?.size === 0),
+		Stream.runDrain,
+	);
+	yield* options.timeoutMs === undefined
+		? consume
+		: Effect.raceFirst(consume, Deferred.await(ready).pipe(Effect.andThen(Effect.sleep(options.timeoutMs))));
+	if (!options.follow && pending?.size === 0) {
+		return WAIT_EXIT.completed;
+	}
+	yield* Console.error("watch: timed out waiting for Fleet work");
+	return WAIT_EXIT.timeout;
+});
+
+function transitionOutcome() {
+	const previous = new Map<string, string>();
+	return (state: FollowState) => {
+		const outcome = followOutcome(state);
+		if (outcome === undefined) {
+			previous.delete(state.workId);
+			return undefined;
+		}
+		const key =
+			state.stage === "needs-human"
+				? JSON.stringify([state.decision?.id, state.decision?.code, outcome.summary])
+				: JSON.stringify([state.stage, outcome.summary]);
+		if (previous.get(state.workId) === key) {
+			return undefined;
+		}
+		previous.set(state.workId, key);
+		return outcome;
+	};
+}

package/src/model.ts

@@ -0,0 +1,123 @@
+import { Schema } from "effect";
+import { diagnostics } from "@shivaedev/work-board/integration/diagnostics.ts";
+import { AttentionOwner } from "#attention.ts";
+import { BoardReport } from "#board/schema.ts";
+import { Checks, Decision, DecisionResponse, Delivery, Review, SupersededDecision, WorkResult } from "#policy.ts";
+import { Preparation } from "#preparation/schema.ts";
+import { LaunchSettings, SessionReceipt } from "#session/schema.ts";
+export const Attempt = Schema.Struct({
+	checkFailures: Schema.optional(Schema.Array(Schema.String)),
+	missingSince: Schema.optional(Schema.Number),
+	observationRetries: Schema.optional(Schema.Number),
+	operationId: Schema.String,
+	output: Schema.optional(Schema.String),
+	progress: Schema.optional(Schema.Struct({ at: Schema.Number, signature: Schema.String })),
+	prompt: Schema.optional(Schema.String),
+	providerFailures: Schema.optional(Schema.Number),
+	readRetry: Schema.optional(Schema.Struct({ error: Schema.String, failures: Schema.Number, retryAt: Schema.Number })),
+	receipt: Schema.optional(SessionReceipt),
+	reviewHead: Schema.optional(Schema.String),
+	reviewRevision: Schema.optional(Schema.String),
+	role: Schema.Literals(["worker", "repair", "reviewer"]),
+	sessionCleanupComplete: Schema.optional(Schema.Boolean),
+	sessionId: Schema.optional(Schema.String),
+	sessionUnusable: Schema.optional(Schema.Boolean),
+	settings: Schema.optional(LaunchSettings),
+	stallRecovery: Schema.optional(
+		Schema.Struct({
+			count: Schema.Number,
+			interruptedAt: Schema.optional(Schema.Number),
+			interruptRequestedAt: Schema.optional(Schema.Number),
+			lastActionAt: Schema.Number,
+			steeredAt: Schema.optional(Schema.Number),
+		}),
+	),
+	status: Schema.Literals(["submitting", "accepted", "running", "completed", "failed", "interrupted"]),
+	submissionTimedOut: Schema.optional(Schema.Boolean),
+	submissionUncertain: Schema.optional(Schema.Boolean),
+	submittedAt: Schema.Number,
+	terminalReceipts: Schema.optional(Schema.Array(SessionReceipt)),
+});
+export type Attempt = typeof Attempt.Type;
+const cycleFields = {
+	admissionReady: Schema.optional(Schema.Boolean),
+	areas: Schema.optional(Schema.Array(Schema.String)),
+	attempts: Schema.Array(Attempt),
+	attentionOwner: Schema.optional(AttentionOwner),
+	blocker: Schema.optional(Schema.String),
+	boardContext: Schema.optional(Schema.String),
+	boardRevision: Schema.String,
+	boardSourcePath: Schema.optional(Schema.String),
+	checks: Schema.optional(Checks),
+	completedAt: Schema.optional(diagnostics.FleetTimestamp),
+	conflictRepairs: Schema.optional(Schema.Array(Schema.String)),
+	cwd: Schema.String,
+	decision: Schema.optional(Decision),
+	decisionAcknowledged: Schema.optional(Schema.Boolean),
+	decisionPublished: Schema.optional(Schema.Boolean),
+	deliverable: Schema.optional(Schema.Literal("report")),
+	integrationRetry: Schema.optional(Schema.Struct({ error: Schema.String, failures: Schema.Number, retryAt: Schema.Number })),
+	launch: Schema.optional(LaunchSettings),
+	launchRetry: Schema.optional(
+		Schema.Struct({ prompt: Schema.optional(Schema.String), rejectedAt: Schema.Number, rejections: Schema.Number, retryAt: Schema.Number }),
+	),
+	mergeAreasReleased: Schema.optional(Schema.Boolean),
+	mergeReadyAt: Schema.optional(Schema.Number),
+	mergeReadyHead: Schema.optional(Schema.String),
+	outcome: Schema.optional(Schema.Union([Delivery, Schema.Struct({ evidence: Schema.Array(Schema.String) })])),
+	pendingAnswers: Schema.optional(Schema.Array(Schema.String)),
+	preparation: Preparation,
+	prompt: Schema.String,
+	releaseReason: Schema.optional(Schema.String),
+	report: Schema.optional(BoardReport),
+	responses: Schema.optional(Schema.Array(DecisionResponse)),
+	result: Schema.optional(WorkResult),
+	resultObservations: Schema.optional(Schema.Array(WorkResult)),
+	review: Schema.optional(Review),
+	stage: diagnostics.FleetStage,
+	stageEnteredAt: Schema.optional(diagnostics.FleetTimestamp),
+	supersededDecisions: Schema.optional(Schema.Array(SupersededDecision)),
+	updatedAt: Schema.optional(diagnostics.FleetTimestamp),
+};
+export const FleetCycleSnapshot = Schema.Struct({ ...cycleFields, archivedAt: Schema.Number });
+export type FleetCycleSnapshot = typeof FleetCycleSnapshot.Type;
+export const FleetRecord = Schema.Struct({ ...cycleFields, history: Schema.optional(Schema.Array(FleetCycleSnapshot)), workId: Schema.String });
+export type FleetRecord = typeof FleetRecord.Type;
+export function executing(record: FleetRecord): boolean {
+	return record.attempts.some((attempt) => ["submitting", "accepted", "running"].includes(attempt.status));
+}
+export function backlog(record: FleetRecord): boolean {
+	return record.result?.kind === "change" && record.stage !== "completed" && record.stage !== "released";
+}
+export const FleetView = Schema.Struct({
+	attentionOwner: Schema.optional(AttentionOwner),
+	blocker: Schema.optional(Schema.String),
+	decision: Schema.optional(Decision),
+	decisionAcknowledged: Schema.optional(Schema.Boolean),
+	links: Schema.Array(Schema.String),
+	outcome: FleetRecord.fields.outcome,
+	sessions: Schema.Array(
+		Schema.Struct({
+			...SessionReceipt.fields,
+			interruptedAt: Schema.optional(Schema.Number),
+			interruptRequestedAt: Schema.optional(Schema.Number),
+			lastProgressAt: Schema.optional(Schema.Number),
+			steeredAt: Schema.optional(Schema.Number),
+		}),
+	),
+	stage: FleetRecord.fields.stage,
+	workId: Schema.String,
+});
+export const FleetViews = Schema.Struct({
+	active: Schema.Array(FleetView),
+	completed: Schema.Array(FleetView),
+	waiting: Schema.Struct({
+		automation: Schema.Array(FleetView),
+		maintainer: Schema.Array(FleetView),
+		orchestrator: Schema.Array(FleetView),
+	}),
+});
+
+export function allAttempts(record: FleetRecord): readonly Attempt[] {
+	return [...(record.history ?? []).flatMap((cycle) => cycle.attempts), ...record.attempts];
+}

package/src/operations.ts

@@ -0,0 +1,76 @@
+import { Effect, Schema } from "effect";
+import { contract } from "@shivaedev/effect-contract/contract.ts";
+import { command, query } from "@shivaedev/effect-contract/operation.ts";
+import { AttentionOwner } from "#attention.ts";
+import { views } from "#engine/views.ts";
+import { fleetRejections } from "#errors.ts";
+import { exposeFailure } from "#exposeFailure.ts";
+import { Fleet } from "#fleet.ts";
+import { fleetRecords as recordKeys } from "#fleetRecords.ts";
+import { FleetRecord, FleetViews } from "#model.ts";
+import { Preparation } from "#preparation/schema.ts";
+import { LaunchSettings } from "#session/schema.ts";
+export const fleetRecords = recordKeys;
+const rejections = fleetRejections;
+export const Prepare = command("prepare", {
+	invalidates: ({ workId }) => [fleetRecords.list, fleetRecords.item(workId)],
+	payload: { cwd: Schema.String, launch: Schema.optional(LaunchSettings), preparation: Preparation, prompt: Schema.String, workId: Schema.String },
+	rejections,
+	success: FleetRecord,
+});
+export const Dispatch = command("dispatch", {
+	invalidates: ({ workId }) => [fleetRecords.list, fleetRecords.item(workId)],
+	payload: { workId: Schema.String },
+	rejections,
+	success: FleetRecord,
+});
+export const Reconcile = command("reconcile", {
+	invalidates: ({ workId }) => [fleetRecords.list, fleetRecords.item(workId)],
+	payload: { workId: Schema.String },
+	rejections,
+	success: FleetRecord,
+});
+export const Continue = command("continue", {
+	invalidates: ({ workId }) => [fleetRecords.list, fleetRecords.item(workId)],
+	payload: { message: Schema.String, workId: Schema.String },
+	rejections,
+	success: FleetRecord,
+});
+export const Resolve = command("resolve", {
+	invalidates: ({ workId }) => [fleetRecords.list, fleetRecords.item(workId)],
+	payload: { decisionId: Schema.String, responseId: Schema.String, workId: Schema.String },
+	rejections,
+	success: FleetRecord,
+});
+export const Get = query("get", {
+	payload: { workId: Schema.String },
+	reads: ({ workId }) => [fleetRecords.item(workId)],
+	rejections,
+	success: FleetRecord,
+});
+export const Reassign = command("reassign", {
+	invalidates: ({ workId }) => [fleetRecords.list, fleetRecords.item(workId)],
+	payload: { attentionOwner: AttentionOwner, decisionId: Schema.String, workId: Schema.String },
+	rejections,
+	success: FleetRecord,
+});
+export const Views = query("views", { reads: () => [fleetRecords.list], rejections, success: FleetViews });
+export const FleetContract = contract("fleet", { commands: [Prepare, Dispatch, Continue, Reconcile, Resolve, Reassign], queries: [Views, Get] });
+
+export const fleetHandlers = FleetContract.toLayer(
+	Effect.gen(function* () {
+		const fleet = yield* Fleet;
+		return FleetContract.of({
+			"fleet.continue": ({ workId, message }) => exposeFailure(fleet.continue(workId, message).pipe(Effect.map(({ value }) => value))),
+			"fleet.dispatch": ({ workId }) => exposeFailure(fleet.dispatch(workId).pipe(Effect.map(({ value }) => value))),
+			"fleet.get": ({ workId }) => exposeFailure(fleet.get(workId).pipe(Effect.map(({ value }) => value))),
+			"fleet.prepare": (input) => exposeFailure(fleet.prepare(input).pipe(Effect.map(({ value }) => value))),
+			"fleet.reassign": ({ workId, decisionId, attentionOwner }) =>
+				exposeFailure(fleet.reassign(workId, decisionId, attentionOwner).pipe(Effect.map(({ value }) => value))),
+			"fleet.reconcile": ({ workId }) => exposeFailure(fleet.reconcile(workId).pipe(Effect.map(({ value }) => value))),
+			"fleet.resolve": ({ workId, decisionId, responseId }) =>
+				exposeFailure(fleet.resolve(workId, decisionId, responseId).pipe(Effect.map(({ value }) => value))),
+			"fleet.views": () => exposeFailure(fleet.list().pipe(Effect.map((records) => views(records.map(({ value }) => value))))),
+		});
+	}),
+);

package/src/packageInfo.ts

@@ -0,0 +1,3 @@
+export const NAME = "work-fleet";
+export const TITLE = "Work Fleet";
+export const VERSION = "0.1.1";