rivet-design 0.25.0 → 0.26.0

package/dist/agent-variants/WorktreeOrchestrator.js

@@ -13,15 +13,12 @@ const events_1 = require("events");
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const DependencyPreparationService_1 = require("../services/DependencyPreparationService");
-const simple_git_1 = require("simple-git");
 const logger_1 = require("../utils/logger");
 const errors_1 = require("./errors");
-const createProjectArtifacts_1 = require("./createProjectArtifacts");
 const contracts_1 = require("./contracts");
 const workItemBriefing_1 = require("./workItemBriefing");
 const briefContent_1 = require("./briefContent");
 const runLabel_1 = require("./runLabel");
-const runPlan_1 = require("./runPlan");
 const previewQa_1 = require("./previewQa");
 const WorkspaceInventory_1 = require("./WorkspaceInventory");
 const WorkspaceProvisioning_1 = require("./WorkspaceProvisioning");
@@ -32,7 +29,6 @@ const variantContext_1 = require("./variantContext");
 const designContext_1 = require("./designContext");
 const variantsTelemetry_1 = require("./variantsTelemetry");
 const variantWorkspaceFiles_1 = require("./variantWorkspaceFiles");
-const errnoCode_1 = require("../utils/errnoCode");
 const errorMessage_1 = require("../utils/errorMessage");
 const pathContainment_1 = require("../utils/pathContainment");
 var variantWorkspaceFiles_2 = require("./variantWorkspaceFiles");
@@ -201,7 +197,6 @@ class AgentVariantsOrchestrator {
     resolveEnv;
     telemetry;
     installDependencies;
-    materializeProject;
     previewQaRunner;
     variantHistory;
     provisionTimeoutMs;
@@ -211,7 +206,6 @@ class AgentVariantsOrchestrator {
     workspaceInventory;
     workspaceProvisioning;
     previewRuntime;
-    inflightCommits = new Map();
     activeSessionId = null;
     events = new events_1.EventEmitter();
     constructor(deps) {
@@ -225,8 +219,6 @@ class AgentVariantsOrchestrator {
         this.telemetry = deps.telemetry ?? variantsTelemetry_1.NOOP_TELEMETRY;
         this.installDependencies =
             deps.installDependencies ?? variantWorkspaceFiles_1.defaultInstallDependencies;
-        this.materializeProject =
-            deps.materializeProject ?? variantWorkspaceFiles_1.defaultMaterializeProject;
         this.previewQaRunner = deps.previewQaRunner ?? defaultPreviewQaRunner;
         this.variantHistory = deps.variantHistory ?? new VariantHistoryService_1.VariantHistoryService();
         this.provisionTimeoutMs = deps.provisionTimeoutMs ?? PROVISION_TIMEOUT_MS;
@@ -258,16 +250,11 @@ class AgentVariantsOrchestrator {
             hasUiClients: () => this.uiClientCount > 0,
             changed: () => this.emitChange(),
             switchPreviewPort: deps.switchPreviewPort,
-            setCommittedDevServerHealth: deps.setCommittedDevServerHealth,
-            startStaticPreviewServer: deps.startStaticPreviewServer,
             activeVariantServerIdleTtlMs: this.activeVariantServerIdleTtlMs,
             devServerRestartDelayMs: this.devServerRestartDelayMs,
         });
     }
     propose(args) {
-        void this.previewRuntime.stopLingeringCommitted().catch((err) => {
-            log.warn('Stopping lingering committed dev servers failed', err);
-        });
         const result = this.store.propose(args);
         this.activeSessionId = result.sessionId;
         this.ensureResources(result.sessionId);
@@ -885,9 +872,6 @@ class AgentVariantsOrchestrator {
             entryPath: args.entryPath,
             isWebsite: Boolean(args.previewRoutes?.length),
         });
-        void this.previewRuntime.stopLingeringCommitted().catch((err) => {
-            log.warn('Stopping lingering committed dev servers failed', err);
-        });
         const created = this.store.createSessionFromStaticHistoryVariant({
             source: args.source,
             prompt: args.prompt ?? args.description ?? args.label,
@@ -945,9 +929,6 @@ class AgentVariantsOrchestrator {
             return { sessionId, variantId: sourceVariantId };
         }
     }
-    getVariantPick(sessionId) {
-        return this.store.getVariantPick(sessionId);
-    }
     refineVariant(args) {
         this.telemetry.trackAgentVariantsRefinementRequested?.({
             sessionId: args.sessionId,
@@ -1058,7 +1039,6 @@ class AgentVariantsOrchestrator {
             }
             const qa = resources?.qaResults.get(variant.workItemId);
             const isSucceeded = variant.status === 'succeeded';
-            const qaFailed = qa?.status === 'failed';
             const canView = Boolean(preview) || (isSucceeded && Boolean(port));
             const previewFailure = this.previewRuntime.getFailure(sessionId, variant.workItemId);
             const previewUnavailable = !canView && isSucceeded && previewFailure
@@ -1067,10 +1047,6 @@ class AgentVariantsOrchestrator {
                     portInUse: previewFailure.portInUse || undefined,
                 }
                 : undefined;
-            const canCommit = isSucceeded && !qaFailed;
-            const commitDisabledReason = qaFailed
-                ? (qa?.summary ?? 'Variant failed QA')
-                : 'Wait for a successful variant';
             return {
                 ...variant,
                 design: (0, designContext_1.enrichDesignSource)(variant.design),
@@ -1090,12 +1066,6 @@ class AgentVariantsOrchestrator {
                                 qa,
                             }),
                         },
-                    commit: canCommit
-                        ? { enabled: true }
-                        : {
-                            enabled: false,
-                            reason: commitDisabledReason,
-                        },
                 },
             };
         });
@@ -1460,8 +1430,6 @@ class AgentVariantsOrchestrator {
         const ctx = this.store.getProjectContext(sessionId);
         if (ctx.kind !== 'existing' || ctx.projectPath !== projectPath)
             return null;
-        if (this.store.getVariantPick(sessionId))
-            return null;
         const stage = this.store.getStage(sessionId);
         if (stage === 'cancelled' || stage === 'failed')
             return null;
@@ -1825,385 +1793,8 @@ class AgentVariantsOrchestrator {
             sessionStage: result.sessionStage,
         };
     }
-    async commitVariant(args) {
-        const prior = this.inflightCommits.get(args.sessionId);
-        const run = (async () => {
-            if (prior) {
-                await prior.catch(() => undefined);
-            }
-            return this.commitVariantImpl(args);
-        })();
-        this.inflightCommits.set(args.sessionId, run);
-        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);
-            }
-        }
-    }
-    async commitVariantImpl(args) {
-        const existingPick = this.store.getVariantPick(args.sessionId);
-        if (existingPick && existingPick.variantId === args.variantId) {
-            const projectContext = this.store.getProjectContext(args.sessionId);
-            let historyProjectPath;
-            if (projectContext.kind === 'fresh') {
-                historyProjectPath = projectContext.workspacePath;
-            }
-            else {
-                try {
-                    historyProjectPath = (await this.resolveEnv(args.sessionId))
-                        ?.projectPath;
-                }
-                catch {
-                    historyProjectPath = undefined;
-                }
-            }
-            if (historyProjectPath) {
-                void this.persistVariantHistoryAtCommit({
-                    sessionId: args.sessionId,
-                    chosenVariantId: args.variantId,
-                    projectPath: historyProjectPath,
-                    projectKind: projectContext.kind,
-                    destinationPath: existingPick.destinationPath ?? historyProjectPath,
-                }).catch((err) => {
-                    log.warn(`persistVariantHistoryAtCommit (duplicate retry) failed for session ${args.sessionId}`, err);
-                });
-            }
-            const replayPort = this.previewRuntime.getCommittedPort(args.sessionId);
-            return {
-                enqueued: false,
-                duplicate: true,
-                changedFilesCount: existingPick.changedFilesCount,
-                payloadKind: existingPick.payload.kind === 'new-project'
-                    ? 'project-created'
-                    : existingPick.payload.kind,
-                destinationPath: existingPick.destinationPath,
-                ...(replayPort
-                    ? { previewUrl: `http://${FRESH_DEV_SERVER_HOST}:${replayPort}` }
-                    : {}),
-            };
-        }
-        const resources = this.resources.get(args.sessionId);
-        if (!resources) {
-            throw new errors_1.AgentVariantsError('SESSION_NOT_FOUND', `No live resources for session ${args.sessionId} (already torn down?)`);
-        }
-        const variantSnapshot = this.getVariants(args.sessionId).find((variant) => variant.workItemId === args.variantId);
-        if (!variantSnapshot || variantSnapshot.actions?.commit?.enabled !== true) {
-            throw new errors_1.AgentVariantsError('INVALID_STAGE_ACTION', variantSnapshot?.actions?.commit?.reason ??
-                'Variant is not committable');
-        }
-        await this.settleHistoryPersists();
-        const input = this.store.requireVariantWorkItemInput({
-            sessionId: args.sessionId,
-            workItemId: args.variantId,
-            kinds: ['code_gen', 'static_preview'],
-        });
-        const projectContext = this.store.getProjectContext(args.sessionId);
-        if (projectContext.kind === 'fresh') {
-            await this.persistCompletedFreshVariantsForCommit(args.sessionId);
-        }
-        let payload;
-        let envelopeDestination;
-        let changedFilesCount;
-        let runnablePaths;
-        let committedPreviewPort;
-        if (projectContext.kind === 'fresh') {
-            const destinationPath = projectContext.workspacePath;
-            let realDestination;
-            try {
-                realDestination = fs_1.default.realpathSync(destinationPath);
-            }
-            catch {
-                realDestination = undefined;
-            }
-            const commitPolicy = (0, runPlan_1.resolveRunPlanPolicy)(projectContext).commit;
-            const isViteApp = commitPolicy === 'materialize_project';
-            if (isViteApp) {
-                this.assertDestinationAvailable(destinationPath);
-            }
-            else {
-                const compareBase = realDestination ?? destinationPath;
-                const anyAssetBaseIsDestination = [
-                    ...this.workspaceInventory.getStaticPreviews(args.sessionId),
-                ].some((sp) => sp.assetBase === compareBase);
-                if (!anyAssetBaseIsDestination) {
-                    const allowed = new Set();
-                    for (const sp of this.workspaceInventory.getStaticPreviews(args.sessionId)) {
-                        if (sp.assetBase &&
-                            (0, pathContainment_1.isPathStrictlyInsideRoot)(compareBase, sp.assetBase)) {
-                            allowed.add(path_1.default.basename(sp.assetBase));
-                        }
-                    }
-                    this.assertDestinationAvailable(destinationPath, allowed);
-                }
-            }
-            if (isViteApp) {
-                const record = this.workspaceInventory.getWorktree(args.sessionId, args.variantId);
-                if (!record) {
-                    throw new errors_1.AgentVariantsError('WORK_ITEM_NOT_FOUND', `Unknown variantId ${args.variantId} for session ${args.sessionId}`);
-                }
-                let usedRename = false;
-                let isDependencyInstallRequired = false;
-                try {
-                    if ((0, variantWorkspaceFiles_1.areSameVolume)(record.worktreePath, destinationPath)) {
-                        await this.previewRuntime.stopVariantServers(args.sessionId);
-                        isDependencyInstallRequired = await (0, variantWorkspaceFiles_1.resolveNodeModulesSymlink)(record.worktreePath);
-                        await this.renameWorktreeIntoDestination(record.worktreePath, destinationPath);
-                        usedRename = true;
-                    }
-                    else {
-                        await this.materializeProject(record.worktreePath, destinationPath);
-                    }
-                }
-                catch (err) {
-                    const message = (0, errorMessage_1.errorMessage)(err);
-                    throw new errors_1.AgentVariantsError('RUNTIME_VALIDATION_FAILED', `Failed to materialize vite_app variant to ${destinationPath}: ${message}`);
-                }
-                changedFilesCount = (0, variantWorkspaceFiles_1.countWorktreeFiles)(destinationPath);
-                if (!usedRename) {
-                    void this.installDependencies(destinationPath)
-                        .then(() => this.previewRuntime.startCommitted({
-                        sessionId: args.sessionId,
-                        destinationPath,
-                    }))
-                        .catch((err) => {
-                        log.warn(`Background install + committed dev server start after vite_app commit failed for ${destinationPath}`, err);
-                    });
-                }
-                else if (isDependencyInstallRequired) {
-                    await this.installDependencies(destinationPath);
-                }
-                if (usedRename) {
-                    try {
-                        runnablePaths = this.preserveUnchosenVariants({
-                            sessionId: args.sessionId,
-                            chosenVariantId: args.variantId,
-                            destinationPath,
-                        });
-                    }
-                    catch (err) {
-                        log.warn(`preserveUnchosenVariants failed for session ${args.sessionId}; continuing without history`, err);
-                    }
-                    committedPreviewPort = await this.previewRuntime.startCommitted({
-                        sessionId: args.sessionId,
-                        destinationPath,
-                        mode: 'vite_app',
-                    });
-                }
-                payload = {
-                    kind: 'project-created',
-                    destinationPath,
-                    changedFilesCount,
-                    note: usedRename
-                        ? 'Vite app moved to destinationPath (rename); node_modules came along.'
-                        : 'Vite app materialized at destinationPath; `npm install` running in the background.',
-                };
-                envelopeDestination = destinationPath;
-            }
-            else {
-                const staticPreview = this.workspaceInventory.getStaticPreview(args.sessionId, args.variantId);
-                const htmlFromDir = staticPreview
-                    ? this.getStaticPreviewHtml(args.sessionId, args.variantId)
-                    : undefined;
-                const htmlFromSnapshot = await this.variantHistory.readStaticPreview({
-                    projectPath: projectContext.workspacePath,
-                    sessionId: args.sessionId,
-                    variantId: args.variantId,
-                });
-                if (!staticPreview && !htmlFromSnapshot) {
-                    throw new errors_1.AgentVariantsError('INVALID_STAGE_ACTION', `No static preview found for variant ${args.variantId} — wait for report_variant_complete(succeeded) first`);
-                }
-                try {
-                    fs_1.default.mkdirSync(destinationPath, { recursive: true });
-                    let flattenBase = realDestination;
-                    if (!flattenBase) {
-                        try {
-                            flattenBase = fs_1.default.realpathSync(destinationPath);
-                        }
-                        catch {
-                            flattenBase = destinationPath;
-                        }
-                    }
-                    const chosenAssetBase = staticPreview?.assetBase;
-                    if (chosenAssetBase &&
-                        (0, pathContainment_1.isPathStrictlyInsideRoot)(flattenBase, chosenAssetBase)) {
-                        for (const entry of fs_1.default.readdirSync(chosenAssetBase)) {
-                            const src = path_1.default.join(chosenAssetBase, entry);
-                            const dst = path_1.default.join(flattenBase, entry);
-                            if (path_1.default.resolve(dst) === path_1.default.resolve(chosenAssetBase)) {
-                                continue;
-                            }
-                            if (fs_1.default.existsSync(dst)) {
-                                fs_1.default.rmSync(dst, { recursive: true, force: true });
-                            }
-                            try {
-                                fs_1.default.renameSync(src, dst);
-                            }
-                            catch (err) {
-                                if ((0, errnoCode_1.errnoCode)(err) !== 'EXDEV')
-                                    throw err;
-                                fs_1.default.cpSync(src, dst, { recursive: true });
-                                fs_1.default.rmSync(src, { recursive: true, force: true });
-                            }
-                        }
-                        fs_1.default.rmSync(chosenAssetBase, { recursive: true, force: true });
-                    }
-                    for (const other of this.workspaceInventory.getStaticPreviews(args.sessionId)) {
-                        if (other.workItemId === args.variantId)
-                            continue;
-                        if (other.assetBase &&
-                            (0, pathContainment_1.isPathStrictlyInsideRoot)(flattenBase, other.assetBase)) {
-                            fs_1.default.rmSync(other.assetBase, { recursive: true, force: true });
-                        }
-                    }
-                    fs_1.default.writeFileSync(path_1.default.join(destinationPath, 'index.html'), htmlFromDir ?? htmlFromSnapshot ?? '', 'utf8');
-                }
-                catch (err) {
-                    const message = (0, errorMessage_1.errorMessage)(err);
-                    throw new errors_1.AgentVariantsError('RUNTIME_VALIDATION_FAILED', `Failed to write static preview to ${destinationPath}: ${message}`);
-                }
-                changedFilesCount = (0, variantWorkspaceFiles_1.countWorktreeFiles)(destinationPath);
-                committedPreviewPort = await this.previewRuntime.startCommitted({
-                    sessionId: args.sessionId,
-                    destinationPath,
-                    mode: 'static_preview',
-                });
-                payload = {
-                    kind: 'project-created',
-                    destinationPath,
-                    changedFilesCount,
-                    note: 'Static preview written to index.html at destinationPath.',
-                };
-                envelopeDestination = destinationPath;
-            }
-        }
-        else {
-            const env = await this.resolveEnv(args.sessionId);
-            const record = this.workspaceInventory.getWorktree(args.sessionId, args.variantId);
-            const saved = record
-                ? null
-                : await this.getSavedVariant({
-                    projectPath: env.projectPath,
-                    sessionId: args.sessionId,
-                    variantId: args.variantId,
-                });
-            const diff = record?.diff ?? saved?.diff;
-            if (!record && !saved) {
-                throw new errors_1.AgentVariantsError('WORK_ITEM_NOT_FOUND', `Unknown variantId ${args.variantId} for session ${args.sessionId}`);
-            }
-            if (diff === undefined) {
-                throw new errors_1.AgentVariantsError('INVALID_STAGE_ACTION', `Variant ${args.variantId} has no captured diff yet — wait for report_variant_complete(succeeded) first`);
-            }
-            changedFilesCount = (0, variantWorkspaceFiles_1.countDiffFiles)(diff);
-            if (!this.worktrees.applyDiffToProject) {
-                throw new errors_1.AgentVariantsError('RUNTIME_VALIDATION_FAILED', 'WorktreeManager does not support applying diffs to the project tree');
-            }
-            try {
-                await this.worktrees.applyDiffToProject(diff, env.projectPath);
-            }
-            catch (err) {
-                const message = (0, errorMessage_1.errorMessage)(err);
-                throw new errors_1.AgentVariantsError('RUNTIME_VALIDATION_FAILED', `Failed to apply variant ${args.variantId} to ${env.projectPath}: ${message}`);
-            }
-            payload = {
-                kind: 'diff-applied',
-                diff,
-                target: input.target,
-                changedFilesCount,
-                note: "Variant diff applied to the user's working tree (uncommitted).",
-            };
-            envelopeDestination = env.projectPath;
-        }
-        const envelope = {
-            sourceSessionId: args.sessionId,
-            variantId: args.variantId,
-            variantLabel: input.briefLabel,
-            destinationPath: envelopeDestination,
-            changedFilesCount,
-            payload,
-        };
-        this.store.recordVariantPick({
-            sessionId: args.sessionId,
-            envelope,
-        });
-        const historyProjectPath = projectContext.kind === 'fresh'
-            ? projectContext.workspacePath
-            : envelopeDestination;
-        try {
-            await this.persistVariantHistoryAtCommit({
-                sessionId: args.sessionId,
-                chosenVariantId: args.variantId,
-                projectPath: historyProjectPath,
-                projectKind: projectContext.kind,
-                destinationPath: envelopeDestination,
-                runnablePaths,
-            });
-        }
-        catch (err) {
-            log.warn(`persistVariantHistoryAtCommit failed for session ${args.sessionId}`, err);
-        }
-        resources.committedVariantIds.add(args.variantId);
-        if (this.activeSessionId === args.sessionId &&
-            payload.kind !== 'project-created') {
-            this.activeSessionId = null;
-        }
-        const dwellMsFromTerminal = resources.terminalAt
-            ? Date.now() - resources.terminalAt
-            : null;
-        this.telemetry.track('agent_variants.committed', {
-            source: 'mcp',
-            sessionId: args.sessionId,
-            workItemId: args.variantId,
-            payloadKind: payload.kind,
-            changedFilesCount,
-            dwellMsFromTerminal,
-            isFresh: projectContext.kind === 'fresh',
-        });
-        this.emitChange();
-        log.info(`Variant ${args.variantId} (${input.briefLabel}) committed by user`);
-        if (!args.skipTeardown) {
-            void this.teardownSession(args.sessionId, 'committed').catch((err) => {
-                log.warn(`teardownSession after commit failed for ${args.sessionId}`, err);
-            });
-        }
-        return {
-            enqueued: true,
-            duplicate: false,
-            changedFilesCount,
-            payloadKind: payload.kind,
-            destinationPath: envelopeDestination,
-            ...(committedPreviewPort
-                ? {
-                    previewUrl: `http://${FRESH_DEV_SERVER_HOST}:${committedPreviewPort}`,
-                }
-                : {}),
-        };
-    }
-    async cleanupCommittedSession(sessionId) {
-        await this.teardownSession(sessionId, 'committed');
-    }
-    assertDestinationAvailable(destinationPath, additionalAllowedEntries = new Set()) {
-        if (!fs_1.default.existsSync(destinationPath))
-            return;
-        const entries = fs_1.default.readdirSync(destinationPath);
-        const userVisibleEntries = entries.filter((entry) => entry !== '.rivet' &&
-            entry !== '.gitignore' &&
-            !additionalAllowedEntries.has(entry));
-        if (userVisibleEntries.length === 0)
-            return;
-        throw new errors_1.AgentVariantsError('DESTINATION_NOT_EMPTY', `Destination ${destinationPath} is not empty (${userVisibleEntries.length} entries) — refuse to materialize.`);
+    async cleanupSession(sessionId) {
+        await this.teardownSession(sessionId, 'shutdown');
     }
     getVariantDiff(sessionId, variantId) {
         return this.workspaceInventory.getWorktree(sessionId, variantId)?.diff;
@@ -3047,52 +2638,6 @@ class AgentVariantsOrchestrator {
             }
         }
     }
-    async persistCompletedFreshVariantsForCommit(sessionId) {
-        const projectContext = this.store.getProjectContext(sessionId);
-        if (projectContext.kind !== 'fresh')
-            return;
-        const variants = this.store
-            .getVariants(sessionId)
-            .filter((variant) => variant.status === 'succeeded');
-        for (const variant of variants) {
-            try {
-                await this.persistCompletedArtifactVariant({
-                    sessionId,
-                    workItemId: variant.workItemId,
-                });
-            }
-            catch (err) {
-                log.warn(`persistCompletedFreshVariantsForCommit failed for ${sessionId}/${variant.workItemId}`, err);
-            }
-        }
-    }
-    async persistVariantHistoryAtCommit(args) {
-        const variants = this.store.getVariants(args.sessionId);
-        for (const variant of variants) {
-            if (variant.status !== 'succeeded')
-                continue;
-            const workItemId = variant.workItemId;
-            const isChosen = workItemId === args.chosenVariantId;
-            const status = isChosen
-                ? 'committed'
-                : 'rejected';
-            const saved = isChosen
-                ? await this.getSavedVariant({
-                    projectPath: args.projectPath,
-                    sessionId: args.sessionId,
-                    variantId: workItemId,
-                })
-                : null;
-            await this.variantHistory.markStatus({
-                projectPath: args.projectPath,
-                sessionId: saved?.manifest.sessionId ?? args.sessionId,
-                variantId: saved?.manifest.variantId ?? workItemId,
-                status,
-                destinationPath: isChosen ? args.destinationPath : undefined,
-                runnablePath: args.runnablePaths?.get(workItemId),
-            });
-        }
-    }
     async markPersistedVariantsCancelled(sessionId) {
         if (!this.store.hasSession(sessionId))
             return;
@@ -3175,180 +2720,6 @@ class AgentVariantsOrchestrator {
             return undefined;
         }
     }
-    preserveUnchosenVariants(args) {
-        const resources = this.resources.get(args.sessionId);
-        const runnablePaths = new Map();
-        if (!resources)
-            return runnablePaths;
-        const destinationParent = path_1.default.dirname(args.destinationPath);
-        const projectSlug = path_1.default.basename(args.destinationPath);
-        const historyDir = (0, createProjectArtifacts_1.createVariantsHistoryPath)(destinationParent, projectSlug);
-        const briefs = this.store.getBriefs(args.sessionId);
-        const variants = this.store.getVariants(args.sessionId);
-        const briefIndexById = new Map(briefs.map((b, i) => [b.briefId, i]));
-        const manifestEntries = [];
-        let chosenSlug = '';
-        for (const variant of variants) {
-            const input = this.store.getVariantWorkItemInput(args.sessionId, variant.workItemId);
-            const label = input?.briefLabel ?? variant.label ?? 'variant';
-            const slug = (0, createProjectArtifacts_1.createProjectVariantSlug)(label);
-            const briefIdx = briefIndexById.get(variant.briefId) ?? 0;
-            const numericPrefix = String(briefIdx + 1).padStart(2, '0');
-            const folderName = `${numericPrefix}-${slug}`;
-            if (variant.workItemId === args.chosenVariantId) {
-                chosenSlug = slug;
-                runnablePaths.set(variant.workItemId, projectSlug);
-                manifestEntries.push({
-                    variantId: variant.workItemId,
-                    label,
-                    slug,
-                    folder: null,
-                    isChosen: true,
-                    chosenPath: `../${projectSlug}`,
-                });
-                continue;
-            }
-            const record = this.workspaceInventory.getWorktree(args.sessionId, variant.workItemId);
-            if (!record) {
-                manifestEntries.push({
-                    variantId: variant.workItemId,
-                    label,
-                    slug,
-                    folder: null,
-                    isChosen: false,
-                });
-                continue;
-            }
-            if (!fs_1.default.existsSync(record.worktreePath)) {
-                manifestEntries.push({
-                    variantId: variant.workItemId,
-                    label,
-                    slug,
-                    folder: null,
-                    isChosen: false,
-                });
-                continue;
-            }
-            try {
-                const newPath = this.worktrees.moveWorktreeToHistory
-                    ? this.worktrees.moveWorktreeToHistory(record.worktreePath, historyDir, folderName)
-                    : (() => {
-                        fs_1.default.mkdirSync(historyDir, { recursive: true });
-                        const dest = path_1.default.join(historyDir, folderName);
-                        fs_1.default.renameSync(record.worktreePath, dest);
-                        return dest;
-                    })();
-                record.worktreePath = newPath;
-                runnablePaths.set(variant.workItemId, `${path_1.default.basename(historyDir)}/${folderName}`);
-                manifestEntries.push({
-                    variantId: variant.workItemId,
-                    label,
-                    slug,
-                    folder: folderName,
-                    isChosen: false,
-                });
-            }
-            catch (err) {
-                log.warn(`moveWorktreeToHistory failed for variant ${variant.workItemId}`, err);
-                manifestEntries.push({
-                    variantId: variant.workItemId,
-                    label,
-                    slug,
-                    folder: null,
-                    isChosen: false,
-                });
-            }
-        }
-        const manifest = {
-            schemaVersion: createProjectArtifacts_1.CREATE_PROJECT_MANIFEST_SCHEMA_VERSION,
-            createdAt: new Date().toISOString(),
-            sessionId: args.sessionId,
-            chosenVariantId: args.chosenVariantId,
-            chosenSlug: chosenSlug || projectSlug,
-            variants: manifestEntries,
-        };
-        try {
-            (0, createProjectArtifacts_1.writeCreateProjectManifestFile)((0, createProjectArtifacts_1.createVariantsHistoryManifestPath)(destinationParent, projectSlug), manifest);
-        }
-        catch (err) {
-            log.warn(`Writing variants history manifest failed for ${historyDir}`, err);
-        }
-        this.workspaceInventory.preserveViteSibling(args.sessionId);
-        return runnablePaths;
-    }
-    async renameWorktreeIntoDestination(sourceWorktreePath, destinationPath) {
-        const destinationParent = path_1.default.dirname(destinationPath);
-        await fs_1.default.promises.mkdir(destinationParent, { recursive: true });
-        let preservedRivetParent;
-        const existingRivetPath = path_1.default.join(destinationPath, '.rivet');
-        if (fs_1.default.existsSync(destinationPath)) {
-            preservedRivetParent = await fs_1.default.promises.mkdtemp(path_1.default.join(destinationParent, '.rivet-preserve-'));
-            if (fs_1.default.existsSync(existingRivetPath)) {
-                await fs_1.default.promises.rename(existingRivetPath, path_1.default.join(preservedRivetParent, '.rivet'));
-            }
-            await fs_1.default.promises.rm(destinationPath, { recursive: true, force: true });
-        }
-        try {
-            await fs_1.default.promises.rename(sourceWorktreePath, destinationPath);
-        }
-        catch (err) {
-            if (preservedRivetParent && !fs_1.default.existsSync(destinationPath)) {
-                await fs_1.default.promises.mkdir(destinationPath, { recursive: true });
-                const preservedRivetPath = path_1.default.join(preservedRivetParent, '.rivet');
-                if (fs_1.default.existsSync(preservedRivetPath)) {
-                    await fs_1.default.promises.rename(preservedRivetPath, existingRivetPath);
-                }
-            }
-            throw err;
-        }
-        if (preservedRivetParent) {
-            const preservedRivetPath = path_1.default.join(preservedRivetParent, '.rivet');
-            if (fs_1.default.existsSync(preservedRivetPath)) {
-                if (fs_1.default.existsSync(existingRivetPath)) {
-                    await fs_1.default.promises.cp(preservedRivetPath, existingRivetPath, {
-                        recursive: true,
-                        force: true,
-                    });
-                    await fs_1.default.promises.rm(preservedRivetPath, {
-                        recursive: true,
-                        force: true,
-                    });
-                }
-                else {
-                    await fs_1.default.promises.rename(preservedRivetPath, existingRivetPath);
-                }
-            }
-            await fs_1.default.promises.rm(preservedRivetParent, {
-                recursive: true,
-                force: true,
-            });
-        }
-        const dotGit = path_1.default.join(destinationPath, '.git');
-        try {
-            fs_1.default.rmSync(dotGit, { recursive: true, force: true });
-        }
-        catch { }
-        try {
-            const git = (0, simple_git_1.simpleGit)(destinationPath);
-            await git.raw(['init']);
-            await git.raw(['add', '-A']);
-            await git
-                .raw([
-                '-c',
-                'user.name=Rivet',
-                '-c',
-                'user.email=hello@tryrivet.design',
-                'commit',
-                '--no-gpg-sign',
-                '-m',
-                'Initial commit (created with Rivet)',
-            ])
-                .catch(() => { });
-        }
-        catch (err) {
-            log.warn(`Initial git history setup at ${destinationPath} failed`, err);
-        }
-    }
     async teardownSession(sessionId, reason) {
         const resources = this.resources.get(sessionId);
         if (!resources)
@@ -3363,17 +2734,8 @@ class AgentVariantsOrchestrator {
             this.settleHistoryPersists(),
             new Promise((resolve) => setTimeout(resolve, SETTLE_PERSISTS_TEARDOWN_TIMEOUT_MS)),
         ]);
-        await this.previewRuntime.closeSession(sessionId, reason);
-        let isFresh = false;
-        try {
-            isFresh = this.store.getProjectContext(sessionId).kind === 'fresh';
-        }
-        catch { }
-        await this.workspaceInventory.disposeAssignments({
-            sessionId,
-            isFresh,
-            isCommitted: reason === 'committed',
-        });
+        await this.previewRuntime.closeSession(sessionId);
+        await this.workspaceInventory.disposeAssignments({ sessionId });
         this.resources.delete(sessionId);
     }
     ensureResources(sessionId) {
@@ -3381,7 +2743,6 @@ class AgentVariantsOrchestrator {
         if (!r) {
             r = {
                 sessionId,
-                committedVariantIds: new Set(),
                 startedAt: Date.now(),
                 nextRoundIndex: 0,
                 rounds: new Map(),