@shivaedev/work-fleet 0.0.0 → 0.1.1

package/src/engine/workerReport.ts

@@ -0,0 +1,54 @@
+import { Effect, Result } from "effect";
+import { BadRequest, Conflict } from "@shivaedev/platform/errors/taxonomy.ts";
+import type { DecisionCode } from "#DecisionCode.ts";
+import { failureCode } from "#engine/failureCode.ts";
+import { withFailureContext } from "#engine/failureContext.ts";
+import { makeLaunch } from "#engine/makeLaunch.ts";
+import type { EngineState } from "#engine/makeState.ts";
+import type { FleetError } from "#errors.ts";
+import { resultReport } from "#host/resultReport.ts";
+import { executing, type FleetRecord } from "#model.ts";
+import type { DecisionResponse } from "#policy.ts";
+import type { Versioned } from "#storage/model.ts";
+
+const correctionPrompt = [
+	"Your completed turn did not contain a valid worker report. Reply only with a corrected report using the result and evidence from that turn.",
+	"Include exactly one FLEET_HEAD line containing the full 40-character head SHA of the existing PR, or the exact checked main SHA for no change, immediately before the final FLEET_PR line.",
+	"The FLEET_PR value must be the existing GitHub PR URL or none. Do not add text after it. The required ending is:",
+	"FLEET_HEAD: <sha>",
+	"FLEET_PR: <url or none>",
+].join("\n");
+
+export const workerReportFailure = Effect.fn("Fleet.workerReportFailure")(function* (record: FleetRecord, code: DecisionCode | undefined) {
+	const latest = record.attempts.at(-1);
+	if (record.deliverable === "report" || latest?.role === "reviewer" || latest?.status !== "completed" || executing(record)) {
+		return undefined;
+	}
+	const parsed = yield* resultReport(latest.output ?? "").pipe(Effect.result);
+	if (Result.isFailure(parsed)) {
+		return failureCode(parsed.failure) === code ? parsed.failure : undefined;
+	}
+	return code !== undefined && ["worker-report-head-moved", "worker-report-merged-head-mismatch"].includes(code)
+		? withFailureContext(new Conflict({ message: "The reported head changed; request a corrected worker report" }), { code })
+		: undefined;
+});
+
+export function correctWorkerReport(state: EngineState) {
+	return Effect.fn("Fleet.correctWorkerReport")(function* (
+		stored: Versioned<FleetRecord>,
+		failure: FleetError,
+		responses?: readonly DecisionResponse[],
+	) {
+		const latest = stored.value.attempts.at(-1);
+		if (latest?.receipt === undefined || latest.role === "reviewer" || latest.status !== "completed") {
+			return yield* new BadRequest({ message: "Report execution lacks a completed receipt" });
+		}
+		if (responses === undefined && latest.prompt?.startsWith(correctionPrompt)) {
+			return yield* state.decision(stored, failureCode(failure), failure.message, "Retry to request a corrected worker report or safely release");
+		}
+		return yield* makeLaunch(state)(stored, latest.role, correctionPrompt, {
+			responses: responses ?? stored.value.responses ?? [],
+			sessionId: latest.receipt.sessionId,
+		});
+	});
+}

package/src/errors.ts

@@ -0,0 +1,7 @@
+import { Schema } from "effect";
+import { BadRequest, Conflict, Forbidden, NotFound, ServiceUnavailable } from "@shivaedev/platform/errors/taxonomy.ts";
+
+export const fleetRejections = { BadRequest, Conflict, Forbidden, NotFound, ServiceUnavailable };
+export const FleetError = Schema.Union(Object.values(fleetRejections));
+export type FleetError = typeof FleetError.Type;
+export const isFleetError = Schema.is(FleetError);

package/src/exposeFailure.ts

@@ -0,0 +1,30 @@
+import { Effect } from "effect";
+import { Conflict, Forbidden, ServiceUnavailable } from "@shivaedev/platform/errors/taxonomy.ts";
+import { rpcBoundary } from "@shivaedev/platform/rpc-server/boundary.ts";
+import { failureMessage } from "#engine/failureMessage.ts";
+import { FleetError, isFleetError } from "#errors.ts";
+import { StorageAdmission, StorageCapacity, StorageConflict, StorageQuota } from "#storage/errors.ts";
+
+function rejection(error: unknown): FleetError {
+	if (isFleetError(error)) {
+		return error;
+	}
+	const message = failureMessage(error);
+	if (error instanceof StorageConflict) {
+		return new Conflict({ message });
+	}
+	if (error instanceof StorageAdmission || error instanceof StorageCapacity || error instanceof StorageQuota) {
+		return new Forbidden({ message });
+	}
+	return new ServiceUnavailable({ message });
+}
+
+export function exposeFailure<A, E, R>(effect: Effect.Effect<A, E, R>) {
+	return effect.pipe(
+		Effect.mapError(rejection),
+		rpcBoundary(FleetError, {
+			message: "The integration is unavailable; inspect runtime diagnostics",
+			unexpected: (message) => new ServiceUnavailable({ message }),
+		}),
+	);
+}

package/src/fleet.ts

@@ -0,0 +1,50 @@
+import { Effect } from "effect";
+import { defineService } from "@shivaedev/effect-service/define-service.ts";
+import { closeDecisions } from "#engine/closeDecisions.ts";
+import { continueCommand } from "#engine/continueCommand.ts";
+import { dispatchCommand } from "#engine/dispatchCommand.ts";
+import { ensurePublication } from "#engine/ensurePublication.ts";
+import { makeAdvance } from "#engine/makeAdvance.ts";
+import { makeLaunch } from "#engine/makeLaunch.ts";
+import { makeState } from "#engine/makeState.ts";
+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 { FleetRepository } from "#engine/repository.ts";
+import { resolveCommand } from "#engine/resolveCommand.ts";
+import { cleanupSessions } from "#engine/sessionCleanup.ts";
+import { BoardGateway, FleetIntegrations, FleetPolicy } from "#policy.ts";
+import type { Preparation } from "#preparation/schema.ts";
+import type { LaunchSettings } from "#session/schema.ts";
+import { SessionService } from "#session/service.ts";
+export interface PrepareWork {
+	readonly cwd: string;
+	readonly launch?: LaunchSettings | undefined;
+	readonly preparation: Preparation;
+	readonly prompt: string;
+	readonly workId: string;
+}
+export const Fleet = defineService({
+	id: "@shivaedev/work-fleet/Fleet",
+	initialize: Effect.gen(function* () {
+		const state = yield* makeState;
+		const launch = makeLaunch(state);
+		return { ...state, advance: makeAdvance(state, launch), launch };
+	}),
+	methods: (state) => ({
+		continue: continueCommand(state, state.launch),
+		dispatch: dispatchCommand(state, state.launch),
+		get: (workId: string) => state.load(workId),
+		hasLaunchRetry: () => state.store.hasLaunchRetry(),
+		list: () => state.store.list(),
+		prepare: (input: PrepareWork) => prepareCommand(state)(input).pipe(Effect.flatMap(closeDecisions(state)), Effect.flatMap(cleanupSessions(state))),
+		publishDecision: (workId: string) => state.load(workId).pipe(Effect.flatMap((stored) => ensurePublication(state)(stored, true))),
+		queueAnswer: queueAnswerCommand(state),
+		reassign: reassignCommand(state),
+		reconcile: (workId: string) => reconcileCommand(state, state.advance)(workId).pipe(Effect.flatMap(cleanupSessions(state))),
+		resolve: (workId: string, decisionId: string, responseId: string) =>
+			resolveCommand(state)(workId, decisionId, responseId).pipe(Effect.flatMap(cleanupSessions(state))),
+	}),
+	requires: [FleetRepository, BoardGateway, FleetPolicy, FleetIntegrations, SessionService],
+});

package/src/fleetRecords.ts

@@ -0,0 +1,4 @@
+import { Schema } from "effect";
+import { collection } from "@shivaedev/effect-contract/keys.ts";
+
+export const fleetRecords = collection("fleet", Schema.String);

package/src/host/actionCommands.ts

@@ -0,0 +1,77 @@
+import { Console, Effect, Option } from "effect";
+import * as Argument from "effect/cli/Argument";
+import * as Command from "effect/cli/Command";
+import * as Flag from "effect/cli/Flag";
+import { answerText } from "#host/answerText.ts";
+import { board, config, port } from "#host/cliOptions.ts";
+import { continuationMessage } from "#host/continuationMessage.ts";
+import { daemonRequest } from "#host/daemonClient.ts";
+
+export const continueCommand = Command.make(
+	"continue",
+	{ 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] }));
+		yield* Console.log(`${value.workId} ${value.stage}${value.blocker === undefined ? "" : `: ${value.blocker}`}`);
+	}),
+).pipe(
+	Command.withDescription("Continue terminal needs-human or completed work on its existing worker thread; read the message from stdin if omitted"),
+);
+
+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 }));
+		for (const value of released) {
+			yield* Console.log(`${value.workId} ${value.stage}${value.blocker === undefined ? "" : `: ${value.blocker}`}`);
+		}
+	}),
+).pipe(Command.withDescription("Safely release terminal needs-human items and record their closing Board responses"));
+
+export const reassignCommand = Command.make(
+	"reassign",
+	{
+		board,
+		config,
+		id: Argument.String("id"),
+		port,
+		question: Argument.String("decision-id"),
+		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 }),
+		);
+		yield* Console.log(`${value.workId} ${value.stage} (waiting on ${value.attentionOwner})`);
+	}),
+).pipe(Command.withDescription("Reassign the exact waiting decision to its next actor"));
+
+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", {}));
+		for (const result of results) {
+			yield* result.error ? Console.error(result.message) : Console.log(result.message);
+		}
+	}),
+).pipe(Command.withDescription("Name existing Fleet Cloud threads after their Board work, best-effort"));
+
+export const answerCommand = Command.make(
+	"answer",
+	{
+		args: [Argument.String("id"), Argument.String("text").pipe(Argument.optional)] as const,
+		board,
+		config,
+		port,
+		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 detail = (value.pendingAnswers?.length ?? 0) > 0 ? "queued for the next turn" : value.blocker;
+		yield* Console.log(`${value.workId} ${value.stage}${detail === undefined ? "" : `: ${detail}`}`);
+	}),
+).pipe(Command.withDescription("Answer the waiting worker question or Fleet decision; read text from stdin if omitted, or use --release"));

package/src/host/admission.ts

@@ -0,0 +1,130 @@
+import { Effect, FileSystem, Schema } from "effect";
+import { BadRequest, Forbidden } from "@shivaedev/platform/errors/taxonomy.ts";
+import { boardDocuments, boardSnapshot } from "#board/documents.ts";
+import { fleetApproved, fleetLaunch } from "#board/fleetField.ts";
+import { inBoardReadPass, workMetadata } from "#board/readPass.ts";
+import { briefChanged } from "#engine/boardBrief.ts";
+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 { BoardGateway, type BoardWork } from "#policy.ts";
+import type { Preparation } from "#preparation/schema.ts";
+import { workerPrompt } from "#prompt/worker.ts";
+import { LaunchSettings } from "#session/schema.ts";
+
+// Workers start from current main, so the whole repository is their scope and preparation pins only the base.
+function preparation(main: MainSnapshot): Preparation {
+	return {
+		baselinePaths: [],
+		baseRevision: main.revision,
+		configuration: [],
+		contextComplete: false,
+		dependencyPaths: [],
+		observedAt: main.observedAt,
+		ownedPaths: ["."],
+		qualityPaths: [],
+		setupPaths: [],
+		sourcePaths: [],
+		validation: [],
+	};
+}
+
+function launchPrompt(host: FleetHost, work: BoardWork): string {
+	return host.provider === "cloud" && host.worker !== undefined
+		? workerPrompt({
+				branch: `${host.worker.branchPrefix}${work.workId}`,
+				deliverable: work.deliverable,
+				sharedEnvironment: host.worker.sharedEnvironment,
+				task: work.context,
+				workId: work.workId,
+			})
+		: work.context;
+}
+
+const taskLaunch = Effect.fn("FleetHost.taskLaunch")(function* (work: BoardWork) {
+	const override = fleetLaunch(yield* workMetadata(work));
+	return yield* override === undefined
+		? Effect.succeed(undefined)
+		: Schema.decodeUnknownEffect(LaunchSettings)(override).pipe(
+				Effect.mapError(() => new BadRequest({ message: `${work.workId} has an invalid fleet-launch; use model, effort and serviceTier strings` })),
+			);
+});
+
+function unlaunched(record: FleetRecord) {
+	return record.stage === "prepared" && record.attempts.length === 0;
+}
+
+function stalePreparation(record: FleetRecord, work: BoardWork, main: MainSnapshot) {
+	return unlaunched(record) && (briefChanged(record, work) || record.preparation.baseRevision !== main.revision);
+}
+
+export type Approval = "board" | "explicit";
+
+export const prepareApproved = Effect.fn("FleetHost.prepareApproved")(function* (
+	host: FleetHost,
+	work: BoardWork,
+	record: FleetRecord | undefined,
+	approval: Approval,
+) {
+	if (record?.stage === "prepared" && record.launchRetry !== undefined) {
+		return;
+	}
+	const fleet = yield* Fleet;
+	const main = yield* MainSource;
+	const snapshot = yield* main.current;
+	const reapproved = record !== undefined && approval === "explicit" && (record.stage === "released" || briefChanged(record, work));
+	if (record !== undefined && !reapproved && !stalePreparation(record, work, snapshot)) {
+		return;
+	}
+	yield* fleet.prepare({
+		cwd: workerCwd(host, main.repositoryRoot),
+		launch: yield* taskLaunch(work),
+		preparation: preparation(snapshot),
+		prompt: launchPrompt(host, work),
+		workId: work.workId,
+	});
+});
+
+export const approvedWorkIds = Effect.fn("FleetHost.approvedWorkIds")(function* (host: FleetHost) {
+	const fs = yield* FileSystem.FileSystem;
+	const documents = yield* boardDocuments(host.boardDir, yield* fs.realPath(host.boardDir));
+	return documents.flatMap((document) =>
+		document.parsed.fields.id !== undefined && fleetApproved(document.parsed) ? [document.parsed.fields.id] : [],
+	);
+});
+
+export const admitApproved = Effect.fn("FleetHost.admitApproved")(function* (host: FleetHost) {
+	const fleet = yield* Fleet;
+	const board = yield* BoardGateway;
+	yield* (yield* MainSource).refresh;
+	const records = new Map((yield* fleet.list()).map(({ value }) => [value.workId, value]));
+	const fs = yield* FileSystem.FileSystem;
+	const snapshot = yield* boardSnapshot(host.boardDir, yield* fs.realPath(host.boardDir));
+	const failures = Array.from(snapshot.problems.values(), (problem) => problem.message);
+	for (const workId of yield* approvedWorkIds(host)) {
+		const admitted = yield* board.get(workId).pipe(
+			Effect.flatMap((work) => prepareApproved(host, work, records.get(workId), "board")),
+			Effect.result,
+		);
+		if (admitted._tag === "Failure") {
+			failures.push(`${workId}: ${admitted.failure.message}`);
+		}
+	}
+	return failures;
+}, inBoardReadPass);
+
+export const dispatchApproved = Effect.fn("FleetHost.dispatchApproved")(function* (host: FleetHost, workId: string) {
+	const fleet = yield* Fleet;
+	const work = yield* (yield* BoardGateway).get(workId);
+	if (!work.approved) {
+		return yield* Effect.fail(new Forbidden({ message: `${workId} needs "fleet: approved" in its Board frontmatter` }));
+	}
+	yield* (yield* MainSource).refresh;
+	const existing = (yield* fleet.list()).find(({ value }) => value.workId === workId)?.value;
+	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));
+}, inBoardReadPass);

package/src/host/answerText.ts

@@ -0,0 +1,11 @@
+import process from "node:process";
+import { text } from "node:stream/consumers";
+import { Effect } from "effect";
+import { BadRequest } from "@shivaedev/platform/errors/taxonomy.ts";
+
+export function answerText(value: string | undefined) {
+	if (value !== undefined || process.stdin.isTTY) {
+		return Effect.succeed(value ?? "");
+	}
+	return Effect.tryPromise({ catch: () => new BadRequest({ message: "Could not read answer text from stdin" }), try: () => text(process.stdin) });
+}

package/src/host/answerWork.ts

@@ -0,0 +1,104 @@
+import { Effect } from "effect";
+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") }),
+			);
+		}),
+	);
+}
+
+function checkDecision(record: FleetRecord, original: Decision | undefined) {
+	const current = record.decision;
+	if (original !== undefined && (record.stage !== "needs-human" || current === undefined || !sameKind(original, current))) {
+		return Effect.fail(
+			new Conflict({
+				message: `Decision changed: ${record.stage === "needs-human" ? (current?.reason ?? record.blocker ?? record.stage) : (record.blocker ?? record.stage)}`,
+			}),
+		);
+	}
+	return record.stage === "needs-human" && current !== undefined
+		? Effect.void
+		: Effect.fail(new BadRequest({ message: `${record.workId} waits on no answer in stage ${record.stage}` }));
+}
+
+function sameKind(original: Decision, current: Decision) {
+	return original.code === undefined ? original.code === current.code && original.reason === current.reason : original.code === current.code;
+}
+
+function hasResponse(record: FleetRecord, recorded: { readonly decisionId: string; readonly responseId: string }) {
+	const receipts = [...(record.history ?? []).flatMap((cycle) => cycle.responses ?? []), ...(record.responses ?? [])];
+	return receipts.some((receipt) => receipt.decisionId === recorded.decisionId && receipt.responseId === recorded.responseId);
+}
+
+const publishAnswer = Effect.fn("FleetHost.publishAnswer")(function* (
+	host: FleetHost,
+	workId: string,
+	original: Decision | undefined,
+	text: string,
+	release: boolean,
+) {
+	const fleet = yield* Fleet;
+	const stored = yield* fleet.publishDecision(workId);
+	if (canQueueAnswer(stored.value, text, release)) {
+		return yield* new Conflict({ message: "Decision changed" });
+	}
+	yield* checkDecision(stored.value, original);
+	const decision = stored.value.decision;
+	if (decision?.published === undefined) {
+		return yield* new BadRequest({ message: `${workId} has no published question in stage ${stored.value.stage}` });
+	}
+	if (!release && decision.worker !== undefined && !text.trim()) {
+		return yield* new BadRequest({ message: "Supply a nonempty answer for the worker as text or on stdin" });
+	}
+	const responseId = yield* recordDecisionResponse(
+		host.boardDir,
+		{ ...decision, published: decision.published },
+		release ? "release" : "retry",
+		text,
+	).pipe(Effect.catchTag("Conflict", (error) => decisionConflict(fleet, workId, decision.id, error)));
+	return { decisionId: decision.id, responseId };
+});
+
+const decisionConflict = Effect.fn("FleetHost.decisionConflict")(function* (
+	fleet: typeof Fleet.Service,
+	workId: string,
+	decisionId: string,
+	error: Conflict,
+) {
+	const current = (yield* fleet.get(workId)).value;
+	return yield* Effect.fail(
+		current.stage !== "needs-human" || current.decision?.id !== decisionId ? new Conflict({ message: "Decision changed" }) : error,
+	);
+});
+
+function canQueueAnswer(record: FleetRecord, text: string, release: boolean) {
+	return !release && text.trim() !== "" && ["repairing", "executing"].includes(record.stage);
+}

package/src/host/applyReportPatch.ts

@@ -0,0 +1,111 @@
+import { Effect } from "effect";
+import { ReportFileFailure } from "#reportFileFailure.ts";
+
+function lines(text: string) {
+	return text.match(/[^\n]*\n|[^\n]+$/gu) ?? [];
+}
+function invalid(path: string) {
+	return Effect.fail(new ReportFileFailure({ path, reason: "Update diff does not match the reconstructed attachment" }));
+}
+interface Hunk {
+	readonly body: string[];
+	readonly newCount: number;
+	readonly newStart: number;
+	readonly oldCount: number;
+	readonly oldStart: number;
+}
+function readHunk(line: string): Hunk | undefined {
+	const groups = /^@@ -(?<oldStart>\d+)(?:,(?<oldCount>\d+))? \+(?<newStart>\d+)(?:,(?<newCount>\d+))? @@[^\n]*\n?$/u.exec(line)?.groups;
+	return groups === undefined
+		? undefined
+		: {
+				body: [],
+				newCount: Number(groups.newCount ?? 1),
+				newStart: Number(groups.newStart),
+				oldCount: Number(groups.oldCount ?? 1),
+				oldStart: Number(groups.oldStart),
+			};
+}
+const appendLine = Effect.fnUntraced(function* (hunk: Hunk, line: string, path: string) {
+	if (/^\\n?$/u.test(line)) {
+		const previous = hunk.body.pop();
+		if (previous === undefined || !previous.endsWith("\n")) {
+			return yield* invalid(path);
+		}
+		hunk.body.push(previous.slice(0, -1));
+	} else if (/^[ +-]/u.test(line)) {
+		hunk.body.push(line);
+	} else {
+		return yield* invalid(path);
+	}
+});
+const hunks = Effect.fnUntraced(function* (diff: string, path: string) {
+	const result: Hunk[] = [];
+	let current: Hunk | undefined;
+	for (const line of lines(diff)) {
+		if (current === undefined && (line.startsWith("--- ") || line.startsWith("+++ "))) {
+			continue;
+		}
+		const header = readHunk(line);
+		if (header === undefined) {
+			if (current === undefined) {
+				return yield* invalid(path);
+			}
+			yield* appendLine(current, line, path);
+		} else {
+			current = header;
+			result.push(header);
+		}
+	}
+	if (result.length === 0) {
+		return yield* invalid(path);
+	}
+	return result;
+});
+const writeHunk = Effect.fnUntraced(function* (original: string[], output: string[], hunk: Hunk, start: number, path: string) {
+	let cursor = start;
+	let added = 0;
+	for (const line of hunk.body) {
+		const value = line.slice(1);
+		if (!line.startsWith("+")) {
+			if (original[cursor] !== value) {
+				return yield* invalid(path);
+			}
+			cursor += 1;
+		}
+		if (!line.startsWith("-")) {
+			output.push(value);
+			added += 1;
+		}
+	}
+	if (cursor - start !== hunk.oldCount || added !== hunk.newCount) {
+		return yield* invalid(path);
+	}
+	return cursor;
+});
+const applyHunk = Effect.fnUntraced(function* (original: string[], output: string[], hunk: Hunk, cursor: number, path: string) {
+	const start = hunk.oldCount === 0 ? hunk.oldStart : hunk.oldStart - 1;
+	if (start < cursor || start > original.length) {
+		return yield* invalid(path);
+	}
+	for (const line of original.slice(cursor, start)) {
+		output.push(line);
+	}
+	const newStart = hunk.newCount === 0 ? hunk.newStart : hunk.newStart - 1;
+	if (newStart !== output.length) {
+		return yield* invalid(path);
+	}
+	return yield* writeHunk(original, output, hunk, start, path);
+});
+export const applyReportPatch = Effect.fn("Fleet.applyReportPatch")(function* (content: string, diff: string, path = "Attachment") {
+	if (diff === "") {
+		return content;
+	}
+	const original = lines(content);
+	const output: string[] = [];
+	let cursor = 0;
+	for (const hunk of yield* hunks(diff, path)) {
+		cursor = yield* applyHunk(original, output, hunk, cursor, path);
+	}
+	return output.concat(original.slice(cursor)).join("");
+});

package/src/host/cliOptions.ts

@@ -0,0 +1,15 @@
+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";
+
+const { DAEMON_PORT } = diagnosticsApi;
+
+export const board = Flag.Directory("board").pipe(Flag.withDefault(".work"), Flag.withDescription("Board folder holding fleet.config.json"));
+export const config = Flag.File("config").pipe(Flag.optional, Flag.withDescription("Host configuration instead of <board>/fleet.config.json"));
+
+export function host(folder: string, file: Option.Option<string>) {
+	return loadHost(folder, Option.getOrUndefined(file));
+}
+
+export const port = Flag.Int("port").pipe(Flag.withDefault(DAEMON_PORT), Flag.withDescription("Local Fleet daemon port"));

package/src/host/commands.ts

@@ -0,0 +1,63 @@
+import * as NodeServices from "@effect/platform-node/NodeServices";
+import { Console, Effect, Layer } 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 { healthLayer } from "#host/healthLayer.ts";
+import { gitMainSource, type MainSource } from "#host/mainSource.ts";
+import { hostProvider } from "#host/providers.ts";
+import { fleetHostLayer } from "#host/runtime.ts";
+import { statusLayer } from "#host/statusLayer.ts";
+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 main: Layer.Layer<MainSource, unknown>;
+	readonly policy?: Layer.Layer<FleetPolicy>;
+	readonly provider: Layer.Layer<SessionTransport, unknown>;
+}
+
+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 hostScheduler(host: FleetHost) {
+	let reported = new Set<string>();
+	const admission = admitApproved(host).pipe(
+		Effect.catch((error) => Effect.succeed([`admission: ${error.message}`])),
+		Effect.flatMap((failures) =>
+			Effect.gen(function* () {
+				for (const failure of failures.filter((entry) => !reported.has(entry))) {
+					yield* Console.error(`work-fleet: ${failure}`);
+				}
+				reported = new Set(failures);
+			}),
+		),
+	);
+	return run(`${host.interval} seconds`, admission);
+}
+
+export function runFleet(host: FleetHost, parts: HostParts = productionParts(host)) {
+	return Effect.scoped(hostScheduler(host)).pipe(Effect.provide(hostLayer(host, parts)));
+}
+
+export function dispatchWork(host: FleetHost, workId: string, parts: HostParts = productionParts(host)) {
+	return dispatchApproved(host, workId).pipe(Effect.provide(hostLayer(host, parts)));
+}
+
+export function continueWork(host: FleetHost, workId: string, message: string, parts: HostParts = productionParts(host)) {
+	return Effect.gen(function* () {
+		return yield* (yield* Fleet).continue(workId, message);
+	}).pipe(Effect.provide(hostLayer(host, parts)));
+}