@teamscala/service-boot 0.23.350 → 0.23.352

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

@@ -1,485 +0,0 @@
-/**
- * @system service-boot
- * @status handwritten
- * @indivisible-unit
- * @edit edit directly
- *
- * Lane DISPATCH by assignment — the WRITE half of dispatch-by-assignment. The
- * operator's contract (verbatim intent): you create a task (the NAME), you write
- * the first COMMENT (which IS the prompt/brief), and THEN you assign it to an AI
- * agent — and the assignment is the TRIGGER that spawns the lane. Assignment
- * last, always, because by the time the agent exists every piece of information
- * it needs is already in the row.
- *
- * This file owns the two pure halves of that flow, split out of task-sync-router
- * (which sits at its 1000-line commit gate, so any new task-sync unit lands in a
- * sibling — the same reason task-sync-brief/lane/dispatch exist):
- *   createTaskWithBriefComment — create the task AND its first comment (the
- *     description IS the first comment IS the brief) in one transaction. An
- *     incomplete task is UNCONSTRUCTIBLE: the ORPC `.input()` schema
- *     (`assignTaskInput`) requires name + description TOGETHER, so oRPC rejects
- *     the call before the handler runs (`prevention-over-detection` — require at
- *     the signature, never validate after the fact).
- *   buildAssignmentSpawnPayload — shape the spawn emission that the assignment
- *     emits. It carries the task id and NO initialPrompt, because the spawned
- *     lane PULLS its brief from the DB by its own session id
- *     (`task-sync-brief.ts` readAssignedBrief → latest comment). That deletes the
- *     keystroke-brief failure class (a ~4400-char initialPrompt fails outright;
- *     a ~2600-char one arrives intact and is never submitted, then the pane is
- *     reaped for producing no turn): when the brief is a row, no keystroke can
- *     lose it.
- *
- * THE EMISSION is a row write followed by an emission that triggers the spawn
- * (`actions-are-rows-then-emissions`): the assignment writes the task + comment,
- * then emits; the host-command bus consumer reacts by spawning. State lives in
- * the row, never in a return value a caller may never receive. The exact bus
- * surface this file emits through is INJECTED (AssignmentEmitter) rather than
- * hard-coded, so it composes with whichever surface the host-command-bus cutover
- * lands — one mechanism, not two (`no-silent-reverts` on the spawn path).
- *
- * BINDING (the gap this flow exposes). A lane resolves its task by its CLI-native
- * session id (`kind_data.lane.session`, minted by the CLI at boot — never by us).
- * Today `ensureLaneTask`/`bindLane` CREATE a fresh parent task at SessionStart.
- * But assignment PRE-CREATES the task (with the brief as its first comment, no
- * session yet), so SessionStart must ADOPT THAT EXISTING TASK BY ID — writing the
- * freshly-minted session onto its `kind_data.lane.session` — instead of creating
- * a new one, or the brief-task is orphaned and the lane self-briefs to nothing.
- * The task is created `status:"active"` with no session, so `resolveLaneTask`
- * (which filters `kind_data.lane.session`) cannot see it until bind writes the
- * session — exactly right: the lane resolves it only after it is bound.
- *
- * 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 { getPlatformOrgId } from "@teamscala/db/registry/platform";
-import * as v from "valibot";
-import type { Prisma, WorkItem } from "./task-sync-router.ts";
-import { authed, type Context } from "./auth-router.ts";
-import { getAppLogger } from "@teamscala/logger/app-loggers";
-
-/**
- * The assignment input. `name` + `description` are REQUIRED TOGETHER at the
- * signature: oRPC parses this schema before the handler runs, so a call missing
- * either is rejected with a 400 — an incomplete task is unconstructible, not
- * caught after the fact. `description` becomes the task's first comment (the
- * brief); it is never stored separately on the task, so "the brief" has exactly
- * one home (`task-sync-brief.ts` readLatestTaskComment, newest-first).
- *
- * `name` → work_items.title; `description` → the first comment. `parent_id` is
- * the project the dispatched task is scoped under (omit for an exploratory
- * lane). `slug`/`windowName` shape the spawn; `organisation_id` defaults to the
- * platform org (fleet/internal lane tasks live there).
- */
-/**
- * A lane task's NAME — the lane's real work label, never the generic "Lane"
- * sentinel. A row titled "Lane" is spawn debris: it tells the operator nothing
- * about the work, so an orchestrator cannot tell real unowned work from it (the
- * signal the fleet steers by). Rejected at the ORPC input chokepoint so a spawn
- * that forgot to name its lane is REFUSED at the mint, never written
- * (lanes-named-by-the-spawner — the spawner sets the work name at creation).
- */
-const laneWorkName = v.pipe(
-	v.string(),
-	v.minLength(1, "name is required — the lane's real work label"),
-	v.check(
-		(n) => n.trim().toLowerCase() !== "lane",
-		"name must carry the lane's real work name, not the generic sentinel 'Lane'",
-	),
-);
-
-export const assignTaskInput = v.object({
-	name: laneWorkName,
-	description: v.pipe(
-		v.string(),
-		v.minLength(1, "description is required — it is the brief (first comment)"),
-	),
-	parent_id: v.optional(v.string()),
-	organisation_id: v.optional(v.string()),
-	slug: v.optional(v.string()),
-	windowName: v.optional(v.string()),
-	idempotencyKey: v.optional(v.string()),
-});
-
-/** The resolved (post-schema) shape the handlers operate on. */
-export type AssignTaskInput = v.InferOutput<typeof assignTaskInput>;
-
-/**
- * bindLane ORPC input. Declaring the schema is the documented remedy for the
- * schema-less-body gap (`upsertFromTaskListInput` cites the same measured bug):
- * oRPC does NOT parse a JSON body into `input` for a procedure with no
- * `.input()`, so a SessionStart adapter that POSTs the work item id as a DIRECT
- * body field (`{lane:{...}, parent_id}`) arrives as an EMPTY input — `parent_id`
- * is silently dropped, `adoptAssignmentTask` gets null, no adoption happens, and
- * `readAssignedBrief` returns nulls for a session that has nothing bound to it.
- * That is a DATA gap (nothing bound to the session), never a serving one — which
- * is exactly the misdiagnosis this closes: a prior lane read those nulls as
- * "fn.taskSync is 404" and reached for serving changes, when the row was simply
- * never bound because the body never parsed.
- *
- * ROOT-OPTIONAL (`v.optional(v.object(...))`) so it tolerates a caller that sends
- * a DIRECT body or none at all: oRPC extracts `input` from the `{json:{...}}` RPC
- * envelope, so a raw-object or empty POST yields `undefined`, which the optional
- * root ACCEPTS — the handler then falls back to its headers, exactly as it did
- * schema-less (a header-only caller like zerostack is unchanged). An adapter that
- * wants the body path (pi's `parent_id`) POSTs the `{json:{...}}` envelope and
- * `parent_id` is parsed + reaches `adoptAssignmentTask` — the same envelope
- * convention pi ALREADY uses for upsertFromTaskList. A raw-object POST is NOT
- * parsed (oRPC hands the handler `undefined`), which is why pi's bindLaneTask
- * must move to the envelope to deliver `parent_id`. Every field is optional with
- * a header fallback, so the schema ADDS the body path without removing the header.
- */
-export const bindLaneInput = v.optional(
-	v.object({
-		lane: v.optional(
-			v.object({
-				pane: v.optional(v.string()),
-				session: v.optional(v.string()),
-				cli_kind: v.optional(v.string()),
-				role: v.optional(v.string()),
-				organisation_id: v.optional(v.string()),
-			}),
-		),
-		title: v.optional(v.string()),
-		parent_id: v.optional(v.string()),
-	}),
-);
-
-/**
- * Resolve the org a dispatched task is created under. Pure: the platform org is
- * INJECTED (resolved by the caller at the handler boundary, where a registry
- * read is appropriate) rather than pulled from the registry inside this module,
- * so the create logic is unit-testable with no DB (`configured-primitives`:
- * config arrives from the caller, never pulled from DB/Env inside a primitive).
- */
-export function resolveAssignOrg(explicit?: string, platformOrg?: string): string {
-	return explicit ?? platformOrg ?? getPlatformOrgId();
-}
-
-/**
- * Create a dispatched task AND its first comment (the description = the brief) in
- * one transaction. The task is `kind:"task"`, `status:"active"`, with NO
- * `kind_data.lane.session` yet — the session is minted by the CLI at spawn and
- * written onto the row by SessionStart's adopt-existing bind. Until then the
- * task is invisible to `resolveLaneTask` (which filters on the session), which is
- * correct: the lane may only resolve its task once it is bound to it.
- *
- * Pure over an injected prisma (no module-level I/O) so the atomic create +
- * first-comment decision is unit-testable with a fake transaction. `userId`
- * stamps `created_by`/`updated_by` on the task and `user_id` on the comment.
- */
-export async function createTaskWithBriefComment(
-	prisma: Prisma,
-	input: { name: string; description: string; parent_id?: string; organisation_id: string },
-	userId: string,
-): Promise<WorkItem> {
-	const organisation_id = input.organisation_id;
-	return (prisma as unknown as {
-		$transaction: (fn: (tx: unknown) => Promise<WorkItem>) => Promise<WorkItem>;
-	}).$transaction(async (tx) => {
-		const t = tx as {
-			work_items: { create: (a: unknown) => Promise<WorkItem> };
-			comments: { create: (a: unknown) => Promise<{ id: string }> };
-		};
-		const task = await t.work_items.create({
-			data: {
-				kind: "task",
-				parent_id: input.parent_id ?? null,
-				organisation_id,
-				title: input.name,
-				status: "active",
-				// No kind_data.lane.session here: the CLI mints the session at spawn
-				// and SessionStart binds it. Carrying an empty lane marker would let
-				// resolveLaneTask race a half-bound row, so the key is absent until set.
-				// assignee_type:"agent" marks the task as OWNED BY A LANE from creation,
-				// so the compliance gate can tell a dispatched+supervised task (the
-				// orchestrator does NOT owe it) from the caller's own implementation work
-				// — even before SessionStart writes the session that finalises ownership.
-				kind_data: { assignee_type: "agent" },
-				created_by: userId,
-				updated_by: userId,
-			},
-		});
-		// The description IS the first comment IS the brief — one write, one source.
-		const firstComment = await t.comments.create({
-			data: {
-				work_item_id: task.id,
-				content: input.description,
-				user_id: userId,
-			},
-		});
-		return { ...task, first_comment_id: firstComment.id } as WorkItem & { first_comment_id: string };
-	});
-}
-
-/**
- * ADOPT a pre-created assignment task at SessionStart: write the lane's
- * freshly-minted session onto an EXISTING task row instead of creating a new
- * one. `bindLane` calls this when the spawn carried a `workItemId` that resolves
- * to a `kind:"task"` row (the assignment task whose first comment IS the brief).
- * Without this, bindLane would CREATE a new task and orphan the brief-task — the
- * lane would `readAssignedBrief` to nothing.
- *
- * Realizes OWNERSHIP too: sets `assignee_id` to the lane's session (its stable
- * identity, `lane-identity-is-cli-session-id`), so the compliance gate can
- * distinguish a task the CALLER owes from one a dispatched lane owns (the
- * orchestrator supervises, not implements — `anthropic-models-orchestrate-not-
- * implement`). "Is the caller the assignee" becomes a simple equality on the
- * session.
- *
- * RE-BINDS a task another session already owns. Migration 109
- * (`work_items_one_active_task_per_lane`) makes `(kind_data->'lane'->>'pane')`
- * unique WHERE active, so when a lane is re-spawned on a pane whose prior task is
- * still active under a STALE session (the lane died, the row survived),
- * `resolveLaneTask(newSession)` finds nothing and `create` P2002s — measured
- * fleet-wide 2026-08-01: every real lane's bindLane 500'd on this constraint.
- * Refusing to steal (the original design) routes every re-spawn into that
- * dead-end. An assignment task belongs to whichever lane was dispatched to it,
- * and a stale session is by definition dead, so re-binding to the fresh session
- * is the correct recovery: the pane's unique slot moves to the live lane and
- * the brief follows. Returns null only when `maybeTaskId` is absent or not a
- * task — caller falls through to create for an exploratory lane (no workItemId).
- */
-export async function adoptAssignmentTask(
-	prisma: Prisma,
-	maybeTaskId: string | null | undefined,
-	lane: { session: string; pane: string | null; cli_kind?: string; role?: string },
-): Promise<WorkItem | null> {
-	if (!maybeTaskId) return null;
-	const row = await prisma.work_items.findFirst({ where: { id: maybeTaskId, kind: "task" } });
-	if (!row) return null;
-	// Defense-in-depth: the findFirst filters kind:"task", but verify the kind on
-	// the read row too rather than trusting only the DB filter — a project parent
-	// (which a spawn also carries as workItemId) must never be adopted, only
-	// created-under. Verified, not assumed (`a-component-may-not-report-a-state...`).
-	if (row.kind !== "task") return null;
-	const laneData = {
-		pane: lane.pane,
-		session: lane.session,
-		cli_kind: lane.cli_kind ?? "claude-code",
-		role: lane.role ?? "agent",
-	};
-	const mergedKindData = {
-		...(row.kind_data ?? {}),
-		lane: laneData,
-		assignee_type: "agent",
-	};
-	// RELEASE any OTHER active task holding this pane's unique lane slot before
-	// writing — migration 109's unique index would otherwise P2002 on the update
-	// when a stale task (prior session, same pane) is still active. Same logic
-	// as the run-link STEAL-before-CLAIM: a pane's lane slot is singly-owned, so
-	// every other row holding it is this lane's own stale prior (or a duplicate the
-	// race created) and is released to null-pane so this update can land. The
-	// assignment task itself is then re-bound to the fresh session.
-	try {
-		if (lane.pane) {
-			const others = (
-				prisma as unknown as {
-					work_items?: {
-						updateMany: (a: unknown) => Promise<{ count: number }>;
-					};
-				}
-			).work_items;
-			await others?.updateMany({
-				where: {
-					kind: "task",
-					status: "active",
-					id: { not: row.id },
-					kind_data: { path: ["lane", "pane"], equals: lane.pane },
-				},
-				data: { kind_data: { lane: { pane: null } } },
-			});
-		}
-	} catch {
-		// Best-effort: a release failure does not block the adopt — the update below
-		// will throw its own P2002 and the handler falls through, converging on the
-		// next bind. Logged by the caller's run-link region, not here.
-	}
-	try {
-		return await prisma.work_items.update({
-			where: { id: row.id },
-			data: { kind_data: mergedKindData, assignee_id: lane.session },
-		});
-	} catch {
-		return null;
-	}
-}
-
-/**
- * The bind decision AFTER attempting to adopt the spawn's referenced task. PURE
- * over the adopt result + whether the referenced row exists, so the
- * "a spawn that cannot bind fails loudly rather than orphaning" invariant
- * (`absent-input-reads-as-success`) is unit-testable without standing up the
- * ORPC handler. `bindLane` calls `adoptAssignmentTask` then this, then acts.
- *
- *   `use`     — adopt succeeded; bind the lane to that task.
- *   `create`  — no task to adopt: an exploratory lane (no workItemId) or the
- *               referenced id is a PROJECT the task is created under.
- *   `refuse`  — the spawn named a workItemId the lane should adopt, but NO task
- *               exists with that id. Silently creating a NEW task here would
- *               abandon the spawn's referenced brief and bind the lane to an
- *               empty task it was never meant to own — exactly the orphan
- *               `absent-input-reads-as-success` forbids (a caller that stated
- *               adopt-intent reads "success" while the referenced row rots).
- *               Failing loudly surfaces the malformed spawn instead.
- */
-export type BindAction =
-	| { action: "use"; task: WorkItem }
-	| { action: "create"; scope: "exploratory" | "project-parent" }
-	| { action: "refuse"; reason: "missing-referenced-task"; workItemId: string };
-
-export function resolveBindAction(args: {
-	adopted: WorkItem | null;
-	workItemId: string | null;
-	/** The kind of the row at workItemId, or null when no such row exists. */
-	referencedKind: string | null;
-}): BindAction {
-	if (args.adopted) return { action: "use", task: args.adopted };
-	if (!args.workItemId) return { action: "create", scope: "exploratory" };
-	// A workItemId was provided but adopt returned null: either it resolves to a
-	// non-task (a PROJECT — create a task under it) or to nothing (refuse).
-	if (args.referencedKind === null) {
-		return { action: "refuse", reason: "missing-referenced-task", workItemId: args.workItemId };
-	}
-	return { action: "create", scope: "project-parent" };
-}
-
-/**
- * Bind a task to a KNOWN session — the RESUME path. Unlike a fresh spawn (the
- * CLI mints the session at boot, so SessionStart must adopt), a resumed/switched
- * lane knows its session id up front (`resumeId`). So the assignment binds the
- * task to `resumeId` directly and writes a NEW comment as the continuation brief,
- * before emitting the spawn with `resumeId`. `readAssignedBrief(resumeId)` then
- * returns that continuation — so `DEFAULT_CONTINUATION_PROMPT`'s job (which rode
- * the now-retired keystroke path) moves to a row write at assign time. Also sets
- * `assignee_id` (ownership) for the same reason as the fresh-spawn adopt.
- */
-export async function bindTaskToKnownSession(
-	prisma: Prisma,
-	taskId: string,
-	lane: { session: string; pane: string | null; cli_kind?: string; role?: string },
-): Promise<WorkItem | null> {
-	return adoptAssignmentTask(prisma, taskId, lane);
-}
-
-/**
- * The spawn payload an assignment emits. Carries the task id (as `workItemId`,
- * which the picker exports into the pane so SessionStart can ADOPT the existing
- * task) and NEVER an `initialPrompt` — the lane pulls its brief from the DB by
- * its own session id. This is the contract whatever host-command surface lands:
- * command `spawn_agent_tab`, payload `{ workItemId, slug?, windowName?,
- * idempotencyKey? }`.
- *
- * Pure (no I/O) so the "no keystroke brief, taskId-only" invariant is
- * unit-testable and regression-locked: a test asserting `initialPrompt` is
- * absent fails the moment someone re-adds keystroke delivery.
- */
-export function buildAssignmentSpawnPayload(
-	task: Pick<WorkItem, "id">,
-	options: { slug?: string; windowName?: string; idempotencyKey?: string },
-): {
-	command: "spawn_agent_tab";
-	payload: { workItemId: string; slug?: string; windowName?: string; idempotencyKey?: string };
-} {
-	return {
-		command: "spawn_agent_tab",
-		payload: {
-			workItemId: task.id,
-			...(options.slug ? { slug: options.slug } : {}),
-			...(options.windowName ? { windowName: options.windowName } : {}),
-			...(options.idempotencyKey ? { idempotencyKey: options.idempotencyKey } : {}),
-		},
-	};
-}
-
-/**
- * The emission surface an assignment writes the spawn intent to. Injected (not
- * imported) so this file composes with whichever bus surface the host-command-bus
- * cutover settles on, rather than hard-coding a second mechanism. Implementations
- * write a durable row the consumer reacts to (`actions-are-rows-then-emissions`):
- * fire-and-forget from the caller's perspective — the caller states intent and
- * proceeds; the consumer spawns the lane and the lane self-briefs.
- */
-export interface AssignmentEmitter {
-	/** Write the spawn intent as a durable row the host-command consumer reacts to. */
-	emitSpawn(
-		payload: ReturnType<typeof buildAssignmentSpawnPayload>,
-	): Promise<void>;
-}
-
-/**
- * The outcome of assigning a task: the created/confirmed task and confirmation
- * that the spawn intent was emitted (not that the lane spawned — that is the
- * consumer's reaction, observed separately). The caller proceeds on the row.
- */
-export interface AssignmentResult {
-	task: WorkItem;
-	emitted: boolean;
-}
-
-/**
- * createBriefTask ORPC input. The MINT entry point a spawner calls to turn a
- * raw brief into the task row a lane self-briefs from. `name` is the lane's work
- * label (the spawner's windowName); `description` is the brief, stored as the
- * task's FIRST COMMENT — never on the task row itself, so "the brief" has
- * exactly one home (`task-sync-brief.ts` readLatestTaskComment, newest-first).
- * Mirrors `assignTaskInput` minus the spawn-shaping fields (slug/windowName/
- * idempotencyKey), which belong on the spawn emission, not the mint.
- */
-export const createBriefTaskInput = v.object({
-	name: laneWorkName,
-	description: v.pipe(
-		v.string(),
-		v.minLength(1, "description is required — it is the brief (first comment)"),
-	),
-	parent_id: v.optional(v.string()),
-	organisation_id: v.optional(v.string()),
-});
-
-/**
- * createBriefTask ORPC handler. `spawn_agent_tab` calls this when it receives
- * an `initialPrompt` with no `workItemId`: the prompt becomes the task's first
- * comment, the returned `work_item_id` rides the spawn payload as `workItemId`,
- * and the lane PULLS the brief at boot (`readAssignedBrief`) — no keystroke, no
- * channel send, no positional argument. That deletes the keystroke-brief
- * failure class by construction (`buildAssignmentSpawnPayload` already carries
- * `workItemId` and never `initialPrompt`).
- *
- * Wraps the pure `createTaskWithBriefComment` (atomic task + first comment). The
- * task is `kind:"task"`, `status:"active"`, `assignee_type:"agent"`, with NO
- * `kind_data.lane.session`: the CLI mints the session at spawn and SessionStart
- * ADOPTS this task by id (`adoptAssignmentTask`), which binds the brief to the
- * lane. Returns only the `work_item_id` — the single fact the spawner needs to
- * carry the brief without writing it into the spawn payload. Same transport as
- * `readAssignedBrief`: page-gate-exempt (fn.taskSync), localhost super-admin.
- */
-export const createBriefTaskHandler = authed.handler(async ({ input, context }) => {
-	const ctx = context as Context;
-	const prisma = ctx.prisma as Prisma;
-	const data = input as v.InferOutput<typeof createBriefTaskInput>;
-	try {
-		const userId = (ctx.user as { id: string }).id;
-		const task = await createTaskWithBriefComment(
-			prisma,
-			{
-				name: data.name,
-				description: data.description,
-				parent_id: data.parent_id,
-				organisation_id: resolveAssignOrg(data.organisation_id),
-			},
-			userId,
-		);
-		return { work_item_id: task.id, comment_id: (task as WorkItem & { first_comment_id: string }).first_comment_id };
-	} catch (err) {
-		// oRPC's default swallows a handler throw into a generic 500 with no stack;
-		// emit it so a mint failure is diagnosable, not a black box
-		// (a-component-may-not-report-a-state-it-has-not-verified).
-		getAppLogger().error("[task-sync] createBriefTask failed", {
-			error: err instanceof Error ? err.message : String(err),
-			stack: err instanceof Error ? err.stack : undefined,
-		});
-		throw err;
-	}
-});

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

@@ -1,110 +0,0 @@
-/**
- * @system service-boot
- * @status handwritten
- * @edit edit directly
- *
- * Unit tests for the SessionStart auto-bind helpers added to close the
- * task-sync -> work_items gap: lanes kept native task lists but nothing reached
- * work_items because fn.taskSync.bindLane was never auto-called, so every
- * TaskCreate hit the `no-task-bound` discard. resolveBindOrg + discardApplied
- * are the two new testable decisions; getPlatformOrgId + recordEvent are mocked.
- */
-import { describe, expect, mock, test } from "bun:test";
-
-const recorded: Array<{ kind: string; payload: Record<string, unknown> }> = [];
-mock.module("@teamscala/event-log/record-event", () => ({
-	recordEvent: (e: { kind: string; payload: Record<string, unknown> }) => {
-		recorded.push(e);
-	},
-}));
-mock.module("@teamscala/db/registry/platform", () => ({
-	getPlatformOrgId: () => "platform-org-test",
-}));
-
-const { resolveBindOrg, discardApplied } = await import(
-	"./task-sync-router.ts"
-);
-
-describe("resolveBindOrg (SessionStart auto-bind default org)", () => {
-	test("defaults to the platform org when the lane provides none", () => {
-		// An adopted or channel-dispatched lane has no client org; its task seeds
-		// under the platform org (where the operator's fleet PM view reads).
-		expect(resolveBindOrg(undefined)).toBe("platform-org-test");
-	});
-	test("uses the lane's explicit org when provided (dispatched fleet lane)", () => {
-		expect(resolveBindOrg("client-org-123")).toBe("client-org-123");
-	});
-});
-
-describe("discardApplied (observable no-task-bound discards)", () => {
-	test("records the discard to event_log AND returns the soft {applied:false} body", () => {
-		recorded.length = 0;
-		const r = discardApplied("no-task-bound", "tmux:%22", { toolName: "TaskCreate" });
-		expect(r).toEqual({ applied: false, reason: "no-task-bound", toolName: "TaskCreate" });
-		expect(recorded).toHaveLength(1);
-		expect(recorded[0]).toEqual({
-			kind: "tasksync.hook.discarded",
-			payload: { reason: "no-task-bound", pane: "tmux:%22", toolName: "TaskCreate" },
-		});
-	});
-	test("no-pane discard carries pane:null", () => {
-		recorded.length = 0;
-		discardApplied("no-pane", null);
-		expect(recorded[0]?.payload).toEqual({ reason: "no-pane", pane: null });
-	});
-	test("every reason is distinguishable in event_log by payload.reason", () => {
-		recorded.length = 0;
-		discardApplied("no-subject", "tmux:%5");
-		discardApplied("no-taskId", "tmux:%5", { toolName: "TaskUpdate" });
-		expect(recorded.map((e) => e.payload.reason)).toEqual(["no-subject", "no-taskId"]);
-	});
-});
-
-describe("lane task binding is deterministic and race-proof (source contract)", () => {
-	// Two sources since the router hit its 1000-line budget: lane RESOLUTION
-	// moved to task-sync-lane.ts, the bindLane HANDLER stayed on the router. A
-	// source-text contract has to point at wherever the code actually lives, so
-	// these read separately rather than sharing one handle.
-	const laneSrc = Bun.file(new URL("./task-sync-lane.ts", import.meta.url).pathname);
-	const src = Bun.file(new URL("./task-sync-router.ts", import.meta.url).pathname);
-
-	test("resolveLaneTask orders, so duplicates cannot flip the answer", async () => {
-		const text = await laneSrc.text();
-		// An unordered findFirst returns whichever row Postgres hands back. With
-		// two parents for one lane, one turn wrote the lane's todos under parent A
-		// and the next read parent B and found nothing — the list appeared to
-		// empty itself and the watchdog accused lanes holding a populated list.
-		expect(text).toContain('orderBy: { created_at: "asc" }');
-		expect(text).toContain('status: "active"');
-	});
-
-	test("bindLane recovers from losing the create race instead of throwing", async () => {
-		const text = await src.text();
-		// Migration 109 makes the second concurrent create fail. Losing is not an
-		// error: the winner's row is exactly what the caller wanted.
-		expect(text).toContain("lost the create race");
-		expect(text).toContain("const winner = await resolveLaneTask(prisma, session)");
-	});
-
-	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("readTaskList returns the checklist with evidence-derived progress", async () => {
-		const text = await src.text();
-		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");
-	});
-});