rivet-design 0.11.11 → 0.11.13

package/dist/services/SessionBridgeService.js

@@ -1,9 +1,37 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SessionBridgeService = void 0;
+exports.SessionBridgeService = exports.MAX_APPLY_BATCH_BYTES = exports.MAX_VARIANT_REQUEST_BYTES = exports.MAX_LEASED_VARIANT_BATCHES = exports.MAX_PENDING_APPLY_BATCHES = exports.MAX_PENDING_VARIANT_REQUESTS = void 0;
 const crypto_1 = require("crypto");
 const index_core_1 = require("../index-core");
+const changeBatchClassification_1 = require("../mcp/changeBatchClassification");
+const BridgeBatchPipeline_1 = require("./BridgeBatchPipeline");
+const BridgeQueueStore_1 = require("./BridgeQueueStore");
 const log = (0, index_core_1.createLogger)('SessionBridgeService');
+/**
+ * Upper bound on the variant-request FIFO depth. The queue intentionally
+ * appends (never clobbers) so concurrent "Vary" runs aren't dropped, but
+ * without a cap a caller hitting the unauthenticated queue endpoint could
+ * append unboundedly and exhaust server memory. 16 is far above any real
+ * concurrent-Vary workload; past it we reject with backpressure (HTTP 429)
+ * so the request surfaces as an error the user can retry, rather than being
+ * silently dropped or growing the queue.
+ */
+exports.MAX_PENDING_VARIANT_REQUESTS = 16;
+/** FIFO depth cap for apply batches (was a single overwrite slot). */
+exports.MAX_PENDING_APPLY_BATCHES = 16;
+/** Maximum concurrent variant batches leased to agents/watchers. */
+exports.MAX_LEASED_VARIANT_BATCHES = 4;
+/**
+ * Per-batch byte budget for a queued variant-request/refine batch. The count
+ * cap above bounds HOW MANY batches queue; this bounds how BIG one can be. The
+ * route schema already caps attached images, but `instruction` / `sourceFiles`
+ * / element metadata are otherwise bounded only by the (much larger) HTTP body
+ * limit — so without this a local/LAN caller could pin memory with a few large
+ * batches × the FIFO depth. ~2MB of non-image text/metadata is generous.
+ */
+exports.MAX_VARIANT_REQUEST_BYTES = 2 * 1024 * 1024;
+/** Same per-batch byte cap for apply batches queued on the apply FIFO. */
+exports.MAX_APPLY_BATCH_BYTES = exports.MAX_VARIANT_REQUEST_BYTES;
 /**
  * Manages the lifecycle of an MCP visual editing session and queues
  * changes between the Rivet UI and the MCP server.
@@ -18,12 +46,35 @@ class SessionBridgeService {
     _isVariantPortAllowed = null;
     statusAccessToken = null;
     projectPath = null;
-    pendingChanges = null;
+    applyPipeline = new BridgeBatchPipeline_1.BridgeBatchPipeline({
+        kind: 'apply',
+        maxQueued: exports.MAX_PENDING_APPLY_BATCHES,
+        maxConcurrentLeases: 1,
+        queueFullReason: 'apply_queue_full',
+    });
+    variantPipeline = new BridgeBatchPipeline_1.BridgeBatchPipeline({
+        kind: 'variant',
+        maxQueued: exports.MAX_PENDING_VARIANT_REQUESTS,
+        maxConcurrentLeases: exports.MAX_LEASED_VARIANT_BATCHES,
+        queueFullReason: 'variant_queue_full',
+    });
     telemetryContext = null;
     roundsCompleted = 0;
     feedback = [];
     status = 'IDLE';
-    waitResolve = null;
+    // Blocking watch_for_changes waiters, FIFO. A multi-element queue (not a
+    // single slot) so several concurrent watchers can each block and each wake on
+    // a DIFFERENT queued change — one change wakes one waiter — letting parallel
+    // agents pick up distinct batches instead of clobbering each other's waiter.
+    waitResolvers = [];
+    /**
+     * Subscribers notified whenever {@link WatcherLiveness} could have changed
+     * (queue/drain/waiter register/settle). The variants SSE stream subscribes so
+     * a strand the user causes — sending a change with no watcher draining it —
+     * re-pushes the snapshot promptly instead of waiting on the next orchestrator
+     * event, which a stranded queue never produces.
+     */
+    livenessListeners = new Set();
     activeRunCorrelation = null;
     baseDevServerHealth = null;
     devServerHealth = {
@@ -46,9 +97,28 @@ class SessionBridgeService {
         }
         this.sessionId = (0, crypto_1.randomUUID)();
         this.projectPath = projectPath;
-        this.pendingChanges = null;
+        this.applyPipeline = new BridgeBatchPipeline_1.BridgeBatchPipeline({
+            kind: 'apply',
+            maxQueued: exports.MAX_PENDING_APPLY_BATCHES,
+            maxConcurrentLeases: 1,
+            queueFullReason: 'apply_queue_full',
+        });
+        this.variantPipeline = new BridgeBatchPipeline_1.BridgeBatchPipeline({
+            kind: 'variant',
+            maxQueued: exports.MAX_PENDING_VARIANT_REQUESTS,
+            maxConcurrentLeases: exports.MAX_LEASED_VARIANT_BATCHES,
+            queueFullReason: 'variant_queue_full',
+        });
+        const persisted = BridgeQueueStore_1.bridgeQueueStore.load(projectPath, this.sessionId);
+        if (persisted) {
+            this.applyPipeline.hydrate(persisted.apply);
+            this.variantPipeline.hydrate(persisted.variant);
+            this.roundsCompleted = persisted.roundsCompleted;
+        }
+        else {
+            this.roundsCompleted = 0;
+        }
         this.telemetryContext = null;
-        this.roundsCompleted = 0;
         this.feedback = [];
         this.status = 'IDLE';
         this.activeRunCorrelation = null;
@@ -66,8 +136,32 @@ class SessionBridgeService {
             startedByRivet: false,
         };
         log.info(`Session started: ${this.sessionId} for ${projectPath}`);
+        this.persistQueue();
+        this.notifyLivenessChange();
         return this.sessionId;
     }
+    /** Write the current queue snapshot to disk for MCP restart recovery. */
+    persistQueue() {
+        if (!this.sessionId || !this.projectPath) {
+            return;
+        }
+        BridgeQueueStore_1.bridgeQueueStore.save(this.projectPath, this.sessionId, {
+            ...(0, BridgeQueueStore_1.emptyBridgeQueueSnapshot)(this.projectPath),
+            apply: this.applyPipeline.snapshot(),
+            variant: this.variantPipeline.snapshot(),
+            roundsCompleted: this.roundsCompleted,
+            updatedAt: Date.now(),
+        });
+    }
+    buildQueuedBatch(intent) {
+        const requestId = intent.agentRunId ?? intent.traceId ?? (0, crypto_1.randomUUID)();
+        return {
+            intent,
+            enqueuedAt: Date.now(),
+            leaseId: (0, crypto_1.randomUUID)(),
+            requestId,
+        };
+    }
     /**
      * Add a feedback message to the session.
      * Feedback is shown in the Rivet UI to let the user know what the MCP client is doing.
@@ -127,30 +221,162 @@ class SessionBridgeService {
     }
     /**
      * Queue changes from the Rivet UI for retrieval by the MCP client.
-     * Replaces any previously queued intent that hasn't been retrieved yet.
+     * Each send appends to the apply or variant FIFO (never overwrites).
      */
     queueChangeRequest(intent) {
         if (!this.sessionId) {
             log.warn('Cannot queue changes: no active session');
-            return;
+            return { accepted: true };
         }
-        // Clear feedback from previous round when a new round starts
         this.feedback = [];
-        this.pendingChanges = intent;
         this.updateTelemetryContext(intent.telemetryContext);
-        log.info(`Change request queued (Round ${this.roundsCompleted + 1}): ${intent.changes.length} changes, ${intent.sourceFiles.length} source files`);
-        // Wake up any blocking watch_for_changes call
-        if (this.waitResolve) {
-            this.waitResolve(intent);
-            this.waitResolve = null;
+        let enqueueResult;
+        if (!(0, changeBatchClassification_1.isMixedVariantBatch)(intent) &&
+            ((0, changeBatchClassification_1.isSingleVariantRequestBatch)(intent) || (0, changeBatchClassification_1.isStaticPreviewRefineBatch)(intent))) {
+            const approxBytes = Buffer.byteLength(JSON.stringify(intent));
+            if (approxBytes > exports.MAX_VARIANT_REQUEST_BYTES) {
+                log.warn(`Variant-request batch too large (${approxBytes} bytes > ${exports.MAX_VARIANT_REQUEST_BYTES}); rejecting`);
+                return { accepted: false, reason: 'variant_request_too_large' };
+            }
+            enqueueResult = this.variantPipeline.enqueue(this.buildQueuedBatch(intent));
+            if (enqueueResult.accepted) {
+                log.info(`Variant-request batch queued (${this.variantPipeline.queuedDepth()} pending): ${intent.changes.length} changes`);
+            }
+            else {
+                log.warn(`Variant-request queue full (${exports.MAX_PENDING_VARIANT_REQUESTS} pending); rejecting new batch`);
+            }
+        }
+        else {
+            const approxBytes = Buffer.byteLength(JSON.stringify(intent));
+            if (approxBytes > exports.MAX_APPLY_BATCH_BYTES) {
+                log.warn(`Apply batch too large (${approxBytes} bytes > ${exports.MAX_APPLY_BATCH_BYTES}); rejecting`);
+                return { accepted: false, reason: 'apply_batch_too_large' };
+            }
+            enqueueResult = this.applyPipeline.enqueue(this.buildQueuedBatch(intent));
+            if (enqueueResult.accepted) {
+                log.info(`Change request queued (Round ${this.roundsCompleted + 1}): ${intent.changes.length} changes, ${intent.sourceFiles.length} source files`);
+            }
+            else {
+                log.warn(`Apply queue full (${exports.MAX_PENDING_APPLY_BATCHES} pending); rejecting new batch`);
+            }
         }
+        if (!enqueueResult.accepted) {
+            return enqueueResult;
+        }
+        this.persistQueue();
+        const waiter = this.waitResolvers.shift();
+        if (waiter)
+            waiter(intent);
+        this.notifyLivenessChange();
+        return { accepted: true };
     }
     /**
-     * Retrieve pending changes, or null if none is queued.
-     * Does NOT clear the queue — call clearPending() after processing.
+     * Retrieve the oldest queued apply batch intent without leasing it.
      */
     getPendingChanges() {
-        return this.pendingChanges;
+        return this.applyPipeline.peekHeadIntent();
+    }
+    /** True when one or more variant-request/refine batches are queued or leased. */
+    hasPendingVariantRequests() {
+        return this.variantPipeline.hasWork();
+    }
+    /** Queued variant batches still waiting for lease pickup. */
+    pendingVariantRequestCount() {
+        return this.variantPipeline.queuedDepth();
+    }
+    /** Non-destructive snapshot of queued variant-request/refine batches. */
+    peekVariantRequests() {
+        return this.variantPipeline.peekQueuedIntents();
+    }
+    /**
+     * Lease the oldest eligible batch across apply and variant channels.
+     * Global FIFO uses oldest `enqueuedAt` among channels that can lease.
+     */
+    leaseBatch(requestId) {
+        if (requestId) {
+            const applyLease = this.applyPipeline.leaseNext(requestId);
+            if (applyLease) {
+                this.persistQueue();
+                this.notifyLivenessChange();
+                return applyLease;
+            }
+            const variantLease = this.variantPipeline.leaseNext(requestId);
+            if (variantLease) {
+                this.persistQueue();
+                this.notifyLivenessChange();
+                return variantLease;
+            }
+            return null;
+        }
+        const candidates = [];
+        const applyHeadAt = this.applyPipeline.oldestQueuedEnqueuedAt();
+        if (this.applyPipeline.canLease() && applyHeadAt !== null) {
+            candidates.push({ kind: 'apply', enqueuedAt: applyHeadAt });
+        }
+        const variantHeadAt = this.variantPipeline.oldestQueuedEnqueuedAt();
+        if (this.variantPipeline.canLease() && variantHeadAt !== null) {
+            candidates.push({ kind: 'variant', enqueuedAt: variantHeadAt });
+        }
+        if (candidates.length === 0) {
+            return null;
+        }
+        candidates.sort((a, b) => a.enqueuedAt - b.enqueuedAt);
+        const head = candidates[0];
+        const lease = head.kind === 'apply'
+            ? this.applyPipeline.leaseNext()
+            : this.variantPipeline.leaseNext();
+        if (lease) {
+            this.persistQueue();
+            this.notifyLivenessChange();
+        }
+        return lease;
+    }
+    /**
+     * Release a leased batch after the agent completes work (`refresh_git` or `ack_batch`).
+     */
+    ackBatch(params) {
+        if (this.applyPipeline.findLease(params.leaseId)) {
+            const hadLease = Boolean(this.applyPipeline.findLease(params.leaseId));
+            const result = this.applyPipeline.ack(params);
+            if (hadLease) {
+                this.roundsCompleted += 1;
+            }
+            this.persistQueue();
+            this.notifyLivenessChange();
+            const applyAck = { ...result, kind: 'apply' };
+            return applyAck;
+        }
+        if (this.variantPipeline.findLease(params.leaseId)) {
+            const result = this.variantPipeline.ack(params);
+            this.persistQueue();
+            this.notifyLivenessChange();
+            const variantAck = { ...result, kind: 'variant' };
+            return variantAck;
+        }
+        return { acked: true, mergedRequestIds: [] };
+    }
+    /** True when either channel has queued or in-flight leased work. */
+    hasUnfinishedWork() {
+        return this.applyPipeline.hasWork() || this.variantPipeline.hasWork();
+    }
+    /** Queue and leased depth for one channel (status API). */
+    getChannelDepth(kind) {
+        const pipeline = kind === 'apply' ? this.applyPipeline : this.variantPipeline;
+        return {
+            queued: pipeline.queuedDepth(),
+            leased: pipeline.leasedDepth(),
+        };
+    }
+    /** @deprecated Use {@link ackBatch} after the agent completes a leased apply batch. */
+    shiftVariantRequest() {
+        const lease = this.variantPipeline.leaseNext();
+        if (!lease) {
+            return null;
+        }
+        this.variantPipeline.ack({ leaseId: lease.leaseId, requestId: lease.requestId });
+        this.persistQueue();
+        this.notifyLivenessChange();
+        return lease.intent;
     }
     /**
      * Block until changes are queued, or return immediately if already pending.
@@ -158,89 +384,115 @@ class SessionBridgeService {
      * Rejects if the timeout is reached.
      */
     waitForChanges(timeoutMs = 300_000) {
-        if (this.pendingChanges) {
-            return Promise.resolve(this.pendingChanges);
+        const existing = this.applyPipeline.peekHeadIntent() ??
+            this.variantPipeline.peekHeadIntent();
+        if (existing) {
+            return Promise.resolve(existing);
         }
         return new Promise((resolve, reject) => {
-            const timer = setTimeout(() => {
-                this.waitResolve = null;
-                reject(new Error('Timed out waiting for design changes'));
-            }, timeoutMs);
-            this.waitResolve = (intent) => {
+            const resolver = (intent) => {
                 clearTimeout(timer);
                 resolve(intent);
             };
+            const timer = setTimeout(() => {
+                const idx = this.waitResolvers.indexOf(resolver);
+                if (idx !== -1)
+                    this.waitResolvers.splice(idx, 1);
+                this.notifyLivenessChange();
+                reject(new Error('Timed out waiting for design changes'));
+            }, timeoutMs);
+            this.waitResolvers.push(resolver);
+            this.notifyLivenessChange();
         });
     }
     /**
-     * Clear the pending changes queue and increment the round counter.
-     * Call after the MCP client has retrieved and processed the intent.
+     * Ack the active apply lease after processing (legacy alias for tests).
      */
     clearPending(expectedIntent) {
-        if (expectedIntent && this.pendingChanges !== expectedIntent) {
+        const snapshot = this.applyPipeline.snapshot();
+        const activeLease = snapshot.leased[0];
+        if (activeLease) {
+            if (expectedIntent && activeLease.intent !== expectedIntent) {
+                log.info('Pending intent changed while processing; preserving newer intent');
+                return;
+            }
+            this.ackBatch({
+                leaseId: activeLease.leaseId,
+                requestId: activeLease.requestId,
+            });
+            log.info(`Pending intent cleared, round ${this.roundsCompleted} complete`);
+            return;
+        }
+        const head = this.applyPipeline.peekHeadIntent();
+        if (!head) {
+            return;
+        }
+        if (expectedIntent && head !== expectedIntent) {
             log.info('Pending intent changed while processing; preserving newer intent');
             return;
         }
-        if (this.pendingChanges) {
-            this.roundsCompleted++;
-            this.pendingChanges = null;
+        const lease = this.applyPipeline.leaseNext();
+        if (lease) {
+            this.ackBatch({ leaseId: lease.leaseId, requestId: lease.requestId });
             log.info(`Pending intent cleared, round ${this.roundsCompleted} complete`);
         }
     }
-    /**
-     * Consume a single-item variant-request batch from the pending queue.
-     *
-     * Variant-request batches are not "applied" — they are routed into the MCP
-     * variants lifecycle (propose_variants → approval → continue → commit). They
-     * must NOT call startApplyingRun, must NOT fire trackChangesQueued /
-     * trackAgentRunStarted, and must NOT increment the apply-run round counter.
-     *
-     * Returns the consumed intent so callers can derive the agent's
-     * propose_variants target from it.
-     */
+    /** @deprecated Leased batches are released via {@link ackBatch}. */
     consumeVariantRequestBatch(expectedIntent) {
-        const intent = this.pendingChanges;
-        if (!intent)
-            return null;
-        if (expectedIntent && intent !== expectedIntent) {
-            log.info('Pending intent changed while consuming variant request; preserving newer intent');
+        const lease = expectedIntent
+            ? this.findVariantLeaseForIntent(expectedIntent)
+            : this.variantPipeline.leaseNext();
+        if (!lease) {
             return null;
         }
-        this.pendingChanges = null;
-        // Wake any blocking watch_for_changes caller that hasn't returned yet,
-        // mirroring the queue/wake symmetry of queueChangeRequest. (Defensive:
-        // the consume path is normally reached from a watch_for_changes caller
-        // that has already resolved; this is a no-op in that case.)
-        this.waitResolve = null;
-        log.info(`Variant-request batch consumed (no apply run started, ${intent.changes.length} items)`);
-        return intent;
+        log.info(`variant-request batch consumed (no apply run started, ${lease.intent.changes.length} items)`);
+        return lease.intent;
     }
-    /**
-     * Consume a static-preview refinement batch from the pending queue.
-     *
-     * These batches refine an in-memory HTML variant through the variants MCP
-     * lifecycle. They must not start a base project apply run or increment the
-     * apply-round counter.
-     */
+    /** @deprecated Leased batches are released via {@link ackBatch}. */
     consumeStaticPreviewRefineBatch(expectedIntent) {
-        const intent = this.pendingChanges;
-        if (!intent)
-            return null;
-        if (expectedIntent && intent !== expectedIntent) {
-            log.info('Pending intent changed while consuming static-preview refine request; preserving newer intent');
+        const lease = expectedIntent
+            ? this.findVariantLeaseForIntent(expectedIntent)
+            : this.variantPipeline.leaseNext();
+        if (!lease) {
             return null;
         }
-        this.pendingChanges = null;
-        this.waitResolve = null;
-        log.info(`Static-preview refine batch consumed (no apply run started, ${intent.changes.length} items)`);
-        return intent;
+        log.info(`static-preview refine batch consumed (no apply run started, ${lease.intent.changes.length} items)`);
+        return lease.intent;
+    }
+    findVariantLeaseForIntent(expectedIntent) {
+        const requestId = expectedIntent.agentRunId ?? expectedIntent.traceId;
+        if (requestId) {
+            const existing = this.variantPipeline.leaseNext(requestId);
+            if (existing) {
+                return existing;
+            }
+            const leased = this.variantPipeline.leaseQueuedRequestId(requestId);
+            if (leased) {
+                this.persistQueue();
+                this.notifyLivenessChange();
+                return leased;
+            }
+        }
+        else {
+            const head = this.variantPipeline.peekHeadIntent();
+            if (head === expectedIntent) {
+                const leased = this.variantPipeline.leaseNext();
+                if (leased) {
+                    this.persistQueue();
+                    this.notifyLivenessChange();
+                    return leased;
+                }
+            }
+        }
+        log.info('Pending variant batch no longer queued (already consumed/superseded)');
+        return null;
     }
     /**
      * Remove variant-request comment items from a mixed pending batch while
      * preserving all non-variant items for a follow-up apply run.
      */
     rejectMixedVariantRequestBatch(expectedIntent) {
-        const intent = this.pendingChanges;
+        const intent = this.applyPipeline.peekHeadIntent();
         if (!intent)
             return null;
         if (expectedIntent && intent !== expectedIntent) {
@@ -253,17 +505,21 @@ class SessionBridgeService {
             return intent;
         }
         if (nextChanges.length === 0) {
-            this.pendingChanges = null;
-            this.waitResolve = null;
+            this.applyPipeline.replaceHeadQueuedBatch(null);
             log.info('Mixed variant batch rejection removed all pending changes');
+            this.persistQueue();
+            this.notifyLivenessChange();
             return null;
         }
-        this.pendingChanges = {
+        const preserved = {
             ...intent,
             changes: nextChanges,
         };
+        this.applyPipeline.replaceHeadQueuedBatch(preserved);
         log.info(`Mixed variant batch rejected; preserved ${nextChanges.length} non-variant items`);
-        return this.pendingChanges;
+        this.persistQueue();
+        this.notifyLivenessChange();
+        return preserved;
     }
     /**
      * Mark the currently processing MCP apply run using identifiers from the queued request.
@@ -291,6 +547,11 @@ class SessionBridgeService {
         this.activeRunCorrelation = null;
         return correlation;
     }
+    /** Active apply lease, if any (at most one). */
+    findActiveApplyLease() {
+        const leased = this.applyPipeline.snapshot().leased;
+        return leased[0] ?? null;
+    }
     /** Get the number of completed editing rounds in this session */
     getRoundsCompleted() {
         return this.roundsCompleted;
@@ -385,12 +646,11 @@ class SessionBridgeService {
      * preview) on `devServerHealth` so `/api/mcp/status` and the iframe's
      * `usePreviewUpstreamHealth` probe see `ownership: 'rivet_owned'` + the
      * new port. Pass `null` to clear back to the no-server state. Distinct
-     * from `switchPreviewPort` (which only retargets the proxy) and from
+     * from `switchPreviewPort` (which temporarily retargets health while a
+     * variant preview is active, then restores `baseDevServerHealth`) and from
      * `setDevServerContext` (which the MCP server uses for the user's own
      * dev server during a regular session). Only the orchestrator's
-     * commit-handoff path should call this — variant cycling and cancel
-     * still go through `switchPreviewPort` and must NOT touch the user's
-     * external dev-server health.
+     * commit-handoff path should call this.
      */
     setCommittedDevServerHealth(port) {
         if (port === null) {
@@ -412,7 +672,7 @@ class SessionBridgeService {
         const committedDevServerHealth = {
             ...this.devServerHealth,
             ownership: 'rivet_owned',
-            host: '127.0.0.1',
+            host: 'localhost',
             port,
             isReachable: true,
             reason: 'healthy',
@@ -431,6 +691,24 @@ class SessionBridgeService {
             log.info(`switchPreviewPort → ${port === null ? 'default upstream' : `localhost:${port}`}`);
         }
         this._setVariantTarget?.(port);
+        if (port !== null) {
+            // Retarget `/api/mcp/status` upstream probes to the active variant dev
+            // server. The proxy already serves this port; without this, health keeps
+            // checking the (possibly dead) base external port and the iframe shows
+            // "Preview isn't connected" while variant previews are live.
+            this.devServerHealth = {
+                ownership: 'rivet_owned',
+                host: 'localhost',
+                port,
+                isReachable: true,
+                reason: 'healthy',
+                lastCheckedAt: Date.now(),
+                startedByRivet: true,
+            };
+        }
+        else if (this.baseDevServerHealth) {
+            this.devServerHealth = { ...this.baseDevServerHealth };
+        }
         this.reportFeedback('__RIVET_RELOAD_PREVIEW__');
     }
     /**
@@ -440,11 +718,22 @@ class SessionBridgeService {
     endSession() {
         const rounds = this.roundsCompleted;
         const id = this.sessionId;
-        // Cancel any blocking wait
-        this.waitResolve = null;
+        const projectPath = this.projectPath;
+        this.waitResolvers = [];
         this.sessionId = null;
         this.projectPath = null;
-        this.pendingChanges = null;
+        this.applyPipeline = new BridgeBatchPipeline_1.BridgeBatchPipeline({
+            kind: 'apply',
+            maxQueued: exports.MAX_PENDING_APPLY_BATCHES,
+            maxConcurrentLeases: 1,
+            queueFullReason: 'apply_queue_full',
+        });
+        this.variantPipeline = new BridgeBatchPipeline_1.BridgeBatchPipeline({
+            kind: 'variant',
+            maxQueued: exports.MAX_PENDING_VARIANT_REQUESTS,
+            maxConcurrentLeases: exports.MAX_LEASED_VARIANT_BATCHES,
+            queueFullReason: 'variant_queue_full',
+        });
         this.telemetryContext = null;
         this.roundsCompleted = 0;
         this.feedback = [];
@@ -462,9 +751,65 @@ class SessionBridgeService {
             lastCheckedAt: null,
             startedByRivet: false,
         };
+        if (id && projectPath) {
+            BridgeQueueStore_1.bridgeQueueStore.delete(projectPath, id);
+        }
         log.info(`Session ended: ${id}, ${rounds} rounds completed`);
+        this.notifyLivenessChange();
         return rounds;
     }
+    /**
+     * Snapshot the real liveness of the change pipeline for stale-watcher
+     * detection. `watcherActive` reflects a registered `watch_for_changes` waiter,
+     * NOT channel silence; `oldestPendingChangeAgeMs` is measured against `now`
+     * (injectable for tests) so a healthy long-poll can never look stuck — only
+     * genuinely unconsumed, unwatched work does.
+     */
+    getWatcherLiveness(now = Date.now()) {
+        const oldestPendingChangeEnqueuedAt = this.oldestPendingChangeEnqueuedAt();
+        const pendingCount = this.applyPipeline.queuedDepth() + this.variantPipeline.queuedDepth();
+        return {
+            watcherActive: this.waitResolvers.length > 0,
+            pendingCount,
+            oldestPendingChangeEnqueuedAt,
+            oldestPendingChangeAgeMs: oldestPendingChangeEnqueuedAt === null
+                ? null
+                : Math.max(0, now - oldestPendingChangeEnqueuedAt),
+        };
+    }
+    /**
+     * Subscribe to changes in {@link getWatcherLiveness} state (queue/drain,
+     * waiter register/settle, session start/end). Returns an unsubscribe fn.
+     */
+    onWatcherLivenessChange(listener) {
+        this.livenessListeners.add(listener);
+        return () => {
+            this.livenessListeners.delete(listener);
+        };
+    }
+    /** Oldest enqueue time across queued apply and variant batches, or null. */
+    oldestPendingChangeEnqueuedAt() {
+        const times = [];
+        const applyAt = this.applyPipeline.oldestQueuedEnqueuedAt();
+        if (applyAt !== null) {
+            times.push(applyAt);
+        }
+        const variantTimes = this.variantPipeline.peekQueuedEnqueuedAt();
+        if (variantTimes.length > 0) {
+            times.push(variantTimes[0]);
+        }
+        return times.length > 0 ? Math.min(...times) : null;
+    }
+    notifyLivenessChange() {
+        for (const listener of this.livenessListeners) {
+            try {
+                listener();
+            }
+            catch (err) {
+                log.warn('liveness listener threw', err);
+            }
+        }
+    }
 }
 exports.SessionBridgeService = SessionBridgeService;
 //# sourceMappingURL=SessionBridgeService.js.map