@wopr-network/platform-core 1.34.0 → 1.35.1

package/dist/billing/crypto/btc/address-gen.d.ts

@@ -11,6 +11,10 @@ export type UtxoNetwork = "mainnet" | "testnet" | "regtest";
 export declare function deriveAddress(xpub: string, index: number, network?: UtxoNetwork, chain?: UtxoChain): string;
 /** Derive the treasury address (internal chain, index 0). */
 export declare function deriveTreasury(xpub: string, network?: UtxoNetwork, chain?: UtxoChain): string;
+/**
+ * Derive a P2PKH (Base58Check) address for chains without bech32 (e.g., DOGE → D...).
+ */
+export declare function deriveP2pkhAddress(xpub: string, index: number, chain: string, network?: "mainnet" | "testnet"): string;
 /** @deprecated Use `deriveAddress` instead. */
 export declare const deriveBtcAddress: typeof deriveAddress;
 /** @deprecated Use `deriveTreasury` instead. */

package/dist/billing/crypto/btc/address-gen.js

@@ -39,6 +39,50 @@ export function deriveTreasury(xpub, network = "mainnet", chain = "bitcoin") {
     const words = bech32.toWords(hash160);
     return bech32.encode(prefix, [0, ...words]);
 }
+/** P2PKH version bytes for Base58Check encoding (chains without bech32). */
+const P2PKH_VERSION = {
+    dogecoin: { mainnet: 0x1e, testnet: 0x71 },
+};
+const BASE58_ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+function base58encode(data) {
+    let num = 0n;
+    for (const byte of data)
+        num = num * 256n + BigInt(byte);
+    let encoded = "";
+    while (num > 0n) {
+        encoded = BASE58_ALPHABET[Number(num % 58n)] + encoded;
+        num = num / 58n;
+    }
+    for (const byte of data) {
+        if (byte !== 0)
+            break;
+        encoded = "1" + encoded;
+    }
+    return encoded;
+}
+/**
+ * Derive a P2PKH (Base58Check) address for chains without bech32 (e.g., DOGE → D...).
+ */
+export function deriveP2pkhAddress(xpub, index, chain, network = "mainnet") {
+    if (!Number.isInteger(index) || index < 0)
+        throw new Error(`Invalid derivation index: ${index}`);
+    const version = P2PKH_VERSION[chain]?.[network];
+    if (version === undefined)
+        throw new Error(`No P2PKH version for chain=${chain} network=${network}`);
+    const master = HDKey.fromExtendedKey(xpub);
+    const child = master.deriveChild(0).deriveChild(index);
+    if (!child.publicKey)
+        throw new Error("Failed to derive public key");
+    const hash160 = ripemd160(sha256(child.publicKey));
+    const payload = new Uint8Array(21);
+    payload[0] = version;
+    payload.set(hash160, 1);
+    const checksum = sha256(sha256(payload));
+    const full = new Uint8Array(25);
+    full.set(payload);
+    full.set(checksum.slice(0, 4), 21);
+    return base58encode(full);
+}
 /** @deprecated Use `deriveAddress` instead. */
 export const deriveBtcAddress = deriveAddress;
 /** @deprecated Use `deriveTreasury` instead. */

package/dist/billing/crypto/oracle/chainlink.js

@@ -25,11 +25,11 @@ export class ChainlinkOracle {
     maxStalenessMs;
     constructor(opts) {
         this.rpc = opts.rpcCall;
-        this.feeds = { ...FEED_ADDRESSES, ...opts.feedAddresses };
+        this.feeds = new Map(Object.entries({ ...FEED_ADDRESSES, ...opts.feedAddresses }));
         this.maxStalenessMs = opts.maxStalenessMs ?? DEFAULT_MAX_STALENESS_MS;
     }
     async getPrice(asset) {
-        const feedAddress = this.feeds[asset];
+        const feedAddress = this.feeds.get(asset);
         if (!feedAddress)
             throw new Error(`No price feed for asset: ${asset}`);
         const result = (await this.rpc("eth_call", [{ to: feedAddress, data: LATEST_ROUND_DATA }, "latest"]));

package/dist/billing/crypto/oracle/types.d.ts

@@ -1,5 +1,5 @@
 /** Assets with Chainlink price feeds. */
-export type PriceAsset = "ETH" | "BTC";
+export type PriceAsset = string;
 /** Result from a price oracle query. */
 export interface PriceResult {
     /** USD cents per 1 unit of asset (integer). */

package/dist/billing/crypto/unified-checkout.js

@@ -1,4 +1,5 @@
 import { Credit } from "../../credits/credit.js";
+import { deriveAddress, deriveP2pkhAddress } from "./btc/address-gen.js";
 import { deriveDepositAddress } from "./evm/address-gen.js";
 import { centsToNative } from "./oracle/convert.js";
 export const MIN_CHECKOUT_USD = 10;
@@ -20,11 +21,11 @@ export async function createUnifiedCheckout(deps, method, opts) {
     if (method.type === "erc20") {
         return handleErc20(deps, method, opts.tenant, amountUsdCents, opts.amountUsd);
     }
-    if (method.token === "ETH") {
-        return handleNativeEth(deps, method, opts.tenant, amountUsdCents, opts.amountUsd);
+    if (method.type === "native" && method.chain === "base") {
+        return handleNativeEvm(deps, method, opts.tenant, amountUsdCents, opts.amountUsd);
     }
-    if (method.token === "BTC") {
-        return handleNativeBtc(deps, method, opts.tenant, amountUsdCents, opts.amountUsd);
+    if (method.type === "native") {
+        return handleNativeUtxo(deps, method, opts.tenant, amountUsdCents, opts.amountUsd);
     }
     throw new Error(`Unsupported payment method type: ${method.type}/${method.token}`);
 }
@@ -39,7 +40,7 @@ async function handleErc20(deps, method, tenant, amountUsdCents, amountUsd) {
         referenceId: `erc20:${method.chain}:${depositAddress}`,
     };
 }
-async function handleNativeEth(deps, method, tenant, amountUsdCents, amountUsd) {
+async function handleNativeEvm(deps, method, tenant, amountUsdCents, amountUsd) {
     const { priceCents } = await deps.oracle.getPrice("ETH");
     const expectedWei = centsToNative(amountUsdCents, priceCents, 18);
     const depositAddress = await deriveAndStore(deps, method, tenant, amountUsdCents);
@@ -56,35 +57,47 @@ async function handleNativeEth(deps, method, tenant, amountUsdCents, amountUsd)
         priceCents,
     };
 }
-async function handleNativeBtc(deps, _method, tenant, amountUsdCents, amountUsd) {
-    const { priceCents } = await deps.oracle.getPrice("BTC");
-    const expectedSats = centsToNative(amountUsdCents, priceCents, 8);
-    // BTC address derivation uses btcXpub — import from btc module
-    const { deriveBtcAddress } = await import("./btc/address-gen.js");
-    if (!deps.btcXpub)
-        throw new Error("BTC payments not configured (no BTC_XPUB)");
+/**
+ * Handle native UTXO coins (BTC, LTC, DOGE, BCH, etc.).
+ * Uses the xpub from the payment method record (DB-driven).
+ * Derives bech32 addresses for BTC/LTC, Base58 P2PKH for DOGE.
+ */
+async function handleNativeUtxo(deps, method, tenant, amountUsdCents, amountUsd) {
+    const xpub = method.xpub ?? deps.btcXpub;
+    if (!xpub)
+        throw new Error(`${method.token} payments not configured (no xpub)`);
+    const { priceCents } = await deps.oracle.getPrice(method.token);
+    const rawAmount = centsToNative(amountUsdCents, priceCents, method.decimals);
     const maxRetries = 3;
     for (let attempt = 0; attempt <= maxRetries; attempt++) {
         const derivationIndex = await deps.chargeStore.getNextDerivationIndex();
-        const depositAddress = deriveBtcAddress(deps.btcXpub, derivationIndex, "mainnet");
-        const referenceId = `btc:${depositAddress}`;
+        // Derive address by chain type
+        let depositAddress;
+        if (method.chain === "dogecoin") {
+            depositAddress = deriveP2pkhAddress(xpub, derivationIndex, "dogecoin");
+        }
+        else {
+            depositAddress = deriveAddress(xpub, derivationIndex, "mainnet", method.chain);
+        }
+        const referenceId = `${method.token.toLowerCase()}:${depositAddress}`;
         try {
             await deps.chargeStore.createStablecoinCharge({
                 referenceId,
                 tenantId: tenant,
                 amountUsdCents,
-                chain: "bitcoin",
-                token: "BTC",
+                chain: method.chain,
+                token: method.token,
                 depositAddress,
                 derivationIndex,
             });
-            const btcAmount = Number(expectedSats) / 100_000_000;
+            const divisor = 10 ** method.decimals;
+            const displayAmt = (Number(rawAmount) / divisor).toFixed(method.decimals);
             return {
                 depositAddress,
-                displayAmount: `${btcAmount.toFixed(8)} BTC`,
+                displayAmount: `${displayAmt} ${method.token}`,
                 amountUsd,
-                token: "BTC",
-                chain: "bitcoin",
+                token: method.token,
+                chain: method.chain,
                 referenceId,
                 priceCents,
             };

package/dist/email/handlebars-renderer.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/email/handlebars-renderer.test.js

@@ -0,0 +1,174 @@
+import { describe, expect, it, vi } from "vitest";
+import { HandlebarsRenderer } from "./handlebars-renderer.js";
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function makeTemplate(overrides = {}) {
+    return {
+        id: "tpl-1",
+        name: "test-template",
+        description: "A test template",
+        subject: "Hello {{name}}",
+        htmlBody: "<h1>Hello {{name}}</h1>",
+        textBody: "Hello {{name}}",
+        active: true,
+        createdAt: Date.now(),
+        updatedAt: Date.now(),
+        ...overrides,
+    };
+}
+function makeRepo(templates = {}) {
+    return {
+        getByName: vi.fn().mockImplementation((name) => Promise.resolve(templates[name] ?? null)),
+        list: vi.fn().mockResolvedValue(Object.values(templates).filter(Boolean)),
+        upsert: vi.fn().mockResolvedValue(undefined),
+    };
+}
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+describe("HandlebarsRenderer", () => {
+    it("returns null for unknown template", async () => {
+        const repo = makeRepo({});
+        const renderer = new HandlebarsRenderer(repo);
+        const result = await renderer.render("nonexistent", { name: "World" });
+        expect(result).toBeNull();
+        expect(repo.getByName).toHaveBeenCalledWith("nonexistent");
+    });
+    it("returns null for inactive template", async () => {
+        const repo = makeRepo({
+            "inactive-tpl": makeTemplate({ name: "inactive-tpl", active: false }),
+        });
+        const renderer = new HandlebarsRenderer(repo);
+        const result = await renderer.render("inactive-tpl", { name: "World" });
+        expect(result).toBeNull();
+    });
+    it("compiles Handlebars and returns subject/html/text", async () => {
+        const repo = makeRepo({
+            greeting: makeTemplate({
+                name: "greeting",
+                subject: "Hi {{name}}!",
+                htmlBody: "<p>Welcome, {{name}}!</p>",
+                textBody: "Welcome, {{name}}!",
+            }),
+        });
+        const renderer = new HandlebarsRenderer(repo);
+        const result = await renderer.render("greeting", { name: "Alice" });
+        expect(result).not.toBeNull();
+        expect(result?.subject).toBe("Hi Alice!");
+        expect(result?.html).toBe("<p>Welcome, Alice!</p>");
+        expect(result?.text).toBe("Welcome, Alice!");
+    });
+    it("injects currentYear automatically", async () => {
+        const repo = makeRepo({
+            footer: makeTemplate({
+                name: "footer",
+                subject: "Year: {{currentYear}}",
+                htmlBody: "<p>&copy; {{currentYear}}</p>",
+                textBody: "(c) {{currentYear}}",
+            }),
+        });
+        const renderer = new HandlebarsRenderer(repo);
+        const result = await renderer.render("footer", {});
+        const year = new Date().getFullYear();
+        expect(result?.subject).toBe(`Year: ${year}`);
+        expect(result?.html).toBe(`<p>&copy; ${year}</p>`);
+        expect(result?.text).toBe(`(c) ${year}`);
+    });
+    it("does not override explicit currentYear from data", async () => {
+        const repo = makeRepo({
+            footer: makeTemplate({
+                name: "footer",
+                subject: "Year: {{currentYear}}",
+                htmlBody: "<p>{{currentYear}}</p>",
+                textBody: "{{currentYear}}",
+            }),
+        });
+        const renderer = new HandlebarsRenderer(repo);
+        const result = await renderer.render("footer", { currentYear: 2099 });
+        expect(result?.subject).toBe("Year: 2099");
+    });
+    describe("helpers", () => {
+        it("eq helper returns true for equal values", async () => {
+            const repo = makeRepo({
+                cond: makeTemplate({
+                    name: "cond",
+                    subject: '{{#if (eq status "active")}}Active{{else}}Inactive{{/if}}',
+                    htmlBody: "ok",
+                    textBody: "ok",
+                }),
+            });
+            const renderer = new HandlebarsRenderer(repo);
+            const active = await renderer.render("cond", { status: "active" });
+            expect(active?.subject).toBe("Active");
+            const inactive = await renderer.render("cond", { status: "disabled" });
+            expect(inactive?.subject).toBe("Inactive");
+        });
+        it("gt helper compares numbers", async () => {
+            const repo = makeRepo({
+                gt: makeTemplate({
+                    name: "gt",
+                    subject: "{{#if (gt count 5)}}Many{{else}}Few{{/if}}",
+                    htmlBody: "ok",
+                    textBody: "ok",
+                }),
+            });
+            const renderer = new HandlebarsRenderer(repo);
+            const many = await renderer.render("gt", { count: 10 });
+            expect(many?.subject).toBe("Many");
+            const few = await renderer.render("gt", { count: 3 });
+            expect(few?.subject).toBe("Few");
+        });
+        it("formatDate helper formats timestamps", async () => {
+            const repo = makeRepo({
+                dated: makeTemplate({
+                    name: "dated",
+                    subject: "Date: {{formatDate ts}}",
+                    htmlBody: "ok",
+                    textBody: "ok",
+                }),
+            });
+            const renderer = new HandlebarsRenderer(repo);
+            // Use noon UTC to avoid timezone date-boundary shifts
+            const ts = new Date("2025-01-15T12:00:00Z").getTime();
+            const result = await renderer.render("dated", { ts });
+            // The formatted string uses en-US locale with year/month/day
+            const expected = new Date(ts).toLocaleDateString("en-US", {
+                year: "numeric",
+                month: "long",
+                day: "numeric",
+            });
+            expect(result?.subject).toBe(`Date: ${expected}`);
+        });
+        it("formatDate helper passes through non-numeric values", async () => {
+            const repo = makeRepo({
+                dated: makeTemplate({
+                    name: "dated",
+                    subject: "Date: {{formatDate ts}}",
+                    htmlBody: "ok",
+                    textBody: "ok",
+                }),
+            });
+            const renderer = new HandlebarsRenderer(repo);
+            const result = await renderer.render("dated", { ts: "not-a-number" });
+            expect(result?.subject).toBe("Date: not-a-number");
+        });
+        it("escapeHtml helper escapes special characters", async () => {
+            const repo = makeRepo({
+                esc: makeTemplate({
+                    name: "esc",
+                    subject: "Safe: {{escapeHtml input}}",
+                    htmlBody: "ok",
+                    textBody: "ok",
+                }),
+            });
+            const renderer = new HandlebarsRenderer(repo);
+            const result = await renderer.render("esc", {
+                input: '<script>alert("xss")</script>',
+            });
+            expect(result?.subject).toContain("&lt;script&gt;");
+            expect(result?.subject).toContain("&quot;xss&quot;");
+            expect(result?.subject).not.toContain("<script>");
+        });
+    });
+});

package/dist/fleet/fleet-notification-listener.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/fleet/fleet-notification-listener.test.js

@@ -0,0 +1,244 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { FleetEventEmitter } from "./fleet-event-emitter.js";
+import { initFleetNotificationListener } from "./fleet-notification-listener.js";
+vi.mock("../config/logger.js", () => ({
+    logger: {
+        info: vi.fn(),
+        error: vi.fn(),
+        warn: vi.fn(),
+        debug: vi.fn(),
+    },
+}));
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+const DEBOUNCE_MS = 100;
+function makePrefs(overrides = {}) {
+    return {
+        billing_low_balance: true,
+        billing_receipts: true,
+        billing_auto_topup: true,
+        agent_channel_disconnect: true,
+        agent_status_changes: false,
+        account_role_changes: true,
+        account_team_invites: true,
+        fleet_updates: true,
+        ...overrides,
+    };
+}
+function makePrefsRepo(prefs = makePrefs()) {
+    return {
+        get: vi.fn().mockResolvedValue(prefs),
+        update: vi.fn().mockResolvedValue(undefined),
+    };
+}
+function makeNotificationService() {
+    return {
+        notifyFleetUpdateComplete: vi.fn(),
+        notifyFleetUpdateAvailable: vi.fn(),
+        notifyLowBalance: vi.fn(),
+    };
+}
+function botUpdated(tenantId, version = "v1.2.0") {
+    return {
+        type: "bot.updated",
+        botId: `bot-${Math.random().toString(36).slice(2, 6)}`,
+        tenantId,
+        timestamp: new Date().toISOString(),
+        version,
+    };
+}
+function botUpdateFailed(tenantId, version = "v1.2.0") {
+    return {
+        type: "bot.update_failed",
+        botId: `bot-${Math.random().toString(36).slice(2, 6)}`,
+        tenantId,
+        timestamp: new Date().toISOString(),
+        version,
+    };
+}
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+describe("initFleetNotificationListener", () => {
+    let emitter;
+    beforeEach(() => {
+        vi.useFakeTimers();
+        emitter = new FleetEventEmitter();
+    });
+    afterEach(() => {
+        vi.useRealTimers();
+    });
+    it("ignores non-bot events (node events)", async () => {
+        const notificationService = makeNotificationService();
+        const preferences = makePrefsRepo();
+        initFleetNotificationListener({
+            eventEmitter: emitter,
+            notificationService,
+            preferences,
+            resolveEmail: vi.fn().mockResolvedValue("user@example.com"),
+            debounceMs: DEBOUNCE_MS,
+        });
+        emitter.emit({
+            type: "node.provisioned",
+            nodeId: "node-1",
+            timestamp: new Date().toISOString(),
+        });
+        await vi.advanceTimersByTimeAsync(DEBOUNCE_MS + 50);
+        expect(notificationService.notifyFleetUpdateComplete).not.toHaveBeenCalled();
+    });
+    it("ignores non-update bot events (bot.started, bot.stopped)", async () => {
+        const notificationService = makeNotificationService();
+        const preferences = makePrefsRepo();
+        initFleetNotificationListener({
+            eventEmitter: emitter,
+            notificationService,
+            preferences,
+            resolveEmail: vi.fn().mockResolvedValue("user@example.com"),
+            debounceMs: DEBOUNCE_MS,
+        });
+        emitter.emit({
+            type: "bot.started",
+            botId: "bot-1",
+            tenantId: "t1",
+            timestamp: new Date().toISOString(),
+        });
+        emitter.emit({
+            type: "bot.stopped",
+            botId: "bot-2",
+            tenantId: "t1",
+            timestamp: new Date().toISOString(),
+        });
+        await vi.advanceTimersByTimeAsync(DEBOUNCE_MS + 50);
+        expect(notificationService.notifyFleetUpdateComplete).not.toHaveBeenCalled();
+    });
+    it("aggregates multiple bot.updated events per tenant into one notification", async () => {
+        const notificationService = makeNotificationService();
+        const preferences = makePrefsRepo();
+        const resolveEmail = vi.fn().mockResolvedValue("owner@example.com");
+        initFleetNotificationListener({
+            eventEmitter: emitter,
+            notificationService,
+            preferences,
+            resolveEmail,
+            debounceMs: DEBOUNCE_MS,
+        });
+        // Emit 3 successful updates for the same tenant
+        emitter.emit(botUpdated("t1", "v2.0.0"));
+        emitter.emit(botUpdated("t1", "v2.0.0"));
+        emitter.emit(botUpdated("t1", "v2.0.0"));
+        // No notification yet — debounce hasn't fired
+        expect(notificationService.notifyFleetUpdateComplete).not.toHaveBeenCalled();
+        await vi.advanceTimersByTimeAsync(DEBOUNCE_MS + 50);
+        expect(notificationService.notifyFleetUpdateComplete).toHaveBeenCalledOnce();
+        expect(notificationService.notifyFleetUpdateComplete).toHaveBeenCalledWith("t1", "owner@example.com", "v2.0.0", 3, // succeeded
+        0);
+    });
+    it("sends summary with correct succeeded/failed counts after debounce", async () => {
+        const notificationService = makeNotificationService();
+        const preferences = makePrefsRepo();
+        const resolveEmail = vi.fn().mockResolvedValue("owner@example.com");
+        initFleetNotificationListener({
+            eventEmitter: emitter,
+            notificationService,
+            preferences,
+            resolveEmail,
+            debounceMs: DEBOUNCE_MS,
+        });
+        emitter.emit(botUpdated("t1", "v3.0.0"));
+        emitter.emit(botUpdated("t1", "v3.0.0"));
+        emitter.emit(botUpdateFailed("t1", "v3.0.0"));
+        await vi.advanceTimersByTimeAsync(DEBOUNCE_MS + 50);
+        expect(notificationService.notifyFleetUpdateComplete).toHaveBeenCalledWith("t1", "owner@example.com", "v3.0.0", 2, // succeeded
+        1);
+    });
+    it("updates version from subsequent events", async () => {
+        const notificationService = makeNotificationService();
+        const preferences = makePrefsRepo();
+        const resolveEmail = vi.fn().mockResolvedValue("owner@example.com");
+        initFleetNotificationListener({
+            eventEmitter: emitter,
+            notificationService,
+            preferences,
+            resolveEmail,
+            debounceMs: DEBOUNCE_MS,
+        });
+        // First event has v1.0.0, subsequent event changes to v1.1.0
+        emitter.emit(botUpdated("t1", "v1.0.0"));
+        emitter.emit(botUpdated("t1", "v1.1.0"));
+        await vi.advanceTimersByTimeAsync(DEBOUNCE_MS + 50);
+        expect(notificationService.notifyFleetUpdateComplete).toHaveBeenCalledWith("t1", "owner@example.com", "v1.1.0", // updated to latest version
+        2, 0);
+    });
+    it("checks fleet_updates preference — skips if disabled", async () => {
+        const notificationService = makeNotificationService();
+        const preferences = makePrefsRepo(makePrefs({ fleet_updates: false }));
+        const resolveEmail = vi.fn().mockResolvedValue("owner@example.com");
+        initFleetNotificationListener({
+            eventEmitter: emitter,
+            notificationService,
+            preferences,
+            resolveEmail,
+            debounceMs: DEBOUNCE_MS,
+        });
+        emitter.emit(botUpdated("t1"));
+        await vi.advanceTimersByTimeAsync(DEBOUNCE_MS + 50);
+        expect(preferences.get).toHaveBeenCalledWith("t1");
+        expect(notificationService.notifyFleetUpdateComplete).not.toHaveBeenCalled();
+    });
+    it("skips if email resolver returns null", async () => {
+        const notificationService = makeNotificationService();
+        const preferences = makePrefsRepo();
+        const resolveEmail = vi.fn().mockResolvedValue(null);
+        initFleetNotificationListener({
+            eventEmitter: emitter,
+            notificationService,
+            preferences,
+            resolveEmail,
+            debounceMs: DEBOUNCE_MS,
+        });
+        emitter.emit(botUpdated("t1"));
+        await vi.advanceTimersByTimeAsync(DEBOUNCE_MS + 50);
+        expect(resolveEmail).toHaveBeenCalledWith("t1");
+        expect(notificationService.notifyFleetUpdateComplete).not.toHaveBeenCalled();
+    });
+    it("async shutdown flushes pending notifications", async () => {
+        const notificationService = makeNotificationService();
+        const preferences = makePrefsRepo();
+        const resolveEmail = vi.fn().mockResolvedValue("owner@example.com");
+        const shutdown = initFleetNotificationListener({
+            eventEmitter: emitter,
+            notificationService,
+            preferences,
+            resolveEmail,
+            debounceMs: DEBOUNCE_MS,
+        });
+        emitter.emit(botUpdated("t1", "v5.0.0"));
+        emitter.emit(botUpdated("t2", "v5.0.0"));
+        // Don't advance timers — flush via shutdown instead
+        await shutdown();
+        // Both tenants should have been flushed
+        expect(notificationService.notifyFleetUpdateComplete).toHaveBeenCalledTimes(2);
+        const calls = vi.mocked(notificationService.notifyFleetUpdateComplete).mock.calls;
+        const tenantIds = calls.map((c) => c[0]);
+        expect(tenantIds).toContain("t1");
+        expect(tenantIds).toContain("t2");
+    });
+    it("no further events after shutdown", async () => {
+        const notificationService = makeNotificationService();
+        const preferences = makePrefsRepo();
+        const resolveEmail = vi.fn().mockResolvedValue("owner@example.com");
+        const shutdown = initFleetNotificationListener({
+            eventEmitter: emitter,
+            notificationService,
+            preferences,
+            resolveEmail,
+            debounceMs: DEBOUNCE_MS,
+        });
+        await shutdown();
+        // Events after shutdown should not trigger anything
+        emitter.emit(botUpdated("t1"));
+        await vi.advanceTimersByTimeAsync(DEBOUNCE_MS + 50);
+        expect(notificationService.notifyFleetUpdateComplete).not.toHaveBeenCalled();
+    });
+});

package/dist/fleet/init-fleet-updater.d.ts

@@ -41,7 +41,7 @@ export interface FleetUpdaterConfig {
     /** Optional fleet event emitter. When provided, bot.updated / bot.update_failed events are emitted. */
     eventEmitter?: FleetEventEmitter;
     /** Called with manual-mode tenant IDs when a new image is available but they are excluded from rollout. */
-    onManualTenantsSkipped?: (tenantIds: string[]) => void;
+    onManualTenantsSkipped?: (tenantIds: string[], imageTag: string) => void;
 }
 export interface FleetUpdaterHandle {
     poller: ImagePoller;

package/dist/fleet/init-fleet-updater.js

@@ -36,6 +36,10 @@ export function initFleetUpdater(docker, fleet, profileStore, profileRepo, confi
     const updater = new ContainerUpdater(docker, profileStore, fleet, poller);
     const snapshotManager = new VolumeSnapshotManager(docker, snapshotDir);
     const strategy = createRolloutStrategy(strategyType, strategyOptions);
+    // Captured by the onUpdateAvailable handler and read by getUpdatableProfiles.
+    // Set before each orchestrator.rollout() call so the callback receives the
+    // image tag that triggered this rollout rather than a stale "latest" placeholder.
+    let currentImageTag = "latest";
     const orchestrator = new RolloutOrchestrator({
         updater,
         snapshotManager,
@@ -53,7 +57,7 @@ export function initFleetUpdater(docker, fleet, profileStore, profileRepo, confi
             });
             if (!configRepo) {
                 if (manualPolicyIds.length > 0 && onManualTenantsSkipped) {
-                    onManualTenantsSkipped([...new Set(manualPolicyIds)]);
+                    onManualTenantsSkipped([...new Set(manualPolicyIds)], currentImageTag);
                 }
                 return nonManualPolicy;
             }
@@ -70,7 +74,7 @@ export function initFleetUpdater(docker, fleet, profileStore, profileRepo, confi
             }));
             const allManualIds = [...manualPolicyIds, ...configManualIds];
             if (allManualIds.length > 0 && onManualTenantsSkipped) {
-                onManualTenantsSkipped([...new Set(allManualIds)]);
+                onManualTenantsSkipped([...new Set(allManualIds)], currentImageTag);
             }
             return results.filter((p) => p !== null);
         },
@@ -106,11 +110,23 @@ export function initFleetUpdater(docker, fleet, profileStore, profileRepo, confi
     // Wire the detection → orchestration pipeline.
     // Any digest change triggers a fleet-wide rollout because the managed image
     // is shared across all tenants — one new digest means all bots need updating.
-    poller.onUpdateAvailable = async (_botId, _newDigest) => {
+    poller.onUpdateAvailable = async (botId, _newDigest) => {
         if (orchestrator.isRolling) {
             logger.debug("Skipping update trigger — rollout already in progress");
             return;
         }
+        // Resolve the image tag from the bot that triggered the update so that
+        // onManualTenantsSkipped receives the real version instead of "latest".
+        try {
+            const triggeringProfile = await profileStore.get(botId);
+            if (triggeringProfile) {
+                const img = triggeringProfile.image;
+                currentImageTag = img.includes(":") ? (img.split(":").pop() ?? "latest") : "latest";
+            }
+        }
+        catch {
+            // Best-effort — currentImageTag stays at previous value
+        }
         logger.info("New image digest detected — starting fleet-wide rollout");
         await orchestrator.rollout().catch((err) => {
             logger.error("Rollout failed", { err });

package/dist/fleet/init-fleet-updater.test.d.ts

@@ -0,0 +1 @@
+export {};