@teamscala/service-boot 0.23.350 → 0.23.352

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

@@ -1,120 +0,0 @@
-/**
- * @system service-boot
- * @status handwritten
- * @edit edit directly
- *
- * Unit tests for the self-brief leg: shapeBriefResponse (the pure
- * no-task/no-comment ⇒ nulls decision) + source-contract assertions that
- * 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, readFirstTaskComment } from "./task-sync-brief.ts";
-
-describe("shapeBriefResponse (no verdict from no data)", () => {
-	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("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: "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 + status ready for a resolved task+comment", () => {
-		const ts = new Date("2026-08-01T03:24:00.000Z");
-		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" }, { id: "c", content: "c", created_at: ts });
-		expect(out.comment_created_at).toBe("1970-01-01T00:00:00.000Z");
-	});
-});
-
-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 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: "asc" }, { id: "asc" }]');
-		expect(text).toContain("work_item_id: workItemId");
-	});
-
-	it("resolves the task by session before reading its comment", async () => {
-		// The lane's own session id is the join key — a pane id is never the key
-		// (it outlives the session and would inherit a prior session's brief).
-		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("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; 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

@@ -1,151 +0,0 @@
-/**
- * @system service-boot
- * @status handwritten
- * @edit edit directly
- *
- * 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 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;
- * the router mounts the handler.
- *
- * Split out of task-sync-router.ts for the same reason task-sync-lane.ts +
- * task-sync-projection.ts exist: the router sits at its 1000-line commit gate,
- * so every cohesive unit that can live in a sibling does. The self-brief leg is
- * one unit — the handler + the response-shaping decision belong together.
- *
- * CAPABILITY HARVEST (capability-harvest-on-split): APP-LOCAL, not a capability
- * candidate. Bound to the work_items + comments schema and to task-sync's own
- * kind_data.lane.session convention; no unrelated app could install this
- * unmodified.
- */
-
-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, resolveTaskById } from "./task-sync-lane.ts";
-
-/**
- * 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.
- *
- * `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, "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,
-		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 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 readFirstTaskComment(
-	prisma: Prisma,
-	workItemId: string,
-): Promise<CommentRow | null> {
-	const comments = (
-		prisma as unknown as {
-			comments?: {
-				findFirst: (a: unknown) => Promise<CommentRow | null>;
-			};
-		}
-	).comments;
-	if (!comments?.findFirst) return null;
-	return comments.findFirst({
-		where: { work_item_id: workItemId },
-		orderBy: [{ created_at: "asc" }, { id: "asc" }],
-	});
-}
-
-/**
- * readAssignedBrief ORPC handler. A lane's CLI extension calls this with its
- * own session id to pull its brief. Same transport as bindLane/readTaskList: the
- * session id arrives on x-lane-session (and body.lane_session as fallback). The
- * procedure is page-gate-exempt (fn.taskSync), so a localhost pane shell
- * authenticates as super-admin via resolveUser with no session cookie.
- */
-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; work_item_id?: string };
-	const session = body.lane_session ?? ctx.headers?.get("x-lane-session") ?? null;
-	// 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 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;
-	}
-	if (!task) return shapeBriefResponse(null, null);
-	const comment = await readFirstTaskComment(prisma, task.id);
-	return shapeBriefResponse(task, comment);
-});

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

@@ -1,109 +0,0 @@
-/**
- * @system service-boot
- * @status handwritten
- * @edit edit directly
- *
- * Tests for classifyTaskHookEvent — the discriminator between the Claude task
- * lifecycle legs.
- *
- * The regression this locks: `TaskCreated` and `TaskCompleted` BOTH carry
- * `task_subject`, so the handler's original "has a subject → it's a creation"
- * test could not tell them apart. Only `TaskCreated` was ever wired, so nothing
- * exercised the ambiguity — but the moment completion is wired, a completion
- * classified as a creation mints a DUPLICATE subtask instead of closing one.
- * That is the operator-visible symptom exactly: a task list that only ever
- * grows, with everything reading incomplete (`task-projection-converges`).
- */
-
-import { describe, expect, test } from "bun:test";
-import { classifyTaskHookEvent, sanitizeTaskSubject } from "./task-sync-router.ts";
-
-describe("classifyTaskHookEvent", () => {
-	test("a completion carrying a subject is COMPLETED, not a creation", () => {
-		// The exact shape the TaskCompleted hook delivers: subject present.
-		expect(
-			classifyTaskHookEvent({
-				hook_event_name: "TaskCompleted",
-				task_subject: "Verify bindLane populates Task",
-			}),
-		).toBe("completed");
-	});
-
-	test("a creation carrying a subject is CREATED", () => {
-		expect(
-			classifyTaskHookEvent({
-				hook_event_name: "TaskCreated",
-				task_subject: "Verify bindLane populates Task",
-			}),
-		).toBe("created");
-	});
-
-	test("subject alone still classifies as created (payloads predating hook_event_name)", () => {
-		expect(classifyTaskHookEvent({ task_subject: "Some task" })).toBe("created");
-	});
-
-	test("a PostToolUse-shaped payload with no subject falls through to the tool leg", () => {
-		expect(classifyTaskHookEvent({})).toBe("tool");
-		expect(classifyTaskHookEvent({ hook_event_name: "PostToolUse" })).toBe("tool");
-	});
-
-	test("event name WINS over subject presence — the whole point", () => {
-		// If this ever inverts, completions silently become duplicate creations.
-		const completed = classifyTaskHookEvent({
-			hook_event_name: "TaskCompleted",
-			task_subject: "x",
-		});
-		const created = classifyTaskHookEvent({
-			hook_event_name: "TaskCreated",
-			task_subject: "x",
-		});
-		expect(completed).not.toBe(created);
-	});
-});
-
-// The subjects below are the REAL corrupted values found in work_items on
-// 2026-07-25 — three rows whose titles rendered on the fleet dashboard as a
-// wall of XML where the operator expects a task name. The malformation happens
-// upstream in the CLI's hook payload, so the write boundary is the only place
-// that can stop it reaching the single source of truth every surface reads.
-describe("sanitizeTaskSubject", () => {
-	test("cuts the leaked tool call, keeping the real subject", () => {
-		expect(
-			sanitizeTaskSubject(
-				'Cut judge false positives on clean work</subject>\n<parameter name="description">Live gate blocks ~half of clean drafts (7 of 7 failures were clean).',
-			),
-		).toBe("Cut judge false positives on clean work");
-
-		expect(
-			sanitizeTaskSubject(
-				'Give benchmark drafts synthetic tool activity</subject>\n<parameter name="description">The labelled suite sends drafts with no tool activity.',
-			),
-		).toBe("Give benchmark drafts synthetic tool activity");
-	});
-
-	test("cuts on a bare next-parameter marker with no closing tag", () => {
-		expect(sanitizeTaskSubject('Do the thing<parameter name="description">blah')).toBe(
-			"Do the thing",
-		);
-	});
-
-	test("leaves an ordinary subject untouched", () => {
-		// Including ones with punctuation that merely LOOKS structural — angle
-		// brackets alone are not a leak, only the tool-call markers are.
-		expect(sanitizeTaskSubject("Bound the pg-boss pool")).toBe("Bound the pg-boss pool");
-		expect(sanitizeTaskSubject("  Fix a < b comparison  ")).toBe("Fix a < b comparison");
-		expect(sanitizeTaskSubject("Rename foo -> bar")).toBe("Rename foo -> bar");
-	});
-
-	test("truncates rather than discards, so the task is not lost", () => {
-		// Dropping the row would lose a task the lane genuinely created; the text
-		// before the marker is the real subject and is worth keeping.
-		expect(sanitizeTaskSubject("Real subject</subject>junk").length).toBeGreaterThan(0);
-	});
-
-	test("an entirely-markup subject collapses to empty so the caller discards it", () => {
-		// The create leg treats "" as no-subject and records a discard — correct,
-		// because there is no real title to keep here.
-		expect(sanitizeTaskSubject('</subject><parameter name="description">x')).toBe("");
-	});
-});

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

@@ -1,44 +0,0 @@
-/**
- * @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

@@ -1,82 +0,0 @@
-/**
- * @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-created-status.test.ts

@@ -1,58 +0,0 @@
-/**
- * A task CREATED already finished must project as done, not open.
- *
- * `TaskCreate({status:"completed"})` is the normal way to record work performed
- * after the fact. The create path hardcoded `status: "todo"`, so such a task
- * landed OPEN and the stop gate then blocked the lane on a task it had itself
- * recorded as done — observed twice on 2026-07-31, each needing a manual
- * work_items update to clear. The UPDATE path already mapped through
- * STATUS_TO_WORK_ITEM; only create dropped it.
- *
- * The derivation is asserted directly because that is the whole change: the map
- * lookup plus the `?? "todo"` default. The default is what makes the fix safe
- * regardless of whether the hook actually sends the field — correct if it does,
- * byte-identical to the old behaviour if it does not.
- */
-import { expect, test } from "bun:test";
-import { STATUS_TO_WORK_ITEM } from "./task-sync-projection.ts";
-
-type Status = "pending" | "in_progress" | "completed";
-const derive = (s: unknown) => STATUS_TO_WORK_ITEM[s as Status] ?? "todo";
-
-test("created completed -> done (the case that blocked the stop gate)", () => {
-	expect(derive("completed")).toBe("done");
-	expect(derive("completed") === "done").toBe(true);
-});
-
-test("created in_progress -> in-progress (DB enum uses the hyphen)", () => {
-	expect(derive("in_progress")).toBe("in-progress");
-});
-
-test("created pending -> todo", () => {
-	expect(derive("pending")).toBe("todo");
-});
-
-test("ABSENT status -> todo — the fix is inert when the hook omits the field", () => {
-	// This is the safety property. If the payload carries no status the lookup
-	// misses and the default reproduces the previous hardcoded behaviour exactly,
-	// so shipping this cannot regress any existing create path.
-	expect(derive(undefined)).toBe("todo");
-	expect(derive(null)).toBe("todo");
-});
-
-test("unknown status -> todo rather than throwing", () => {
-	// A CLI sending a status this platform does not model must degrade to open,
-	// never crash the hook — a task-sync throw takes the lane's whole list down.
-	expect(derive("archived")).toBe("todo");
-	expect(derive(42)).toBe("todo");
-});
-
-test("only the done mapping sets completed", () => {
-	// `completed` is a separate column from `status`; deriving it from the same
-	// value keeps the two from disagreeing (a done row with completed=false reads
-	// as open to every consumer that checks the boolean).
-	for (const s of ["pending", "in_progress"] as const) {
-		expect(derive(s) === "done").toBe(false);
-	}
-	expect(derive("completed") === "done").toBe(true);
-});

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

@@ -1,62 +0,0 @@
-/**
- * @system service-boot
- * @status handwritten
- * @edit edit directly
- *
- * 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 { buildTaskChangeComment, notifyLaneOfTaskChange } from "./task-sync-dispatch.ts";
-
-	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("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("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);
-		});
-	});