rivet-design 0.9.2 → 0.9.4

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

@@ -1,9 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SessionStore = exports.SCAFFOLD_LEASE_TTL_MS = exports.DEFAULT_LEASE_TTL_MS = void 0;
+exports.SessionStore = exports.SOURCE_PLAN_OUTPUT_SCHEMA = exports.SCAFFOLD_LEASE_TTL_MS = exports.DEFAULT_LEASE_TTL_MS = void 0;
 const crypto_1 = require("crypto");
 const errors_1 = require("./errors");
 const contracts_1 = require("./contracts");
+const sourceContext_1 = require("./sourceContext");
 const DEFAULT_VARIANT_COUNT = 4;
 const MAX_VARIANT_COUNT = 8;
 /** TTL for a lease on a code_gen work item. Bumped to 10min after observing
@@ -21,6 +22,7 @@ function fingerprint(parts) {
 function leaseTtlForKind(kind) {
     return kind === 'scaffold_base' ? exports.SCAFFOLD_LEASE_TTL_MS : exports.DEFAULT_LEASE_TTL_MS;
 }
+/** Describes the work item contract returned to an agent lease holder. */
 function descriptorFor(item) {
     return {
         id: item.id,
@@ -31,18 +33,77 @@ function descriptorFor(item) {
         output_schema: outputSchemaFor(item.kind),
     };
 }
+exports.SOURCE_PLAN_OUTPUT_SCHEMA = {
+    sourceIntent: 'Array<{url, role: design_source|interaction_reference|asset_source|content_reference|other, confidence: low|medium|high, reason}> — agent-decided URL classification; classify by prompt intent only, no deterministic URL heuristics.',
+    sourceContext: 'sourceFindings, sectionInventory, visualObservations, sourceRoles, qualityBar, screenshotReferences?, risks?',
+    designContexts: 'Array<{url, label, markdown}> REQUIRED for every design_source URL from sourceIntent (full browser-extracted DESIGN.md).',
+    executionPlan: "{ mode: 'static_preview' | 'vite_app', confidence: low|medium|high, reason, assetPlan?: Array<{source, destination, referenceAs}>, runtimeRequirements?, userQuestion? } — choose vite_app for large local assets, model-viewer, Three.js, route structure, package deps, or files under public/; assetPlan.source must live under the approved asset root; static_preview for self-contained HTML/CSS/JS prototypes.",
+};
+/** Returns the completion payload shape required for each leased work item. */
 function outputSchemaFor(kind) {
     switch (kind) {
+        case 'source_plan':
+            return exports.SOURCE_PLAN_OUTPUT_SCHEMA;
         case 'brief':
-            return { briefs: 'Array<{briefId, label, body}>' };
+            return { briefs: 'Array<{briefId, label, body, visualReferenceUrl?}>' };
         case 'scaffold_base':
             return { workspacePath: 'string', framework: 'string' };
+        case 'static_preview':
+            return { html: 'string', css: 'string?', js: 'string?' };
         case 'code_gen':
             return { worktreePath: 'string', changedFiles: 'string[]' };
         case 'cleanup_runtime':
             return { released: 'boolean' };
     }
 }
+const variantDesignFromInput = (entry) => {
+    if (!entry)
+        return undefined;
+    if (entry.kind === 'slug') {
+        return {
+            kind: 'slug',
+            slug: entry.slug,
+            displayName: entry.slug,
+        };
+    }
+    return {
+        kind: 'markdown',
+        label: entry.label,
+    };
+};
+const createBriefWorkItem = (args) => ({
+    id: (0, crypto_1.randomUUID)(),
+    kind: 'brief',
+    status: 'pending',
+    attempt: 0,
+    dependsOn: [],
+    input: {
+        prompt: args.prompt,
+        count: args.count,
+        target: args.target,
+        projectContext: args.projectContext,
+    },
+    acceptedReports: [],
+});
+/**
+ * Source-grounded fresh sessions require a single `source_plan` planning hop
+ * before briefs. Sessions without source URLs (or with the plan already
+ * materialized via `artifact`) skip straight to `awaiting_briefs`.
+ */
+const requiresSourcePlan = (projectContext) => {
+    if (projectContext.kind !== 'fresh')
+        return false;
+    const sourceContext = projectContext.sourceContext;
+    if (!sourceContext)
+        return false;
+    const hasSources = (sourceContext.sourceUrls?.length ?? 0) > 0;
+    if (!hasSources)
+        return false;
+    const hasArtifact = Boolean(sourceContext.artifact);
+    const hasIntent = Boolean(sourceContext.sourceIntent);
+    const hasExecutionPlan = Boolean(projectContext.executionPlan);
+    return !(hasArtifact && hasIntent && hasExecutionPlan);
+};
 class SessionStore {
     sessions = new Map();
     clock;
@@ -57,36 +118,58 @@ class SessionStore {
         }
         const projectContext = args.projectContext ?? { kind: 'existing' };
         const count = clampCount(args.count);
-        const briefItem = {
-            id: (0, crypto_1.randomUUID)(),
-            kind: 'brief',
-            status: 'pending',
-            attempt: 0,
-            dependsOn: [],
-            input: {
+        const sourceContextForPlan = projectContext.kind === 'fresh' ? projectContext.sourceContext : undefined;
+        const needsSourcePlan = requiresSourcePlan(projectContext);
+        const initialItem = needsSourcePlan
+            ? {
+                id: (0, crypto_1.randomUUID)(),
+                kind: 'source_plan',
+                status: 'pending',
+                attempt: 0,
+                dependsOn: [],
+                input: {
+                    prompt: args.prompt,
+                    count,
+                    target: args.target,
+                    sourceUrls: sourceContextForPlan?.sourceUrls ?? [],
+                    sourceArtifacts: sourceContextForPlan?.sourceArtifacts ?? [],
+                    preserveBrand: sourceContextForPlan?.preserveBrand ?? false,
+                    projectContext,
+                },
+                acceptedReports: [],
+            }
+            : createBriefWorkItem({
                 prompt: args.prompt,
                 count,
                 target: args.target,
                 projectContext,
-            },
-            acceptedReports: [],
-        };
+            });
         const record = {
             sessionId,
-            stage: 'awaiting_briefs',
+            stage: needsSourcePlan ? 'awaiting_source_plan' : 'awaiting_briefs',
             prompt: args.prompt,
             count,
             target: args.target,
             projectContext,
             briefs: [],
             approvedBriefs: [],
-            workItems: new Map([[briefItem.id, briefItem]]),
-            workItemOrder: [briefItem.id],
+            workItems: new Map([[initialItem.id, initialItem]]),
+            workItemOrder: [initialItem.id],
             acceptedFingerprints: new Map(),
             createdAt: this.clock.now(),
         };
         this.sessions.set(sessionId, record);
-        return { sessionId, briefWorkItem: briefItem };
+        return needsSourcePlan
+            ? {
+                sessionId,
+                stage: 'awaiting_source_plan',
+                sourcePlanWorkItem: initialItem,
+            }
+            : {
+                sessionId,
+                stage: 'awaiting_briefs',
+                briefWorkItem: initialItem,
+            };
     }
     reportBriefs(args) {
         const session = this.requireSession(args.sessionId);
@@ -122,6 +205,107 @@ class SessionStore {
         session.acceptedFingerprints.set(fp, result);
         return result;
     }
+    reportSourcePlan(args) {
+        const session = this.requireSession(args.sessionId);
+        const fp = fingerprint([
+            'reportSourcePlan',
+            args.sessionId,
+            args.workItemId,
+            args.leaseId,
+            args.attempt,
+            'succeeded',
+        ]);
+        const cached = session.acceptedFingerprints.get(fp);
+        if (cached)
+            return cached;
+        this.assertStage(session, ['awaiting_source_plan']);
+        const item = this.requireWorkItem(session, args.workItemId);
+        if (item.kind !== 'source_plan') {
+            throw new errors_1.AgentVariantsError('INVALID_STAGE_ACTION', `Work item ${args.workItemId} is not a source_plan item`);
+        }
+        this.validateLease(item, args.leaseId, args.attempt);
+        const { sourceIntent, sourceContext, designContexts, executionPlan } = args.sourcePlan;
+        // Cross-check: every source URL on the session must be classified, and
+        // every design_source URL must come with a browser-extracted DESIGN.md.
+        const sessionSourceUrls = session.projectContext.kind === 'fresh'
+            ? (session.projectContext.sourceContext?.sourceUrls ?? [])
+            : [];
+        const classifiedUrls = new Set(sourceIntent.sources.map((e) => e.url));
+        const missingClassification = sessionSourceUrls.filter((url) => !classifiedUrls.has(url));
+        if (missingClassification.length > 0) {
+            throw new errors_1.AgentVariantsError('SOURCE_CONTEXT_INVALID', `source_plan missing sourceIntent classification for: ${missingClassification.join(', ')}`);
+        }
+        const designSourceUrls = sourceIntent.sources
+            .filter((entry) => entry.role === 'design_source')
+            .map((entry) => entry.url);
+        const reportedDesignUrls = new Set((designContexts ?? []).map((entry) => entry.url));
+        const missingDesignContexts = designSourceUrls.filter((url) => !reportedDesignUrls.has(url));
+        if (missingDesignContexts.length > 0) {
+            throw new errors_1.AgentVariantsError('SOURCE_CONTEXT_INVALID', `Missing browser-extracted DESIGN.md for design source URL(s): ${missingDesignContexts.join(', ')}`);
+        }
+        const normalizedArtifact = (0, sourceContext_1.normalizeSourceContextArtifact)(sourceContext);
+        if (session.projectContext.kind === 'fresh') {
+            // Persist one designContext entry PER design_source URL, aligned
+            // to the SOURCE_INTENT design_source order (NOT the agent's
+            // designContexts submission order). Brief fan-out
+            // (provisionFreshWorktrees) reads slot [min(briefIndex, length-1)]
+            // and falls back to slot 0 — a single-source session still ships
+            // one shared markdown, but a multi-source session puts each
+            // design_source's DESIGN.md at a deterministic slot regardless of
+            // how many non-design_source entries the agent classified or the
+            // order it shipped designContexts in. Without this alignment, an
+            // extra interaction_reference URL ahead of a design_source in the
+            // agent's payload would push the wrong DESIGN.md onto variant 0.
+            const designContextByUrl = new Map();
+            for (const entry of designContexts ?? []) {
+                designContextByUrl.set(entry.url, {
+                    label: entry.label,
+                    markdown: entry.markdown,
+                });
+            }
+            const alignedDesignContexts = designSourceUrls
+                .map((url) => designContextByUrl.get(url))
+                .filter((entry) => Boolean(entry));
+            session.projectContext = {
+                ...session.projectContext,
+                ...(alignedDesignContexts.length > 0
+                    ? {
+                        designContext: alignedDesignContexts.map((entry) => ({
+                            kind: 'markdown',
+                            label: entry.label,
+                            content: entry.markdown,
+                        })),
+                    }
+                    : {}),
+                sourceContext: {
+                    ...(session.projectContext.sourceContext ?? {}),
+                    sourceIntent,
+                    artifact: normalizedArtifact,
+                },
+                executionPlan,
+            };
+        }
+        item.status = 'succeeded';
+        item.output = {
+            sourceIntent,
+            sourceContext: normalizedArtifact,
+            ...(designContexts ? { designContexts } : {}),
+            executionPlan,
+        };
+        item.lease = undefined;
+        const briefItem = createBriefWorkItem({
+            prompt: session.prompt,
+            count: session.count,
+            target: session.target,
+            projectContext: session.projectContext,
+        });
+        session.workItems.set(briefItem.id, briefItem);
+        session.workItemOrder.push(briefItem.id);
+        session.stage = 'awaiting_briefs';
+        const result = { briefWorkItem: briefItem };
+        session.acceptedFingerprints.set(fp, result);
+        return result;
+    }
     approve(args) {
         const session = this.requireSession(args.sessionId);
         this.assertStage(session, ['awaiting_approval']);
@@ -135,48 +319,114 @@ class SessionStore {
             }
         }
         session.approvedBriefs = args.selections;
+        const isFresh = session.projectContext.kind === 'fresh';
+        const executionPlan = session.projectContext.kind === 'fresh'
+            ? session.projectContext.executionPlan
+            : undefined;
+        // Surface an agent-flagged clarification as a hard blocker rather than
+        // silently downgrading to a static preview. The agent sets
+        // `userQuestion` when it cannot decide between static_preview and
+        // vite_app without more info from the user.
+        if (executionPlan?.userQuestion) {
+            throw new errors_1.AgentVariantsError('MISSING_REQUIRED_INPUT', executionPlan.userQuestion);
+        }
+        // Fresh sessions default to static_preview when no plan was reported
+        // (source-less zero-to-one). Source-grounded sessions carry an
+        // executionPlan from `report_source_plan`.
+        const freshMode = isFresh
+            ? (executionPlan?.mode ?? 'static_preview')
+            : 'static_preview';
+        const needsViteApp = isFresh && freshMode === 'vite_app';
+        const codeGenIds = [];
+        // For fresh+vite_app sessions, code_gen items depend on a single
+        // scaffold_base item so the orchestrator can do the Vite skeleton +
+        // npm install + asset copy before the agent leases the code_gen.
         let scaffoldBaseId;
-        if (session.projectContext.kind === 'fresh') {
+        if (needsViteApp) {
+            scaffoldBaseId = (0, crypto_1.randomUUID)();
             const scaffoldItem = {
-                id: (0, crypto_1.randomUUID)(),
+                id: scaffoldBaseId,
                 kind: 'scaffold_base',
                 status: 'pending',
                 attempt: 0,
                 dependsOn: [],
-                input: {
-                    workspacePath: session.projectContext.workspacePath,
-                    framework: session.projectContext.framework,
-                },
+                input: { projectContext: session.projectContext },
                 acceptedReports: [],
+                internal: true,
             };
             session.workItems.set(scaffoldItem.id, scaffoldItem);
             session.workItemOrder.push(scaffoldItem.id);
-            scaffoldBaseId = scaffoldItem.id;
-        }
-        const codeGenIds = [];
-        for (const sel of args.selections) {
-            const brief = session.briefs.find((b) => b.briefId === sel.briefId);
-            if (!brief)
-                continue;
-            const codeGenItem = {
-                id: (0, crypto_1.randomUUID)(),
-                kind: 'code_gen',
-                status: 'pending',
-                attempt: 0,
-                dependsOn: scaffoldBaseId ? [scaffoldBaseId] : [],
-                input: {
-                    briefId: brief.briefId,
-                    briefLabel: brief.label,
-                    briefBody: sel.bodyOverride ?? brief.body,
-                    target: session.target,
-                    projectContext: session.projectContext,
-                },
-                acceptedReports: [],
-            };
-            session.workItems.set(codeGenItem.id, codeGenItem);
-            session.workItemOrder.push(codeGenItem.id);
-            codeGenIds.push(codeGenItem.id);
         }
+        args.selections.forEach((sel) => {
+            const briefIndex = session.briefs.findIndex((b) => b.briefId === sel.briefId);
+            if (briefIndex === -1)
+                return;
+            const brief = session.briefs[briefIndex];
+            // D-VR2: Plumb the optional per-brief visualReferenceUrl into the
+            // resulting work-item input. Omitted (not nulled) when absent so the
+            // shape stays backward-compatible for callers that destructure.
+            const visualRef = brief.visualReferenceUrl
+                ? { visualReferenceUrl: brief.visualReferenceUrl }
+                : {};
+            if (isFresh && !needsViteApp) {
+                // Fresh + static_preview: HTML is the deliverable. No scaffold or
+                // code_gen — the static_preview item is leased directly.
+                const staticPreviewItem = {
+                    id: (0, crypto_1.randomUUID)(),
+                    kind: 'static_preview',
+                    status: 'pending',
+                    attempt: 0,
+                    dependsOn: [],
+                    input: {
+                        briefId: brief.briefId,
+                        briefLabel: brief.label,
+                        briefBody: sel.bodyOverride ?? brief.body,
+                        ...visualRef,
+                        projectContext: session.projectContext,
+                    },
+                    acceptedReports: [],
+                };
+                session.workItems.set(staticPreviewItem.id, staticPreviewItem);
+                session.workItemOrder.push(staticPreviewItem.id);
+            }
+            else {
+                // Existing project OR fresh+vite_app: code_gen against a worktree.
+                // Fresh+vite_app additionally depends on scaffold_base so the agent
+                // doesn't lease code_gen before the Vite skeleton lands.
+                //
+                // Per-slot designContextEntry is read by provisionFreshWorktrees to
+                // decide what DESIGN.md to write per variant. Falls back to slot 0
+                // when the session has fewer designContext entries than variants
+                // (the common case after report_source_plan ships one shared
+                // markdown).
+                const freshDesignContext = session.projectContext.kind === 'fresh'
+                    ? session.projectContext.designContext
+                    : undefined;
+                const designContextEntry = freshDesignContext
+                    ? freshDesignContext[Math.min(briefIndex, freshDesignContext.length - 1)]
+                    : undefined;
+                const codeGenItem = {
+                    id: (0, crypto_1.randomUUID)(),
+                    kind: 'code_gen',
+                    status: 'pending',
+                    attempt: 0,
+                    dependsOn: scaffoldBaseId ? [scaffoldBaseId] : [],
+                    input: {
+                        briefId: brief.briefId,
+                        briefLabel: brief.label,
+                        briefBody: sel.bodyOverride ?? brief.body,
+                        ...visualRef,
+                        target: session.target,
+                        projectContext: session.projectContext,
+                        ...(designContextEntry ? { designContextEntry } : {}),
+                    },
+                    acceptedReports: [],
+                };
+                session.workItems.set(codeGenItem.id, codeGenItem);
+                session.workItemOrder.push(codeGenItem.id);
+                codeGenIds.push(codeGenItem.id);
+            }
+        });
         session.stage = 'work_items_ready';
         return {
             approvedCount: args.selections.length,
@@ -188,7 +438,11 @@ class SessionStore {
     // --- Lease management ---------------------------------------------------
     requestWork(args) {
         const session = this.requireSession(args.sessionId);
-        this.assertStage(session, ['work_items_ready', 'waiting_for_results']);
+        this.assertStage(session, [
+            'awaiting_source_plan',
+            'work_items_ready',
+            'waiting_for_results',
+        ]);
         this.expireStaleLeases(session);
         const leasable = this.leasableItems(session);
         const limit = args.requestedLeaseCount ?? leasable.length;
@@ -210,11 +464,14 @@ class SessionStore {
             };
             item.status = 'running';
         }
-        session.stage = 'waiting_for_results';
+        session.stage =
+            session.stage === 'awaiting_source_plan'
+                ? 'awaiting_source_plan'
+                : 'waiting_for_results';
         return {
             leaseId,
             leaseTtlMs: Math.max(...issued.map((i) => leaseTtlForKind(i.kind))),
-            leasedWorkItems: issued.map(descriptorFor),
+            leasedWorkItems: issued.map((item) => descriptorFor(item)),
         };
     }
     reportComplete(args) {
@@ -275,6 +532,49 @@ class SessionStore {
         session.acceptedFingerprints.set(fp, result);
         return result;
     }
+    /**
+     * Mark a server-owned work item as succeeded without going through the
+     * lease + agent-report path. Used for `scaffold_base` items where the
+     * orchestrator runs the scaffold + npm install in the background and needs
+     * to unblock dependent code_gen items when it's done.
+     *
+     * Bypasses lease validation because no lease was ever issued for internal
+     * items. Idempotent: completing an already-succeeded item is a no-op.
+     */
+    completeInternal(args) {
+        const session = this.requireSession(args.sessionId);
+        const item = this.requireWorkItem(session, args.workItemId);
+        if (!item.internal) {
+            throw new errors_1.AgentVariantsError('INVALID_STAGE_ACTION', `completeInternal called on non-internal work item ${args.workItemId}`);
+        }
+        if (item.status === 'succeeded') {
+            return this.evaluateTerminal(session);
+        }
+        item.status = 'succeeded';
+        item.output = args.output;
+        item.lease = undefined;
+        return this.evaluateTerminal(session);
+    }
+    /**
+     * Mark a server-owned work item as failed, cascading DEPENDENCY_FAILED to
+     * its dependents. Used when the orchestrator's background scaffold work
+     * (npm install, file writes) fails and we need the session to degrade.
+     */
+    failInternal(args) {
+        const session = this.requireSession(args.sessionId);
+        const item = this.requireWorkItem(session, args.workItemId);
+        if (!item.internal) {
+            throw new errors_1.AgentVariantsError('INVALID_STAGE_ACTION', `failInternal called on non-internal work item ${args.workItemId}`);
+        }
+        if (item.status === 'succeeded' || item.status === 'failed') {
+            return this.evaluateTerminal(session);
+        }
+        item.status = 'failed';
+        item.error = args.error;
+        item.lease = undefined;
+        this.cascadeDependencyFailure(session, item.id);
+        return this.evaluateTerminal(session);
+    }
     // --- Cancel / cleanup ---------------------------------------------------
     cancel(args) {
         const session = this.requireSession(args.sessionId);
@@ -294,6 +594,37 @@ class SessionStore {
         // Phase 2 wires the worktree teardown.
         return { stage: 'cancelled', cleanupStatus: 'pending' };
     }
+    /**
+     * Cancel a single work item without tearing down its sibling variants or
+     * the session itself. Idempotent on terminal states — already-cancelled,
+     * succeeded, or failed items return their current status with
+     * `alreadyTerminal: true` and no state change. Triggers
+     * `evaluateTerminal` so the session can reach a terminal stage if this
+     * was the last in-flight item.
+     */
+    cancelWorkItem(args) {
+        const session = this.requireSession(args.sessionId);
+        const item = this.requireWorkItem(session, args.workItemId);
+        if (item.status === 'cancelled' ||
+            item.status === 'succeeded' ||
+            item.status === 'failed') {
+            return {
+                workItemId: item.id,
+                finalStatus: item.status,
+                sessionStage: session.stage,
+                alreadyTerminal: true,
+            };
+        }
+        item.status = 'cancelled';
+        item.lease = undefined;
+        this.evaluateTerminal(session);
+        return {
+            workItemId: item.id,
+            finalStatus: 'cancelled',
+            sessionStage: session.stage,
+            alreadyTerminal: false,
+        };
+    }
     // --- Variant pick handoff (queues to pending-changes adapter) -----------
     recordVariantPick(args) {
         const session = this.requireSession(args.sessionId);
@@ -324,6 +655,10 @@ class SessionStore {
         const session = this.requireSession(sessionId);
         return this.summaryOf(session);
     }
+    getVariants(sessionId) {
+        const session = this.requireSession(sessionId);
+        return this.variantsOf(session);
+    }
     getVariantPick(sessionId) {
         return this.requireSession(sessionId).variantPick;
     }
@@ -337,6 +672,11 @@ class SessionStore {
         const item = this.requireWorkItem(session, workItemId);
         return item.input;
     }
+    getWorkItemOutput(sessionId, workItemId) {
+        const session = this.requireSession(sessionId);
+        const item = this.requireWorkItem(session, workItemId);
+        return item.output;
+    }
     /** Read the projectContext for a session (existing | fresh). */
     getProjectContext(sessionId) {
         return this.requireSession(sessionId).projectContext;
@@ -392,14 +732,38 @@ class SessionStore {
             const item = session.workItems.get(id);
             if (item.kind === 'brief')
                 continue;
+            // Server-owned items never surface to external agents.
+            if (item.internal)
+                continue;
             if (item.status !== 'pending')
                 continue;
             if (!this.dependenciesMet(session, item))
                 continue;
+            if (item.kind === 'static_preview' &&
+                this.hasLeasableCodeGenForStaticPreview(session, item)) {
+                continue;
+            }
             out.push(item);
         }
         return out;
     }
+    hasLeasableCodeGenForStaticPreview(session, staticPreview) {
+        const staticInput = staticPreview.input;
+        if (!staticInput.briefId)
+            return false;
+        for (const candidate of session.workItems.values()) {
+            if (candidate.kind !== 'code_gen')
+                continue;
+            if (candidate.status !== 'pending')
+                continue;
+            if (!this.dependenciesMet(session, candidate))
+                continue;
+            const codeInput = candidate.input;
+            if (codeInput.briefId === staticInput.briefId)
+                return true;
+        }
+        return false;
+    }
     dependenciesMet(session, item) {
         for (const depId of item.dependsOn) {
             const dep = session.workItems.get(depId);
@@ -419,9 +783,26 @@ class SessionStore {
             }
         }
     }
+    terminalItems(session) {
+        const kind = this.variantWorkItemKind(session);
+        return [...session.workItems.values()].filter((i) => i.kind === kind);
+    }
+    /**
+     * The work-item kind that represents a user-facing variant for this
+     * session. Drives both progress accounting and the active variants
+     * snapshot. Fresh+vite_app sessions use `code_gen` like existing
+     * projects; fresh+static_preview (the default for source-less 0→1)
+     * keeps `static_preview` as the deliverable.
+     */
+    variantWorkItemKind(session) {
+        if (session.projectContext.kind !== 'fresh')
+            return 'code_gen';
+        const mode = session.projectContext.executionPlan?.mode ?? 'static_preview';
+        return mode === 'vite_app' ? 'code_gen' : 'static_preview';
+    }
     evaluateTerminal(session) {
-        const codeGenItems = [...session.workItems.values()].filter((i) => i.kind === 'code_gen');
-        const allDone = codeGenItems.every((i) => i.status === 'succeeded' ||
+        const items = this.terminalItems(session);
+        const allDone = items.every((i) => i.status === 'succeeded' ||
             i.status === 'failed' ||
             i.status === 'cancelled');
         if (!allDone) {
@@ -430,9 +811,9 @@ class SessionStore {
                 progress: this.progressOf(session),
             };
         }
-        const succeeded = codeGenItems.filter((i) => i.status === 'succeeded').length;
+        const succeeded = items.filter((i) => i.status === 'succeeded').length;
         let terminal;
-        if (succeeded === codeGenItems.length)
+        if (succeeded === items.length)
             terminal = 'ready';
         else if (succeeded > 0)
             terminal = 'degraded';
@@ -446,17 +827,22 @@ class SessionStore {
         };
     }
     progressOf(session) {
-        const codeGen = [...session.workItems.values()].filter((i) => i.kind === 'code_gen');
-        const ready = codeGen.filter((i) => i.status === 'succeeded').length;
-        return { ready, total: codeGen.length };
+        if (session.stage === 'awaiting_source_plan') {
+            const planItems = [...session.workItems.values()].filter((item) => item.kind === 'source_plan');
+            const ready = planItems.filter((item) => item.status === 'succeeded').length;
+            return { ready, total: planItems.length };
+        }
+        const items = this.terminalItems(session);
+        const ready = items.filter((i) => i.status === 'succeeded').length;
+        return { ready, total: items.length };
     }
     summaryOf(session) {
-        const codeGen = [...session.workItems.values()].filter((i) => i.kind === 'code_gen');
+        const items = this.terminalItems(session);
         return {
-            successCount: codeGen.filter((i) => i.status === 'succeeded').length,
-            failureCount: codeGen.filter((i) => i.status === 'failed').length,
-            cancelledCount: codeGen.filter((i) => i.status === 'cancelled').length,
-            variants: codeGen.map((i) => {
+            successCount: items.filter((i) => i.status === 'succeeded').length,
+            failureCount: items.filter((i) => i.status === 'failed').length,
+            cancelledCount: items.filter((i) => i.status === 'cancelled').length,
+            variants: items.map((i) => {
                 const input = i.input;
                 return {
                     workItemId: i.id,
@@ -466,6 +852,22 @@ class SessionStore {
             }),
         };
     }
+    variantsOf(session) {
+        const kind = this.variantWorkItemKind(session);
+        return [...session.workItems.values()]
+            .filter((i) => i.kind === kind)
+            .map((item) => {
+            const input = item.input;
+            return {
+                workItemId: item.id,
+                briefId: input.briefId ?? '',
+                label: input.briefLabel ?? 'Variant',
+                status: item.status,
+                design: variantDesignFromInput(input.designContextEntry),
+                ...(item.error?.code ? { errorCode: String(item.error.code) } : {}),
+            };
+        });
+    }
 }
 exports.SessionStore = SessionStore;
 function clampCount(count) {