@teamscala/service-boot 0.23.322 → 0.23.323

package/package.json

@@ -6,7 +6,7 @@
   },
   "name": "@teamscala/service-boot",
   "type": "module",
-  "version": "0.23.322",
+  "version": "0.23.323",
   "sideEffects": false,
   "files": [
     "src"
@@ -426,6 +426,14 @@
       "types": "./src/fn-routers/task-sync-projection.d.ts",
       "default": "./src/fn-routers/task-sync-projection.ts"
     },
+    "./fn-routers/task-sync-rename": {
+      "types": "./src/fn-routers/task-sync-rename.d.ts",
+      "default": "./src/fn-routers/task-sync-rename.ts"
+    },
+    "./fn-routers/task-sync-rename.ts": {
+      "types": "./src/fn-routers/task-sync-rename.d.ts",
+      "default": "./src/fn-routers/task-sync-rename.ts"
+    },
     "./fn-routers/task-sync-router": {
       "types": "./src/fn-routers/task-sync-router.d.ts",
       "default": "./src/fn-routers/task-sync-router.ts"

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

@@ -0,0 +1,91 @@
+/**
+ * @system service-boot
+ * @status handwritten
+ * @edit edit directly
+ *
+ * Lane RENAME back-write for task-sync: a tab rename EMITS to update the bound
+ * work_items task's title in the DB, by CLI session id. This is the DB half of
+ * `tab-rename-emits-back-to-task-title`: the operator's tab bar is how they see
+ * what is being worked on (`lane-labels-and-task-lists`), so the tmux window
+ * name and the task title must never diverge silently. Renaming a tab from
+ * `scala-tools session rename` (or the lane renaming itself through the same
+ * surface) updates the task title so the project board agrees with the tab bar.
+ *
+ * THE EMISSION, not a poll (`actions-are-rows-then-emissions`): a caller renames
+ * the window (a row/state change) and that change emits the title update — the
+ * task-sync owner reacts by updating the row. State lives in the row, never in a
+ * return value a caller may never receive.
+ *
+ * Bound by CLI SESSION ID, never pane id (`lane-identity-is-cli-session-id`): a
+ * pane OUTLIVES the session inside it, so matching on a pane would let a dead
+ * session's task answer for a live lane. The session is the stable identity a
+ * rename resolves to (the daemon resolves the pane's tab → its stored session id
+ * and passes that here), so the rename lands on the lane that owns the tab.
+ *
+ * Split out of task-sync-router.ts for the same reason task-sync-brief/lane/
+ * assign exist: the router sits at its 1000-line commit gate, so every cohesive
+ * task-sync unit that can live in a sibling does. This owns the rename handler +
+ * its pure outcome decision.
+ *
+ * CAPABILITY HARVEST (capability-harvest-on-split): APP-LOCAL, not a capability
+ * candidate. Bound to the work_items schema and to task-sync's own
+ * kind_data.lane.session convention; no unrelated app could install this
+ * unmodified.
+ */
+import * as v from "valibot";
+import { type Context } from "./auth-router.ts";
+/**
+ * renameLaneTask ORPC input. `lane_session` is the lane's CLI-native session id
+ * (kind_data.lane.session) — the stable identity a pane rename resolves to.
+ * `title` is the new task title (the renamed tab's label). Both required:
+ * oRPC rejects a call missing either at the signature
+ * (`prevention-over-detection`), so a malformed rename is a 400, never a silent
+ * no-op that leaves the title stale.
+ */
+export declare const renameLaneTaskInput: v.ObjectSchema<{
+    readonly lane_session: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, "lane_session is required">]>;
+    readonly title: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, "title is required">]>;
+}, undefined>;
+/**
+ * The rename outcome from a resolved lane task — pure so the "no task bound ⇒
+ * not updated, never an error" decision is unit-testable with no DB. A rename
+ * whose lane has no task is best-effort (returns updated:false): every spawn
+ * now mints a task, so this is the rare case (a tab whose task was archived and
+ * pruned), not a path the operator hits. Failing loudly here would refuse a
+ * rename of the WINDOW for a DB miss, which couples two surfaces that must not
+ * be — the tmux rename already succeeded before this is called.
+ */
+export declare function renameOutcome(task: {
+    id: string;
+} | null): {
+    task_id: string | null;
+    updated: boolean;
+};
+/**
+ * renameLaneTask ORPC handler. The session-picker daemon calls this from
+ * `/rpc/rename` after it renames the tmux window: it resolves the pane's tab to
+ * its session id and posts it here. Same transport as bindLane/readTaskList:
+ * page-gate-exempt (fn.taskSync), localhost super-admin. Resolves the lane's
+ * task BY SESSION (never pane) and updates its title. Idempotent: renaming to
+ * the same title writes the same row.
+ *
+ * An archived parent is matched too (resolveLaneTask falls back to the archived
+ * lane task for the session), so a rename of a tab whose run closed still lands
+ * on its task — the title is the title regardless of run state.
+ */
+export declare const renameLaneTaskHandler: 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 title: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, "title is required">]>;
+}, undefined>, import("@orpc/contract").Schema<{
+    task_id: string | null;
+    updated: boolean;
+}, {
+    task_id: string | null;
+    updated: boolean;
+}>, Record<never, never>, Record<never, never>>;

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

@@ -0,0 +1,53 @@
+/**
+ * @system service-boot
+ * @status handwritten
+ * @edit directly
+ *
+ * Unit tests for the rename back-write leg: renameOutcome (the pure
+ * no-task ⇒ not-updated decision) + source-contract assertions that the handler
+ * resolves the lane task BY SESSION (never pane) and updates its title. Covers
+ * `what-must-have-a-test` for the new procedure + the `lane-identity-is-cli-
+ * session-id` invariant it rides on.
+ */
+import { describe, it, expect } from "bun:test";
+import { renameOutcome } from "./task-sync-rename.ts";
+
+describe("renameOutcome (no verdict from no data)", () => {
+	it("returns not-updated with a null task_id when no task is bound to the session", () => {
+		// A rename of a tab whose lane has no resolvable task updates nothing —
+		// never an error, never a fake id. updated:false is the signal the caller
+		// treats as best-effort (the window was already renamed; this only missed
+		// the DB echo, which is the rare archived-and-pruned case).
+		expect(renameOutcome(null)).toEqual({ task_id: null, updated: false });
+	});
+
+	it("returns the bound task id + updated:true when a task resolves", () => {
+		expect(renameOutcome({ id: "task-9" })).toEqual({ task_id: "task-9", updated: true });
+	});
+});
+
+describe("renameLaneTask resolves BY SESSION and writes the title (source contract)", () => {
+	const renameSrc = Bun.file(new URL("./task-sync-rename.ts", import.meta.url).pathname);
+
+	it("resolves the lane task by lane_session (the CLI session id), never by pane", async () => {
+		// `lane-identity-is-cli-session-id`: binding is by session because a pane
+		// outlives the session inside it. A pane-keyed rename would let a dead
+		// session's task answer for a live lane.
+		const text = await renameSrc.text();
+		expect(text).toContain("resolveLaneTask(prisma, lane_session)");
+		// No pane matching anywhere in the resolution path.
+		expect(text).not.toContain("lane.pane");
+	});
+
+	it("updates the resolved task's title by id", async () => {
+		const text = await renameSrc.text();
+		expect(text).toContain('where: { id: task.id }');
+		expect(text).toContain("data: { title }");
+	});
+
+	it("requires lane_session + title at the signature (incomplete rename unconstructible)", async () => {
+		const text = await renameSrc.text();
+		expect(text).toContain('lane_session: v.pipe(v.string()');
+		expect(text).toContain('title: v.pipe(v.string()');
+	});
+});

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

@@ -0,0 +1,111 @@
+/**
+ * @system service-boot
+ * @status handwritten
+ * @edit edit directly
+ *
+ * Lane RENAME back-write for task-sync: a tab rename EMITS to update the bound
+ * work_items task's title in the DB, by CLI session id. This is the DB half of
+ * `tab-rename-emits-back-to-task-title`: the operator's tab bar is how they see
+ * what is being worked on (`lane-labels-and-task-lists`), so the tmux window
+ * name and the task title must never diverge silently. Renaming a tab from
+ * `scala-tools session rename` (or the lane renaming itself through the same
+ * surface) updates the task title so the project board agrees with the tab bar.
+ *
+ * THE EMISSION, not a poll (`actions-are-rows-then-emissions`): a caller renames
+ * the window (a row/state change) and that change emits the title update — the
+ * task-sync owner reacts by updating the row. State lives in the row, never in a
+ * return value a caller may never receive.
+ *
+ * Bound by CLI SESSION ID, never pane id (`lane-identity-is-cli-session-id`): a
+ * pane OUTLIVES the session inside it, so matching on a pane would let a dead
+ * session's task answer for a live lane. The session is the stable identity a
+ * rename resolves to (the daemon resolves the pane's tab → its stored session id
+ * and passes that here), so the rename lands on the lane that owns the tab.
+ *
+ * Split out of task-sync-router.ts for the same reason task-sync-brief/lane/
+ * assign exist: the router sits at its 1000-line commit gate, so every cohesive
+ * task-sync unit that can live in a sibling does. This owns the rename handler +
+ * its pure outcome decision.
+ *
+ * CAPABILITY HARVEST (capability-harvest-on-split): APP-LOCAL, not a capability
+ * candidate. Bound to the work_items schema and to task-sync's own
+ * kind_data.lane.session convention; no unrelated app could install this
+ * unmodified.
+ */
+
+import * as v from "valibot";
+import type { Prisma } from "./task-sync-router.ts";
+import { authed, type Context } from "./auth-router.ts";
+import { resolveLaneTask } from "./task-sync-lane.ts";
+import { getAppLogger } from "@teamscala/logger/app-loggers";
+
+/**
+ * renameLaneTask ORPC input. `lane_session` is the lane's CLI-native session id
+ * (kind_data.lane.session) — the stable identity a pane rename resolves to.
+ * `title` is the new task title (the renamed tab's label). Both required:
+ * oRPC rejects a call missing either at the signature
+ * (`prevention-over-detection`), so a malformed rename is a 400, never a silent
+ * no-op that leaves the title stale.
+ */
+export const renameLaneTaskInput = v.object({
+	lane_session: v.pipe(v.string(), v.minLength(1, "lane_session is required")),
+	title: v.pipe(v.string(), v.minLength(1, "title is required")),
+});
+
+/**
+ * The rename outcome from a resolved lane task — pure so the "no task bound ⇒
+ * not updated, never an error" decision is unit-testable with no DB. A rename
+ * whose lane has no task is best-effort (returns updated:false): every spawn
+ * now mints a task, so this is the rare case (a tab whose task was archived and
+ * pruned), not a path the operator hits. Failing loudly here would refuse a
+ * rename of the WINDOW for a DB miss, which couples two surfaces that must not
+ * be — the tmux rename already succeeded before this is called.
+ */
+export function renameOutcome(task: { id: string } | null): {
+	task_id: string | null;
+	updated: boolean;
+} {
+	if (!task) return { task_id: null, updated: false };
+	return { task_id: task.id, updated: true };
+}
+
+/**
+ * renameLaneTask ORPC handler. The session-picker daemon calls this from
+ * `/rpc/rename` after it renames the tmux window: it resolves the pane's tab to
+ * its session id and posts it here. Same transport as bindLane/readTaskList:
+ * page-gate-exempt (fn.taskSync), localhost super-admin. Resolves the lane's
+ * task BY SESSION (never pane) and updates its title. Idempotent: renaming to
+ * the same title writes the same row.
+ *
+ * An archived parent is matched too (resolveLaneTask falls back to the archived
+ * lane task for the session), so a rename of a tab whose run closed still lands
+ * on its task — the title is the title regardless of run state.
+ */
+export const renameLaneTaskHandler = authed
+	.input(renameLaneTaskInput)
+	.handler(async ({ input, context }) => {
+		const ctx = context as Context;
+		const prisma = ctx.prisma as Prisma;
+		const { lane_session, title } = input;
+		const task = await resolveLaneTask(prisma, lane_session);
+		const outcome = renameOutcome(task);
+		if (!task) return outcome;
+		try {
+			await prisma.work_items.update({
+				where: { id: task.id },
+				data: { title },
+				select: { id: true },
+			});
+		} catch (err) {
+			// The window was already renamed by the caller; a DB update failure must
+			// not surface as an error that implies the rename failed. Report
+			// not-updated + log, so the two surfaces stay decoupled
+			// (`a-component-may-not-report-a-state-it-has-not-verified`).
+			getAppLogger().warn("[task-sync] renameLaneTask: title update failed", {
+				taskId: task.id,
+				error: err instanceof Error ? err.message : String(err),
+			});
+			return { task_id: task.id, updated: false };
+		}
+		return outcome;
+	});

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

@@ -344,6 +344,28 @@ export declare const taskSyncRouter: {
     }, {
         work_item_id: string;
     }>, Record<never, never>, Record<never, never>>;
+    /**
+     * TAB→DB rename back-write: the session-picker `/rpc/rename` calls this after
+     * renaming a tmux window to update the bound task's title BY SESSION (never
+     * pane), so the tab bar and the project board never diverge
+     * (`tab-rename-emits-back-to-task-title`). Handler in task-sync-rename.ts.
+     */
+    renameLaneTask: 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 title: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, "title is required">]>;
+    }, undefined>, import("@orpc/contract").Schema<{
+        task_id: string | null;
+        updated: boolean;
+    }, {
+        task_id: string | null;
+        updated: boolean;
+    }>, Record<never, never>, Record<never, never>>;
     /**
      * DB→AGENT realtime leg (explicit dispatch path). Record an out-of-band
      * change to a subtask's status (operator toggles it in the projects UI,

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

@@ -43,6 +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 { renameLaneTaskHandler } from "./task-sync-rename.ts";
 import {
 	adoptAssignmentTask,
 	bindLaneInput,
@@ -772,6 +773,14 @@ export const taskSyncRouter = {
 	/** 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: createBriefTaskHandler,
 
+	/**
+	 * TAB→DB rename back-write: the session-picker `/rpc/rename` calls this after
+	 * renaming a tmux window to update the bound task's title BY SESSION (never
+	 * pane), so the tab bar and the project board never diverge
+	 * (`tab-rename-emits-back-to-task-title`). Handler in task-sync-rename.ts.
+	 */
+	renameLaneTask: renameLaneTaskHandler,
+
 	/**
 	 * DB→AGENT realtime leg (explicit dispatch path). Record an out-of-band
 	 * change to a subtask's status (operator toggles it in the projects UI,