@teamscala/service-boot 0.23.294 → 0.23.296

package/package.json

@@ -6,7 +6,7 @@
   },
   "name": "@teamscala/service-boot",
   "type": "module",
-  "version": "0.23.294",
+  "version": "0.23.296",
   "sideEffects": false,
   "files": [
     "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" } },
 					},

package/src/register-static-assets.ts

@@ -14,6 +14,8 @@ import { join } from "node:path";
 import type { Hono } from "hono";
 import { etag } from "hono/etag";
 import { buildErrorReport } from "@teamscala/os/errors/error-report";
+import { collectHeapReport } from "@teamscala/os/observability/heap-report";
+import { isLoopbackHost } from "@teamscala/os/observability/loopback-host";
 import { handleAssetProxy } from "./asset-proxy";
 import { resolveBrandFaviconPath, warmBrandFaviconCache } from "./resolve-brand-favicon";
 
@@ -37,41 +39,20 @@ export async function registerStaticAssets(
 		}),
 	);
 
-	// Localhost-gated heap-attribution probe — restores the object-composition
-	// data the removed /_healthz surface exposed: the heapSize-vs-RSS split
-	// (JS heap vs native — OTel/Prisma-engine/buffers/compiled code) plus the
-	// top object types by count. Read-only, no secrets; gated to a localhost
-	// Host so it never answers over the public domain. Registered here (before
-	// auth + page routes) so it is reachable on every service kind, like
-	// /health (`verify-via-127.0.0.1`, sibling of `runtime-metrics-via-railway-cli`).
+	// Localhost-gated heap-attribution probe — the heapSize-vs-RSS split (JS heap
+	// vs native: OTel/Prisma-engine/buffers/compiled code) plus the top object
+	// types by count. Read-only, no secrets; gated to a localhost Host so it never
+	// answers over the public domain. Registered here (before auth + page routes)
+	// so it is reachable on every service kind, like /health
+	// (`verify-via-127.0.0.1`, sibling of `runtime-metrics-via-railway-cli`).
+	//
+	// The payload shape lives in @teamscala/os so standalone `Bun.serve` daemons
+	// (scala-guard) answer this probe identically — `scala-tools heap <slug>` must
+	// not mean different things depending on which process replied.
 	app.get("/_heap", async (c) => {
-		const host = c.req.header("host") ?? "";
-		const isLocal =
-			host.startsWith("127.0.0.1") || host.startsWith("localhost") || host.startsWith("[::1]");
-		if (!isLocal) return c.json({ error: "localhost only" }, 403);
+		if (!isLoopbackHost(c.req.header("host"))) return c.json({ error: "localhost only" }, 403);
 		try {
-			const { heapStats } = await import("bun:jsc");
-			const s = heapStats() as unknown as {
-				heapSize: number;
-				heapCapacity: number;
-				objectCount: number;
-				objectTypeCounts?: Record<string, number>;
-			};
-			const rss = process.memoryUsage.rss();
-			const topObjectTypes = Object.fromEntries(
-				Object.entries(s.objectTypeCounts ?? {})
-					.sort((a, b) => b[1] - a[1])
-					.slice(0, 40),
-			);
-			return c.json({
-				service: serviceSlug,
-				rss,
-				heapSize: s.heapSize,
-				heapCapacity: s.heapCapacity,
-				objectCount: s.objectCount,
-				nativeApprox: Math.max(0, rss - s.heapSize),
-				topObjectTypes,
-			});
+			return c.json(await collectHeapReport(serviceSlug));
 		} catch (err) {
 			const report = buildErrorReport(err, { service: serviceSlug, url: c.req.url });
 			return new Response(JSON.stringify(report.http.body), {