commandmate 0.31.1 → 0.31.3

package/dist/server/src/lib/push/model-change-push-notifier.js

@@ -0,0 +1,174 @@
+"use strict";
+/**
+ * The wording of "the model changed", and the push that carries it
+ * (Issue #2357).
+ *
+ * ## What this module owns
+ *
+ * Three things, and the first is the reason the other two live together:
+ *
+ *  1. **The sentence.** `Model changed from gpt-5.6-sol to gpt-5-mini`, in the
+ *     reader's language, from `locales/<locale>/worktree.json` —
+ *     `agentModel.changed`, next to the session row that shows the value on the
+ *     phone. It is rendered here rather than in `push-sender` because it is also
+ *     what the history row says: the model edge writes one row into
+ *     `chat_messages` and sends one push, and a reader comparing the two must
+ *     find the same words.
+ *  2. **Which language the history row is written in.** A row is stored once,
+ *     and the server has no request to read a cookie from — the edge fires from
+ *     the hook route or the status poll, neither of which is the reader. The
+ *     best evidence it has is the language the readers registered their push
+ *     subscriptions in, so the newest subscription's locale is used, and the
+ *     default locale when nobody has registered one.
+ *  3. **The push itself.** One per transition, through `notifyPushSubscribers`,
+ *     on the `enabled_prompt` bucket (see `NotificationEvent.modelChange` for
+ *     why that bucket and why the transport kind reads `failure`).
+ *
+ * ## Why the dictionaries are static imports
+ *
+ * The same constraint `push-sender` documents: this module is reached from the
+ * custom server's graph (`ws-server` → `waiting-broadcast` →
+ * `model-change-broadcast` → here) and is therefore emitted into `dist/server`
+ * as CommonJS, where `next-intl` (ESM-only) cannot be required. The JSON is
+ * imported directly and `{from}` / `{to}` are substituted by hand.
+ *
+ * @module lib/push/model-change-push-notifier
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildModelChangedSentence = buildModelChangedSentence;
+exports.buildModelChangedBodies = buildModelChangedBodies;
+exports.resolveReadersLocale = resolveReadersLocale;
+exports.notifyModelChangePush = notifyModelChangePush;
+const i18n_config_1 = require("../../config/i18n-config");
+const db_instance_1 = require("../../lib/db/db-instance");
+const push_subscriptions_db_1 = require("../../lib/db/push-subscriptions-db");
+const worktree_db_1 = require("../../lib/db/worktree-db");
+const logger_1 = require("../../lib/logger");
+const worktree_json_1 = __importDefault(require("../../../locales/en/worktree.json"));
+const worktree_json_2 = __importDefault(require("../../../locales/ja/worktree.json"));
+const push_sender_1 = require("./push-sender");
+const vapid_1 = require("./vapid");
+const logger = (0, logger_1.createLogger)('push/model-change-notifier');
+/**
+ * The one sentence, per locale. Keyed by `SupportedLocale` so adding a locale
+ * without a dictionary is a type error here rather than an English push in a
+ * Japanese install.
+ */
+const MODEL_CHANGED_TEMPLATES = {
+    en: worktree_json_1.default.agentModel.changed,
+    ja: worktree_json_2.default.agentModel.changed,
+};
+/**
+ * "Model changed from {from} to {to}", in one language.
+ *
+ * `from` / `to` are the resolved values `sessionStatusByInstance[].model`
+ * publishes, verbatim — the same string the phone's session row shows, so the
+ * sentence and the row cannot name the same model two ways.
+ */
+function buildModelChangedSentence(locale, from, to) {
+    return MODEL_CHANGED_TEMPLATES[(0, push_sender_1.resolvePushLocale)(locale)]
+        .replace('{from}', from)
+        .replace('{to}', to);
+}
+/** The sentence in every supported language, for a per-device fan-out. */
+function buildModelChangedBodies(from, to) {
+    const bodies = {};
+    for (const locale of i18n_config_1.SUPPORTED_LOCALES) {
+        bodies[locale] = buildModelChangedSentence(locale, from, to);
+    }
+    return bodies;
+}
+/**
+ * The language the history row should be written in (Issue #2357).
+ *
+ * The newest push subscription's locale, because that is the only place the
+ * server has ever been told what language a reader reads in — registration
+ * resolves it the way the UI does (`resolveLocale`, cookie then
+ * `Accept-Language`) and stores it on the row. No subscription at all means the
+ * default locale, which is what the UI shows a reader who has chosen nothing.
+ *
+ * Never throws: a database that cannot answer is a reason to write the row in
+ * the default language, not a reason to write no row.
+ */
+function resolveReadersLocale(db) {
+    try {
+        const subscriptions = (0, push_subscriptions_db_1.getAllPushSubscriptions)(db);
+        let newest = null;
+        for (const sub of subscriptions) {
+            const updatedAt = sub.updatedAt.getTime();
+            if (newest === null || updatedAt > newest.updatedAt) {
+                newest = { updatedAt, locale: sub.locale };
+            }
+        }
+        return (0, push_sender_1.resolvePushLocale)(newest?.locale ?? i18n_config_1.DEFAULT_LOCALE);
+    }
+    catch {
+        return i18n_config_1.DEFAULT_LOCALE;
+    }
+}
+/**
+ * The worktree's display name, for the notification title. Falls back to the
+ * id rather than dropping the notification — the same rule
+ * `waiting-push-notifier` applies.
+ */
+function resolveWorktreeName(worktreeId) {
+    try {
+        return (0, worktree_db_1.getWorktreeById)((0, db_instance_1.getDbInstance)(), worktreeId)?.name ?? worktreeId;
+    }
+    catch {
+        return worktreeId;
+    }
+}
+/**
+ * Notify every opted-in device that this instance changed model (Issue #2357).
+ *
+ * States the fact and nothing more — no ranking, no "downgraded", because the
+ * Issue rules that out and because the server has no table that could say
+ * which of two models is the lesser. Never throws; push is advisory and the
+ * edge that called this has already been observed.
+ *
+ * @returns Null when a fan-out was attempted, otherwise why it was not.
+ */
+async function notifyModelChangePush(change) {
+    if (!(0, vapid_1.isPushConfigured)()) {
+        logger.debug('model-change-push-suppressed', {
+            worktreeId: change.worktreeId,
+            instanceId: change.instanceId,
+            reason: 'unconfigured',
+        });
+        return 'unconfigured';
+    }
+    try {
+        await (0, push_sender_1.notifyPushSubscribers)({
+            worktreeId: change.worktreeId,
+            worktreeName: resolveWorktreeName(change.worktreeId),
+            // The delivery bucket, not the meaning — see `NotificationEvent.modelChange`.
+            kind: 'failure',
+            agentName: change.instanceId,
+            instanceId: change.instanceId,
+            modelChange: {
+                from: change.from,
+                to: change.to,
+                body: buildModelChangedBodies(change.from, change.to),
+            },
+        }, change.at);
+        logger.info('model-change-push-raised', {
+            worktreeId: change.worktreeId,
+            instanceId: change.instanceId,
+            from: change.from,
+            to: change.to,
+            source: change.source,
+        });
+    }
+    catch (error) {
+        logger.warn('model-change-push-failed', {
+            worktreeId: change.worktreeId,
+            instanceId: change.instanceId,
+            error: error instanceof Error ? error.message : String(error),
+        });
+    }
+    return null;
+}

package/dist/server/src/lib/push/notification-dedup.js

@@ -20,7 +20,8 @@ exports.resetWaitingPushDedup = resetWaitingPushDedup;
 const crypto_1 = require("crypto");
 /** Default suppression window: repeats of identical content within this are dropped. */
 exports.DEFAULT_DEDUP_WINDOW_MS = 30_000;
-const lastSent = new Map();
+const lastSent = globalThis.__notificationDedupLastSent ??
+    (globalThis.__notificationDedupLastSent = new Map());
 function contentHash(content) {
     return (0, crypto_1.createHash)('sha256').update(content).digest('hex');
 }

package/dist/server/src/lib/push/push-sender.js

@@ -27,6 +27,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.MODEL_CHANGE_TAG_SUFFIX = void 0;
 exports.resolvePushLocale = resolvePushLocale;
 exports.buildExcerpt = buildExcerpt;
 exports.buildPushPayload = buildPushPayload;
@@ -51,6 +52,11 @@ const PUSH_MESSAGES = {
     en: notifications_json_1.default.push,
     ja: notifications_json_2.default.push,
 };
+/**
+ * The `tag` segment a model-change card carries in place of its kind
+ * (Issue #2357). Exported so the notifier's tests can name the card they expect.
+ */
+exports.MODEL_CHANGE_TAG_SUFFIX = 'model';
 /**
  * Narrow a stored subscription locale to one we can actually render.
  * Subscriptions registered before v42 have `locale = NULL` and land on
@@ -147,25 +153,31 @@ function buildPushPayload(event, locale = i18n_config_1.DEFAULT_LOCALE, now = Da
     const excerpt = buildExcerpt(event.excerpt);
     const agentSuffix = event.agentName ? ` (${event.agentName})` : '';
     const title = `${event.worktreeName}${agentSuffix}`;
-    const messages = PUSH_MESSAGES[resolvePushLocale(locale)];
-    const body = event.kind === 'prompt'
-        ? // Issue #2001: the resolution's body replaces the stale card's, so it
-            // has to answer the question that card asked. It quotes no excerpt —
-            // the prompt is over, and repeating it would read as a new one.
-            event.resolved === true
-                ? messages.promptResolved
-                : buildWaitingBody(event, messages, excerpt, now)
-        : event.kind === 'failure'
-            ? buildFailureBody(event, messages, excerpt)
-            : // Issue #2045: an update notice is a completion by *bucket*, not by
-                // content, so it is the one completion whose body is not "Done".
-                event.updateAvailable
-                    ? messages.updateAvailable
-                        .replace('{agent}', event.updateAvailable.agent)
-                        .replace('{version}', event.updateAvailable.version)
-                    : excerpt
-                        ? messages.completionWithExcerpt.replace('{excerpt}', excerpt)
-                        : messages.completion;
+    const resolvedLocale = resolvePushLocale(locale);
+    const messages = PUSH_MESSAGES[resolvedLocale];
+    const body = 
+    // Issue #2357: read first, because the event's `kind` is the bucket it is
+    // delivered to and says nothing about what it is. See `modelChange`.
+    event.modelChange
+        ? event.modelChange.body[resolvedLocale]
+        : event.kind === 'prompt'
+            ? // Issue #2001: the resolution's body replaces the stale card's, so it
+                // has to answer the question that card asked. It quotes no excerpt —
+                // the prompt is over, and repeating it would read as a new one.
+                event.resolved === true
+                    ? messages.promptResolved
+                    : buildWaitingBody(event, messages, excerpt, now)
+            : event.kind === 'failure'
+                ? buildFailureBody(event, messages, excerpt)
+                : // Issue #2045: an update notice is a completion by *bucket*, not by
+                    // content, so it is the one completion whose body is not "Done".
+                    event.updateAvailable
+                        ? messages.updateAvailable
+                            .replace('{agent}', event.updateAvailable.agent)
+                            .replace('{version}', event.updateAvailable.version)
+                        : excerpt
+                            ? messages.completionWithExcerpt.replace('{excerpt}', excerpt)
+                            : messages.completion;
     return {
         kind: event.kind,
         title,
@@ -176,7 +188,12 @@ function buildPushPayload(event, locale = i18n_config_1.DEFAULT_LOCALE, now = Da
         // Unchanged by #1790, and deliberately: the escalation carries the same tag
         // as the notification it follows up, so the Service Worker replaces the
         // stale one instead of stacking a second card for the same wait.
-        tag: `${event.worktreeId}:${event.kind}`,
+        // Issue #2357: a model change gets a tag of its own, so it neither replaces
+        // a failure card (its transport bucket) nor is replaced by one; two changes
+        // of the same worktree do collapse, which is right — the newer is the fact.
+        tag: event.modelChange
+            ? `${event.worktreeId}:${exports.MODEL_CHANGE_TAG_SUFFIX}`
+            : `${event.worktreeId}:${event.kind}`,
         timestamp: now,
         ...(event.waitingKind ? { waitingKind: event.waitingKind } : {}),
         ...(event.resolved === true ? { resolved: true } : {}),
@@ -252,6 +269,17 @@ function passesDedup(event) {
     // uses, so the two would suppress each other on a 30 s window neither wants.
     if (event.resolved === true)
         return true;
+    // Issue #2357: keyed on the transition, not on its wording — the body is
+    // localized per device and the same change must not send twice because two
+    // readers speak different languages. The producer already emits one edge per
+    // transition; this is the second net, on the same 30 s window as the rest.
+    if (event.modelChange) {
+        return (0, notification_dedup_1.shouldSendNotification)({
+            worktreeId: event.worktreeId,
+            kind: event.kind,
+            content: `${exports.MODEL_CHANGE_TAG_SUFFIX}:${event.instanceId ?? event.agentName ?? ''}:${event.modelChange.from}>${event.modelChange.to}`,
+        });
+    }
     if (event.kind === 'prompt' && typeof event.waitingSince === 'number') {
         return (0, notification_dedup_1.shouldSendWaitingPush)({
             worktreeId: event.worktreeId,

package/dist/server/src/lib/realtime/model-change-broadcast.js

@@ -0,0 +1,171 @@
+"use strict";
+/**
+ * What happens when an agent instance changes model (Issue #2357).
+ *
+ * ## The edge, and its three receivers
+ *
+ * `agent-event-state` judges the model edge — the merged hook/frame value moving
+ * from one model to another, with the first sighting, the value going quiet
+ * and a spelling change all ruled out there — and hands it out through
+ * `onAgentModelChange`. This module is that subscription, and it is the ONE
+ * subscription: the three things the Issue asks for on the receiving side are
+ * fanned out from here, in the order that leaves the most durable trace first.
+ *
+ *  1. **The history row.** One assistant row in `chat_messages`, in the
+ *     readers' language, so the chat transcript and the History tab both keep
+ *     "the model changed from A to B" where the conversation is. Written
+ *     first, because it is the receiver that survives a phone being off.
+ *  2. **The room frames.** The row is pushed as a `message` frame — the same
+ *     frame `sendUserMessage` publishes — so a transcript that is open shows
+ *     the line without waiting for its poll; then the `model_changed` frame
+ *     itself, which is what the phone's session row turns amber on.
+ *  3. **The push.** `notifyModelChangePush`, fire-and-forget; it has its own
+ *     dedup and its own logging.
+ *
+ * Each receiver is wrapped separately: a database that cannot be written must
+ * not cost the reader the socket frame, and a socket with no owner must not
+ * cost them the push.
+ *
+ * ## Why `publish` is injected, and who arms this
+ *
+ * The same shape as `waiting-broadcast`, and armed by it: `ws-server` owns the
+ * rooms and calls `startWaitingStatusBroadcast(handleBroadcast)` from
+ * `setupWebSocket`, which is the one place in the process that knows which
+ * bundle's `rooms` a frame has to reach. That call now arms this subscription
+ * too, with the same publisher, and `stopWaitingStatusBroadcast` (from
+ * `closeWebSocket`) disarms both — so the listener's lifetime is the server's,
+ * and a suite that stands a server up and tears it down leaves nothing pointed
+ * at a dead room map.
+ *
+ * ## Authorization
+ *
+ * None is bypassed: the publisher is the room broadcaster, and a socket only
+ * joins a room through the authenticated `subscribe` path.
+ *
+ * @module lib/realtime/model-change-broadcast
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildModelChangedEvent = buildModelChangedEvent;
+exports.handleAgentModelChange = handleAgentModelChange;
+exports.startModelChangeBroadcast = startModelChangeBroadcast;
+exports.stopModelChangeBroadcast = stopModelChangeBroadcast;
+exports.isModelChangeBroadcastActive = isModelChangeBroadcastActive;
+const db_instance_1 = require("../../lib/db/db-instance");
+const chat_db_1 = require("../../lib/db/chat-db");
+const logger_1 = require("../../lib/logger");
+const model_change_push_notifier_1 = require("../../lib/push/model-change-push-notifier");
+const types_1 = require("../../lib/realtime/types");
+const agent_event_state_1 = require("../../lib/session/agent-event-state");
+const logger = (0, logger_1.createLogger)('model-change-broadcast');
+/**
+ * Translate a model edge into the frame clients receive.
+ *
+ * Field for field the producer's record; `instance` is already resolved there
+ * (`instanceId ?? cliToolId`), so a client can match it against its own pane
+ * without re-deriving the convention.
+ */
+function buildModelChangedEvent(change) {
+    return {
+        type: types_1.MODEL_CHANGED_EVENT_TYPE,
+        worktreeId: change.worktreeId,
+        cliTool: change.cliToolId,
+        instance: change.instanceId,
+        from: change.from,
+        to: change.to,
+        source: change.source,
+        at: change.at,
+    };
+}
+/**
+ * Write the history row and hand back the `message` frame for it, or null
+ * when the database could not take it.
+ *
+ * Never throws. The sentence is localized once, for the readers' registered
+ * language (`resolveReadersLocale`) — a stored row cannot be re-rendered per
+ * viewer the way the push body is.
+ */
+function recordModelChangeHistory(change) {
+    try {
+        const db = (0, db_instance_1.getDbInstance)();
+        const locale = (0, model_change_push_notifier_1.resolveReadersLocale)(db);
+        const message = (0, chat_db_1.createModelChangeMessage)(db, {
+            worktreeId: change.worktreeId,
+            cliToolId: change.cliToolId,
+            instanceId: change.instanceId,
+            content: (0, model_change_push_notifier_1.buildModelChangedSentence)(locale, change.from, change.to),
+            at: change.at,
+        });
+        return { type: 'message', worktreeId: change.worktreeId, message };
+    }
+    catch (error) {
+        logger.warn('model-change-history-failed', {
+            worktreeId: change.worktreeId,
+            instanceId: change.instanceId,
+            error: error instanceof Error ? error.message : String(error),
+        });
+        return null;
+    }
+}
+/**
+ * Deliver one edge to all three receivers. Exported so a suite can drive the
+ * fan-out without a live subscription; never throws.
+ */
+function handleAgentModelChange(change, publish) {
+    logger.info('model-changed', {
+        worktreeId: change.worktreeId,
+        cliToolId: change.cliToolId,
+        instanceId: change.instanceId,
+        from: change.from,
+        to: change.to,
+        source: change.source,
+    });
+    const messageFrame = recordModelChangeHistory(change);
+    try {
+        if (messageFrame)
+            publish(change.worktreeId, messageFrame);
+        publish(change.worktreeId, buildModelChangedEvent(change));
+    }
+    catch (error) {
+        logger.warn('model-change-broadcast-failed', {
+            worktreeId: change.worktreeId,
+            instanceId: change.instanceId,
+            error: error instanceof Error ? error.message : String(error),
+        });
+    }
+    // Fire-and-forget: `notifyModelChangePush` contains its own failures and
+    // logs its own decision, and nothing here has anything to do with the result.
+    void (0, model_change_push_notifier_1.notifyModelChangePush)(change);
+}
+/**
+ * Subscribe to the model edge and fan it out.
+ *
+ * Idempotent: calling it again replaces the previous subscription rather than
+ * adding a second one, so a re-entered `setupWebSocket` cannot double-send.
+ *
+ * @param publish - Room broadcaster, normally `ws-server`'s internal one.
+ * @returns The unsubscribe function (also reachable as
+ *   {@link stopModelChangeBroadcast}).
+ */
+function startModelChangeBroadcast(publish) {
+    stopModelChangeBroadcast();
+    const unsubscribe = (0, agent_event_state_1.onAgentModelChange)((change) => {
+        handleAgentModelChange(change, publish);
+    });
+    globalThis.__modelChangeBroadcastUnsubscribe = unsubscribe;
+    return unsubscribe;
+}
+/**
+ * Drop the subscription, if any. Safe to call when none is active — and called
+ * from `stopWaitingStatusBroadcast`, i.e. from `closeWebSocket`.
+ */
+function stopModelChangeBroadcast() {
+    const existing = globalThis.__modelChangeBroadcastUnsubscribe;
+    if (existing) {
+        existing();
+        globalThis.__modelChangeBroadcastUnsubscribe = undefined;
+    }
+}
+/** Whether a subscription is currently active. Test seam. */
+function isModelChangeBroadcastActive() {
+    return globalThis.__modelChangeBroadcastUnsubscribe !== undefined;
+}

package/dist/server/src/lib/realtime/types.js

@@ -9,7 +9,7 @@
  * the canonical {@link RealtimeEvent}.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MESSAGES_INVALIDATED_EVENT_TYPE = exports.MAX_CHAT_TURN_PROGRESS_BODY_LENGTH = exports.CHAT_TURN_PROGRESS_MIN_INTERVAL_MS = exports.CHAT_TURN_PROGRESS_EVENT_TYPE = exports.VERSION_MISMATCH_EVENT_TYPE = exports.CLIENT_VERSION_MESSAGE_TYPE = void 0;
+exports.MODEL_CHANGED_EVENT_TYPE = exports.MESSAGES_INVALIDATED_EVENT_TYPE = exports.MAX_CHAT_TURN_PROGRESS_BODY_LENGTH = exports.CHAT_TURN_PROGRESS_MIN_INTERVAL_MS = exports.CHAT_TURN_PROGRESS_EVENT_TYPE = exports.VERSION_MISMATCH_EVENT_TYPE = exports.CLIENT_VERSION_MESSAGE_TYPE = void 0;
 exports.isVersionMismatch = isVersionMismatch;
 exports.truncateChatTurnProgressBody = truncateChatTurnProgressBody;
 exports.parseRealtimeEvent = parseRealtimeEvent;
@@ -143,6 +143,24 @@ function truncateChatTurnProgressBody(body, maxLength = exports.MAX_CHAT_TURN_PR
  * an omitted field would simply never match.
  */
 exports.MESSAGES_INVALIDATED_EVENT_TYPE = 'messages_invalidated';
+/**
+ * "This instance is now on a different model" (Issue #2357).
+ *
+ * Emitted once per transition from `agent-event-state`'s model edge, on the
+ * same room broadcast `session_status_changed` rides — so every client that
+ * subscribed to the worktree hears it, and one that never subscribed does not.
+ * It is its own type rather than a field on `session_status_changed` because
+ * the consumers do not overlap: the phone's session row is the only thing that
+ * reacts, and every `session_status_changed` listener would otherwise have to
+ * learn to ignore it.
+ *
+ * `from` and `to` are the resolved values `sessionStatusByInstance[].model`
+ * publishes, verbatim — the client shows them, it does not compare them. The
+ * suppression rules (`null → value`, `value → null`, a first sighting, a
+ * spelling change) are applied by the producer, and there is nothing here for
+ * a client to re-judge.
+ */
+exports.MODEL_CHANGED_EVENT_TYPE = 'model_changed';
 /**
  * Parse a raw WebSocket frame into the inner realtime event.
  *

package/dist/server/src/lib/realtime/waiting-broadcast.js

@@ -37,6 +37,7 @@ exports.buildWaitingStatusEvent = buildWaitingStatusEvent;
 exports.startWaitingStatusBroadcast = startWaitingStatusBroadcast;
 exports.stopWaitingStatusBroadcast = stopWaitingStatusBroadcast;
 exports.isWaitingStatusBroadcastActive = isWaitingStatusBroadcastActive;
+const model_change_broadcast_1 = require("../../lib/realtime/model-change-broadcast");
 const waiting_episode_state_1 = require("../../lib/session/waiting-episode-state");
 /**
  * Translate a waiting crossing into the frame clients receive.
@@ -63,6 +64,14 @@ function buildWaitingStatusEvent(transition) {
  * Idempotent: calling it again replaces the previous subscription rather than
  * adding a second one, so a re-entered `setupWebSocket` cannot double-send.
  *
+ * Issue #2357: this is also where the model edge is armed. `setupWebSocket`
+ * calls exactly one function to start the edge → room subscriptions, and it
+ * is this one; the model-change fan-out (`model-change-broadcast`) needs the
+ * same publisher for the same reason the waiting edge does — the closure has
+ * to hold the bundle's own `rooms` — so it is started here with it, and
+ * stopped with it below, rather than growing a second arming call in
+ * `ws-server` for every edge that comes along.
+ *
  * @param publish - Room broadcaster, normally `ws-server`'s internal one.
  * @returns The unsubscribe function (also reachable as
  *   {@link stopWaitingStatusBroadcast}).
@@ -73,12 +82,15 @@ function startWaitingStatusBroadcast(publish) {
         publish(transition.worktreeId, buildWaitingStatusEvent(transition));
     });
     globalThis.__waitingStatusBroadcastUnsubscribe = unsubscribe;
+    (0, model_change_broadcast_1.startModelChangeBroadcast)(publish);
     return unsubscribe;
 }
 /**
  * Drop the subscription, if any. Safe to call when none is active — and called
  * from `closeWebSocket`, so a suite that stands a server up and tears it down
  * does not leave a listener pointed at a dead room map.
+ *
+ * Issue #2357: drops the model edge's subscription with it, for the same reason.
  */
 function stopWaitingStatusBroadcast() {
     const existing = globalThis.__waitingStatusBroadcastUnsubscribe;
@@ -86,6 +98,7 @@ function stopWaitingStatusBroadcast() {
         existing();
         globalThis.__waitingStatusBroadcastUnsubscribe = undefined;
     }
+    (0, model_change_broadcast_1.stopModelChangeBroadcast)();
 }
 /** Whether a subscription is currently active. Test seam. */
 function isWaitingStatusBroadcastActive() {