@teamscala/service-boot 0.23.334 → 0.23.336

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

@@ -21,8 +21,8 @@
  * identity in kind_data.lane = { pane, session, cli_kind, role } so any surface
  * (fleet UI, another lane) can resolve "who owns this work" and push changes
  * back. Binding is by pane identity (the stable $TMUX_PANE), not by fleet run —
- * so it works before/without the fleet_agent_runs.work_item_id join (that column
- * is a UI convenience for the unified lane+task+subtask view, not a dependency).
+ * so it works without any second runtime-assignment join; the canonical runtime
+ * identity remains cli_sessions and the assignment remains work_items.
  *
  * These procedures are the ONLY CLI-agnostic surface an adapter calls:
  *   bindLane           — bind (create-or-confirm) a lane's task. SessionStart.
@@ -56,11 +56,13 @@ import {
 import * as v from "valibot";
 import {
 	STATUS_TO_WORK_ITEM,
+	deriveEvidenceProgress,
 	normalizeStatus,
 	resolveProjectedStatus,
 	subtaskKey,
 	resolveTaskUpdateTarget,
 	planReconcile,
+	type ProgressAcceptanceEvidence,
 	type ReconcilePlan,
 } from "./task-sync-projection.ts";
 
@@ -134,12 +136,16 @@ export type Prisma = {
 		update: (a: unknown) => Promise<WorkItem>;
 		deleteMany: (a: unknown) => Promise<{ count: number }>;
 	};
+	cli_sessions: {
+		findFirst: (a: unknown) => Promise<{ id: string; label?: string | null } | null>;
+	};
 	// `comments` is a universal shared model (owned by @teamgbg/db), so every
 	// service with the db client carries it. Declared here rather than
-	// feature-detected because, unlike fleet_agent_runs (fleet-service-only), it
-	// is part of the shared client every consumer installs.
+	// feature-detected only for clients generated before the shared comments model
+	// was deployed; current consumers install the universal comments surface.
 	comments?: {
 		findFirst: (a: unknown) => Promise<CommentRow | null>;
+		findMany: (a: unknown) => Promise<Array<ProgressAcceptanceEvidence>>;
 	};
 };
 
@@ -149,20 +155,6 @@ export interface CommentRow {
 	created_at: Date;
 }
 
-/**
- * A dispatched run already points at its fleet_tasks row. Task-sync may fill
- * the convenience join for an adopted lane, but must never replace that
- * dispatch identity with the lane's work_items projection id.
- */
-export function untrackedRunForPane(pane: string) {
-	return {
-		pane,
-		state: { not: "closed" },
-		tracked_task_id: null,
-	};
-}
-
-
 /**
  * Resolve the org a lane's task is created under. Explicit when the lane knows
  * its org (a dispatched fleet lane carries one); defaults to the platform org
@@ -215,35 +207,26 @@ export function discardApplied(
 }
 
 /**
- * The lane's human work name, read from its live fleet run (slot_name carries the
- * tmux window label per lanes-named-by-the-spawner). Returns null when no run
- * carries this pane yet — adoption and bind race at SessionStart, and a missing
- * name must not block the bind. Feature-detected like the run-link below, because
- * fleet_agent_runs lives only in the fleet service's schema.
+ * The lane's human work name is resolved by the assignment owner before binding.
+ * This router never reads a retired fleet-run row to derive task identity.
  */
 
 /**
- * Resolve a lane's CLI-native session id from its live run row by pane. Used by
- * the task-event handlers (upsertFromTaskHook) whose payloads lack session_id —
- * the run row's opencode_session_id IS the same CLI-native id the bind stamped
- * on kind_data.lane.session, so this recovers it for session-keyed matching.
- * Feature-detected (fleet_agent_runs lives only in the fleet service's schema).
+ * Resolve a lane's CLI-native session id from the canonical runtime row by pane.
+ * Task-event payloads may lack session_id, so the active cli_sessions row's
+ * host_route is the only valid recovery address.
  */
 async function resolveSessionFromPane(prisma: Prisma, pane: string): Promise<string | null> {
 	try {
-		const runs = (
-			prisma as unknown as {
-				fleet_agent_runs?: {
-					findFirst: (a: unknown) => Promise<{ opencode_session_id?: string | null } | null>;
-				};
-			}
-		).fleet_agent_runs;
-		if (!runs?.findFirst) return null;
-		const run = await runs.findFirst({
-			where: { pane, state: { not: "closed" } },
-			select: { opencode_session_id: true },
+		const session = await prisma.cli_sessions.findFirst({
+			where: {
+				closed_at: null,
+				lifecycle_state: { not: "closed" },
+				host_route: { path: ["pane_id"], equals: pane },
+			},
+			select: { id: true },
 		});
-		return run?.opencode_session_id ?? null;
+		return session?.id ?? null;
 	} catch {
 		return null;
 	}
@@ -446,8 +429,7 @@ export const taskSyncRouter = {
 	 * adapter so the lane has a durable task row before its first todo write.
 	 * Idempotent: re-binding updates the identity (role/cli_kind can change) but
 	 * never orphans existing subtasks. After binding, links the lane's
-	 * fleet_agent_runs row (matched by pane) to the task via tracked_task_id —
-	 * the join the operator's lane-labels monitor + the unified fleet view read.
+	 * cli_sessions is the runtime identity and work_items is the assignment.
 	 */
 	bindLane: authed.input(bindLaneInput).handler(async ({ input, context }) => {
 		const ctx = context as Context;
@@ -488,8 +470,9 @@ export const taskSyncRouter = {
 				message: "bindLane requires lane.session (the CLI's native session id)",
 			});
 		}
+		const lanePane = pane ?? "";
 		const lane: LaneIdentity = {
-			pane,
+			pane: lanePane,
 			session,
 			cli_kind: (raw.lane?.cli_kind ?? headerWorkKind ?? "claude-code") as LaneIdentity["cli_kind"],
 			role: raw.lane?.role ?? "agent",
@@ -509,7 +492,7 @@ export const taskSyncRouter = {
 		// 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;
+		const laneTitle = raw.title ?? (await resolveLaneWorkName(prisma, lanePane)) ?? null;
 		let taskId: string;
 		let created: boolean;
 		if (existing) {
@@ -626,51 +609,7 @@ export const taskSyncRouter = {
 				created = true;
 			}
 		}
-		// Link the fleet run carrying this pane to the bound task — sets
-		// fleet_agent_runs.tracked_task_id. Best-effort by design: fleet_agent_runs
-		// is only in the fleet service's schema, so feature-detect the model; and a
-		// run not yet carrying its pane (adoption race at SessionStart — adoption
-		// fires first, but its pane resolve can come up empty on a tmux hiccup) is
-		// simply not matched, converging on re-bind / next adoption. The work_items
-		// task is the source of truth; this column is the UI convenience join.
-		try {
-			const runs = (
-				prisma as unknown as {
-					fleet_agent_runs?: {
-						updateMany: (a: unknown) => Promise<{ count: number }>;
-					};
-				}
-			).fleet_agent_runs;
-			if (runs?.updateMany) {
-				// STEAL before CLAIM. A task is tracked by at most one LIVE run — the
-				// partial unique index fleet_agent_runs_one_active_run_per_task
-				// (UNIQUE(tracked_task_id) WHERE state IN active/committing/waiting)
-				// enforces it. Assigning tracked_task_id without first releasing it
-				// from any OTHER run holding it leaves two runs sharing the task, and
-				// the next state→active transition on either one (upsertLaneRun's
-				// UPDATE) violates the index → P2002 → the lane-event 500s and the
-				// run-link join is lost. The common trigger is re-adoption: a lane
-				// moves to a new pane, bindLane claims the task for the new run while
-				// the OLD pane's run still holds it. A task is session-scoped, so every
-				// run holding this taskId is this lane's own (or a stale duplicate) —
-				// releasing from all non-closed runs is correct, then only this lane's
-				// untracked run re-claims it.
-				await runs.updateMany({
-					where: { tracked_task_id: taskId, state: { not: "closed" } },
-					data: { tracked_task_id: null },
-				});
-				await runs.updateMany({
-					where: untrackedRunForPane(pane),
-					data: { tracked_task_id: taskId },
-				});
-			}
-		} catch (err) {
-			log.warn("[task-sync] bindLane: run-link by pane failed", {
-				pane,
-				taskId,
-				error: err instanceof Error ? err.message : String(err),
-			});
-		}
+		// Runtime identity is owned by cli_sessions; task binding must not mutate a retired run row.
 		return { task_id: taskId, created };
 	}),
 
@@ -691,10 +630,9 @@ export const taskSyncRouter = {
 			const { ORPCError } = await import("@orpc/server");
 			throw new ORPCError("BAD_REQUEST", { message: "upsertFromTaskList requires lane_session" });
 		}
-		// The pane rides in the header the callers already send (`x-lane-pane`),
-		// and it is what lets the on-demand bind link the new task to the lane's
-		// run. Absent, the bind still succeeds — it just cannot link the run — so
-		// this is passed opportunistically rather than required.
+		// The pane rides in the header the callers already send (`x-lane-pane`)
+		// for canonical cli_sessions routing. Absent, task binding still uses the
+		// native lane session id.
 		const headerPane = (context as Context).headers?.get("x-lane-pane") ?? null;
 		try {
 			const res = await reconcileTaskList(prisma, session, list, body.source, headerPane);
@@ -752,17 +690,38 @@ export const taskSyncRouter = {
 			throw new ORPCError("BAD_REQUEST", { message: "readTaskList requires lane_session" });
 		}
 		const task = await resolveLaneTask(prisma, session);
-		if (!task) return { task_id: null, task_title: null, subtasks: [] };
+		if (!task) {
+			return {
+				task_id: null,
+				task_title: null,
+				subtasks: [],
+				progress: { total: 0, accepted: 0, percentage: 0 },
+			};
+		}
 		const rows = await prisma.work_items.findMany({
 			where: { parent_id: task.id, kind: "subtask" },
 		});
 		rows.sort((a, b) => (a.position ?? "").localeCompare(b.position ?? "", undefined, { numeric: true }));
+		const evidence = prisma.comments
+			? await prisma.comments.findMany({
+					where: {
+						work_item_id: { in: rows.map((row) => row.id) },
+						sender_role: "orchestrator",
+					},
+					select: { work_item_id: true, sender_role: true, system_key: true },
+				})
+			: [];
 		const subtasks: TaskListItem[] = rows.map((r) => ({
 			content: r.title,
 			status: normalizeStatus(r.status),
 			mark: (r.kind_data?.task_sync as { mark?: string } | undefined)?.mark,
 		}));
-		return { task_id: task.id, task_title: task.title, subtasks };
+		return {
+			task_id: task.id,
+			task_title: task.title,
+			subtasks,
+			progress: deriveEvidenceProgress(rows, evidence),
+		};
 	}),
 
 	/**
@@ -801,11 +760,9 @@ export const taskSyncRouter = {
 	 * there the lane is the originator (no self-echo); here the lane is the
 	 * recipient.
 	 *
-	 * COMPLETION STEP (not MVP): this procedure is the explicit trigger. For
-	 * FULL coverage — every work_items subtask write, including the projects
-	 * UI's generated CRUD — a Postgres trigger + LISTEN subscriber on
-	 * scala-channel fires the same publish, so an operator edit reaches the
-	 * lane with no explicit call. Tracked in apps/agent-fleet.md task-sync.
+	 * Every call writes the canonical task-change comment for the active
+	 * cli_sessions row; the database comment emission is the delivery trigger.
+	 * There is no pane transport or secondary channel publisher here.
 	 */
 	applyExternalChange: authed.handler(async ({ input, context }) => {
 		const body = input as { task_id: string; subtask_id?: string; status?: TaskListItem["status"] };
@@ -823,17 +780,19 @@ export const taskSyncRouter = {
 			});
 		}
 		const task = await prisma.work_items.findFirst({ where: { id: task_id } });
-		const lanePane = (task?.kind_data?.lane as { pane?: string } | undefined)?.pane;
-		// Fire-and-forget: a dispatch failure must never block the work_items write.
-		if (lanePane) {
-			notifyLaneOfTaskChange(lanePane, task_id).catch((err) => {
-				log.warn("[task-sync] applyExternalChange: lane notify failed", {
-					taskId: task_id,
-					error: err instanceof Error ? err.message : String(err),
-				});
-			});
-		}
-		return { task_id, lane_pane: lanePane ?? null, notified: !!lanePane };
+		const dispatch = task
+			? await notifyLaneOfTaskChange(
+				prisma as unknown as Parameters<typeof notifyLaneOfTaskChange>[0],
+				task_id,
+				`${subtask_id ?? "task"}:${status ?? "refresh"}`,
+			)
+			: { delivered: false, sessionId: null, commentId: null };
+		log.info("[task-sync] applyExternalChange: durable comment emission", {
+			taskId: task_id,
+			sessionId: dispatch.sessionId,
+			delivered: dispatch.delivered,
+		});
+		return { task_id, cli_session_id: dispatch.sessionId, comment_id: dispatch.commentId, notified: dispatch.delivered };
 	}),
 };
 
@@ -871,9 +830,8 @@ export async function upsertFromTaskHookHandler(input: unknown, context: Context
 	// TaskCreated/TaskCompleted event payloads do NOT carry session_id (only
 	// SessionStart does), so the task hooks cannot populate x-lane-session —
 	// the extraction in the hook command yields an empty string. Resolve the
-	// session from the lane's run row by pane instead: the bind (at
-	// session_start) already stamped kind_data.lane.session, and the run row's
-	// opencode_session_id is the same CLI-native id. This keeps matching
+	// session from the canonical cli_sessions row by pane instead: the bind (at
+	// session_start) already stamped kind_data.lane.session. This keeps matching
 	// session-keyed (resolveLaneTask still filters kind_data.lane.session)
 	// without requiring every task-event payload to carry the session id.
 	const session = headerSession || (headerPane ? await resolveSessionFromPane(prisma, headerPane) : null);

package/src/handlers/sweep-host-cache.d.ts

@@ -1 +1,21 @@
-export {};
+/**
+ * Expand a path pattern containing single-segment `*` wildcards into concrete
+ * paths (files or dirs). Used by `retention_dirs` so a single config key like
+* a pattern like `${WORKSPACE}/<star>/target` reaches every repo's target dir.
+* Sync + bounded: the
+ * pattern is shallow (3 segments), and this runs once
+ * nightly. Non-existent segments yield no matches (the caller stats each result).
+ */
+export declare function expandGlob(pattern: string): string[];
+/**
+ * Is `dir` stale — i.e. NO file under it is newer than `cutoffMs`? Walks
+ * recursively and SHORT-CIRCUITS the instant it finds a fresh file (so an
+ * actively-built target dir returns fast without walking its full tree). On a
+ * stale dir the walk is complete and returns the total size + file count, so
+ * the caller can report bytes-freed before deleting the dir whole.
+ */
+export declare function checkDirStale(dir: string, cutoffMs: number): Promise<{
+    stale: boolean;
+    bytes: number;
+    fileCount: number;
+}>;

package/src/handlers/sweep-host-cache.test.ts

@@ -0,0 +1,85 @@
+/**
+ * @system server-boot
+ * @status handwritten
+ * @edit edit directly
+ *
+ * Unit tests for the `retention_dirs` helpers (`expandGlob`, `checkDirStale`) —
+ * the whole-directory prune that bounds Rust `target/` waste. The file-by-mtime
+ * `retention` path is unchanged; these cover ONLY the new build-cache model:
+ * (1) glob expansion reaches every repo's target dir; (2) an actively-built dir
+ * is kept (short-circuits on a fresh file); (3) an abandoned dir is reported
+ * stale with its full size. Lives next to the handler per co-located-test rule.
+ */
+import { describe, expect, test, beforeEach, afterEach } from "bun:test";
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync, utimesSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { expandGlob, checkDirStale } from "./sweep-host-cache.ts";
+
+const DAY = 86_400_000;
+const now = Date.now();
+const daysAgo = (n: number) => new Date(now - n * DAY);
+const touch = (p: string, t: Date) => utimesSync(p, t, t);
+
+let root: string;
+beforeEach(() => {
+	root = mkdtempSync(join(tmpdir(), "sweep-"));
+});
+afterEach(() => {
+	rmSync(root, { recursive: true, force: true });
+});
+
+describe("expandGlob", () => {
+	test("expands a single-segment wildcard to concrete dirs", () => {
+		mkdirSync(join(root, "scala-rust", "target"), { recursive: true });
+		mkdirSync(join(root, "scala-os", "target"), { recursive: true });
+		mkdirSync(join(root, "scala-os", "src"), { recursive: true });
+		const matches = expandGlob(`${root}/*/target`).sort();
+		expect(matches).toEqual(
+			[join(root, "scala-os", "target"), join(root, "scala-rust", "target")].sort(),
+		);
+	});
+	test("literal segment matches only itself", () => {
+		mkdirSync(join(root, "scala-rust", "target"), { recursive: true });
+		mkdirSync(join(root, "other", "target"), { recursive: true });
+		const matches = expandGlob(`${root}/scala-rust/target`);
+		expect(matches).toEqual([join(root, "scala-rust", "target")]);
+	});
+	test("no matches when the wildcard segment has no children", () => {
+		const matches = expandGlob(`${root}/does-not-exist/*/target`);
+		expect(matches).toEqual([]);
+	});
+});
+
+describe("checkDirStale", () => {
+	test("stale dir: all files older than cutoff → stale + full size", async () => {
+		const dir = join(root, "target");
+		mkdirSync(join(dir, "debug", "deps"), { recursive: true });
+		writeFileSync(join(dir, "debug", "deps", "a.o"), "x".repeat(40));
+		writeFileSync(join(dir, "debug", "deps", "b.o"), "y".repeat(60));
+		touch(join(dir, "debug", "deps", "a.o"), daysAgo(40));
+		touch(join(dir, "debug", "deps", "b.o"), daysAgo(35));
+		const res = await checkDirStale(dir, now - 30 * DAY);
+		expect(res.stale).toBe(true);
+		expect(res.fileCount).toBe(2);
+		expect(res.bytes).toBe(100);
+	});
+	test("active dir: a file newer than cutoff → not stale (short-circuit)", async () => {
+		const dir = join(root, "target");
+		mkdirSync(join(dir, "debug"), { recursive: true });
+		writeFileSync(join(dir, "debug", "old.o"), "x".repeat(40));
+		touch(join(dir, "debug", "old.o"), daysAgo(40));
+		writeFileSync(join(dir, "debug", "fresh.o"), "y".repeat(60));
+		touch(join(dir, "debug", "fresh.o"), daysAgo(1));
+		const res = await checkDirStale(dir, now - 30 * DAY);
+		expect(res.stale).toBe(false);
+	});
+	test("empty dir → stale with zero bytes", async () => {
+		const dir = join(root, "target");
+		mkdirSync(dir, { recursive: true });
+		const res = await checkDirStale(dir, now - 30 * DAY);
+		expect(res.stale).toBe(true);
+		expect(res.bytes).toBe(0);
+		expect(res.fileCount).toBe(0);
+	});
+});

package/src/handlers/sweep-host-cache.ts

@@ -16,8 +16,14 @@
  * Path convention (config.retention keys, substituted at runtime via `userHome()`
  * / `workspaceRoot()` per `host-literals-via-substitution` — source never
  * hardcodes host paths):
- *   "${HOME}/.bun/install/cache"          → "30 days"
- *   "${HOME}/.config/*.retired-*"         → "14 days"  (glob leaf, optional)
+*   "${HOME}/.bun/install/cache"          → "30 days"
+*   "${HOME}/.config/*.retired-*"         → "14 days"  (glob leaf, optional)
+*
+* config.retention_dirs — whole-DIRECTORY prune for build caches (Rust
+* `target/`) whose unit is the dir, not the file (file-by-mtime would corrupt
+* the cache). Keys support `*` globs; a matched dir is deleted ENTIRELY only
+* when its newest file is older than the cutoff:
+*   "${WORKSPACE}/<repo>/target"         → "30 days"  (glob wildcard, whole-dir delete)
  *
  * Deletion runs through Bun fs APIs — pure filesystem deletion needs no shell,
  * so `spawn-is-the-only-spawn` does not apply (that governs shell commands).
@@ -34,7 +40,7 @@
  * Registered under slug `@teamscala/service-boot:sweep-host-cache`.
  */
 import { rm, readdir, stat } from "node:fs/promises";
-import type { Dirent } from "node:fs";
+import { readdirSync, type Dirent } from "node:fs";
 import { join } from "node:path";
 import { spawnSync } from "@teamscala/os/spawn/spawn";
 import { userHome, workspaceRoot } from "@teamscala/os/host-paths";
@@ -117,11 +123,89 @@ async function sweepPath(
 	return { path: rootDir, scanned, deleted, bytesFreed };
 }
 
+/**
+ * Expand a path pattern containing single-segment `*` wildcards into concrete
+ * paths (files or dirs). Used by `retention_dirs` so a single config key like
+* a pattern like `${WORKSPACE}/<star>/target` reaches every repo's target dir.
+* Sync + bounded: the
+ * pattern is shallow (3 segments), and this runs once
+ * nightly. Non-existent segments yield no matches (the caller stats each result).
+ */
+export function expandGlob(pattern: string): string[] {
+	const absolute = pattern.startsWith("/");
+	const segments = (absolute ? pattern.slice(1) : pattern)
+		.split("/")
+		.filter((s) => s.length > 0);
+	let current: string[] = [absolute ? "/" : "."];
+	for (const seg of segments) {
+		if (current.length === 0) break;
+		const next: string[] = [];
+		for (const dir of current) {
+			let names: string[];
+			try {
+				names = readdirSync(dir);
+			} catch {
+				continue;
+			}
+			for (const name of names) {
+				if (seg === "*" || seg === name) next.push(join(dir, name));
+			}
+		}
+		current = next;
+	}
+	return current;
+}
+
+/**
+ * Is `dir` stale — i.e. NO file under it is newer than `cutoffMs`? Walks
+ * recursively and SHORT-CIRCUITS the instant it finds a fresh file (so an
+ * actively-built target dir returns fast without walking its full tree). On a
+ * stale dir the walk is complete and returns the total size + file count, so
+ * the caller can report bytes-freed before deleting the dir whole.
+ */
+export async function checkDirStale(
+	dir: string,
+	cutoffMs: number,
+): Promise<{ stale: boolean; bytes: number; fileCount: number }> {
+	const stack: string[] = [dir];
+	let bytes = 0;
+	let fileCount = 0;
+	while (stack.length > 0) {
+		const d = stack.pop();
+		if (d === undefined) break;
+		let entries: Dirent[];
+		try {
+			entries = await readdir(d, { withFileTypes: true });
+		} catch {
+			continue;
+		}
+		for (const entry of entries) {
+			const full = join(d, entry.name);
+			if (entry.isDirectory()) {
+				stack.push(full);
+			} else if (entry.isFile()) {
+				try {
+					const st = await stat(full);
+					if (st.mtimeMs >= cutoffMs) {
+						return { stale: false, bytes: 0, fileCount: 0 };
+					}
+					bytes += st.size;
+					fileCount++;
+				} catch {
+					// vanished/unreadable — skip
+				}
+			}
+		}
+	}
+	return { stale: true, bytes, fileCount };
+}
+
 async function sweepHostCache(ctx: {
-	config: { retention?: Record<string, string> };
+	config: { retention?: Record<string, string>; retention_dirs?: Record<string, string> };
 }): Promise<void> {
 	const log = getAppLogger();
 	const retention = ctx.config.retention ?? {};
+	const retentionDirs = ctx.config.retention_dirs ?? {};
 	const now = Date.now();
 	const results: SweepResult[] = [];
 
@@ -154,6 +238,36 @@ async function sweepHostCache(ctx: {
 		);
 	}
 
+	// retention_dirs — whole-directory prune for build caches (Rust target/).
+	// A matched dir is deleted ENTIRELY only when its newest file is older than
+	// the cutoff, so an actively-built repo keeps its cache and an abandoned one
+	// is reclaimed whole (never the partial slice that would corrupt the cache).
+	for (const [rawPattern, rawDuration] of Object.entries(retentionDirs)) {
+		const days = parseDays(rawDuration);
+		if (days === null || days <= 0) {
+			log.warn(
+				`[host-cache-sweep] skipping retention_dirs "${rawPattern}" — value "${rawDuration}" is not a day-granularity duration (expected e.g. "30 days")`,
+			);
+			continue;
+		}
+		const cutoffMs = now - days * MS_PER_DAY;
+		for (const dir of expandGlob(resolveHostPath(rawPattern))) {
+			try {
+				const st = await stat(dir);
+				if (!st.isDirectory()) continue;
+			} catch {
+				continue; // glob match that is not a dir (or vanished) — skip
+			}
+			const { stale, bytes, fileCount } = await checkDirStale(dir, cutoffMs);
+			if (!stale) continue;
+			await rm(dir, { recursive: true, force: true });
+			results.push({ path: dir, scanned: fileCount, deleted: fileCount, bytesFreed: bytes });
+			log.info(
+				`[host-cache-sweep] ${dir}: no build in ${rawDuration}; reclaimed whole dir — ${fileCount} file(s), ${formatBytes(bytes)}`,
+			);
+		}
+	}
+
 	const totalDeleted = results.reduce((sum, r) => sum + r.deleted, 0);
 	const totalBytes = results.reduce((sum, r) => sum + r.bytesFreed, 0);
 	log.info(

package/src/mount-orpc-router.ts

@@ -37,7 +37,7 @@ export async function mountOrpcRouter(
 	);
 
 	// No generated ORPC router is the EXPECTED state for daemon-only / boot-hook
-	// services (session-picker, package-poller, etc.) that own no DB schema or
+	// services (session-picker, dep-sync, etc.) that own no DB schema or
 	// api_routes — they serve no /api/rpc surface. Skip silently: importing a
 	// nonexistent module would throw into the catch below and surface a
 	// misleading "ORPC router not mounted" WARN on every boot. The catch is

package/src/resolve-brand-favicon.d.ts

@@ -21,7 +21,7 @@ export declare function resolveBrandFaviconPath(brandOrg: string | undefined): P
  * pays the S3 existence-probe latency. The probe (`handleAssetProxy` →
  * `s3.file(key).stat()`) is a COLD S3 call — the connection setup to the asset
  * store takes 6s locally / up to 21s in prod, and the in-process cache resets
- * on every restart (deploys, package-poller). Without warming, the first
+ * on every restart (deploys, dep-sync). Without warming, the first
  * /favicon.ico after each restart stalls for that duration (operator-reported
  * 23s). Fire-and-forget — runs in the background during boot, never blocks.
  */

package/src/resolve-brand-favicon.ts

@@ -55,7 +55,7 @@ export async function resolveBrandFaviconPath(
  * pays the S3 existence-probe latency. The probe (`handleAssetProxy` →
  * `s3.file(key).stat()`) is a COLD S3 call — the connection setup to the asset
  * store takes 6s locally / up to 21s in prod, and the in-process cache resets
- * on every restart (deploys, package-poller). Without warming, the first
+ * on every restart (deploys, dep-sync). Without warming, the first
  * /favicon.ico after each restart stalls for that duration (operator-reported
  * 23s). Fire-and-forget — runs in the background during boot, never blocks.
  */