@teamscala/service-boot 0.23.313 → 0.23.315

package/package.json

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

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

@@ -80,6 +80,42 @@ 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.
+ *
+ * ROOT-OPTIONAL (`v.optional(v.object(...))`) so it tolerates a caller that sends
+ * a DIRECT body or none at all: oRPC extracts `input` from the `{json:{...}}` RPC
+ * envelope, so a raw-object or empty POST yields `undefined`, which the optional
+ * root ACCEPTS — the handler then falls back to its headers, exactly as it did
+ * schema-less (a header-only caller like zerostack is unchanged). An adapter that
+ * wants the body path (pi's `parent_id`) POSTs the `{json:{...}}` envelope and
+ * `parent_id` is parsed + reaches `adoptAssignmentTask` — the same envelope
+ * convention pi ALREADY uses for upsertFromTaskList. A raw-object POST is NOT
+ * parsed (oRPC hands the handler `undefined`), which is why pi's bindLaneTask
+ * must move to the envelope to deliver `parent_id`. Every field is optional with
+ * a header fallback, so the schema ADDS the body path without removing the header.
+ */
+export declare const bindLaneInput: v.OptionalSchema<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>, 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,51 @@ 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.
+		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" };
 

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

@@ -92,6 +92,47 @@ 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.
+ *
+ * ROOT-OPTIONAL (`v.optional(v.object(...))`) so it tolerates a caller that sends
+ * a DIRECT body or none at all: oRPC extracts `input` from the `{json:{...}}` RPC
+ * envelope, so a raw-object or empty POST yields `undefined`, which the optional
+ * root ACCEPTS — the handler then falls back to its headers, exactly as it did
+ * schema-less (a header-only caller like zerostack is unchanged). An adapter that
+ * wants the body path (pi's `parent_id`) POSTs the `{json:{...}}` envelope and
+ * `parent_id` is parsed + reaches `adoptAssignmentTask` — the same envelope
+ * convention pi ALREADY uses for upsertFromTaskList. A raw-object POST is NOT
+ * parsed (oRPC hands the handler `undefined`), which is why pi's bindLaneTask
+ * must move to the envelope to deliver `parent_id`. Every field is optional with
+ * a header fallback, so the schema ADDS the body path without removing the header.
+ */
+export const bindLaneInput = v.optional(
+	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.OptionalSchema<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>, 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,10 +443,17 @@ 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 for the same reason (body not parsed) — without it
-		// every adopting lane is mis-attributed as claude-code.
+		// 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");