rivet-design 0.9.4 → 0.9.5

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

@@ -4,9 +4,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AgentVariantsOrchestrator = void 0;
+exports.buildStaticPreviewDocument = buildStaticPreviewDocument;
 const crypto_1 = require("crypto");
 const events_1 = require("events");
 const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
 const path_1 = __importDefault(require("path"));
 const child_process_1 = require("child_process");
 const simple_git_1 = require("simple-git");
@@ -17,6 +19,7 @@ const contracts_1 = require("./contracts");
 const viteReactTs_1 = require("../../services/templates/viteReactTs");
 const designCatalog_1 = require("../../services/templates/designCatalog");
 const previewQa_1 = require("./previewQa");
+const VariantHistoryService_1 = require("../../services/VariantHistoryService");
 const log = (0, logger_1.createLogger)('AgentVariantsOrchestrator');
 const FRESH_DEV_SERVER_HOST = '127.0.0.1';
 /**
@@ -209,6 +212,7 @@ class AgentVariantsOrchestrator {
     materializeProject;
     previewQaRunner;
     switchPreviewPort;
+    variantHistory;
     resources = new Map();
     /**
      * Committed dev servers from prior sessions that survived teardown. The
@@ -248,6 +252,7 @@ class AgentVariantsOrchestrator {
             deps.materializeProject ?? defaultMaterializeProject;
         this.previewQaRunner = deps.previewQaRunner ?? defaultPreviewQaRunner;
         this.switchPreviewPort = deps.switchPreviewPort;
+        this.variantHistory = deps.variantHistory ?? new VariantHistoryService_1.VariantHistoryService();
     }
     // --- Pure delegations (no side effects) ---------------------------------
     propose(args) {
@@ -736,6 +741,9 @@ class AgentVariantsOrchestrator {
             fromStage: stageBefore,
         });
         this.emitChange();
+        void this.markPersistedVariantsCancelled(args.sessionId).catch((err) => {
+            log.warn(`markPersistedVariantsCancelled failed for ${args.sessionId}`, err);
+        });
         void this.teardownSession(args.sessionId, 'cancel').catch((err) => {
             log.error(`teardownSession failed for ${args.sessionId}`, err);
         });
@@ -763,6 +771,11 @@ class AgentVariantsOrchestrator {
             alreadyTerminal: result.alreadyTerminal,
             reason: args.reason ?? null,
         });
+        if (!result.alreadyTerminal) {
+            void this.markPersistedVariantCancelled(args.sessionId, args.variantId).catch((err) => {
+                log.warn(`markPersistedVariantCancelled failed for ${args.sessionId}/${args.variantId}`, err);
+            });
+        }
         this.emitChange();
         return {
             sessionId: args.sessionId,
@@ -808,6 +821,38 @@ class AgentVariantsOrchestrator {
         // without going back through resources (which may have been torn down).
         const existingPick = this.store.getVariantPick(args.sessionId);
         if (existingPick && existingPick.variantId === args.variantId) {
+            // Retry-safe history flip. If the first commit attempt enqueued
+            // successfully but the history-persist task crashed (it's
+            // fire-and-forget — see persistVariantHistoryAtCommit call site),
+            // the chosen variant stays at `completed` instead of `committed`
+            // on disk. Re-run the flip on every duplicate attempt; the
+            // terminal-status guard in `markStatus` makes this safely
+            // idempotent.
+            const projectContext = this.store.getProjectContext(args.sessionId);
+            let historyProjectPath;
+            if (projectContext.kind === 'fresh') {
+                historyProjectPath = projectContext.workspaceRoot;
+            }
+            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);
+                });
+            }
             return {
                 enqueued: false,
                 duplicate: true,
@@ -831,16 +876,9 @@ class AgentVariantsOrchestrator {
         let payload;
         let envelopeDestination;
         let changedFilesCount;
-        let freshVariantFolderName;
         if (projectContext.kind === 'fresh') {
             const destinationPath = projectContext.workspacePath;
             this.assertDestinationAvailable(destinationPath);
-            const variantFolderName = this.getFreshVariantFolderName({
-                sessionId: args.sessionId,
-                variantId: args.variantId,
-                variantName: input.briefLabel,
-            });
-            freshVariantFolderName = variantFolderName;
             const freshMode = projectContext.executionPlan?.mode === 'vite_app'
                 ? 'vite_app'
                 : 'static_preview';
@@ -950,11 +988,16 @@ class AgentVariantsOrchestrator {
             }
             else {
                 // Static_preview: HTML is the entire deliverable. Write index.html.
+                // Prefer the in-memory record; fall back to the persisted history at
+                // `<workspaceRoot>/.rivet/variants/<sessionId>/<variantId>/files/index.html`
+                // so a process restart between report_variant_complete and commit
+                // doesn't strand the variant.
                 const staticPreview = resources.staticPreviews.get(args.variantId);
-                const persistedSnapshotIndexPath = (0, createProjectArtifacts_1.createProjectVariantIndexPath)(destinationPath, variantFolderName);
-                const htmlFromSnapshot = fs_1.default.existsSync(persistedSnapshotIndexPath)
-                    ? fs_1.default.readFileSync(persistedSnapshotIndexPath, 'utf8')
-                    : null;
+                const htmlFromSnapshot = await this.variantHistory.readStaticPreview({
+                    projectPath: projectContext.workspaceRoot,
+                    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`);
                 }
@@ -1028,27 +1071,25 @@ class AgentVariantsOrchestrator {
             sessionId: args.sessionId,
             envelope,
         });
-        if (projectContext.kind === 'fresh') {
-            // Manifest persistence is bookkeeping for the .rivet/ artifacts and must
-            // never strand the session — `recordVariantPick` above has already marked
-            // this variant as the selection, so a retry would short-circuit via the
-            // `duplicate: true` path and skip the enqueue below. Catch and log
-            // instead of letting a filesystem hiccup block the handoff to pending-
-            // changes.
-            try {
-                this.persistFreshSelectionMetadata({
-                    sessionId: args.sessionId,
-                    variantId: args.variantId,
-                    variantName: input.briefLabel,
-                    projectPath: projectContext.workspacePath,
-                    variantFolderName: freshVariantFolderName ?? (0, createProjectArtifacts_1.createProjectVariantSlug)(input.briefLabel),
-                    changedFilesCount,
-                });
-            }
-            catch (err) {
-                log.warn(`persistFreshSelectionMetadata failed for session ${args.sessionId} variant ${args.variantId} — continuing with enqueue`, err);
-            }
-        }
+        // History: flip every persisted variant in this session to its terminal
+        // status. Variants were persisted at code_gen success time; this only
+        // patches the status (+ destinationPath on the chosen one). For fresh
+        // sessions, history lives at `<workspaceRoot>/.rivet/variants/` — the
+        // user's working dir — so all variants from any session in the workspace
+        // accumulate in one place, not per-subproject. Best-effort, never blocks
+        // the commit.
+        const historyProjectPath = projectContext.kind === 'fresh'
+            ? projectContext.workspaceRoot
+            : envelopeDestination;
+        void this.persistVariantHistoryAtCommit({
+            sessionId: args.sessionId,
+            chosenVariantId: args.variantId,
+            projectPath: historyProjectPath,
+            projectKind: projectContext.kind,
+            destinationPath: envelopeDestination,
+        }).catch((err) => {
+            log.warn(`persistVariantHistoryAtCommit failed for session ${args.sessionId}`, err);
+        });
         const enqueueResult = this.adapter.enqueue(envelope);
         resources.committedVariantIds.add(args.variantId);
         if (this.activeSessionId === args.sessionId) {
@@ -1090,12 +1131,17 @@ class AgentVariantsOrchestrator {
     /**
      * Ensure the user-facing destination path can receive the new project.
      * Rejects when the path exists and is non-empty.
+     *
+     * `.rivet/` (pre-commit snapshots + history manifests) and `.gitignore`
+     * (written by VariantHistoryService.ensureGitignore when variants persist
+     * at success time) are both tolerated — neither is user-authored content
+     * that would be clobbered by the materialize step.
      */
     assertDestinationAvailable(destinationPath) {
         if (!fs_1.default.existsSync(destinationPath))
             return;
         const entries = fs_1.default.readdirSync(destinationPath);
-        const userVisibleEntries = entries.filter((entry) => entry !== '.rivet');
+        const userVisibleEntries = entries.filter((entry) => entry !== '.rivet' && entry !== '.gitignore');
         if (userVisibleEntries.length === 0)
             return;
         throw new errors_1.AgentVariantsError('DESTINATION_NOT_EMPTY', `Destination ${destinationPath} is not empty (${userVisibleEntries.length} entries) — refuse to materialize.`);
@@ -1187,10 +1233,16 @@ class AgentVariantsOrchestrator {
             designContext: summarizeDesignContext(designContext),
         });
         log.info(`Provisioning ${codeGenIds.length} fresh worktree(s) for session ${sessionId}`);
-        // destinationParent for fresh worktrees: same parent the materialized
-        // project will land in. Keeping the worktree on the same volume turns
-        // commit into a directory rename instead of a recursive copy.
-        const destinationParent = path_1.default.dirname(projectContext.workspacePath);
+        // destinationParent for fresh worktrees: the user's workspace root
+        // (sibling to `.rivet/`). Keeping the worktree on the same volume as
+        // the materialize destination turns commit into a directory rename
+        // instead of a recursive copy. `path.dirname(workspacePath)` *used*
+        // to equal `workspaceRoot`, but after nesting subprojects under
+        // `<workspaceRoot>/.rivet/<slug>/` the dirname is now `.rivet/`,
+        // which would stage worktrees inside `.rivet/.rivet-variants/`.
+        // Use workspaceRoot directly so staging lives at
+        // `<workspaceRoot>/.rivet-variants/` as originally intended.
+        const destinationParent = projectContext.workspaceRoot;
         const paths = await createFresh.call(this.worktrees, sessionId, codeGenIds.length, viteReactTs_1.VITE_REACT_TS_TEMPLATE, designContext, sourceContext, destinationParent);
         resources.scaffoldBaseWorkItemId = scaffoldId;
         resources.freshDestinationParent = destinationParent;
@@ -1387,10 +1439,17 @@ class AgentVariantsOrchestrator {
                     };
                     resources.staticPreviews.set(workItemId, record);
                     if (this.store.getProjectContext(sessionId).kind === 'fresh') {
-                        this.persistFreshVariantArtifacts({
+                        // History at `<workspaceRoot>/.rivet/variants/<sessionId>/<variantId>/`
+                        // is the sole on-disk record. The legacy per-subproject snapshot
+                        // tree (`<slug>/.rivet/<variantName>/`) is no longer written —
+                        // it duplicated this data in a parallel layout and cluttered
+                        // `.rivet/` with slug-named directories before the user ever
+                        // committed.
+                        this.persistCompletedFreshVariant({
                             sessionId,
                             workItemId,
-                            html: staticPreview.html,
+                        }).catch((err) => {
+                            log.warn(`persistCompletedFreshVariant failed for ${sessionId}/${workItemId}`, err);
                         });
                     }
                     const leasedAt = resources.leasedAt.get(workItemId);
@@ -1424,6 +1483,31 @@ class AgentVariantsOrchestrator {
         catch (err) {
             log.warn(`getDiff failed for ${record.worktreePath}`, err);
         }
+        // History: persist every completed variant immediately to
+        // `<projectPath>/.rivet/variants/`. Existing projects pass the captured
+        // diff (or an empty string when capture itself failed — the variant
+        // still succeeded code-gen-wise, and the history row is the only
+        // record the UI has). Fresh-project variants copy their worktree
+        // (vite_app) or the staged HTML (static_preview). Best-effort — a
+        // failure here must never block dev-server startup or the user's pick
+        // flow.
+        if (!isFresh) {
+            this.persistCompletedExistingVariant({
+                sessionId,
+                workItemId,
+                diff: record.diff ?? '',
+            }).catch((err) => {
+                log.warn(`persistCompletedExistingVariant failed for ${sessionId}/${workItemId}`, err);
+            });
+        }
+        else {
+            this.persistCompletedFreshVariant({
+                sessionId,
+                workItemId,
+            }).catch((err) => {
+                log.warn(`persistCompletedFreshVariant failed for ${sessionId}/${workItemId}`, err);
+            });
+        }
         // Bring up a dev server in the variant's worktree so the user can cycle
         // through live variants in the iframe via the chip. Failures here are
         // logged but non-fatal — the user can still pick by reading the diff.
@@ -1463,80 +1547,206 @@ class AgentVariantsOrchestrator {
             log.warn(`Failed to start dev server for variant ${workItemId}; live preview disabled for this variant`, err);
         }
     }
-    persistFreshVariantArtifacts(args) {
+    /**
+     * Persist a completed existing-project code_gen variant into
+     * `<env.projectPath>/.rivet/variants/<sessionId>/<variantId>/`. Called from
+     * `handleSucceededReport` once the worktree diff has been captured but
+     * before the user picks. Status is `completed` until `commitVariant` or a
+     * cancellation transitions it.
+     */
+    async persistCompletedExistingVariant(args) {
         const projectContext = this.store.getProjectContext(args.sessionId);
-        if (projectContext.kind !== 'fresh') {
+        if (projectContext.kind !== 'existing')
             return;
+        let projectPath;
+        try {
+            const env = await this.resolveEnv(args.sessionId);
+            projectPath = env.projectPath;
         }
-        const projectPath = projectContext.workspacePath;
-        const now = new Date().toISOString();
-        const projectManifestPath = (0, createProjectArtifacts_1.createProjectManifestPath)(projectPath);
-        const existingProjectManifest = this.readManifest(projectManifestPath);
-        (0, createProjectArtifacts_1.writeCreateProjectManifestFile)(projectManifestPath, (0, createProjectArtifacts_1.createProjectManifest)({
-            createdAt: existingProjectManifest?.createdAt ?? now,
-            selectedDesignSlug: existingProjectManifest?.selectedDesignSlug,
-            latestVariantSessionId: args.sessionId,
-            selectedVariantId: existingProjectManifest?.selectedVariantId,
-        }));
-        const briefInput = this.store.getWorkItemInput(args.sessionId, args.workItemId);
-        const variantFolderName = this.getFreshVariantFolderName({
-            sessionId: args.sessionId,
-            variantId: args.workItemId,
-            variantName: briefInput.briefLabel,
-        });
-        const snapshotPath = (0, createProjectArtifacts_1.createProjectVariantSnapshotPath)(projectPath, variantFolderName);
-        fs_1.default.rmSync(snapshotPath, { recursive: true, force: true });
-        fs_1.default.mkdirSync(snapshotPath, { recursive: true });
-        const briefPath = (0, createProjectArtifacts_1.createProjectVariantBriefPath)(projectPath, variantFolderName);
-        fs_1.default.writeFileSync(briefPath, `# ${briefInput.briefLabel}\n\n${briefInput.briefBody}\n`, 'utf8');
-        const variantManifestPath = (0, createProjectArtifacts_1.createProjectVariantManifestPath)(projectPath, variantFolderName);
-        (0, createProjectArtifacts_1.writeCreateProjectManifestFile)(variantManifestPath, {
-            schemaVersion: createProjectArtifacts_1.CREATE_PROJECT_MANIFEST_SCHEMA_VERSION,
-            createdAt: now,
+        catch (err) {
+            log.warn(`persistCompletedExistingVariant: resolveEnv failed for ${args.sessionId}`, err);
+            return;
+        }
+        const input = this.store.getWorkItemInput(args.sessionId, args.workItemId);
+        const sessionPrompt = this.store.getPrompt(args.sessionId);
+        await this.variantHistory.persistVariant({
+            projectPath,
             sessionId: args.sessionId,
             variantId: args.workItemId,
-            variantName: briefInput.briefLabel,
-            variantFolderName,
-            changedFilesCount: 1,
-        });
-        fs_1.default.writeFileSync((0, createProjectArtifacts_1.createProjectVariantIndexPath)(projectPath, variantFolderName), args.html, 'utf8');
-    }
-    persistFreshSelectionMetadata(args) {
-        const now = new Date().toISOString();
-        const projectManifestPath = (0, createProjectArtifacts_1.createProjectManifestPath)(args.projectPath);
-        const existingProjectManifest = this.readManifest(projectManifestPath);
-        (0, createProjectArtifacts_1.writeCreateProjectManifestFile)(projectManifestPath, (0, createProjectArtifacts_1.createProjectManifest)({
-            createdAt: existingProjectManifest?.createdAt ?? now,
-            selectedDesignSlug: existingProjectManifest?.selectedDesignSlug,
-            latestVariantSessionId: args.sessionId,
-            selectedVariantId: args.variantId,
-        }));
-        const variantManifestPath = (0, createProjectArtifacts_1.createProjectVariantManifestPath)(args.projectPath, args.variantFolderName);
-        const existingVariantManifest = this.readManifest(variantManifestPath);
-        (0, createProjectArtifacts_1.writeCreateProjectManifestFile)(variantManifestPath, {
-            ...existingVariantManifest,
-            schemaVersion: createProjectArtifacts_1.CREATE_PROJECT_MANIFEST_SCHEMA_VERSION,
-            createdAt: existingVariantManifest?.createdAt ?? now,
-            sessionId: args.sessionId,
-            variantId: args.variantId,
-            variantName: args.variantName,
-            variantFolderName: args.variantFolderName,
-            changedFilesCount: args.changedFilesCount,
-            selectedVariantId: args.variantId,
+            label: input.briefLabel,
+            brief: input.briefBody,
+            sessionPrompt,
+            kind: 'diff',
+            diff: args.diff,
+            changedFilesCount: countDiffFiles(args.diff),
+            projectKind: 'existing',
         });
     }
-    getFreshVariantFolderName(args) {
-        const baseSlug = (0, createProjectArtifacts_1.createProjectVariantSlug)(args.variantName);
+    /**
+     * Persist a completed fresh-project variant into
+     * `<projectContext.workspacePath>/.rivet/variants/<sessionId>/<variantId>/`.
+     * Called from `handleSucceededReport` right after the per-variant snapshot
+     * lands on disk — for static_preview that's the `.rivet/<slug>/` snapshot
+     * dir; for vite_app fresh variants it's the worktree itself. Status starts
+     * as 'completed' and transitions to 'committed' / 'rejected' / 'cancelled'
+     * via `markStatus` at commit or teardown time.
+     *
+     * Running at success time (rather than commit time) means the history panel
+     * populates live as variants generate — including when the user never picks
+     * one. Mirrors the existing-project persistCompletedExistingVariant flow.
+     */
+    async persistCompletedFreshVariant(args) {
+        const projectContext = this.store.getProjectContext(args.sessionId);
+        if (projectContext.kind !== 'fresh')
+            return;
+        // Variant history lives at the workspace root — the user's working
+        // dir (e.g. `fable-eng-demo/`). All variants from any session in this
+        // workspace accumulate at
+        // `<workspaceRoot>/.rivet/variants/<sessionId>/<variantId>/`.
+        const historyProjectPath = projectContext.workspaceRoot;
+        const input = this.store.getWorkItemInput(args.sessionId, args.workItemId);
+        const sessionPrompt = this.store.getPrompt(args.sessionId);
+        const designArtifact = resolveDesignArtifact(input.designContextEntry);
+        const resources = this.resources.get(args.sessionId);
+        const worktreeRecord = resources?.worktrees.get(args.workItemId);
+        const staticPreview = resources?.staticPreviews.get(args.workItemId);
+        // Vite_app deliverables are full scaffolded worktrees — pass the worktree
+        // directory as sourceDir and let copyDirFiltered handle it (excludes
+        // node_modules, .rivet, etc). Static_preview deliverables are inline HTML
+        // captured in `resources.staticPreviews`; stage them in a tmp dir so the
+        // existing copy path works without poking the user's workspace.
+        let sourceDir = null;
+        let tmpStagingDir = null;
+        if (worktreeRecord && fs_1.default.existsSync(worktreeRecord.worktreePath)) {
+            sourceDir = worktreeRecord.worktreePath;
+        }
+        else if (staticPreview) {
+            tmpStagingDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), `rivet-variant-${args.workItemId}-`));
+            fs_1.default.writeFileSync(path_1.default.join(tmpStagingDir, 'index.html'), staticPreview.html, 'utf8');
+            fs_1.default.writeFileSync(path_1.default.join(tmpStagingDir, 'brief.md'), `# ${input.briefLabel}\n\n${input.briefBody}\n`, 'utf8');
+            sourceDir = tmpStagingDir;
+        }
+        if (!sourceDir) {
+            log.warn(`persistCompletedFreshVariant: no source for ${args.workItemId} (session ${args.sessionId}); skipping`);
+            return;
+        }
+        // For static_preview, only `index.html` is a real deliverable — `brief.md`
+        // is implementation-detail staging that we copy alongside it. Hardcode
+        // the count so the history row matches what `commit_variant` reports
+        // (always 1) instead of double-counting the brief.
+        const changedFilesCount = staticPreview
+            ? 1
+            : countWorktreeFiles(sourceDir);
+        try {
+            await this.variantHistory.persistVariant({
+                projectPath: historyProjectPath,
+                sessionId: args.sessionId,
+                variantId: args.workItemId,
+                label: input.briefLabel,
+                brief: input.briefBody,
+                sessionPrompt,
+                kind: 'project-created',
+                sourceDir,
+                changedFilesCount,
+                projectKind: 'fresh',
+                designMarkdown: designArtifact?.markdown,
+                designSource: designArtifact?.source,
+            });
+        }
+        finally {
+            if (tmpStagingDir) {
+                try {
+                    fs_1.default.rmSync(tmpStagingDir, { recursive: true, force: true });
+                }
+                catch (err) {
+                    log.warn(`Failed to clean up variant staging dir ${tmpStagingDir}: ${err instanceof Error ? err.message : String(err)}`);
+                }
+            }
+        }
+    }
+    /**
+     * At commit time, flip persisted variant manifests to terminal statuses
+     * ('committed' for the chosen, 'rejected' for the rest). Both existing- and
+     * fresh-project variants have already been persisted at code_gen success
+     * time, so this is a pure status update — no source-dir copy required.
+     * Also records the destination path on the chosen variant so history can
+     * surface "this variant became <path>".
+     */
+    async persistVariantHistoryAtCommit(args) {
         const variants = this.store.getVariants(args.sessionId);
-        const matchingVariants = variants.filter((variant) => {
-            const input = this.store.getWorkItemInput(args.sessionId, variant.workItemId);
-            return (0, createProjectArtifacts_1.createProjectVariantSlug)(input.briefLabel ?? '') === baseSlug;
+        for (const variant of variants) {
+            if (variant.status !== 'succeeded')
+                continue;
+            const workItemId = variant.workItemId;
+            const isChosen = workItemId === args.chosenVariantId;
+            const status = isChosen
+                ? 'committed'
+                : 'rejected';
+            await this.variantHistory.markStatus({
+                projectPath: args.projectPath,
+                sessionId: args.sessionId,
+                variantId: workItemId,
+                status,
+                destinationPath: isChosen ? args.destinationPath : undefined,
+            });
+        }
+    }
+    /**
+     * Flip persisted variant manifests to status='cancelled' for every variant
+     * in the session that was already snapshotted to disk. Fresh- and existing-
+     * project variants both persist at success time now, so both need their
+     * manifests flipped here. Best-effort — missing manifests are silently
+     * skipped by VariantHistoryService.markStatus.
+     */
+    async markPersistedVariantsCancelled(sessionId) {
+        if (!this.store.hasSession(sessionId))
+            return;
+        const projectPath = await this.resolveHistoryProjectPath(sessionId);
+        if (!projectPath)
+            return;
+        const variants = this.store.getVariants(sessionId);
+        for (const variant of variants) {
+            await this.variantHistory.markStatus({
+                projectPath,
+                sessionId,
+                variantId: variant.workItemId,
+                status: 'cancelled',
+            });
+        }
+    }
+    async markPersistedVariantCancelled(sessionId, variantId) {
+        if (!this.store.hasSession(sessionId))
+            return;
+        const projectPath = await this.resolveHistoryProjectPath(sessionId);
+        if (!projectPath)
+            return;
+        await this.variantHistory.markStatus({
+            projectPath,
+            sessionId,
+            variantId,
+            status: 'cancelled',
         });
-        const index = matchingVariants.findIndex((variant) => variant.workItemId === args.variantId);
-        if (index <= 0) {
-            return baseSlug;
+    }
+    /**
+     * Resolve the project path that owns `.rivet/variants/` for a session.
+     * Existing sessions: the user's project (via `resolveEnv`). Fresh sessions:
+     * the *workspace root*, which is the parent of `workspacePath` — variants
+     * accumulate there across sessions instead of being scattered under each
+     * subproject. Must match what `persistCompletedFreshVariant` writes to.
+     */
+    async resolveHistoryProjectPath(sessionId) {
+        const projectContext = this.store.getProjectContext(sessionId);
+        if (projectContext.kind === 'fresh') {
+            return projectContext.workspaceRoot;
+        }
+        try {
+            const env = await this.resolveEnv(sessionId);
+            return env.projectPath;
+        }
+        catch (err) {
+            log.warn(`resolveHistoryProjectPath: resolveEnv failed for ${sessionId}`, err);
+            return null;
         }
-        return `${baseSlug}-${index + 1}`;
     }
     readManifest(manifestPath) {
         if (!fs_1.default.existsSync(manifestPath)) {
@@ -1995,11 +2205,33 @@ function parseStaticPreviewOutput(output) {
     };
 }
 function buildStaticPreviewDocument(input) {
-    if (/<!doctype html>|<html[\s>]/i.test(input.html)) {
-        return input.html;
-    }
     const style = input.css ? `<style>\n${input.css}\n</style>` : '';
     const script = input.js ? `<script>\n${input.js}\n</script>` : '';
+    if (/<!doctype html>|<html[\s>]/i.test(input.html)) {
+        // Full document: inject css before </head> and js before </body>. The
+        // agent often passes a complete `<!doctype html>...` blob with css/js
+        // alongside; without this they're silently dropped and the variant ships
+        // unstyled and non-interactive. Falls back to appending to the end if
+        // the closing tag isn't found.
+        let doc = input.html;
+        if (style) {
+            if (/<\/head>/i.test(doc)) {
+                doc = doc.replace(/<\/head>/i, () => `${style}\n</head>`);
+            }
+            else {
+                doc += `\n${style}`;
+            }
+        }
+        if (script) {
+            if (/<\/body>/i.test(doc)) {
+                doc = doc.replace(/<\/body>/i, () => `${script}\n</body>`);
+            }
+            else {
+                doc += `\n${script}`;
+            }
+        }
+        return doc;
+    }
     return `<!doctype html>
 <html lang="en">
   <head>
@@ -2061,6 +2293,7 @@ const toActiveProjectContext = (projectContext) => {
     return {
         kind: 'fresh',
         workspacePath: projectContext.workspacePath,
+        workspaceRoot: projectContext.workspaceRoot,
         framework: projectContext.framework,
         designContext: projectContext.designContext?.map((entry) => entry.kind === 'slug'
             ? { kind: 'slug', slug: entry.slug }
@@ -2161,6 +2394,36 @@ const addDesignContextArtifact = (artifactsByContent, artifact) => {
         usedByVariantCount: 1,
     });
 };
+/**
+ * Resolve a per-variant design context entry into the raw DESIGN.md markdown
+ * the worktree scaffolder writes, plus a small `designSource` descriptor for
+ * the variant manifest. Slug entries resolve through the bundled catalog;
+ * markdown entries (Agent Browser / inspiration extractor output) carry their
+ * stored markdown verbatim. Returns null when the entry is missing or the
+ * slug doesn't resolve to bundled markdown.
+ */
+const resolveDesignArtifact = (entry) => {
+    if (!entry)
+        return null;
+    if (entry.kind === 'markdown') {
+        return {
+            markdown: entry.content,
+            source: { kind: 'markdown', label: entry.label },
+        };
+    }
+    const markdown = (0, designCatalog_1.loadDesignSystemMarkdown)(entry.slug);
+    if (!markdown)
+        return null;
+    const catalogEntry = (0, designCatalog_1.getDesignSystemBySlug)(entry.slug);
+    return {
+        markdown,
+        source: {
+            kind: 'slug',
+            slug: entry.slug,
+            label: catalogEntry?.name ?? entry.slug,
+        },
+    };
+};
 const summarizeDesignContext = (designContext) => {
     if (!designContext)
         return null;