@shivaedev/work-fleet 0.2.0 → 0.3.0

package/dist/storage/shapeV14.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shapeV14.d.ts","sourceRoot":"","sources":["../../src/storage/shapeV14.ts"],"names":[],"mappings":"AAaA,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAJR,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wCAJ2C,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2CACsB,QAAQ;;;;;;qBAKpF,MAAM;yBAAI,WAAW,EAAE,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCAFnC,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCAEF,MAAM;qCAAI,WAAW,EAAE,SAAS;;;yCAKM,QAAQ;;;;;CAEpC,CAAC"}

package/dist/storage/shapeV14.js

@@ -0,0 +1,18 @@
+import { attemptV12 } from "#storage/attemptV12.ts";
+import { cycleV12 } from "#storage/cycleV12.ts";
+import { decisionV12 } from "#storage/typedDecisionsV12.ts";
+const attempt = { fields: { ...attemptV12.fields, overLimit: "boolean" } };
+const publicationWork = { fields: { ...decisionV12.fields.publicationWork.fields, priority: "string" } };
+const cycle = {
+    ...cycleV12.fields,
+    attempts: { array: attempt },
+    decision: { fields: { ...decisionV12.fields, publicationWork } },
+    dispatchNow: { fields: { ignoreAreas: "boolean" } },
+};
+export const shapeV14 = {
+    fields: {
+        ...cycle,
+        history: { array: { fields: { ...cycle, archivedAt: "number" } } },
+    },
+};
+//# sourceMappingURL=shapeV14.js.map

package/dist/storage/shapeV14.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"shapeV14.js","sourceRoot":"","sources":["../../src/storage/shapeV14.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AACpD,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAEhD,OAAO,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAC;AAE5D,MAAM,OAAO,GAAG,EAAE,MAAM,EAAE,EAAE,GAAG,UAAU,CAAC,MAAM,EAAE,SAAS,EAAE,SAAS,EAAE,EAAW,CAAC;AACpF,MAAM,eAAe,GAAG,EAAE,MAAM,EAAE,EAAE,GAAG,WAAW,CAAC,MAAM,CAAC,eAAe,CAAC,MAAM,EAAE,QAAQ,EAAE,QAAQ,EAAE,EAAW,CAAC;AAClH,MAAM,KAAK,GAAG;IACb,GAAG,QAAQ,CAAC,MAAM;IAClB,QAAQ,EAAE,EAAE,KAAK,EAAE,OAAO,EAAE;IAC5B,QAAQ,EAAE,EAAE,MAAM,EAAE,EAAE,GAAG,WAAW,CAAC,MAAM,EAAE,eAAe,EAAE,EAAE;IAChE,WAAW,EAAE,EAAE,MAAM,EAAE,EAAE,WAAW,EAAE,SAAS,EAAE,EAAE;CAC1C,CAAC;AACX,MAAM,CAAC,MAAM,QAAQ,GAAG;IACvB,MAAM,EAAE;QACP,GAAG,KAAK;QACR,OAAO,EAAE,EAAE,KAAK,EAAE,EAAE,MAAM,EAAE,EAAE,GAAG,KAAK,EAAE,UAAU,EAAE,QAAQ,EAAE,EAAE,EAAE;KAClE;CACwB,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shivaedev/work-fleet",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Optional Board-backed execution, review and authorized delivery",
   "homepage": "https://github.com/ShivaeDev/platform/tree/main/packages/work-fleet#readme",
   "bugs": {
@@ -48,8 +48,8 @@
     "@shivaedev/effect-contract": "0.5.1",
     "@shivaedev/effect-service": "0.3.0",
     "@shivaedev/effect-sql": "0.5.0",
-    "@shivaedev/platform": "0.14.0",
-    "@shivaedev/work-board": "0.14.1",
+    "@shivaedev/platform": "0.14.2",
+    "@shivaedev/work-board": "0.15.0",
     "yaml": "2.9.1"
   },
   "devDependencies": {
@@ -57,9 +57,9 @@
     "@effect/platform-node-shared": "4.0.4",
     "@effect/vitest": "4.0.4",
     "@shivaedev/effect-test": "0.5.0",
-    "@shivaedev/effect-test-sql": "0.4.0",
-    "@shivaedev/quality": "0.22.0",
-    "@types/node": "24.19.1",
+    "@shivaedev/effect-test-sql": "0.5.2",
+    "@shivaedev/quality": "0.23.0",
+    "@types/node": "24.19.2",
     "@typescript/native": "npm:typescript@7.0.2",
     "effect": "4.0.4",
     "typescript": "npm:@typescript/typescript6@6.0.2",

package/src/DispatchRequest.ts

@@ -0,0 +1,13 @@
+import { Schema } from "effect";
+
+export const DispatchRequest = Schema.Struct({
+	acceptedAt: Schema.Number,
+	completedAt: Schema.optional(Schema.Number),
+	error: Schema.optional(Schema.String),
+	id: Schema.String,
+	ignoreAreas: Schema.optional(Schema.Boolean),
+	now: Schema.optional(Schema.Boolean),
+	status: Schema.Literals(["pending", "completed", "failed"]),
+	workId: Schema.String,
+});
+export type DispatchRequest = typeof DispatchRequest.Type;

package/src/attention.ts

@@ -3,6 +3,8 @@ import { Schema } from "effect";
 export const AttentionOwner = Schema.Literals(["maintainer", "orchestrator", "automation"]);
 export type AttentionOwner = typeof AttentionOwner.Type;
 
+export const ANSWER_RECORDED = "Answer recorded; applying in the background";
+
 export function waitingOwner(record: {
 	readonly attentionOwner?: AttentionOwner | undefined;
 	readonly blocker?: string | undefined;
@@ -11,6 +13,9 @@ export function waitingOwner(record: {
 	readonly launchRetry?: { readonly retryAt: number } | undefined;
 	readonly stage: string;
 }): AttentionOwner | undefined {
+	if (record.blocker === ANSWER_RECORDED) {
+		return "automation";
+	}
 	if (record.launchRetry !== undefined || (record.stage === "prepared" && record.blocker?.startsWith("waiting for dependency "))) {
 		return "automation";
 	}

package/src/board/fleetField.ts

@@ -4,6 +4,7 @@ import type { ParsedMetadata } from "@shivaedev/work-board/integration/board.ts"
 const APPROVAL = "fleet";
 const LAUNCH = "fleet-launch";
 const DELIVERABLE = "fleet-deliverable";
+const PRIORITY = "fleet-priority";
 const parsedFields = new WeakMap<ParsedMetadata, ReadonlyMap<string, unknown>>();
 
 function fleetField(parsed: ParsedMetadata, field: string): unknown {
@@ -33,3 +34,7 @@ export function fleetLaunch(parsed: ParsedMetadata): unknown {
 export function fleetDeliverable(parsed: ParsedMetadata): unknown {
 	return fleetField(parsed, DELIVERABLE);
 }
+
+export function fleetPriority(parsed: ParsedMetadata): unknown {
+	return fleetField(parsed, PRIORITY);
+}

package/src/board/markdown.ts

@@ -6,13 +6,13 @@ import { briefRevision } from "#board/briefRevision.ts";
 import { completionMarkdown } from "#board/completionMarkdown.ts";
 import { decisionReading } from "#board/decisionReading.ts";
 import { boundDocuments, boundSnapshot, refreshSnapshotDocument, snapshotDocument } from "#board/documents.ts";
-import { fleetApproved, fleetDeliverable } from "#board/fleetField.ts";
+import { fleetApproved, fleetDeliverable, fleetPriority } from "#board/fleetField.ts";
 import { publishBoard } from "#board/publish.ts";
 import { publishReport } from "#board/publishReport.ts";
 import { workMetadata } from "#board/readPass.ts";
 import { workRevision } from "#board/workRevision.ts";
 import { writeCompletion } from "#board/writeCompletion.ts";
-import { BoardFailure, BoardGateway } from "#policy.ts";
+import { BoardFailure, BoardGateway, Priority } from "#policy.ts";
 import { RepositoryPath } from "#preparation/schema.ts";
 
 class BoardRoot extends Context.Service<BoardRoot, string>()("Fleet/BoardRoot") {}
@@ -38,6 +38,10 @@ const MarkdownBoard = defineService({
 			if (deliverable !== undefined && deliverable !== "report") {
 				return yield* Effect.fail(new BoardFailure({ message: "Invalid fleet-deliverable; use report or omit the field for pull requests." }));
 			}
+			const priority = fleetPriority(found.parsed);
+			if (priority !== undefined && !Schema.is(Priority)(priority)) {
+				return yield* Effect.fail(new BoardFailure({ message: "Invalid fleet-priority; use urgent, high or normal, or omit the field." }));
+			}
 			return {
 				approved: fleetApproved(found.parsed),
 				areas: found.parsed.fields.areas,
@@ -45,6 +49,7 @@ const MarkdownBoard = defineService({
 				...(deliverable === "report" ? { deliverable: "report" as const } : {}),
 				context: found.source,
 				dependsOn: (found.parsed.fields.relationships ?? []).filter((relation) => relation.kind === "depends_on").map((relation) => relation.target),
+				...(priority === undefined ? {} : { priority }),
 				revision: briefRevision(found.parsed),
 				sourcePath: path.join(realRoot, found.file),
 				workId,

package/src/cli.ts

@@ -26,13 +26,25 @@ const serveCommand = Command.make(
 
 const dispatchCommand = Command.make(
 	"dispatch",
-	{ board, config, port, workId: Argument.String("id") },
+	{
+		board,
+		config,
+		ignoreAreas: Flag.Boolean("ignore-areas").pipe(Flag.withDefault(false), Flag.withDescription("With --now, also skip area claims")),
+		now: Flag.Boolean("now").pipe(
+			Flag.withDefault(false),
+			Flag.withDescription("Launch over concurrency, open-PR back pressure and backlog limits; areas and dependencies still apply"),
+		),
+		port,
+		workId: Argument.String("id"),
+	},
 	Effect.fn("WorkFleetCli.dispatch")(function* (input) {
-		const { daemonClient, daemonError } = yield* Effect.promise(() => import("#host/daemonClient.ts"));
-		const value = yield* Effect.scoped(
-			daemonClient(input.port).pipe(Effect.flatMap((client) => client("daemon.dispatch", { workId: input.workId }))),
-		).pipe(Effect.mapError((error) => daemonError(error, input.port)));
-		yield* Console.log(`${value.workId} ${value.stage}${value.blocker === undefined ? "" : `: ${value.blocker}`}`);
+		const { daemonRequest } = yield* Effect.promise(() => import("#host/daemonClient.ts"));
+		const value = yield* daemonRequest(
+			input.port,
+			(client) => client("daemon.dispatch", { ignoreAreas: input.ignoreAreas, now: input.now, workId: input.workId }),
+			`dispatch ${input.workId}`,
+		);
+		yield* Console.log(`${value.workId}: dispatch recorded${value.now ? " over the limits" : ""}; preparing and launching in the background`);
 	}),
 ).pipe(Command.withDescription("Prepare the current approved revision of one Board item and launch it"));
 
@@ -46,13 +58,15 @@ const statusCommand = Command.make(
 		workId: Argument.String("id").pipe(Argument.optional),
 	},
 	Effect.fn("WorkFleetCli.status")(function* (input) {
-		const [{ daemonClient, daemonError }, { renderStatus }] = yield* Effect.promise(() =>
+		const [{ daemonRequest }, { renderStatus }] = yield* Effect.promise(() =>
 			Promise.all([import("#host/daemonClient.ts"), import("#host/renderStatus.ts")]),
 		);
 		const workId = Option.getOrUndefined(input.workId);
-		const current = yield* Effect.scoped(
-			daemonClient(input.port).pipe(Effect.flatMap((client) => client("daemon.status", workId === undefined ? {} : { workId }))),
-		).pipe(Effect.mapError((error) => daemonError(error, input.port)));
+		const current = yield* daemonRequest(
+			input.port,
+			(client) => client("daemon.status", workId === undefined ? {} : { workId }),
+			workId === undefined ? "status" : `status ${workId}`,
+		);
 		yield* Console.log(input.json ? JSON.stringify(current) : renderStatus(current, input.port));
 	}),
 ).pipe(Command.withDescription("Show active and completed Fleet work, and waiting work grouped by owner"));

package/src/engine/admissionOrder.ts

@@ -0,0 +1,25 @@
+import { Effect } from "effect";
+import type { EngineState } from "#engine/makeState.ts";
+import { retryPending } from "#engine/readRetry.ts";
+import type { FleetRecord } from "#model.ts";
+import type { Priority } from "#policy.ts";
+import type { Versioned } from "#storage/model.ts";
+
+const ranks: Readonly<Record<Priority, number>> = { high: 1, normal: 2, urgent: 0 };
+
+export function admissionOrder(state: EngineState) {
+	return Effect.fn("Fleet.admissionOrder")(function* (records: readonly Versioned<FleetRecord>[]) {
+		const prepared = records.filter(({ value }) => value.stage === "prepared");
+		const ranked = yield* Effect.forEach(prepared, (entry) =>
+			retryPending(state, entry.value)
+				? Effect.succeed({ entry, rank: ranks.normal })
+				: state.board.get(entry.value.workId).pipe(
+						Effect.map((work) => ({ entry, rank: ranks[work.priority ?? "normal"] })),
+						Effect.orElseSucceed(() => ({ entry, rank: ranks.normal })),
+					),
+		);
+		return ranked
+			.sort((left, right) => (right.entry.value.launchRetry?.retryAt ?? 0) - (left.entry.value.launchRetry?.retryAt ?? 0) || left.rank - right.rank)
+			.map(({ entry }) => entry);
+	});
+}

package/src/engine/dispatchCommand.ts

@@ -1,5 +1,6 @@
 import { Effect, Result } from "effect";
 import { Forbidden } from "@shivaedev/platform/errors/taxonomy.ts";
+import { waitingOwner } from "#attention.ts";
 import { approveDispatchedBrief } from "#engine/approveBrief.ts";
 import { authorizeBriefContext } from "#engine/boardBrief.ts";
 import { failureCode } from "#engine/failureCode.ts";
@@ -10,10 +11,16 @@ import type { EngineState } from "#engine/makeState.ts";
 import { clearIntegrationRetry, readRetry, retryPending } from "#engine/readRetry.ts";
 import { refreshBrief } from "#engine/refreshBrief.ts";
 import { releaseClosedPreparation } from "#engine/releaseClosedPreparation.ts";
+import type { DispatchNow, FleetRecord } from "#model.ts";
 import { assessPreparation } from "#preparation/compatibility.ts";
+import type { Versioned } from "#storage/model.ts";
 export function dispatchCommand(state: EngineState, launch: ReturnType<typeof makeLaunch>) {
 	const { board, load, save, decision, integrations, policy } = state;
-	const dispatchPrepared = Effect.fn("Fleet.dispatchPrepared")(function* (workId: string, prompt?: string) {
+	function rememberNow(stored: Versioned<FleetRecord>, now: DispatchNow | undefined) {
+		const requested = requestedNow(stored.value, now);
+		return requested === undefined ? Effect.succeed(stored) : save(stored, requested);
+	}
+	const dispatchPrepared = Effect.fn("Fleet.dispatchPrepared")(function* (workId: string, prompt?: string, now?: DispatchNow) {
 		let stored = yield* load(workId);
 		const work = yield* board.get(workId);
 		stored = yield* refreshBrief(state, stored, work);
@@ -25,6 +32,7 @@ export function dispatchCommand(state: EngineState, launch: ReturnType<typeof ma
 		if (released !== undefined) {
 			return released;
 		}
+		stored = yield* rememberNow(stored, now);
 		const authorized = yield* authorizeBriefContext(stored.value, work).pipe(Effect.result);
 		if (Result.isFailure(authorized)) {
 			return yield* decision(
@@ -56,18 +64,21 @@ export function dispatchCommand(state: EngineState, launch: ReturnType<typeof ma
 					if (current.value.stage !== "prepared") {
 						return current;
 					}
-					yield* save(current, {
+					const waiting = {
 						...current.value,
 						admissionReady: !(error instanceof Forbidden),
 						attentionOwner: failureOwner(error),
 						blocker: failureMessage(error),
-					});
+					};
+					if (!sameWait(current.value, waiting)) {
+						yield* save(current, waiting);
+					}
 					return yield* Effect.fail(error);
 				}),
 			),
 		);
 	});
-	return Effect.fn("Fleet.dispatch")(function* (workId: string, prompt?: string) {
+	return Effect.fn("Fleet.dispatch")(function* (workId: string, prompt?: string, now?: DispatchNow) {
 		const current = yield* load(workId);
 		if (retryPending(state, current.value)) {
 			return current;
@@ -75,7 +86,7 @@ export function dispatchCommand(state: EngineState, launch: ReturnType<typeof ma
 		if (current.value.integrationRetry !== undefined) {
 			yield* save(current, { ...current.value, attentionOwner: undefined, blocker: undefined });
 		}
-		return yield* dispatchPrepared(workId, prompt).pipe(
+		return yield* dispatchPrepared(workId, prompt, now).pipe(
 			Effect.flatMap((updated) => clearIntegrationRetry(state, updated)),
 			Effect.catch((error) =>
 				Effect.gen(function* () {
@@ -86,3 +97,16 @@ export function dispatchCommand(state: EngineState, launch: ReturnType<typeof ma
 		);
 	});
 }
+
+function requestedNow(record: FleetRecord, now: DispatchNow | undefined): FleetRecord | undefined {
+	const current = record.dispatchNow;
+	if (now === undefined || (current !== undefined && (current.ignoreAreas || !now.ignoreAreas))) {
+		return undefined;
+	}
+	return { ...record, dispatchNow: now };
+}
+
+// Every scheduler pass retries waiting work, so rewriting an unchanged wait would make each pass write and notify once per waiter.
+function sameWait(current: FleetRecord, waiting: FleetRecord) {
+	return current.blocker === waiting.blocker && current.admissionReady === waiting.admissionReady && current.attentionOwner === waitingOwner(waiting);
+}

package/src/engine/failureContext.ts

@@ -7,6 +7,7 @@ interface FailureContext {
 	readonly code?: DecisionCode | undefined;
 	readonly head?: string;
 	readonly mainRevision?: string;
+	readonly retryAt?: number;
 	readonly retryable?: boolean;
 }
 

package/src/engine/failureMessage.ts

@@ -10,10 +10,21 @@ export function failureMessage(error: unknown): string {
 		return "Fresh available provider quota is required";
 	}
 	if (error instanceof StorageCapacity) {
-		return `${error.kind} capacity is occupied (limit ${error.limit})`;
+		return capacityMessage(error);
 	}
 	if (error instanceof StorageConflict) {
 		return "Work changed during this observation; load the current record";
 	}
 	return "The integration is unavailable; inspect runtime diagnostics";
 }
+
+function capacityMessage(error: StorageCapacity) {
+	switch (error.kind) {
+		case "open-pull-requests":
+			return `waiting for open PRs to merge: ${error.occupied ?? error.limit} of ${error.limit}`;
+		case "merge-work":
+			return `waiting for ${error.occupied ?? 0} review or repair launches to go first (limit ${error.limit})`;
+		default:
+			return `${error.kind} capacity is occupied (limit ${error.limit})`;
+	}
+}

package/src/engine/localOnlyCriteria.ts

@@ -2,11 +2,16 @@ import { Effect } from "effect";
 import { workMetadata } from "#board/readPass.ts";
 import type { BoardWork } from "#policy.ts";
 
+function mentions(text: string, localPath: string) {
+	const escaped = localPath.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+	return new RegExp(`(?<![\\w.-])${escaped}(?![\\w-])`, "u").test(text);
+}
+
 export const localOnlyCriteria = Effect.fn("Fleet.localOnlyCriteria")(function* (work: BoardWork, localPath: string | undefined) {
 	if (localPath === undefined) {
 		return undefined;
 	}
-	const criteria = (yield* workMetadata(work)).fields.criteria?.filter(({ text }) => text.includes(localPath)) ?? [];
+	const criteria = (yield* workMetadata(work)).fields.criteria?.filter(({ text }) => mentions(text, localPath)) ?? [];
 	if (criteria.length > 0) {
 		return `Criteria ${criteria.map(({ id }) => `"${id}"`).join(", ")} reference ${localPath}: Cloud workers cannot read local-only Board data`;
 	}

package/src/engine/makeLaunch.ts

@@ -7,6 +7,7 @@ import { launchRecord } from "#engine/launchRecord.ts";
 import { localOnlyCriteria } from "#engine/localOnlyCriteria.ts";
 import type { EngineState } from "#engine/makeState.ts";
 import { releaseClosedPreparation } from "#engine/releaseClosedPreparation.ts";
+import { saveLaunch } from "#engine/saveLaunch.ts";
 import { submitLaunch } from "#engine/submitLaunch.ts";
 import type { Attempt, FleetRecord } from "#model.ts";
 import type { DecisionResponse } from "#policy.ts";
@@ -14,7 +15,7 @@ import { policyGuidance } from "#policyGuidance.ts";
 import { reportPrompt, withWorkerGuidance } from "#prompt/worker.ts";
 import type { Versioned } from "#storage/model.ts";
 export function makeLaunch(state: EngineState) {
-	const { store, board, policy, sessions, load, save } = state;
+	const { store, board, sessions, load } = state;
 	return Effect.fn("Fleet.launch")(function* (
 		input: Versioned<FleetRecord>,
 		role: "worker" | "repair",
@@ -27,6 +28,7 @@ export function makeLaunch(state: EngineState) {
 		},
 	) {
 		const stored = input;
+		const policy = yield* state.current;
 		const work = yield* board.get(stored.value.workId, { fresh: true });
 		const released = yield* releaseClosedPreparation(state, stored, work);
 		if (released !== undefined) {
@@ -75,22 +77,7 @@ export function makeLaunch(state: EngineState) {
 			submittedAt: policy.now(),
 		};
 		const record = launchRecord(stored.value, launchRole, policy.now(), continuation?.responses);
-		yield* save(
-			stored,
-			{
-				...record,
-				admissionReady: true,
-				attempts: [...record.attempts, attempt],
-				blocker: undefined,
-				launchRetry: undefined,
-				mergeAreasReleased: undefined,
-				mergeReadyAt: undefined,
-				mergeReadyHead: undefined,
-				pendingAnswers: undefined,
-				stage: "executing",
-			},
-			{ quota, role: launchRole },
-		);
+		yield* saveLaunch(state, stored, record, attempt, { priority: work.priority, quota, role: launchRole });
 		const submitted =
 			sessionId === undefined
 				? sessions.start({ cwd: stored.value.cwd, operationId: attempt.operationId, prompt: workerPrompt, settings })

package/src/engine/makeState.ts

@@ -6,11 +6,18 @@ import { originalWork } from "#engine/originalWork.ts";
 import { ReportInspection } from "#engine/ReportInspection.ts";
 import { FleetRepository } from "#engine/repository.ts";
 import type { Attempt, FleetRecord } from "#model.ts";
-import { BoardGateway, type BoardWork, type Decision, FleetIntegrations, FleetPolicy } from "#policy.ts";
+import { BoardGateway, type BoardWork, type Decision, type FleetConfiguration, FleetIntegrations, FleetPolicy } from "#policy.ts";
 import { DEFAULT_AREA_MERGE_WAIT_MS } from "#scheduling/areas.ts";
 import type { SessionReceipt } from "#session/schema.ts";
 import { SessionService } from "#session/service.ts";
-import type { Versioned } from "#storage/model.ts";
+import type { AdmissionLimits, Versioned } from "#storage/model.ts";
+export interface LaunchAdmission {
+	readonly ignoreAreas?: boolean;
+	readonly implementer?: boolean;
+	readonly overLimit?: boolean;
+	readonly quota: FleetConfiguration["quota"];
+	readonly role: Attempt["role"];
+}
 export const makeState = Effect.gen(function* () {
 	const store = yield* FleetRepository;
 	const board = yield* BoardGateway;
@@ -29,29 +36,13 @@ export const makeState = Effect.gen(function* () {
 				),
 			);
 	}
-	function save(
-		stored: Versioned<FleetRecord>,
-		value: FleetRecord,
-		admission?: {
-			readonly role: Attempt["role"];
-			readonly quota: typeof policy.quota;
-		},
-	) {
-		return store.compareAndSet(
-			value.workId,
-			stored.version,
-			{ ...value, attentionOwner: waitingOwner(value) },
-			admission === undefined
-				? undefined
-				: {
-						scheduling: { areaMergeWaitMs: policy.areaMergeWaitMs ?? DEFAULT_AREA_MERGE_WAIT_MS, now: policy.now() },
-						...(admission.quota.available === undefined
-							? {}
-							: { quota: { available: admission.quota.available, observedAt: admission.quota.observedAt } }),
-						...(policy.executionConcurrency === undefined ? {} : { maxExecuting: policy.executionConcurrency }),
-						...(admission.role !== "worker" || policy.deliveryBacklog === undefined ? {} : { maxBacklog: policy.deliveryBacklog }),
-					},
-		);
+	const current = policy.current ?? Effect.succeed(policy);
+	function save(stored: Versioned<FleetRecord>, value: FleetRecord, admission?: LaunchAdmission) {
+		const record = { ...value, attentionOwner: waitingOwner(value) };
+		if (admission === undefined) {
+			return store.compareAndSet(value.workId, stored.version, record);
+		}
+		return Effect.flatMap(current, (applied) => store.compareAndSet(value.workId, stored.version, record, launchLimits(applied, admission)));
 	}
 	const decision = Effect.fn("Fleet.decision")(function* (
 		stored: Versioned<FleetRecord>,
@@ -84,6 +75,19 @@ export const makeState = Effect.gen(function* () {
 		const published = yield* board.decision(stored.value.workId, value, publicationWork ?? originalWork(stored.value));
 		return yield* save(updated, { ...updated.value, decision: { ...value, published }, decisionPublished: true });
 	});
-	return { board, decision, integrations, launching, launchScope, load, policy, reportInspection, save, sessions, store };
+	return { board, current, decision, integrations, launching, launchScope, load, policy, reportInspection, save, sessions, store };
 });
 export type EngineState = Effect.Success<typeof makeState>;
+
+function launchLimits(policy: FleetConfiguration, admission: LaunchAdmission): AdmissionLimits {
+	const concurrency = admission.overLimit ? undefined : policy.executionConcurrency;
+	return {
+		...(admission.ignoreAreas ? {} : { scheduling: { areaMergeWaitMs: policy.areaMergeWaitMs ?? DEFAULT_AREA_MERGE_WAIT_MS, now: policy.now() } }),
+		...(admission.quota.available === undefined ? {} : { quota: { available: admission.quota.available, observedAt: admission.quota.observedAt } }),
+		...(concurrency === undefined ? {} : { maxExecuting: concurrency }),
+		...(admission.role !== "worker" || admission.overLimit || policy.deliveryBacklog === undefined ? {} : { maxBacklog: policy.deliveryBacklog }),
+		...(concurrency === undefined || !admission.implementer
+			? {}
+			: { implementers: { concurrency, ...(policy.openPullRequests === undefined ? {} : { openPullRequests: policy.openPullRequests }) } }),
+	};
+}

package/src/engine/mergeReadiness.ts

@@ -36,9 +36,10 @@ export const awaitHumanMerge = Effect.fn("Fleet.awaitHumanMerge")(function* (
 	);
 });
 
-export function expireMergeAreas({ save, policy }: EngineState, stored: Versioned<FleetRecord>) {
-	return stored.value.mergeAreasReleased !== true
-		&& mergeWaitExpired(stored.value, policy.now(), policy.areaMergeWaitMs ?? DEFAULT_AREA_MERGE_WAIT_MS)
-		? save(stored, { ...stored.value, mergeAreasReleased: true })
-		: Effect.succeed(stored);
+export function expireMergeAreas({ save, current }: EngineState, stored: Versioned<FleetRecord>) {
+	return Effect.flatMap(current, (policy) =>
+		stored.value.mergeAreasReleased !== true && mergeWaitExpired(stored.value, policy.now(), policy.areaMergeWaitMs ?? DEFAULT_AREA_MERGE_WAIT_MS)
+			? save(stored, { ...stored.value, mergeAreasReleased: true })
+			: Effect.succeed(stored),
+	);
 }

package/src/engine/obtainReview.ts

@@ -13,7 +13,7 @@ import { readReviewerVerdict, reviewerPrompt } from "#prompt/reviewer.ts";
 import type { Versioned } from "#storage/model.ts";
 
 export function obtainReview(state: EngineState) {
-	const { store, policy, sessions, save, board } = state;
+	const { store, sessions, save, board } = state;
 	return Effect.fn("Fleet.obtainReview")(function* (
 		stored: Versioned<FleetRecord>,
 		work: BoardWork,
@@ -25,6 +25,7 @@ export function obtainReview(state: EngineState) {
 			readonly observationRetries?: number;
 		},
 	) {
+		const policy = yield* state.current;
 		if (stored.value.review?.head === result.head) {
 			return stored.value.review.receipt;
 		}

package/src/engine/prepareCommand.ts

@@ -41,7 +41,7 @@ export function prepareCommand(state: EngineState) {
 			return yield* store.insert(current);
 		}
 		if (unusedPreparation(existing.value)) {
-			return yield* save(existing, { ...current, history: existing.value.history });
+			return yield* save(existing, { ...current, dispatchNow: existing.value.dispatchNow, history: existing.value.history });
 		}
 		if (refreshablePreparation(existing.value, work, input)) {
 			return yield* save(existing, {

package/src/engine/readOrContinueReview.ts

@@ -35,7 +35,8 @@ export function readOrContinueReview(state: EngineState) {
 
 function continueReview(state: EngineState) {
 	return Effect.fn("Fleet.continueReview")(function* (stored: Versioned<FleetRecord>, work: BoardWork, result: WorkResult, receipt: SessionReceipt) {
-		const { policy, store, board, save, sessions } = state;
+		const { store, board, save, sessions } = state;
+		const policy = yield* state.current;
 		const reviewerGuidance = yield* policyGuidance(policy, "reviewer");
 		const prompt = [
 			reviewerPrompt({

package/src/engine/readRetry.ts

@@ -39,6 +39,24 @@ function retryAttempts(record: FleetRecord, operationId: string | undefined, ret
 	);
 }
 
+function rateLimitedUntil(kind: "integration" | "provider", error: unknown) {
+	return kind === "integration" ? failureContext(error).retryAt : undefined;
+}
+
+function providerReadClosed(kind: "integration" | "provider", attempt: Attempt | undefined) {
+	return kind === "provider" && (attempt === undefined || !["submitting", "accepted", "running"].includes(attempt.status));
+}
+
+// An integration that names its retry time, such as a GitHub rate limit, is pacing Fleet rather than failing, so the wait does not count toward escalation.
+function waitForRateLimit(state: EngineState, current: Versioned<FleetRecord>, message: string, retryAt: number) {
+	return state.save(current, {
+		...current.value,
+		attentionOwner: "automation",
+		blocker: message,
+		integrationRetry: { error: message, failures: current.value.integrationRetry?.failures ?? 0, retryAt },
+	});
+}
+
 export const readRetry = Effect.fn("Fleet.readRetry")(function* (
 	state: EngineState,
 	current: Versioned<FleetRecord>,
@@ -56,13 +74,17 @@ export const readRetry = Effect.fn("Fleet.readRetry")(function* (
 		return current;
 	}
 	const attempt = current.value.attempts.at(-1);
-	if (kind === "provider" && (attempt === undefined || !["submitting", "accepted", "running"].includes(attempt.status))) {
+	if (providerReadClosed(kind, attempt)) {
 		return undefined;
 	}
 	const previous = kind === "provider" ? attempt?.readRetry : current.value.integrationRetry;
 	if (retryPending(state, current.value)) {
 		return current;
 	}
+	const limitedUntil = rateLimitedUntil(kind, error);
+	if (limitedUntil !== undefined) {
+		return yield* waitForRateLimit(state, current, failureMessage(error), limitedUntil);
+	}
 	const failures = (previous?.failures ?? 0) + 1;
 	if (failures >= 5 && (yield* retryLostReview(state, current.value, error))) {
 		return yield* state.load(current.value.workId);

package/src/engine/reconcileAttempt.ts

@@ -5,9 +5,10 @@ import type { Attempt, FleetRecord } from "#model.ts";
 import { reportPrompt } from "#prompt/worker.ts";
 import type { Versioned } from "#storage/model.ts";
 
-export function reconcileAttempt({ sessions, policy, board }: EngineState) {
+export function reconcileAttempt({ sessions, current, board }: EngineState) {
 	return Effect.fn("Fleet.reconcileAttempt")(function* (stored: Versioned<FleetRecord>, attempt: Attempt) {
 		const work = yield* board.get(stored.value.workId);
+		const policy = yield* current;
 		const authorized = briefApproved(work) && !briefChanged(stored.value, work);
 		const preparedPrompt = stored.value.deliverable === "report" ? reportPrompt(stored.value.prompt) : stored.value.prompt;
 		const prompt = attempt.prompt ?? (attempt.role === "worker" ? preparedPrompt : undefined);

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);
+});