rivet-design 0.11.13 → 0.11.14

package/dist/mcp/agent-variants/WorktreeOrchestrator.js

@@ -402,6 +402,31 @@ class AgentVariantsOrchestrator {
         const result = this.store.propose(args);
         this.activeSessionId = result.sessionId;
         this.ensureResources(result.sessionId);
+        const projectContext = args.projectContext ?? { kind: 'existing' };
+        const mode = this.getVariantsTelemetryMode(projectContext, args.target);
+        this.startVariantsRound({
+            sessionId: result.sessionId,
+            mode,
+            workItemCount: args.count ?? 4,
+        });
+        if (result.sourcePlanWorkItem) {
+            this.telemetry.trackAgentVariantsSourcePlanStarted?.({
+                sessionId: result.sessionId,
+                workItemId: result.sourcePlanWorkItem.id,
+                mode,
+                projectContextKind: projectContext.kind,
+                requestedCount: args.count ?? 4,
+            });
+        }
+        if (result.briefWorkItem) {
+            this.telemetry.trackAgentVariantsBriefsStarted?.({
+                sessionId: result.sessionId,
+                workItemId: result.briefWorkItem.id,
+                mode,
+                projectContextKind: projectContext.kind,
+                requestedCount: args.count ?? 4,
+            });
+        }
         this.telemetry.track('agent_variants.session_started', {
             source: 'mcp',
             sessionId: result.sessionId,
@@ -501,6 +526,205 @@ class AgentVariantsOrchestrator {
             ...(artifacts.length > 0 ? { artifacts } : {}),
         };
     }
+    getVariantsTelemetryMode(projectContext, _target) {
+        if (projectContext.kind === 'fresh' && projectContext.variantContext) {
+            return 'source_grounded';
+        }
+        if (projectContext.kind === 'fresh')
+            return 'zero_to_one';
+        return 'initial_generation';
+    }
+    startVariantsRound(args) {
+        const resources = this.ensureResources(args.sessionId);
+        const roundIndex = resources.nextRoundIndex;
+        const startedAt = Date.now();
+        const workItemIds = args.workItemIds ? [...args.workItemIds] : undefined;
+        resources.nextRoundIndex += 1;
+        resources.rounds.set(roundIndex, {
+            roundIndex,
+            startedAt,
+            mode: args.mode,
+            workItemIds,
+            completed: false,
+        });
+        resources.currentRoundIndex = roundIndex;
+        resources.currentRoundStartedAt = startedAt;
+        resources.currentRoundMode = args.mode;
+        resources.currentRoundWorkItemIds = workItemIds;
+        const projectContext = this.store.getProjectContext(args.sessionId);
+        this.telemetry.trackAgentVariantsRoundStarted?.({
+            sessionId: args.sessionId,
+            roundIndex,
+            mode: args.mode,
+            projectContextKind: projectContext.kind,
+            workItemCount: args.workItemCount,
+        });
+    }
+    completeVariantsRound(args) {
+        const resources = this.resources.get(args.sessionId);
+        if (!resources)
+            return;
+        const roundIndex = args.roundIndex ?? resources.currentRoundIndex;
+        if (roundIndex === undefined)
+            return;
+        const round = resources.rounds.get(roundIndex);
+        if (round?.completed)
+            return;
+        const projectContext = this.store.getProjectContext(args.sessionId);
+        const summary = round?.workItemIds
+            ? this.buildRoundSummary({
+                sessionId: args.sessionId,
+                workItemIds: round.workItemIds,
+            })
+            : args.summary;
+        this.telemetry.trackAgentVariantsRoundCompleted?.({
+            sessionId: args.sessionId,
+            roundIndex,
+            mode: round?.mode ?? resources.currentRoundMode,
+            projectContextKind: projectContext.kind,
+            requestStatus: args.requestStatus,
+            completedCount: summary.successCount,
+            failedCount: summary.failureCount,
+            cancelledCount: summary.cancelledCount,
+            durationMs: round?.startedAt !== undefined
+                ? Date.now() - round.startedAt
+                : undefined,
+        });
+        if (round) {
+            round.completed = true;
+        }
+        if (resources.currentRoundIndex === roundIndex) {
+            resources.currentRoundIndex = undefined;
+            resources.currentRoundStartedAt = undefined;
+            resources.currentRoundMode = undefined;
+            resources.currentRoundWorkItemIds = undefined;
+        }
+    }
+    buildRoundSummary(args) {
+        const ids = new Set(args.workItemIds);
+        const variants = this.store
+            .getVariants(args.sessionId)
+            .filter((variant) => ids.has(variant.workItemId))
+            .map((variant) => ({
+            workItemId: variant.workItemId,
+            status: variant.status,
+            label: variant.label,
+        }));
+        return {
+            successCount: variants.filter((variant) => variant.status === 'succeeded')
+                .length,
+            failureCount: variants.filter((variant) => variant.status === 'failed')
+                .length,
+            cancelledCount: variants.filter((variant) => variant.status === 'cancelled').length,
+            variants,
+        };
+    }
+    recordCurrentVariantsRoundWorkItems(args) {
+        const resources = this.resources.get(args.sessionId);
+        if (!resources || resources.currentRoundIndex === undefined)
+            return;
+        const round = resources.rounds.get(resources.currentRoundIndex);
+        if (!round || round.workItemIds)
+            return;
+        const workItemIds = [...args.workItemIds];
+        round.workItemIds = workItemIds;
+        resources.currentRoundWorkItemIds = workItemIds;
+        this.completeTerminalVariantsRounds(args.sessionId);
+    }
+    completeTerminalVariantsRounds(sessionId) {
+        const resources = this.resources.get(sessionId);
+        if (!resources)
+            return;
+        for (const round of resources.rounds.values()) {
+            if (round.completed || !round.workItemIds)
+                continue;
+            const summary = this.buildRoundSummary({
+                sessionId,
+                workItemIds: round.workItemIds,
+            });
+            if (!this.isVariantsRoundTerminal(summary, round.workItemIds))
+                continue;
+            this.completeVariantsRound({
+                sessionId,
+                roundIndex: round.roundIndex,
+                requestStatus: this.getVariantsRoundRequestStatus(summary),
+                summary,
+            });
+        }
+    }
+    completePendingVariantsRounds(args) {
+        const resources = this.resources.get(args.sessionId);
+        if (!resources)
+            return;
+        for (const round of resources.rounds.values()) {
+            if (round.completed)
+                continue;
+            this.completeVariantsRound({
+                ...args,
+                roundIndex: round.roundIndex,
+                summary: round.workItemIds
+                    ? this.buildRoundSummary({
+                        sessionId: args.sessionId,
+                        workItemIds: round.workItemIds,
+                    })
+                    : args.summary,
+            });
+        }
+    }
+    isVariantsRoundTerminal(summary, workItemIds) {
+        return (summary.variants.length === workItemIds.length &&
+            summary.variants.every((variant) => variant.status === 'succeeded' ||
+                variant.status === 'failed' ||
+                variant.status === 'cancelled'));
+    }
+    getVariantsRoundRequestStatus(summary) {
+        if (summary.cancelledCount > 0 && summary.successCount === 0) {
+            return summary.failureCount > 0 ? 'failed' : 'cancelled';
+        }
+        if (summary.failureCount > 0) {
+            return summary.successCount > 0 ? 'degraded' : 'failed';
+        }
+        if (summary.cancelledCount > 0)
+            return 'degraded';
+        return 'completed';
+    }
+    refinementTelemetryForWorkItem(args) {
+        const input = this.store.getWorkItemInput(args.sessionId, args.workItemId);
+        const targetVariantId = input?.variantId ?? input?.sourceVariantId;
+        if (!targetVariantId)
+            return null;
+        const projectContext = this.store.getProjectContext(args.sessionId);
+        return {
+            sessionId: args.sessionId,
+            requestId: input?.requestId,
+            workItemId: args.workItemId,
+            leaseId: args.leaseId,
+            targetVariantId,
+            sourceVariantId: input?.sourceVariantId,
+            mode: input?.sourceVariantId ? 'vary' : 'comment_refine',
+            projectContextKind: projectContext.kind,
+            requestStatus: args.requestStatus,
+            instructionLength: input?.instruction?.length,
+            durationMs: args.durationMs,
+            failureReason: args.failureReason,
+        };
+    }
+    trackRefinementLeased(args) {
+        for (const item of args.lease.leasedWorkItems) {
+            const telemetry = this.refinementTelemetryForWorkItem({
+                sessionId: args.sessionId,
+                workItemId: item.id,
+                leaseId: args.lease.leaseId,
+            });
+            if (!telemetry)
+                continue;
+            this.telemetry.trackAgentVariantsRefinementLeased?.({
+                ...telemetry,
+                leaseDurationMs: args.lease.leaseTtlMs,
+                workItemCount: 1,
+            });
+        }
+    }
     emitChange() {
         try {
             this.events.emit('change', this.buildActiveSnapshot());
@@ -510,7 +734,19 @@ class AgentVariantsOrchestrator {
         }
     }
     reportBriefs(args) {
-        const result = this.store.reportBriefs(args);
+        let result;
+        try {
+            result = this.store.reportBriefs(args);
+        }
+        catch (error) {
+            this.telemetry.trackAgentVariantsBriefsFailed?.({
+                sessionId: args.sessionId,
+                workItemId: args.workItemId,
+                briefCount: args.briefs.length,
+                failureReason: error,
+            });
+            throw error;
+        }
         const projectContext = this.store.getProjectContext(args.sessionId);
         if (projectContext.variantContext) {
             (0, variantContext_1.writeVariantContextBundle)(projectContext.variantContext);
@@ -523,11 +759,33 @@ class AgentVariantsOrchestrator {
             evidenceBackedCount,
             shortBriefCount,
         });
+        this.telemetry.trackAgentVariantsBriefsCompleted?.({
+            sessionId: args.sessionId,
+            workItemId: args.workItemId,
+            mode: args.mode,
+            projectContextKind: projectContext.kind,
+            requestStatus: 'completed',
+            briefCount: result.briefs.length,
+            briefLabelCount: result.briefs.filter((brief) => brief.label.length > 0)
+                .length,
+            bindingCount: args.bindings?.length ?? 0,
+        });
         this.emitChange();
         return result;
     }
     reportSourcePlan(args) {
-        const result = this.store.reportSourcePlan(args);
+        let result;
+        try {
+            result = this.store.reportSourcePlan(args);
+        }
+        catch (error) {
+            this.telemetry.trackAgentVariantsSourcePlanFailed?.({
+                sessionId: args.sessionId,
+                workItemId: args.workItemId,
+                failureReason: error,
+            });
+            throw error;
+        }
         const projectContext = this.store.getProjectContext(args.sessionId);
         if (projectContext.variantContext) {
             (0, variantContext_1.writeVariantContextBundle)(projectContext.variantContext);
@@ -547,6 +805,20 @@ class AgentVariantsOrchestrator {
                 preserveBrand: false,
             });
         }
+        this.telemetry.trackAgentVariantsSourcePlanCompleted?.({
+            sessionId: args.sessionId,
+            workItemId: args.workItemId,
+            projectContextKind: projectContext.kind,
+            requestStatus: 'completed',
+            actionCount: args.sourcePlan.actions.length,
+            metadataCount: args.sourcePlan.metadata.length,
+            bindingCount: args.sourcePlan.bindings?.length ?? 0,
+        });
+        this.telemetry.trackAgentVariantsBriefsStarted?.({
+            sessionId: args.sessionId,
+            workItemId: result.briefWorkItem.id,
+            projectContextKind: projectContext.kind,
+        });
         this.emitChange();
         return result;
     }
@@ -562,6 +834,7 @@ class AgentVariantsOrchestrator {
                 resources.leasedAt.set(item.id, now);
             }
         }
+        this.trackRefinementLeased({ sessionId: args.sessionId, lease: result });
         // Decorate each leased item's input with the worktreePath provisioned
         // by approve(). The skill instructs agents to write files to
         // `input.worktreePath` — without this decoration that field would be
@@ -598,6 +871,19 @@ class AgentVariantsOrchestrator {
             if (seenVariantIds.has(target.variantId))
                 continue;
             seenVariantIds.add(target.variantId);
+            const mode = target.count == null ? 'comment_refine' : 'vary';
+            this.telemetry.trackAgentVariantsRefinementRequested?.({
+                sessionId: args.sessionId,
+                requestId: target.requestId,
+                entryPoint: 'watch_loop',
+                mode,
+                projectContextKind: this.store.getProjectContext(args.sessionId).kind,
+                targetVariantId: target.variantId,
+                sourceVariantId: mode === 'vary' ? target.variantId : undefined,
+                requestedCount: target.count,
+                commentCount: 1,
+                instructionLength: target.instruction.length,
+            });
             const currentHtml = this.getStaticPreviewHtml(args.sessionId, target.variantId);
             if (target.count == null) {
                 // Plain Apply (no variantRequest) → refine the variant IN PLACE: one
@@ -679,6 +965,17 @@ class AgentVariantsOrchestrator {
                 throw error;
             }
         }
+        for (const dropped of droppedRefinements) {
+            this.telemetry.trackAgentVariantsRefinementFailed?.({
+                sessionId: args.sessionId,
+                targetVariantId: dropped.variantId,
+                mode: args.targets.find((target) => target.variantId === dropped.variantId)
+                    ?.count == null
+                    ? 'comment_refine'
+                    : 'vary',
+                failureReason: dropped.reason,
+            });
+        }
         this.emitChange();
         return { droppedRefinements, createdWorkItemIds };
     }
@@ -709,6 +1006,14 @@ class AgentVariantsOrchestrator {
             description: args.description,
             runLabel: args.runLabel,
         });
+        this.telemetry.trackAgentVariantsRequestStarted?.({
+            sessionId: args.sessionId,
+            entryPoint: 'history',
+            mode: 'history_adoption',
+            projectContextKind: this.store.getProjectContext(args.sessionId).kind,
+            requestedCount: 1,
+            sourceVariantId: args.source.variantId,
+        });
         // Register (or re-register, harmlessly) the static-preview record so the
         // snapshot surfaces the adopted variant as a static_artifact.
         const resources = this.ensureResources(args.sessionId);
@@ -718,6 +1023,16 @@ class AgentVariantsOrchestrator {
             assetBase,
             hasAssets,
         });
+        this.telemetry.trackAgentVariantsRequestAccepted?.({
+            sessionId: args.sessionId,
+            entryPoint: 'history',
+            mode: 'history_adoption',
+            projectContextKind: this.store.getProjectContext(args.sessionId).kind,
+            requestStatus: 'accepted',
+            acceptedCount: append.created ? 1 : 0,
+            sourceVariantId: args.source.variantId,
+            targetVariantId: append.workItemId,
+        });
         this.emitChange();
         return {
             workItemId: append.workItemId,
@@ -800,7 +1115,9 @@ class AgentVariantsOrchestrator {
         }
         let hasAssets = false;
         try {
-            hasAssets = fs_1.default.readdirSync(assetBase).some((name) => name !== 'index.html');
+            hasAssets = fs_1.default
+                .readdirSync(assetBase)
+                .some((name) => name !== 'index.html');
         }
         catch {
             hasAssets = false;
@@ -815,7 +1132,7 @@ class AgentVariantsOrchestrator {
      */
     isStaticPreviewVariant(sessionId, workItemId) {
         try {
-            return this.store.getWorkItemKind(sessionId, workItemId) === 'static_preview';
+            return (this.store.getWorkItemKind(sessionId, workItemId) === 'static_preview');
         }
         catch {
             return false;
@@ -825,12 +1142,22 @@ class AgentVariantsOrchestrator {
         return this.store.getVariantPick(sessionId);
     }
     refineVariant(args) {
+        this.telemetry.trackAgentVariantsRefinementRequested?.({
+            sessionId: args.sessionId,
+            entryPoint: 'mcp_tool',
+            mode: 'comment_refine',
+            projectContextKind: this.store.getProjectContext(args.sessionId).kind,
+            targetVariantId: args.variantId,
+            commentCount: 1,
+            instructionLength: args.instruction.length,
+        });
         try {
             const lease = this.store.leaseRefineItemForVariant({
                 sessionId: args.sessionId,
                 variantId: args.variantId,
                 leaseOwner: args.leaseOwner,
             });
+            this.trackRefinementLeased({ sessionId: args.sessionId, lease });
             this.emitChange();
             return lease;
         }
@@ -838,6 +1165,14 @@ class AgentVariantsOrchestrator {
             if (!(error instanceof errors_1.AgentVariantsError) ||
                 error.code !== 'INVALID_STAGE_ACTION' ||
                 !error.message.includes('No pending refinement exists')) {
+                this.telemetry.trackAgentVariantsRefinementFailed?.({
+                    sessionId: args.sessionId,
+                    entryPoint: 'mcp_tool',
+                    mode: 'comment_refine',
+                    projectContextKind: this.store.getProjectContext(args.sessionId).kind,
+                    targetVariantId: args.variantId,
+                    failureReason: error,
+                });
                 throw error;
             }
         }
@@ -848,6 +1183,16 @@ class AgentVariantsOrchestrator {
             instruction: args.instruction,
             currentHtml,
         });
+        this.telemetry.trackAgentVariantsRefinementLeased?.({
+            sessionId: args.sessionId,
+            entryPoint: 'mcp_tool',
+            mode: 'comment_refine',
+            projectContextKind: this.store.getProjectContext(args.sessionId).kind,
+            targetVariantId: args.variantId,
+            workItemId: refineItem.id,
+            workItemCount: 1,
+            instructionLength: args.instruction.length,
+        });
         // Lease the just-created refine item by id. A generic
         // requestWork({ requestedLeaseCount: 1 }) takes the first leasable item in
         // work-item order, which could be an unrelated still-pending static_preview
@@ -1086,12 +1431,20 @@ class AgentVariantsOrchestrator {
         const result = this.store.approve(args);
         const resources = this.ensureResources(args.sessionId);
         resources.approveStartedAt = Date.now();
+        const projectContext = this.store.getProjectContext(args.sessionId);
         this.telemetry.track('agent_variants.approved', {
             source: 'mcp',
             sessionId: args.sessionId,
             approvedCount: result.approvedCount,
             totalBriefs: result.totalCount,
-            isFresh: this.store.getProjectContext(args.sessionId).kind === 'fresh',
+            isFresh: projectContext.kind === 'fresh',
+        });
+        const workItemIds = projectContext.kind === 'fresh'
+            ? this.store.getVariants(args.sessionId).map((v) => v.workItemId)
+            : result.codeGenWorkItemIds;
+        this.recordCurrentVariantsRoundWorkItems({
+            sessionId: args.sessionId,
+            workItemIds,
         });
         this.emitChange();
         // Await provisioning before returning so request_work always sees a
@@ -1179,6 +1532,14 @@ class AgentVariantsOrchestrator {
                 })
                 : this.store.appendExistingCodeGenVariants(forkArgs);
             variantIds = createdWorkItemIds;
+            this.startVariantsRound({
+                sessionId,
+                mode: args.sourceVariantId
+                    ? 'vary'
+                    : this.getVariantsTelemetryMode(projectContext, args.target),
+                workItemCount: createdWorkItemIds.length,
+                workItemIds: createdWorkItemIds,
+            });
             if (args.sourceVariantId) {
                 await this.provisionForkedFromVariantWorktrees(sessionId, args.sourceVariantId, createdWorkItemIds);
             }
@@ -1208,11 +1569,12 @@ class AgentVariantsOrchestrator {
                 !proposeResult.briefWorkItem) {
                 throw new errors_1.AgentVariantsError('INVALID_STAGE_ACTION', `start_variants expected awaiting_briefs from propose, got ${proposeResult.stage}`);
             }
-            this.store.reportBriefs({
+            this.reportBriefs({
                 sessionId: proposeResult.sessionId,
                 workItemId: proposeResult.briefWorkItem.id,
                 attempt: proposeResult.briefWorkItem.attempt,
                 briefs,
+                mode: this.getVariantsTelemetryMode(projectContext, args.target),
             });
             const approveResult = await this.approve({
                 sessionId: proposeResult.sessionId,
@@ -1243,12 +1605,29 @@ class AgentVariantsOrchestrator {
         if (args.requestId) {
             this.store.assignVariantRequestId(sessionId, variantIds, args.requestId);
         }
+        if (args.sourceVariantId) {
+            this.telemetry.trackAgentVariantsRefinementRequested?.({
+                sessionId,
+                requestId: args.requestId,
+                entryPoint: 'mcp_tool',
+                mode: 'vary',
+                projectContextKind: projectContext.kind,
+                targetVariantId: args.sourceVariantId,
+                sourceVariantId: args.sourceVariantId,
+                requestedCount: count,
+                instructionLength: args.prompt.length,
+            });
+        }
         const variants = variantIds.map((workItemId, i) => ({
             variantId: workItemId,
             briefId: briefs[i].briefId,
             label: briefs[i].label,
             status: 'pending',
         }));
+        this.recordCurrentVariantsRoundWorkItems({
+            sessionId,
+            workItemIds: variantIds,
+        });
         let leaseId;
         let leaseTtlMs;
         let leasedWorkItems;
@@ -1384,6 +1763,16 @@ class AgentVariantsOrchestrator {
             (workItemKind === 'static_preview' ||
                 workItemKind === 'refine_variant') &&
             !parseStaticPreviewOutput(normalizeOutput(args.output))) {
+            const telemetry = this.refinementTelemetryForWorkItem({
+                sessionId: args.sessionId,
+                workItemId: args.workItemId,
+                leaseId: args.leaseId,
+                requestStatus: 'failed',
+                failureReason: 'schema_validation_failed',
+            });
+            if (telemetry) {
+                this.telemetry.trackAgentVariantsRefinementFailed?.(telemetry);
+            }
             throw new errors_1.AgentVariantsError('SCHEMA_VALIDATION_FAILED', `${workItemKind} report_variant_complete requires output.html (string, non-empty). ` +
                 'Pass the full HTML inline as output: { html: "<!doctype html>...", css?: "...", js?: "..." }. ' +
                 'Do NOT write the HTML to a file and report a file list — Rivet renders the HTML inline; on-disk files are not read.');
@@ -1438,7 +1827,23 @@ class AgentVariantsOrchestrator {
                 };
             }
         }
-        const result = this.store.reportComplete(effectiveArgs);
+        let result;
+        try {
+            result = this.store.reportComplete(effectiveArgs);
+        }
+        catch (error) {
+            const telemetry = this.refinementTelemetryForWorkItem({
+                sessionId: args.sessionId,
+                workItemId: args.workItemId,
+                leaseId: args.leaseId,
+                requestStatus: 'failed',
+                failureReason: error,
+            });
+            if (telemetry) {
+                this.telemetry.trackAgentVariantsRefinementFailed?.(telemetry);
+            }
+            throw error;
+        }
         this.emitChange();
         // Per-variant telemetry on terminal item statuses (skip 'running'
         // heartbeats and the brief work item — only code_gen / scaffold_base
@@ -1471,16 +1876,45 @@ class AgentVariantsOrchestrator {
                 model: args.model ?? null,
                 outputBytes,
             });
+            const refinementTelemetry = this.refinementTelemetryForWorkItem({
+                sessionId: args.sessionId,
+                workItemId: args.workItemId,
+                leaseId: args.leaseId,
+                requestStatus: effectiveArgs.status === 'succeeded' ? 'completed' : 'failed',
+                durationMs: durationMs ?? undefined,
+                failureReason: effectiveArgs.error?.code,
+            });
+            if (refinementTelemetry) {
+                const counts = {
+                    completedCount: effectiveArgs.status === 'succeeded' ? 1 : 0,
+                    failedCount: effectiveArgs.status === 'failed' ? 1 : 0,
+                    cancelledCount: effectiveArgs.status === 'cancelled' ? 1 : 0,
+                    resultVariantCount: effectiveArgs.status === 'succeeded' ? 1 : 0,
+                };
+                if (effectiveArgs.status === 'succeeded') {
+                    this.telemetry.trackAgentVariantsRefinementCompleted?.({
+                        ...refinementTelemetry,
+                        ...counts,
+                    });
+                }
+                else {
+                    this.telemetry.trackAgentVariantsRefinementFailed?.({
+                        ...refinementTelemetry,
+                        ...counts,
+                    });
+                }
+            }
         }
+        this.completeTerminalVariantsRounds(args.sessionId);
         if (contracts_1.TERMINAL_STAGES.has(result.stage)) {
             const resources = this.resources.get(args.sessionId);
+            const summary = result.summary ?? this.store.getSummary(args.sessionId);
             if (resources && resources.terminalAt === undefined) {
                 resources.terminalAt = Date.now();
                 const totalLatencyMs = resources.terminalAt - resources.startedAt;
                 const approveToTerminalMs = resources.approveStartedAt !== undefined
                     ? resources.terminalAt - resources.approveStartedAt
                     : null;
-                const summary = result.summary ?? this.store.getSummary(args.sessionId);
                 this.telemetry.track('agent_variants.terminal_state', {
                     source: 'mcp',
                     sessionId: args.sessionId,
@@ -1493,6 +1927,19 @@ class AgentVariantsOrchestrator {
                     projectContextKind: this.store.getProjectContext(args.sessionId).kind,
                 });
             }
+            if (resources) {
+                this.completePendingVariantsRounds({
+                    sessionId: args.sessionId,
+                    requestStatus: result.stage === 'cancelled'
+                        ? 'cancelled'
+                        : result.stage === 'failed'
+                            ? 'failed'
+                            : result.stage === 'degraded'
+                                ? 'degraded'
+                                : 'completed',
+                    summary,
+                });
+            }
         }
         if (effectiveArgs.status === 'succeeded' &&
             workItemKind !== 'refine_variant') {
@@ -1524,6 +1971,11 @@ class AgentVariantsOrchestrator {
             reason: args.reason ?? null,
             fromStage: stageBefore,
         });
+        this.completePendingVariantsRounds({
+            sessionId: args.sessionId,
+            requestStatus: 'cancelled',
+            summary: this.store.getSummary(args.sessionId),
+        });
         this.emitChange();
         void this.markPersistedVariantsCancelled(args.sessionId).catch((err) => {
             log.warn(`markPersistedVariantsCancelled failed for ${args.sessionId}`, err);
@@ -1657,6 +2109,16 @@ class AgentVariantsOrchestrator {
         try {
             return await run;
         }
+        catch (error) {
+            this.telemetry.trackAgentVariantsCommitFailed?.({
+                sessionId: args.sessionId,
+                targetVariantId: args.variantId,
+                mode: 'commit',
+                requestStatus: 'failed',
+                failureReason: error,
+            });
+            throw error;
+        }
         finally {
             if (this.inflightCommits.get(args.sessionId) === run) {
                 this.inflightCommits.delete(args.sessionId);
@@ -4028,6 +4490,8 @@ class AgentVariantsOrchestrator {
                 cleanupStarted: false,
                 committedVariantIds: new Set(),
                 startedAt: Date.now(),
+                nextRoundIndex: 0,
+                rounds: new Map(),
                 leasedAt: new Map(),
                 qaResults: new Map(),
                 qaRegenRetried: new Set(),