@shivaedev/work-fleet 0.6.0 → 0.7.0

package/src/engine/situations/stop.ts

@@ -0,0 +1,60 @@
+import type { DecisionCode } from "#DecisionCode.ts";
+import { type Situation, stopOnly } from "#engine/situations/choices.ts";
+
+export const stopSituations = {
+	"checks-result-invalid": stopOnly(
+		"Fleet could not read check results because this work has no valid PR or commit.",
+		"Trying again cannot fix this. Stop here so the task can be prepared again with a valid PR.",
+	),
+	"delivery-pr-required": stopOnly(
+		"Fleet has no valid GitHub PR for this work.",
+		"Trying again cannot fix this. Stop here, check who owns the branch, and prepare the task again.",
+	),
+	"duplicate-turns": stopOnly(
+		"The worker service shows several runs for the same step, so Fleet cannot tell which result is right.",
+		"Fleet cannot pick a result itself. Stop here once every one of those runs has finished.",
+	),
+	"foreign-pr": stopOnly(
+		"The reported PR belongs to another repository.",
+		"Fleet cannot move a PR between repositories. Stop here so the task can be prepared again in the right repository.",
+	),
+	"incomplete-context": {
+		details: true,
+		happened: "The task needs information the worker cannot reach.",
+		recommendation:
+			"Trying again cannot fill in the missing information. Stop here, change the task to use data from the repository, and prepare it again.",
+	},
+	"incomplete-observation": {
+		details: true,
+		happened: "Fleet could not get a complete view of the Board or the repository.",
+		recommendation: "Fleet cannot continue from an incomplete view. Stop here so the task can be prepared again.",
+	},
+	"no-change-checks-unconfigured": stopOnly(
+		"The worker changed nothing, and this Fleet setup cannot check a result without changes.",
+		"Trying again cannot verify this result here. Stop here so the task can run where such results can be checked.",
+	),
+	"not-ancestor": stopOnly(
+		"The main branch no longer contains the commit this work was prepared on.",
+		"Fleet cannot move the work onto the new history. Stop here so the task can be prepared again on the current main branch.",
+	),
+	"relevant-change": stopOnly(
+		"Files this work depends on changed on the main branch after it was prepared.",
+		"Fleet cannot refresh the preparation itself. Stop here so the task can be prepared again on the current main branch.",
+	),
+	"report-published": stopOnly(
+		"The report worker published to GitHub, which a report task must not do.",
+		"Fleet cannot undo the publication. Stop here and check what was published.",
+	),
+	"report-too-large": stopOnly(
+		"The worker's report is too large for the Board.",
+		"Fleet cannot shorten a finished report. Stop here so a worker can write a shorter report.",
+	),
+	"result-identity-changed": stopOnly(
+		"The PR or branch for this work was replaced during review.",
+		"Fleet cannot take over a different result. Stop here and check the replacement before preparing the task again.",
+	),
+	"worker-receipt-missing": stopOnly(
+		"Fleet lost the record of which worker run produced this result.",
+		"Fleet cannot prove who owns this result. Stop here and check the branch before preparing the task again.",
+	),
+} satisfies Partial<Record<DecisionCode, Situation>>;

package/src/engine/situations/work.ts

@@ -0,0 +1,94 @@
+import type { DecisionCode } from "#DecisionCode.ts";
+import { CORRECT_REPORT, RUN_AGAIN, type Situation } from "#engine/situations/choices.ts";
+
+export const workSituations = {
+	"approval-required": {
+		happened: "The task is no longer approved on the Board.",
+		recommendation: "Fleet only works on approved tasks. If the task is still needed, approve it on the Board and continue. Otherwise stop here.",
+		retry: { label: "Continue after approval", outcome: "Fleet checks that the task is approved and continues the same work." },
+	},
+	"checks-repair-exhausted": {
+		details: true,
+		happened: "Required checks still fail after three repair attempts.",
+		recommendation:
+			"Fleet will not repair these checks again on its own. Look at the failing checks on the PR. If you fixed the cause, let Fleet check again. Otherwise stop here.",
+		retry: { label: "Check again", outcome: "Fleet reviews the PR and its checks again. If the same checks still fail, Fleet asks you again." },
+	},
+	"delivery-head-mismatch": {
+		happened: "The PR changed after Fleet reviewed it.",
+		recommendation: "Fleet must review the current PR before it can be merged. Fleet recommends reviewing it again.",
+		retry: { label: "Review again", outcome: "Fleet reviews the PR at its current commit and checks it again." },
+	},
+	"empty-report": {
+		happened: "The report worker returned an empty report.",
+		recommendation: "Fleet recommends running the report worker again.",
+		retry: { label: "Write the report again", outcome: "Fleet starts the report worker again." },
+	},
+	"pr-closed": {
+		happened: "The PR was closed without merging.",
+		recommendation: "Check why the PR was closed. If that was a mistake, reopen it on GitHub and let Fleet check again. Otherwise stop here.",
+		retry: { label: "Check the PR again", outcome: "Fleet checks the PR again and continues the same work if it is open." },
+	},
+	"pr-conflicting": {
+		happened: "The PR has merge conflicts with the main branch.",
+		question: "How should Fleet handle the conflicts?",
+		recommendation: "Fleet recommends letting the worker resolve the conflicts. Add notes for the worker in your answer if needed.",
+		retry: {
+			label: "Resolve the conflicts",
+			outcome: "The worker merges main into the same branch, resolves the conflicts and updates the same PR. Your notes go along.",
+		},
+	},
+	"pr-head-moved": {
+		happened: "New commits reached the PR after Fleet reviewed it.",
+		recommendation: "Fleet must review the new commits before the PR can be merged. Fleet recommends reviewing again.",
+		retry: { label: "Review the new commits", outcome: "Fleet reviews the PR again at its latest commit." },
+	},
+	"reviewed-pr-ready": {
+		happened: "The PR passed review and all required checks. It is ready to merge.",
+		question: "Do you want changes before merging?",
+		recommendation:
+			"Merge the PR on GitHub when you are happy with it. Fleet notices the merge and finishes the task. Answer here only to request changes or to stop.",
+		release: { label: "Stop and hand back", outcome: "Fleet stops watching this PR and hands the task back to you. The PR stays open." },
+		retry: {
+			label: "Request changes",
+			outcome: "Write the changes in your answer. The worker makes them on the same branch and PR, then Fleet reviews and checks the PR again.",
+		},
+	},
+	"reviewer-terminal": {
+		happened: "The review stopped before it finished.",
+		recommendation: "Fleet recommends running the review again.",
+		retry: { label: "Review again", outcome: "Fleet starts a new review of the same PR." },
+	},
+	"worker-question": {
+		details: true,
+		happened: "The worker asked a question.",
+		recommendation: "Fleet recommends running the step again.",
+		retry: RUN_AGAIN,
+	},
+	"worker-report-head-invalid": {
+		happened: "The worker's final report does not name the exact commit it pushed.",
+		recommendation: "Fleet recommends asking the worker to fix its report.",
+		retry: CORRECT_REPORT,
+	},
+	"worker-report-head-moved": {
+		happened: "The PR changed after the worker reported its final commit.",
+		recommendation: "Fleet recommends asking the worker to report the PR's current commit.",
+		retry: CORRECT_REPORT,
+	},
+	"worker-report-merged-head-mismatch": {
+		happened: "The PR was merged at a different commit than the worker reported.",
+		recommendation: "Check what was merged on GitHub. Then ask the worker to correct its report, or stop here.",
+		retry: CORRECT_REPORT,
+	},
+	"worker-report-pr-invalid": {
+		happened: "The worker's final report does not contain a valid PR link.",
+		recommendation: "Fleet recommends asking the worker to fix its report.",
+		retry: CORRECT_REPORT,
+	},
+	"worker-terminal": {
+		details: true,
+		happened: "The worker's run stopped before it finished.",
+		recommendation: "Fleet recommends running the step again.",
+		retry: RUN_AGAIN,
+	},
+} satisfies Partial<Record<DecisionCode, Situation>>;

package/src/engine/threadNames.ts

@@ -1,4 +1,4 @@
-import { board as boardApi } from "@shivaedev/work-board/integration/board.ts";
+import { board as boardApi } from "@shivaedev/work-board/server/integration/board.ts";
 import type { Attempt, FleetRecord } from "#model.ts";
 
 function headingAt(line: string, next: string): string | undefined {

package/src/exposeFailure.ts

@@ -1,6 +1,6 @@
 import { Effect } from "effect";
 import { Conflict, Forbidden, ServiceUnavailable } from "@shivaedev/platform/errors/taxonomy.ts";
-import { rpcBoundary } from "@shivaedev/platform/rpc-server/boundary.ts";
+import { rpcBoundary } from "@shivaedev/platform/server/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";

package/src/fleet.ts

@@ -1,5 +1,5 @@
 import { Effect } from "effect";
-import { defineService } from "@shivaedev/effect-service/define-service.ts";
+import { defineService } from "@shivaedev/effect-service/defineService.ts";
 import { admissionOrder } from "#engine/admissionOrder.ts";
 import { closeDecisions } from "#engine/closeDecisions.ts";
 import { continueCommand } from "#engine/continueCommand.ts";

package/src/host/actionCommands.ts

@@ -3,7 +3,7 @@ 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 { board, clientPort, config, port } from "#host/cliOptions.ts";
 import { continuationMessage } from "#host/continuationMessage.ts";
 import { daemonRequest } from "#host/daemonClient.ts";
 
@@ -13,7 +13,7 @@ export const continueCommand = Command.make(
 	Effect.fn("WorkFleetCli.continue")(function* (input) {
 		const message = yield* continuationMessage(Option.getOrUndefined(input.args[1]));
 		const value = yield* daemonRequest(
-			input.port,
+			yield* clientPort(input),
 			(client) => client("fleet.continue", { message, workId: input.args[0] }),
 			`continue ${input.args[0]}`,
 		);
@@ -28,7 +28,7 @@ export const releaseCommand = Command.make(
 	{ board, config, port, workIds: Argument.String("id").pipe(Argument.variadic({ min: 1 })) },
 	Effect.fn("WorkFleetCli.release")(function* (input) {
 		const released = yield* daemonRequest(
-			input.port,
+			yield* clientPort(input),
 			(client) => client("daemon.release", { workIds: input.workIds }),
 			`release ${input.workIds.join(", ")}`,
 		);
@@ -50,7 +50,7 @@ export const reassignCommand = Command.make(
 	},
 	Effect.fn("WorkFleetCli.reassign")(function* (input) {
 		const value = yield* daemonRequest(
-			input.port,
+			yield* clientPort(input),
 			(client) => client("fleet.reassign", { attentionOwner: input.to, decisionId: input.question, workId: input.id }),
 			`reassign ${input.id}`,
 		);
@@ -62,7 +62,7 @@ export const nameThreadsCommand = Command.make(
 	"name-threads",
 	{ board, config, port },
 	Effect.fn("WorkFleetCli.nameThreads")(function* (input) {
-		const results = yield* daemonRequest(input.port, (client) => client("daemon.name-threads", {}), "name-threads");
+		const results = yield* daemonRequest(yield* clientPort(input), (client) => client("daemon.name-threads", {}), "name-threads");
 		for (const result of results) {
 			yield* result.error ? Console.error(result.message) : Console.log(result.message);
 		}
@@ -82,7 +82,7 @@ export const answerCommand = Command.make(
 		const supplied = Option.getOrUndefined(input.args[1]);
 		const text = input.release && supplied === undefined ? "" : yield* answerText(supplied);
 		const value = yield* daemonRequest(
-			input.port,
+			yield* clientPort(input),
 			(client) => client("daemon.answer", { release: input.release, text, workId: input.args[0] }),
 			`answer ${input.args[0]}`,
 		);

package/src/host/cliOptions.ts

@@ -1,15 +1,20 @@
 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/configFile.ts";
+import { readDaemonPort } from "#host/daemonPort.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 board = Flag.Directory("board").pipe(
+	Flag.withDefault(".work"),
+	Flag.withDescription("Board folder holding Fleet configuration and daemon port"),
+);
 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"));
+export const port = Flag.Int("port").pipe(Flag.optional, Flag.withDescription("Override the local Fleet daemon port"));
+
+export function clientPort(input: { readonly board: string; readonly port: Option.Option<number> }) {
+	return readDaemonPort(input.board, Option.getOrUndefined(input.port));
+}

package/src/host/daemon.ts

@@ -1,10 +1,11 @@
 import { Context, Effect, Fiber, Layer } from "effect";
-import { appHost } from "@shivaedev/platform/appHost.ts";
-import { diagnostics as diagnosticsApi } from "@shivaedev/work-board/integration/diagnostics.ts";
+import { appHost } from "@shivaedev/platform/server/appHost.ts";
+import { diagnostics as diagnosticsApi } from "@shivaedev/work-board/server/integration/diagnostics.ts";
 import { type HostParts, hostLayer, hostScheduler, productionParts } from "#host/commands.ts";
 import type { FleetHost } from "#host/config.ts";
 import { DaemonContract, RPC_PATH } from "#host/daemonContract.ts";
 import { daemonHandlers } from "#host/daemonHandlers.ts";
+import { publishDaemonPort } from "#host/daemonPort.ts";
 import { watchedConfig } from "#host/liveConfig.ts";
 import { fleetHandlers } from "#operations.ts";
 
@@ -17,6 +18,7 @@ class Scheduler extends Context.Service<Scheduler, Fiber.Fiber<void, unknown>>()
 
 export function daemonHostOptions(host: FleetHost, parts: HostParts = productionParts(host), port: number = DAEMON_PORT) {
 	return {
+		boardDir: host.boardDir,
 		config: { disablePreemptiveShutdown: true, host: DAEMON_HOST, port },
 		group: DaemonContract,
 		handlers: Layer.merge(fleetHandlers, Layer.unwrap(daemonHandlers(host))),
@@ -33,7 +35,9 @@ export function daemonLayer(host: FleetHost, parts: HostParts = productionParts(
 }
 
 export function daemonHttpLayer(options: ReturnType<typeof daemonHostOptions>) {
-	return appHost({ ...options, services: Layer.empty }).pipe(Layer.provideMerge(options.services));
+	const { boardDir, ...http } = options;
+	const server = appHost({ ...http, services: Layer.empty }).pipe(Layer.provideMerge(options.services));
+	return Layer.effectDiscard(publishDaemonPort(boardDir)).pipe(Layer.provideMerge(server));
 }
 
 export function serveFleet(host: FleetHost, parts: HostParts = productionParts(host), port: number = DAEMON_PORT) {

package/src/host/daemonClient.ts

@@ -3,7 +3,7 @@ import { FetchHttpClient } from "effect/http";
 import { RpcClient, RpcSerialization } from "effect/rpc";
 import { RpcClientError } from "effect/rpc/RpcClientError";
 import { ServiceUnavailable } from "@shivaedev/platform/errors/taxonomy.ts";
-import { diagnostics as diagnosticsApi } from "@shivaedev/work-board/integration/diagnostics.ts";
+import { diagnostics as diagnosticsApi } from "@shivaedev/work-board/server/integration/diagnostics.ts";
 import { isFleetError } from "#errors.ts";
 import { DaemonContract, RPC_PATH } from "#host/daemonContract.ts";
 

package/src/host/daemonContract.ts

@@ -2,7 +2,7 @@ import { Schema } from "effect";
 import { contract } from "@shivaedev/effect-contract/contract.ts";
 import { command, query, stream } from "@shivaedev/effect-contract/operation.ts";
 import { RequestTracing } from "@shivaedev/platform/rpc/middleware.ts";
-import { diagnostics as diagnosticsApi } from "@shivaedev/work-board/integration/diagnostics.ts";
+import { diagnostics as diagnosticsApi } from "@shivaedev/work-board/server/integration/diagnostics.ts";
 import { DispatchRequest } from "#DispatchRequest.ts";
 import { fleetRejections } from "#errors.ts";
 import { DaemonStatus } from "#host/configSettings.ts";

package/src/host/daemonDiagnostics.ts

@@ -1,6 +1,6 @@
 import { Effect } from "effect";
 import { ServiceUnavailable } from "@shivaedev/platform/errors/taxonomy.ts";
-import { diagnostics as diagnosticsApi } from "@shivaedev/work-board/integration/diagnostics.ts";
+import { diagnostics as diagnosticsApi } from "@shivaedev/work-board/server/integration/diagnostics.ts";
 import { failureMessage } from "#engine/failureMessage.ts";
 import { HealthSnapshot } from "#engine/health.ts";
 import { fleetItems } from "#host/fleetItems.ts";

package/src/host/daemonPort.ts

@@ -0,0 +1,50 @@
+import { Effect, FileSystem, Path, Schema } from "effect";
+import { HttpServer } from "effect/http";
+import * as NetAddress from "effect/net/NetAddress";
+import { ServiceUnavailable } from "@shivaedev/platform/errors/taxonomy.ts";
+import { diagnostics as diagnosticsApi } from "@shivaedev/work-board/server/integration/diagnostics.ts";
+
+const PORT_FILE = ".fleet-port";
+const Port = Schema.NumberFromString.pipe(Schema.check(Schema.isInt(), Schema.isBetween({ maximum: 65_535, minimum: 1 })));
+
+export const readDaemonPort = Effect.fn("FleetDaemon.readDaemonPort")(function* (board: string, override?: number) {
+	if (override !== undefined) {
+		return override;
+	}
+	const fs = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	const file = path.join(path.resolve(board), PORT_FILE);
+	const text = yield* fs
+		.readFileString(file)
+		.pipe(
+			Effect.catchTag("PlatformError", (error) =>
+				error.reason._tag === "NotFound"
+					? Effect.succeed(String(diagnosticsApi.DAEMON_PORT))
+					: Effect.fail(new ServiceUnavailable({ message: `Cannot read Fleet daemon port from ${file}: ${error.message}` })),
+			),
+		);
+	return yield* Schema.decodeUnknownEffect(Port)(text.trim()).pipe(
+		Effect.mapError(() => new ServiceUnavailable({ message: `Invalid Fleet daemon port in ${file}` })),
+	);
+});
+
+export const publishDaemonPort = Effect.fn("FleetDaemon.publishDaemonPort")(function* (board: string) {
+	const server = yield* HttpServer.HttpServer;
+	if (!NetAddress.isInetAddress(server.address)) {
+		return yield* Effect.die("Expected a TCP Fleet daemon");
+	}
+	const fs = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	const file = path.join(board, PORT_FILE);
+	const port = String(server.address.port);
+	yield* Effect.acquireRelease(fs.writeFileString(`${file}.tmp`, `${port}\n`).pipe(Effect.andThen(fs.rename(`${file}.tmp`, file))), () =>
+		Effect.gen(function* () {
+			const current = yield* fs
+				.readFileString(file)
+				.pipe(Effect.catchTag("PlatformError", (error) => (error.reason._tag === "NotFound" ? Effect.succeed("") : Effect.fail(error))));
+			if (current.trim() === port) {
+				yield* fs.remove(file, { force: true });
+			}
+		}).pipe(Effect.orDie),
+	);
+});

package/src/host/daemonSnapshots.ts

@@ -1,7 +1,7 @@
 import { Effect, Schedule, Stream } from "effect";
 import { SqlClient } from "effect/sql";
-import { AppChanges } from "@shivaedev/platform/appHost.ts";
 import { ServiceUnavailable } from "@shivaedev/platform/errors/taxonomy.ts";
+import { AppChanges } from "@shivaedev/platform/server/appHost.ts";
 import type { DispatchRequest } from "#DispatchRequest.ts";
 import { fleetRecords } from "#fleetRecords.ts";
 import type { FleetHost } from "#host/config.ts";

package/src/host/follow.ts

@@ -1,12 +1,13 @@
-import { Effect, Stream } from "effect";
-import { diagnostics as diagnosticsApi } from "@shivaedev/work-board/integration/diagnostics.ts";
+import * as NodeServices from "@effect/platform-node/NodeServices";
+import { Console, Effect, Stream } from "effect";
+import { RpcClientError } from "effect/rpc/RpcClientError";
 import { type FleetError, isFleetError } from "#errors.ts";
 import { daemonClient, daemonError } from "#host/daemonClient.ts";
+import { readDaemonPort } from "#host/daemonPort.ts";
 import { decodeFollowState, type FollowState } from "#host/followState.ts";
 
-const { DAEMON_PORT } = diagnosticsApi;
-
 export interface FollowOptions {
+	readonly board?: string;
 	readonly follow?: boolean;
 	readonly intervalMs: number;
 	readonly port?: number;
@@ -14,11 +15,13 @@ export interface FollowOptions {
 }
 
 export function follow(options: FollowOptions, workIds: readonly string[]) {
-	const port = options.port ?? DAEMON_PORT;
 	let ids = workIds;
 	let connected = false;
 	let failures = 0;
 	function connect(): Stream.Stream<readonly FollowState[], FleetError> {
+		return Stream.unwrap(readDaemonPort(options.board ?? ".work", options.port).pipe(Effect.provide(NodeServices.layer), Effect.map(subscribe)));
+	}
+	function subscribe(port: number): Stream.Stream<readonly FollowState[], FleetError> {
 		return Stream.unwrap(daemonClient(port).pipe(Effect.map((client) => client("daemon.follow", { follow: options.follow, workIds: ids })))).pipe(
 			Stream.scoped,
 			Stream.map((states) => states.map(decodeFollowState)),
@@ -33,6 +36,14 @@ export function follow(options: FollowOptions, workIds: readonly string[]) {
 			Stream.concat(Stream.fail(new Error("Fleet daemon subscription closed"))),
 			Stream.catch((error) => {
 				failures += 1;
+				if (options.follow && !isFleetError(error) && (!(error instanceof RpcClientError) || error.reason._tag === "HttpError")) {
+					return Stream.unwrap(
+						Console.error(`work-fleet: ERROR ${daemonError(error, port, "follow").message}; retrying in ${options.intervalMs / 1000}s`).pipe(
+							Effect.andThen(Effect.sleep(options.intervalMs)),
+							Effect.as(connect()),
+						),
+					);
+				}
 				if (!connected || isFleetError(error) || failures >= 20) {
 					return Stream.fail(daemonError(error, port, "follow"));
 				}

package/src/host/followCommands.ts

@@ -20,8 +20,9 @@ export const waitCommand = Command.make(
 	Effect.fn("WorkFleetCli.wait")(function* (input) {
 		const { waitFor } = yield* Effect.promise(() => import("#host/wait.ts"));
 		const outcome = yield* waitFor({
+			board: input.board,
 			intervalMs: input.interval * 1000,
-			port: input.port,
+			...Option.match(input.port, { onNone: () => ({}), onSome: (value) => ({ port: value }) }),
 			workId: input.workId,
 			...Option.match(input.timeout, { onNone: () => ({}), onSome: (seconds) => ({ timeoutMs: seconds * 1000 }) }),
 		});
@@ -44,9 +45,10 @@ export const watchCommand = Command.make(
 	Effect.fn("WorkFleetCli.watch")(function* (input) {
 		const { watchFor } = yield* Effect.promise(() => import("#host/watch.ts"));
 		process.exitCode = yield* watchFor({
+			board: input.board,
 			follow: input.follow,
 			intervalMs: input.interval * 1000,
-			port: input.port,
+			...Option.match(input.port, { onNone: () => ({}), onSome: (value) => ({ port: value }) }),
 			workIds: input.workIds,
 			...Option.match(input.timeout, { onNone: () => ({}), onSome: (seconds) => ({ timeoutMs: seconds * 1000 }) }),
 		});

package/src/host/githubApi.ts

@@ -1,5 +1,5 @@
 import { Clock, Effect, Layer } from "effect";
-import { defineService } from "@shivaedev/effect-service/define-service.ts";
+import { defineService } from "@shivaedev/effect-service/defineService.ts";
 import { ServiceUnavailable } from "@shivaedev/platform/errors/taxonomy.ts";
 import {
 	type GithubObservation,

package/src/host/githubDelivery.ts

@@ -90,7 +90,9 @@ const validateDelivery = Effect.fn("FleetHost.validateDelivery")(function* (pr:
 		return yield* failure("Delivery observation differs from the adopted PR");
 	}
 	if (pr.state === "CLOSED" && pr.mergedAt === null && pr.mergeCommit === null) {
-		return yield* failure("PR was closed without merging; inspect the closed PR before retrying or releasing this work");
+		return yield* withFailureContext(failure("PR was closed without merging; inspect the closed PR before retrying or releasing this work"), {
+			code: "pr-closed",
+		});
 	}
 	const merged = pr.state === "MERGED" && pr.mergedAt !== null && pr.mergeCommit !== null;
 	if (!merged && (pr.state !== "OPEN" || pr.mergedAt !== null || pr.mergeCommit !== null)) {

package/src/host/healthLayer.ts

@@ -1,5 +1,5 @@
 import { Effect, Layer, Ref, Schema } from "effect";
-import { diagnostics as diagnosticsApi } from "@shivaedev/work-board/integration/diagnostics.ts";
+import { diagnostics as diagnosticsApi } from "@shivaedev/work-board/server/integration/diagnostics.ts";
 import { Health } from "#engine/health.ts";
 import { ProviderCapacity } from "#session/schema.ts";
 

package/src/host/integrations.ts

@@ -1,6 +1,6 @@
 import * as NodeServices from "@effect/platform-node/NodeServices";
 import { Effect, Layer } from "effect";
-import { defineService } from "@shivaedev/effect-service/define-service.ts";
+import { defineService } from "@shivaedev/effect-service/defineService.ts";
 import { ServiceUnavailable } from "@shivaedev/platform/errors/taxonomy.ts";
 import type { DecisionCode } from "#DecisionCode.ts";
 import { withFailureContext } from "#engine/failureContext.ts";

package/src/host/mainSource.ts

@@ -1,6 +1,6 @@
 import { execFile } from "node:child_process";
 import { Clock, Context, Effect, Layer } from "effect";
-import { defineService } from "@shivaedev/effect-service/define-service.ts";
+import { defineService } from "@shivaedev/effect-service/defineService.ts";
 import { ServiceUnavailable } from "@shivaedev/platform/errors/taxonomy.ts";
 import type { FleetError } from "#errors.ts";
 import type { FleetHost } from "#host/config.ts";

package/src/host/providerHealth.ts

@@ -1,5 +1,5 @@
 import { Context, Effect, Layer, type Option } from "effect";
-import { defineService } from "@shivaedev/effect-service/define-service.ts";
+import { defineService } from "@shivaedev/effect-service/defineService.ts";
 import { capacityRejected, Health } from "#engine/health.ts";
 import type { SessionFailure, SessionObservation } from "#session/schema.ts";
 import { SessionTransport } from "#session/service.ts";

package/src/host/quota.ts

@@ -1,6 +1,6 @@
 import { Effect, Schema } from "effect";
 import { ServiceUnavailable } from "@shivaedev/platform/errors/taxonomy.ts";
-import { diagnostics as diagnosticsApi } from "@shivaedev/work-board/integration/diagnostics.ts";
+import { diagnostics as diagnosticsApi } from "@shivaedev/work-board/server/integration/diagnostics.ts";
 import type { FleetError } from "#errors.ts";
 import type { FleetHost } from "#host/config.ts";
 import type { FleetConfiguration } from "#policy.ts";

package/src/host/recordDecisionResponse.ts

@@ -1,6 +1,6 @@
 import { Clock, Effect, FileSystem, Schema } from "effect";
 import { BadRequest, Conflict } from "@shivaedev/platform/errors/taxonomy.ts";
-import { responses as responsesApi } from "@shivaedev/work-board/integration/responses.ts";
+import { responses as responsesApi } from "@shivaedev/work-board/server/integration/responses.ts";
 import type { BoardDecision } from "#board/schema.ts";
 import { BoardGateway, type Decision } from "#policy.ts";
 

package/src/host/releaseWork.ts

@@ -1,8 +1,8 @@
 import * as NodeServices from "@effect/platform-node/NodeServices";
 import { Effect, Layer } from "effect";
 import { Conflict, Forbidden } from "@shivaedev/platform/errors/taxonomy.ts";
-import { board } from "@shivaedev/work-board/integration/board.ts";
-import { responses } from "@shivaedev/work-board/integration/responses.ts";
+import { board } from "@shivaedev/work-board/server/integration/board.ts";
+import { responses } from "@shivaedev/work-board/server/integration/responses.ts";
 import { Fleet } from "#fleet.ts";
 import { type HostParts, hostLayer, productionParts } from "#host/commands.ts";
 import type { FleetHost } from "#host/config.ts";

package/src/host/renderStatus.ts

@@ -1,21 +1,20 @@
-import { diagnostics as diagnosticsApi } from "@shivaedev/work-board/integration/diagnostics.ts";
 import { sessionStatus } from "#engine/sessionStatus.ts";
 import { type DaemonStatus, renderConfig } from "#host/configSettings.ts";
 import type { FleetViews } from "#model.ts";
 
-const { DAEMON_PORT } = diagnosticsApi;
-
 type View = (typeof FleetViews.Type)["active"][number];
 
-function line(view: View, waiting: boolean, port: number) {
+function line(view: View, waiting: boolean, selection: string) {
 	const reason = view.blocker ?? view.decision?.reason ?? (view.overLimit ? "launched over the limit" : undefined);
 	const detail = reason === undefined ? "" : `  ${reason}`;
 	const links = [...view.links, ...view.sessions.map(sessionStatus)];
-	const answer = waiting ? `\n    work-fleet answer ${view.workId}${port === DAEMON_PORT ? "" : ` --port ${port}`}` : "";
+	const answer = waiting ? `\n    work-fleet answer ${view.workId}${selection}` : "";
 	return `  ${view.workId}  ${view.stage}${detail}${links.length === 0 ? "" : `  (${links.join(", ")})`}${answer}`;
 }
 
-export function renderStatus(current: typeof DaemonStatus.Type, port: number = DAEMON_PORT): string {
+export function renderStatus(current: typeof DaemonStatus.Type, selection: { readonly board?: string; readonly port?: number } = {}): string {
+	const board = selection.board === undefined || selection.board === ".work" ? "" : ` --board '${selection.board.replaceAll("'", "'\\''")}'`;
+	const endpoint = `${board}${selection.port === undefined ? "" : ` --port ${selection.port}`}`;
 	const sections: readonly [string, readonly View[]][] = [
 		["Active", current.active],
 		["Waiting on maintainer", current.waiting.maintainer],
@@ -27,7 +26,7 @@ export function renderStatus(current: typeof DaemonStatus.Type, port: number = D
 		.map(([title, items]) =>
 			[
 				`${title} (${items.length})`,
-				...items.map((item) => line(item, title === "Waiting on maintainer" || title === "Waiting on orchestrator", port)),
+				...items.map((item) => line(item, title === "Waiting on maintainer" || title === "Waiting on orchestrator", endpoint)),
 			].join("\n"),
 		)
 		.join("\n");

package/src/host/reportBoard.ts

@@ -1,6 +1,6 @@
 import * as NodeServices from "@effect/platform-node/NodeServices";
 import { Context, Effect, Layer } from "effect";
-import { defineService } from "@shivaedev/effect-service/define-service.ts";
+import { defineService } from "@shivaedev/effect-service/defineService.ts";
 import { BadRequest } from "@shivaedev/platform/errors/taxonomy.ts";
 import { markdownBoard } from "#board/markdown.ts";
 import { reportContent } from "#board/reportContent.ts";

package/src/host/runtime.ts

@@ -1,7 +1,7 @@
 import * as NodeServices from "@effect/platform-node/NodeServices";
 import { Clock, Effect, Layer, Redacted } from "effect";
-import { appDatabase } from "@shivaedev/platform/appHost.ts";
 import { ServiceUnavailable } from "@shivaedev/platform/errors/taxonomy.ts";
+import { appDatabase } from "@shivaedev/platform/server/appHost.ts";
 import type { ReportInspection } from "#engine/ReportInspection.ts";
 import { fleetSessionJournal, postgresFleetRepository } from "#engine/repository.ts";
 import { Fleet } from "#fleet.ts";

package/src/host/statusLayer.ts

@@ -1,7 +1,7 @@
 import { Clock, Console, Context, Effect, FileSystem, Layer, type Option, Ref, Semaphore } from "effect";
-import { defineService } from "@shivaedev/effect-service/define-service.ts";
-import type { FleetHealth } from "@shivaedev/work-board/integration/diagnostics.ts";
-import { diagnostics as diagnosticsApi } from "@shivaedev/work-board/integration/diagnostics.ts";
+import { defineService } from "@shivaedev/effect-service/defineService.ts";
+import type { FleetHealth } from "@shivaedev/work-board/server/integration/diagnostics.ts";
+import { diagnostics as diagnosticsApi } from "@shivaedev/work-board/server/integration/diagnostics.ts";
 import { publishAfterBoardPass } from "#board/readPass.ts";
 import { writeHealth } from "#board/writeHealth.ts";
 import { writeStatus } from "#board/writeStatus.ts";

package/src/host/watch.ts

@@ -39,7 +39,10 @@ export const watchFor = Effect.fn("FleetWatch.watchFor")(function* (options: Wat
 	);
 	yield* options.timeoutMs === undefined
 		? consume
-		: Effect.raceFirst(consume, Deferred.await(ready).pipe(Effect.andThen(Effect.sleep(options.timeoutMs))));
+		: Effect.raceFirst(
+				consume,
+				options.follow ? Effect.sleep(options.timeoutMs) : Deferred.await(ready).pipe(Effect.andThen(Effect.sleep(options.timeoutMs))),
+			);
 	if (!options.follow && pending?.size === 0) {
 		return WAIT_EXIT.completed;
 	}

package/src/model.ts

@@ -1,5 +1,5 @@
 import { Schema } from "effect";
-import { diagnostics } from "@shivaedev/work-board/integration/diagnostics.ts";
+import { diagnostics } from "@shivaedev/work-board/server/integration/diagnostics.ts";
 import { AttentionOwner } from "#attention.ts";
 import { BoardReport } from "#board/schema.ts";
 import { DispatchRequest } from "#DispatchRequest.ts";