@shivaedev/work-fleet 0.0.0 → 0.1.1

package/src/engine/requestRework.ts

@@ -0,0 +1,45 @@
+import { Effect } from "effect";
+import { closeDecisions } from "#engine/closeDecisions.ts";
+import type { EngineState } from "#engine/makeState.ts";
+import type { FleetRecord } from "#model.ts";
+import type { DecisionResponse } from "#policy.ts";
+import type { Versioned } from "#storage/model.ts";
+
+export function requestRework(state: EngineState) {
+	return Effect.fn("Fleet.requestRework")(function* (
+		stored: Versioned<FleetRecord>,
+		body: string,
+		responses?: readonly DecisionResponse[],
+		mainRevision?: string,
+	) {
+		const record = stored.value;
+		const published = record.decision?.published;
+		return yield* state
+			.save(stored, {
+				...record,
+				attentionOwner: undefined,
+				blocker: undefined,
+				checks: undefined,
+				conflictRepairs: mainRevision === undefined ? record.conflictRepairs : [...(record.conflictRepairs ?? []), mainRevision],
+				decision: undefined,
+				decisionAcknowledged: undefined,
+				decisionPublished: undefined,
+				mergeReadyAt: undefined,
+				mergeReadyHead: undefined,
+				prompt: [
+					"Requested changes to the existing PR:",
+					body,
+					`Continue on the same branch and PR (${record.result?.kind === "change" ? record.result.pr : ""}). Do not open another PR.`,
+					"Run focused tests and pnpm ready, push the changes, and watch CI for the new head. Return the required FLEET_HEAD and final FLEET_PR report.",
+				].join("\n\n"),
+				responses: responses ?? record.responses,
+				review: undefined,
+				stage: "repairing",
+				supersededDecisions:
+					responses !== undefined || published === undefined
+						? record.supersededDecisions
+						: [...(record.supersededDecisions ?? []), { published, supersededAt: state.policy.now() }],
+			})
+			.pipe(Effect.flatMap(closeDecisions(state)));
+	});
+}

package/src/engine/reserveRenewal.ts

@@ -0,0 +1,19 @@
+import { Effect } from "effect";
+import { Forbidden } from "@shivaedev/platform/errors/taxonomy.ts";
+import type { EngineState } from "#engine/makeState.ts";
+import type { WorkResult } from "#policy.ts";
+
+export function reserveRenewal({ store }: EngineState) {
+	return Effect.fn("Fleet.reserveRenewal")(function* (previous: WorkResult | undefined, current: WorkResult) {
+		for (const result of [previous, current]) {
+			if (result?.kind === "change") {
+				yield* store.reserveForeign(result.pr, { backlog: true, executing: false });
+			}
+		}
+		if (previous?.kind === "change" && (current.kind !== "change" || current.pr !== previous.pr)) {
+			return yield* Effect.fail(
+				new Forbidden({ message: "Existing PR identity changed; retained known reservations pending an ownership decision" }),
+			);
+		}
+	});
+}

package/src/engine/resolveCommand.ts

@@ -0,0 +1,42 @@
+import { Effect } from "effect";
+import { Conflict } from "@shivaedev/platform/errors/taxonomy.ts";
+import { applyResolution } from "#engine/applyResolution.ts";
+import { closeDecisions } from "#engine/closeDecisions.ts";
+import { ensurePublication } from "#engine/ensurePublication.ts";
+import type { EngineState } from "#engine/makeState.ts";
+import { readResolution } from "#engine/readResolution.ts";
+import type { FleetRecord } from "#model.ts";
+
+export function resolveCommand(state: EngineState) {
+	const { board, policy, load } = state;
+	return Effect.fn("Fleet.resolve")(
+		function* (workId: string, decisionId: string, responseId: string) {
+			const stored = yield* load(workId);
+			if (hasResponse(stored.value, decisionId, responseId)) {
+				return yield* ensurePublication(state)(stored).pipe(Effect.flatMap(closeDecisions(state)));
+			}
+			if (stored.value.decision?.id !== decisionId) {
+				return yield* Effect.fail(new Conflict({ message: "Decision changed" }));
+			}
+			const { action, published, response } = yield* readResolution(board, stored.value.decision, responseId);
+			const receipt = {
+				...(action === undefined ? {} : { action }),
+				decisionId,
+				processedAt: policy.now(),
+				published,
+				questionId: published.questionId,
+				questionRevision: published.revision,
+				responseId,
+				type: response.response.type,
+			};
+			const responses = [...(stored.value.responses ?? []), receipt];
+			return yield* applyResolution(state)(stored, responses, action, response.body, responseId);
+		},
+		(effect) => effect.pipe(Effect.catchTag("StorageConflict", () => Effect.fail(new Conflict({ message: "Decision changed" })))),
+	);
+}
+
+function hasResponse(record: FleetRecord, decisionId: string, responseId: string) {
+	const prior = [...(record.history ?? []).flatMap((cycle) => cycle.responses ?? []), ...(record.responses ?? [])];
+	return prior.some((previous) => previous.decisionId === decisionId && previous.responseId === responseId);
+}

package/src/engine/resolveExecution.ts

@@ -0,0 +1,42 @@
+import { Effect } from "effect";
+import { authorizeResolution } from "#engine/authorizeResolution.ts";
+import type { EngineState } from "#engine/makeState.ts";
+import { releaseExecution } from "#engine/releaseExecution.ts";
+import { retireUnacknowledged } from "#engine/retireUnacknowledged.ts";
+import { executing, type FleetRecord } from "#model.ts";
+import type { Versioned } from "#storage/model.ts";
+
+export const resolveExecution = Effect.fn("Fleet.resolveExecution")(function* (
+	state: EngineState,
+	stored: Versioned<FleetRecord>,
+	action: "retry" | "release",
+) {
+	if (action === "retry") {
+		yield* authorizeResolution(state, stored.value, action);
+	}
+	const fenced = yield* retireUnacknowledged(state, stored);
+	const current = action === "release" && executing(fenced.value) ? yield* releaseExecution(state, fenced) : fenced;
+	if (action === "release") {
+		yield* authorizeResolution(state, current.value, action);
+	}
+	const latest = current.value.attempts.at(-1);
+	if (
+		action === "retry"
+		&& latest?.status === "failed"
+		&& latest.role !== "reviewer"
+		&& latest.receipt === undefined
+		&& latest.sessionId !== undefined
+		&& current.value.decision?.code === "session-active-turn-exhausted"
+	) {
+		return {
+			...current,
+			value: {
+				...current.value,
+				attempts: current.value.attempts.map((attempt) =>
+					attempt.operationId === latest.operationId ? { ...attempt, sessionUnusable: true } : attempt,
+				),
+			},
+		};
+	}
+	return current;
+});

package/src/engine/restartableReview.ts

@@ -0,0 +1,17 @@
+import type { FleetRecord } from "#model.ts";
+import { SessionFailure } from "#session/schema.ts";
+
+export function restartableReview(record: FleetRecord, error: unknown): error is SessionFailure {
+	const attempt = record.attempts.at(-1);
+	return (
+		error instanceof SessionFailure
+		&& record.stage === "reviewing"
+		&& attempt?.role === "reviewer"
+		&& attempt.status === "submitting"
+		&& attempt.receipt === undefined
+		&& (attempt.terminalReceipts?.length ?? 0) === 0
+		&& error.reason === "ambiguous"
+		&& error.code !== "duplicate-turns"
+		&& (error.code === "session-turn-missing" || attempt.sessionId === undefined)
+	);
+}

package/src/engine/resumeAttempt.ts

@@ -0,0 +1,29 @@
+import { Effect } from "effect";
+import { makeLaunch } from "#engine/makeLaunch.ts";
+import type { EngineState } from "#engine/makeState.ts";
+import { obtainReview } from "#engine/obtainReview.ts";
+import { retryPrompt } from "#engine/retryPrompt.ts";
+import type { Attempt, FleetRecord } from "#model.ts";
+import type { Versioned } from "#storage/model.ts";
+
+export const resumeAttempt = Effect.fn("Fleet.resumeAttempt")(function* (
+	state: EngineState,
+	stored: Versioned<FleetRecord>,
+	attempt: Attempt,
+	recovery: { readonly stallRecovery: Attempt["stallRecovery"]; readonly observationRetries?: number },
+) {
+	const sessionId = attempt.receipt?.sessionId;
+	if (sessionId === undefined) {
+		return stored;
+	}
+	const prompt = retryPrompt(stored.value, attempt);
+	if (attempt.role === "reviewer") {
+		const work = yield* state.board.get(stored.value.workId);
+		if (stored.value.result === undefined) {
+			return stored;
+		}
+		yield* obtainReview(state)(stored, work, stored.value.result, { ...recovery, prompt: attempt.prompt ?? prompt, sessionId });
+		return yield* state.load(stored.value.workId);
+	}
+	return yield* makeLaunch(state)(stored, attempt.role, prompt, { ...recovery, responses: stored.value.responses ?? [], sessionId });
+});

package/src/engine/retireUnacknowledged.ts

@@ -0,0 +1,19 @@
+import { Effect } from "effect";
+import type { EngineState } from "#engine/makeState.ts";
+import type { FleetRecord } from "#model.ts";
+import type { Versioned } from "#storage/model.ts";
+
+export function retireUnacknowledged(state: EngineState, stored: Versioned<FleetRecord>) {
+	const attempts = stored.value.attempts.map((attempt) =>
+		attempt.status === "submitting"
+		&& attempt.sessionId === undefined
+		&& attempt.receipt === undefined
+		&& (attempt.terminalReceipts?.length ?? 0) === 0
+			? { ...attempt, status: "failed" as const }
+			: attempt,
+	);
+	// The journal rejects acknowledgements after this CAS, before a turn can start.
+	return attempts.some((attempt, index) => attempt !== stored.value.attempts[index])
+		? state.save(stored, { ...stored.value, attempts })
+		: Effect.succeed(stored);
+}

package/src/engine/retryPrompt.ts

@@ -0,0 +1,14 @@
+import type { Attempt, FleetRecord } from "#model.ts";
+
+export function retryPrompt(previous: FleetRecord, attempt: Attempt) {
+	return [
+		previous.prompt,
+		previous.review?.repairPrompt,
+		previous.checks?.repairPrompt,
+		previous.decision?.code === "worker-question" ? `Worker question:\n${previous.decision.reason}\n\nRecorded answer:` : undefined,
+		attempt.prompt,
+		`Continue on the same branch and PR${previous.result?.kind === "change" ? ` (${previous.result.pr})` : " created by the previous worker"}. Reuse that branch; do not create another branch or PR.`,
+	]
+		.filter(Boolean)
+		.join("\n\n");
+}

package/src/engine/retryTerminal.ts

@@ -0,0 +1,22 @@
+import { Effect } from "effect";
+import { capacityRetry } from "#engine/capacityRetry.ts";
+import type { EngineState } from "#engine/makeState.ts";
+import type { FleetRecord } from "#model.ts";
+import { SessionFailure, type SessionObservation } from "#session/schema.ts";
+
+export const retryTerminal = Effect.fn("Fleet.retryTerminal")(function* (state: EngineState, record: FleetRecord, observation: SessionObservation) {
+	const attempt = record.attempts.at(-1);
+	if (observation.execution !== "failed" || attempt === undefined) {
+		return false;
+	}
+	return yield* capacityRetry(
+		state,
+		record,
+		attempt.operationId,
+		new SessionFailure({
+			capacity: observation.capacity,
+			message: observation.error ?? `Provider turn ${observation.receipt.turnId} failed`,
+			reason: "rejected",
+		}),
+	);
+});

package/src/engine/scheduler.ts

@@ -0,0 +1,87 @@
+import { Effect, Result } from "effect";
+import { inBoardReadPass, withBoardReadPass } from "#board/readPass.ts";
+import { boardCompletionAction } from "#engine/completeBoardWork.ts";
+import { schedulerPassed } from "#engine/health.ts";
+import { pendingAcknowledgements } from "#engine/pendingAcknowledgements.ts";
+import { pendingSessionCleanup } from "#engine/sessionCleanup.ts";
+import { Fleet } from "#fleet.ts";
+import type { FleetRecord } from "#model.ts";
+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 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);
+		dispatched.push(result);
+		if ((Result.isSuccess(result) && result.success.value.launchRetry !== undefined) || (yield* fleet.hasLaunchRetry())) {
+			break;
+		}
+	}
+	return dispatched;
+});
+
+function activeRecords(records: readonly Versioned<FleetRecord>[]) {
+	return records.filter(
+		({ value }) =>
+			!["completed", "released", "prepared"].includes(value.stage)
+			|| boardCompletionAction(value) !== undefined
+			|| pendingAcknowledgements(value).length > 0
+			|| pendingSessionCleanup(value).length > 0,
+	);
+}
+
+const dispatchPrepared = Effect.gen(function* () {
+	const fleet = yield* Fleet;
+	return yield* dispatchRecords(yield* fleet.list());
+});
+const activeWork = Effect.gen(function* () {
+	const fleet = yield* Fleet;
+	return activeRecords(yield* fleet.list());
+});
+export const cycle = inBoardReadPass(
+	Effect.gen(function* () {
+		const fleet = yield* Fleet;
+		const records = yield* fleet.list();
+		const active = activeRecords(records).filter(({ value }) => value.stage !== "prepared");
+		const result = yield* Effect.all(
+			{
+				dispatched: dispatchRecords(records),
+				reconciled: Effect.forEach(active, ({ value }) => fleet.reconcile(value.workId).pipe(Effect.result), {
+					concurrency: "unbounded",
+				}),
+			},
+			{ concurrency: "unbounded" },
+		);
+		yield* schedulerPassed;
+		return result;
+	}),
+);
+export const run = Effect.fn("Fleet.run")(function* <R = never>(
+	interval: Parameters<typeof Effect.sleep>[0],
+	admit: Effect.Effect<void, never, R> = Effect.void,
+) {
+	const fleet = yield* Fleet;
+	const running = new Set<string>();
+	yield* Effect.forever(
+		withBoardReadPass(
+			Effect.gen(function* () {
+				yield* admit;
+				for (const { value } of yield* activeWork) {
+					if (running.has(value.workId)) {
+						continue;
+					}
+					running.add(value.workId);
+					yield* fleet
+						.reconcile(value.workId)
+						.pipe(Effect.ignore, Effect.ensuring(Effect.sync(() => running.delete(value.workId))), Effect.forkScoped);
+				}
+				yield* dispatchPrepared;
+				yield* schedulerPassed;
+			}),
+		).pipe(Effect.andThen(Effect.sleep(interval))),
+	);
+});

package/src/engine/sessionCleanup.ts

@@ -0,0 +1,51 @@
+import { Cause, Effect } from "effect";
+import type { EngineState } from "#engine/makeState.ts";
+import { type Attempt, allAttempts, type FleetRecord } from "#model.ts";
+import type { Versioned } from "#storage/model.ts";
+
+function sessionId(attempt: Attempt) {
+	return attempt.receipt?.sessionId ?? attempt.sessionId;
+}
+
+export function pendingSessionCleanup(record: FleetRecord): readonly string[] {
+	const attempts = allAttempts(record);
+	const terminal = ["completed", "released"].includes(record.stage);
+	const retained = new Set(terminal ? [] : record.attempts.map(sessionId));
+	const eligible = [...(record.history ?? []).flatMap((cycle) => cycle.attempts), ...(terminal ? record.attempts : [])];
+	return [...new Set(eligible.filter((attempt) => !attempt.sessionCleanupComplete).map(sessionId))].filter(
+		(id): id is string =>
+			id !== undefined
+			&& !retained.has(id)
+			&& !attempts.some((attempt) => sessionId(attempt) === id && ["submitting", "accepted", "running"].includes(attempt.status)),
+	);
+}
+
+export function cleanupSessions({ sessions, load, save }: EngineState) {
+	return Effect.fn("Fleet.cleanupSessions")(function* (input: Versioned<FleetRecord>) {
+		let stored = input;
+		for (const id of pendingSessionCleanup(stored.value)) {
+			const result = yield* sessions.archive(id).pipe(Effect.result);
+			if (result._tag === "Failure") {
+				yield* Effect.logWarning("Fleet session cleanup failed; reconciliation will retry", Cause.fail(result.failure)).pipe(
+					Effect.annotateLogs({ sessionId: id }),
+				);
+				continue;
+			}
+			stored = yield* load(input.value.workId);
+			if (!pendingSessionCleanup(stored.value).includes(id)) {
+				continue;
+			}
+			function complete(attempt: Attempt): Attempt {
+				return sessionId(attempt) === id ? { ...attempt, sessionCleanupComplete: true } : attempt;
+			}
+			stored = yield* save(stored, {
+				...stored.value,
+				attempts: stored.value.attempts.map(complete),
+				...(stored.value.history === undefined
+					? {}
+					: { history: stored.value.history.map((cycle) => ({ ...cycle, attempts: cycle.attempts.map(complete) })) }),
+			});
+		}
+		return stored;
+	});
+}

package/src/engine/sessionStatus.ts

@@ -0,0 +1,14 @@
+import type { FleetView } from "#model.ts";
+
+export function sessionStatus(session: (typeof FleetView.Type)["sessions"][number]): string {
+	const times: readonly [string, number | undefined][] = [
+		["last progress", session.lastProgressAt],
+		["Fleet steer requested", session.steeredAt],
+		["Fleet interrupt requested", session.interruptRequestedAt],
+		["Fleet interrupt acknowledged", session.interruptedAt],
+	];
+	return [
+		`session ${session.sessionId} turn ${session.turnId}`,
+		...times.flatMap(([label, time]) => (time === undefined ? [] : [`${label} ${new Date(time).toISOString()}`])),
+	].join("; ");
+}

package/src/engine/settleMergedDelivery.ts

@@ -0,0 +1,31 @@
+import { Effect, Result } from "effect";
+import { validateChecks, validateReview } from "#completion.ts";
+import type { EngineState } from "#engine/makeState.ts";
+import { releaseFinishedWork } from "#engine/releaseFinishedWork.ts";
+import type { FleetRecord } from "#model.ts";
+import type { ChangeResult, Delivery } from "#policy.ts";
+import type { Versioned } from "#storage/model.ts";
+
+export const settleMergedDelivery = Effect.fn("Fleet.settleMergedDelivery")(function* (
+	state: EngineState,
+	stored: Versioned<FleetRecord>,
+	result: typeof ChangeResult.Type,
+	delivery: Delivery,
+	pendingDecision: boolean,
+) {
+	const record = stored.value;
+	yield* state.store.releaseForeign(result.pr);
+	const approved =
+		record.review?.verdict === "approved"
+		&& !pendingDecision
+		&& Result.isSuccess(yield* validateReview(record, record.review, result.head).pipe(Effect.result))
+		&& record.checks !== undefined
+		&& Result.isSuccess(yield* validateChecks(record.checks, result.head).pipe(Effect.result));
+	return approved && delivery.head === result.head
+		? yield* state.save(stored, { ...record, blocker: undefined, outcome: delivery, stage: "completed" })
+		: yield* releaseFinishedWork(
+				state,
+				stored,
+				`PR #${result.pr.split("/").at(-1)} merged by a human at ${delivery.head}; Fleet review covered ${record.review?.head ?? "nothing"}`,
+			);
+});

package/src/engine/submissionFailure.ts

@@ -0,0 +1,47 @@
+import { Effect } from "effect";
+import { capacityRetry } from "#engine/capacityRetry.ts";
+import { failureCode } from "#engine/failureCode.ts";
+import type { EngineState } from "#engine/makeState.ts";
+import { readRetry } from "#engine/readRetry.ts";
+import type { SessionFailure } from "#session/schema.ts";
+import { requestTimedOut } from "#session/transientFailure.ts";
+
+export const submissionFailure = Effect.fn("Fleet.submissionFailure")(function* (
+	state: EngineState,
+	workId: string,
+	operationId: string,
+	error: SessionFailure,
+	recommendation: string,
+) {
+	let current = yield* state.load(workId);
+	if (current.value.decision !== undefined) {
+		return;
+	}
+	if (requestTimedOut(error)) {
+		current = yield* state.save(current, {
+			...current.value,
+			attempts: current.value.attempts.map((attempt) => (attempt.operationId === operationId ? { ...attempt, submissionTimedOut: true } : attempt)),
+		});
+	}
+	if (requestTimedOut(error) || (error.reason === "ambiguous" && error.code === "session-unavailable")) {
+		yield* readRetry(state, current, error, requestTimedOut(error) ? undefined : operationId);
+		return;
+	}
+	if (error.reason !== "rejected" && error.reason !== "unavailable") {
+		return;
+	}
+	if (yield* capacityRetry(state, current.value, operationId, error)) {
+		return;
+	}
+	const acknowledged = current.value.attempts.find((item) => item.operationId === operationId);
+	const unresolvedSession = acknowledged?.receipt !== undefined || (error.reason === "unavailable" && acknowledged?.sessionId !== undefined);
+	const attempts = current.value.attempts.map((item) =>
+		item.operationId === operationId && !unresolvedSession ? { ...item, status: "failed" as const } : item,
+	);
+	yield* state.decision(
+		yield* state.save(current, { ...current.value, attempts }),
+		failureCode(error),
+		error.message,
+		unresolvedSession ? "Reconcile the acknowledged session before retrying" : recommendation,
+	);
+});

package/src/engine/submitLaunch.ts

@@ -0,0 +1,43 @@
+import { Effect, Fiber } from "effect";
+import { capacityRetry } from "#engine/capacityRetry.ts";
+import type { EngineState } from "#engine/makeState.ts";
+import { submissionFailure } from "#engine/submissionFailure.ts";
+import type { FleetRecord } from "#model.ts";
+import type { SessionFailure, SessionReceipt } from "#session/schema.ts";
+
+const handleFailure = Effect.fn("Fleet.handleFailure")(function* (
+	state: EngineState,
+	previous: FleetRecord,
+	operationId: string,
+	error: SessionFailure,
+) {
+	if (yield* capacityRetry(state, previous, operationId, error)) {
+		return;
+	}
+	yield* submissionFailure(state, previous.workId, operationId, error, "Restore provider access and retry this approved work");
+});
+
+export const submitLaunch = Effect.fn("Fleet.submitLaunch")(function* (
+	state: EngineState,
+	previous: FleetRecord,
+	operationId: string,
+	submitted: Effect.Effect<SessionReceipt, SessionFailure>,
+) {
+	yield* Effect.uninterruptibleMask((restore) =>
+		Effect.gen(function* () {
+			state.launching.add(operationId);
+			const submission = yield* restore(
+				submitted.pipe(
+					Effect.catch((error) => handleFailure(state, previous, operationId, error)),
+					Effect.ensuring(Effect.sync(() => state.launching.delete(operationId))),
+				),
+			).pipe(Effect.forkIn(state.launchScope));
+			yield* restore(
+				Fiber.join(submission).pipe(
+					Effect.timeout("1 second"),
+					Effect.catchTag("TimeoutError", () => Effect.void),
+				),
+			).pipe(Effect.onInterrupt(() => Fiber.interrupt(submission)));
+		}),
+	);
+});

package/src/engine/threadNames.ts

@@ -0,0 +1,56 @@
+import { board as boardApi } from "@shivaedev/work-board/integration/board.ts";
+import type { Attempt, FleetRecord } from "#model.ts";
+
+function headingAt(line: string, next: string): string | undefined {
+	const heading = /^ {0,3}#{1,6}[\t ]+(?<title>.+?)(?:[\t ]+#+)?[\t ]*$/u.exec(line)?.groups?.title;
+	if (heading !== undefined) {
+		return heading;
+	}
+	return line.trim() && /^ {0,3}(?:=+|-+)[\t ]*$/u.test(next) ? line.trim() : undefined;
+}
+
+function firstHeading(context: string): string | undefined {
+	const lines = boardApi.metadataParse(context).body.split(/\r?\n/u);
+	let fence: string | undefined;
+	for (const [index, line] of lines.entries()) {
+		const marker = /^ {0,3}(?<fence>`{3,}|~{3,})/u.exec(line)?.groups?.fence;
+		if (marker !== undefined) {
+			if (fence === undefined) {
+				fence = marker;
+			} else if (marker[0] === fence[0] && marker.length >= fence.length) {
+				fence = undefined;
+			}
+			continue;
+		}
+		if (fence !== undefined) {
+			continue;
+		}
+		const heading = headingAt(line, lines[index + 1] ?? "");
+		if (heading !== undefined) {
+			return heading;
+		}
+	}
+	return undefined;
+}
+
+export function threadName(workId: string, context: string | undefined, role: Attempt["role"]): string {
+	const heading = (firstHeading(context ?? "") ?? workId).replace(/\s+/gu, " ").trim();
+	const characters = Array.from(heading);
+	const title = characters.length > 80 ? `${characters.slice(0, 79).join("").trimEnd()}…` : heading;
+	const suffix = { repair: " (repair)", reviewer: " (review)", worker: "" }[role];
+	return `${workId}${suffix}: ${title}`;
+}
+
+export function recordThreadNames(record: FleetRecord) {
+	const cycles = [...(record.history ?? []), record];
+	const names = new Map<string, string>();
+	for (const cycle of cycles) {
+		for (const attempt of cycle.attempts) {
+			const sessionId = attempt.receipt?.sessionId ?? attempt.sessionId;
+			if (sessionId !== undefined && !names.has(sessionId)) {
+				names.set(sessionId, threadName(record.workId, cycle.boardContext, attempt.role));
+			}
+		}
+	}
+	return names;
+}

package/src/engine/views.ts

@@ -0,0 +1,42 @@
+import { waitingOwner } from "#attention.ts";
+import type { Attempt, FleetRecord, FleetViews } from "#model.ts";
+export function views(records: readonly FleetRecord[]): typeof FleetViews.Type {
+	const items = records
+		.filter((record) => record.stage !== "released" || waitingOwner(record) !== undefined)
+		.map((record) => ({
+			attentionOwner: waitingOwner(record),
+			blocker:
+				record.launchRetry === undefined
+					? (record.blocker ?? (record.stage === "completed" ? undefined : record.decision?.reason))
+					: `Waiting for provider capacity; last rejection ${new Date(record.launchRetry.rejectedAt).toISOString()}; retry after ${new Date(record.launchRetry.retryAt).toISOString()}`,
+			decision: record.stage === "completed" ? undefined : record.decision,
+			links: [...(record.report === undefined ? [] : [record.report.sourcePath]), ...(record.result?.kind === "change" ? [record.result.pr] : [])],
+			outcome: record.outcome,
+			sessions: record.attempts.flatMap(sessionView),
+			stage: record.stage,
+			workId: record.workId,
+		}));
+	return {
+		active: items.filter((item) => item.stage !== "completed" && item.attentionOwner === undefined),
+		completed: items.filter((item) => item.stage === "completed" && item.attentionOwner === undefined),
+		waiting: {
+			automation: items.filter((item) => item.attentionOwner === "automation"),
+			maintainer: items.filter((item) => item.attentionOwner === "maintainer"),
+			orchestrator: items.filter((item) => item.attentionOwner === "orchestrator"),
+		},
+	};
+}
+
+function sessionView(attempt: Attempt) {
+	return attempt.receipt === undefined
+		? []
+		: [
+				{
+					...attempt.receipt,
+					interruptedAt: attempt.stallRecovery?.interruptedAt,
+					interruptRequestedAt: attempt.stallRecovery?.interruptRequestedAt,
+					lastProgressAt: attempt.progress?.at,
+					steeredAt: attempt.stallRecovery?.steeredAt,
+				},
+			];
+}