@teamscala/service-boot 0.23.346 → 0.23.348

package/package.json

@@ -1062,5 +1062,5 @@
   "repository": "https://github.com/teamgbg/service-boot",
   "sideEffects": false,
   "type": "module",
-  "version": "0.23.346"
+  "version": "0.23.348"
 }

package/src/fn-routers/index.ts

@@ -32,12 +32,10 @@ import { publicAgreementRouter } from "./public-agreement-router.ts";
 import { publicAssessmentRouter } from "./public-assessment-router.ts";
 import { publicGptSessionRouter } from "./public-gpt-session-router.ts";
 import { signInFlowRouter } from "./sign-in-flow-router.ts";
-import { taskSyncRouter } from "./task-sync-router.ts";
 import { tasksRouter } from "./tasks-router.ts";
 import { userPreferencesRouter } from "./user-preferences-router.ts";
 import { userPreferencesRouter as portalPreferencesRouter } from "../page-server-orpc/user-preferences-router.ts";
 import { workItemsRouter } from "./work-items-router.ts";
-import { orchestratorRegistrationRouter } from "./orchestrator-registration-router.ts";
 
 export function registerFnRouters(): void {
 	registerCustomRouter("fn", {
@@ -52,9 +50,7 @@ export function registerFnRouters(): void {
 		publicGptSession: publicGptSessionRouter,
 		signInFlow: signInFlowRouter,
 		tasks: tasksRouter,
-		taskSync: taskSyncRouter,
 		workItems: workItemsRouter,
-		orchestratorRegistration: orchestratorRegistrationRouter,
 		userPreferences: userPreferencesRouter,
 		portalPreferences: portalPreferencesRouter,
 		plans: plansRouter,

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

@@ -1,361 +0,0 @@
-/**
- * @system service-boot
- * @status handwritten
- * @edit edit directly
- *
- * Unit tests for the pure task-sync reconciliation logic (planReconcile +
- * status mapping). The ORPC handlers only EXECUTE the plan against prisma; the
- * matching / status / positioning decisions live here so they are unit-testable
- * without a DB. Covers `what-must-have-a-test` for the public API.
- */
-import { describe, it, expect } from "bun:test";
-import {
-	resolveTaskUpdateTarget,
-	planReconcile,
-	normalizeStatus,
-	resolveProjectedStatus,
-	subtaskKey,
-	STATUS_TO_WORK_ITEM,
-} from "./task-sync-projection.ts";
-import { type TaskListItem, upsertFromTaskListInput } from "./task-sync-router.ts";
-import * as v from "valibot";
-
-interface WorkItemLike {
-	id: string;
-	kind: string;
-	parent_id: string | null;
-	organisation_id: string;
-	title: string;
-	status: string | null;
-	position: string | null;
-	completed: boolean | null;
-	kind_data: Record<string, unknown>;
-}
-
-function subtask(opts: Partial<WorkItemLike> & { id: string; title: string }): WorkItemLike {
-	return {
-		kind: "subtask",
-		parent_id: "task-1",
-		organisation_id: "org-1",
-		status: "todo",
-		position: null,
-		completed: false,
-		kind_data: {},
-		...opts,
-	};
-}
-
-const item = (content: string, status: TaskListItem["status"] = "pending", mark?: string): TaskListItem => ({
-	content,
-	status,
-	...(mark !== undefined ? { mark } : {}),
-});
-
-describe("task-sync status mapping", () => {
-	it("maps normalized status to the work_items DB enum (hyphenated in-progress)", () => {
-		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");
-	});
-
-	it("normalizes work_items status back to the CLI form", () => {
-		expect(normalizeStatus("todo")).toBe("pending");
-		expect(normalizeStatus("in-progress")).toBe("in_progress");
-		expect(normalizeStatus("done")).toBe("completed");
-		expect(normalizeStatus("active")).toBe("in_progress");
-		expect(normalizeStatus(null)).toBe("pending");
-		expect(normalizeStatus("unknown-state")).toBe("pending");
-	});
-});
-
-describe("task-sync subtaskKey", () => {
-	it("prefers a stable mark over content when present", () => {
-		expect(subtaskKey({ mark: "m1", content: "ignored", title: "ignored" })).toBe("m1");
-	});
-	it("falls back to content when no mark", () => {
-		expect(subtaskKey({ content: "Build it", title: "Build it" })).toBe("Build it");
-	});
-});
-
-describe("task-sync planReconcile", () => {
-	it("creates every incoming item when there are no existing subtasks", () => {
-		const plan = planReconcile([], [item("A"), item("B", "in_progress")]);
-		expect(plan.toCreate).toHaveLength(2);
-		expect(plan.toCreate[0]).toMatchObject({ content: "A", status: "todo", position: "0", completed: false });
-		expect(plan.toCreate[1]).toMatchObject({ content: "B", status: "in-progress", position: "1", completed: false });
-		expect(plan.toUpdate).toHaveLength(0);
-		expect(plan.toDelete).toHaveLength(0);
-	});
-
-	it("emits no ops when existing already matches incoming (idempotent)", () => {
-		const existing = [
-			subtask({ id: "1", title: "A", status: "todo", position: "0", completed: false }),
-		];
-		const plan = planReconcile(existing, [item("A")]);
-		expect(plan.toCreate).toHaveLength(0);
-		expect(plan.toUpdate).toHaveLength(0);
-		expect(plan.toDelete).toHaveLength(0);
-	});
-
-	it("updates status + completed when a matched item changed", () => {
-		const existing = [subtask({ id: "1", title: "A", status: "todo", position: "0", completed: false })];
-		const plan = planReconcile(existing, [item("A", "completed")]);
-		expect(plan.toUpdate).toEqual([
-			expect.objectContaining({ id: "1", status: "done", completed: true, position: "0" }),
-		]);
-		expect(plan.toCreate).toHaveLength(0);
-		expect(plan.toDelete).toHaveLength(0);
-	});
-
-	it("updates position on reorder (same content, different index)", () => {
-		const existing = [
-			subtask({ id: "1", title: "A", status: "todo", position: "0" }),
-			subtask({ id: "2", title: "B", status: "todo", position: "1" }),
-		];
-		const plan = planReconcile(existing, [item("B"), item("A")]);
-		expect(plan.toUpdate.map((u) => [u.id, u.position])).toEqual([
-			["2", "0"],
-			["1", "1"],
-		]);
-	});
-
-	it("deletes existing subtasks absent from the incoming list", () => {
-		const existing = [
-			subtask({ id: "1", title: "A", position: "0" }),
-			subtask({ id: "2", title: "B", position: "1" }),
-		];
-		const plan = planReconcile(existing, [item("A")]);
-		expect(plan.toDelete).toEqual(["2"]);
-		expect(plan.toUpdate).toHaveLength(0);
-	});
-
-	it("matches by stable mark across a content rename, updating content", () => {
-		const existing = [
-			subtask({ id: "1", title: "Old text", status: "todo", position: "0", kind_data: { task_sync: { mark: "m1" } } }),
-		];
-		const plan = planReconcile(existing, [item("New text", "pending", "m1")]);
-		expect(plan.toUpdate).toEqual([
-			expect.objectContaining({ id: "1", content: "New text" }),
-		]);
-		expect(plan.toCreate).toHaveLength(0);
-		expect(plan.toDelete).toHaveLength(0);
-	});
-
-	it("ignores blank incoming content", () => {
-		const plan = planReconcile([], [item("   "), item("Real")]);
-		expect(plan.toCreate).toHaveLength(1);
-		expect(plan.toCreate[0].content).toBe("Real");
-	});
-
-	it("carries source into kind_data.task_sync for traceability", () => {
-		const plan = planReconcile([], [item("A")], "claude-code");
-		expect(plan.toCreate[0].kind_data).toEqual({ task_sync: { mark: undefined, source: "claude-code" } });
-	});
-});
-
-// --- resolveTaskUpdateTarget (added 2026-07-28) ----------------------------
-// The gap these close: the update path matched ONLY on kind_data.task_sync.mark,
-// so a subtask whose mark was never stamped — or a TaskCreate that silently
-// produced no row at all — was unaddressable forever. Every later update for it
-// was dropped as `no-matching-subtask`: 26 of 30 tasksync discards in six hours,
-// across seven distinct lane sessions, all one reason. One lane had marks "1"
-// and "3" stamped correctly while "2" was missing entirely, so a whole work item
-// left no trace in the fleet's record.
-describe("task-sync resolveTaskUpdateTarget", () => {
-	const marked = (id: string, title: string, mark?: string) => ({
-		id,
-		title,
-		kind_data: mark ? { task_sync: { mark } } : {},
-	});
-
-	it("matches by mark when stamped", () => {
-		const r = resolveTaskUpdateTarget([marked("a", "Alpha", "1")], { taskId: "1" });
-		expect(r).toEqual({ op: "update", id: "a" });
-	});
-
-	it("falls back to exact title when the mark was never stamped", () => {
-		// The unmarked-row case: mark lookup misses, title still identifies it.
-		const r = resolveTaskUpdateTarget([marked("a", "Alpha")], {
-			taskId: "1",
-			subject: "Alpha",
-		});
-		expect(r).toEqual({ op: "update", id: "a" });
-	});
-
-	it("does not cross-match a different task's mark", () => {
-		const r = resolveTaskUpdateTarget([marked("a", "Alpha", "1")], { taskId: "2" });
-		expect(r).toEqual({ op: "discard" });
-	});
-
-	it("heals a missed create when the event carries a subject", () => {
-		// The mark-"2"-never-written case: nothing to match, but the subject is
-		// enough to rebuild the row instead of orphaning the task forever.
-		const r = resolveTaskUpdateTarget([marked("a", "Alpha", "1")], {
-			taskId: "2",
-			subject: "Bravo",
-		});
-		expect(r).toEqual({ op: "heal", title: "Bravo" });
-	});
-
-	it("discards only when there is no subject to rebuild a title from", () => {
-		const r = resolveTaskUpdateTarget([marked("a", "Alpha", "1")], { taskId: "2" });
-		expect(r).toEqual({ op: "discard" });
-	});
-
-	it("prefers the mark over a same-subject title collision", () => {
-		const r = resolveTaskUpdateTarget(
-			[marked("a", "Same", "1"), marked("b", "Same", "2")],
-			{ taskId: "2", subject: "Same" },
-		);
-		expect(r).toEqual({ op: "update", id: "b" });
-	});
-
-	it("ignores a blank subject rather than healing a titleless row", () => {
-		const r = resolveTaskUpdateTarget([], { taskId: "9", subject: "   " });
-		expect(r).toEqual({ op: "discard" });
-	});
-});
-
-// --- rename must not orphan an unmarked row (added 2026-07-28) --------------
-describe("a rename cannot orphan an unmarked subtask", () => {
-	// Matching is mark-first, then EXACT TITLE. A row that has never been stamped
-	// can therefore only ever be found by its title — so the moment a task is
-	// RENAMED, neither match succeeds, the event heals into a NEW row, and the
-	// pre-rename row is orphaned at whatever status it held. Nothing in the
-	// single-event path will ever address it again.
-	//
-	// Observed on this lane 2026-07-28: three subtasks stranded at `todo` and
-	// `in-progress` under their OLD titles while the CLI's own list read empty,
-	// which is what made the stop gate refuse a lane that had genuinely finished.
-	// `task-projection-converges` requires the projection to express every state a
-	// task reaches; a row it can no longer address expresses nothing.
-
-	it("an unmarked row is still reachable by exact title", () => {
-		// The pre-condition for the whole failure: without a mark, TITLE is the
-		// only handle, so it works right up until the title changes.
-		const existing = [{ id: "row-1", title: "Original title", kind_data: null }];
-		expect(resolveTaskUpdateTarget(existing, { taskId: "7", subject: "Original title" })).toEqual({
-			op: "update",
-			id: "row-1",
-		});
-	});
-
-	it("renaming an UNMARKED row heals into a new one — the orphan", () => {
-		// This is the defect, asserted so the cost of NOT stamping is explicit: the
-		// update does not reach row-1, which stays at its old status forever.
-		const existing = [{ id: "row-1", title: "Original title", kind_data: null }];
-		expect(resolveTaskUpdateTarget(existing, { taskId: "7", subject: "Renamed title" })).toEqual({
-			op: "heal",
-			title: "Renamed title",
-		});
-	});
-
-	it("once marked, a rename updates the SAME row", () => {
-		// The fix: the first title-match stamps the mark, so every later rename is
-		// mark-addressable and lands on the original row. The heal path already
-		// stamped on create; the update path was the missing half.
-		const existing = [
-			{ id: "row-1", title: "Original title", kind_data: { task_sync: { mark: "7" } } },
-		];
-		expect(resolveTaskUpdateTarget(existing, { taskId: "7", subject: "Renamed title" })).toEqual({
-			op: "update",
-			id: "row-1",
-		});
-	});
-
-	it("the update path stamps the mark when the row has none", async () => {
-		// Asserted against the source because the write is inside an ORPC handler
-		// that needs a live prisma context. The regression is the absence of a
-		// stamp, which no pure test on resolveTaskUpdateTarget can observe.
-		const src = await Bun.file(
-			new URL("./task-sync-router.ts", import.meta.url).pathname,
-		).text();
-		expect(src).toContain("const alreadyMarked");
-		expect(src).toContain("if (taskId && !alreadyMarked)");
-		// Prior kind_data must be preserved — the lane binding and any other
-		// sibling keys live there, and clobbering them would trade this bug for a
-		// worse one.
-		expect(src).toContain("...priorKindData");
-		expect(src).toContain("...priorSync");
-	});
-});
-
-// --- upsertFromTaskList input schema (added 2026-07-29) ---------------------
-// The gap this closes: upsertFromTaskList read `input.lane_session`, but oRPC
-// leaves `input` empty for a schema-less procedure, so EVERY whole-list publish
-// 400'd with "requires lane_session" — confirmed by curl (a body containing
-// lane_session still 400'd). The pi/opencode adapter was always sending a valid
-// payload; the server never parsed it. Adding `.input()` is the fix.
-describe("task-sync upsertFromTaskListInput schema", () => {
-	it("accepts a valid whole-list payload (the pi/opencode adapter shape)", () => {
-		const out = v.parse(upsertFromTaskListInput, {
-			lane_session: "ses-1",
-			task_list: [{ content: "Do X", status: "in_progress" }],
-			source: "pi",
-		});
-		expect(out.lane_session).toBe("ses-1");
-		expect(out.task_list).toHaveLength(1);
-	});
-
-	it("accepts an optional mark on items", () => {
-		const out = v.parse(upsertFromTaskListInput, {
-			lane_session: "ses-1",
-			task_list: [{ content: "Do X", status: "pending", mark: "m1" }],
-		});
-		expect(out.task_list[0].mark).toBe("m1");
-	});
-
-	it("rejects a payload missing lane_session (the field the procedure requires)", () => {
-		expect(() => v.parse(upsertFromTaskListInput, { task_list: [] })).toThrow();
-	});
-});
-
-describe("a blocked row survives a CLI list that cannot express it", () => {
-	it("an incoming todo does NOT overwrite a blocked row", () => {
-		// The CLI emits todo/pending for every status it cannot represent, so a
-		// todo arriving for a blocked row asserts nothing about the work.
-		expect(resolveProjectedStatus("blocked", "todo")).toBe("blocked");
-	});
-
-	it("real transitions the CLI CAN express still win", () => {
-		// in-progress and done are genuine user signals, not projection artifacts.
-		expect(resolveProjectedStatus("blocked", "in-progress")).toBe("in-progress");
-		expect(resolveProjectedStatus("blocked", "done")).toBe("done");
-	});
-
-	it("a non-blocked row is unaffected", () => {
-		expect(resolveProjectedStatus("todo", "in-progress")).toBe("in-progress");
-		expect(resolveProjectedStatus("in-progress", "done")).toBe("done");
-		expect(resolveProjectedStatus("done", "todo")).toBe("todo");
-	});
-
-	it("a missing current status never resurrects a block", () => {
-		expect(resolveProjectedStatus(null, "todo")).toBe("todo");
-		expect(resolveProjectedStatus(undefined, "todo")).toBe("todo");
-	});
-
-	it("planReconcile leaves a blocked subtask blocked when the list says pending", () => {
-		// The end-to-end shape: this is what re-blocked the lane three times.
-		const plan = planReconcile(
-			[
-				{
-					id: "row-1",
-					kind: "subtask",
-					parent_id: "task-1",
-					organisation_id: "org-1",
-					title: "Deploy the fix",
-					status: "blocked",
-					position: "0",
-					completed: false,
-					kind_data: { task_sync: { mark: "1" } },
-				},
-			],
-			[{ content: "Deploy the fix", status: "pending" }],
-			"claude-code",
-		);
-		const update = plan.toUpdate.find((u) => u.id === "row-1");
-
-		// Either untouched, or updated while KEEPING blocked — never downgraded.
-		expect(update?.status ?? "blocked").toBe("blocked");
-	});
-});