@teamscala/service-boot 0.23.316 → 0.23.318

package/package.json

@@ -6,7 +6,7 @@
   },
   "name": "@teamscala/service-boot",
   "type": "module",
-  "version": "0.23.316",
+  "version": "0.23.318",
   "sideEffects": false,
   "files": [
     "src"

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

@@ -157,11 +157,18 @@ export declare function createTaskWithBriefComment(prisma: Prisma, input: {
  * implement`). "Is the caller the assignee" becomes a simple equality on the
  * session.
  *
- * Refuses to STEAL a task another live session already owns — that is the
- * existing-session re-bind branch's job (matched by `kind_data.lane.session`).
- * Here we adopt only tasks with no session (or already this session). Returns
- * null when `maybeTaskId` is absent, not a task, or already owned by another
- * session — caller falls through to the normal create.
+ * 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 declare function adoptAssignmentTask(prisma: Prisma, maybeTaskId: string | null | undefined, lane: {
     session: string;

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

@@ -187,6 +187,7 @@ describe("createTaskWithBriefComment (atomic task + first comment = brief)", ()
 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,
@@ -195,9 +196,13 @@ describe("adoptAssignmentTask (SessionStart adopts the pre-created task + owners
 					updates.push(row);
 					return row;
 				},
+				updateMany: async (a: unknown) => {
+					updateManyCalls.push(a);
+					return { count: 0 };
+				},
 			},
 		};
-		return { prisma, updates };
+		return { prisma, updates, updateManyCalls };
 	}
 
 	it("writes the lane session onto the pre-created task AND sets assignee_id (ownership)", async () => {
@@ -224,12 +229,22 @@ describe("adoptAssignmentTask (SessionStart adopts the pre-created task + owners
 		expect(kd.lane.session).toBe("s");
 	});
 
-	it("REFUSES to steal a task another live session already owns", async () => {
-		const task = { id: "t", kind: "task", kind_data: { lane: { session: "someone-else" } } };
-		const { prisma, updates } = fakeAdoptPrisma(task);
-		const out = await adoptAssignmentTask(prisma as never, "t", { session: "s", pane: null });
-		expect(out).toBeNull();
-		expect(updates).toHaveLength(0);
+	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 () => {

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

@@ -215,11 +215,18 @@ export async function createTaskWithBriefComment(
  * implement`). "Is the caller the assignee" becomes a simple equality on the
  * session.
  *
- * Refuses to STEAL a task another live session already owns — that is the
- * existing-session re-bind branch's job (matched by `kind_data.lane.session`).
- * Here we adopt only tasks with no session (or already this session). Returns
- * null when `maybeTaskId` is absent, not a task, or already owned by another
- * session — caller falls through to the normal create.
+ * 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,
@@ -234,10 +241,6 @@ export async function adoptAssignmentTask(
 	// (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 existingSession = (
-		(row.kind_data as { lane?: { session?: string } } | null) ?? {}
-	).lane?.session;
-	if (existingSession && existingSession !== lane.session) return null;
 	const laneData = {
 		pane: lane.pane,
 		session: lane.session,
@@ -249,6 +252,37 @@ export async function adoptAssignmentTask(
 		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 },

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

@@ -426,11 +426,6 @@ export const taskSyncRouter = {
 		const ctx = context as Context;
 		const prisma = ctx.prisma as Prisma;
 		const log = getAppLogger();
-		// DIAG: capture the real exception+stack for the pane-with-run 500
-		// (oRPC swallows it to a generic 500; the run-link catch is not firing).
-		const __diagPane = (input as { lane?: { pane?: string } })?.lane?.pane ?? ctx.headers?.get("x-lane-pane");
-		const __diagSession = (input as { lane?: { session?: string } })?.lane?.session ?? ctx.headers?.get("x-lane-session");
-		try {
 		// The SessionStart hook sends the pane + the CLI's native session id.
 		// SESSION is the match key (kind_data.lane.session) — it is unique per
 		// CLI session and re-minted each session, so a fresh session cannot find
@@ -604,14 +599,6 @@ export const taskSyncRouter = {
 			});
 		}
 		return { task_id: taskId, created };
-		} catch (__diagErr) {
-			log.error("[task-sync] bindLane THREW (diag)", {
-				pane: __diagPane, session: __diagSession,
-				error: __diagErr instanceof Error ? __diagErr.message : String(__diagErr),
-				stack: __diagErr instanceof Error ? __diagErr.stack : undefined,
-			});
-			throw __diagErr;
-		}
 	}),
 
 	/**