@teamscala/service-boot 0.23.329 → 0.23.331

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

@@ -5,20 +5,19 @@
  *
  * Unit tests for the self-brief leg: shapeBriefResponse (the pure
  * no-task/no-comment ⇒ nulls decision) + source-contract assertions that
- * readFirstTaskComment reads the FIRST launch comment and the handler resolves by
+ * readLatestTaskComment reads the LATEST comment and the handler resolves by
  * session. Covers `what-must-have-a-test` for the new procedure.
  */
 import { describe, it, expect } from "bun:test";
-import { shapeBriefResponse, readFirstTaskComment } from "./task-sync-brief.ts";
+import { shapeBriefResponse, readLatestTaskComment } from "./task-sync-brief.ts";
 
 describe("shapeBriefResponse (no verdict from no data)", () => {
 	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, { id: "c-0", content: "x", created_at: new Date() })).toEqual({
+		expect(shapeBriefResponse(null, { content: "x", created_at: new Date() })).toEqual({
 			work_item_id: null,
-			comment_id: null,
 			brief: null,
 			comment_created_at: null,
 			status: "unbound",
@@ -31,7 +30,6 @@ describe("shapeBriefResponse (no verdict from no data)", () => {
 		// is the broken state a fleet lane halts on rather than reading as success.
 		expect(shapeBriefResponse({ id: "task-1" }, null)).toEqual({
 			work_item_id: "task-1",
-			comment_id: null,
 			brief: null,
 			comment_created_at: null,
 			status: "no_comment",
@@ -42,16 +40,14 @@ describe("shapeBriefResponse (no verdict from no data)", () => {
 		// 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" }, { id: "c-2", content: "   ", created_at: new Date() })).toEqual({
+		expect(shapeBriefResponse({ id: "task-2" }, { content: "   ", created_at: new Date() })).toEqual({
 			work_item_id: "task-2",
-			comment_id: "c-2",
 			brief: null,
 			comment_created_at: null,
 			status: "empty_brief",
 		});
-		expect(shapeBriefResponse({ id: "task-2b" }, { id: "c-2b", content: "", created_at: new Date() })).toEqual({
+		expect(shapeBriefResponse({ id: "task-2b" }, { content: "", created_at: new Date() })).toEqual({
 			work_item_id: "task-2b",
-			comment_id: "c-2b",
 			brief: null,
 			comment_created_at: null,
 			status: "empty_brief",
@@ -60,9 +56,8 @@ describe("shapeBriefResponse (no verdict from no data)", () => {
 
 	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" }, { id: "c-7", content: "Do the thing", created_at: ts })).toEqual({
+		expect(shapeBriefResponse({ id: "task-7" }, { content: "Do the thing", created_at: ts })).toEqual({
 			work_item_id: "task-7",
-			comment_id: "c-7",
 			brief: "Do the thing",
 			comment_created_at: "2026-08-01T03:24:00.000Z",
 			status: "ready",
@@ -71,18 +66,19 @@ describe("shapeBriefResponse (no verdict from no data)", () => {
 
 	it("serializes the comment created_at deterministically (Date → ISO)", () => {
 		const ts = new Date(0);
-		const out = shapeBriefResponse({ id: "t" }, { id: "c", content: "c", created_at: ts });
+		const out = shapeBriefResponse({ id: "t" }, { content: "c", created_at: ts });
 		expect(out.comment_created_at).toBe("1970-01-01T00:00:00.000Z");
 	});
 });
 
-describe("readAssignedBrief reads the FIRST launch comment (source contract)", () => {
+describe("readAssignedBrief reads the LATEST comment (source contract)", () => {
 	const briefSrc = Bun.file(new URL("./task-sync-brief.ts", import.meta.url).pathname);
 
-	it("queries comments oldest-first with an id tie-breaker", async () => {
-		// The first comment is immutable launch identity; later comments are dialogue.
+	it("queries comments newest-first by created_at on work_item_id", async () => {
+		// The comment IS the brief for a run; ordering by created_at desc makes the
+		// LATEST comment (this run's) the answer, never a stale prior-run comment.
 		const text = await briefSrc.text();
-		expect(text).toContain('orderBy: [{ created_at: "asc" }, { id: "asc" }]');
+		expect(text).toContain('orderBy: { created_at: "desc" }');
 		expect(text).toContain("work_item_id: workItemId");
 	});
 
@@ -110,11 +106,12 @@ describe("readAssignedBrief reads the FIRST launch comment (source contract)", (
 	});
 });
 
-describe("readFirstTaskComment is a single deterministic launch-comment read", () => {
+describe("readLatestTaskComment is a single latest-comment read", () => {
 	it("returns null when the prisma client has no comments model (feature-detect)", async () => {
-		// `comments` is a universal shared model; a client without it degrades to
-		// "no brief" rather than throwing.
-		const out = await readFirstTaskComment({} as never, "task-1");
+		// `comments` is a universal shared model, but the access is feature-detected
+		// like the fleet_agent_runs reads so a client without it degrades to "no
+		// brief" rather than throwing.
+		const out = await readLatestTaskComment({} as never, "task-1");
 		expect(out).toBe(null);
 	});
 });

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

@@ -5,7 +5,7 @@
  *
  * Lane BRIEF resolution for task-sync: a spawned lane PULLS its own brief. The
  * lane's CLI extension reads its own session id on load, resolves the task
- * assigned to that session, and reads the brief from that task's FIRST comment.
+ * assigned to that session, and reads the brief from that task's LATEST comment.
  * Nothing is pasted, typed, passed as an argument or sent over a channel
  * (`scala-docs/reference/action-emission-architecture.md` "The lane PULLS its
  * brief"). This file owns the readAssignedBrief ORPC handler + its pure helper;
@@ -39,7 +39,7 @@ import { resolveLaneTask, resolveTaskById } from "./task-sync-lane.ts";
 export type BriefReadStatus = "ready" | "empty_brief" | "no_comment" | "unbound";
 
 /**
- * Shape the readAssignedBrief response from a resolved task + its first
+ * 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.
  *
@@ -61,27 +61,25 @@ export type BriefReadStatus = "ready" | "empty_brief" | "no_comment" | "unbound"
  */
 export function shapeBriefResponse(
 	task: { id: string } | null,
-	comment: Pick<CommentRow, "id" | "content" | "created_at"> | null,
+	comment: Pick<CommentRow, "content" | "created_at"> | null,
 ): {
 	work_item_id: string | null;
-	comment_id: string | null;
 	brief: string | null;
 	comment_created_at: string | null;
 	status: BriefReadStatus;
 } {
 	if (!task) {
-		return { work_item_id: null, comment_id: null, brief: null, comment_created_at: null, status: "unbound" };
+		return { work_item_id: null, brief: null, comment_created_at: null, status: "unbound" };
 	}
 	if (!comment) {
-		return { work_item_id: task.id, comment_id: null, brief: null, comment_created_at: null, status: "no_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, comment_id: comment.id, brief: null, comment_created_at: null, status: "empty_brief" };
+		return { work_item_id: task.id, brief: null, comment_created_at: null, status: "empty_brief" };
 	}
 	return {
 		work_item_id: task.id,
-		comment_id: comment.id,
 		brief: text,
 		comment_created_at:
 			comment.created_at instanceof Date ? comment.created_at.toISOString() : String(comment.created_at),
@@ -90,12 +88,13 @@ export function shapeBriefResponse(
 }
 
 /**
- * Read the immutable FIRST comment on a work_items task. It is the launch brief;
- * later comments are conversation and must never change the launch identity.
- * Oldest-first by created_at with id as a deterministic tie-breaker. Returns null
- * when the task has no comment yet.
+ * Read the LATEST comment on a work_items task. The comment IS the brief for a
+ * run: every spawn writes a NEW comment, and the description is never the brief,
+ * so "what was this lane told" always has exactly one answer
+ * (`assignment-as-dispatch`). Newest-first by created_at. Returns null when the
+ * task has no comment yet — the extension treats that as "no brief to inject".
  */
-export async function readFirstTaskComment(
+export async function readLatestTaskComment(
 	prisma: Prisma,
 	workItemId: string,
 ): Promise<CommentRow | null> {
@@ -109,7 +108,7 @@ export async function readFirstTaskComment(
 	if (!comments?.findFirst) return null;
 	return comments.findFirst({
 		where: { work_item_id: workItemId },
-		orderBy: [{ created_at: "asc" }, { id: "asc" }],
+		orderBy: { created_at: "desc" },
 	});
 }
 
@@ -146,6 +145,6 @@ export const readAssignedBriefHandler = authed.handler(async ({ input, context }
 		task = (await resolveLaneTask(prisma, session)) as (WorkItem & { id: string }) | null;
 	}
 	if (!task) return shapeBriefResponse(null, null);
-	const comment = await readFirstTaskComment(prisma, task.id);
+	const comment = await readLatestTaskComment(prisma, task.id);
 	return shapeBriefResponse(task, comment);
 });

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

@@ -0,0 +1,41 @@
+/**
+ * @system service-boot
+ * @status handwritten
+ * @edit edit directly
+ *
+ * Lane-close write-through for task-sync. The session-owning fleet runtime
+ * calls this ORPC procedure before releasing an ACP lane, so work_items remains
+ * the durable lifecycle source without a second raw-SQL writer in the host.
+ */
+import * as v from "valibot";
+import { type Context } from "./auth-router.ts";
+import type { WorkItem } from "./task-sync-router.ts";
+export declare const closeLaneInput: v.ObjectSchema<{
+    readonly lane_session: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, "lane_session is required">]>;
+    readonly disposition: v.PicklistSchema<["completed", "needs_retry", "failed", "orchestrator_closed", "orphaned"], undefined>;
+}, undefined>;
+export interface ClosedTaskState {
+    task_id: string;
+    task_status: "done" | "archived";
+    completed: boolean;
+    kind_data: Record<string, unknown>;
+}
+export declare function closedTaskState(task: Pick<WorkItem, "id" | "kind_data">, disposition: v.InferOutput<typeof closeLaneInput>["disposition"]): ClosedTaskState;
+export declare const closeLaneHandler: import("@orpc/server").DecoratedProcedure<import("@orpc/server").MergedInitialContext<Context & Record<never, never>, Context, Context>, import("@orpc/server").MergedCurrentContext<Context, {
+    headers: Headers;
+    resolveUser?: (headers: Headers, prisma: any) => Promise<import("./auth-router.ts").User | null>;
+    prisma: any;
+    user: import("./auth-router.ts").User;
+    orgId: string | null | undefined;
+}>, v.ObjectSchema<{
+    readonly lane_session: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, "lane_session is required">]>;
+    readonly disposition: v.PicklistSchema<["completed", "needs_retry", "failed", "orchestrator_closed", "orphaned"], undefined>;
+}, undefined>, import("@orpc/contract").Schema<{
+    task_id: string;
+    task_status: "archived" | "done";
+    reconciled: boolean;
+}, {
+    task_id: string;
+    task_status: "archived" | "done";
+    reconciled: boolean;
+}>, Record<never, never>, Record<never, never>>;

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

@@ -0,0 +1,61 @@
+/**
+ * @system service-boot
+ * @status handwritten
+ * @edit edit directly
+ *
+ * DB→AGENT dispatch for task-sync — notifies a lane's live pane that its
+ * work_items task list changed out-of-band (operator toggled a subtask in the
+ * projects UI, another lane edited a shared task). The pane's adapter then
+ * re-reads (fn.taskSync.readTaskList) and updates its native list.
+ *
+ * MECHANISM — reuses the existing CLI-agnostic channel delivery, no new
+ * transport: a POST to scala-channel's fleet-events publish entry
+ * (POST /api/fleet/events — @teamscala/channel/fleet-events-publish) carrying an
+ * `orchestrator.message` FleetEvent with slotName "cross-pane". That slot is
+ * the watchEvents bypass for events NOT tied to a fleet_agent_runs row
+ * (FleetEventOrchestratorMessageSchema comment) — exactly the system-originated
+ * case. scala-channel re-emits onto its eventBus and streamFleetEvents delivers
+ * to the subscriber filtered by orchestratorSessionId (the target lane pane).
+ * Both the Claude Code relay and the OpenCode scala-hooks plugin subscribe to
+ * that SSE stream for their own pane identity and inject each event natively —
+ * so ONE publish reaches every CLI that has a live projection, no per-CLI
+ * dispatch code here.
+ *
+ * NOT the dispatch entry (POST /api/channel/send): that path requires a real
+ * sender pane identity (channel-sender-identity-validated anti-spoof) and so
+ * cannot carry a system-originated notification. The publish path is
+ * internal-trusted (localhost super-admin) and accepts a synthetic
+ * fromOrchestratorId — the correct path for a system→pane message.
+ *
+ * scala-channel's address is resolved from its service_routing row (local_port)
+ * — never hardcoded (service-ports-from-registry). Fire-and-forget: a dispatch
+ * failure (scala-channel down, port unresolvable) is logged and swallowed; it
+ * must never block the work_items write that triggered it, and the lane's
+ * SessionStart/UserPromptSubmit backstop picks up the change on its next turn
+ * regardless.
+ */
+/**
+ * The `orchestrator.message` FleetEvent payload that notifies a lane its task
+ * list changed. Pure (no I/O) so it is unit-testable; notifyLaneOfTaskChange
+ * posts it. slotName "cross-pane" is REQUIRED — it is the watchEvents bypass for
+ * events not tied to a fleet_agent_runs row. orchestratorSessionId is the TARGET
+ * lane pane (the SSE subscriber filter). The message is single-line (the
+ * <channel> tag renders it inline).
+ */
+export interface TaskChangedEvent {
+    type: "orchestrator.message";
+    message: string;
+    fromOrchestratorId: string;
+    runId: string;
+    slotName: "cross-pane";
+    ts: number;
+    orchestratorSessionId: string;
+}
+export declare function buildTaskChangedEvent(lanePane: string, taskId: string, now?: number): TaskChangedEvent;
+/**
+ * Publish a "your task list changed" notification to the owning lane's pane.
+ * The pane identity is the stable tmux id ("tmux:%42") every CLI relay/plugin
+ * receives for. `taskId` is carried in the message so the recipient can re-read
+ * just that task. Fire-and-forget.
+ */
+export declare function notifyLaneOfTaskChange(lanePane: string, taskId: string): Promise<void>;

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

@@ -3,60 +3,42 @@
  * @status handwritten
  * @edit edit directly
  *
- * Unit tests for the pure durable comment-payload builder in task-sync-dispatch.
- * The runtime path writes this payload through the canonical comments model.
+ * Unit tests for the pure event-payload builder in task-sync-dispatch. The HTTP
+ * POST + registry resolution are side-effectful (covered end-to-end by the
+ * DB->AGENT direction demo — a published orchestrator.message with slotName
+ * cross-pane delivers to the target pane's <channel> tag); buildTaskChangedEvent
+ * is pure and tested here. Satisfies what-must-have-a-test / primitive-api-has-test.
  */
 import { describe, it, expect } from "bun:test";
-import { buildTaskChangeComment, notifyLaneOfTaskChange } from "./task-sync-dispatch.ts";
+import { buildTaskChangedEvent } from "./task-sync-dispatch.ts";
 
-	describe("task-sync buildTaskChangeComment", () => {
-		it("addresses the canonical task and runtime with no pane transport", () => {
-			const comment = buildTaskChangeComment("task-7", "session-5", "subtask-1:completed");
-			expect(comment).toMatchObject({
-				work_item_id: "task-7",
-				source_cli_session_id: "session-5",
-				sender_role: "system",
-				sender_name: "TaskSync",
-			});
-			expect(comment.system_key).toBe("task-sync:task-7:session-5:subtask-1:completed");
-			expect(comment.content).toContain("readTaskList");
-			expect(comment).not.toHaveProperty("pane");
-		});
+describe("task-sync buildTaskChangedEvent", () => {
+	it("is an orchestrator.message addressed to the owning lane pane", () => {
+		const e = buildTaskChangedEvent("tmux:%5", "task-7", 1700000000000);
+		expect(e.type).toBe("orchestrator.message");
+		expect(e.orchestratorSessionId).toBe("tmux:%5");
+	});
+
+	it("uses slotName cross-pane so watchEvents bypasses the fleet-run-existence check", () => {
+		const e = buildTaskChangedEvent("tmux:%5", "task-7", 1700000000000);
+		expect(e.slotName).toBe("cross-pane");
+	});
 
-		it("writes one durable comment addressed by the active cli_session", async () => {
-			const calls: unknown[] = [];
-			const result = await notifyLaneOfTaskChange(
-				{
-					cli_sessions: { findFirst: async () => ({ id: "session-5" }) },
-					comments: {
-						upsert: async (args) => {
-							calls.push(args);
-							return { id: "comment-1" };
-						},
-					},
-				},
-				"task-7",
-				"subtask-1:completed",
-			);
-			expect(result).toMatchObject({ delivered: true, sessionId: "session-5", commentId: "comment-1" });
-			expect(calls[0]).toMatchObject({ create: { work_item_id: "task-7", source_cli_session_id: "session-5" } });
-		});
+	it("carries the task id in the message so the recipient can re-read just it", () => {
+		const e = buildTaskChangedEvent("tmux:%5", "task-7", 1700000000000);
+		expect(e.message).toContain("task-7");
+		expect(e.message).toContain("readTaskList");
+	});
+
+	it("produces a single-line message (the <channel> tag renders it inline)", () => {
+		const e = buildTaskChangedEvent("tmux:%5", "task-7", 1700000000000);
+		expect(e.message.includes("\n")).toBe(false);
+	});
 
-		it("does not fabricate a pre-launch session or comment", async () => {
-			let writes = 0;
-			const result = await notifyLaneOfTaskChange(
-				{
-					cli_sessions: { findFirst: async () => null },
-					comments: {
-						upsert: async () => {
-							writes++;
-							return { id: "unexpected" };
-						},
-					},
-				},
-				"task-7",
-			);
-			expect(result).toEqual({ delivered: false, sessionId: null, commentId: null });
-			expect(writes).toBe(0);
-		});
+	it("stamps the system sender + a deterministic runId + the provided epoch-ms ts", () => {
+		const e = buildTaskChangedEvent("tmux:%5", "task-7", 1700000000000);
+		expect(e.fromOrchestratorId).toBe("task-sync");
+		expect(e.runId).toBe("task-sync-task-7-1700000000000");
+		expect(e.ts).toBe(1700000000000);
 	});
+});

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

@@ -0,0 +1,124 @@
+/**
+ * @system service-boot
+ * @status handwritten
+ * @edit edit directly
+ *
+ * DB→AGENT dispatch for task-sync — notifies a lane's live pane that its
+ * work_items task list changed out-of-band (operator toggled a subtask in the
+ * projects UI, another lane edited a shared task). The pane's adapter then
+ * re-reads (fn.taskSync.readTaskList) and updates its native list.
+ *
+ * MECHANISM — reuses the existing CLI-agnostic channel delivery, no new
+ * transport: a POST to scala-channel's fleet-events publish entry
+ * (POST /api/fleet/events — @teamscala/channel/fleet-events-publish) carrying an
+ * `orchestrator.message` FleetEvent with slotName "cross-pane". That slot is
+ * the watchEvents bypass for events NOT tied to a fleet_agent_runs row
+ * (FleetEventOrchestratorMessageSchema comment) — exactly the system-originated
+ * case. scala-channel re-emits onto its eventBus and streamFleetEvents delivers
+ * to the subscriber filtered by orchestratorSessionId (the target lane pane).
+ * Both the Claude Code relay and the OpenCode scala-hooks plugin subscribe to
+ * that SSE stream for their own pane identity and inject each event natively —
+ * so ONE publish reaches every CLI that has a live projection, no per-CLI
+ * dispatch code here.
+ *
+ * NOT the dispatch entry (POST /api/channel/send): that path requires a real
+ * sender pane identity (channel-sender-identity-validated anti-spoof) and so
+ * cannot carry a system-originated notification. The publish path is
+ * internal-trusted (localhost super-admin) and accepts a synthetic
+ * fromOrchestratorId — the correct path for a system→pane message.
+ *
+ * scala-channel's address is resolved from its service_routing row (local_port)
+ * — never hardcoded (service-ports-from-registry). Fire-and-forget: a dispatch
+ * failure (scala-channel down, port unresolvable) is logged and swallowed; it
+ * must never block the work_items write that triggered it, and the lane's
+ * SessionStart/UserPromptSubmit backstop picks up the change on its next turn
+ * regardless.
+ */
+
+import { loadRegistryConfig } from "@teamscala/db/registry/load-config";
+import { ServiceRoutingConfigSchema } from "@teamscala/db-validation/registry-schemas/service-routing";
+import { getAppLogger } from "@teamscala/logger/app-loggers";
+
+let cachedChannelBaseUrl: string | null | undefined;
+
+async function resolveChannelBaseUrl(): Promise<string | null> {
+	if (cachedChannelBaseUrl !== undefined) return cachedChannelBaseUrl;
+	try {
+		const row = await loadRegistryConfig("service_routing", "scala-channel", ServiceRoutingConfigSchema);
+		const port = row?.local_port;
+		cachedChannelBaseUrl = port ? `http://127.0.0.1:${port}` : null;
+	} catch {
+		cachedChannelBaseUrl = null;
+	}
+	return cachedChannelBaseUrl;
+}
+
+/** The system sender identity stamped on fromOrchestratorId. */
+const FROM_ORCHESTRATOR_ID = "task-sync";
+
+/**
+ * The `orchestrator.message` FleetEvent payload that notifies a lane its task
+ * list changed. Pure (no I/O) so it is unit-testable; notifyLaneOfTaskChange
+ * posts it. slotName "cross-pane" is REQUIRED — it is the watchEvents bypass for
+ * events not tied to a fleet_agent_runs row. orchestratorSessionId is the TARGET
+ * lane pane (the SSE subscriber filter). The message is single-line (the
+ * <channel> tag renders it inline).
+ */
+export interface TaskChangedEvent {
+	type: "orchestrator.message";
+	message: string;
+	fromOrchestratorId: string;
+	runId: string;
+	slotName: "cross-pane";
+	ts: number;
+	orchestratorSessionId: string;
+}
+
+export function buildTaskChangedEvent(lanePane: string, taskId: string, now: number = Date.now()): TaskChangedEvent {
+	return {
+		type: "orchestrator.message",
+		message: `TaskSync: your work_items task list changed externally (task ${taskId}). Re-read via fn.taskSync.readTaskList and update your todo list.`,
+		fromOrchestratorId: FROM_ORCHESTRATOR_ID,
+		runId: `task-sync-${taskId}-${now}`,
+		slotName: "cross-pane",
+		ts: now,
+		orchestratorSessionId: lanePane,
+	};
+}
+
+/**
+ * Publish a "your task list changed" notification to the owning lane's pane.
+ * The pane identity is the stable tmux id ("tmux:%42") every CLI relay/plugin
+ * receives for. `taskId` is carried in the message so the recipient can re-read
+ * just that task. Fire-and-forget.
+ */
+export async function notifyLaneOfTaskChange(
+	lanePane: string,
+	taskId: string,
+): Promise<void> {
+	const log = getAppLogger();
+	if (!lanePane) return;
+	const base = await resolveChannelBaseUrl();
+	if (!base) {
+		log.warn("[task-sync] notifyLaneOfTaskChange: scala-channel address unresolvable", { taskId });
+		return;
+	}
+	const payload = buildTaskChangedEvent(lanePane, taskId);
+	try {
+		const res = await fetch(`${base}/api/fleet/events`, {
+			method: "POST",
+			headers: { "content-type": "application/json" },
+			body: JSON.stringify(payload),
+			signal: AbortSignal.timeout(3000),
+		});
+		if (!res.ok) {
+			log.warn("[task-sync] notifyLaneOfTaskChange: non-2xx from scala-channel", {
+				taskId, status: res.status,
+			});
+		}
+	} catch (err) {
+		log.warn("[task-sync] notifyLaneOfTaskChange: POST failed", {
+			taskId, error: err instanceof Error ? err.message : String(err),
+		});
+	}
+}

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

@@ -0,0 +1,49 @@
+/**
+ * @system service-boot
+ * @status handwritten
+ * @edit edit directly
+ *
+ * Lane RESOLUTION for task-sync: given a session or a pane, which work_items
+ * task IS this lane, and what is it called.
+ *
+ * Split out of task-sync-router.ts, which had reached 998 of its 1000-line
+ * budget — two lines from frozen. That is not tidiness: the budget is a commit
+ * gate, so at 998 lines ANY change to task-sync was blocked for every lane, and
+ * the four-line fix that needed to land could not. The router header records
+ * being split once before for exactly this reason; it grew back.
+ *
+ * The seam matches the one that split the projection. Everything here answers
+ * "which lane, called what" from an identity, and none of it touches the ORPC
+ * surface or decides what a task list should become — which is why these move
+ * together rather than one at a time: resolveLaneTask alone has seven callers.
+ *
+ * CAPABILITY HARVEST (capability-harvest-on-split): APP-LOCAL, not a capability
+ * candidate. Checked against the 14 platform singletons and the package
+ * catalogue; the doctrine test fails plainly, because every export is bound to
+ * the work_items schema and to task-sync own kind_data.lane convention, so no
+ * unrelated app could install this unmodified.
+ */
+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>;