@teamscala/service-boot 0.23.312 → 0.23.314

package/package.json

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

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

@@ -80,6 +80,39 @@ export declare const assignTaskInput: v.ObjectSchema<{
 }, undefined>;
 /** 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.
+ *
+ * With the schema oRPC parses the body, so `parent_id` reaches the adopt path.
+ * Every field is OPTIONAL and the handler keeps a header fallback for each, so a
+ * caller that transports everything on headers (zerostack: x-lane-pane/session/
+ * work-item) parses to an empty object and behaves EXACTLY as before — the schema
+ * ADDS the body path without removing the header one. As a side effect it also
+ * fixes zerostack cli_kind mis-attribution: zerostack's body `{lane:{cli_kind:
+ * "zerostack"}}` was never parsed, so its cli_kind fell through every header to
+ * the "claude-code" default; parsed now, it reads "zerostack" as intended.
+ */
+export declare const bindLaneInput: v.ObjectSchema<{
+    readonly lane: v.OptionalSchema<v.ObjectSchema<{
+        readonly pane: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        readonly session: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        readonly cli_kind: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        readonly role: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        readonly organisation_id: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    }, undefined>, undefined>;
+    readonly title: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly parent_id: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+}, undefined>;
 /**
  * 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

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

@@ -13,6 +13,7 @@ import { describe, it, expect } from "bun:test";
 import * as v from "valibot";
 import {
 	assignTaskInput,
+	bindLaneInput,
 	createBriefTaskInput,
 	createTaskWithBriefComment,
 	adoptAssignmentTask,
@@ -287,6 +288,44 @@ describe("resolveAssignOrg", () => {
 	});
 });
 
+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.
+		const out = v.safeParse(bindLaneInput, {});
+		expect(out.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" };
 

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

@@ -92,6 +92,42 @@ export const assignTaskInput = v.object({
 /** 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.
+ *
+ * With the schema oRPC parses the body, so `parent_id` reaches the adopt path.
+ * Every field is OPTIONAL and the handler keeps a header fallback for each, so a
+ * caller that transports everything on headers (zerostack: x-lane-pane/session/
+ * work-item) parses to an empty object and behaves EXACTLY as before — the schema
+ * ADDS the body path without removing the header one. As a side effect it also
+ * fixes zerostack cli_kind mis-attribution: zerostack's body `{lane:{cli_kind:
+ * "zerostack"}}` was never parsed, so its cli_kind fell through every header to
+ * the "claude-code" default; parsed now, it reads "zerostack" as intended.
+ */
+export const bindLaneInput = 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

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

@@ -187,7 +187,17 @@ export declare const taskSyncRouter: {
         prisma: any;
         user: import("./auth-router.ts").User;
         orgId: string | null | undefined;
-    }>, import("@orpc/contract").Schema<unknown, unknown>, import("@orpc/contract").Schema<{
+    }>, v.ObjectSchema<{
+        readonly lane: v.OptionalSchema<v.ObjectSchema<{
+            readonly pane: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+            readonly session: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+            readonly cli_kind: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+            readonly role: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+            readonly organisation_id: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        }, undefined>, undefined>;
+        readonly title: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        readonly parent_id: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    }, undefined>, import("@orpc/contract").Schema<{
         task_id: string;
         created: boolean;
     }, {

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

@@ -43,7 +43,7 @@ import { authed, type Context } from "./auth-router.ts";
 import { notifyLaneOfTaskChange } from "./task-sync-dispatch.ts";
 import { resolveLaneTask, resolveLaneWorkName } from "./task-sync-lane.ts";
 import { readAssignedBriefHandler } from "./task-sync-brief.ts";
-import { adoptAssignmentTask, createBriefTaskHandler } from "./task-sync-assign.ts";
+import { adoptAssignmentTask, bindLaneInput, createBriefTaskHandler } from "./task-sync-assign.ts";
 import * as v from "valibot";
 import {
 	STATUS_TO_WORK_ITEM,
@@ -422,7 +422,7 @@ export const taskSyncRouter = {
 	 * fleet_agent_runs row (matched by pane) to the task via tracked_task_id —
 	 * the join the operator's lane-labels monitor + the unified fleet view read.
 	 */
-	bindLane: authed.handler(async ({ input, context }) => {
+	bindLane: authed.input(bindLaneInput).handler(async ({ input, context }) => {
 		const ctx = context as Context;
 		const prisma = ctx.prisma as Prisma;
 		const log = getAppLogger();
@@ -443,8 +443,18 @@ export const taskSyncRouter = {
 		const pane = raw.lane?.pane ?? headerPane;
 		const headerSession = ctx.headers?.get("x-lane-session") ?? null;
 		const session = raw.lane?.session ?? headerSession;
-		// parent_id via header: bindLane has no .input() schema so ORPC does not parse the body (headers are the reliable transport, same as pane/session) — body parent_id was always undefined, which is why adoption silently never happened.
+		// parent_id arrives EITHER as a body field (parsed now that bindLane has an
+		// `.input()` schema — bindLaneInput) OR on the x-lane-work-item header. Both
+		// are the assignment task id this lane ADOPTS (`adoptAssignmentTask`); the
+		// header stays as the redundant transport a header-only caller (zerostack)
+		// already sends. Before the schema, the body path silently never parsed, so a
+		// body-only caller (pi) dropped parent_id, never adopted, and self-briefed to
+		// nulls — the data-not-serving gap `bindLaneInput` exists to close.
 		const headerWorkItem = ctx.headers?.get("x-lane-work-item") ?? null;
+		// cli_kind via header is the fallback for callers that transport it there; a
+		// caller that puts cli_kind in the body lane object (parsed by bindLaneInput)
+		// is read from raw.lane.cli_kind first.
+		const headerWorkKind = ctx.headers?.get("x-lane-cli-kind") ?? null;
 		if (!session) {
 			const { ORPCError } = await import("@orpc/server");
 			throw new ORPCError("BAD_REQUEST", {
@@ -454,7 +464,7 @@ export const taskSyncRouter = {
 		const lane: LaneIdentity = {
 			pane,
 			session,
-			cli_kind: raw.lane?.cli_kind ?? "claude-code",
+			cli_kind: (raw.lane?.cli_kind ?? headerWorkKind ?? "claude-code") as LaneIdentity["cli_kind"],
 			role: raw.lane?.role ?? "agent",
 			organisation_id: raw.lane?.organisation_id,
 		};