@shivaedev/work-fleet 0.2.1 → 0.4.0

package/src/engine/recordResponseCommand.ts

@@ -0,0 +1,38 @@
+import { Effect } from "effect";
+import { Conflict } from "@shivaedev/platform/errors/taxonomy.ts";
+import { ANSWER_RECORDED } from "#attention.ts";
+import { failureMessage } from "#engine/failureMessage.ts";
+import { makeHuman } from "#engine/makeHuman.ts";
+import type { EngineState } from "#engine/makeState.ts";
+import { readResolution } from "#engine/readResolution.ts";
+import { cleanupSessions } from "#engine/sessionCleanup.ts";
+
+export function recordResponseCommand(state: EngineState) {
+	return Effect.fn("Fleet.recordResponse")(function* (workId: string, decisionId: string, responseId: string) {
+		const stored = yield* state.load(workId);
+		const receipts = [...(stored.value.history ?? []).flatMap((cycle) => cycle.responses ?? []), ...(stored.value.responses ?? [])];
+		if (receipts.some((receipt) => receipt.decisionId === decisionId && receipt.responseId === responseId)) {
+			return stored;
+		}
+		if (stored.value.stage !== "needs-human" || stored.value.decision?.id !== decisionId) {
+			return yield* new Conflict({ message: "Decision changed" });
+		}
+		yield* readResolution(state.board, stored.value.decision, responseId);
+		const recorded = yield* state.save(stored, { ...stored.value, blocker: ANSWER_RECORDED });
+		yield* state.load(workId).pipe(
+			Effect.flatMap(makeHuman(state)),
+			Effect.flatMap(cleanupSessions(state)),
+			Effect.catch((error) => recordFailure(state, workId, error)),
+			Effect.catchCause(Effect.logError),
+			Effect.forkIn(state.launchScope),
+		);
+		return recorded;
+	});
+}
+
+const recordFailure = Effect.fn("Fleet.recordFailure")(function* (state: EngineState, workId: string, error: unknown) {
+	const current = yield* state.load(workId);
+	return yield* current.value.blocker === ANSWER_RECORDED
+		? state.save(current, { ...current.value, blocker: failureMessage(error) })
+		: Effect.succeed(current);
+});

package/src/engine/recoverStall.ts

@@ -21,7 +21,7 @@ export const recoverStall = Effect.fn("Fleet.recoverStall")(function* (
 	if (attempt.status === "interrupted" && recovery?.interruptRequestedAt !== undefined) {
 		return yield* resumeStalled(state, stored, attempt);
 	}
-	if (!stalled(attempt, now, state.policy.stallMinutes ?? 30)) {
+	if (!stalled(attempt, now, (yield* state.current).stallMinutes ?? 30)) {
 		return undefined;
 	}
 	const work = yield* state.board.get(stored.value.workId);

package/src/engine/repository.ts

@@ -4,33 +4,34 @@ import { defineService } from "@shivaedev/effect-service/define-service.ts";
 import { operationRecord } from "#engine/operationRecord.ts";
 import { threadName } from "#engine/threadNames.ts";
 import { type Attempt, allAttempts, backlog, executing, FleetRecord } from "#model.ts";
-import { checkAreas, needsAreaRecords, requeue } from "#scheduling/areas.ts";
+import { checkLaunchAdmission, needsLaunchRecords } from "#scheduling/admission.ts";
+import { requeue } from "#scheduling/areas.ts";
 import { SessionFailure, type SessionReceipt } from "#session/schema.ts";
 import { SessionJournal } from "#session/service.ts";
+import type { FleetStoreOptions } from "#storage/FleetStoreOptions.ts";
 import { makePostgresFleetStore } from "#storage/makePostgresFleetStore.ts";
 
+const fleetStoreOptions = {
+	admission: checkLaunchAdmission,
+	admissionNeedsRecords: needsLaunchRecords,
+	backlog,
+	executing,
+	requeue,
+	submissions: (record, since) => allAttempts(record).filter((attempt) => attempt.submittedAt >= since).length,
+} satisfies FleetStoreOptions<FleetRecord>;
+
 type Store = Effect.Success<ReturnType<typeof makePostgresFleetStore<typeof FleetRecord>>>;
-export class FleetRepository extends Context.Service<
-	FleetRepository,
-	Omit<Store, "initialize" | "operationEntries"> & Partial<Pick<Store, "operationEntries">>
->()("@shivaedev/work-fleet/FleetRepository") {}
+export class FleetRepository extends Context.Service<FleetRepository, Omit<Store, "operationEntries"> & Partial<Pick<Store, "operationEntries">>>()(
+	"@shivaedev/work-fleet/FleetRepository",
+) {}
 class RepositoryNamespace extends Context.Service<RepositoryNamespace, string | undefined>()("Fleet/RepositoryNamespace") {}
 const PostgresFleetRepository = defineService({
 	id: "Fleet/PostgresFleetRepository",
 	initialize: Effect.gen(function* () {
 		const namespace = yield* RepositoryNamespace;
-		const store = yield* makePostgresFleetStore(FleetRecord, {
-			admission: checkAreas,
-			admissionNeedsRecords: needsAreaRecords,
-			backlog,
-			executing,
-			requeue,
-			submissions: (record, since) => allAttempts(record).filter((attempt) => attempt.submittedAt >= since).length,
-			...(namespace === undefined ? {} : { namespace }),
-		});
-		return store;
+		return yield* makePostgresFleetStore(FleetRecord, { ...fleetStoreOptions, ...(namespace === undefined ? {} : { namespace }) });
 	}),
-	methods: ({ initialize: _initialize, ...methods }) => methods,
+	methods: (store) => store,
 	requires: [SqlClient.SqlClient, RepositoryNamespace],
 });
 

package/src/engine/saveLaunch.ts

@@ -0,0 +1,45 @@
+import { Effect } from "effect";
+import type { EngineState, LaunchAdmission } from "#engine/makeState.ts";
+import type { Attempt, FleetRecord } from "#model.ts";
+import type { BoardWork } from "#policy.ts";
+import type { Versioned } from "#storage/model.ts";
+
+function launched(record: FleetRecord, attempt: Attempt): FleetRecord {
+	return {
+		...record,
+		admissionReady: true,
+		attempts: [...record.attempts, attempt],
+		blocker: undefined,
+		launchRetry: undefined,
+		mergeAreasReleased: undefined,
+		mergeReadyAt: undefined,
+		mergeReadyHead: undefined,
+		pendingAnswers: undefined,
+		stage: "executing",
+	};
+}
+
+// Urgent work first asks for admission within the limits, so only a launch the limits refused is recorded as over the limit.
+export const saveLaunch = Effect.fn("Fleet.saveLaunch")(function* (
+	state: EngineState,
+	stored: Versioned<FleetRecord>,
+	record: FleetRecord,
+	attempt: Attempt,
+	launch: Pick<LaunchAdmission, "quota" | "role"> & { readonly priority: BoardWork["priority"] },
+) {
+	const implementer = stored.value.stage === "prepared";
+	const admission: LaunchAdmission = {
+		ignoreAreas: implementer && stored.value.dispatchNow?.ignoreAreas === true,
+		implementer,
+		quota: launch.quota,
+		role: launch.role,
+	};
+	const urgent = implementer && (launch.priority === "urgent" || stored.value.dispatchNow !== undefined);
+	return yield* state
+		.save(stored, launched(record, attempt), admission)
+		.pipe(
+			Effect.catchTag("StorageCapacity", (error) =>
+				urgent ? state.save(stored, launched(record, { ...attempt, overLimit: true }), { ...admission, overLimit: true }) : Effect.fail(error),
+			),
+		);
+});

package/src/engine/scheduler.ts

@@ -10,9 +10,7 @@ import type { Versioned } from "#storage/model.ts";
 
 const dispatchRecords = Effect.fn("Fleet.dispatchRecords")(function* (records: readonly Versioned<FleetRecord>[]) {
 	const fleet = yield* Fleet;
-	const prepared = records
-		.filter(({ value }) => value.stage === "prepared")
-		.sort((left, right) => (right.value.launchRetry?.retryAt ?? 0) - (left.value.launchRetry?.retryAt ?? 0));
+	const prepared = yield* fleet.admissionOrder(records);
 	const dispatched: Result.Result<Effect.Success<ReturnType<typeof fleet.dispatch>>, Effect.Error<ReturnType<typeof fleet.dispatch>>>[] = [];
 	for (const { value } of prepared) {
 		const result = yield* fleet.dispatch(value.workId).pipe(Effect.result);
@@ -60,8 +58,8 @@ export const cycle = inBoardReadPass(
 		return result;
 	}),
 );
-export const run = Effect.fn("Fleet.run")(function* <R = never>(
-	interval: Parameters<typeof Effect.sleep>[0],
+export const run = Effect.fn("Fleet.run")(function* <R = never, TPause = never>(
+	pause: Effect.Effect<void, never, TPause>,
 	admit: Effect.Effect<void, never, R> = Effect.void,
 ) {
 	const fleet = yield* Fleet;
@@ -82,6 +80,6 @@ export const run = Effect.fn("Fleet.run")(function* <R = never>(
 				yield* dispatchPrepared;
 				yield* schedulerPassed;
 			}),
-		).pipe(Effect.andThen(Effect.sleep(interval))),
+		).pipe(Effect.andThen(pause)),
 	);
 });

package/src/engine/views.ts

@@ -12,6 +12,7 @@ export function views(records: readonly FleetRecord[]): typeof FleetViews.Type {
 			decision: record.stage === "completed" ? undefined : record.decision,
 			links: [...(record.report === undefined ? [] : [record.report.sourcePath]), ...(record.result?.kind === "change" ? [record.result.pr] : [])],
 			outcome: record.outcome,
+			...(launchedOverLimit(record) ? { overLimit: true } : {}),
 			sessions: record.attempts.flatMap(sessionView),
 			stage: record.stage,
 			workId: record.workId,
@@ -41,3 +42,7 @@ function sessionView(attempt: Attempt) {
 				},
 			];
 }
+
+function launchedOverLimit(record: FleetRecord) {
+	return record.attempts.some((attempt) => attempt.overLimit === true && ["submitting", "accepted", "running"].includes(attempt.status));
+}

package/src/fleet.ts

@@ -1,5 +1,6 @@
 import { Effect } from "effect";
 import { defineService } from "@shivaedev/effect-service/define-service.ts";
+import { admissionOrder } from "#engine/admissionOrder.ts";
 import { closeDecisions } from "#engine/closeDecisions.ts";
 import { continueCommand } from "#engine/continueCommand.ts";
 import { dispatchCommand } from "#engine/dispatchCommand.ts";
@@ -11,6 +12,7 @@ import { prepareCommand } from "#engine/prepareCommand.ts";
 import { queueAnswerCommand } from "#engine/queueAnswerCommand.ts";
 import { reassignCommand } from "#engine/reassignCommand.ts";
 import { reconcileCommand } from "#engine/reconcileCommand.ts";
+import { recordResponseCommand } from "#engine/recordResponseCommand.ts";
 import { FleetRepository } from "#engine/repository.ts";
 import { resolveCommand } from "#engine/resolveCommand.ts";
 import { cleanupSessions } from "#engine/sessionCleanup.ts";
@@ -33,6 +35,7 @@ export const Fleet = defineService({
 		return { ...state, advance: makeAdvance(state, launch), launch };
 	}),
 	methods: (state) => ({
+		admissionOrder: admissionOrder(state),
 		continue: continueCommand(state, state.launch),
 		dispatch: dispatchCommand(state, state.launch),
 		get: (workId: string) => state.load(workId),
@@ -43,6 +46,7 @@ export const Fleet = defineService({
 		queueAnswer: queueAnswerCommand(state),
 		reassign: reassignCommand(state),
 		reconcile: (workId: string) => reconcileCommand(state, state.advance)(workId).pipe(Effect.flatMap(cleanupSessions(state))),
+		recordResponse: recordResponseCommand(state),
 		resolve: (workId: string, decisionId: string, responseId: string) =>
 			resolveCommand(state)(workId, decisionId, responseId).pipe(Effect.flatMap(cleanupSessions(state))),
 	}),

package/src/host/actionCommands.ts

@@ -12,7 +12,11 @@ export const continueCommand = Command.make(
 	{ args: [Argument.String("id"), Argument.String("message").pipe(Argument.optional)] as const, board, config, port },
 	Effect.fn("WorkFleetCli.continue")(function* (input) {
 		const message = yield* continuationMessage(Option.getOrUndefined(input.args[1]));
-		const value = yield* daemonRequest(input.port, (client) => client("fleet.continue", { message, workId: input.args[0] }));
+		const value = yield* daemonRequest(
+			input.port,
+			(client) => client("fleet.continue", { message, workId: input.args[0] }),
+			`continue ${input.args[0]}`,
+		);
 		yield* Console.log(`${value.workId} ${value.stage}${value.blocker === undefined ? "" : `: ${value.blocker}`}`);
 	}),
 ).pipe(
@@ -23,7 +27,11 @@ export const releaseCommand = Command.make(
 	"release",
 	{ board, config, port, workIds: Argument.String("id").pipe(Argument.variadic({ min: 1 })) },
 	Effect.fn("WorkFleetCli.release")(function* (input) {
-		const released = yield* daemonRequest(input.port, (client) => client("daemon.release", { workIds: input.workIds }));
+		const released = yield* daemonRequest(
+			input.port,
+			(client) => client("daemon.release", { workIds: input.workIds }),
+			`release ${input.workIds.join(", ")}`,
+		);
 		for (const value of released) {
 			yield* Console.log(`${value.workId} ${value.stage}${value.blocker === undefined ? "" : `: ${value.blocker}`}`);
 		}
@@ -41,8 +49,10 @@ export const reassignCommand = Command.make(
 		to: Argument.Literals("owner", ["maintainer", "orchestrator", "automation"]),
 	},
 	Effect.fn("WorkFleetCli.reassign")(function* (input) {
-		const value = yield* daemonRequest(input.port, (client) =>
-			client("fleet.reassign", { attentionOwner: input.to, decisionId: input.question, workId: input.id }),
+		const value = yield* daemonRequest(
+			input.port,
+			(client) => client("fleet.reassign", { attentionOwner: input.to, decisionId: input.question, workId: input.id }),
+			`reassign ${input.id}`,
 		);
 		yield* Console.log(`${value.workId} ${value.stage} (waiting on ${value.attentionOwner})`);
 	}),
@@ -52,7 +62,7 @@ export const nameThreadsCommand = Command.make(
 	"name-threads",
 	{ board, config, port },
 	Effect.fn("WorkFleetCli.nameThreads")(function* (input) {
-		const results = yield* daemonRequest(input.port, (client) => client("daemon.name-threads", {}));
+		const results = yield* daemonRequest(input.port, (client) => client("daemon.name-threads", {}), "name-threads");
 		for (const result of results) {
 			yield* result.error ? Console.error(result.message) : Console.log(result.message);
 		}
@@ -69,8 +79,13 @@ export const answerCommand = Command.make(
 		release: Flag.Boolean("release").pipe(Flag.withDefault(false)),
 	},
 	Effect.fn("WorkFleetCli.answer")(function* (input) {
-		const text = yield* answerText(Option.getOrUndefined(input.args[1]));
-		const value = yield* daemonRequest(input.port, (client) => client("daemon.answer", { release: input.release, text, workId: input.args[0] }));
+		const supplied = Option.getOrUndefined(input.args[1]);
+		const text = input.release && supplied === undefined ? "" : yield* answerText(supplied);
+		const value = yield* daemonRequest(
+			input.port,
+			(client) => client("daemon.answer", { release: input.release, text, workId: input.args[0] }),
+			`answer ${input.args[0]}`,
+		);
 		const detail = (value.pendingAnswers?.length ?? 0) > 0 ? "queued for the next turn" : value.blocker;
 		yield* Console.log(`${value.workId} ${value.stage}${detail === undefined ? "" : `: ${detail}`}`);
 	}),

package/src/host/admission.ts

@@ -8,7 +8,7 @@ import { Fleet } from "#fleet.ts";
 import type { FleetHost } from "#host/config.ts";
 import { type MainSnapshot, MainSource } from "#host/mainSource.ts";
 import { workerCwd } from "#host/providers.ts";
-import type { FleetRecord } from "#model.ts";
+import type { DispatchNow, FleetRecord } from "#model.ts";
 import { BoardGateway, type BoardWork } from "#policy.ts";
 import type { Preparation } from "#preparation/schema.ts";
 import { workerPrompt } from "#prompt/worker.ts";
@@ -116,7 +116,7 @@ export const admitApproved = Effect.fn("FleetHost.admitApproved")(function* (hos
 	return failures;
 }, inBoardReadPass);
 
-export const dispatchApproved = Effect.fn("FleetHost.dispatchApproved")(function* (host: FleetHost, workId: string) {
+export const dispatchApproved = Effect.fn("FleetHost.dispatchApproved")(function* (host: FleetHost, workId: string, now?: DispatchNow) {
 	const fleet = yield* Fleet;
 	const work = yield* (yield* BoardGateway).get(workId);
 	if (!work.approved) {
@@ -127,5 +127,5 @@ export const dispatchApproved = Effect.fn("FleetHost.dispatchApproved")(function
 	if (existing === undefined || ["completed", "released"].includes(existing.stage) || unlaunched(existing) || !briefChanged(existing, work)) {
 		yield* prepareApproved(host, work, existing, "explicit");
 	}
-	return yield* fleet.dispatch(workId, launchPrompt(host, work));
+	return yield* fleet.dispatch(workId, launchPrompt(host, work), now);
 }, inBoardReadPass);

package/src/host/answerWork.ts

@@ -3,37 +3,38 @@ import { BadRequest, Conflict } from "@shivaedev/platform/errors/taxonomy.ts";
 import { Fleet } from "#fleet.ts";
 import type { FleetHost } from "#host/config.ts";
 import { recordDecisionResponse } from "#host/recordDecisionResponse.ts";
-import { withDecisionResponses } from "#host/releaseWork.ts";
 import type { FleetRecord } from "#model.ts";
 import type { Decision } from "#policy.ts";
 
-export function answerWork(host: FleetHost, workId: string, text = "", release = false) {
-	return withDecisionResponses(
-		host,
-		Effect.gen(function* () {
-			const fleet = yield* Fleet;
-			const original = (yield* fleet.get(workId)).value.decision;
-			let recorded: { readonly decisionId: string; readonly responseId: string } | undefined;
-			return yield* Effect.gen(function* () {
-				const current = (yield* fleet.get(workId)).value;
-				if (recorded !== undefined && hasResponse(current, recorded)) {
-					return yield* fleet.resolve(workId, recorded.decisionId, recorded.responseId);
-				}
-				if (canQueueAnswer(current, text, release)) {
-					return yield* fleet.queueAnswer(workId, text);
-				}
-				yield* checkDecision(current, original);
-				const response = yield* publishAnswer(host, workId, original, text, release);
-				recorded = response;
-				return yield* fleet
-					.resolve(workId, response.decisionId, response.responseId)
-					.pipe(Effect.catchTag("Conflict", (error) => decisionConflict(fleet, workId, response.decisionId, error)));
-			}).pipe(
-				Effect.retry({ while: (error) => error._tag === "StorageConflict" || (error._tag === "Conflict" && error.message === "Decision changed") }),
-			);
-		}),
+export const answerWork = Effect.fn("FleetHost.answerWork")(function* (
+	host: FleetHost,
+	workId: string,
+	text = "",
+	release = false,
+	background = false,
+) {
+	const fleet = yield* Fleet;
+	const resolve = background ? fleet.recordResponse : fleet.resolve;
+	const original = (yield* fleet.get(workId)).value.decision;
+	let recorded: { readonly decisionId: string; readonly responseId: string } | undefined;
+	return yield* Effect.gen(function* () {
+		const current = (yield* fleet.get(workId)).value;
+		if (recorded !== undefined && hasResponse(current, recorded)) {
+			return yield* resolve(workId, recorded.decisionId, recorded.responseId);
+		}
+		if (canQueueAnswer(current, text, release)) {
+			return yield* fleet.queueAnswer(workId, text);
+		}
+		yield* checkDecision(current, original);
+		const response = yield* publishAnswer(host, workId, original, text, release);
+		recorded = response;
+		return yield* resolve(workId, response.decisionId, response.responseId).pipe(
+			Effect.catchTag("Conflict", (error) => decisionConflict(fleet, workId, response.decisionId, error)),
+		);
+	}).pipe(
+		Effect.retry({ while: (error) => error._tag === "StorageConflict" || (error._tag === "Conflict" && error.message === "Decision changed") }),
 	);
-}
+});
 
 function checkDecision(record: FleetRecord, original: Decision | undefined) {
 	const current = record.decision;

package/src/host/cliOptions.ts

@@ -1,7 +1,7 @@
 import * as Flag from "effect/cli/Flag";
 import * as Option from "effect/Option";
 import { diagnostics as diagnosticsApi } from "@shivaedev/work-board/integration/diagnostics.ts";
-import { loadHost } from "#host/config.ts";
+import { loadHost } from "#host/configFile.ts";
 
 const { DAEMON_PORT } = diagnosticsApi;
 

package/src/host/commands.ts

@@ -1,11 +1,13 @@
 import * as NodeServices from "@effect/platform-node/NodeServices";
-import { Console, Effect, Layer } from "effect";
+import { Console, Effect, Layer, Stream } from "effect";
 import type { ReportInspection } from "#engine/ReportInspection.ts";
 import { run } from "#engine/scheduler.ts";
 import { Fleet } from "#fleet.ts";
 import { admitApproved, dispatchApproved } from "#host/admission.ts";
 import type { FleetHost } from "#host/config.ts";
+import { GithubApi } from "#host/githubApi.ts";
 import { healthLayer } from "#host/healthLayer.ts";
+import { LiveConfig, staticConfig } from "#host/liveConfig.ts";
 import { gitMainSource, type MainSource } from "#host/mainSource.ts";
 import { hostProvider } from "#host/providers.ts";
 import { fleetHostLayer } from "#host/runtime.ts";
@@ -14,8 +16,9 @@ import type { BoardGateway, FleetIntegrations, FleetPolicy } from "#policy.ts";
 import type { SessionTransport } from "#session/service.ts";
 
 export interface HostParts {
-	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, unknown>;
 	readonly policy?: Layer.Layer<FleetPolicy>;
 	readonly provider: Layer.Layer<SessionTransport, unknown>;
@@ -25,13 +28,31 @@ export function productionParts(host: FleetHost): HostParts {
 	return { main: gitMainSource(host), provider: hostProvider(host) };
 }
 
-export function hostLayer(host: FleetHost, parts: HostParts) {
-	const runtime = Layer.mergeAll(fleetHostLayer(host, parts), NodeServices.layer).pipe(Layer.provideMerge(healthLayer(host.boardDir)));
-	return statusLayer(host.boardDir, { concurrency: host.concurrency, staleAfterMs: Math.max(60_000, host.interval * 3000) }).pipe(
-		Layer.provideMerge(runtime),
+export function hostLayer(host: FleetHost, parts: HostParts, config: Layer.Layer<LiveConfig, unknown> = staticConfig(host)) {
+	const runtime = Layer.mergeAll(fleetHostLayer(host, parts, config), NodeServices.layer).pipe(Layer.provideMerge(healthLayer(host.boardDir)));
+	const status = Layer.unwrap(
+		Effect.map(LiveConfig, (live) =>
+			statusLayer(
+				host.boardDir,
+				Effect.map(live.current, ({ host: applied }) => ({
+					concurrency: applied.concurrency,
+					staleAfterMs: Math.max(60_000, applied.interval * 3000),
+				})),
+			),
+		),
 	);
+	return status.pipe(Layer.provideMerge(runtime), Layer.provideMerge(config));
 }
 
+// An applied config edit starts the next pass at once instead of after the interval it replaced, and a low GitHub budget stretches that interval.
+export const schedulerPause = Effect.gen(function* () {
+	const live = yield* LiveConfig;
+	const github = yield* GithubApi;
+	const { host: applied } = yield* live.current;
+	const delay = yield* github.pace(applied.interval * 1000);
+	yield* Effect.raceFirst(Effect.sleep(delay), live.changes.pipe(Stream.drop(1), Stream.take(1), Stream.runDrain));
+});
+
 export function hostScheduler(host: FleetHost) {
 	let reported = new Set<string>();
 	const admission = admitApproved(host).pipe(
@@ -45,7 +66,7 @@ export function hostScheduler(host: FleetHost) {
 			}),
 		),
 	);
-	return run(`${host.interval} seconds`, admission);
+	return run(schedulerPause, admission);
 }
 
 export function runFleet(host: FleetHost, parts: HostParts = productionParts(host)) {

package/src/host/config.ts

@@ -1,12 +1,12 @@
-import * as Effect from "effect/Effect";
-import * as FileSystem from "effect/FileSystem";
-import * as Path from "effect/Path";
 import * as Schema from "effect/Schema";
-import { CONFIG_FILE, DEFAULT_NAMESPACE, NAMESPACE, SHARED_LOCAL_POSTGRES } from "#host/defaults.ts";
+import { DEFAULT_READ_RETRY_MS } from "#engine/readRetry.ts";
+import { DEFAULT_NAMESPACE, NAMESPACE, SHARED_LOCAL_POSTGRES } from "#host/defaults.ts";
 import { DEFAULT_AREA_MERGE_WAIT_MS } from "#scheduling/areas.ts";
 import { LaunchSettings } from "#session/schema.ts";
+import type { OpenPullRequestCurve } from "#storage/model.ts";
 
 const Positive = Schema.Int.check(Schema.isGreaterThan(0));
+const Count = Schema.Int.check(Schema.isGreaterThanOrEqualTo(0));
 const Text = Schema.String.check(Schema.isMinLength(1));
 const Guidance = Schema.Union([Text, Schema.Struct({ file: Text })]);
 
@@ -21,6 +21,7 @@ export const HostConfig = Schema.Struct({
 			endpoint: Schema.optional(Text),
 			environmentId: Text,
 			projectId: Schema.optional(Text),
+			recoveryGraceMs: Schema.optional(Positive),
 			refreshCommand: Schema.optional(Schema.Struct({ args: Schema.Array(Schema.String), command: Text })),
 			requestTimeoutMs: Schema.optional(Positive),
 			threadNamePrefix: Schema.optional(Text),
@@ -33,8 +34,14 @@ export const HostConfig = Schema.Struct({
 	launch: Schema.optional(LaunchSettings),
 	local: Schema.optional(Schema.Struct({ endpoint: Text, requestTimeoutMs: Schema.optional(Positive) })),
 	namespace: Schema.optional(Schema.String.check(Schema.isPattern(NAMESPACE))),
+	openPullRequests: Schema.optional(
+		Schema.Struct({ ease: Count, floor: Schema.optional(Count), max: Positive }).check(
+			Schema.makeFilter((curve) => curve.ease <= curve.max || "openPullRequests.ease must not exceed openPullRequests.max"),
+		),
+	),
 	provider: Schema.Literals(["local", "cloud"]),
 	quota: Schema.optional(Schema.Literals(["codex", "unlimited"])),
+	readRetryMs: Schema.optional(Positive),
 	repository: Schema.optional(Schema.Struct({ branch: Text, remote: Text })),
 	result: Schema.optional(Schema.Literal("github")),
 	stallMinutes: Schema.optional(Positive),
@@ -51,61 +58,58 @@ export type HostConfig = typeof HostConfig.Type;
 
 export class HostFailure extends Schema.TaggedError<HostFailure>()("HostFailure", { message: Schema.String }) {}
 
+export class HostConfigRejected extends Schema.TaggedError<HostConfigRejected>()("HostConfigRejected", {
+	field: Schema.optional(Schema.String),
+	file: Schema.String,
+	message: Schema.String,
+}) {}
+
 export interface FleetHost {
 	readonly areaMergeWaitMs: number;
 	readonly backlog: number;
 	readonly boardDir: string;
 	readonly cloud: HostConfig["cloud"];
 	readonly concurrency: number;
+	readonly config: HostConfig;
+	readonly configFile?: string;
 	readonly databaseUrl: string;
 	readonly interval: number;
 	readonly launch: NonNullable<HostConfig["launch"]>;
 	readonly local: HostConfig["local"];
 	readonly maxConnections: number;
 	readonly namespace: string;
+	readonly openPullRequests?: OpenPullRequestCurve;
 	readonly provider: HostConfig["provider"];
 	readonly quota: NonNullable<HostConfig["quota"]>;
+	readonly readRetryMs: number;
 	readonly repository: NonNullable<HostConfig["repository"]>;
 	readonly result?: HostConfig["result"];
 	readonly stallMinutes: number;
 	readonly worker: HostConfig["worker"];
 }
 
-export function resolveHost(boardDir: string, config: HostConfig): FleetHost {
+export function resolveHost(boardDir: string, config: HostConfig, configFile?: string): FleetHost {
 	return {
 		areaMergeWaitMs: config.areaMergeWaitMs ?? DEFAULT_AREA_MERGE_WAIT_MS,
 		backlog: config.backlog ?? 100,
 		boardDir,
 		cloud: config.cloud,
 		concurrency: config.concurrency ?? 100,
+		config,
+		...(configFile === undefined ? {} : { configFile }),
 		databaseUrl: config.database?.url ?? SHARED_LOCAL_POSTGRES,
 		interval: config.intervalSeconds ?? 15,
 		launch: config.launch ?? {},
 		local: config.local,
 		maxConnections: config.database?.maxConnections ?? 20,
 		namespace: config.namespace ?? DEFAULT_NAMESPACE,
+		...(config.openPullRequests === undefined ? {} : { openPullRequests: { ...config.openPullRequests, floor: config.openPullRequests.floor ?? 0 } }),
 		provider: config.provider,
 		quota: config.quota ?? "codex",
+		readRetryMs: config.readRetryMs ?? DEFAULT_READ_RETRY_MS,
 		repository: config.repository ?? { branch: "main", remote: "origin" },
 		result: config.result,
 		stallMinutes: config.stallMinutes ?? 30,
 		worker: config.worker,
 	};
 }
-
-export const loadHost = Effect.fn("FleetHost.loadHost")(function* (board: string, configPath?: string) {
-	const fs = yield* FileSystem.FileSystem;
-	const path = yield* Path.Path;
-	const boardDir = path.resolve(board);
-	const file = configPath === undefined ? path.join(boardDir, CONFIG_FILE) : path.resolve(configPath);
-	const text = yield* fs
-		.readFileString(file)
-		.pipe(Effect.mapError(() => new HostFailure({ message: `Fleet host configuration is missing or unreadable: ${file}` })));
-	const config = yield* Schema.decodeUnknownEffect(Schema.fromJsonString(HostConfig))(text).pipe(
-		Effect.mapError((error) => new HostFailure({ message: `Fleet host configuration ${file} is invalid: ${error.message}` })),
-	);
-	if (config.provider === "cloud" && (config.cloud === undefined || config.worker === undefined)) {
-		return yield* new HostFailure({ message: `Fleet host configuration ${file} selects provider "cloud" without cloud and worker settings` });
-	}
-	return resolveHost(boardDir, config);
-});

package/src/host/configFile.ts

@@ -0,0 +1,40 @@
+import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
+import * as Path from "effect/Path";
+import * as Schema from "effect/Schema";
+import * as SchemaIssue from "effect/SchemaIssue";
+import { HostConfig, HostConfigRejected, HostFailure, resolveHost } from "#host/config.ts";
+import { CONFIG_FILE } from "#host/defaults.ts";
+
+export const readHostConfig = Effect.fn("FleetHost.readHostConfig")(function* (file: string) {
+	const fs = yield* FileSystem.FileSystem;
+	const text = yield* fs
+		.readFileString(file)
+		.pipe(Effect.mapError(() => new HostConfigRejected({ file, message: `Fleet host configuration is missing or unreadable: ${file}` })));
+	const config = yield* Schema.decodeUnknownEffect(Schema.fromJsonString(HostConfig))(text).pipe(
+		Effect.mapError((error) => {
+			const field = SchemaIssue.makeFormatterStandardSchemaV1()(error.issue).issues[0]?.path?.map(String).join(".");
+			return new HostConfigRejected({
+				...(field === undefined || field === "" ? {} : { field }),
+				file,
+				message: `Fleet host configuration ${file} is invalid: ${error.message}`,
+			});
+		}),
+	);
+	if (config.provider === "cloud" && (config.cloud === undefined || config.worker === undefined)) {
+		return yield* new HostConfigRejected({
+			field: config.cloud === undefined ? "cloud" : "worker",
+			file,
+			message: `Fleet host configuration ${file} selects provider "cloud" without cloud and worker settings`,
+		});
+	}
+	return config;
+});
+
+export const loadHost = Effect.fn("FleetHost.loadHost")(function* (board: string, configPath?: string) {
+	const path = yield* Path.Path;
+	const boardDir = path.resolve(board);
+	const file = configPath === undefined ? path.join(boardDir, CONFIG_FILE) : path.resolve(configPath);
+	const config = yield* readHostConfig(file).pipe(Effect.mapError((rejected) => new HostFailure({ message: rejected.message })));
+	return resolveHost(boardDir, config, file);
+});