@teamscala/service-boot 0.23.317 → 0.23.319

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

@@ -21,7 +21,7 @@ mock.module("@teamscala/db/registry/platform", () => ({
 	getPlatformOrgId: () => "platform-org-test",
 }));
 
-const { resolveBindOrg, discardApplied, untrackedRunForPane } = await import(
+const { resolveBindOrg, discardApplied } = await import(
 	"./task-sync-router.ts"
 );
 
@@ -86,25 +86,25 @@ describe("lane task binding is deterministic and race-proof (source contract)",
 		expect(text).toContain("const winner = await resolveLaneTask(prisma, session)");
 	});
 
-	test("bindLane only fills an untracked run and preserves dispatched task identity", () => {
-		expect(untrackedRunForPane("tmux:%77")).toEqual({
-			pane: "tmux:%77",
-			state: { not: "closed" },
-			tracked_task_id: null,
-		});
+	test("bindLane leaves runtime identity to cli_sessions", async () => {
+		const text = await src.text();
+		const bindLane = text.slice(text.indexOf("bindLane:"), text.indexOf("upsertFromTaskList:"));
+		expect(bindLane).toContain("Runtime identity is owned by cli_sessions");
+		expect(bindLane).not.toContain("tracked_task_id");
+	});
+
+	test("task events resolve pane identity through cli_sessions", async () => {
+		const text = await src.text();
+		const resolver = text.slice(text.indexOf("async function resolveSessionFromPane"), text.indexOf("/** Resolve the task"));
+		expect(resolver).toContain("prisma.cli_sessions.findFirst");
+		expect(resolver).toContain('path: ["pane_id"]');
 	});
 
-	test("bindLane STEALS tracked_task_id before claiming (no two live runs share a task)", async () => {
+	test("readTaskList returns the checklist with evidence-derived progress", async () => {
 		const text = await src.text();
-		// The partial unique index fleet_agent_runs_one_active_run_per_task means a
-		// task is tracked by at most one LIVE run. Re-adoption on a new pane left the
-		// old run holding the task; claiming without first releasing it made the next
-		// state->active transition (upsertLaneRun's UPDATE) violate the index
-		// (P2002 -> the lane-event 500 + the lost run-link join). Release-then-claim
-		// steals it: only this lane's untracked run ends up with it.
-		expect(text).toContain("STEAL before CLAIM");
-		expect(text).toContain(
-			"tracked_task_id: taskId, state: { not: \"closed\" }",
-		);
+		const reader = text.slice(text.indexOf("readTaskList:"), text.indexOf("/**\n\t * DB→AGENT self-brief"));
+		expect(reader).toContain("deriveEvidenceProgress(rows, evidence)");
+		expect(reader).toContain("subtasks");
+		expect(reader).not.toContain("percentage from");
 	});
 });

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

@@ -5,56 +5,84 @@
  *
  * Unit tests for the self-brief leg: shapeBriefResponse (the pure
  * no-task/no-comment ⇒ nulls decision) + source-contract assertions that
- * readLatestTaskComment reads the LATEST comment and the handler resolves by
+ * readFirstTaskComment reads the FIRST launch comment and the handler resolves by
  * session. Covers `what-must-have-a-test` for the new procedure.
  */
 import { describe, it, expect } from "bun:test";
-import { shapeBriefResponse, readLatestTaskComment } from "./task-sync-brief.ts";
+import { shapeBriefResponse, readFirstTaskComment } from "./task-sync-brief.ts";
 
 describe("shapeBriefResponse (no verdict from no data)", () => {
-	it("returns all-null when there is no task", () => {
-		// A lane with no bound task has no brief — null, never an empty fake.
-		expect(shapeBriefResponse(null, { content: "x", created_at: new Date() })).toEqual({
+	it("classifies a missing task as unbound (work_item_id null)", () => {
+		// A lane with no resolvable task has no brief — null, never an empty fake.
+		// status:"unbound" is the signal a non-fleet lane no-ops on and a fleet
+		// lane (which resolves by work_item_id, so cannot reach this) never sees.
+		expect(shapeBriefResponse(null, { id: "c-0", content: "x", created_at: new Date() })).toEqual({
 			work_item_id: null,
+			comment_id: null,
 			brief: null,
 			comment_created_at: null,
+			status: "unbound",
 		});
 	});
 
-	it("returns all-null when the task has no comment yet", () => {
-		// The task exists but no spawn comment landed; the extension must inject
-		// nothing rather than a fabricated brief.
+	it("classifies a task with NO comment as no_comment (work_item_id SET)", () => {
+		// The task resolved but no spawn comment landed. work_item_id is now SET
+		// (the task IS bound) — distinct from unbound — and status:"no_comment"
+		// is the broken state a fleet lane halts on rather than reading as success.
 		expect(shapeBriefResponse({ id: "task-1" }, null)).toEqual({
-			work_item_id: null,
+			work_item_id: "task-1",
+			comment_id: null,
+			brief: null,
+			comment_created_at: null,
+			status: "no_comment",
+		});
+	});
+
+	it("classifies a task with a BLANK comment as empty_brief (the unreadable case)", () => {
+		// The comment exists but its content is empty/whitespace — "loads it
+		// empty". A fleet lane whose spawn minted a task MUST have a non-empty
+		// brief, so a blank comment is a defect the hook halts on, not a success.
+		expect(shapeBriefResponse({ id: "task-2" }, { id: "c-2", content: "   ", created_at: new Date() })).toEqual({
+			work_item_id: "task-2",
+			comment_id: "c-2",
 			brief: null,
 			comment_created_at: null,
+			status: "empty_brief",
+		});
+		expect(shapeBriefResponse({ id: "task-2b" }, { id: "c-2b", content: "", created_at: new Date() })).toEqual({
+			work_item_id: "task-2b",
+			comment_id: "c-2b",
+			brief: null,
+			comment_created_at: null,
+			status: "empty_brief",
 		});
 	});
 
-	it("returns the comment content + ISO created_at for a resolved task+comment", () => {
+	it("returns the comment content + ISO created_at + status ready for a resolved task+comment", () => {
 		const ts = new Date("2026-08-01T03:24:00.000Z");
-		expect(shapeBriefResponse({ id: "task-7" }, { content: "Do the thing", created_at: ts })).toEqual({
+		expect(shapeBriefResponse({ id: "task-7" }, { id: "c-7", content: "Do the thing", created_at: ts })).toEqual({
 			work_item_id: "task-7",
+			comment_id: "c-7",
 			brief: "Do the thing",
 			comment_created_at: "2026-08-01T03:24:00.000Z",
+			status: "ready",
 		});
 	});
 
 	it("serializes the comment created_at deterministically (Date → ISO)", () => {
 		const ts = new Date(0);
-		const out = shapeBriefResponse({ id: "t" }, { content: "c", created_at: ts });
+		const out = shapeBriefResponse({ id: "t" }, { id: "c", content: "c", created_at: ts });
 		expect(out.comment_created_at).toBe("1970-01-01T00:00:00.000Z");
 	});
 });
 
-describe("readAssignedBrief reads the LATEST comment (source contract)", () => {
+describe("readAssignedBrief reads the FIRST launch comment (source contract)", () => {
 	const briefSrc = Bun.file(new URL("./task-sync-brief.ts", import.meta.url).pathname);
 
-	it("queries comments newest-first by created_at on work_item_id", async () => {
-		// The comment IS the brief for a run; ordering by created_at desc makes the
-		// LATEST comment (this run's) the answer, never a stale prior-run comment.
+	it("queries comments oldest-first with an id tie-breaker", async () => {
+		// The first comment is immutable launch identity; later comments are dialogue.
 		const text = await briefSrc.text();
-		expect(text).toContain('orderBy: { created_at: "desc" }');
+		expect(text).toContain('orderBy: [{ created_at: "asc" }, { id: "asc" }]');
 		expect(text).toContain("work_item_id: workItemId");
 	});
 
@@ -64,14 +92,29 @@ describe("readAssignedBrief reads the LATEST comment (source contract)", () => {
 		const text = await briefSrc.text();
 		expect(text).toContain("resolveLaneTask(prisma, session)");
 	});
+
+	it("resolves by the authoritative work_item_id BEFORE the session (deletes the bind race)", async () => {
+		// The spawn's known task id (SCALA_LANE_WORK_ITEM) cannot race — the row
+		// exists because the spawn created it — so resolving by it first makes an
+		// empty brief for a fleet lane unambiguously broken rather than a
+		// transient "retry" the lane can never exit (absent-input-reads-as-success).
+		const text = await briefSrc.text();
+		expect(text).toContain("workItemId");
+		expect(text).toContain("resolveTaskById(prisma, workItemId)");
+		// The session bind is no longer load-bearing for brief delivery: it stays
+		// only as the fallback for callers without a work_item_id.
+		const idIdx = text.indexOf("resolveTaskById(prisma, workItemId)");
+		const sessionIdx = text.indexOf("resolveLaneTask(prisma, session)");
+		expect(idIdx).toBeGreaterThan(-1);
+		expect(sessionIdx).toBeGreaterThan(idIdx);
+	});
 });
 
-describe("readLatestTaskComment is a single latest-comment read", () => {
+describe("readFirstTaskComment is a single deterministic launch-comment read", () => {
 	it("returns null when the prisma client has no comments model (feature-detect)", async () => {
-		// `comments` is a universal shared model, but the access is feature-detected
-		// like the fleet_agent_runs reads so a client without it degrades to "no
-		// brief" rather than throwing.
-		const out = await readLatestTaskComment({} as never, "task-1");
+		// `comments` is a universal shared model; a client without it degrades to
+		// "no brief" rather than throwing.
+		const out = await readFirstTaskComment({} as never, "task-1");
 		expect(out).toBe(null);
 	});
 });

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

@@ -5,7 +5,7 @@
  *
  * Lane BRIEF resolution for task-sync: a spawned lane PULLS its own brief. The
  * lane's CLI extension reads its own session id on load, resolves the task
- * assigned to that session, and reads the brief from that task's LATEST comment.
+ * assigned to that session, and reads the brief from that task's FIRST comment.
  * Nothing is pasted, typed, passed as an argument or sent over a channel
  * (`scala-docs/reference/action-emission-architecture.md` "The lane PULLS its
  * brief"). This file owns the readAssignedBrief ORPC handler + its pure helper;
@@ -25,38 +25,77 @@
 import type { Prisma, CommentRow } from "./task-sync-router.ts";
 import type { WorkItem } from "./task-sync-router.ts";
 import { authed, type Context } from "./auth-router.ts";
-import { resolveLaneTask } from "./task-sync-lane.ts";
+import { resolveLaneTask, resolveTaskById } from "./task-sync-lane.ts";
 
 /**
- * Shape the readAssignedBrief response from a resolved task + its latest
+ * The outcome of a brief read, single-sourced here so every CLI's self-brief
+ * hook (zerostack/codex shell, opencode/pi TS) branches on ONE field rather
+ * than each re-deriving "is the brief missing" from null/empty probes — the
+ * seam at which absent-input-reads-as-success hid (`the-severe-bugs-live-at-seams`).
+ *
+ * The hook decides ACTION from this; the classification lives here. A fleet
+ * lane (SCALA_LANE_WORK_ITEM set) treats anything but "ready" as a hard halt.
+ */
+export type BriefReadStatus = "ready" | "empty_brief" | "no_comment" | "unbound";
+
+/**
+ * Shape the readAssignedBrief response from a resolved task + its first
  * comment. Pure (no prisma) so the decision — "no task/comment ⇒ nulls, never a
- * verdict from no data" (`no-verdict-from-no-data`) — is unit-testable. A null
- * task or null comment returns all-null rather than an empty/fake brief, so the
- * extension can distinguish "nothing to inject" from "inject this".
+ * verdict from no data" (`no-verdict-from-no-data`) — is unit-testable.
+ *
+ * `work_item_id` is set iff the TASK resolved (independent of whether a comment
+ * exists), and `status` distinguishes the four states a hook must act on:
+ *   - "ready"        — task + a non-empty comment: inject the brief.
+ *   - "empty_brief"  — task resolved, comment exists but content is blank: the
+ *                      spawn minted a task with no usable brief — broken.
+ *   - "no_comment"   — task resolved, no comment at all: same broken class.
+ *   - "unbound"      — no task resolved: the lane has no brief task (a non-fleet
+ *                      operator tab, or — for the session-only path — a bind
+ *                      that has not yet commit; the work_item_id path cannot
+ *                      reach this for a fleet lane).
+ *
+ * "empty_brief" / "no_comment" with the task resolved is the state the
+ * absent-input fix exists to catch: a fleet lane whose spawn succeeded MUST
+ * have a non-empty brief comment, so its absence is a defect the hook halts on
+ * rather than reading as success.
  */
 export function shapeBriefResponse(
 	task: { id: string } | null,
-	comment: Pick<CommentRow, "content" | "created_at"> | null,
-): { work_item_id: string | null; brief: string | null; comment_created_at: string | null } {
-	if (!task || !comment) {
-		return { work_item_id: null, brief: null, comment_created_at: null };
+	comment: Pick<CommentRow, "id" | "content" | "created_at"> | null,
+): {
+	work_item_id: string | null;
+	comment_id: string | null;
+	brief: string | null;
+	comment_created_at: string | null;
+	status: BriefReadStatus;
+} {
+	if (!task) {
+		return { work_item_id: null, comment_id: null, brief: null, comment_created_at: null, status: "unbound" };
+	}
+	if (!comment) {
+		return { work_item_id: task.id, comment_id: null, brief: null, comment_created_at: null, status: "no_comment" };
+	}
+	const text = typeof comment.content === "string" ? comment.content : String(comment.content);
+	if (text.trim() === "") {
+		return { work_item_id: task.id, comment_id: comment.id, brief: null, comment_created_at: null, status: "empty_brief" };
 	}
 	return {
 		work_item_id: task.id,
-		brief: comment.content,
+		comment_id: comment.id,
+		brief: text,
 		comment_created_at:
 			comment.created_at instanceof Date ? comment.created_at.toISOString() : String(comment.created_at),
+		status: "ready",
 	};
 }
 
 /**
- * Read the LATEST comment on a work_items task. The comment IS the brief for a
- * run: every spawn writes a NEW comment, and the description is never the brief,
- * so "what was this lane told" always has exactly one answer
- * (`assignment-as-dispatch`). Newest-first by created_at. Returns null when the
- * task has no comment yet — the extension treats that as "no brief to inject".
+ * Read the immutable FIRST comment on a work_items task. It is the launch brief;
+ * later comments are conversation and must never change the launch identity.
+ * Oldest-first by created_at with id as a deterministic tie-breaker. Returns null
+ * when the task has no comment yet.
  */
-export async function readLatestTaskComment(
+export async function readFirstTaskComment(
 	prisma: Prisma,
 	workItemId: string,
 ): Promise<CommentRow | null> {
@@ -70,7 +109,7 @@ export async function readLatestTaskComment(
 	if (!comments?.findFirst) return null;
 	return comments.findFirst({
 		where: { work_item_id: workItemId },
-		orderBy: { created_at: "desc" },
+		orderBy: [{ created_at: "asc" }, { id: "asc" }],
 	});
 }
 
@@ -84,14 +123,29 @@ export async function readLatestTaskComment(
 export const readAssignedBriefHandler = authed.handler(async ({ input, context }) => {
 	const ctx = context as Context;
 	const prisma = ctx.prisma as Prisma;
-	const body = (input ?? {}) as { lane_session?: string };
+	const body = (input ?? {}) as { lane_session?: string; work_item_id?: string };
 	const session = body.lane_session ?? ctx.headers?.get("x-lane-session") ?? null;
-	if (!session) {
+	// The spawn's known task id (SCALA_LANE_WORK_ITEM) — AUTHORITATIVE for brief
+	// resolution. Resolving by it first deletes the bindLane race that made an
+	// empty brief read as a transient "retry" a fleet lane could never exit
+	// (absent-input-reads-as-success). Falls back to session for callers without
+	// it (operator tabs / pre-id lanes).
+	const workItemId =
+		body.work_item_id?.trim() || ctx.headers?.get("x-lane-work-item")?.trim() || null;
+	if (!session && !workItemId) {
 		const { ORPCError } = await import("@orpc/server");
-		throw new ORPCError("BAD_REQUEST", { message: "readAssignedBrief requires lane_session" });
+		throw new ORPCError("BAD_REQUEST", {
+			message: "readAssignedBrief requires lane_session or work_item_id",
+		});
+	}
+	let task: (WorkItem & { id: string }) | null = null;
+	if (workItemId) {
+		task = (await resolveTaskById(prisma, workItemId)) as (WorkItem & { id: string }) | null;
+	}
+	if (!task && session) {
+		task = (await resolveLaneTask(prisma, session)) as (WorkItem & { id: string }) | null;
 	}
-	const task = (await resolveLaneTask(prisma, session)) as (WorkItem & { id: string }) | null;
 	if (!task) return shapeBriefResponse(null, null);
-	const comment = await readLatestTaskComment(prisma, task.id);
+	const comment = await readFirstTaskComment(prisma, task.id);
 	return shapeBriefResponse(task, comment);
 });

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

@@ -0,0 +1,44 @@
+/**
+ * @system service-boot
+ * @status handwritten
+ * @edit edit directly
+ */
+
+import { describe, expect, it } from "bun:test";
+import { closedTaskState } from "./task-sync-close.ts";
+
+const task = {
+	id: "task-1",
+	kind_data: {
+		lane: { session: "acp-session", cli_kind: "zerostack", live: true },
+		assignee_type: "agent",
+	},
+};
+
+describe("closedTaskState", () => {
+	it("marks completed work done and the lane non-live", () => {
+		expect(closedTaskState(task, "completed")).toEqual({
+			task_id: "task-1",
+			task_status: "done",
+			completed: true,
+			kind_data: {
+				lane: { session: "acp-session", cli_kind: "zerostack", live: false },
+				assignee_type: "agent",
+			},
+		});
+	});
+
+	it("archives every disposition that does not prove completion", () => {
+		for (const disposition of [
+			"needs_retry",
+			"failed",
+			"orchestrator_closed",
+			"orphaned",
+		] as const) {
+			const state = closedTaskState(task, disposition);
+			expect(state.task_status).toBe("archived");
+			expect(state.completed).toBe(false);
+			expect((state.kind_data.lane as { live: boolean }).live).toBe(false);
+		}
+	});
+});

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

@@ -0,0 +1,82 @@
+/**
+ * @system service-boot
+ * @status handwritten
+ * @edit edit directly
+ *
+ * Lane-close write-through for task-sync. The session-owning fleet runtime
+ * calls this ORPC procedure before releasing an ACP lane, so work_items remains
+ * the durable lifecycle source without a second raw-SQL writer in the host.
+ */
+
+import { ORPCError } from "@orpc/server";
+import * as v from "valibot";
+import { authed, type Context } from "./auth-router.ts";
+import type { Prisma, WorkItem } from "./task-sync-router.ts";
+
+export const closeLaneInput = v.object({
+	lane_session: v.pipe(v.string(), v.minLength(1, "lane_session is required")),
+	disposition: v.picklist([
+		"completed",
+		"needs_retry",
+		"failed",
+		"orchestrator_closed",
+		"orphaned",
+	]),
+});
+
+export interface ClosedTaskState {
+	task_id: string;
+	task_status: "done" | "archived";
+	completed: boolean;
+	kind_data: Record<string, unknown>;
+}
+
+export function closedTaskState(
+	task: Pick<WorkItem, "id" | "kind_data">,
+	disposition: v.InferOutput<typeof closeLaneInput>["disposition"],
+): ClosedTaskState {
+	const completed = disposition === "completed";
+	const lane =
+		task.kind_data.lane && typeof task.kind_data.lane === "object"
+			? (task.kind_data.lane as Record<string, unknown>)
+			: {};
+	return {
+		task_id: task.id,
+		task_status: completed ? "done" : "archived",
+		completed,
+		kind_data: { ...task.kind_data, lane: { ...lane, live: false } },
+	};
+}
+
+export const closeLaneHandler = authed
+	.input(closeLaneInput)
+	.handler(async ({ input, context }) => {
+		const prisma = (context as Context).prisma as Prisma;
+		const task = await prisma.work_items.findFirst({
+			where: {
+				kind: "task",
+				kind_data: { path: ["lane", "session"], equals: input.lane_session },
+			},
+			orderBy: { created_at: "desc" },
+		});
+		if (!task) {
+			throw new ORPCError("NOT_FOUND", {
+				message: `No task is bound to ACP lane ${input.lane_session}`,
+			});
+		}
+		const state = closedTaskState(task, input.disposition);
+		await prisma.work_items.update({
+			where: { id: task.id },
+			data: {
+				kind_data: state.kind_data,
+				status: state.task_status,
+				completed: state.completed,
+			},
+			select: { id: true },
+		});
+		return {
+			task_id: state.task_id,
+			task_status: state.task_status,
+			reconciled: true,
+		};
+	});

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

@@ -3,42 +3,60 @@
  * @status handwritten
  * @edit edit directly
  *
- * Unit tests for the pure event-payload builder in task-sync-dispatch. The HTTP
- * POST + registry resolution are side-effectful (covered end-to-end by the
- * DB->AGENT direction demo — a published orchestrator.message with slotName
- * cross-pane delivers to the target pane's <channel> tag); buildTaskChangedEvent
- * is pure and tested here. Satisfies what-must-have-a-test / primitive-api-has-test.
+ * Unit tests for the pure durable comment-payload builder in task-sync-dispatch.
+ * The runtime path writes this payload through the canonical comments model.
  */
 import { describe, it, expect } from "bun:test";
-import { buildTaskChangedEvent } from "./task-sync-dispatch.ts";
+import { buildTaskChangeComment, notifyLaneOfTaskChange } from "./task-sync-dispatch.ts";
 
-describe("task-sync buildTaskChangedEvent", () => {
-	it("is an orchestrator.message addressed to the owning lane pane", () => {
-		const e = buildTaskChangedEvent("tmux:%5", "task-7", 1700000000000);
-		expect(e.type).toBe("orchestrator.message");
-		expect(e.orchestratorSessionId).toBe("tmux:%5");
-	});
-
-	it("uses slotName cross-pane so watchEvents bypasses the fleet-run-existence check", () => {
-		const e = buildTaskChangedEvent("tmux:%5", "task-7", 1700000000000);
-		expect(e.slotName).toBe("cross-pane");
-	});
+	describe("task-sync buildTaskChangeComment", () => {
+		it("addresses the canonical task and runtime with no pane transport", () => {
+			const comment = buildTaskChangeComment("task-7", "session-5", "subtask-1:completed");
+			expect(comment).toMatchObject({
+				work_item_id: "task-7",
+				source_cli_session_id: "session-5",
+				sender_role: "system",
+				sender_name: "TaskSync",
+			});
+			expect(comment.system_key).toBe("task-sync:task-7:session-5:subtask-1:completed");
+			expect(comment.content).toContain("readTaskList");
+			expect(comment).not.toHaveProperty("pane");
+		});
 
-	it("carries the task id in the message so the recipient can re-read just it", () => {
-		const e = buildTaskChangedEvent("tmux:%5", "task-7", 1700000000000);
-		expect(e.message).toContain("task-7");
-		expect(e.message).toContain("readTaskList");
-	});
-
-	it("produces a single-line message (the <channel> tag renders it inline)", () => {
-		const e = buildTaskChangedEvent("tmux:%5", "task-7", 1700000000000);
-		expect(e.message.includes("\n")).toBe(false);
-	});
+		it("writes one durable comment addressed by the active cli_session", async () => {
+			const calls: unknown[] = [];
+			const result = await notifyLaneOfTaskChange(
+				{
+					cli_sessions: { findFirst: async () => ({ id: "session-5" }) },
+					comments: {
+						upsert: async (args) => {
+							calls.push(args);
+							return { id: "comment-1" };
+						},
+					},
+				},
+				"task-7",
+				"subtask-1:completed",
+			);
+			expect(result).toMatchObject({ delivered: true, sessionId: "session-5", commentId: "comment-1" });
+			expect(calls[0]).toMatchObject({ create: { work_item_id: "task-7", source_cli_session_id: "session-5" } });
+		});
 
-	it("stamps the system sender + a deterministic runId + the provided epoch-ms ts", () => {
-		const e = buildTaskChangedEvent("tmux:%5", "task-7", 1700000000000);
-		expect(e.fromOrchestratorId).toBe("task-sync");
-		expect(e.runId).toBe("task-sync-task-7-1700000000000");
-		expect(e.ts).toBe(1700000000000);
+		it("does not fabricate a pre-launch session or comment", async () => {
+			let writes = 0;
+			const result = await notifyLaneOfTaskChange(
+				{
+					cli_sessions: { findFirst: async () => null },
+					comments: {
+						upsert: async () => {
+							writes++;
+							return { id: "unexpected" };
+						},
+					},
+				},
+				"task-7",
+			);
+			expect(result).toEqual({ delivered: false, sessionId: null, commentId: null });
+			expect(writes).toBe(0);
+		});
 	});
-});