@teamscala/service-boot 0.23.293 → 0.23.295

package/package.json

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

package/src/build-client-assets/input-hashing.ts

@@ -24,6 +24,7 @@
 import { createHash } from "node:crypto";
 import { existsSync } from "node:fs";
 import { dirname, join, relative, resolve } from "node:path";
+import { firstPartyScopeAlternation } from "@teamscala/os/workspace-topology/first-party-scopes";
 
 // Resolve + hash the content of every `@import` in app.css's @teamscala/*
 // stylesheet chain — INCLUDING transitive @imports (generic-ui/styles.css
@@ -59,7 +60,7 @@ export async function hashResolvedPackageStylesheets(
 		}
 	};
 	for (const spec of [
-		...appCss.matchAll(/@import\s+["'](@teamgbg\/[^"']+)["']/g),
+		...appCss.matchAll(new RegExp(`@import\\s+["']((?:${firstPartyScopeAlternation()})\\/[^"']+)['"]`, "g")),
 	].map((m) => m[1].trim())) {
 		await hashSpec(spec, join(cwd, "src"));
 	}

package/src/fn-routers/task-sync-created-status.test.ts

@@ -0,0 +1,58 @@
+/**
+ * A task CREATED already finished must project as done, not open.
+ *
+ * `TaskCreate({status:"completed"})` is the normal way to record work performed
+ * after the fact. The create path hardcoded `status: "todo"`, so such a task
+ * landed OPEN and the stop gate then blocked the lane on a task it had itself
+ * recorded as done — observed twice on 2026-07-31, each needing a manual
+ * work_items update to clear. The UPDATE path already mapped through
+ * STATUS_TO_WORK_ITEM; only create dropped it.
+ *
+ * The derivation is asserted directly because that is the whole change: the map
+ * lookup plus the `?? "todo"` default. The default is what makes the fix safe
+ * regardless of whether the hook actually sends the field — correct if it does,
+ * byte-identical to the old behaviour if it does not.
+ */
+import { expect, test } from "bun:test";
+import { STATUS_TO_WORK_ITEM } from "./task-sync-projection.ts";
+
+type Status = "pending" | "in_progress" | "completed";
+const derive = (s: unknown) => STATUS_TO_WORK_ITEM[s as Status] ?? "todo";
+
+test("created completed -> done (the case that blocked the stop gate)", () => {
+	expect(derive("completed")).toBe("done");
+	expect(derive("completed") === "done").toBe(true);
+});
+
+test("created in_progress -> in-progress (DB enum uses the hyphen)", () => {
+	expect(derive("in_progress")).toBe("in-progress");
+});
+
+test("created pending -> todo", () => {
+	expect(derive("pending")).toBe("todo");
+});
+
+test("ABSENT status -> todo — the fix is inert when the hook omits the field", () => {
+	// This is the safety property. If the payload carries no status the lookup
+	// misses and the default reproduces the previous hardcoded behaviour exactly,
+	// so shipping this cannot regress any existing create path.
+	expect(derive(undefined)).toBe("todo");
+	expect(derive(null)).toBe("todo");
+});
+
+test("unknown status -> todo rather than throwing", () => {
+	// A CLI sending a status this platform does not model must degrade to open,
+	// never crash the hook — a task-sync throw takes the lane's whole list down.
+	expect(derive("archived")).toBe("todo");
+	expect(derive(42)).toBe("todo");
+});
+
+test("only the done mapping sets completed", () => {
+	// `completed` is a separate column from `status`; deriving it from the same
+	// value keeps the two from disagreeing (a done row with completed=false reads
+	// as open to every consumer that checks the boolean).
+	for (const s of ["pending", "in_progress"] as const) {
+		expect(derive(s) === "done").toBe(false);
+	}
+	expect(derive("completed") === "done").toBe(true);
+});

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

@@ -290,7 +290,7 @@ async function ensureLaneTask(
 }
 
 async function resolveLaneTask(prisma: Prisma, session: string): Promise<WorkItem | null> {
-	return prisma.work_items.findFirst({
+	const active = await prisma.work_items.findFirst({
 		where: {
 			kind: "task",
 			status: "active",
@@ -305,6 +305,31 @@ async function resolveLaneTask(prisma: Prisma, session: string): Promise<WorkIte
 		// unwritable; this makes the read stable regardless.
 		orderBy: { created_at: "asc" },
 	});
+	if (active) return active;
+
+	// FALL BACK TO AN ARCHIVED PARENT FOR THE SAME SESSION.
+	//
+	// Closing a run archives the lane's parent (close-run.ts) specifically to
+	// drop it from the active match set above. That is correct when the LANE is
+	// gone, and wrong whenever the run record closes while the lane keeps
+	// running — which happens on a tmux-server restart (runs are reaped, panes
+	// are restored) and whenever an orchestrator closes a run on a stale read.
+	// The lane then has a full task list that this function cannot see, so
+	// callers mint a FRESH parent, the old list is orphaned, and the compliance
+	// watchdog reports "working with NO task list" at a lane holding 85 tasks.
+	// That is the "KNOWN ADJACENT DEFECT" recorded on the lane-working-has-task-list
+	// guard row, observed live 2026-07-31.
+	//
+	// Safe because a session id is minted per lane spawn and never reused, so an
+	// archived parent under this session belongs to THIS lane. Newest-first.
+	return prisma.work_items.findFirst({
+		where: {
+			kind: "task",
+			status: "archived",
+			kind_data: { path: ["lane", "session"], equals: session },
+		},
+		orderBy: { created_at: "desc" },
+	});
 }
 
 /** Match key for a subtask: stable mark when the CLI provides one, else content, else title. Uses || (not ??) so an empty-string content (passed for existing rows that key by title) falls through. */
@@ -671,6 +696,8 @@ export const taskSyncRouter = {
 			task_subject?: unknown;
 			task_id?: unknown;
 			hook_event_name?: unknown;
+			// Created-already-done must not project OPEN. Absent -> old behaviour.
+			status?: unknown;
 		};
 		// TaskCompleted BEFORE the TaskCreated branch. Both dedicated events carry
 		// `task_subject`, so the subject-presence test below cannot tell them apart
@@ -727,6 +754,8 @@ export const taskSyncRouter = {
 			const task2 = await ensureLaneTask(prisma, session, headerPane);
 			if (!task2) return discardApplied("no-task-bound", session, { source: "TaskCreated" });
 			const createdId = String(createdEvt.task_id ?? "");
+			const createdStatus =
+				STATUS_TO_WORK_ITEM[createdEvt.status as TaskListItem["status"]] ?? "todo";
 			const existing = await prisma.work_items.findMany({ where: { parent_id: task2.id, kind: "subtask" } });
 			// IDEMPOTENT on the CLI's own task id. The hook curls with `--retry 2
 			// --retry-connrefused`, so one TaskCreate can arrive twice (observed
@@ -754,8 +783,8 @@ export const taskSyncRouter = {
 						parent_id: task2.id,
 						organisation_id: task2.organisation_id,
 						title: subject,
-						status: "todo",
-						completed: false,
+						status: createdStatus,
+						completed: createdStatus === "done",
 						position: String(existing.length),
 						kind_data: { task_sync: { mark: createdId || undefined, source: "claude-code" } },
 					},