@teamscala/service-boot 0.23.350 → 0.23.352

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-projection.test.ts

@@ -1,172 +0,0 @@
-/**
- * @system service-boot
- * @status handwritten
- * @edit edit directly
- *
- * Co-located tests for the task-sync PROJECTION pure helpers. The module was
- * split out of task-sync-router.ts precisely so this half — the WHAT-changes
- * decisions — is unit-testable with no database (the router only EXECUTES the
- * plan). Covers status mapping, the blocked-row preservation rule, key
- * resolution, update-target resolution + full reconciliation planning.
- */
-import { describe, expect, it } from "bun:test";
-import {
-	STATUS_TO_WORK_ITEM,
-	deriveEvidenceProgress,
-	normalizeStatus,
-	planReconcile,
-	resolveProjectedStatus,
-	resolveTaskUpdateTarget,
-	subtaskKey,
-	type ReconcilePlan,
-} from "./task-sync-projection.ts";
-import type { TaskListItem } from "./task-sync-router.ts";
-
-describe("STATUS_TO_WORK_ITEM", () => {
-	it("maps the three CLI statuses to work_items status enum values", () => {
-		expect(STATUS_TO_WORK_ITEM.pending).toBe("todo");
-		expect(STATUS_TO_WORK_ITEM.in_progress).toBe("in-progress");
-		expect(STATUS_TO_WORK_ITEM.completed).toBe("done");
-	});
-});
-
-describe("evidence-derived task progress", () => {
-	it("counts only required subtasks with independent Orchestrator acceptance", () => {
-		const out = deriveEvidenceProgress(
-			[
-				{ id: "a", status: "done" },
-				{ id: "b", status: "done" },
-				{ id: "c", status: "todo", kind_data: { pm_progress: { required: false } } },
-			],
-			[
-				{ work_item_id: "a", sender_role: "orchestrator", system_key: "acceptance:a" },
-				{ work_item_id: "b", sender_role: "worker", system_key: "acceptance:b" },
-			],
-		);
-		expect(out).toEqual({ total: 2, accepted: 1, percentage: 50 });
-	});
-
-	it("does not treat prose, context, or done alone as evidence", () => {
-		expect(
-			deriveEvidenceProgress([{ id: "a", status: "done" }], [
-				{ work_item_id: "a", sender_role: "orchestrator", system_key: "progress:100" },
-			]),
-		).toEqual({ total: 1, accepted: 0, percentage: 0 });
-	});
-});
-
-describe("status translation is a single non-drifting source", () => {
-	// The forward map (CLI → work_items) is canonical; the reverse is DERIVED from
-	// it (+ a closed synonym set). This locks the structural fix: the two
-	// directions can never disagree, so adding a CLI status is one entry, not two
-	// maps to keep in sync — deletes the drift class (`prevention-over-detection`).
-
-	it("round-trips every CLI status through work_items and back unchanged", () => {
-		for (const cli of ["pending", "in_progress", "completed"] as TaskListItem["status"][]) {
-			expect(normalizeStatus(STATUS_TO_WORK_ITEM[cli])).toBe(cli);
-		}
-	});
-
-	it("the reverse map is the derived inverse of the forward map", () => {
-		// Every forward mapping is present reversed (the reverse may ADD synonyms
-		// like active/completed, but must never CONTRADICT the forward map).
-		for (const [cli, workItem] of Object.entries(STATUS_TO_WORK_ITEM) as Array<
-			[TaskListItem["status"], string]
-		>) {
-			expect(normalizeStatus(workItem)).toBe(cli);
-		}
-	});
-});
-
-describe("normalizeStatus", () => {
-	it("maps work_items statuses back to the normalized CLI form", () => {
-		expect(normalizeStatus("todo")).toBe("pending");
-		expect(normalizeStatus("in-progress")).toBe("in_progress");
-		expect(normalizeStatus("done")).toBe("completed");
-	});
-
-	it("collapses unknown / null / internal statuses to pending", () => {
-		expect(normalizeStatus(null)).toBe("pending");
-		expect(normalizeStatus("blocked")).toBe("pending");
-		expect(normalizeStatus("some-internal-state")).toBe("pending");
-	});
-});
-
-describe("resolveProjectedStatus", () => {
-	it("preserves a blocked row when the CLI list can only express it as todo", () => {
-		expect(resolveProjectedStatus("blocked", "todo")).toBe("blocked");
-	});
-
-	it("lets real CLI transitions (in-progress, done) win normally", () => {
-		expect(resolveProjectedStatus("blocked", "in-progress")).toBe("in-progress");
-		expect(resolveProjectedStatus("todo", "done")).toBe("done");
-	});
-});
-
-describe("subtaskKey", () => {
-	it("prefers mark, then content, then title", () => {
-		expect(subtaskKey({ mark: "1", content: "c", title: "t" })).toBe("1");
-		expect(subtaskKey({ content: "c", title: "t" })).toBe("c");
-		expect(subtaskKey({ content: "", title: "t" })).toBe("t");
-	});
-});
-
-describe("resolveTaskUpdateTarget", () => {
-	const existing = [
-		{ id: "a", title: "Alpha", kind_data: { task_sync: { mark: "1" } } },
-		{ id: "b", title: "Beta", kind_data: null },
-	];
-	it("updates by stamped mark", () => {
-		expect(resolveTaskUpdateTarget(existing, { taskId: "1", subject: "anything" })).toEqual({
-			op: "update",
-			id: "a",
-		});
-	});
-	it("updates by exact title when no mark matches", () => {
-		expect(resolveTaskUpdateTarget(existing, { taskId: "9", subject: "Beta" })).toEqual({
-			op: "update",
-			id: "b",
-		});
-	});
-	it("heals when nothing matches but a subject can rebuild the row", () => {
-		expect(resolveTaskUpdateTarget(existing, { taskId: "9", subject: "Gamma" })).toEqual({
-			op: "heal",
-			title: "Gamma",
-		});
-	});
-	it("discards when nothing matches and there is no subject", () => {
-		expect(resolveTaskUpdateTarget(existing, { taskId: "9" })).toEqual({ op: "discard" });
-	});
-});
-
-describe("planReconcile", () => {
-	it("creates new items, updates changed ones, deletes unseen ones", () => {
-		const existing = [
-			{ id: "1", kind: "subtask", parent_id: null, organisation_id: "org", title: "Keep", status: "todo", completed: false, position: "0", kind_data: {} },
-			{ id: "2", kind: "subtask", parent_id: null, organisation_id: "org", title: "Gone", status: "todo", completed: false, position: "1", kind_data: {} },
-		];
-		const incoming: TaskListItem[] = [
-			{ content: "Keep", status: "completed", mark: undefined },
-			{ content: "New", status: "pending", mark: undefined },
-		];
-		const plan: ReconcilePlan = planReconcile(existing, incoming);
-		// "Keep" changed (todo→done) → update; "Gone" absent → delete; "New" → create.
-		expect(plan.toUpdate.map((u) => u.id)).toEqual(["1"]);
-		expect(plan.toUpdate[0]?.status).toBe("done");
-		expect(plan.toCreate.map((c) => c.content)).toEqual(["New"]);
-		expect(plan.toDelete).toEqual(["2"]);
-	});
-
-	it("preserves a blocked existing row against an incoming todo", () => {
-		const existing = [
-			{ id: "1", kind: "subtask", parent_id: null, organisation_id: "org", title: "X", status: "blocked", completed: false, position: "5", kind_data: {} },
-		];
-		// Incoming pending (-> "todo") at a DIFFERENT position so an update fires;
-		// without the preservation rule the row would be rewritten to "todo",
-		// silently destroying the block.
-		const incoming: TaskListItem[] = [{ content: "X", status: "pending", mark: undefined }];
-		const plan = planReconcile(existing, incoming, "src");
-		expect(plan.toUpdate.length).toBe(1);
-		expect(plan.toUpdate[0]?.status).toBe("blocked");
-	});
-});

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

@@ -1,273 +0,0 @@
-/**
- * @system service-boot
- * @status handwritten
- * @edit edit directly
- *
- * The task-sync PROJECTION: how a CLI's task list maps onto `work_items` rows,
- * and what reconciling one against the other should do.
- *
- * Split out of `task-sync-router.ts`, which had grown past the 1000-line budget
- * and so could not be committed by anyone touching it. The seam is real rather
- * than arbitrary: everything here is PURE and decides WHAT should change, while
- * the router owns the ORPC surface and performs the writes. That is exactly why
- * this half is directly testable with no database.
- *
- * CAPABILITY HARVEST (capability-harvest-on-split): APP-LOCAL, not a capability
- * candidate. Checked against the 14 platform singletons and the package catalog
- * — nothing generic to fold into, and the doctrine test fails: no unrelated app
- * could install this unmodified, because every export is bound to the
- * `work_items` schema and task-sync's own contract (STATUS_TO_WORK_ITEM encodes
- * the work_items status enum, subtaskKey is this projection's key convention,
- * planReconcile diffs against work_items subtask rows).
- *
- * The near-miss is worth naming so the next reader does not re-derive it: the
- * SHAPE — diff a desired list against existing rows into create/update/delete —
- * is generic, and `document-signing` is precedent for lifting a pure domain half
- * out of service-boot into a package. It stays here because it has exactly one
- * consumer; extracting it now would be speculative packaging, which
- * platform-capabilities treats as drift. Revisit if a SECOND surface needs
- * list-against-rows reconciliation — then the generic diff core (not the
- * work_items-specific mapping) is what earns a package.
- */
-
-import type { TaskListItem, WorkItem } from "./task-sync-router.ts";
-
-// The status translation between a CLI's task list (pending/in_progress/completed)
-// and work_items.status (todo/in-progress/done/active/blocked/…). ONE source of
-// truth: the CLI→work_items map is canonical (each CLI state maps to exactly one
-// work_items status); the reverse direction is DERIVED from it, plus a closed set
-// of work_items-internal synonyms (active, completed) that have no distinct CLI
-// state. The two directions therefore cannot drift — adding a CLI state is one
-// entry in CLI_STATUS_TO_WORK_ITEM and the inverse updates with it — which deletes
-// the "two hand-maintained inverse maps" drift class (`prevention-over-detection`).
-// The DB enum uses a hyphen for the active state ("in-progress"); see
-// COLUMN_ENUMES["work_items.status"] in db-validation.
-const CLI_STATUS_TO_WORK_ITEM: Record<TaskListItem["status"], string> = {
-	pending: "todo",
-	in_progress: "in-progress",
-	completed: "done",
-};
-
-// work_items-internal statuses that are SYNONYMS for a CLI state (no distinct CLI
-// representation). A closed, additive set — the only hand-maintained second source.
-const WORK_ITEM_STATUS_SYNONYMS: Record<string, TaskListItem["status"]> = {
-	active: "in_progress",
-	completed: "completed",
-};
-
-// The reverse map, DERIVED: the canonical inverse of CLI_STATUS_TO_WORK_ITEM, plus
-// the synonyms. Generated at module load so it can never disagree with the forward
-// map. Unknown/internal statuses collapse to pending via normalizeStatus.
-const WORK_ITEM_TO_STATUS: Record<string, TaskListItem["status"]> = {
-	...Object.fromEntries(
-		(Object.entries(CLI_STATUS_TO_WORK_ITEM) as Array<[TaskListItem["status"], string]>).map(
-			([cli, workItem]) => [workItem, cli],
-		),
-	),
-	...WORK_ITEM_STATUS_SYNONYMS,
-};
-
-/** CLI task-list status → work_items.status. The canonical forward direction. */
-export const STATUS_TO_WORK_ITEM = CLI_STATUS_TO_WORK_ITEM;
-
-export function normalizeStatus(s: string | null): TaskListItem["status"] {
-	return (s && WORK_ITEM_TO_STATUS[s]) || "pending";
-}
-
-export interface ProgressSubtask {
-	id: string;
-	status: string | null;
-	kind_data?: Record<string, unknown> | null;
-}
-
-export interface ProgressAcceptanceEvidence {
-	work_item_id: string | null;
-	sender_role: string | null;
-	system_key: string | null;
-}
-
-export interface EvidenceProgress {
-	total: number;
-	accepted: number;
-	percentage: number;
-}
-
-/**
- * Derive progress from the canonical checklist and independent acceptance
- * comments. A done status without an Orchestrator acceptance comment is not
- * evidence of completion; prose percentages and context gauges never enter
- * this calculation. Subtasks are required by default, with an explicit
- * `kind_data.pm_progress.required: false` opt-out for non-gating notes.
- */
-export function deriveEvidenceProgress(
-	subtasks: ProgressSubtask[],
-	evidence: ProgressAcceptanceEvidence[],
-): EvidenceProgress {
-	const required = subtasks.filter(
-		(s) => (s.kind_data?.pm_progress as { required?: boolean } | undefined)?.required !== false,
-	);
-	const accepted = new Set(
-		evidence
-			.filter(
-				(e) =>
-					e.sender_role === "orchestrator" &&
-					typeof e.system_key === "string" &&
-					e.system_key.startsWith("acceptance:") &&
-					e.work_item_id,
-			)
-			.map((e) => e.work_item_id as string),
-	);
-	const acceptedCount = required.filter((s) => s.status === "done" && accepted.has(s.id)).length;
-	return {
-		total: required.length,
-		accepted: acceptedCount,
-		percentage: required.length === 0 ? 0 : Math.round((acceptedCount / required.length) * 100),
-	};
-}
-
-/**
- * Decide the status to WRITE for an existing row, given what the CLI list says.
- *
- * The CLI task list has no `blocked` state, so a blocked row round-trips as
- * `pending` (via `normalizeStatus`, which collapses unknown/internal statuses)
- * and then maps back to `todo` — silently destroying the block. That is not a
- * cosmetic drift: the stop gate reads these rows, so un-blocking one re-blocks
- * the LANE from stopping, and the lane's only apparent fix is to touch the list
- * again, which destroys it again.
- *
- * A `todo` arriving from the CLI therefore carries NO information: it is what
- * the projection emits for every status it cannot represent, not an assertion
- * that the work became un-blocked. `in-progress` and `done` are different —
- * those are real transitions the CLI CAN express, so they win normally.
- *
- * Measured 2026-07-30: a lane set a row to `blocked` with a named blocker, the
- * next TaskUpdate reset it to `todo`, and the stop gate reported the lane
- * unfinished again — three turns of ping-pong before the cause was found.
- */
-export function resolveProjectedStatus(
-	currentStatus: string | null | undefined,
-	incomingStatus: string,
-): string {
-	if (currentStatus === "blocked" && incomingStatus === "todo") return "blocked";
-	return incomingStatus;
-}
-
-export function subtaskKey(item: { mark?: string; content: string; title: string }): string {
-	return item.mark || item.content || item.title;
-}
-
-/**
- * Pure decision for a TaskUpdate/TaskDelete: which existing subtask does this
- * event address, and what should happen when none does. Extracted for the same
- * reason planReconcile was — the handler should only EXECUTE, so the matching
- * rule is unit-testable.
- *
- * Three resolutions:
- *  - `update` — matched by mark, or (mark absent/unstamped) by exact title.
- *  - `heal`   — nothing matched but the event carries a subject, so the row can
- *               be reconstructed. Covers a TaskCreate that silently produced no
- *               subtask, which previously orphaned the task forever.
- *  - `discard` — nothing matched and there is no subject to rebuild a title from.
- *
- * Measured 2026-07-28: marks "1" and "3" were stamped for one lane while mark
- * "2" was never written at all, and every later update for it was dropped as
- * `no-matching-subtask` — 26 of 30 tasksync discards in six hours, across seven
- * distinct lane sessions, were that one reason.
- */
-export function resolveTaskUpdateTarget(
-	existing: Array<{ id: string; title: string; kind_data?: Record<string, unknown> | null }>,
-	evt: { taskId: string; subject?: string },
-): { op: "update"; id: string } | { op: "heal"; title: string } | { op: "discard" } {
-	const byMark = existing.find(
-		(s) =>
-			evt.taskId &&
-			(s.kind_data as { task_sync?: { mark?: string } } | null)?.task_sync?.mark === evt.taskId,
-	);
-	if (byMark) return { op: "update", id: byMark.id };
-	const subject = (evt.subject ?? "").trim();
-	if (subject) {
-		const byTitle = existing.find((s) => s.title === subject);
-		if (byTitle) return { op: "update", id: byTitle.id };
-		return { op: "heal", title: subject };
-	}
-	return { op: "discard" };
-}
-
-/**
- * Pure reconciliation plan: given the lane's EXISTING subtasks and its INCOMING
- * (current) task list, compute the create/update/delete ops that make the
- * subtask set match the list — WITHOUT touching prisma. Extracted so the
- * matching/status/positioning logic is unit-testable (the handler only executes
- * the plan). Matching is by stable mark when the CLI provides one, else by
- * content. Position follows incoming index, so a reorder is an update.
- */
-export interface ReconcilePlan {
-	toCreate: Array<{
-		content: string;
-		status: string;
-		completed: boolean;
-		position: string;
-		kind_data: Record<string, unknown>;
-	}>;
-	toUpdate: Array<{
-		id: string;
-		content: string;
-		status: string;
-		completed: boolean;
-		position: string;
-		kind_data: Record<string, unknown>;
-	}>;
-	toDelete: string[];
-}
-
-export function planReconcile(
-	existing: WorkItem[],
-	incoming: TaskListItem[],
-	source?: string,
-): ReconcilePlan {
-	const byKey = new Map<string, WorkItem>();
-	for (const s of existing) {
-		const mark = (s.kind_data?.task_sync as { mark?: string } | undefined)?.mark;
-		byKey.set(subtaskKey({ mark, content: "", title: s.title }), s);
-	}
-	const toCreate: ReconcilePlan["toCreate"] = [];
-	const toUpdate: ReconcilePlan["toUpdate"] = [];
-	const seen = new Set<string>();
-	for (let i = 0; i < incoming.length; i++) {
-		const item = incoming[i];
-		const content = (item.content ?? "").trim();
-		if (!content) continue;
-		const key = subtaskKey({ mark: item.mark, content, title: content });
-		const incomingStatus = STATUS_TO_WORK_ITEM[item.status] ?? "todo";
-		const completed = item.status === "completed";
-		const position = String(i);
-		const taskSync = { task_sync: { mark: item.mark, source } };
-		const match = byKey.get(key);
-		if (match) {
-			seen.add(match.id);
-			// A blocked row must survive a list the CLI cannot express it in.
-			const status = resolveProjectedStatus(match.status, incomingStatus);
-			const changed =
-				match.title !== content ||
-				match.status !== status ||
-				(match.completed ?? false) !== completed ||
-				match.position !== position;
-			if (changed) {
-				toUpdate.push({
-					id: match.id,
-					content,
-					status,
-					completed,
-					position,
-					kind_data: { ...match.kind_data, ...taskSync },
-				});
-			}
-		} else {
-			// A row being created has no prior status to preserve, so the incoming
-			// one stands unmodified.
-			toCreate.push({ content, status: incomingStatus, completed, position, kind_data: taskSync });
-		}
-	}
-	const toDelete = existing.filter((s) => !seen.has(s.id)).map((s) => s.id);
-	return { toCreate, toUpdate, toDelete };
-}