@teamscala/service-boot 0.23.350 → 0.23.352

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

@@ -1,483 +0,0 @@
-/**
- * @system service-boot
- * @status handwritten
- * @edit edit directly
- *
- * Unit tests for the dispatch-by-assignment WRITE core (task-sync-assign.ts):
- * the "incomplete task is unconstructible" signature invariant, the atomic
- * create-task + first-comment (= brief) write, and the no-initialPrompt spawn
- * payload (regression-locks the row-based self-brief model — fails the moment
- * someone re-adds keystroke delivery). Covers `what-must-have-a-test`.
- */
-import { describe, it, expect } from "bun:test";
-import * as v from "valibot";
-import {
-	assignTaskInput,
-	bindLaneInput,
-	createBriefTaskInput,
-	createTaskWithBriefComment,
-	adoptAssignmentTask,
-	bindTaskToKnownSession,
-	buildAssignmentSpawnPayload,
-	resolveAssignOrg,
-	resolveBindAction,
-} from "./task-sync-assign.ts";
-import type { WorkItem } from "./task-sync-router.ts";
-
-/** A minimal fake prisma exposing only $transaction + the two creates the fn uses. */
-function fakePrisma(overrides: { platformOrg?: string } = {}) {
-	const calls: {
-		workItem: Record<string, unknown> | null;
-		comment: Record<string, unknown> | null;
-	}[] = [];
-	let createdTask: Record<string, unknown> = {
-		id: "task-new-1",
-		kind: "task",
-		title: "unused",
-		status: "active",
-		kind_data: {},
-	};
-	const prisma = {
-		$transaction: async (fn: (tx: unknown) => Promise<unknown>) => {
-			const tx = {
-				work_items: {
-					create: async (a: { data: Record<string, unknown> }) => {
-						createdTask = { ...createdTask, ...a.data, id: "task-new-1" };
-						return createdTask;
-					},
-				},
-				comments: {
-					create: async (a: { data: Record<string, unknown> }) => {
-						calls.push({ workItem: null, comment: a.data });
-						return { ...a.data, id: "comment-new-1" };
-					},
-				},
-			};
-			const result = await fn(tx);
-			// Record the task create alongside the first comment for assertion.
-			calls[calls.length - 1] = { ...calls[calls.length - 1], workItem: { ...createdTask } };
-			return result;
-		},
-	};
-	return { prisma, calls, platformOrg: overrides.platformOrg ?? "org-platform" };
-}
-
-describe("assignTaskInput (incomplete task is unconstructible)", () => {
-	it("accepts name + description together", () => {
-		const out = v.safeParse(assignTaskInput, { name: "FleetTruth", description: "Do X" });
-		expect(out.success).toBe(true);
-	});
-
-	it("rejects a missing description — no brief, no task", () => {
-		// The description IS the brief (first comment); a task without it is exactly
-		// the incomplete state the operator said must be unconstructible.
-		const out = v.safeParse(assignTaskInput, { name: "FleetTruth" });
-		expect(out.success).toBe(false);
-	});
-
-	it("rejects a missing name", () => {
-		const out = v.safeParse(assignTaskInput, { description: "Do X" });
-		expect(out.success).toBe(false);
-	});
-
-	it("rejects an empty-string description (not just absent)", () => {
-		const out = v.safeParse(assignTaskInput, { name: "FleetTruth", description: "" });
-		expect(out.success).toBe(false);
-	});
-
-	it("treats parent_id/slug/windowName as optional", () => {
-		const out = v.safeParse(assignTaskInput, {
-			name: "Exploratory",
-			description: "Look around",
-		});
-		expect(out.success).toBe(true);
-	});
-
-	it("REJECTS the generic 'Lane' title (assignment mint — same gate as createBriefTask)", () => {
-		expect(v.safeParse(assignTaskInput, { name: "Lane", description: "d" }).success).toBe(false);
-	});
-});
-
-describe("createBriefTaskInput (the spawner's mint entry — incomplete task is unconstructible)", () => {
-	// The mint a raw initialPrompt hits: spawn_agent_tab calls createBriefTask,
-	// which validates against this schema BEFORE the handler runs. An incomplete
-	// mint (no brief) is rejected at the signature, never caught after the fact —
-	// the same gate assignTaskInput sets, on the entry point spawn_agent_tab owns.
-	it("accepts name + description together", () => {
-		const out = v.safeParse(createBriefTaskInput, {
-			name: "Spawn mints row",
-			description: "the brief text",
-		});
-		expect(out.success).toBe(true);
-	});
-
-	it("rejects a missing description — no brief, no minted task", () => {
-		expect(v.safeParse(createBriefTaskInput, { name: "X" }).success).toBe(false);
-	});
-
-	it("rejects a missing name", () => {
-		expect(v.safeParse(createBriefTaskInput, { description: "d" }).success).toBe(false);
-	});
-
-	it("rejects an empty-string description (not just absent)", () => {
-		expect(v.safeParse(createBriefTaskInput, { name: "X", description: "" }).success).toBe(false);
-	});
-
-	it("treats parent_id/organisation_id as optional (exploratory lane)", () => {
-		const out = v.safeParse(createBriefTaskInput, { name: "Explore", description: "d" });
-		expect(out.success).toBe(true);
-	});
-
-	// "Lane" is the generic sentinel a spawn that forgot to name its lane falls
-	// back to. A row titled "Lane" is spawn debris an orchestrator cannot
-	// attribute — rejected at the mint chokepoint so the malformed spawn is
-	// refused, never written (lanes-named-by-the-spawner).
-	it("REJECTS the generic 'Lane' title — spawn debris is unconstructible", () => {
-		expect(
-			v.safeParse(createBriefTaskInput, { name: "Lane", description: "d" }).success,
-		).toBe(false);
-	});
-
-	it("rejects 'Lane' case- and whitespace-insensitively", () => {
-		expect(
-			v.safeParse(createBriefTaskInput, { name: "  lane  ", description: "d" }).success,
-		).toBe(false);
-		expect(
-			v.safeParse(createBriefTaskInput, { name: "LANE", description: "d" }).success,
-		).toBe(false);
-	});
-
-	it("accepts a real work name (e.g. the lane's slot_name)", () => {
-		expect(
-			v.safeParse(createBriefTaskInput, { name: "Bus handlers", description: "d" }).success,
-		).toBe(true);
-	});
-});
-
-describe("createTaskWithBriefComment (atomic task + first comment = brief)", () => {
-	it("creates the task active with kind_data carrying NO session, and writes the description as the first comment in the SAME transaction", async () => {
-		const { prisma, calls } = fakePrisma();
-		const task = await createTaskWithBriefComment(
-			prisma as never,
-			{ name: "Dispatch test", description: "the brief text", organisation_id: "org-1" },
-			"user-1",
-		);
-
-		// The task is the active parent the lane will later bind its session to.
-		expect(task.kind).toBe("task");
-		expect(task.status).toBe("active");
-		expect(task.title).toBe("Dispatch test");
-		// CRITICAL: no session key yet — the CLI mints it at spawn and SessionStart
-		// writes it. Carrying one now would let resolveLaneTask race a half-bound row.
-		// assignee_type:"agent" marks it lane-owned from creation (ownership marker).
-		expect(task.kind_data).toEqual({ assignee_type: "agent" });
-		expect((task.kind_data as Record<string, unknown>).lane).toBeUndefined();
-
-		// Exactly one comment, content = the description (one source, not two).
-		expect(calls).toHaveLength(1);
-		expect(calls[0].comment).toMatchObject({
-			work_item_id: task.id,
-			content: "the brief text",
-			user_id: "user-1",
-		});
-		// The comment was written inside the same transaction as the task create
-		// (atomic — a task row without its brief comment can never exist).
-		expect(calls[0].workItem).toMatchObject({ id: task.id, kind: "task", status: "active" });
-	});
-
-	it("parents the task under parent_id when supplied, else null", async () => {
-		const withParent = fakePrisma();
-		await createTaskWithBriefComment(
-			withParent.prisma as never,
-			{ name: "T", description: "d", parent_id: "proj-9", organisation_id: "org-1" },
-			"u",
-		);
-		expect(withParent.calls[0].workItem?.parent_id).toBe("proj-9");
-
-		const noParent = fakePrisma();
-		await createTaskWithBriefComment(
-			noParent.prisma as never,
-			{ name: "T", description: "d", organisation_id: "org-1" },
-			"u",
-		);
-		expect(noParent.calls[0].workItem?.parent_id).toBe(null);
-	});
-
-	it("stamps created_by/updated_by + comment user_id from the caller", async () => {
-		const { prisma, calls } = fakePrisma();
-		await createTaskWithBriefComment(
-			prisma as never,
-			{ name: "T", description: "d", organisation_id: "org-1" },
-			"user-42",
-		);
-		expect(calls[0].workItem).toMatchObject({ created_by: "user-42", updated_by: "user-42" });
-		expect(calls[0].comment).toMatchObject({ user_id: "user-42" });
-	});
-});
-
-describe("adoptAssignmentTask (SessionStart adopts the pre-created task + ownership)", () => {
-	function fakeAdoptPrisma(existing: Record<string, unknown> | null) {
-		const updates: Array<{ id: string } & Record<string, unknown>> = [];
-		const updateManyCalls: unknown[] = [];
-		const prisma = {
-			work_items: {
-				findFirst: async () => existing,
-				update: async (a: { where: { id: string }; data: Record<string, unknown> }) => {
-					const row = { ...(existing ?? {}), ...a.data, id: a.where.id };
-					updates.push(row);
-					return row;
-				},
-				updateMany: async (a: unknown) => {
-					updateManyCalls.push(a);
-					return { count: 0 };
-				},
-			},
-		};
-		return { prisma, updates, updateManyCalls };
-	}
-
-	it("writes the lane session onto the pre-created task AND sets assignee_id (ownership)", async () => {
-		const task = { id: "task-1", kind: "task", kind_data: { assignee_type: "agent" }, assignee_id: null };
-		const { prisma, updates } = fakeAdoptPrisma(task);
-		const out = await adoptAssignmentTask(prisma as never, "task-1", { session: "ses-9", pane: "tmux:%5" });
-		expect(out).not.toBeNull();
-		expect(updates).toHaveLength(1);
-		// OWNERSHIP: assignee_id = the lane session (so the gate can key caller==assignee).
-		expect(updates[0].assignee_id).toBe("ses-9");
-		// BINDING: kind_data.lane.session set (resolveLaneTask can now find it).
-		const kd = updates[0].kind_data as { lane: { session: string; pane: string }; assignee_type: string };
-		expect(kd.lane.session).toBe("ses-9");
-		expect(kd.lane.pane).toBe("tmux:%5");
-		expect(kd.assignee_type).toBe("agent");
-	});
-
-	it("preserves existing kind_data when merging the lane marker onto it", async () => {
-		const task = { id: "t", kind: "task", kind_data: { assignee_type: "agent", other: "keep" } };
-		const { prisma, updates } = fakeAdoptPrisma(task);
-		await adoptAssignmentTask(prisma as never, "t", { session: "s", pane: null });
-		const kd = updates[0].kind_data as { other: string; lane: { session: string } };
-		expect(kd.other).toBe("keep"); // not clobbered
-		expect(kd.lane.session).toBe("s");
-	});
-
-	it("RE-BINDS a task a stale session owns to the fresh lane (pane slot recovery)", async () => {
-		// Migration 109 makes (kind_data->'lane'->>'pane') unique WHERE active, so a
-		// re-spawn on a pane whose prior task is still active under a dead session
-		// cannot create a new task (P2002). adopt re-binds the assignment task to
-		// the fresh session + releases the stale pane slot first. A stale session
-		// is by definition dead, so the task belongs to whichever lane was
-		// dispatched to it — re-binding is correct recovery, not theft.
-		const task = { id: "t", kind: "task", kind_data: { lane: { session: "someone-else", pane: "tmux:%9" } } };
-		const { prisma, updates, updateManyCalls } = fakeAdoptPrisma(task);
-		const out = await adoptAssignmentTask(prisma as never, "t", { session: "fresh", pane: "tmux:%9" });
-		expect(out).not.toBeNull();
-		expect(updates).toHaveLength(1);
-		expect((updates[0].kind_data as { lane: { session: string } }).lane.session).toBe("fresh");
-		expect(updates[0].assignee_id).toBe("fresh");
-		// The stale pane slot was released before the re-bind (STEAL-before-CLAIM).
-		expect(updateManyCalls).toHaveLength(1);
-	});
-
-	it("re-adopts a task already bound to THIS session (idempotent re-bind)", async () => {
-		const task = { id: "t", kind: "task", kind_data: { lane: { session: "ses-9" } } };
-		const { prisma, updates } = fakeAdoptPrisma(task);
-		const out = await adoptAssignmentTask(prisma as never, "t", { session: "ses-9", pane: "tmux:%5" });
-		expect(out).not.toBeNull();
-		expect(updates).toHaveLength(1);
-	});
-
-	it("returns null when the id is absent (nothing to adopt — caller creates)", async () => {
-		const { prisma, updates } = fakeAdoptPrisma(null);
-		expect(await adoptAssignmentTask(prisma as never, null, { session: "s", pane: null })).toBeNull();
-		expect(await adoptAssignmentTask(prisma as never, undefined, { session: "s", pane: null })).toBeNull();
-		expect(updates).toHaveLength(0);
-	});
-
-	it("returns null when the id is a PROJECT, not a task (disambiguates by kind)", async () => {
-		// A project parent must NOT be adopted — bindLane creates a task UNDER it.
-		const { prisma, updates } = fakeAdoptPrisma({ id: "proj-1", kind: "project", kind_data: {} });
-		expect(await adoptAssignmentTask(prisma as never, "proj-1", { session: "s", pane: null })).toBeNull();
-		expect(updates).toHaveLength(0);
-	});
-});
-
-describe("bindTaskToKnownSession (resume path binds to a known session up front)", () => {
-	it("binds the task to the known resumeId session (ownership = resumeId)", async () => {
-		const task = { id: "t", kind: "task", kind_data: { assignee_type: "agent" }, assignee_id: null };
-		const prisma = {
-			work_items: {
-				findFirst: async () => task,
-				update: async (a: { where: { id: string }; data: Record<string, unknown> }) =>
-					({ ...task, ...a.data, id: a.where.id }) as Record<string, unknown>,
-			},
-		};
-		const out = (await bindTaskToKnownSession(prisma as never, "t", {
-			session: "resumeId-1",
-			pane: "tmux:%9",
-		})) as Record<string, unknown> | null;
-		expect(out).not.toBeNull();
-		expect(out?.assignee_id).toBe("resumeId-1");
-	});
-});
-
-describe("resolveAssignOrg", () => {
-	it("returns the explicit org when supplied", () => {
-		expect(resolveAssignOrg("org-explicit")).toBe("org-explicit");
-	});
-	it("falls back to the INJECTED platform org when explicit is omitted", () => {
-		// Pure: platform org arrives from the caller (resolved at the handler
-		// boundary), never pulled from the registry inside this module.
-		expect(resolveAssignOrg(undefined, "org-platform")).toBe("org-platform");
-	});
-	it("prefers explicit over the injected platform org", () => {
-		expect(resolveAssignOrg("org-explicit", "org-platform")).toBe("org-explicit");
-	});
-});
-
-describe("bindLaneInput (body parent_id reaches the adopt path — schema-less gap closed)", () => {
-	// The data-not-serving gap this schema exists to close: a SessionStart
-	// adapter POSTs the work item id as a DIRECT body field, but oRPC parses the
-	// body into `input` ONLY when a `.input()` schema is declared. Without one,
-	// parent_id arrived as an empty input, adopt got null, and readAssignedBrief
-	// returned nulls for a session with nothing bound — read by one lane as
-	// "fn.taskSync is 404". The schema makes the body parse; the header stays as
-	// the redundant transport a header-only caller already sends.
-	it("parses a direct body carrying parent_id (the assignment task id)", () => {
-		const out = v.safeParse(bindLaneInput, {
-			lane: { pane: "tmux:%5", session: "ses-1", cli_kind: "pi", role: "agent" },
-			parent_id: "task-99",
-		});
-		expect(out.success).toBe(true);
-		expect(out.success && out.output.parent_id).toBe("task-99");
-	});
-
-	it("parses an EMPTY body to all-undefined (header-only caller behaves as before)", () => {
-		// A caller transporting everything on headers sends {} (or omits the
-		// body); the schema must not reject it, and every field is undefined so the
-		// handler's header fallbacks carry the values.
-		expect(v.safeParse(bindLaneInput, {}).success).toBe(true);
-	});
-
-	it("ACCEPTS undefined input — a raw-object POST yields undefined (root-optional)", () => {
-		// oRPC extracts input from the {json:{...}} envelope; a raw-object POST
-		// (what zerostack/pi send today) yields undefined. The root MUST be optional
-		// or those callers 400 instead of falling back to headers. A strict root
-		// regressed exactly this (0.23.314), so this assertion locks the tolerance.
-		expect(v.safeParse(bindLaneInput, undefined).success).toBe(true);
-	});
-
-	it("treats every field as optional (no caller is forced to populate the body)", () => {
-		expect(v.safeParse(bindLaneInput, { lane: { cli_kind: "zerostack" } }).success).toBe(true);
-		expect(v.safeParse(bindLaneInput, { parent_id: "t-1" }).success).toBe(true);
-		expect(v.safeParse(bindLaneInput, { title: "Lane" }).success).toBe(true);
-	});
-
-	it("does NOT require lane.session in the body (session may arrive on a header)", () => {
-		// bindLane resolves session from raw.lane?.session ?? x-lane-session, so the
-		// schema must not make the body the sole transport for it.
-		expect(v.safeParse(bindLaneInput, { parent_id: "t-1" }).success).toBe(true);
-	});
-});
-
-describe("buildAssignmentSpawnPayload (no keystroke brief — row-based self-brief)", () => {
-	const task = { id: "task-99" };
-
-	it("emits command spawn_agent_tab carrying the taskId as workItemId", () => {
-		const out = buildAssignmentSpawnPayload(task, { slug: "cc-glm52", windowName: "FleetTruth" });
-		expect(out.command).toBe("spawn_agent_tab");
-		expect(out.payload.workItemId).toBe("task-99");
-		expect(out.payload.slug).toBe("cc-glm52");
-		expect(out.payload.windowName).toBe("FleetTruth");
-	});
-
-	it("NEVER carries initialPrompt — the lane pulls its brief from the DB by session id", () => {
-		// Regression-lock for the failure class this deletes: a 4400-char
-		// initialPrompt fails; a 2600-char one arrives but is never submitted.
-		// The moment someone re-adds keystroke delivery this assertion fails.
-		const out = buildAssignmentSpawnPayload(task, { slug: "cc-glm52" });
-		expect("initialPrompt" in out.payload).toBe(false);
-		expect(out.payload).not.toHaveProperty("initialPrompt");
-		expect("cliSessionId" in out.payload).toBe(false);
-	});
-
-	it("omits optional spawn fields when not supplied (no undefined keys)", () => {
-		const out = buildAssignmentSpawnPayload(task, {});
-		expect(out.payload).toEqual({ workItemId: "task-99" });
-		expect("slug" in out.payload).toBe(false);
-		expect("windowName" in out.payload).toBe(false);
-		expect("idempotencyKey" in out.payload).toBe(false);
-	});
-
-	it("forwards idempotencyKey when supplied (retries reuse it, new spawns don't)", () => {
-		const out = buildAssignmentSpawnPayload(task, { idempotencyKey: "k-1" });
-		expect(out.payload.idempotencyKey).toBe("k-1");
-	});
-});
-
-describe("resolveBindAction (a spawn that cannot bind fails loudly, never orphans)", () => {
-	// The `absent-input-reads-as-success` failure this closes: a spawn carried a
-	// workItemId the lane should adopt, but no task with that id exists. The old
-	// path silently created a NEW task, abandoning the spawn's referenced brief
-	// and binding the lane to an empty task it was never meant to own — an orphan
-	// an orchestrator cannot tell from real unowned work. bindLane now REFUSES on
-	// this outcome; this is the pure, unit-testable decision behind that refusal.
-	function taskRow(id: string): WorkItem {
-		return {
-			id,
-			kind: "task",
-			parent_id: null,
-			organisation_id: "org",
-			title: "T",
-			status: "active",
-			position: null,
-			completed: null,
-			kind_data: {},
-		};
-	}
-
-	it("uses the adopted task when adopt succeeds", () => {
-		const t = taskRow("t1");
-		const out = resolveBindAction({ adopted: t, workItemId: "t1", referencedKind: "task" });
-		expect(out.action).toBe("use");
-		if (out.action === "use") expect(out.task.id).toBe("t1");
-	});
-
-	it("creates for an exploratory lane (no workItemId supplied)", () => {
-		const out = resolveBindAction({ adopted: null, workItemId: null, referencedKind: null });
-		expect(out.action).toBe("create");
-		if (out.action === "create") expect(out.scope).toBe("exploratory");
-	});
-
-	it("creates under a PROJECT parent (workItemId resolves to a project, not a task)", () => {
-		const out = resolveBindAction({
-			adopted: null,
-			workItemId: "proj-1",
-			referencedKind: "project",
-		});
-		expect(out.action).toBe("create");
-		if (out.action === "create") expect(out.scope).toBe("project-parent");
-	});
-
-	it("REFUSES when the spawn named a task that does not exist — no orphan created", () => {
-		// THE owed test: a spawn carrying a workItemId that resolves to NO task
-		// must fail (refuse) instead of silently creating a new orphan task.
-		const out = resolveBindAction({
-			adopted: null,
-			workItemId: "ghost-9",
-			referencedKind: null,
-		});
-		expect(out.action).toBe("refuse");
-		if (out.action === "refuse") {
-			expect(out.reason).toBe("missing-referenced-task");
-			expect(out.workItemId).toBe("ghost-9");
-		}
-	});
-
-	it("prefers a successful adopt even when a (stale) referenced kind is present", () => {
-		// adopt already writes the session + assignee_id; once it succeeds the
-		// referenced-kind probe is irrelevant.
-		const t = taskRow("t1");
-		const out = resolveBindAction({ adopted: t, workItemId: "t1", referencedKind: null });
-		expect(out.action).toBe("use");
-	});
-});