rivet-design 0.12.3 → 0.13.0

package/dist/services/SessionBridgeService.js

@@ -1,95 +1,35 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-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;
+exports.SessionBridgeService = 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.
- *
- * Instantiated by the MCP server and shared in-memory with the Express
- * server so both MCP tool handlers and REST endpoints can access it.
- */
+const EMPTY_DEV_SERVER_HEALTH = {
+    ownership: 'none',
+    host: null,
+    port: null,
+    isReachable: null,
+    reason: 'unknown',
+    lastCheckedAt: null,
+    startedByRivet: false,
+};
 class SessionBridgeService {
     sessionId = null;
+    projectPath = null;
+    feedback = [];
+    status = 'IDLE';
+    roundsCompleted = 0;
+    telemetryContext = null;
     _setVariantTarget = null;
     _variantLookup = null;
     _isVariantPortAllowed = null;
     statusAccessToken = null;
-    projectPath = 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';
-    // 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 = {
-        ownership: 'none',
-        host: null,
-        port: null,
-        isReachable: null,
-        reason: 'unknown',
-        lastCheckedAt: null,
-        startedByRivet: false,
-    };
-    /**
-     * Start a new MCP visual editing session
-     * @returns The unique session ID
-     */
+    devServerHealth = { ...EMPTY_DEV_SERVER_HEALTH };
+    sessionInitiator = null;
+    resolvedRunner = null;
+    runnerMismatches = [];
+    livenessListeners = new Set();
     startSession(projectPath) {
         if (this.sessionId) {
             log.warn('Session already active, ending previous session');
@@ -97,121 +37,54 @@ class SessionBridgeService {
         }
         this.sessionId = (0, crypto_1.randomUUID)();
         this.projectPath = projectPath;
-        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.feedback = [];
         this.status = 'IDLE';
-        this.activeRunCorrelation = null;
+        this.roundsCompleted = 0;
+        this.telemetryContext = null;
+        this.sessionInitiator = null;
+        this.resolvedRunner = null;
+        this.runnerMismatches = [];
         this.baseDevServerHealth = null;
+        this.devServerHealth = { ...EMPTY_DEV_SERVER_HEALTH };
         this._variantLookup = null;
         this._isVariantPortAllowed = null;
         this.statusAccessToken = null;
-        this.devServerHealth = {
-            ownership: 'none',
-            host: null,
-            port: null,
-            isReachable: null,
-            reason: 'unknown',
-            lastCheckedAt: null,
-            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.
-     * Normalizes literal escape sequences (e.g. `\n`, `\t`) that MCP clients sometimes
-     * emit instead of real whitespace characters.
-     */
     reportFeedback(message) {
         if (!this.sessionId) {
             log.warn('Cannot report feedback: no active session');
             return;
         }
-        // Internal __RIVET_* signals carry JSON payloads — do not normalize escape
-        // sequences in them, or the embedded JSON becomes unparseable.
         const normalized = message.startsWith('__RIVET_')
             ? message
             : message.replace(/\\n/g, '\n').replace(/\\t/g, '\t');
         this.feedback.push(normalized);
         log.info(`Feedback reported: ${normalized}`);
     }
-    /** Get all feedback messages for the current session */
     getFeedback() {
         return this.feedback;
     }
-    /** Get the current session status */
     getStatus() {
         return this.status;
     }
-    /** Set the session status (used by MCP tools to indicate progress) */
     setStatus(status) {
         if (this.status !== status) {
             log.info(`Session status changed: ${this.status} -> ${status}`);
             this.status = status;
         }
     }
-    /** Check whether a session is currently active */
     isActive() {
         return this.sessionId !== null;
     }
-    /** Get the current session ID, or null if no session is active */
     getSessionId() {
         return this.sessionId;
     }
-    /** Get the project path for the current session */
     getProjectPath() {
         return this.projectPath;
     }
-    /**
-     * Rebind the active session to a new project root after a fresh-variant
-     * handoff succeeds.
-     */
     rebindProjectPath(projectPath) {
         if (!this.sessionId) {
             throw new Error('Cannot rebind project path without an active session');
@@ -219,386 +92,70 @@ class SessionBridgeService {
         this.projectPath = projectPath;
         log.info(`Session project rebound to ${projectPath}`);
     }
-    /**
-     * Queue changes from the Rivet UI for retrieval by the MCP client.
-     * 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 { accepted: true };
-        }
-        this.feedback = [];
-        this.updateTelemetryContext(intent.telemetryContext);
-        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 the oldest queued apply batch intent without leasing it.
-     */
-    getPendingChanges() {
-        return this.applyPipeline.peekHeadIntent();
-    }
-    /** True when one or more variant-request/refine batches are queued or leased. */
-    hasPendingVariantRequests() {
-        return this.variantPipeline.hasWork();
+    hasUnfinishedWork() {
+        return false;
     }
-    /** 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();
-    }
-    /**
-     * Resolve the active visual editor project for a queued or leased variant
-     * request. Returns null for unrelated request ids so direct variant runs keep
-     * their caller/cwd defaults.
-     */
-    resolveVariantRequestProjectPath(requestId) {
-        if (!this.projectPath || !this.variantPipeline.hasRequestId(requestId)) {
-            return null;
-        }
-        return this.projectPath;
+    getChannelDepth(_kind) {
+        return { queued: 0, leased: 0 };
     }
-    /**
-     * 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: [] };
+    getActiveLeaseMetadata() {
+        return [];
     }
-    /** True when either channel has queued or in-flight leased work. */
-    hasUnfinishedWork() {
-        return this.applyPipeline.hasWork() || this.variantPipeline.hasWork();
+    getQueuedBatchMetadata() {
+        return [];
     }
-    /** 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(),
-        };
+    getActiveRunCorrelation() {
+        return null;
     }
-    /** @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.
-     * Used by watch_for_changes for clients without background monitoring (e.g. Cursor).
-     * Rejects if the timeout is reached.
-     */
-    waitForChanges(timeoutMs = 300_000) {
-        const existing = this.applyPipeline.peekHeadIntent() ??
-            this.variantPipeline.peekHeadIntent();
-        if (existing) {
-            return Promise.resolve(existing);
-        }
-        return new Promise((resolve, reject) => {
-            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();
-        });
+    getSettledRequestIds() {
+        return [];
     }
-    /**
-     * Ack the active apply lease after processing (legacy alias for tests).
-     */
-    clearPending(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;
-        }
-        const lease = this.applyPipeline.leaseNext();
-        if (lease) {
-            this.ackBatch({ leaseId: lease.leaseId, requestId: lease.requestId });
-            log.info(`Pending intent cleared, round ${this.roundsCompleted} complete`);
-        }
+    getRoundsCompleted() {
+        return this.roundsCompleted;
     }
-    /** @deprecated Leased batches are released via {@link ackBatch}. */
-    consumeVariantRequestBatch(expectedIntent) {
-        const lease = expectedIntent
-            ? this.findVariantLeaseForIntent(expectedIntent)
-            : this.variantPipeline.leaseNext();
-        if (!lease) {
-            return null;
-        }
-        log.info(`variant-request batch consumed (no apply run started, ${lease.intent.changes.length} items)`);
-        return lease.intent;
-    }
-    /** @deprecated Leased batches are released via {@link ackBatch}. */
-    consumeStaticPreviewRefineBatch(expectedIntent) {
-        const lease = expectedIntent
-            ? this.findVariantLeaseForIntent(expectedIntent)
-            : this.variantPipeline.leaseNext();
-        if (!lease) {
-            return null;
+    setSessionRuntimeInfo(info) {
+        if ('sessionInitiator' in info) {
+            this.sessionInitiator = info.sessionInitiator ?? null;
         }
-        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;
-            }
+        if ('resolvedRunner' in info) {
+            this.resolvedRunner = info.resolvedRunner ?? null;
         }
-        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.applyPipeline.peekHeadIntent();
-        if (!intent)
-            return null;
-        if (expectedIntent && intent !== expectedIntent) {
-            log.info('Pending intent changed while rejecting mixed variant request; preserving newer intent');
-            return undefined;
-        }
-        const nextChanges = intent.changes.filter((change) => !(change.kind === 'comment' && change.variantRequest !== undefined));
-        if (nextChanges.length === intent.changes.length) {
-            return intent;
-        }
-        if (nextChanges.length === 0) {
-            this.applyPipeline.replaceHeadQueuedBatch(null);
-            log.info('Mixed variant batch rejection removed all pending changes');
-            this.persistQueue();
-            this.notifyLivenessChange();
-            return null;
-        }
-        const preserved = {
-            ...intent,
-            changes: nextChanges,
-        };
-        this.applyPipeline.replaceHeadQueuedBatch(preserved);
-        log.info(`Mixed variant batch rejected; preserved ${nextChanges.length} non-variant items`);
-        this.persistQueue();
-        this.notifyLivenessChange();
-        return preserved;
-    }
-    /**
-     * Mark the currently processing MCP apply run using identifiers from the queued request.
-     */
-    startApplyingRun(intent) {
-        const telemetryContext = this.getTelemetryContext();
-        const correlation = {
-            traceId: intent.traceId || (0, crypto_1.randomUUID)(),
-            agentRunId: intent.agentRunId || (0, crypto_1.randomUUID)(),
-            startedAt: Date.now(),
-            browserSessionId: telemetryContext?.browserSessionId,
-        };
-        const orphanedRun = this.activeRunCorrelation;
-        this.activeRunCorrelation = correlation;
+    getSessionRuntimeInfo() {
         return {
-            newRun: correlation,
-            orphanedRun,
+            sessionInitiator: this.sessionInitiator,
+            resolvedRunner: this.resolvedRunner,
+            runnerMismatches: [...this.runnerMismatches],
         };
     }
-    /**
-     * Complete the active MCP run and clear it from bridge state.
-     */
-    completeActiveRunCorrelation() {
-        const correlation = this.activeRunCorrelation;
-        this.activeRunCorrelation = null;
-        return correlation;
-    }
-    /** Active apply lease, if any (at most one). */
-    findActiveApplyLease() {
-        const leased = this.applyPipeline.snapshot().leased;
-        return leased[0] ?? null;
-    }
-    /** Active lease metadata safe to expose for agent recovery. */
-    getActiveLeaseMetadata(now = Date.now()) {
-        const leases = [
-            ...this.applyPipeline.snapshot().leased,
-            ...this.variantPipeline.snapshot().leased,
-        ];
-        return leases
-            .sort((a, b) => a.leasedAt - b.leasedAt)
-            .map((lease) => ({
-            kind: lease.kind,
-            requestId: lease.requestId,
-            leaseId: lease.leaseId,
-            leasedAt: lease.leasedAt,
-            ageMs: Math.max(0, now - lease.leasedAt),
-            changeCount: lease.intent.changes.length,
-            sourceFileCount: lease.intent.sourceFiles.length,
-            mergedFrom: lease.mergedFrom,
-            mergedRequestCount: lease.mergedRequestIds.length,
-        }));
-    }
-    /** Get the number of completed editing rounds in this session */
-    getRoundsCompleted() {
-        return this.roundsCompleted;
+    recordRunnerMismatch(initiator) {
+        if (initiator.kind !== 'agent' || initiator.agent === 'unknown')
+            return;
+        this.runnerMismatches.push({
+            agent: initiator.agent,
+            ...(initiator.model ? { model: initiator.model } : {}),
+            at: Date.now(),
+        });
     }
-    /** Get telemetry correlation data for the active session */
     getTelemetryContext() {
         return this.telemetryContext;
     }
-    /** Get dev-server health metadata for the active MCP session. */
+    updateTelemetryContext(context) {
+        if (!context)
+            return;
+        const nextContext = {
+            ...this.telemetryContext,
+            ...context,
+        };
+        if (nextContext.browserSessionId === undefined &&
+            nextContext.browserDistinctId === undefined) {
+            return;
+        }
+        this.telemetryContext = nextContext;
+    }
     getDevServerHealth() {
         return this.devServerHealth;
     }
-    /** Set the base session dev-server context (ownership + endpoint). */
     setDevServerContext(context) {
         this.devServerHealth = {
             ...this.devServerHealth,
@@ -609,7 +166,6 @@ class SessionBridgeService {
         };
         this.baseDevServerHealth = { ...this.devServerHealth };
     }
-    /** Update session dev-server health reason/reachability. */
     updateDevServerHealth(update) {
         this.devServerHealth = {
             ...this.devServerHealth,
@@ -628,108 +184,55 @@ class SessionBridgeService {
             this.baseDevServerHealth = { ...this.devServerHealth };
         }
     }
-    /** Merge and store telemetry correlation data for the active session */
-    updateTelemetryContext(context) {
-        if (!context) {
-            return;
-        }
-        const nextContext = {
-            ...this.telemetryContext,
-            ...context,
-        };
-        if (nextContext.browserSessionId === undefined &&
-            nextContext.browserDistinctId === undefined) {
-            return;
-        }
-        this.telemetryContext = nextContext;
-    }
-    /** Inject the proxy's setVariantTarget fn (called from server.ts after proxy is created) */
     registerVariantTargetSetter(fn) {
         this._setVariantTarget = fn;
     }
-    /** Register a variant-key→port lookup function (called from mcp/server.ts after variant sessions are built) */
     registerVariantLookup(fn) {
         this._variantLookup = fn;
     }
-    /** Register preview-port allowlist checker tied to the active variant session */
     registerVariantPortAllowlist(fn) {
         this._isVariantPortAllowed = fn;
     }
-    /** Look up a variant's preview port by stable lookup key */
     lookupVariantPort(variantKey) {
         return this._variantLookup?.(variantKey) ?? null;
     }
-    /** Check whether a preview port is registered for the active variant session */
     isVariantPortAllowed(port) {
         return this._isVariantPortAllowed?.(port) ?? false;
     }
-    /** Register a status polling token used by Rivet UI. */
     setStatusAccessToken(token) {
         this.statusAccessToken = token;
     }
-    /** Check whether a status polling token has already been registered. */
     hasStatusAccessToken() {
         return this.statusAccessToken !== null;
     }
-    /** Validate status polling token from API requests. */
     isStatusAccessTokenValid(token) {
         return Boolean(token) && token === this.statusAccessToken;
     }
-    /**
-     * Advertise a Rivet-spawned committed dev server (vite_app or static
-     * 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 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.
-     */
     setCommittedDevServerHealth(port) {
         if (port === null) {
-            if (this.baseDevServerHealth) {
-                this.devServerHealth = { ...this.baseDevServerHealth };
-                return;
-            }
-            this.devServerHealth = {
-                ownership: 'none',
-                host: null,
-                port: null,
-                isReachable: null,
-                reason: 'unknown',
-                lastCheckedAt: Date.now(),
-                startedByRivet: false,
-            };
+            this.devServerHealth = this.baseDevServerHealth
+                ? { ...this.baseDevServerHealth }
+                : { ...EMPTY_DEV_SERVER_HEALTH, lastCheckedAt: Date.now() };
             return;
         }
         const committedDevServerHealth = {
-            ...this.devServerHealth,
             ownership: 'rivet_owned',
             host: 'localhost',
             port,
             isReachable: true,
             reason: 'healthy',
-            startedByRivet: true,
             lastCheckedAt: Date.now(),
+            startedByRivet: true,
         };
         this.devServerHealth = committedDevServerHealth;
         this.baseDevServerHealth = { ...committedDevServerHealth };
     }
-    /** Switch the proxy to a variant dev server (or back to user's dev server when port is null) */
     switchPreviewPort(port) {
         if (!this._setVariantTarget) {
-            log.warn(`switchPreviewPort(${port}) called but no variant target setter registered — proxy will NOT retarget. (Did open_visual_editor run? Is framework='static'?)`);
-        }
-        else {
-            log.info(`switchPreviewPort → ${port === null ? 'default upstream' : `localhost:${port}`}`);
+            log.warn(`switchPreviewPort(${port}) called but no variant target setter registered`);
         }
         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',
@@ -739,112 +242,57 @@ class SessionBridgeService {
                 lastCheckedAt: Date.now(),
                 startedByRivet: true,
             };
+            this.reportFeedback('__RIVET_RELOAD_PREVIEW__');
+            return;
         }
-        else if (this.baseDevServerHealth) {
+        if (this.baseDevServerHealth) {
             this.devServerHealth = { ...this.baseDevServerHealth };
         }
         this.reportFeedback('__RIVET_RELOAD_PREVIEW__');
     }
-    /**
-     * End the current session, clearing all state.
-     * @returns The total number of completed rounds
-     */
     endSession() {
         const rounds = this.roundsCompleted;
-        const id = this.sessionId;
-        const projectPath = this.projectPath;
-        this.waitResolvers = [];
+        if (this.sessionId) {
+            log.info(`Session ended: ${this.sessionId}`);
+        }
         this.sessionId = null;
         this.projectPath = 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 = [];
         this.status = 'IDLE';
-        this.activeRunCorrelation = null;
+        this.roundsCompleted = 0;
+        this.telemetryContext = null;
+        this.sessionInitiator = null;
+        this.resolvedRunner = null;
+        this.runnerMismatches = [];
+        this.baseDevServerHealth = null;
+        this.devServerHealth = { ...EMPTY_DEV_SERVER_HEALTH };
         this._variantLookup = null;
         this._isVariantPortAllowed = null;
         this.statusAccessToken = null;
-        this.devServerHealth = {
-            ownership: 'none',
-            host: null,
-            port: null,
-            isReachable: null,
-            reason: 'unknown',
-            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() +
-            this.variantPipeline.leasedDepth();
+    getWatcherLiveness(_now = Date.now()) {
         return {
-            watcherActive: this.waitResolvers.length > 0,
-            pendingCount,
-            leasedVariantRequests: this.variantPipeline.leasedDepth(),
-            oldestPendingChangeEnqueuedAt,
-            oldestPendingChangeAgeMs: oldestPendingChangeEnqueuedAt === null
-                ? null
-                : Math.max(0, now - oldestPendingChangeEnqueuedAt),
+            watcherActive: false,
+            pendingCount: 0,
+            leasedVariantRequests: 0,
+            oldestPendingChangeEnqueuedAt: null,
+            oldestPendingChangeAgeMs: null,
         };
     }
-    /**
-     * 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 work or unfinished variant work. */
-    oldestPendingChangeEnqueuedAt() {
-        const times = [];
-        const applyAt = this.applyPipeline.oldestQueuedEnqueuedAt();
-        if (applyAt !== null) {
-            times.push(applyAt);
-        }
-        const variantAt = this.variantPipeline.oldestUnfinishedEnqueuedAt();
-        if (variantAt !== null) {
-            times.push(variantAt);
-        }
-        return times.length > 0 ? Math.min(...times) : null;
+    pendingVariantRequestCount() {
+        return 0;
     }
     notifyLivenessChange() {
         for (const listener of this.livenessListeners) {
-            try {
-                listener();
-            }
-            catch (err) {
-                log.warn('liveness listener threw', err);
-            }
+            listener();
         }
     }
 }