@teamscala/service-boot 0.23.284

package/src/handlers/bun-stable-watch.ts

@@ -0,0 +1,89 @@
+/**
+ * @system server-boot
+ * @status handwritten
+ * @edit edit directly
+ *
+ * The `bun-stable-watch` pg-boss handler — the durable trigger for the
+ * bun-1.4 lock-resolution escape hatch's atomic flip-back (open-migration
+ * `bun-14-lock-resolution-pin`). Polls the public npm `bun` `latest`
+ * dist-tag once daily; when a STABLE 1.4.x (≥1.4.0, no prerelease) ships,
+ * records a detection event so the escape hatch can be retired via the atomic
+ * flip-back: `config/scala-tools-deps.lockResolutionBun` → "bun" + the ~18
+ * `railpack_config` rows → 1.4.0 stable + delete the pinned
+ * `/usr/local/bin/bun-1.3.14` binary + a green deploy (all one change). The
+ * flip-back itself is a deliberate action, not auto-fired — it mutates config
+ * + railpack + a binary + a deploy.
+ *
+ * `bun/latest` returns the stable release (canaries live under the `canary`
+ * dist-tag, not `latest`), so a non-prerelease version ≥1.4.0 means stable
+ * shipped. A daily `bun.watch.tick` liveness event lets a watchdog detect a
+ * silently-stopped watch (the same shape as `sweep.completed`).
+ *
+ * Registered under slug `@teamscala/service-boot:bun-stable-watch`.
+ */
+import type { ScheduledJobConfig } from "@teamscala/db-validation/registry-schemas/scheduled-job";
+import { recordEvent } from "@teamscala/event-log/record-event";
+import { getAppLogger } from "@teamscala/logger/app-loggers";
+import { pgBossHandlerRegistry } from "../pg-boss-handler-registry.ts";
+
+const BUN_NPM_LATEST = "https://registry.npmjs.org/bun/latest";
+const TARGET_STABLE = "1.4.0"; // flip back when a stable at or above this ships
+
+interface BunLatestManifest {
+	version: string;
+}
+
+function parseSemver(
+	v: string,
+): { major: number; minor: number; patch: number; prerelease: string } | null {
+	const m = /^(\d+)\.(\d+)\.(\d+)(?:-(.+))?$/.exec(v.trim());
+	if (!m) return null;
+	return { major: Number(m[1]), minor: Number(m[2]), patch: Number(m[3]), prerelease: m[4] ?? "" };
+}
+
+/** A stable (non-prerelease) release at or above the target version. */
+function isStableAtOrAbove(version: string, target: string): boolean {
+	const v = parseSemver(version);
+	const t = parseSemver(target);
+	if (!v || !t) return false;
+	if (v.prerelease) return false; // canary/beta/rc are not stable
+	if (v.major !== t.major) return v.major > t.major;
+	if (v.minor !== t.minor) return v.minor > t.minor;
+	return v.patch >= t.patch;
+}
+
+async function bunStableWatch(_ctx: { config: ScheduledJobConfig }): Promise<void> {
+	const log = getAppLogger();
+	let manifest: BunLatestManifest;
+	try {
+		const res = await fetch(BUN_NPM_LATEST, { headers: { accept: "application/json" } });
+		if (!res.ok) throw new Error(`npm bun/latest HTTP ${res.status}`);
+		manifest = (await res.json()) as BunLatestManifest;
+	} catch (err) {
+		log.warn(`[bun-stable-watch] failed to fetch npm bun/latest: ${err}`);
+		return;
+	}
+	if (isStableAtOrAbove(manifest.version, TARGET_STABLE)) {
+		log.warn(
+			`[bun-stable-watch] Bun stable ${manifest.version} (>=${TARGET_STABLE}) shipped — escape hatch 'bun-14-lock-resolution-pin' is ready to retire. Run the atomic flip-back: config/scala-tools-deps.lockResolutionBun -> "bun" + railpack_config rows -> 1.4.0 stable + delete /usr/local/bin/bun-1.3.14 + a green deploy.`,
+		);
+		recordEvent({
+			kind: "bun.stable.shipped",
+			payload: {
+				latest: manifest.version,
+				targetStable: TARGET_STABLE,
+				note: "escape hatch bun-14-lock-resolution-pin ready to retire; verify railpack 1.4.0 support then run the atomic flip-back",
+			},
+		});
+		return;
+	}
+	log.info(
+		`[bun-stable-watch] npm bun/latest = ${manifest.version} — not yet stable ${TARGET_STABLE}; escape hatch remains`,
+	);
+	recordEvent({
+		kind: "bun.watch.tick",
+		payload: { latest: manifest.version, targetStable: TARGET_STABLE },
+	});
+}
+
+pgBossHandlerRegistry.register("@teamscala/service-boot:bun-stable-watch", bunStableWatch);

package/src/handlers/projects-digest.ts

@@ -0,0 +1,198 @@
+/**
+ * @system server-boot
+ * @status handwritten
+ * @edit edit directly
+ *
+ * The `projects-daily-digest` / `projects-weekly-digest` pg-boss handlers for
+ * scala-projects. Same fixed-query shape as prune-stale-data: no row-driven
+ * SQL, every query is a literal Prisma call against work_items; the
+ * scheduled_job row only carries the cron.
+ *
+ * Daily digest: per assignee, tasks assigned to them created in the last 24h.
+ * Weekly digest: per assignee, their overdue tasks + tasks due in the next 7
+ * days. Both group work_items by assignee_id so one org-wide query covers
+ * every member, then send one email per assignee via the
+ * projects-daily-digest / projects-weekly-digest email_template rows.
+ *
+ * Registered under `@teamscala/service-boot:projects-daily-digest` and
+ * `@teamscala/service-boot:projects-weekly-digest`.
+ */
+import type { ScheduledJobConfig } from "@teamscala/db-validation/registry-schemas/scheduled-job";
+import { escapeHtml } from "@teamscala/formatters/escapeHtml";
+import { getPrisma } from "@teamscala/db/prisma-registry";
+import { createEmailClient } from "@teamscala/email-client/client";
+import { getAppLogger } from "@teamscala/logger/app-loggers";
+import { pgBossHandlerRegistry } from "../pg-boss-handler-registry.ts";
+import { resolveAppBaseUrl } from "../resolve-app-base-url.ts";
+
+const emailClient = createEmailClient();
+
+interface DigestTask {
+	id: string;
+	title: string;
+	organisation_id: string;
+	assignee_id: string | null;
+}
+
+type PrismaClient = ReturnType<typeof getPrisma>;
+
+function taskLink(appUrl: string, task: DigestTask): string {
+	return `${appUrl}/${task.organisation_id}?panel=task-comments&comment=${task.id}`;
+}
+
+function renderListHtml(tasks: DigestTask[], appUrl: string): string {
+	if (tasks.length === 0) return "<p><em>None</em></p>";
+	const items = tasks.map((t) => `<li><a href="${taskLink(appUrl, t)}">${escapeHtml(t.title)}</a></li>`).join("");
+	return `<ul>${items}</ul>`;
+}
+
+function renderListText(tasks: DigestTask[]): string {
+	if (tasks.length === 0) return "None";
+	return tasks.map((t) => `- ${t.title}`).join("\n");
+}
+
+function groupByAssignee(tasks: DigestTask[]): Map<string, DigestTask[]> {
+	const map = new Map<string, DigestTask[]>();
+	for (const t of tasks) {
+		if (!t.assignee_id) continue;
+		const list = map.get(t.assignee_id) ?? [];
+		list.push(t);
+		map.set(t.assignee_id, list);
+	}
+	return map;
+}
+
+async function loadOrgNames(prisma: PrismaClient, orgIds: string[]): Promise<Map<string, string>> {
+	if (orgIds.length === 0) return new Map();
+	const rows = await prisma.organisation_profile.findMany({
+		where: { id: { in: orgIds } },
+		select: { id: true, company_name: true },
+	});
+	return new Map(rows.map((r: { id: string; company_name: string | null }) => [r.id, r.company_name || "your organisation"]));
+}
+
+async function loadUsers(
+	prisma: PrismaClient,
+	userIds: string[],
+): Promise<Map<string, { email: string; name: string }>> {
+	if (userIds.length === 0) return new Map();
+	const rows = await prisma.user.findMany({
+		where: { id: { in: userIds } },
+		select: { id: true, email: true, name: true },
+	});
+	return new Map(rows.map((r: { id: string; email: string; name: string }) => [r.id, { email: r.email, name: r.name }]));
+}
+
+export async function sendDailyDigest(_ctx: { config: ScheduledJobConfig }): Promise<void> {
+	const log = getAppLogger();
+	const prisma = getPrisma();
+	const since = new Date(Date.now() - 24 * 60 * 60 * 1000);
+	const tasks = (await prisma.work_items.findMany({
+		where: { kind: "task", created_at: { gte: since }, assignee_id: { not: null } },
+		select: { id: true, title: true, organisation_id: true, assignee_id: true },
+	})) as DigestTask[];
+
+	const byAssignee = groupByAssignee(tasks);
+	if (byAssignee.size === 0) {
+		log.info("[projects-daily-digest] no new tasks in the last 24h — nothing to send");
+		return;
+	}
+
+	const orgNames = await loadOrgNames(prisma, [...new Set(tasks.map((t) => t.organisation_id))]);
+	const users = await loadUsers(prisma, [...byAssignee.keys()]);
+	const appUrl = await resolveAppBaseUrl();
+
+	let sent = 0;
+	for (const [userId, userTasks] of byAssignee) {
+		const user = users.get(userId);
+		if (!user?.email) continue;
+		const orgId = userTasks[0]!.organisation_id;
+		try {
+			const result = await emailClient.send({
+				to: user.email,
+				template: "projects-daily-digest",
+				vars: {
+					recipient_name: user.name || user.email,
+					org_name: orgNames.get(orgId) ?? "your organisation",
+					new_task_count: String(userTasks.length),
+					task_list_html: renderListHtml(userTasks, appUrl),
+					task_list_text: renderListText(userTasks),
+					app_url: `${appUrl}/${orgId}`,
+				},
+			});
+			if (result.status !== "failed") sent++;
+		} catch (err) {
+			log.error("[projects-daily-digest] send failed", { userId, error: err instanceof Error ? err.message : String(err) });
+		}
+	}
+	log.info(`[projects-daily-digest] complete — ${sent}/${byAssignee.size} digest(s) sent`);
+}
+
+export async function sendWeeklyDigest(_ctx: { config: ScheduledJobConfig }): Promise<void> {
+	const log = getAppLogger();
+	const prisma = getPrisma();
+	const now = new Date();
+	const weekAhead = new Date(now.getTime() + 7 * 24 * 60 * 60 * 1000);
+
+	const [overdue, upcoming] = await Promise.all([
+		prisma.work_items.findMany({
+			where: { kind: "task", completed: { not: true }, assignee_id: { not: null }, due_date: { lt: now } },
+			select: { id: true, title: true, organisation_id: true, assignee_id: true },
+		}) as Promise<DigestTask[]>,
+		prisma.work_items.findMany({
+			where: {
+				kind: "task",
+				completed: { not: true },
+				assignee_id: { not: null },
+				due_date: { gte: now, lte: weekAhead },
+			},
+			select: { id: true, title: true, organisation_id: true, assignee_id: true },
+		}) as Promise<DigestTask[]>,
+	]);
+
+	const overdueByAssignee = groupByAssignee(overdue);
+	const upcomingByAssignee = groupByAssignee(upcoming);
+	const assigneeIds = new Set([...overdueByAssignee.keys(), ...upcomingByAssignee.keys()]);
+	if (assigneeIds.size === 0) {
+		log.info("[projects-weekly-digest] nothing overdue or due this week — nothing to send");
+		return;
+	}
+
+	const allTasks = [...overdue, ...upcoming];
+	const orgNames = await loadOrgNames(prisma, [...new Set(allTasks.map((t) => t.organisation_id))]);
+	const users = await loadUsers(prisma, [...assigneeIds]);
+	const appUrl = await resolveAppBaseUrl();
+
+	let sent = 0;
+	for (const userId of assigneeIds) {
+		const user = users.get(userId);
+		if (!user?.email) continue;
+		const userOverdue = overdueByAssignee.get(userId) ?? [];
+		const userUpcoming = upcomingByAssignee.get(userId) ?? [];
+		const orgId = (userOverdue[0] ?? userUpcoming[0])!.organisation_id;
+		try {
+			const result = await emailClient.send({
+				to: user.email,
+				template: "projects-weekly-digest",
+				vars: {
+					recipient_name: user.name || user.email,
+					org_name: orgNames.get(orgId) ?? "your organisation",
+					overdue_count: String(userOverdue.length),
+					upcoming_count: String(userUpcoming.length),
+					overdue_list_html: renderListHtml(userOverdue, appUrl),
+					overdue_list_text: renderListText(userOverdue),
+					upcoming_list_html: renderListHtml(userUpcoming, appUrl),
+					upcoming_list_text: renderListText(userUpcoming),
+					app_url: `${appUrl}/${orgId}`,
+				},
+			});
+			if (result.status !== "failed") sent++;
+		} catch (err) {
+			log.error("[projects-weekly-digest] send failed", { userId, error: err instanceof Error ? err.message : String(err) });
+		}
+	}
+	log.info(`[projects-weekly-digest] complete — ${sent}/${assigneeIds.size} digest(s) sent`);
+}
+
+pgBossHandlerRegistry.register("@teamscala/service-boot:projects-daily-digest", sendDailyDigest);
+pgBossHandlerRegistry.register("@teamscala/service-boot:projects-weekly-digest", sendWeeklyDigest);

package/src/handlers/prune-stale-data.ts

@@ -0,0 +1,110 @@
+/**
+ * @system server-boot
+ * @status handwritten
+ * @edit edit directly
+ *
+ * The `db-prune-stale-data` pg-boss handler. Reads the `retention` map from the
+ * `scheduled_job` row config and prunes stale rows per entry.
+ *
+ * Writes use Prisma ORM methods (deleteMany/updateMany) via the prisma-registry
+ * client — NEVER raw SQL. The `@teamscala/db` client carries the `blockRawSqlWrites`
+ * audit extension: `$executeRaw`/`$executeRawUnsafe` are blocked so every write
+ * is audited; ORM methods are the canonical audited path.
+ *
+ * SAFETY — identifier allowlist: each retention key selects a FIXED, hardcoded
+ * Prisma model + field (table/field names are literal in code, never derived
+ * from the row); the row's value (a duration string) is parsed to a cutoff Date.
+ * A row can therefore never inject arbitrary SQL or address an unvetted model.
+ * Keys not in the allowlist are skipped + logged.
+ *
+ * `audit_trail.*` is INTENTIONALLY EXCLUDED: `audit-trail-permanent` (critical)
+ * forbids any DELETE FROM audit_trail. The legacy row's
+ * `audit_trail.sync_entities: "delete all"` entry is stale drift from before
+ * the 2026-06-19 hardening — surfaced (skipped + warned), never executed.
+ *
+ * Registered under slug `@teamscala/service-boot:prune-stale-data`.
+ */
+import type { ScheduledJobConfig } from "@teamscala/db-validation/registry-schemas/scheduled-job";
+import { Prisma } from "@teamscala/db/client";
+import { getPrisma } from "@teamscala/db/prisma-registry";
+import { getAppLogger } from "@teamscala/logger/app-loggers";
+import { pgBossHandlerRegistry } from "../pg-boss-handler-registry.ts";
+
+const DURATION_RE = /^(\d+)\s+(second|minute|hour|day|week|month|year)s?$/;
+const UNIT_TO_MS: Record<string, number> = {
+	second: 1_000,
+	minute: 60_000,
+	hour: 3_600_000,
+	day: 86_400_000,
+	week: 604_800_000,
+	month: 2_592_000_000,
+	year: 31_536_000_000,
+};
+
+type PrismaClient = ReturnType<typeof getPrisma>;
+type PruneOp = (prisma: PrismaClient, cutoff: Date) => Promise<number>;
+
+// Fixed ops — model + field names literal in code, cutoff Date is the only
+// variable. Adding a prunable target = adding an entry here (and confirming the
+// model/field + audit-trail-permanent scope).
+const PRUNE_OPS: Record<string, PruneOp> = {
+	"fleet_run_events": async (prisma, cutoff) =>
+		(await prisma.fleet_run_events.deleteMany({ where: { created_at: { lt: cutoff } } })).count,
+	"fleet_run_transitions": async (prisma, cutoff) =>
+		(await prisma.fleet_run_transitions.deleteMany({ where: { created_at: { lt: cutoff } } })).count,
+	// Null out the bulky transcript JSON of old runs — keep the run row itself.
+	// A nullable-Json column requires Prisma's DbNull sentinel (bare `null` is
+	// ambiguous: JSON null vs SQL NULL); DbNull sets the column to SQL NULL.
+	// Prisma namespace is re-exported from @teamscala/db/client.
+	"fleet_agent_runs.transcript": async (prisma, cutoff) =>
+		(
+			await prisma.fleet_agent_runs.updateMany({
+				where: { created_at: { lt: cutoff } },
+				data: { transcript: Prisma.DbNull },
+			})
+		).count,
+};
+
+export async function pruneStaleData({
+	config,
+}: {
+	config: ScheduledJobConfig;
+}): Promise<void> {
+	const log = getAppLogger();
+	const retention = config.retention;
+	if (!retention || Object.keys(retention).length === 0) {
+		log.info("[db-prune-stale-data] no retention entries — nothing to prune");
+		return;
+	}
+	const prisma = getPrisma();
+	let ran = 0;
+	let skipped = 0;
+	for (const [key, rawValue] of Object.entries(retention)) {
+		const op = PRUNE_OPS[key];
+		if (!op) {
+			log.warn(
+				`[db-prune-stale-data] skipping "${key}" — not in the prune allowlist ` +
+					`(audit_trail is excluded by audit-trail-permanent; add the op explicitly to enable)`,
+			);
+			skipped++;
+			continue;
+		}
+		const match = DURATION_RE.exec(rawValue.trim());
+		if (!match) {
+			log.warn(
+				`[db-prune-stale-data] skipping "${key}" — value "${rawValue}" is not a duration (expected e.g. "1 day")`,
+			);
+			skipped++;
+			continue;
+		}
+		const cutoff = new Date(Date.now() - Number(match[1]) * UNIT_TO_MS[match[2]!]);
+		const affected = await op(prisma, cutoff);
+		log.info(
+			`[db-prune-stale-data] pruned "${key}" older than ${rawValue} — ${affected} row(s) affected`,
+		);
+		ran++;
+	}
+	log.info(`[db-prune-stale-data] complete — ${ran} op(s) ran, ${skipped} skipped`);
+}
+
+pgBossHandlerRegistry.register("@teamscala/service-boot:prune-stale-data", pruneStaleData);

package/src/handlers/registry-stale-inactive-sweep.ts

@@ -0,0 +1,82 @@
+/**
+ * @system server-boot
+ * @status handwritten
+ * @edit edit directly
+ *
+ * The `registry-stale-inactive-sweep` pg-boss handler. Surfaces registry
+ * rows that have been inactive beyond a threshold with no deliberate-pause
+ * metadata — the "deactivated and forgotten" class that caused the
+ * fleet_agent_slots miscount (operator directive 2026-07-20).
+ *
+ * This is a MONITOR (detection), not enforcement: it records an event_log
+ * entry so the operator sees stale rows accumulate, but never blocks or
+ * auto-reaps. The structural prevention is the `deactivated_at` stamp the
+ * registry_edit deactivate path writes; this sweep is the detection
+ * backstop that surfaces rows whose `updated_at` (the deactivation
+ * timestamp) has aged past the threshold.
+ *
+ * Excluded from the sweep (deliberate deactivation — NOT stale):
+ * - config.pause_owner / config.reactivate_when (progressive-activation paused guards)
+ * - config.operator_deactivated = true (operator emergency off)
+ *
+ * Registered under slug `@teamscala/service-boot:registry-stale-inactive-sweep`.
+ */
+import type { ScheduledJobConfig } from "@teamscala/db-validation/registry-schemas/scheduled-job";
+import { getPrisma } from "@teamscala/db/prisma-registry";
+import { recordEvent } from "@teamscala/event-log/record-event";
+import { getAppLogger } from "@teamscala/logger/app-loggers";
+import { pgBossHandlerRegistry } from "../pg-boss-handler-registry.ts";
+
+const STALE_AFTER_DAYS = 30;
+const SAMPLE_LIMIT = 20;
+
+interface StaleRow {
+	type: string;
+	slug: string;
+	updated_at: Date;
+}
+
+async function registryStaleInactiveSweep(): Promise<void> {
+	const log = getAppLogger();
+	const prisma = getPrisma();
+
+	const rows = await prisma.$queryRawUnsafe<StaleRow[]>(`
+		SELECT type, slug, updated_at
+		FROM registry_entries
+		WHERE is_active = false
+			AND updated_at < NOW() - INTERVAL '${STALE_AFTER_DAYS} days'
+			AND NOT (config ? 'pause_owner')
+			AND NOT (config ? 'reactivate_when')
+			AND NOT (config->>'operator_deactivated' = 'true')
+		ORDER BY updated_at ASC
+	`);
+
+	const byType = new Map<string, number>();
+	for (const r of rows) {
+		byType.set(r.type, (byType.get(r.type) ?? 0) + 1);
+	}
+
+	const samples = rows
+		.slice(0, SAMPLE_LIMIT)
+		.map((r) => `${r.type}/${r.slug}(${r.updated_at.toISOString().slice(0, 10)})`);
+
+	recordEvent({
+		kind: "registry.stale-inactive.detected",
+		payload: {
+			totalStale: rows.length,
+			staleAfterDays: STALE_AFTER_DAYS,
+			byType: Object.fromEntries(byType),
+			samples,
+		},
+	});
+
+	log.info(
+		`[registry-stale-inactive-sweep] ${rows.length} stale inactive row(s) (>${STALE_AFTER_DAYS}d, no pause metadata) — recorded to event_log`,
+		{ byType: Object.fromEntries(byType), samples },
+	);
+}
+
+pgBossHandlerRegistry.register(
+	"@teamscala/service-boot:registry-stale-inactive-sweep",
+	registryStaleInactiveSweep as (ctx: { config: ScheduledJobConfig }) => Promise<void>,
+);

package/src/handlers/scala-tools-currency-watch.test.ts

@@ -0,0 +1,60 @@
+import { describe, expect, test } from "bun:test";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+
+/**
+ * Regression lock: this watch must never restart scala-sentinel again.
+ *
+ * It used to reinstall @teamscala/scala-tools and then `pm2 restart scala-sentinel`
+ * "so the fresh scala-tools loads". That premise is false for this package —
+ * sentinel SPAWNS `node_modules/.bin/scala-tools` per invocation rather than
+ * importing it, so the reinstall alone is what takes effect. The restart's only
+ * real consequence was taking enforcement offline: every guard-daemon shutdown
+ * logs "152 guard(s) failed to run (fail-open)", so each publish of scala-tools
+ * opened a window where tool-check, turn-end and pre-push silently did not run.
+ *
+ * The assertion is on the SOURCE rather than on a mocked run, and that is
+ * deliberate rather than a shortcut: the property being locked is the ABSENCE of
+ * a side effect. A behavioural test can only prove the restart did not fire for
+ * the paths it happens to drive, whereas the absence of any pm2-restart call in
+ * the module proves it cannot fire on any path. It also stays honest if someone
+ * reintroduces the restart behind a new condition.
+ */
+const SOURCE = readFileSync(
+	join(import.meta.dir, "scala-tools-currency-watch.ts"),
+	"utf-8",
+);
+
+/** Comment prose legitimately discusses the removed restart; code must not do it. */
+const CODE = SOURCE.split("\n")
+	.filter((l) => !l.trimStart().startsWith("//") && !l.trimStart().startsWith("*"))
+	.join("\n");
+
+describe("scala-tools-currency-watch never restarts the guard daemon", () => {
+	test("issues no pm2 restart command", () => {
+		expect(CODE).not.toContain('"restart"');
+	});
+
+	test("never names scala-sentinel as a spawn argument", () => {
+		// The reinstall targets the sentinel DIRECTORY (a path constant); what must
+		// not exist is scala-sentinel as a process argument to a supervisor call.
+		expect(CODE).not.toContain('"scala-sentinel"');
+	});
+
+	test("uses no bare pm2 invocation", () => {
+		// forbid-bare-pm2-restart: a bare `pm2` call bypasses the currency-gated
+		// canonical pipeline, and the guard blocks agents from making this exact
+		// call — the handler was doing what agents are prevented from doing.
+		expect(CODE).not.toContain('"pm2"');
+	});
+
+	test("still performs the reinstall, which is the watch's actual job", () => {
+		// Removing the restart must not turn this into a no-op watch.
+		expect(CODE).toContain("deps");
+		expect(CODE).toContain("install");
+	});
+
+	test("still records the reinstall event for observability", () => {
+		expect(CODE).toContain("scala-tools.currency.reinstalled");
+	});
+});