@shivaedev/work-fleet 0.2.1 → 0.3.0

package/src/host/renderStatus.ts

@@ -1,5 +1,6 @@
 import { diagnostics as diagnosticsApi } from "@shivaedev/work-board/integration/diagnostics.ts";
 import { sessionStatus } from "#engine/sessionStatus.ts";
+import { type DaemonStatus, renderConfig } from "#host/configSettings.ts";
 import type { FleetViews } from "#model.ts";
 
 const { DAEMON_PORT } = diagnosticsApi;
@@ -7,14 +8,14 @@ const { DAEMON_PORT } = diagnosticsApi;
 type View = (typeof FleetViews.Type)["active"][number];
 
 function line(view: View, waiting: boolean, port: number) {
-	const reason = view.decision?.reason ?? view.blocker;
+	const reason = view.blocker ?? view.decision?.reason ?? (view.overLimit ? "launched over the limit" : undefined);
 	const detail = reason === undefined ? "" : `  ${reason}`;
 	const links = [...view.links, ...view.sessions.map(sessionStatus)];
 	const answer = waiting ? `\n    work-fleet answer ${view.workId}${port === DAEMON_PORT ? "" : ` --port ${port}`}` : "";
 	return `  ${view.workId}  ${view.stage}${detail}${links.length === 0 ? "" : `  (${links.join(", ")})`}${answer}`;
 }
 
-export function renderStatus(current: typeof FleetViews.Type, port: number = DAEMON_PORT): string {
+export function renderStatus(current: typeof DaemonStatus.Type, port: number = DAEMON_PORT): string {
 	const sections: readonly [string, readonly View[]][] = [
 		["Active", current.active],
 		["Waiting on maintainer", current.waiting.maintainer],
@@ -22,7 +23,7 @@ export function renderStatus(current: typeof FleetViews.Type, port: number = DAE
 		["Waiting on automation", current.waiting.automation],
 		["Completed", current.completed],
 	];
-	return sections
+	const rendered = sections
 		.map(([title, items]) =>
 			[
 				`${title} (${items.length})`,
@@ -30,4 +31,10 @@ export function renderStatus(current: typeof FleetViews.Type, port: number = DAE
 			].join("\n"),
 		)
 		.join("\n");
+	const dispatches = current.dispatches ?? [];
+	const views =
+		dispatches.length === 0
+			? rendered
+			: `${rendered}\nDispatches (${dispatches.length})\n${dispatches.map((request) => `  ${request.workId}  dispatch ${request.status}${request.error === undefined ? "" : `: ${request.error}`}`).join("\n")}`;
+	return current.config === undefined ? views : `${views}\n${renderConfig(current.config)}`;
 }

package/src/host/reportBoard.ts

@@ -1,7 +1,7 @@
 import * as NodeServices from "@effect/platform-node/NodeServices";
 import { Context, Effect, Layer } from "effect";
 import { defineService } from "@shivaedev/effect-service/define-service.ts";
-import { BadRequest, ServiceUnavailable } from "@shivaedev/platform/errors/taxonomy.ts";
+import { BadRequest } from "@shivaedev/platform/errors/taxonomy.ts";
 import { markdownBoard } from "#board/markdown.ts";
 import { reportContent } from "#board/reportContent.ts";
 import { reportFiles } from "#board/reportFiles.ts";
@@ -12,6 +12,8 @@ import { withFailureContext } from "#engine/failureContext.ts";
 import { ReportInspection } from "#engine/ReportInspection.ts";
 import { isFleetError } from "#errors.ts";
 import type { FleetHost } from "#host/config.ts";
+import { GithubApi } from "#host/githubApi.ts";
+import { githubFailure } from "#host/githubRateLimit.ts";
 import { MainSource } from "#host/mainSource.ts";
 import { reportPublication, reportRepository } from "#host/reportPublication.ts";
 import { BoardFailure, BoardGateway, type BoardWork } from "#policy.ts";
@@ -57,7 +59,7 @@ const ReportBoard = defineService({
 		const { root, check, files } = yield* ReportInputs;
 		function inspect(work: BoardWork) {
 			return check(work).pipe(
-				Effect.mapError(() => new ServiceUnavailable({ message: "Report publication could not be checked on GitHub" })),
+				Effect.mapError(githubFailure("Report publication could not be checked on GitHub")),
 				Effect.flatMap((published) =>
 					published ? Effect.fail(withFailureContext(new BadRequest({ message: PUBLISHED_REPORT }), { code: "report-published" })) : Effect.void,
 				),
@@ -121,12 +123,13 @@ export function hostReportBoard(host: FleetHost) {
 	return Layer.unwrap(
 		Effect.gen(function* () {
 			const main = yield* MainSource;
+			const github = yield* GithubApi;
 			function check(work: BoardWork) {
 				return Effect.gen(function* () {
 					if (host.worker === undefined) {
 						return yield* Effect.fail(new BoardFailure({ message: "Report publication checks need worker.branchPrefix" }));
 					}
-					return yield* reportPublication(
+					return yield* reportPublication(github)(
 						yield* reportRepository(main.repositoryRoot, host.repository.remote),
 						`${host.worker.branchPrefix}${work.workId}`,
 					);

package/src/host/reportPublication.ts

@@ -1,6 +1,8 @@
 import { Effect, Schema } from "effect";
 import { ServiceUnavailable } from "@shivaedev/platform/errors/taxonomy.ts";
 import type { FleetError } from "#errors.ts";
+import type { GithubRead } from "#host/github.ts";
+import { githubFailure } from "#host/githubRateLimit.ts";
 import { readCommand } from "#host/readCommand.ts";
 
 const References = Schema.Array(Schema.Array(Schema.Struct({ ref: Schema.String })));
@@ -17,13 +19,13 @@ export function makeReportPublication<R>(read: (endpoint: string) => Effect.Effe
 			).pipe(Effect.flatMap(Schema.decodeUnknownEffect(Schema.fromJsonString(PullRequests))));
 			return refs.flat().some((ref) => ref.ref === `refs/heads/${branch}`) || prs.flat().length > 0;
 		},
-		Effect.mapError(() => new ServiceUnavailable({ message: "Report publication could not be checked on GitHub" })),
+		Effect.mapError(githubFailure("Report publication could not be checked on GitHub")),
 	);
 }
 
-export const reportPublication = makeReportPublication((endpoint) =>
-	readCommand("gh", ["api", "--method", "GET", "--paginate", "--slurp", endpoint]),
-);
+export function reportPublication(read: GithubRead) {
+	return makeReportPublication(read.pages);
+}
 
 export const reportRepository = Effect.fn("Fleet.reportRepository")(function* (cwd: string, remote: string) {
 	const url = (yield* readCommand("git", ["remote", "get-url", remote], cwd)).trim();

package/src/host/runtime.ts

@@ -1,81 +1,62 @@
 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 { type GithubApi, githubApiLayer } from "#host/githubApi.ts";
+import { hostIntegrations } from "#host/integrations.ts";
+import { type AppliedConfig, LiveConfig, staticConfig } from "#host/liveConfig.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 { type BoardGateway, type FleetConfiguration, type 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 live = yield* LiveConfig;
 			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 }),
-			});
+			// Each quota source caches its observation, so a reload reuses the source for an unchanged quota setting.
+			const quotas = new Map<FleetHost["quota"], ReturnType<typeof hostQuota>>();
+			function refreshQuota(applied: FleetHost) {
+				const known = quotas.get(applied.quota);
+				if (known !== undefined) {
+					return known;
+				}
+				const created = hostQuota(applied, now);
+				quotas.set(applied.quota, created);
+				return created;
+			}
+			function configuration({ guidance, host: applied }: AppliedConfig): FleetConfiguration {
+				return {
+					areaMergeWaitMs: applied.areaMergeWaitMs,
+					deliveryBacklog: applied.backlog,
+					executionConcurrency: applied.concurrency,
+					launch: applied.launch,
+					...(localPath === undefined ? {} : { localOnlyBoardPath: localPath }),
+					now,
+					...(applied.openPullRequests === undefined ? {} : { openPullRequests: applied.openPullRequests }),
+					operationId: () => crypto.randomUUID(),
+					quota: { expiresAt: 0, observedAt: 0 },
+					readGuidance: (role) => guidance[role].pipe(Effect.mapError((error) => new ServiceUnavailable({ message: error.message }))),
+					refreshQuota: refreshQuota(applied),
+					stallMinutes: applied.stallMinutes,
+					...(applied.worker === undefined ? {} : { sharedEnvironment: applied.worker.sharedEnvironment }),
+				};
+			}
+			return FleetPolicy.of({ ...configuration(yield* live.current), current: Effect.map(live.current, configuration) });
 		}),
 	);
 }
@@ -107,23 +88,34 @@ export function hostSql(host: FleetHost) {
 export function fleetHostLayer<TProvider, TMain>(
 	host: FleetHost,
 	parts: {
-		readonly board?: Layer.Layer<BoardGateway | ReportInspection, unknown, MainSource>;
-		readonly integrations?: Layer.Layer<FleetIntegrations, unknown, MainSource>;
+		readonly board?: Layer.Layer<BoardGateway | ReportInspection, unknown, MainSource | GithubApi>;
+		readonly github?: Layer.Layer<GithubApi>;
+		readonly integrations?: Layer.Layer<FleetIntegrations, unknown, MainSource | GithubApi>;
 		readonly main: Layer.Layer<MainSource, TMain>;
 		readonly policy?: Layer.Layer<FleetPolicy>;
 		readonly provider: Layer.Layer<SessionTransport, TProvider>;
 	},
+	config: Layer.Layer<LiveConfig, unknown> = staticConfig(host),
 ) {
 	const repository = postgresFleetRepository(host.namespace);
 	const sessions = SessionService.layer.pipe(
 		Layer.provideMerge([fleetSessionJournal.pipe(Layer.provide(repository)), providerHealth.pipe(Layer.provide(parts.provider))]),
 	);
+	const github = parts.github ?? githubApiLayer.pipe(Layer.provide(NodeServices.layer));
 	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.mergeAll(
+				repository,
+				sessions,
+				board,
+				parts.policy ?? hostPolicy(host).pipe(Layer.provide([parts.main, config])),
+				integrations,
+				parts.main,
+			),
 		),
+		Layer.provideMerge(github),
 		Layer.provideMerge(hostSql(host)),
 	);
 }

package/src/host/snapshotStream.ts

@@ -1,4 +1,5 @@
 import { Stream } from "effect";
+import { ANSWER_RECORDED } from "#attention.ts";
 import type { FleetError } from "#errors.ts";
 import type { State } from "#host/waitOutcome.ts";
 
@@ -12,7 +13,11 @@ export function snapshotStream(snapshots: Stream.Stream<States, FleetError>, ids
 				if (continuous && selected === undefined) {
 					return states;
 				}
-				selected ??= new Set(states.filter((state) => !["completed", "needs-human", "released"].includes(state.stage)).map((state) => state.workId));
+				selected ??= new Set(
+					states
+						.filter((state) => state.blocker === ANSWER_RECORDED || !["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

@@ -1,16 +1,33 @@
 import { Effect, Schema } from "effect";
+import { makeRepository } from "@shivaedev/effect-sql/repository.ts";
 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";
+import { renderStatus as render } from "#host/renderStatus.ts";
+import { FleetRecord } from "#model.ts";
+import { dispatchStore } from "#storage/dispatchStore.ts";
+import { recordModel } from "#storage/model.ts";
+import { readRecords } from "#storage/readRecords.ts";
+import { recordShape } from "#storage/recordShape.ts";
+import { recordValues } from "#storage/recordValue.ts";
 
-export function renderStatus(current: typeof FleetViews.Type) {
+export function renderStatus(current: Parameters<typeof render>[0]) {
 	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);
+	const repository = yield* makeRepository(recordModel(), {
+		idColumn: "work_id",
+		spanPrefix: "FleetReader",
+		tableName: `${host.namespace}_records`,
+	});
+	const records = yield* readRecords(
+		host.namespace,
+		Effect.gen(function* () {
+			const rows = yield* repository.findMany({ orderBy: { direction: "asc", field: "work_id" }, where: { "work_id": workId } });
+			return yield* Schema.decodeUnknownEffect(Schema.Array(FleetRecord))(yield* recordValues(rows, recordShape(), host.namespace));
+		}),
+	);
+	const requests = yield* (yield* dispatchStore(host.namespace)).list(workId);
+	const dispatches = requests.filter((request) => request.status !== "completed");
+	return dispatches.length === 0 ? views(records) : { ...views(records), dispatches };
 });

package/src/host/statusLayer.ts

@@ -8,18 +8,22 @@ 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 { GithubApi } from "#host/githubApi.ts";
+import type { GithubObservation } from "#host/githubRateLimit.ts";
 import { executing } from "#model.ts";
 
 const { SourceFailure } = diagnosticsApi;
 
 class StatusHealth extends Context.Service<StatusHealth, Option.Option<Health["Service"]>>()("Fleet/StatusHealth") {}
+class StatusGithub extends Context.Service<StatusGithub, Effect.Effect<readonly GithubObservation[]>>()("Fleet/StatusGithub") {}
 
-export function statusLayer(root: string, healthConfig?: { readonly concurrency: number; readonly staleAfterMs: number }) {
+export function statusLayer(root: string, healthConfig?: Effect.Effect<{ 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 github = yield* StatusGithub;
 			const fs = yield* FileSystem.FileSystem;
 			const realRoot = yield* fs.realPath(root);
 			const lock = yield* Semaphore.make(1);
@@ -37,10 +41,12 @@ export function statusLayer(root: string, healthConfig?: { readonly concurrency:
 					).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 observations = yield* github;
 						const nextHealth: FleetHealth = {
+							...(observations.length === 0 ? {} : { github: observations }),
 							observedAt: yield* Clock.currentTimeMillis,
 							version: 2,
-							...healthConfig,
+							...(yield* healthConfig),
 							...state,
 							queued: records.filter(({ value }) => value.stage === "prepared").length,
 							running: records.filter(({ value }) => executing(value)).length,
@@ -71,18 +77,28 @@ export function statusLayer(root: string, healthConfig?: { readonly concurrency:
 				readHealth: () => readSnapshot(snapshot),
 				reassign: (...args: Parameters<typeof fleet.reassign>) => after(fleet.reassign(...args)),
 				reconcile: (workId: string) => after(fleet.reconcile(workId)),
+				recordResponse: (...args: Parameters<typeof fleet.recordResponse>) => after(fleet.recordResponse(...args)),
 				resolve: (...args: Parameters<typeof fleet.resolve>) => after(fleet.resolve(...args)),
 			};
 		},
-		requires: [Fleet, FileSystem.FileSystem, StatusHealth],
+		requires: [Fleet, FileSystem.FileSystem, StatusHealth, StatusGithub],
 	});
 	return Layer.unwrap(
-		Effect.map(Effect.serviceOption(Health), (health) =>
+		Effect.map(Effect.all([Effect.serviceOption(Health), Effect.serviceOption(GithubApi)]), ([health, github]) =>
 			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))))),
+			).pipe(
+				Layer.provide(
+					StatusPublication.layer.pipe(
+						Layer.provide([
+							Layer.succeed(StatusHealth, health),
+							Layer.succeed(StatusGithub, github._tag === "Some" ? github.value.observations() : Effect.succeed([])),
+						]),
+					),
+				),
+			),
 		),
 	);
 }

package/src/host/waitOutcome.ts

@@ -1,5 +1,5 @@
 import * as Schema from "effect/Schema";
-import { AttentionOwner, waitingOwner } from "#attention.ts";
+import { ANSWER_RECORDED, AttentionOwner, waitingOwner } from "#attention.ts";
 
 export const WAIT_EXIT = { completed: 0, error: 1, released: 3, timeout: 4, waitingDecision: 2 } as const;
 
@@ -28,6 +28,9 @@ 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 {
+	if (state.blocker === ANSWER_RECORDED) {
+		return undefined;
+	}
 	const owner = waitingOwner(state);
 	const attention = owner === undefined ? "" : ` (waiting on ${owner})`;
 	if (state.stage === "completed") {
@@ -37,7 +40,7 @@ export function settled(workId: string, state: WaitState): WaitOutcome | undefin
 	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"}`,
+			summary: `${workId} needs-human${attention}: ${state.blocker ?? state.decision?.reason ?? "a Board decision is pending"}`,
 		};
 	}
 	if (state.stage === "released") {

package/src/model.ts

@@ -2,6 +2,7 @@ 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 { DispatchRequest } from "#DispatchRequest.ts";
 import { Checks, Decision, DecisionResponse, Delivery, Review, SupersededDecision, WorkResult } from "#policy.ts";
 import { Preparation } from "#preparation/schema.ts";
 import { LaunchSettings, SessionObservation, SessionReceipt } from "#session/schema.ts";
@@ -29,6 +30,7 @@ export const Attempt = Schema.Struct({
 	observationRetries: Schema.optional(Schema.Number),
 	operationId: Schema.String,
 	output: Schema.optional(Schema.String),
+	overLimit: Schema.optional(Schema.Boolean),
 	progress: Schema.optional(Schema.Struct({ at: Schema.Number, signature: Schema.String })),
 	prompt: Schema.optional(Schema.String),
 	providerFailures: Schema.optional(Schema.Number),
@@ -74,6 +76,7 @@ const cycleFields = {
 	decisionAcknowledged: Schema.optional(Schema.Boolean),
 	decisionPublished: Schema.optional(Schema.Boolean),
 	deliverable: Schema.optional(Schema.Literal("report")),
+	dispatchNow: Schema.optional(Schema.Struct({ ignoreAreas: Schema.Boolean })),
 	integrationRetry: Schema.optional(Schema.Struct({ error: Schema.String, failures: Schema.Number, retryAt: Schema.Number })),
 	launch: Schema.optional(LaunchSettings),
 	launchRetry: Schema.optional(
@@ -101,6 +104,7 @@ export const FleetCycleSnapshot = Schema.Struct({ ...cycleFields, archivedAt: Sc
 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 type DispatchNow = NonNullable<FleetRecord["dispatchNow"]>;
 export function executing(record: FleetRecord): boolean {
 	return record.attempts.some((attempt) => ["submitting", "accepted", "running"].includes(attempt.status));
 }
@@ -114,6 +118,7 @@ export const FleetView = Schema.Struct({
 	decisionAcknowledged: Schema.optional(Schema.Boolean),
 	links: Schema.Array(Schema.String),
 	outcome: FleetRecord.fields.outcome,
+	overLimit: Schema.optional(Schema.Boolean),
 	sessions: Schema.Array(
 		Schema.Struct({
 			...SessionReceipt.fields,
@@ -130,6 +135,7 @@ export const FleetView = Schema.Struct({
 export const FleetViews = Schema.Struct({
 	active: Schema.Array(FleetView),
 	completed: Schema.Array(FleetView),
+	dispatches: Schema.optional(Schema.Array(DispatchRequest)),
 	waiting: Schema.Struct({
 		automation: Schema.Array(FleetView),
 		maintainer: Schema.Array(FleetView),

package/src/packageInfo.ts

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

package/src/policy.ts

@@ -12,13 +12,17 @@ import type { FleetError } from "#errors.ts";
 import type { MainObservation, Preparation } from "#preparation/schema.ts";
 import type { SessionObservation } from "#session/schema.ts";
 import { type LaunchSettings, SessionReceipt } from "#session/schema.ts";
+import type { OpenPullRequestCurve } from "#storage/model.ts";
 
+export const Priority = Schema.Literals(["urgent", "high", "normal"]);
+export type Priority = typeof Priority.Type;
 export const BoardWork = Schema.Struct({
 	approved: Schema.Boolean,
 	areas: Schema.optional(Schema.Array(Schema.String)),
 	context: Schema.String,
 	deliverable: Schema.optional(Schema.Literal("report")),
 	dependsOn: Schema.Array(Schema.String),
+	priority: Schema.optional(Priority),
 	revision: Schema.String,
 	sourcePath: Schema.String,
 	status: Schema.optional(Schema.String),
@@ -105,11 +109,14 @@ export const Delivery = Schema.Struct({ head: Schema.String, revision: Schema.St
 export type Delivery = typeof Delivery.Type;
 export interface FleetConfiguration {
 	readonly areaMergeWaitMs?: number;
+	// A host that reloads its settings serves the configuration each scheduler pass and launch should apply.
+	readonly current?: Effect.Effect<FleetConfiguration>;
 	readonly deliveryBacklog?: number;
 	readonly executionConcurrency?: number;
 	readonly launch?: LaunchSettings;
 	readonly localOnlyBoardPath?: string;
 	readonly now: () => number;
+	readonly openPullRequests?: OpenPullRequestCurve;
 	readonly operationId: () => string;
 	readonly quota: { readonly available?: number; readonly observedAt: number; readonly expiresAt: number };
 	readonly readGuidance?: (role: "worker" | "reviewer") => Effect.Effect<string | undefined, FleetError>;

package/src/providers/codexCloud.ts

@@ -15,6 +15,7 @@ export const CodexCloudConfiguration = Schema.Struct({
 	endpoint: Schema.optional(Schema.String),
 	environmentId: Schema.String.check(Schema.isNonEmpty()),
 	projectId: Schema.optional(Schema.String.check(Schema.isNonEmpty())),
+	recoveryGraceMs: Schema.Finite.check(Schema.isGreaterThan(0)),
 	refreshCommand: Schema.optional(Schema.Struct({ args: Schema.Array(Schema.String), command: Schema.String })),
 	requestTimeoutMs: Schema.Finite.check(Schema.isGreaterThan(0)),
 	threadNamePrefix: Schema.optional(Schema.String.check(Schema.isNonEmpty())),
@@ -86,7 +87,7 @@ const CodexCloud = defineService({
 		const adapter = codexAdapter(rpc, {
 			beforeTurn: verifyEnvironment,
 			provisioning: "unknown",
-			recoveryGraceMs: 5000,
+			recoveryGraceMs: config.recoveryGraceMs,
 			threadStart: (input) => threadStart(config, input),
 		});
 		return {

package/src/scheduling/admission.ts

@@ -0,0 +1,19 @@
+import { Effect } from "effect";
+import type { FleetRecord } from "#model.ts";
+import { checkAreas, needsAreaRecords } from "#scheduling/areas.ts";
+import { acquiresExecution, checkBackPressure } from "#scheduling/backPressure.ts";
+import type { AdmissionLimits } from "#storage/model.ts";
+
+export const checkLaunchAdmission = Effect.fn("Fleet.checkLaunchAdmission")(function* (
+	record: FleetRecord,
+	previous: FleetRecord | undefined,
+	records: readonly FleetRecord[],
+	limits: AdmissionLimits,
+) {
+	yield* checkAreas(record, previous, records, limits);
+	yield* checkBackPressure(record, previous, records, limits);
+});
+
+export function needsLaunchRecords(record: FleetRecord, previous: FleetRecord | undefined, limits: AdmissionLimits): boolean {
+	return needsAreaRecords(record, previous, limits) || (limits.implementers !== undefined && acquiresExecution(record, previous));
+}

package/src/scheduling/backPressure.ts

@@ -0,0 +1,55 @@
+import { Effect } from "effect";
+import { backlog, executing, type FleetRecord } from "#model.ts";
+import { StorageCapacity } from "#storage/errors.ts";
+import type { AdmissionLimits, OpenPullRequestCurve } from "#storage/model.ts";
+
+export function implementerLimit(concurrency: number, curve: OpenPullRequestCurve | undefined, open: number): number {
+	if (curve === undefined || (open <= curve.ease && open < curve.max)) {
+		return concurrency;
+	}
+	const floor = Math.min(curve.floor, concurrency);
+	if (open >= curve.max) {
+		return floor;
+	}
+	return floor + Math.floor(((concurrency - floor) * (curve.max - open)) / (curve.max - curve.ease));
+}
+
+// Reviews, repairs and answers for work that already has a session hold a slot ahead of new implementers while they wait to launch.
+function awaitsMergeWork(record: FleetRecord): boolean {
+	return (
+		!executing(record)
+		&& (["reviewing", "repairing"].includes(record.stage)
+			|| (!["prepared", "completed", "released"].includes(record.stage) && (record.pendingAnswers?.length ?? 0) > 0))
+	);
+}
+
+export function acquiresExecution(record: FleetRecord, previous: FleetRecord | undefined): boolean {
+	return executing(record) && (previous === undefined || !executing(previous));
+}
+
+export const checkBackPressure = Effect.fn("Fleet.checkBackPressure")(function* (
+	record: FleetRecord,
+	previous: FleetRecord | undefined,
+	records: readonly FleetRecord[],
+	limits: AdmissionLimits,
+) {
+	const implementers = limits.implementers;
+	if (implementers === undefined || !acquiresExecution(record, previous)) {
+		return;
+	}
+	const others = records.filter((entry) => entry.workId !== record.workId);
+	const running = others.filter(executing).length;
+	const waiting = others.filter(awaitsMergeWork).length;
+	const open = others.filter(backlog).length;
+	const curve = implementers.openPullRequests;
+	const limit = implementerLimit(implementers.concurrency, curve, open);
+	if (running + waiting < limit) {
+		return;
+	}
+	if (curve !== undefined && limit < implementers.concurrency) {
+		return yield* Effect.fail(new StorageCapacity({ kind: "open-pull-requests", limit: curve.max, occupied: open }));
+	}
+	if (running < implementers.concurrency) {
+		return yield* Effect.fail(new StorageCapacity({ kind: "merge-work", limit: implementers.concurrency, occupied: waiting }));
+	}
+});

package/src/storage/FleetStoreOptions.ts

@@ -1,9 +1,14 @@
 import type { Effect } from "effect";
-import type { StorageAdmission } from "#storage/errors.ts";
+import type { StorageAdmission, StorageCapacity } 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 admission?: (
+		record: A,
+		previous: A | undefined,
+		records: readonly A[],
+		limits: AdmissionLimits,
+	) => Effect.Effect<void, StorageAdmission | StorageCapacity>;
 	readonly admissionNeedsRecords?: (record: A, previous: A | undefined, limits: AdmissionLimits) => boolean;
 	readonly backlog?: (record: A) => boolean;
 	readonly executing?: (record: A) => boolean;

package/src/storage/addShapeColumns.ts

@@ -0,0 +1,24 @@
+import { Effect } from "effect";
+import { SqlClient } from "effect/sql";
+import { childTable } from "#storage/recordChildren.ts";
+import { collections, type Shape, shapeColumns, sqlTypes } from "#storage/recordShape.ts";
+
+export const addShapeColumns = Effect.fn("FleetStore.addShapeColumns")(function* (namespace: string, before: Shape, after: Shape) {
+	const sql = yield* SqlClient.SqlClient;
+	const existing = new Map(collections(before).map((collection) => [collection.path.join("."), shapeColumns(collection.shape)]));
+	const tables = [
+		{ columns: shapeColumns(after), existing: shapeColumns(before), table: `${namespace}_records` },
+		...collections(after).map((collection) => ({
+			columns: shapeColumns(collection.shape),
+			existing: existing.get(collection.path.join(".")) ?? {},
+			table: childTable(namespace, collection.path),
+		})),
+	];
+	for (const { columns, existing: present, table } of tables) {
+		for (const [name, kind] of Object.entries(columns)) {
+			if (!(name in present)) {
+				yield* sql`alter table ${sql(table)} add column ${sql(name)} ${sql.literal(sqlTypes[kind])}`;
+			}
+		}
+	}
+});