@teamscala/service-boot 0.23.319 → 0.23.321

package/src/fn-routers/task-sync-hook-lifecycle.test.ts

@@ -1,204 +0,0 @@
-/**
- * @system service-boot
- * @status handwritten
- * @edit edit directly
- *
- * Lifecycle round-trip for the Claude Code per-item task projection:
- * `upsertFromTaskHookHandler` (the extracted body of the upsertFromTaskHook
- * ORPC handler) must carry a task through created -> in_progress -> completed ->
- * deleted against an in-memory mock prisma, so `work_items` sees every state a
- * task reaches (`task-projection-converges`). A projection that cannot express
- * completion — or deletion — is an append-only log, and the operator cannot see
- * what a lane is doing. The matcher covering TaskCreate|TaskUpdate|TaskDelete is
- * what routes all three tool events here; these tests assert the body applies
- * each one. Same mock-prisma shape as claim-orchestrator-session.test.ts.
- */
-import { afterEach, beforeEach, describe, expect, it, mock } from "bun:test";
-
-const recordEventMock = mock((_event: unknown) => {});
-mock.module("@teamscala/event-log/record-event", () => ({ recordEvent: recordEventMock }));
-mock.module("@teamscala/logger/app-loggers", () => ({
-	getAppLogger: () => ({
-		info: () => {},
-		warn: () => {},
-		error: () => {},
-	}),
-}));
-
-const { upsertFromTaskHookHandler } = await import("./task-sync-router.ts");
-
-/** A lane's parent task, returned by the mocked resolveLaneTask findFirst. */
-const LANE_TASK = {
-	id: "task-1",
-	kind: "task",
-	parent_id: null,
-	organisation_id: "org-1",
-	title: "Test Lane",
-	status: "active",
-	completed: false,
-	position: null,
-	kind_data: { lane: { session: "ses-1", pane: "tmux:%1" } },
-};
-
-function makePrisma() {
-	// In-memory subtask store, so the four states act on ONE evolving row.
-	const subtasks: Array<Record<string, unknown>> = [];
-	const findFirst = mock(async (args: { where: Record<string, unknown> }) => {
-		// resolveLaneTask asks for kind='task' + status active/archived; everything
-		// else (subtask lookups) returns null.
-		if (args.where?.kind === "task") return { ...LANE_TASK };
-		return null;
-	});
-	const findMany = mock(async (args: { where: Record<string, unknown> }) => {
-		const pid = args.where?.parent_id;
-		return subtasks.filter((s) => s.parent_id === pid);
-	});
-	const create = mock(async (args: { data: Record<string, unknown> }) => {
-		const row = { id: `s-${subtasks.length + 1}`, ...args.data };
-		subtasks.push(row);
-		return row;
-	});
-	const update = mock(async (args: { where: { id: string }; data: Record<string, unknown> }) => {
-		const row = subtasks.find((s) => s.id === args.where.id);
-		if (row) Object.assign(row, args.data);
-		return row ?? null;
-	});
-	const deleteMany = mock(async (args: { where: { id: { in: string[] } } }) => {
-		// Real Prisma form: where.id.in (a bare array on the scalar id is a
-		// validation error). Mirrors the canonical deleteMany in reconcileTaskList.
-		const ids = args.where?.id?.in ?? [];
-		let count = 0;
-		for (let i = subtasks.length - 1; i >= 0; i--) {
-			if (ids.includes(String(subtasks[i]?.id))) {
-				subtasks.splice(i, 1);
-				count++;
-			}
-		}
-		return { count };
-	});
-	return {
-		store: subtasks,
-		prisma: { work_items: { findFirst, findMany, create, update, deleteMany } },
-		mocks: { findFirst, findMany, create, update, deleteMany },
-	};
-}
-
-/** A lane context bound to a mock prisma, so each call site passes only the event. */
-function bindCtx(prisma: unknown, session = "ses-1") {
-	const headers = new Headers();
-	headers.set("x-lane-session", session);
-	headers.set("x-lane-pane", "tmux:%1");
-	return { headers, prisma, user: undefined };
-}
-
-/** makePrisma + a `hook(evt)` convenience bound to that prisma's session. */
-function makeFixture() {
-	const fixture = makePrisma();
-	const hook = (evt: unknown) => upsertFromTaskHookHandler(evt, bindCtx(fixture.prisma));
-	return { ...fixture, hook };
-}
-
-describe("upsertFromTaskHookHandler — full lifecycle round-trip", () => {
-	beforeEach(() => recordEventMock.mockClear());
-
-	it("created -> in_progress -> completed -> deleted all write through to one subtask", async () => {
-		const { hook, store, mocks } = makeFixture();
-
-		// 1. CREATED — PostToolUse:TaskCreate. The harness assigns the task id in
-		//    tool_response.task.id; the projection must stamp it as the mark so every
-		//    later state is mark-addressable.
-		const created = await hook({
-			tool_name: "TaskCreate",
-			hook_event_name: "PostToolUse",
-			tool_input: { subject: "Ship the fix" },
-			tool_response: { task: { id: "42" } },
-		});
-		expect(created).toEqual({ applied: true, op: "create", taskId: "42" });
-		expect(mocks.create).toHaveBeenCalledTimes(1);
-		const row = store[0];
-		expect(row.title).toBe("Ship the fix");
-		expect(row.status).toBe("todo");
-		expect((row.kind_data as { task_sync: { mark: string } }).task_sync.mark).toBe("42");
-
-		// 2. IN_PROGRESS — PostToolUse:TaskUpdate with status in_progress. Matched
-		//    by the mark stamped at creation; the projection expresses it, it does
-		//    not append a new row.
-		mocks.create.mockClear();
-		const inProgress = await hook({
-			tool_name: "TaskUpdate",
-			hook_event_name: "PostToolUse",
-			tool_input: { taskId: "42", status: "in_progress" },
-		});
-		expect(inProgress).toEqual({ applied: true, op: "update", taskId: "42" });
-		expect(mocks.create).not.toHaveBeenCalled();
-		expect(mocks.update).toHaveBeenCalledTimes(1);
-		expect(row.status).toBe("in-progress");
-		expect(row.completed).toBe(false);
-		expect(store).toHaveLength(1);
-
-		// 3. COMPLETED — PostToolUse:TaskUpdate with status completed. A projection
-		//    that cannot express completion is an append-only log.
-		mocks.update.mockClear();
-		const done = await hook({
-			tool_name: "TaskUpdate",
-			hook_event_name: "PostToolUse",
-			tool_input: { taskId: "42", status: "completed" },
-		});
-		expect(done).toEqual({ applied: true, op: "update", taskId: "42" });
-		expect(mocks.update).toHaveBeenCalledTimes(1);
-		expect(row.status).toBe("done");
-		expect(row.completed).toBe(true);
-		expect(store).toHaveLength(1);
-
-		// 4. DELETED — PostToolUse:TaskDelete. The row leaves the projection; the
-		//    list empties, which is the half a create-only projection can never do.
-		const deleted = await hook({
-			tool_name: "TaskDelete",
-			hook_event_name: "PostToolUse",
-			tool_input: { taskId: "42" },
-		});
-		expect(deleted).toEqual({ applied: true, op: "delete", taskId: "42" });
-		expect(mocks.deleteMany).toHaveBeenCalledTimes(1);
-		expect(store).toHaveLength(0);
-	});
-
-	it("stamps the mark on a title-matched update so a later rename is mark-addressable", async () => {
-		// A row written with NO mark (pre-mark history, or a healed row) is only
-		// reachable by title. The first title-match must stamp the mark so the row
-		// never orphans on a later rename (the 2026-07-28 stranded-subtask class).
-		const { hook, store } = makeFixture();
-		store.push({
-			id: "legacy-1",
-			parent_id: "task-1",
-			title: "Old title",
-			status: "todo",
-			completed: false,
-			kind_data: {},
-		});
-
-		await hook({
-			tool_name: "TaskUpdate",
-			hook_event_name: "PostToolUse",
-			tool_input: { taskId: "99", subject: "Old title", status: "in_progress" },
-		});
-		expect((store[0].kind_data as { task_sync: { mark: string } }).task_sync.mark).toBe("99");
-		expect(store[0].status).toBe("in-progress");
-	});
-
-	it("is idempotent on a retried TaskCreate (no duplicate subtask)", async () => {
-		// The hook curls with --retry, so one TaskCreate can arrive twice. A
-		// projection that duplicates on retry is not a projection.
-		const { hook, store } = makeFixture();
-		const evt = {
-			tool_name: "TaskCreate",
-			hook_event_name: "PostToolUse",
-			tool_input: { subject: "Once only" },
-			tool_response: { task: { id: "7" } },
-		};
-		await hook(evt);
-		const second = await hook(evt);
-		// The retried create matches the stored mark and is discarded, not doubled.
-		expect(second.applied).toBe(false);
-		expect(store.filter((s) => s.title === "Once only")).toHaveLength(1);
-	});
-});

package/src/fn-routers/task-sync-lane.test.ts

@@ -1,36 +0,0 @@
-/**
- * @system service-boot
- * @status handwritten
- * @edit edit directly
- *
- * Behavioral tests for canonical CLI-session lane resolution.
- */
-import { describe, expect, it } from "bun:test";
-import { resolveLaneWorkName } from "./task-sync-lane.ts";
-
-describe("resolveLaneWorkName", () => {
-	it("reads the visible label from the active cli_sessions route", async () => {
-		let query: unknown;
-		const name = await resolveLaneWorkName(
-			{
-				cli_sessions: {
-					findFirst: async (args: unknown) => {
-						query = args;
-						return { id: "session-1", label: "ZeroStack" };
-					},
-				},
-			} as never,
-			"tmux:%7",
-		);
-		expect(name).toBe("ZeroStack");
-		expect(query).toMatchObject({ where: { host_route: { path: ["pane_id"], equals: "tmux:%7" } } });
-	});
-
-	it("returns no unverified title when no active session owns the pane", async () => {
-		const name = await resolveLaneWorkName(
-			{ cli_sessions: { findFirst: async () => null } } as never,
-			"tmux:%8",
-		);
-		expect(name).toBeNull();
-	});
-});

package/src/fn-routers/task-sync-rename.test.ts

@@ -1,53 +0,0 @@
-/**
- * @system service-boot
- * @status handwritten
- * @edit directly
- *
- * Unit tests for the rename back-write leg: renameOutcome (the pure
- * no-task ⇒ not-updated decision) + source-contract assertions that the handler
- * resolves the lane task BY SESSION (never pane) and updates its title. Covers
- * `what-must-have-a-test` for the new procedure + the `lane-identity-is-cli-
- * session-id` invariant it rides on.
- */
-import { describe, it, expect } from "bun:test";
-import { renameOutcome } from "./task-sync-rename.ts";
-
-describe("renameOutcome (no verdict from no data)", () => {
-	it("returns not-updated with a null task_id when no task is bound to the session", () => {
-		// A rename of a tab whose lane has no resolvable task updates nothing —
-		// never an error, never a fake id. updated:false is the signal the caller
-		// treats as best-effort (the window was already renamed; this only missed
-		// the DB echo, which is the rare archived-and-pruned case).
-		expect(renameOutcome(null)).toEqual({ task_id: null, updated: false });
-	});
-
-	it("returns the bound task id + updated:true when a task resolves", () => {
-		expect(renameOutcome({ id: "task-9" })).toEqual({ task_id: "task-9", updated: true });
-	});
-});
-
-describe("renameLaneTask resolves BY SESSION and writes the title (source contract)", () => {
-	const renameSrc = Bun.file(new URL("./task-sync-rename.ts", import.meta.url).pathname);
-
-	it("resolves the lane task by lane_session (the CLI session id), never by pane", async () => {
-		// `lane-identity-is-cli-session-id`: binding is by session because a pane
-		// outlives the session inside it. A pane-keyed rename would let a dead
-		// session's task answer for a live lane.
-		const text = await renameSrc.text();
-		expect(text).toContain("resolveLaneTask(prisma, lane_session)");
-		// No pane matching anywhere in the resolution path.
-		expect(text).not.toContain("lane.pane");
-	});
-
-	it("updates the resolved task's title by id", async () => {
-		const text = await renameSrc.text();
-		expect(text).toContain('where: { id: task.id }');
-		expect(text).toContain("data: { title }");
-	});
-
-	it("requires lane_session + title at the signature (incomplete rename unconstructible)", async () => {
-		const text = await renameSrc.text();
-		expect(text).toContain('lane_session: v.pipe(v.string()');
-		expect(text).toContain('title: v.pipe(v.string()');
-	});
-});

package/src/fn-routers/task-sync-rename.ts

@@ -1,111 +0,0 @@
-/**
- * @system service-boot
- * @status handwritten
- * @edit edit directly
- *
- * Lane RENAME back-write for task-sync: a tab rename EMITS to update the bound
- * work_items task's title in the DB, by CLI session id. This is the DB half of
- * `tab-rename-emits-back-to-task-title`: the operator's tab bar is how they see
- * what is being worked on (`lane-labels-and-task-lists`), so the tmux window
- * name and the task title must never diverge silently. Renaming a tab from
- * `scala-tools session rename` (or the lane renaming itself through the same
- * surface) updates the task title so the project board agrees with the tab bar.
- *
- * THE EMISSION, not a poll (`actions-are-rows-then-emissions`): a caller renames
- * the window (a row/state change) and that change emits the title update — the
- * task-sync owner reacts by updating the row. State lives in the row, never in a
- * return value a caller may never receive.
- *
- * Bound by CLI SESSION ID, never pane id (`lane-identity-is-cli-session-id`): a
- * pane OUTLIVES the session inside it, so matching on a pane would let a dead
- * session's task answer for a live lane. The session is the stable identity a
- * rename resolves to (the daemon resolves the pane's tab → its stored session id
- * and passes that here), so the rename lands on the lane that owns the tab.
- *
- * Split out of task-sync-router.ts for the same reason task-sync-brief/lane/
- * assign exist: the router sits at its 1000-line commit gate, so every cohesive
- * task-sync unit that can live in a sibling does. This owns the rename handler +
- * its pure outcome decision.
- *
- * CAPABILITY HARVEST (capability-harvest-on-split): APP-LOCAL, not a capability
- * candidate. Bound to the work_items schema and to task-sync's own
- * kind_data.lane.session convention; no unrelated app could install this
- * unmodified.
- */
-
-import * as v from "valibot";
-import type { Prisma } from "./task-sync-router.ts";
-import { authed, type Context } from "./auth-router.ts";
-import { resolveLaneTask } from "./task-sync-lane.ts";
-import { getAppLogger } from "@teamscala/logger/app-loggers";
-
-/**
- * renameLaneTask ORPC input. `lane_session` is the lane's CLI-native session id
- * (kind_data.lane.session) — the stable identity a pane rename resolves to.
- * `title` is the new task title (the renamed tab's label). Both required:
- * oRPC rejects a call missing either at the signature
- * (`prevention-over-detection`), so a malformed rename is a 400, never a silent
- * no-op that leaves the title stale.
- */
-export const renameLaneTaskInput = v.object({
-	lane_session: v.pipe(v.string(), v.minLength(1, "lane_session is required")),
-	title: v.pipe(v.string(), v.minLength(1, "title is required")),
-});
-
-/**
- * The rename outcome from a resolved lane task — pure so the "no task bound ⇒
- * not updated, never an error" decision is unit-testable with no DB. A rename
- * whose lane has no task is best-effort (returns updated:false): every spawn
- * now mints a task, so this is the rare case (a tab whose task was archived and
- * pruned), not a path the operator hits. Failing loudly here would refuse a
- * rename of the WINDOW for a DB miss, which couples two surfaces that must not
- * be — the tmux rename already succeeded before this is called.
- */
-export function renameOutcome(task: { id: string } | null): {
-	task_id: string | null;
-	updated: boolean;
-} {
-	if (!task) return { task_id: null, updated: false };
-	return { task_id: task.id, updated: true };
-}
-
-/**
- * renameLaneTask ORPC handler. The session-picker daemon calls this from
- * `/rpc/rename` after it renames the tmux window: it resolves the pane's tab to
- * its session id and posts it here. Same transport as bindLane/readTaskList:
- * page-gate-exempt (fn.taskSync), localhost super-admin. Resolves the lane's
- * task BY SESSION (never pane) and updates its title. Idempotent: renaming to
- * the same title writes the same row.
- *
- * An archived parent is matched too (resolveLaneTask falls back to the archived
- * lane task for the session), so a rename of a tab whose run closed still lands
- * on its task — the title is the title regardless of run state.
- */
-export const renameLaneTaskHandler = authed
-	.input(renameLaneTaskInput)
-	.handler(async ({ input, context }) => {
-		const ctx = context as Context;
-		const prisma = ctx.prisma as Prisma;
-		const { lane_session, title } = input;
-		const task = await resolveLaneTask(prisma, lane_session);
-		const outcome = renameOutcome(task);
-		if (!task) return outcome;
-		try {
-			await prisma.work_items.update({
-				where: { id: task.id },
-				data: { title },
-				select: { id: true },
-			});
-		} catch (err) {
-			// The window was already renamed by the caller; a DB update failure must
-			// not surface as an error that implies the rename failed. Report
-			// not-updated + log, so the two surfaces stay decoupled
-			// (`a-component-may-not-report-a-state-it-has-not-verified`).
-			getAppLogger().warn("[task-sync] renameLaneTask: title update failed", {
-				taskId: task.id,
-				error: err instanceof Error ? err.message : String(err),
-			});
-			return { task_id: task.id, updated: false };
-		}
-		return outcome;
-	});

package/src/handlers/sweep-host-cache.test.ts

@@ -1,133 +0,0 @@
-/**
- * @system server-boot
- * @status handwritten
- * @edit edit directly
- *
- * Unit tests for the `retention_dirs` helpers (`expandGlob`, `checkDirStale`) —
- * the whole-directory prune that bounds Rust `target/` waste. The file-by-mtime
- * `retention` path is unchanged; these cover ONLY the new build-cache model:
- * (1) glob expansion reaches every repo's target dir; (2) an actively-built dir
- * is kept (short-circuits on a fresh file); (3) an abandoned dir is reported
- * stale with its full size. Lives next to the handler per co-located-test rule.
- */
-import { describe, expect, test, beforeEach, afterEach } from "bun:test";
-import { mkdtempSync, mkdirSync, writeFileSync, rmSync, utimesSync } from "node:fs";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-import { expandGlob, checkDirStale, parseRootDiskPct } from "./sweep-host-cache.ts";
-
-const DAY = 86_400_000;
-const now = Date.now();
-const daysAgo = (n: number) => new Date(now - n * DAY);
-const touch = (p: string, t: Date) => utimesSync(p, t, t);
-
-let root: string;
-beforeEach(() => {
-	root = mkdtempSync(join(tmpdir(), "sweep-"));
-});
-afterEach(() => {
-	rmSync(root, { recursive: true, force: true });
-});
-
-describe("expandGlob", () => {
-	test("expands a single-segment wildcard to concrete dirs", () => {
-		mkdirSync(join(root, "scala-rust", "target"), { recursive: true });
-		mkdirSync(join(root, "scala-os", "target"), { recursive: true });
-		mkdirSync(join(root, "scala-os", "src"), { recursive: true });
-		const matches = expandGlob(`${root}/*/target`).sort();
-		expect(matches).toEqual(
-			[join(root, "scala-os", "target"), join(root, "scala-rust", "target")].sort(),
-		);
-	});
-	test("literal segment matches only itself", () => {
-		mkdirSync(join(root, "scala-rust", "target"), { recursive: true });
-		mkdirSync(join(root, "other", "target"), { recursive: true });
-		const matches = expandGlob(`${root}/scala-rust/target`);
-		expect(matches).toEqual([join(root, "scala-rust", "target")]);
-	});
-	test("no matches when the wildcard segment has no children", () => {
-		const matches = expandGlob(`${root}/does-not-exist/*/target`);
-		expect(matches).toEqual([]);
-	});
-});
-
-describe("checkDirStale", () => {
-	test("stale dir: all files older than cutoff → stale + full size", async () => {
-		const dir = join(root, "target");
-		mkdirSync(join(dir, "debug", "deps"), { recursive: true });
-		writeFileSync(join(dir, "debug", "deps", "a.o"), "x".repeat(40));
-		writeFileSync(join(dir, "debug", "deps", "b.o"), "y".repeat(60));
-		touch(join(dir, "debug", "deps", "a.o"), daysAgo(40));
-		touch(join(dir, "debug", "deps", "b.o"), daysAgo(35));
-		const res = await checkDirStale(dir, now - 30 * DAY);
-		expect(res.stale).toBe(true);
-		expect(res.fileCount).toBe(2);
-		expect(res.bytes).toBe(100);
-	});
-	test("active dir: a file newer than cutoff → not stale (short-circuit)", async () => {
-		const dir = join(root, "target");
-		mkdirSync(join(dir, "debug"), { recursive: true });
-		writeFileSync(join(dir, "debug", "old.o"), "x".repeat(40));
-		touch(join(dir, "debug", "old.o"), daysAgo(40));
-		writeFileSync(join(dir, "debug", "fresh.o"), "y".repeat(60));
-		touch(join(dir, "debug", "fresh.o"), daysAgo(1));
-		const res = await checkDirStale(dir, now - 30 * DAY);
-		expect(res.stale).toBe(false);
-	});
-	test("empty dir → stale with zero bytes", async () => {
-		const dir = join(root, "target");
-		mkdirSync(dir, { recursive: true });
-		const res = await checkDirStale(dir, now - 30 * DAY);
-		expect(res.stale).toBe(true);
-		expect(res.bytes).toBe(0);
-		expect(res.fileCount).toBe(0);
-	});
-});
-
-describe("parseRootDiskPct", () => {
-	test("extracts root-fs Use% from df --output=pcent,target output", () => {
-		const df =
-			"Use% Mounted on\n" +
-			"  97% /\n" +
-			"  45% /home\n";
-		expect(parseRootDiskPct(df)).toBe(97);
-	});
-	test("picks the root mount (/) over nested mounts", () => {
-		const df =
-			"Use% Mounted on\n" +
-			"  10% /proc/x\n" +
-			"  76% /\n";
-		expect(parseRootDiskPct(df)).toBe(76);
-	});
-	test("returns null when no root-mount line present", () => {
-		const df = "Use% Mounted on\n  40% /mnt/other\n";
-		expect(parseRootDiskPct(df)).toBeNull();
-	});
-	test("returns null on empty / malformed output", () => {
-		expect(parseRootDiskPct("")).toBeNull();
-		expect(parseRootDiskPct("Use% Mounted on")).toBeNull();
-	});
-});
-
-describe("disk-threshold early-warning regression lock", () => {
-	const { readFileSync } = require("node:fs");
-	// Source-shape lock (same pattern as singleton-tools-currency-watch.test.ts):
-	// the df-check that rides this periodic sweep was once removed in favour of an
-	// in-process interval watchdog — the wrong architecture (interval watchdogs
-	// are forbidden; observability is event-driven). This asserts the corrected
-	// shape survives: the sweep handler MUST carry the event-driven host.disk.high
-	// emission (logger.warn -> GlitchTip) + the pure parseRootDiskPct helper that
-	// backs it. Removing either fails this test. The asserted surface is the
-	// disk early-warning cell of host-resources-have-complete-monitoring.
-	const src = readFileSync(import.meta.dir + "/sweep-host-cache.ts", "utf-8");
-	test("handler emits the host.disk.high event (event-driven, not an interval)", () => {
-		expect(src).toContain('log.warn("host.disk.high"');
-		expect(src).toContain('kind: "host.disk.high"');
-	});
-	test("handler reads df via the sanctioned spawn (no in-process poller)", () => {
-		expect(src).toContain('command: ["df", "--output=pcent,target"]');
-	});
-	test("threshold parse is the exported pure helper", () => {
-		expect(src).toContain("export function parseRootDiskPct");
-	});
-});

package/src/serve/stamp-transport-identity.test.ts

@@ -1,24 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { summariseLocalCommand } from "./stamp-transport-identity.ts";
-
-describe("local command attribution", () => {
-	test("never copies command arguments into telemetry", () => {
-		const token = "operator-token-must-not-appear";
-		const summary = summariseLocalCommand([
-			"curl",
-			"-H",
-			`x-operator-spawn-token: ${token}`,
-			"http://127.0.0.1:3021/rpc/spawn",
-		]);
-		expect(summary).toBe("curl [arguments redacted]");
-		expect(summary).not.toContain(token);
-	});
-
-	test("keeps a lone executable name", () => {
-		expect(summariseLocalCommand(["scala-picker"])).toBe("scala-picker");
-	});
-
-	test("omits an empty command line", () => {
-		expect(summariseLocalCommand([])).toBeNull();
-	});
-});

package/src/two-phase-health-gate-client-only.test.ts

@@ -1,77 +0,0 @@
-/**
- * @system service-boot
- * @status handwritten
- * @edit edit directly
- *
- * A CLIENT-ONLY service (`render_mode=client`) must reach ready, even though it
- * never registers an SSR page handler.
- *
- * Separate file from `two-phase-health-gate.test.ts` on purpose: `fullAppReady`
- * is module state that only transitions false -> true and has no reset hook, so
- * the two ready-paths cannot both be exercised in one module instance. A reset
- * hook would exist only for tests.
- *
- * THE REGRESSION THIS LOCKS (measured 2026-08-07 on scala-agents-ui). Readiness
- * used to be flipped INSIDE `setPageHandler`, which was honest while every
- * service was SSR. `render_mode=client` made a service that completes phase 2
- * and never calls it, so `/health` answered `{"status":"starting"}` FOREVER
- * while the process was healthy and serving — boot completed in 5023ms, "Full
- * app built: 50 block(s)" logged, `GET /` correctly 302'd to sign-in, and three
- * untouched UI services reported ok beside it.
- *
- * That is precisely what `readiness-gated-boot` forbids ("binary: fully-ready or
- * cleanly-unavailable"): a permanently-un-ready health signal makes the
- * activator's wake gate and every health-gated router treat a working service as
- * down. Exercised through a real Hono request against the REAL exported handler
- * (`proxy-is-not-behaviour`) — a source grep would prove the call exists, never
- * that the endpoint answers 200.
- */
-
-import { beforeAll, describe, expect, test } from "bun:test";
-import { Hono } from "hono";
-import {
-	__resetPhase2StateForTest,
-	getPageHandlerState,
-	healthHandler,
-	markFullAppReady,
-} from "./two-phase-boot.ts";
-
-/** Mount the real handler exactly as buildMinimalApp does. */
-const app = new Hono().get("/health", healthHandler);
-
-describe("/health for a client-only service", () => {
-	// Bun shares one module instance across every test file in a run, so the SSR
-	// readiness test's setPageHandler leaks into this file when both run together.
-	// Without this reset the suite passes file-by-file and fails in CI.
-	beforeAll(() => {
-		__resetPhase2StateForTest();
-	});
-
-	test("before phase 2 completes it reports 503, not ready", async () => {
-		expect(getPageHandlerState().ready).toBe(false);
-
-		const res = await app.request("/health");
-
-		expect(res.status).toBe(503);
-		expect(await res.json()).toEqual({ status: "starting" });
-	});
-
-	test("reaches ready without an SSR page handler", async () => {
-		// The real client-only phase-2 path: buildFullApp finishes and marks the
-		// app ready WITHOUT setPageHandler, because there is no SSR handler.
-		markFullAppReady();
-
-		const state = getPageHandlerState();
-		expect(state.ready).toBe(true);
-		// The discriminator: ready is true while hasHandler stays false. Asserting
-		// both is what separates this from the SSR path — a fix that flipped ready
-		// by registering a dummy handler would pass `ready` and fail here.
-		expect(state.hasHandler).toBe(false);
-
-		const res = await app.request("/health");
-
-		expect(res.status).toBe(200);
-		expect(res.ok).toBe(true);
-		expect(await res.json()).toEqual({ status: "ok" });
-	});
-});