@shivaedev/work-fleet 0.0.0 → 0.1.1

package/src/engine/failureOwner.ts

@@ -0,0 +1,10 @@
+import type { AttentionOwner } from "#attention.ts";
+import { failureContext } from "#engine/failureContext.ts";
+import { StorageAdmission, StorageCapacity, StorageQuota } from "#storage/errors.ts";
+
+export function failureOwner(error: unknown): AttentionOwner {
+	if (error instanceof StorageAdmission || error instanceof StorageCapacity || error instanceof StorageQuota) {
+		return "automation";
+	}
+	return failureContext(error).attentionOwner ?? "orchestrator";
+}

package/src/engine/health.ts

@@ -0,0 +1,31 @@
+import { Clock, Context, Effect, Ref } from "effect";
+import type { CapacityRejection, FleetHealth, SourceFailure } from "@shivaedev/work-board/integration/diagnostics.ts";
+import type { SessionObservation } from "#session/schema.ts";
+
+export interface HealthState {
+	readonly lastCapacityRejection: CapacityRejection | null;
+	readonly lastSchedulerPass: number | null;
+}
+export class Health extends Context.Service<Health, Ref.Ref<HealthState>>()("Fleet/Health") {}
+export class HealthSnapshot extends Context.Service<HealthSnapshot, Effect.Effect<FleetHealth, SourceFailure>>()("Fleet/HealthSnapshot") {}
+export class HealthPublication extends Context.Service<HealthPublication, Effect.Effect<void>>()("Fleet/HealthPublication") {}
+
+export const schedulerPassed = Effect.gen(function* () {
+	const health = yield* Effect.serviceOption(Health);
+	if (health._tag === "Some") {
+		const now = yield* Clock.currentTimeMillis;
+		yield* Ref.update(health.value, (state) => ({ ...state, lastSchedulerPass: now }));
+	}
+	const publication = yield* Effect.serviceOption(HealthPublication);
+	if (publication._tag === "Some") {
+		yield* publication.value;
+	}
+});
+
+export const capacityRejected = Effect.fn("Fleet.capacityRejected")(function* (cause: NonNullable<SessionObservation["capacity"]>) {
+	const health = yield* Effect.serviceOption(Health);
+	if (health._tag === "Some") {
+		const now = yield* Clock.currentTimeMillis;
+		yield* Ref.update(health.value, (state) => ({ ...state, lastCapacityRejection: { at: now, cause } }));
+	}
+});

package/src/engine/inspectRenewal.ts

@@ -0,0 +1,64 @@
+import { Effect } from "effect";
+import { Forbidden } from "@shivaedev/platform/errors/taxonomy.ts";
+import { validateResult } from "#completion.ts";
+import type { EngineState } from "#engine/makeState.ts";
+import { observeRenewal, priorBoardWork } from "#engine/observeRenewal.ts";
+import { reserveRenewal } from "#engine/reserveRenewal.ts";
+import type { FleetError } from "#errors.ts";
+import type { FleetRecord } from "#model.ts";
+import type { BoardWork } from "#policy.ts";
+import type { Versioned } from "#storage/model.ts";
+
+export function inspectRenewal(state: EngineState) {
+	const { integrations, save } = state;
+	return Effect.fn("Fleet.inspectRenewal")(function* (stored: Versioned<FleetRecord>, work: BoardWork) {
+		if (stored.value.stage === "released") {
+			return stored;
+		}
+		if (stored.value.deliverable === "report") {
+			return yield* inspectReportRenewal(stored);
+		}
+		const previous = stored.value.result;
+		if (renewalSettled(stored.value)) {
+			return stored;
+		}
+		const worker = stored.value.attempts.findLast((attempt) => attempt.role !== "reviewer");
+		if (worker?.receipt === undefined) {
+			if (previous !== undefined) {
+				return yield* Effect.fail(new Forbidden({ message: "Existing PR has no exact worker receipt; reconcile ownership before renewal" }));
+			}
+			return stored;
+		}
+		const prior = yield* priorBoardWork(stored.value, work);
+		const { observation, observed } = yield* observeRenewal(state)(stored, worker, worker.receipt);
+		const result = yield* integrations
+			.result(prior, observation)
+			.pipe(Effect.mapError(() => new Forbidden({ message: "Existing worker result ownership is unavailable; reconcile before renewal" })));
+		yield* reserveRenewal(state)(previous, result);
+		const validation: Effect.Effect<void, FleetError> = validateResult(observed.value, result);
+		yield* validation.pipe(
+			Effect.mapError(
+				() => new Forbidden({ message: "Observed PR scope exceeds prior preparation; retained its reservation pending an ownership decision" }),
+			),
+		);
+		return yield* save(observed, {
+			...observed.value,
+			result,
+			resultObservations: previous === undefined ? observed.value.resultObservations : [...(observed.value.resultObservations ?? []), previous],
+		});
+	});
+}
+
+function inspectReportRenewal(stored: Versioned<FleetRecord>) {
+	if (stored.value.stage === "released") {
+		return Effect.succeed(stored);
+	}
+	const latest = stored.value.attempts.at(-1);
+	return stored.value.report === undefined && latest?.status === "completed" && latest.output?.trim()
+		? Effect.fail(new Forbidden({ message: "Reconcile the completed report before renewing preparation" }))
+		: Effect.succeed(stored);
+}
+
+function renewalSettled(record: FleetRecord) {
+	return record.result !== undefined && (record.result.kind === "no-change" || record.outcome !== undefined);
+}

package/src/engine/launchInput.ts

@@ -0,0 +1,30 @@
+import { Effect } from "effect";
+import { launchReceipt } from "#engine/launchReceipt.ts";
+import { allAttempts, type FleetRecord } from "#model.ts";
+
+export const launchInput = Effect.fn("Fleet.launchInput")(function* (
+	record: FleetRecord,
+	requestedRole: "worker" | "repair",
+	continuationSessionId?: string,
+) {
+	const latest = record.attempts.at(-1);
+	const emptySession =
+		latest?.role !== "reviewer" && latest?.status === "failed" && latest.receipt === undefined && !latest.sessionCleanupComplete
+			? latest.sessionId
+			: undefined;
+	const retry = record.launchRetry === undefined ? undefined : record.attempts.at(-1);
+	const role = retry?.role === "worker" || retry?.role === "repair" ? retry.role : requestedRole;
+	const original = yield* launchReceipt(record, role);
+	const sessionId =
+		continuationSessionId
+		?? emptySession
+		?? (retry?.sessionId === original?.sessionId ? retry?.sessionId : undefined)
+		?? (role === "repair" ? original?.sessionId : undefined);
+	return {
+		checkFailures: role === "repair" && record.stage === "repairing" ? record.checks?.failedChecks : undefined,
+		prompt: record.launchRetry?.prompt ?? retry?.prompt,
+		role,
+		sessionId: allAttempts(record).some((attempt) => attempt.sessionUnusable && attempt.sessionId === sessionId) ? undefined : sessionId,
+		settings: retry?.settings,
+	};
+});

package/src/engine/launchObservationRetries.ts

@@ -0,0 +1,5 @@
+import type { FleetRecord } from "#model.ts";
+
+export function launchObservationRetries(record: FleetRecord, requested?: number): number | undefined {
+	return requested ?? (record.launchRetry === undefined ? undefined : record.attempts.at(-1)?.observationRetries);
+}

package/src/engine/launchReceipt.ts

@@ -0,0 +1,14 @@
+import { Effect } from "effect";
+import { Forbidden } from "@shivaedev/platform/errors/taxonomy.ts";
+import { allAttempts, executing, type FleetRecord } from "#model.ts";
+
+export const launchReceipt = Effect.fn("Fleet.launchReceipt")(function* (record: FleetRecord, role: "worker" | "repair") {
+	if (executing(record)) {
+		return yield* Effect.fail(new Forbidden({ message: "Reconcile terminal execution before launching another turn" }));
+	}
+	const original = allAttempts(record).findLast((previous) => previous.role !== "reviewer" && previous.receipt !== undefined)?.receipt;
+	if (role === "repair" && original === undefined) {
+		return yield* Effect.fail(new Forbidden({ message: "Repair requires an existing worker receipt" }));
+	}
+	return original;
+});

package/src/engine/launchRecord.ts

@@ -0,0 +1,10 @@
+import { continuedRecord } from "#engine/continuedRecord.ts";
+import type { FleetRecord } from "#model.ts";
+import type { DecisionResponse } from "#policy.ts";
+
+export function launchRecord(record: FleetRecord, role: "worker" | "repair", now: number, responses?: readonly DecisionResponse[]): FleetRecord {
+	if (responses !== undefined) {
+		return { ...record, decision: undefined, responses };
+	}
+	return role === "repair" && ["needs-human", "completed"].includes(record.stage) ? continuedRecord(record, now) : record;
+}

package/src/engine/localOnlyCriteria.ts

@@ -0,0 +1,14 @@
+import { Effect } from "effect";
+import { workMetadata } from "#board/readPass.ts";
+import type { BoardWork } from "#policy.ts";
+
+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)) ?? [];
+	if (criteria.length > 0) {
+		return `Criteria ${criteria.map(({ id }) => `"${id}"`).join(", ")} reference ${localPath}: Cloud workers cannot read local-only Board data`;
+	}
+	return undefined;
+});

package/src/engine/makeAdopt.ts

@@ -0,0 +1,57 @@
+import { Effect, Result } from "effect";
+import { BadRequest } from "@shivaedev/platform/errors/taxonomy.ts";
+import { validateResult } from "#completion.ts";
+import { authorizeBriefContext } from "#engine/boardBrief.ts";
+import { completeReport } from "#engine/completeReport.ts";
+import { failureCode } from "#engine/failureCode.ts";
+import type { EngineState } from "#engine/makeState.ts";
+import { correctWorkerReport, workerReportFailure } from "#engine/workerReport.ts";
+import type { FleetRecord } from "#model.ts";
+import type { BoardWork } from "#policy.ts";
+import type { Versioned } from "#storage/model.ts";
+export function makeAdopt(state: EngineState) {
+	const { integrations, save } = state;
+	return Effect.fn("Fleet.makeAdopt")(function* (stored: Versioned<FleetRecord>, work: BoardWork) {
+		if (stored.value.stage !== "adopting") {
+			return stored;
+		}
+		yield* authorizeBriefContext(stored.value, work);
+		if (stored.value.deliverable === "report") {
+			return yield* completeReport(state)(stored, work);
+		}
+		const latest = stored.value.attempts.at(-1);
+		if (latest?.receipt === undefined) {
+			return yield* Effect.fail(new BadRequest({ message: "Terminal execution lacks receipt" }));
+		}
+		const adopted = yield* integrations
+			.result(work, {
+				execution: "completed",
+				output: latest.output ?? "",
+				provisioning: "unknown",
+				receipt: latest.receipt,
+			})
+			.pipe(Effect.result);
+		if (Result.isFailure(adopted)) {
+			const failure = yield* workerReportFailure(stored.value, failureCode(adopted.failure));
+			if (failure !== undefined) {
+				return yield* correctWorkerReport(state)(stored, failure);
+			}
+			return yield* Effect.fail(adopted.failure);
+		}
+		const result = adopted.success;
+		yield* validateResult(stored.value, result);
+		if (
+			latest.role === "repair"
+			&& latest.checkFailures !== undefined
+			&& result.kind === "change"
+			&& stored.value.result?.kind === "change"
+			&& result.pr === stored.value.result.pr
+			&& result.head === stored.value.result.head
+			&& stored.value.review?.head === result.head
+			&& stored.value.review.verdict === "approved"
+		) {
+			return yield* save(stored, { ...stored.value, checks: undefined, result, stage: "validating" });
+		}
+		return yield* save(stored, { ...stored.value, checks: undefined, result, review: undefined, stage: "reviewing" });
+	});
+}

package/src/engine/makeAdvance.ts

@@ -0,0 +1,84 @@
+import { Effect } from "effect";
+import { authorizeBriefContext } from "#engine/boardBrief.ts";
+import { closeDecisions } from "#engine/closeDecisions.ts";
+import { deliverPendingAnswers } from "#engine/deliverPendingAnswers.ts";
+import { makeAdopt } from "#engine/makeAdopt.ts";
+import { makeDeliver } from "#engine/makeDeliver.ts";
+import { makeHuman } from "#engine/makeHuman.ts";
+import type { makeLaunch } from "#engine/makeLaunch.ts";
+import { makeObserve } from "#engine/makeObserve.ts";
+import { makeReview } from "#engine/makeReview.ts";
+import type { EngineState } from "#engine/makeState.ts";
+import { makeValidate } from "#engine/makeValidate.ts";
+import { reconcileBrief } from "#engine/refreshBrief.ts";
+import { releaseClosedPreparation } from "#engine/releaseClosedPreparation.ts";
+import type { FleetRecord } from "#model.ts";
+import type { Versioned } from "#storage/model.ts";
+export function makeAdvance(state: EngineState, launch: ReturnType<typeof makeLaunch>) {
+	return Effect.fn("Fleet.advance")(function* (workId: string) {
+		let stored = yield* state.load(workId);
+		stored = yield* closeDecisions(state)(stored);
+		if (["completed", "released"].includes(stored.value.stage)) {
+			return stored;
+		}
+		if (stored.value.stage === "needs-human") {
+			stored = yield* makeDeliver(state)(stored);
+			stored = (yield* releaseClosedPreparation(state, stored, yield* state.board.get(workId))) ?? stored;
+		}
+		stored = yield* makeHuman(state)(stored);
+		if (stored.value.stage === "executing" && stored.value.attempts.at(-1)?.receipt === undefined) {
+			stored = yield* reconcileBrief(state, stored);
+			if (stored.value.stage === "needs-human") {
+				return stored;
+			}
+		}
+		stored = yield* makeObserve(state)(stored);
+		const answered = yield* deliverPendingAnswers(state, launch, stored);
+		if (answered !== undefined) {
+			return answered;
+		}
+		return yield* advanceObserved(state, launch)(stored);
+	});
+}
+
+function advanceObserved(state: EngineState, launch: ReturnType<typeof makeLaunch>) {
+	return Effect.fn("Fleet.advanceObserved")(function* (input: Versioned<FleetRecord>) {
+		let stored = input;
+		stored = yield* makeDeliver(state)(stored);
+		if (stored.value.stage === "needs-human") {
+			stored = (yield* releaseClosedPreparation(state, stored, yield* state.board.get(stored.value.workId))) ?? stored;
+		}
+		stored = yield* reconcileBrief(state, stored);
+		return yield* advanceExecution(state, launch)(stored);
+	});
+}
+
+function advanceExecution(state: EngineState, launch: ReturnType<typeof makeLaunch>) {
+	return Effect.fn("Fleet.advanceExecution")(function* (input: Versioned<FleetRecord>) {
+		let stored = input;
+		if (["completed", "released", "prepared", "needs-human"].includes(stored.value.stage)) {
+			return stored;
+		}
+		const work = yield* state.board.get(stored.value.workId);
+		yield* authorizeBriefContext(stored.value, work);
+		stored = yield* makeAdopt(state)(stored, work);
+		stored = yield* makeDeliver(state)(stored);
+		stored = yield* makeReview(state)(stored, work);
+		if (stored.value.stage === "repairing") {
+			stored = yield* makeDeliver(state)(stored);
+			if (stored.value.stage === "released") {
+				return stored;
+			}
+			return yield* launch(stored, "repair", stored.value.checks?.repairPrompt ?? stored.value.review?.repairPrompt ?? stored.value.prompt);
+		}
+		stored = yield* makeValidate(state)(stored, work);
+		if (stored.value.stage === "repairing") {
+			stored = yield* makeDeliver(state)(stored);
+			if (stored.value.stage === "released") {
+				return stored;
+			}
+			return yield* launch(stored, "repair", stored.value.checks?.repairPrompt ?? "Fix required checks");
+		}
+		return yield* makeDeliver(state)(stored).pipe(Effect.flatMap(closeDecisions(state)));
+	});
+}

package/src/engine/makeDeliver.ts

@@ -0,0 +1,114 @@
+import { Effect, Result } from "effect";
+import { validateChecks, validateReview } from "#completion.ts";
+import { authorizeBriefContext } from "#engine/boardBrief.ts";
+import { failureCode } from "#engine/failureCode.ts";
+import type { EngineState } from "#engine/makeState.ts";
+import { awaitHumanMerge, expireMergeAreas } from "#engine/mergeReadiness.ts";
+import { observeDeliveryFailure } from "#engine/observeDeliveryFailure.ts";
+import { releaseClosedPreparation } from "#engine/releaseClosedPreparation.ts";
+import { settleMergedDelivery } from "#engine/settleMergedDelivery.ts";
+import { executing, type FleetRecord } from "#model.ts";
+import type { BoardWork, ChangeResult, WorkResult } from "#policy.ts";
+import type { Versioned } from "#storage/model.ts";
+
+export function makeDeliver(state: EngineState) {
+	return Effect.fn("Fleet.makeDeliver")(function* (stored: Versioned<FleetRecord>) {
+		const record = stored.value;
+		const result = record.result;
+		if (["completed", "released", "prepared"].includes(record.stage) || result === undefined) {
+			return stored;
+		}
+		if (executing(record)) {
+			return result.kind === "change" ? yield* observeDelivery(state, stored, result) : stored;
+		}
+		if (result.kind === "change") {
+			return yield* observeDelivery(state, yield* expireMergeAreas(state, stored), result);
+		}
+		return ["delivering", "needs-human"].includes(record.stage) && !deliveryPending(record) ? yield* continueDelivery(state, stored, result) : stored;
+	});
+}
+
+const continueDelivery = Effect.fn("Fleet.continueDelivery")(function* (
+	state: EngineState,
+	stored: Versioned<FleetRecord>,
+	result: Extract<WorkResult, { readonly kind: "no-change" }>,
+) {
+	const record = stored.value;
+	const work = yield* state.board.get(record.workId);
+	const denied = yield* deniedDelivery(state, stored, work);
+	if (denied !== undefined) {
+		return denied;
+	}
+	return record.stage === "delivering"
+		? yield* state.save(stored, { ...record, blocker: undefined, outcome: { evidence: result.evidence }, stage: "completed" })
+		: stored;
+});
+
+function deniedDelivery(state: EngineState, stored: Versioned<FleetRecord>, work: BoardWork) {
+	return authorizeBriefContext(stored.value, work).pipe(
+		Effect.catch((error) =>
+			stored.value.decision === undefined
+				? state.decision(
+						stored,
+						failureCode(error),
+						error.message,
+						"Restore approval for work that is still needed, or release it",
+						undefined,
+						"maintainer",
+					)
+				: state.save(stored, { ...stored.value, blocker: error.message, mergeReadyAt: undefined, mergeReadyHead: undefined }),
+		),
+	);
+}
+
+function deliveryPending(record: FleetRecord): boolean {
+	return record.decision?.worker !== undefined || (record.decision !== undefined && record.decision.published === undefined);
+}
+
+const observeDelivery = Effect.fn("Fleet.observeDelivery")(function* (
+	state: EngineState,
+	stored: Versioned<FleetRecord>,
+	result: typeof ChangeResult.Type,
+) {
+	const record = stored.value;
+	const observed = yield* state.integrations.delivery(result).pipe(Effect.result);
+	if (Result.isSuccess(observed) && observed.success !== undefined && !executing(record)) {
+		return yield* settleMergedDelivery(state, stored, result, observed.success, deliveryPending(record));
+	}
+	const released = yield* releaseClosedDelivery(state, stored);
+	if (released !== undefined) {
+		return released;
+	}
+	if (Result.isFailure(observed)) {
+		return (["delivering", "needs-human"].includes(record.stage)
+			|| (failureCode(observed.failure) === "pr-head-moved" && ["reviewing", "validating"].includes(record.stage) && !executing(record)))
+			&& !deliveryPending(record)
+			? yield* observeDeliveryFailure(state, stored, result, observed.failure)
+			: stored;
+	}
+	if (executing(record)) {
+		return stored;
+	}
+	if (
+		deliveryPending(record)
+		|| !["delivering", "needs-human"].includes(record.stage)
+		|| record.review?.verdict !== "approved"
+		|| record.checks?.passed !== true
+	) {
+		return stored;
+	}
+	const denied = yield* deniedDelivery(state, stored, yield* state.board.get(record.workId));
+	if (denied !== undefined) {
+		return denied;
+	}
+	yield* validateReview(record, record.review, result.head);
+	yield* validateChecks(record.checks, result.head);
+	return yield* awaitHumanMerge(state, stored, result.head);
+});
+
+const releaseClosedDelivery = Effect.fn("Fleet.releaseClosedDelivery")(function* (state: EngineState, stored: Versioned<FleetRecord>) {
+	if (stored.value.stage !== "needs-human" || executing(stored.value)) {
+		return undefined;
+	}
+	return yield* releaseClosedPreparation(state, stored, yield* state.board.get(stored.value.workId));
+});

package/src/engine/makeHuman.ts

@@ -0,0 +1,46 @@
+import { Effect } from "effect";
+import { ensureDecisionOwner } from "#engine/ensureDecisionOwner.ts";
+import { ensurePublication } from "#engine/ensurePublication.ts";
+import { failureMessage } from "#engine/failureMessage.ts";
+import { failureOwner } from "#engine/failureOwner.ts";
+import type { EngineState } from "#engine/makeState.ts";
+import { resolveCommand } from "#engine/resolveCommand.ts";
+import { isFleetError } from "#errors.ts";
+import type { FleetRecord } from "#model.ts";
+import { BoardFailure } from "#policy.ts";
+import { StorageCapacity, StorageQuota } from "#storage/errors.ts";
+import type { Versioned } from "#storage/model.ts";
+
+export function makeHuman(state: EngineState) {
+	return Effect.fn("Fleet.makeHuman")(function* (input: Versioned<FleetRecord>) {
+		let stored = input;
+		let decision = stored.value.decision;
+		if (stored.value.stage !== "needs-human" || decision === undefined) {
+			return stored;
+		}
+		stored = yield* ensurePublication(state)(stored);
+		decision = stored.value.decision ?? decision;
+		const published = stored.value.decision?.published;
+		if (published === undefined) {
+			return stored;
+		}
+		const reading = yield* state.board.readDecision(published);
+		if (reading._tag === "Pending") {
+			return yield* ensureDecisionOwner(state)(stored);
+		}
+		if (reading._tag !== "Response") {
+			const blocker = reading._tag === "Stale" ? reading.reason : "Several Board answers compete; explicitly supersede the other responses";
+			return yield* state.save(stored, { ...stored.value, blocker });
+		}
+		return yield* resolveCommand(state)(stored.value.workId, decision.id, reading.response.id).pipe(
+			Effect.catch((error) =>
+				Effect.gen(function* () {
+					if (isFleetError(error) || error instanceof BoardFailure || error instanceof StorageCapacity || error instanceof StorageQuota) {
+						return yield* state.save(stored, { ...stored.value, attentionOwner: failureOwner(error), blocker: failureMessage(error) });
+					}
+					return yield* Effect.fail(error);
+				}),
+			),
+		);
+	});
+}

package/src/engine/makeLaunch.ts

@@ -0,0 +1,111 @@
+import { Effect } from "effect";
+import { admit } from "#admit.ts";
+import { authorizeBriefContext } from "#engine/boardBrief.ts";
+import { launchInput } from "#engine/launchInput.ts";
+import { launchObservationRetries } from "#engine/launchObservationRetries.ts";
+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 { submitLaunch } from "#engine/submitLaunch.ts";
+import type { Attempt, FleetRecord } from "#model.ts";
+import type { DecisionResponse } from "#policy.ts";
+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;
+	return Effect.fn("Fleet.launch")(function* (
+		input: Versioned<FleetRecord>,
+		role: "worker" | "repair",
+		prompt: string,
+		continuation?: {
+			readonly sessionId: string;
+			readonly responses: readonly DecisionResponse[];
+			readonly stallRecovery?: Attempt["stallRecovery"];
+			readonly observationRetries?: number;
+		},
+	) {
+		const stored = input;
+		const work = yield* board.get(stored.value.workId, { fresh: true });
+		const released = yield* releaseClosedPreparation(state, stored, work);
+		if (released !== undefined) {
+			return released;
+		}
+		yield* authorizeBriefContext(stored.value, work);
+		const localOnly = yield* localOnlyCriteria(work, policy.localOnlyBoardPath);
+		if (localOnly !== undefined) {
+			return yield* state.decision(
+				stored,
+				"incomplete-context",
+				localOnly,
+				"Edit the criteria to use repository fixtures or other data available to Cloud workers, then dispatch again",
+			);
+		}
+		if (stored.value.launchRetry !== undefined && policy.now() < stored.value.launchRetry.retryAt) {
+			return stored;
+		}
+		const {
+			checkFailures,
+			prompt: retryPrompt,
+			role: launchRole,
+			sessionId,
+			settings: retrySettings,
+		} = yield* launchInput(stored.value, role, continuation?.sessionId);
+		const workerPrompt = answeredPrompt(stored.value, prompt, retryPrompt, yield* policyGuidance(policy, "worker"));
+		const quota = yield* policy.refreshQuota === undefined ? Effect.succeed(policy.quota) : policy.refreshQuota();
+		yield* admit(
+			work,
+			(yield* store.list()).map(({ value }) => value),
+			{ ...policy, quota },
+			board.get,
+		);
+		const settings = retrySettings ?? { ...policy.launch, ...stored.value.launch };
+		const attempt: Attempt = {
+			checkFailures,
+			observationRetries: launchObservationRetries(stored.value, continuation?.observationRetries),
+			operationId: policy.operationId(),
+			prompt: workerPrompt,
+			providerFailures: stored.value.launchRetry?.rejections,
+			role: launchRole,
+			settings,
+			stallRecovery: continuation?.stallRecovery,
+			...(sessionId === undefined ? {} : { sessionId }),
+			status: "submitting",
+			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 },
+		);
+		const submitted =
+			sessionId === undefined
+				? sessions.start({ cwd: stored.value.cwd, operationId: attempt.operationId, prompt: workerPrompt, settings })
+				: sessions.continue({ operationId: attempt.operationId, prompt: workerPrompt, sessionId, settings });
+		yield* submitLaunch(state, stored.value, attempt.operationId, submitted);
+		return yield* load(stored.value.workId);
+	});
+}
+
+export function launchPrompt(record: FleetRecord, prompt: string, retryPrompt: string | undefined, guidance?: string): string {
+	const queuedPrompt = retryPrompt ?? prompt;
+	return withWorkerGuidance(record.deliverable === "report" && retryPrompt === undefined ? reportPrompt(queuedPrompt) : queuedPrompt, guidance);
+}
+
+function answeredPrompt(record: FleetRecord, prompt: string, retryPrompt: string | undefined, guidance?: string) {
+	const queuedPrompt = [retryPrompt ?? prompt, ...(record.pendingAnswers ?? [])].join("\n\n");
+	return launchPrompt(record, queuedPrompt, retryPrompt === undefined ? undefined : queuedPrompt, guidance);
+}