@teamscala/service-boot 0.23.318 → 0.23.320

package/package.json

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

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

@@ -56,21 +56,8 @@
 import * as v from "valibot";
 import type { Prisma, WorkItem } from "./task-sync-router.ts";
 import { type Context } from "./auth-router.ts";
-/**
- * The assignment input. `name` + `description` are REQUIRED TOGETHER at the
- * signature: oRPC parses this schema before the handler runs, so a call missing
- * either is rejected with a 400 — an incomplete task is unconstructible, not
- * caught after the fact. `description` becomes the task's first comment (the
- * brief); it is never stored separately on the task, so "the brief" has exactly
- * one home (`task-sync-brief.ts` readLatestTaskComment, newest-first).
- *
- * `name` → work_items.title; `description` → the first comment. `parent_id` is
- * the project the dispatched task is scoped under (omit for an exploratory
- * lane). `slug`/`windowName` shape the spawn; `organisation_id` defaults to the
- * platform org (fleet/internal lane tasks live there).
- */
 export declare const assignTaskInput: v.ObjectSchema<{
-    readonly name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, "name is required — an incomplete task is unconstructible">]>;
+    readonly name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, "name is required — the lane's real work label">, v.CheckAction<string, "name must carry the lane's real work name, not the generic sentinel 'Lane'">]>;
     readonly description: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, "description is required — it is the brief (first comment)">]>;
     readonly parent_id: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
     readonly organisation_id: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
@@ -176,6 +163,41 @@ export declare function adoptAssignmentTask(prisma: Prisma, maybeTaskId: string
     cli_kind?: string;
     role?: string;
 }): Promise<WorkItem | null>;
+/**
+ * The bind decision AFTER attempting to adopt the spawn's referenced task. PURE
+ * over the adopt result + whether the referenced row exists, so the
+ * "a spawn that cannot bind fails loudly rather than orphaning" invariant
+ * (`absent-input-reads-as-success`) is unit-testable without standing up the
+ * ORPC handler. `bindLane` calls `adoptAssignmentTask` then this, then acts.
+ *
+ *   `use`     — adopt succeeded; bind the lane to that task.
+ *   `create`  — no task to adopt: an exploratory lane (no workItemId) or the
+ *               referenced id is a PROJECT the task is created under.
+ *   `refuse`  — the spawn named a workItemId the lane should adopt, but NO task
+ *               exists with that id. Silently creating a NEW task here would
+ *               abandon the spawn's referenced brief and bind the lane to an
+ *               empty task it was never meant to own — exactly the orphan
+ *               `absent-input-reads-as-success` forbids (a caller that stated
+ *               adopt-intent reads "success" while the referenced row rots).
+ *               Failing loudly surfaces the malformed spawn instead.
+ */
+export type BindAction = {
+    action: "use";
+    task: WorkItem;
+} | {
+    action: "create";
+    scope: "exploratory" | "project-parent";
+} | {
+    action: "refuse";
+    reason: "missing-referenced-task";
+    workItemId: string;
+};
+export declare function resolveBindAction(args: {
+    adopted: WorkItem | null;
+    workItemId: string | null;
+    /** The kind of the row at workItemId, or null when no such row exists. */
+    referencedKind: string | null;
+}): BindAction;
 /**
  * Bind a task to a KNOWN session — the RESUME path. Unlike a fresh spawn (the
  * CLI mints the session at boot, so SessionStart must adopt), a resumed/switched
@@ -248,7 +270,7 @@ export interface AssignmentResult {
  * idempotencyKey), which belong on the spawn emission, not the mint.
  */
 export declare const createBriefTaskInput: v.ObjectSchema<{
-    readonly name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, "name is required — the lane's work label">]>;
+    readonly name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, "name is required — the lane's real work label">, v.CheckAction<string, "name must carry the lane's real work name, not the generic sentinel 'Lane'">]>;
     readonly description: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, "description is required — it is the brief (first comment)">]>;
     readonly parent_id: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
     readonly organisation_id: v.OptionalSchema<v.StringSchema<undefined>, undefined>;

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

@@ -20,7 +20,9 @@ import {
 	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 } = {}) {
@@ -90,6 +92,10 @@ describe("assignTaskInput (incomplete task is unconstructible)", () => {
 		});
 		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)", () => {
@@ -121,6 +127,31 @@ describe("createBriefTaskInput (the spawner's mint entry — incomplete task is
 		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)", () => {
@@ -381,3 +412,71 @@ describe("buildAssignmentSpawnPayload (no keystroke brief — row-based self-bri
 		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");
+	});
+});

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

@@ -73,11 +73,25 @@ import { getAppLogger } from "@teamscala/logger/app-loggers";
  * lane). `slug`/`windowName` shape the spawn; `organisation_id` defaults to the
  * platform org (fleet/internal lane tasks live there).
  */
-export const assignTaskInput = v.object({
-	name: v.pipe(
-		v.string(),
-		v.minLength(1, "name is required — an incomplete task is unconstructible"),
+/**
+ * A lane task's NAME — the lane's real work label, never the generic "Lane"
+ * sentinel. A row titled "Lane" is spawn debris: it tells the operator nothing
+ * about the work, so an orchestrator cannot tell real unowned work from it (the
+ * signal the fleet steers by). Rejected at the ORPC input chokepoint so a spawn
+ * that forgot to name its lane is REFUSED at the mint, never written
+ * (lanes-named-by-the-spawner — the spawner sets the work name at creation).
+ */
+const laneWorkName = v.pipe(
+	v.string(),
+	v.minLength(1, "name is required — the lane's real work label"),
+	v.check(
+		(n) => n.trim().toLowerCase() !== "lane",
+		"name must carry the lane's real work name, not the generic sentinel 'Lane'",
 	),
+);
+
+export const assignTaskInput = v.object({
+	name: laneWorkName,
 	description: v.pipe(
 		v.string(),
 		v.minLength(1, "description is required — it is the brief (first comment)"),
@@ -293,6 +307,45 @@ export async function adoptAssignmentTask(
 	}
 }
 
+/**
+ * The bind decision AFTER attempting to adopt the spawn's referenced task. PURE
+ * over the adopt result + whether the referenced row exists, so the
+ * "a spawn that cannot bind fails loudly rather than orphaning" invariant
+ * (`absent-input-reads-as-success`) is unit-testable without standing up the
+ * ORPC handler. `bindLane` calls `adoptAssignmentTask` then this, then acts.
+ *
+ *   `use`     — adopt succeeded; bind the lane to that task.
+ *   `create`  — no task to adopt: an exploratory lane (no workItemId) or the
+ *               referenced id is a PROJECT the task is created under.
+ *   `refuse`  — the spawn named a workItemId the lane should adopt, but NO task
+ *               exists with that id. Silently creating a NEW task here would
+ *               abandon the spawn's referenced brief and bind the lane to an
+ *               empty task it was never meant to own — exactly the orphan
+ *               `absent-input-reads-as-success` forbids (a caller that stated
+ *               adopt-intent reads "success" while the referenced row rots).
+ *               Failing loudly surfaces the malformed spawn instead.
+ */
+export type BindAction =
+	| { action: "use"; task: WorkItem }
+	| { action: "create"; scope: "exploratory" | "project-parent" }
+	| { action: "refuse"; reason: "missing-referenced-task"; workItemId: string };
+
+export function resolveBindAction(args: {
+	adopted: WorkItem | null;
+	workItemId: string | null;
+	/** The kind of the row at workItemId, or null when no such row exists. */
+	referencedKind: string | null;
+}): BindAction {
+	if (args.adopted) return { action: "use", task: args.adopted };
+	if (!args.workItemId) return { action: "create", scope: "exploratory" };
+	// A workItemId was provided but adopt returned null: either it resolves to a
+	// non-task (a PROJECT — create a task under it) or to nothing (refuse).
+	if (args.referencedKind === null) {
+		return { action: "refuse", reason: "missing-referenced-task", workItemId: args.workItemId };
+	}
+	return { action: "create", scope: "project-parent" };
+}
+
 /**
  * Bind a task to a KNOWN session — the RESUME path. Unlike a fresh spawn (the
  * CLI mints the session at boot, so SessionStart must adopt), a resumed/switched
@@ -376,7 +429,7 @@ export interface AssignmentResult {
  * idempotencyKey), which belong on the spawn emission, not the mint.
  */
 export const createBriefTaskInput = v.object({
-	name: v.pipe(v.string(), v.minLength(1, "name is required — the lane's work label")),
+	name: laneWorkName,
 	description: v.pipe(
 		v.string(),
 		v.minLength(1, "description is required — it is the brief (first comment)"),

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

@@ -23,12 +23,36 @@
  */
 import type { Prisma, CommentRow } from "./task-sync-router.ts";
 import { type Context } from "./auth-router.ts";
+/**
+ * The outcome of a brief read, single-sourced here so every CLI's self-brief
+ * hook (zerostack/codex shell, opencode/pi TS) branches on ONE field rather
+ * than each re-deriving "is the brief missing" from null/empty probes — the
+ * seam at which absent-input-reads-as-success hid (`the-severe-bugs-live-at-seams`).
+ *
+ * The hook decides ACTION from this; the classification lives here. A fleet
+ * lane (SCALA_LANE_WORK_ITEM set) treats anything but "ready" as a hard halt.
+ */
+export type BriefReadStatus = "ready" | "empty_brief" | "no_comment" | "unbound";
 /**
  * Shape the readAssignedBrief response from a resolved task + its latest
  * comment. Pure (no prisma) so the decision — "no task/comment ⇒ nulls, never a
- * verdict from no data" (`no-verdict-from-no-data`) — is unit-testable. A null
- * task or null comment returns all-null rather than an empty/fake brief, so the
- * extension can distinguish "nothing to inject" from "inject this".
+ * verdict from no data" (`no-verdict-from-no-data`) — is unit-testable.
+ *
+ * `work_item_id` is set iff the TASK resolved (independent of whether a comment
+ * exists), and `status` distinguishes the four states a hook must act on:
+ *   - "ready"        — task + a non-empty comment: inject the brief.
+ *   - "empty_brief"  — task resolved, comment exists but content is blank: the
+ *                      spawn minted a task with no usable brief — broken.
+ *   - "no_comment"   — task resolved, no comment at all: same broken class.
+ *   - "unbound"      — no task resolved: the lane has no brief task (a non-fleet
+ *                      operator tab, or — for the session-only path — a bind
+ *                      that has not yet commit; the work_item_id path cannot
+ *                      reach this for a fleet lane).
+ *
+ * "empty_brief" / "no_comment" with the task resolved is the state the
+ * absent-input fix exists to catch: a fleet lane whose spawn succeeded MUST
+ * have a non-empty brief comment, so its absence is a defect the hook halts on
+ * rather than reading as success.
  */
 export declare function shapeBriefResponse(task: {
     id: string;
@@ -36,6 +60,7 @@ export declare function shapeBriefResponse(task: {
     work_item_id: string | null;
     brief: string | null;
     comment_created_at: string | null;
+    status: BriefReadStatus;
 };
 /**
  * Read the LATEST comment on a work_items task. The comment IS the brief for a
@@ -62,8 +87,10 @@ export declare const readAssignedBriefHandler: import("@orpc/server").DecoratedP
     work_item_id: string | null;
     brief: string | null;
     comment_created_at: string | null;
+    status: BriefReadStatus;
 }, {
     work_item_id: string | null;
     brief: string | null;
     comment_created_at: string | null;
+    status: BriefReadStatus;
 }>, Record<never, never>, Record<never, never>>;

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

@@ -12,31 +12,55 @@ import { describe, it, expect } from "bun:test";
 import { shapeBriefResponse, readLatestTaskComment } from "./task-sync-brief.ts";
 
 describe("shapeBriefResponse (no verdict from no data)", () => {
-	it("returns all-null when there is no task", () => {
-		// A lane with no bound task has no brief — null, never an empty fake.
+	it("classifies a missing task as unbound (work_item_id null)", () => {
+		// A lane with no resolvable task has no brief — null, never an empty fake.
+		// status:"unbound" is the signal a non-fleet lane no-ops on and a fleet
+		// lane (which resolves by work_item_id, so cannot reach this) never sees.
 		expect(shapeBriefResponse(null, { content: "x", created_at: new Date() })).toEqual({
 			work_item_id: null,
 			brief: null,
 			comment_created_at: null,
+			status: "unbound",
 		});
 	});
 
-	it("returns all-null when the task has no comment yet", () => {
-		// The task exists but no spawn comment landed; the extension must inject
-		// nothing rather than a fabricated brief.
+	it("classifies a task with NO comment as no_comment (work_item_id SET)", () => {
+		// The task resolved but no spawn comment landed. work_item_id is now SET
+		// (the task IS bound) — distinct from unbound — and status:"no_comment"
+		// is the broken state a fleet lane halts on rather than reading as success.
 		expect(shapeBriefResponse({ id: "task-1" }, null)).toEqual({
-			work_item_id: null,
+			work_item_id: "task-1",
+			brief: null,
+			comment_created_at: null,
+			status: "no_comment",
+		});
+	});
+
+	it("classifies a task with a BLANK comment as empty_brief (the unreadable case)", () => {
+		// The comment exists but its content is empty/whitespace — "loads it
+		// empty". A fleet lane whose spawn minted a task MUST have a non-empty
+		// brief, so a blank comment is a defect the hook halts on, not a success.
+		expect(shapeBriefResponse({ id: "task-2" }, { content: "   ", created_at: new Date() })).toEqual({
+			work_item_id: "task-2",
 			brief: null,
 			comment_created_at: null,
+			status: "empty_brief",
+		});
+		expect(shapeBriefResponse({ id: "task-2b" }, { content: "", created_at: new Date() })).toEqual({
+			work_item_id: "task-2b",
+			brief: null,
+			comment_created_at: null,
+			status: "empty_brief",
 		});
 	});
 
-	it("returns the comment content + ISO created_at for a resolved task+comment", () => {
+	it("returns the comment content + ISO created_at + status ready for a resolved task+comment", () => {
 		const ts = new Date("2026-08-01T03:24:00.000Z");
 		expect(shapeBriefResponse({ id: "task-7" }, { content: "Do the thing", created_at: ts })).toEqual({
 			work_item_id: "task-7",
 			brief: "Do the thing",
 			comment_created_at: "2026-08-01T03:24:00.000Z",
+			status: "ready",
 		});
 	});
 
@@ -64,6 +88,22 @@ describe("readAssignedBrief reads the LATEST comment (source contract)", () => {
 		const text = await briefSrc.text();
 		expect(text).toContain("resolveLaneTask(prisma, session)");
 	});
+
+	it("resolves by the authoritative work_item_id BEFORE the session (deletes the bind race)", async () => {
+		// The spawn's known task id (SCALA_LANE_WORK_ITEM) cannot race — the row
+		// exists because the spawn created it — so resolving by it first makes an
+		// empty brief for a fleet lane unambiguously broken rather than a
+		// transient "retry" the lane can never exit (absent-input-reads-as-success).
+		const text = await briefSrc.text();
+		expect(text).toContain("workItemId");
+		expect(text).toContain("resolveTaskById(prisma, workItemId)");
+		// The session bind is no longer load-bearing for brief delivery: it stays
+		// only as the fallback for callers without a work_item_id.
+		const idIdx = text.indexOf("resolveTaskById(prisma, workItemId)");
+		const sessionIdx = text.indexOf("resolveLaneTask(prisma, session)");
+		expect(idIdx).toBeGreaterThan(-1);
+		expect(sessionIdx).toBeGreaterThan(idIdx);
+	});
 });
 
 describe("readLatestTaskComment is a single latest-comment read", () => {

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

@@ -25,27 +25,65 @@
 import type { Prisma, CommentRow } from "./task-sync-router.ts";
 import type { WorkItem } from "./task-sync-router.ts";
 import { authed, type Context } from "./auth-router.ts";
-import { resolveLaneTask } from "./task-sync-lane.ts";
+import { resolveLaneTask, resolveTaskById } from "./task-sync-lane.ts";
+
+/**
+ * The outcome of a brief read, single-sourced here so every CLI's self-brief
+ * hook (zerostack/codex shell, opencode/pi TS) branches on ONE field rather
+ * than each re-deriving "is the brief missing" from null/empty probes — the
+ * seam at which absent-input-reads-as-success hid (`the-severe-bugs-live-at-seams`).
+ *
+ * The hook decides ACTION from this; the classification lives here. A fleet
+ * lane (SCALA_LANE_WORK_ITEM set) treats anything but "ready" as a hard halt.
+ */
+export type BriefReadStatus = "ready" | "empty_brief" | "no_comment" | "unbound";
 
 /**
  * Shape the readAssignedBrief response from a resolved task + its latest
  * comment. Pure (no prisma) so the decision — "no task/comment ⇒ nulls, never a
- * verdict from no data" (`no-verdict-from-no-data`) — is unit-testable. A null
- * task or null comment returns all-null rather than an empty/fake brief, so the
- * extension can distinguish "nothing to inject" from "inject this".
+ * verdict from no data" (`no-verdict-from-no-data`) — is unit-testable.
+ *
+ * `work_item_id` is set iff the TASK resolved (independent of whether a comment
+ * exists), and `status` distinguishes the four states a hook must act on:
+ *   - "ready"        — task + a non-empty comment: inject the brief.
+ *   - "empty_brief"  — task resolved, comment exists but content is blank: the
+ *                      spawn minted a task with no usable brief — broken.
+ *   - "no_comment"   — task resolved, no comment at all: same broken class.
+ *   - "unbound"      — no task resolved: the lane has no brief task (a non-fleet
+ *                      operator tab, or — for the session-only path — a bind
+ *                      that has not yet commit; the work_item_id path cannot
+ *                      reach this for a fleet lane).
+ *
+ * "empty_brief" / "no_comment" with the task resolved is the state the
+ * absent-input fix exists to catch: a fleet lane whose spawn succeeded MUST
+ * have a non-empty brief comment, so its absence is a defect the hook halts on
+ * rather than reading as success.
  */
 export function shapeBriefResponse(
 	task: { id: string } | null,
 	comment: Pick<CommentRow, "content" | "created_at"> | null,
-): { work_item_id: string | null; brief: string | null; comment_created_at: string | null } {
-	if (!task || !comment) {
-		return { work_item_id: null, brief: null, comment_created_at: null };
+): {
+	work_item_id: string | null;
+	brief: string | null;
+	comment_created_at: string | null;
+	status: BriefReadStatus;
+} {
+	if (!task) {
+		return { work_item_id: null, brief: null, comment_created_at: null, status: "unbound" };
+	}
+	if (!comment) {
+		return { work_item_id: task.id, brief: null, comment_created_at: null, status: "no_comment" };
+	}
+	const text = typeof comment.content === "string" ? comment.content : String(comment.content);
+	if (text.trim() === "") {
+		return { work_item_id: task.id, brief: null, comment_created_at: null, status: "empty_brief" };
 	}
 	return {
 		work_item_id: task.id,
-		brief: comment.content,
+		brief: text,
 		comment_created_at:
 			comment.created_at instanceof Date ? comment.created_at.toISOString() : String(comment.created_at),
+		status: "ready",
 	};
 }
 
@@ -84,13 +122,28 @@ export async function readLatestTaskComment(
 export const readAssignedBriefHandler = authed.handler(async ({ input, context }) => {
 	const ctx = context as Context;
 	const prisma = ctx.prisma as Prisma;
-	const body = (input ?? {}) as { lane_session?: string };
+	const body = (input ?? {}) as { lane_session?: string; work_item_id?: string };
 	const session = body.lane_session ?? ctx.headers?.get("x-lane-session") ?? null;
-	if (!session) {
+	// The spawn's known task id (SCALA_LANE_WORK_ITEM) — AUTHORITATIVE for brief
+	// resolution. Resolving by it first deletes the bindLane race that made an
+	// empty brief read as a transient "retry" a fleet lane could never exit
+	// (absent-input-reads-as-success). Falls back to session for callers without
+	// it (operator tabs / pre-id lanes).
+	const workItemId =
+		body.work_item_id?.trim() || ctx.headers?.get("x-lane-work-item")?.trim() || null;
+	if (!session && !workItemId) {
 		const { ORPCError } = await import("@orpc/server");
-		throw new ORPCError("BAD_REQUEST", { message: "readAssignedBrief requires lane_session" });
+		throw new ORPCError("BAD_REQUEST", {
+			message: "readAssignedBrief requires lane_session or work_item_id",
+		});
+	}
+	let task: (WorkItem & { id: string }) | null = null;
+	if (workItemId) {
+		task = (await resolveTaskById(prisma, workItemId)) as (WorkItem & { id: string }) | null;
+	}
+	if (!task && session) {
+		task = (await resolveLaneTask(prisma, session)) as (WorkItem & { id: string }) | null;
 	}
-	const task = (await resolveLaneTask(prisma, session)) as (WorkItem & { id: string }) | null;
 	if (!task) return shapeBriefResponse(null, null);
 	const comment = await readLatestTaskComment(prisma, task.id);
 	return shapeBriefResponse(task, comment);

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

@@ -26,3 +26,24 @@
 import type { Prisma, WorkItem } from "./task-sync-router.ts";
 export declare function resolveLaneWorkName(prisma: Prisma, pane: string): Promise<string | null>;
 export declare function resolveLaneTask(prisma: Prisma, session: string): Promise<WorkItem | null>;
+/**
+ * Resolve a lane's task by its AUTHORITATIVE work_item id — the id the spawn
+ * minted (createBriefTask) and exported into the pane as SCALA_LANE_WORK_ITEM.
+ *
+ * WHY this exists alongside the session resolution: readAssignedBrief used to
+ * resolve ONLY by kind_data.lane.session, which is written by the lane's OWN
+ * bindLane hook at boot. That bind is a fire-and-forget POST racing the brief
+ * read, so a fleet lane whose bind had not yet commit read "no task" and the
+ * self-brief hook silently exited 0 — absent-input-reads-as-success at the
+ * dispatch boundary (a lane booted, was told its brief was loaded, had none,
+ * ran nothing, and was archived having done nothing — measured 2026-08-02).
+ *
+ * The work_item id is known to the spawn before the lane even starts
+ * (mintBriefTask returns it; the spawn REFUSES if minting fails for a capture
+ * CLI), so resolving by it CANNOT race: the row exists because the spawn
+ * created it. The session bind stays for task-list writes (upsertFromTaskList)
+ * — it is no longer load-bearing for brief delivery. Any status is matched
+ * (active OR archived) because the brief is the brief regardless of the run's
+ * state — closing a run archives the task, not the brief.
+ */
+export declare function resolveTaskById(prisma: Prisma, workItemId: string): Promise<WorkItem | null>;

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

@@ -36,8 +36,16 @@ export async function resolveLaneWorkName(prisma: Prisma, pane: string): Promise
 			}
 		).fleet_agent_runs;
 		if (!runs?.findFirst) return null;
+		// Most recent run for the pane, REGARDLESS of state. A lane's work name does
+		// not vanish when its run closes, and filtering `state != closed` here is
+		// exactly why task rows were titled "Lane": a task-list write (ensureLaneTask)
+		// that fires after the run closed resolved no name and fell back to the
+		// generic sentinel — spawn debris an orchestrator cannot attribute
+		// (measured 2026-08-01: 207 "Lane" rows). Newest-first so a reused pane
+		// resolves its CURRENT lane, not a prior one.
 		const run = await runs.findFirst({
-			where: { pane, state: { not: "closed" } },
+			where: { pane },
+			orderBy: { created_at: "desc" },
 			select: { slot_name: true },
 		});
 		const name = run?.slot_name?.trim();
@@ -89,3 +97,29 @@ export async function resolveLaneTask(prisma: Prisma, session: string): Promise<
 		orderBy: { created_at: "desc" },
 	});
 }
+
+/**
+ * Resolve a lane's task by its AUTHORITATIVE work_item id — the id the spawn
+ * minted (createBriefTask) and exported into the pane as SCALA_LANE_WORK_ITEM.
+ *
+ * WHY this exists alongside the session resolution: readAssignedBrief used to
+ * resolve ONLY by kind_data.lane.session, which is written by the lane's OWN
+ * bindLane hook at boot. That bind is a fire-and-forget POST racing the brief
+ * read, so a fleet lane whose bind had not yet commit read "no task" and the
+ * self-brief hook silently exited 0 — absent-input-reads-as-success at the
+ * dispatch boundary (a lane booted, was told its brief was loaded, had none,
+ * ran nothing, and was archived having done nothing — measured 2026-08-02).
+ *
+ * The work_item id is known to the spawn before the lane even starts
+ * (mintBriefTask returns it; the spawn REFUSES if minting fails for a capture
+ * CLI), so resolving by it CANNOT race: the row exists because the spawn
+ * created it. The session bind stays for task-list writes (upsertFromTaskList)
+ * — it is no longer load-bearing for brief delivery. Any status is matched
+ * (active OR archived) because the brief is the brief regardless of the run's
+ * state — closing a run archives the task, not the brief.
+ */
+export async function resolveTaskById(prisma: Prisma, workItemId: string): Promise<WorkItem | null> {
+	return prisma.work_items.findFirst({
+		where: { id: workItemId, kind: "task" },
+	});
+}

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

@@ -325,10 +325,12 @@ export declare const taskSyncRouter: {
         work_item_id: string | null;
         brief: string | null;
         comment_created_at: string | null;
+        status: import("./task-sync-brief.ts").BriefReadStatus;
     }, {
         work_item_id: string | null;
         brief: string | null;
         comment_created_at: string | null;
+        status: import("./task-sync-brief.ts").BriefReadStatus;
     }>, Record<never, never>, Record<never, never>>;
     /** SPAWNER→DB brief mint: `spawn_agent_tab` turns an initialPrompt into the task row (brief = first comment) the lane self-briefs from; returns the work_item_id that rides the spawn payload. Handler in task-sync-assign.ts. */
     createBriefTask: import("@orpc/server").DecoratedProcedure<import("@orpc/server").MergedInitialContext<Context & Record<never, never>, Context, Context>, import("@orpc/server").MergedCurrentContext<Context, {

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

@@ -43,7 +43,12 @@ 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, bindLaneInput, createBriefTaskHandler } from "./task-sync-assign.ts";
+import {
+	adoptAssignmentTask,
+	bindLaneInput,
+	createBriefTaskHandler,
+	resolveBindAction,
+} from "./task-sync-assign.ts";
 import * as v from "valibot";
 import {
 	STATUS_TO_WORK_ITEM,
@@ -269,6 +274,16 @@ async function ensureLaneTask(
 ): Promise<WorkItem | null> {
 	const existing = await resolveLaneTask(prisma, session);
 	if (existing) return existing;
+	// The lane's real work name — its fleet run's slot_name
+	// (lanes-named-by-the-spawner). resolveLaneWorkName reads the most recent run
+	// for the pane regardless of state, so a lane whose run closed still resolves.
+	// A task with NO resolvable name is NOT created: writing the generic "Lane"
+	// sentinel is exactly the unmakeable state this backstop must refuse (a row
+	// titled "Lane" tells the operator nothing and reads as spawn debris).
+	// Return null — reconcileTaskList throws, the TaskCreated hook discards
+	// (observably), so the lane never silently produces a "Lane" row.
+	const name = pane ? await resolveLaneWorkName(prisma, pane) : null;
+	if (!name || name.trim().toLowerCase() === "lane") return null;
 	const lane: LaneIdentity = { pane: pane ?? "", session, cli_kind: "claude-code", role: "agent" };
 	try {
 		return await prisma.work_items.create({
@@ -276,8 +291,11 @@ async function ensureLaneTask(
 				kind: "task",
 				parent_id: null,
 				organisation_id: resolveBindOrg(),
-				title: (pane ? await resolveLaneWorkName(prisma, pane) : null) ?? "Lane",
+				title: name,
 				status: "active",
+				// assignee_id on every bind path (see bindLane): without it a bound
+				// task reads as unowned to an orchestrator steering by assignee_id.
+				assignee_id: session,
 				kind_data: { lane },
 			},
 		});
@@ -478,7 +496,11 @@ export const taskSyncRouter = {
 		// lane is doing. The run's slot_name IS the work name
 		// (lanes-named-by-the-spawner); fall back to a bare "Lane" rather than
 		// leak the pane id when no run resolves a name.
-		const laneTitle = raw.title ?? (await resolveLaneWorkName(prisma, pane)) ?? "Lane";
+		// The lane's work name — NEVER the "Lane" sentinel (spawn debris an
+		// orchestrator cannot attribute). null when no run resolves a slot_name;
+		// the create path REFUSES rather than write "Lane" (lanes-named-by-the-
+		// spawner).
+		const laneTitle = raw.title ?? (await resolveLaneWorkName(prisma, pane)) ?? null;
 		let taskId: string;
 		let created: boolean;
 		if (existing) {
@@ -493,6 +515,11 @@ export const taskSyncRouter = {
 				// project cannot orphan a lane that already has one.
 				data: {
 					kind_data: kindData,
+					// assignee_id on EVERY bind path, not only adopt: a re-bind that
+					// left assignee_id null read as "unowned" to an orchestrator
+					// steering by it (measured 2026-08-01: "Dev-mcp bus claim" — a
+					// live lane whose task had a session but null assignee_id).
+					assignee_id: session,
 					...(raw.parent_id ? { parent_id: raw.parent_id } : {}),
 				},
 			});
@@ -500,26 +527,57 @@ export const taskSyncRouter = {
 			created = false;
 			log.info("[task-sync] bindLane: re-bound existing task", { taskId, session });
 		} else {
-			// DISPATCH-BY-ASSIGNMENT adopt. When the spawn carried a workItemId that
-			// points to an existing kind:"task" (the assignment task whose FIRST
-			// COMMENT is the brief), ADOPT it — write this lane's freshly-minted
-			// session onto it + set ownership (assignee_id) — instead of creating a
-			// new task that orphans the brief and leaves the lane self-briefing to
-			// nothing. Falls through to create for an exploratory lane (no
-			// workItemId) or a project parent (kind:"project"), so existing behaviour
-			// is unchanged on those paths.
-			const adopted = await adoptAssignmentTask(prisma, raw.parent_id ?? headerWorkItem, {
-				...lane,
-				session,
-			});
-			if (adopted) {
-				taskId = adopted.id;
+			// DISPATCH-BY-ASSIGNMENT adopt, then a write-back that NEVER orphans.
+			// The spawn may have carried a workItemId the lane should adopt; adopt
+			// attempts it, then resolveBindAction decides from the outcome:
+			//   use     — adopt succeeded.
+			//   create  — exploratory lane (no workItemId) or the id is a PROJECT
+			//             the task is created under.
+			//   refuse  — the spawn named a task that does NOT exist. This is the
+			//             `absent-input-reads-as-success` failure: silently creating
+			//             a new task here would abandon the spawn's referenced brief
+			//             and bind the lane to an empty task it was never meant to
+			//             own, leaving an orphan an orchestrator cannot tell from
+			//             real unowned work. Failing loudly surfaces the bad spawn.
+			const workItemId = raw.parent_id ?? headerWorkItem;
+			const adopted = await adoptAssignmentTask(prisma, workItemId, { ...lane, session });
+			let referencedKind: string | null = null;
+			if (!adopted && workItemId) {
+				const ref = await prisma.work_items.findFirst({
+					where: { id: workItemId },
+					select: { kind: true },
+				});
+				referencedKind = ref?.kind ?? null;
+			}
+			const action = resolveBindAction({ adopted, workItemId, referencedKind });
+			if (action.action === "refuse") {
+				const { ORPCError } = await import("@orpc/server");
+				throw new ORPCError("NOT_FOUND", {
+					message:
+						`bindLane: the spawn referenced work item ${action.workItemId} to adopt, but no task ` +
+						"exists with that id — refusing rather than creating an orphan task and abandoning the spawn's brief.",
+				});
+			}
+			if (action.action === "use") {
+				taskId = adopted!.id;
 				created = false;
 				log.info("[task-sync] bindLane: adopted assigned task", {
-					taskId: adopted.id,
+					taskId: adopted!.id,
 					session,
 				});
 			} else {
+				// A task's title must carry the lane's REAL work name — never the
+				// generic "Lane" sentinel (spawn debris an orchestrator cannot
+				// attribute). No resolvable name = refuse, so a "Lane" row is
+				// unmakeable on this path (lanes-named-by-the-spawner).
+				if (!laneTitle || laneTitle.trim().toLowerCase() === "lane") {
+					const { ORPCError } = await import("@orpc/server");
+					throw new ORPCError("BAD_REQUEST", {
+						message:
+							"bindLane: no real work name resolved for this lane (its fleet run has no slot_name). " +
+							"A task titled 'Lane' is spawn debris — name the lane at spawn (windowName) or ensure its fleet run resolves a slot_name.",
+					});
+				}
 				// Read-then-create is a race: SessionStart and the lane's first
 				// TaskCreate arrive seconds apart, both read nothing, and both create.
 				// Measured 2026-07-25: 9 lanes with two active parents each, every twin
@@ -536,6 +594,12 @@ export const taskSyncRouter = {
 							organisation_id,
 							title: laneTitle,
 							status: "active",
+							// assignee_id = the lane's session on EVERY bind path, not only
+							// adopt. Without it a bound task reads as unowned (assignee_id
+							// null) — the signal the fleet steers by. Measured 2026-08-01:
+							// 207 task rows with kind_data.lane.session set but assignee_id
+							// null, every one reading as unowned.
+							assignee_id: session,
 							kind_data: { lane },
 						},
 					});