rivet-design 0.27.0 → 0.28.0

package/dist/agent-variants/WorktreeOrchestrator.js

@@ -8,6 +8,7 @@ const workItemContextFiles_1 = require("./workItemContextFiles");
 const staticPreviewFiles_1 = require("./staticPreviewFiles");
 const workItemPreviewRoutes_1 = require("./workItemPreviewRoutes");
 const staticPreviewRefinements_1 = require("./staticPreviewRefinements");
+const WorkItemRequestTimes_1 = require("./WorkItemRequestTimes");
 const crypto_1 = require("crypto");
 const events_1 = require("events");
 const fs_1 = __importDefault(require("fs"));
@@ -20,6 +21,7 @@ const workItemBriefing_1 = require("./workItemBriefing");
 const briefContent_1 = require("./briefContent");
 const runLabel_1 = require("./runLabel");
 const previewQa_1 = require("./previewQa");
+const workItemInput_1 = require("./workItemInput");
 const WorkspaceInventory_1 = require("./WorkspaceInventory");
 const WorkspaceProvisioning_1 = require("./WorkspaceProvisioning");
 const PreviewRuntime_1 = require("./PreviewRuntime");
@@ -31,6 +33,7 @@ const variantsTelemetry_1 = require("./variantsTelemetry");
 const variantWorkspaceFiles_1 = require("./variantWorkspaceFiles");
 const errorMessage_1 = require("../utils/errorMessage");
 const pathContainment_1 = require("../utils/pathContainment");
+const existingStaticEntry_1 = require("./existingStaticEntry");
 var variantWorkspaceFiles_2 = require("./variantWorkspaceFiles");
 Object.defineProperty(exports, "buildStaticPreviewDocument", { enumerable: true, get: function () { return variantWorkspaceFiles_2.buildStaticPreviewDocument; } });
 const log = (0, logger_1.createLogger)('AgentVariantsOrchestrator');
@@ -426,6 +429,7 @@ class AgentVariantsOrchestrator {
                 leaseExpiresAt: item.leaseExpiresAt,
                 workspace,
                 mode,
+                ...(0, workItemInput_1.shownDirectionRef)(input),
                 direction: {
                     label: input.briefLabel ?? 'Variant',
                     brief: input.briefBody ?? input.instruction ?? 'Create this variant',
@@ -487,6 +491,7 @@ class AgentVariantsOrchestrator {
         resources.currentRoundStartedAt = startedAt;
         resources.currentRoundMode = args.mode;
         resources.currentRoundWorkItemIds = workItemIds;
+        resources.requestTimes.record(workItemIds ?? [], startedAt);
         const projectContext = this.store.getProjectContext(args.sessionId);
         this.telemetry.trackAgentVariantsRoundStarted?.({
             sessionId: args.sessionId,
@@ -565,6 +570,7 @@ class AgentVariantsOrchestrator {
         const workItemIds = [...args.workItemIds];
         round.workItemIds = workItemIds;
         resources.currentRoundWorkItemIds = workItemIds;
+        resources.requestTimes.record(workItemIds, round.startedAt);
         this.completeTerminalVariantsRounds(args.sessionId);
     }
     completeTerminalVariantsRounds(sessionId) {
@@ -646,6 +652,8 @@ class AgentVariantsOrchestrator {
         };
     }
     trackRefinementLeased(args) {
+        const requestTimes = this.resources.get(args.sessionId)?.requestTimes;
+        const leasedAt = Date.now();
         for (const item of args.lease.leasedWorkItems) {
             const telemetry = this.refinementTelemetryForWorkItem({
                 sessionId: args.sessionId,
@@ -657,6 +665,7 @@ class AgentVariantsOrchestrator {
             this.telemetry.trackAgentVariantsRefinementLeased?.({
                 ...telemetry,
                 leaseDurationMs: args.lease.leaseTtlMs,
+                queueWaitMs: requestTimes?.elapsedSinceRequestMs(item.id, leasedAt) ?? undefined,
                 workItemCount: 1,
             });
         }
@@ -788,13 +797,16 @@ class AgentVariantsOrchestrator {
         }
     }
     beginStaticPreviewRefinements(args) {
-        return (0, staticPreviewRefinements_1.createStaticPreviewRefinements)({
+        const result = (0, staticPreviewRefinements_1.createStaticPreviewRefinements)({
             request: args,
             store: this.store,
             telemetry: this.telemetry,
             getStaticPreviewHtml: (sessionId, workItemId) => this.getStaticPreviewHtml(sessionId, workItemId),
             emitChange: () => this.emitChange(),
         });
+        const requestTimes = this.resources.get(args.sessionId)?.requestTimes;
+        requestTimes?.record(result.createdWorkItemIds, Date.now());
+        return result;
     }
     async adoptPastVariant(args) {
         const { assetBase, entryPath, hasAssets } = await (0, staticPreviewFiles_1.resolveStaticPreviewFiles)({
@@ -810,6 +822,7 @@ class AgentVariantsOrchestrator {
             references: args.references,
             previewRoutes: args.previewRoutes,
             runLabel: args.runLabel,
+            sourceDirectionRef: args.directionRef,
         });
         this.telemetry.trackAgentVariantsRequestStarted?.({
             sessionId: args.sessionId,
@@ -859,6 +872,7 @@ class AgentVariantsOrchestrator {
                 references: args.references,
                 previewRoutes: args.previewRoutes,
                 runLabel: args.runLabel,
+                directionRef: args.directionRef,
             });
             return {
                 sessionId: usableSessionId,
@@ -880,6 +894,7 @@ class AgentVariantsOrchestrator {
             references: args.references,
             previewRoutes: args.previewRoutes,
             runLabel: args.runLabel,
+            sourceDirectionRef: args.directionRef,
             projectContext: args.projectContext,
         });
         this.activeSessionId = created.sessionId;
@@ -1548,6 +1563,8 @@ class AgentVariantsOrchestrator {
             const durationMs = leasedAt !== undefined ? Date.now() - leasedAt : null;
             const approveStartedAt = resources?.approveStartedAt;
             const approveToCompleteMs = approveStartedAt !== undefined ? Date.now() - approveStartedAt : null;
+            const requestTimes = resources?.requestTimes;
+            const elapsedSinceRequestMs = (at) => requestTimes?.elapsedSinceRequestMs(args.workItemId, at) ?? null;
             const outputBytes = (0, variantWorkspaceFiles_1.estimateOutputBytes)(effectiveArgs.output);
             const projectContextKind = this.store.getProjectContext(args.sessionId).kind;
             const mode = workItemKind !== undefined && isImplementationWorkItemKind(workItemKind)
@@ -1563,6 +1580,8 @@ class AgentVariantsOrchestrator {
                 attempt: args.attempt,
                 durationMs,
                 approveToCompleteMs,
+                requestToCompleteMs: elapsedSinceRequestMs(Date.now()),
+                queueWaitMs: elapsedSinceRequestMs(leasedAt),
                 kind: workItemKind ?? null,
                 mode,
                 leaseToReportMs: leasedAt !== undefined ? reportReceivedAt - leasedAt : null,
@@ -2094,12 +2113,24 @@ class AgentVariantsOrchestrator {
         catch (err) {
             log.warn(`getDiff failed for ${record.worktreePath}`, err);
         }
+        const staticEntryResolution = isFresh
+            ? Promise.resolve(undefined)
+            : (0, existingStaticEntry_1.resolveExistingStaticPreviewEntry)({
+                sessionId,
+                record,
+                resolveEnv: this.resolveEnv,
+                worktrees: this.worktrees,
+                telemetry: this.telemetry,
+            });
         if (!isFresh) {
-            this.trackHistoryPersist(this.persistCompletedExistingVariant({
+            this.trackHistoryPersist(staticEntryResolution
+                .then((staticEntry) => this.persistCompletedExistingVariant({
                 sessionId,
                 workItemId,
                 diff: record.diff ?? '',
-            }).catch((err) => {
+                staticEntry,
+            }))
+                .catch((err) => {
                 log.warn(`persistCompletedExistingVariant failed for ${sessionId}/${workItemId}`, err);
             }));
         }
@@ -2111,12 +2142,11 @@ class AgentVariantsOrchestrator {
                 log.warn(`persistCompletedArtifactVariant failed for ${sessionId}/${workItemId}`, err);
             }));
         }
-        if (!isFresh) {
-            const staticPreview = await this.registerExistingStaticPreview(sessionId, workItemId, record);
-            if (staticPreview !== 'not_static') {
-                this.emitChange();
-                return;
-            }
+        const staticEntry = await staticEntryResolution;
+        if (staticEntry) {
+            await this.registerExistingStaticPreview(sessionId, workItemId, staticEntry);
+            this.emitChange();
+            return;
         }
         await this.previewRuntime.startVariant({
             sessionId,
@@ -2224,6 +2254,12 @@ class AgentVariantsOrchestrator {
             await Promise.allSettled([...this.pendingHistoryPersists]);
         }
     }
+    loadDirectionRefs() {
+        return this.store.directionRefs.load({
+            projectPath: this.getProjectPath(),
+            history: this.variantHistory,
+        });
+    }
     async getSavedVariant(args) {
         const saved = await this.variantHistory.getVariant(args);
         if (saved)
@@ -2297,16 +2333,9 @@ class AgentVariantsOrchestrator {
             return;
         }
         const record = this.workspaceInventory.getWorktree(args.sessionId, args.workItemId);
-        let sourceDir;
-        const staticEntryPath = env.framework === 'static' ? env.entryPath : undefined;
-        if (env.framework === 'static' && record) {
-            try {
-                sourceDir = await this.worktrees.getProjectCwdInWorktree(record.worktreePath);
-            }
-            catch (err) {
-                log.warn(`persistCompletedExistingVariant: static snapshot path failed for ${args.sessionId}/${args.workItemId}`, err);
-            }
-        }
+        const staticSource = args.staticEntry?.kind === 'found' ? args.staticEntry : undefined;
+        const sourceDir = staticSource?.projectDirectory;
+        const staticEntryPath = staticSource?.entryPath;
         const input = this.store.requireVariantWorkItemInput({
             sessionId: args.sessionId,
             workItemId: args.workItemId,
@@ -2333,7 +2362,7 @@ class AgentVariantsOrchestrator {
                 recipe: (0, variantWorkspaceFiles_1.buildServeRecipeFromResolved)(record.worktreePath, runningPreview.command, runningPreview.port),
             };
         }
-        else if (record) {
+        else if (record && env.framework !== 'static') {
             try {
                 const dev = await this.previewRuntime.resolveCommand(args.sessionId, record.worktreePath, RECIPE_PORT_SENTINEL, false);
                 serve = {
@@ -2350,6 +2379,7 @@ class AgentVariantsOrchestrator {
             sessionId: args.sessionId,
             variantId: args.workItemId,
             ...(input.requestId ? { requestId: input.requestId } : {}),
+            directionRef: this.store.claimDirectionRef(args),
             label: input.briefLabel,
             brief: input.briefBody,
             references: input.references,
@@ -2380,92 +2410,74 @@ class AgentVariantsOrchestrator {
                 : {}),
         });
     }
-    async registerExistingStaticPreview(sessionId, workItemId, record) {
-        let env;
-        try {
-            env = await this.resolveEnv(sessionId);
-        }
-        catch (err) {
-            log.warn(`registerExistingStaticPreview: resolveEnv failed for ${sessionId}`, err);
-            return 'not_static';
-        }
-        if (env.framework !== 'static')
-            return 'not_static';
-        const previewStartedAt = Date.now();
-        (0, variantsTelemetry_1.trackPreviewStarted)(this.telemetry, {
-            sessionId,
-            variantId: workItemId,
-            projectContextKind: 'existing',
-            previewKind: 'static_artifact',
-        });
+    async registerExistingStaticPreview(sessionId, workItemId, entry) {
         const resources = this.resources.get(sessionId);
         if (!resources)
-            return 'unavailable';
+            return;
         const input = this.store.getVariantWorkItemInput(sessionId, workItemId);
         if (!input?.briefId)
-            return 'unavailable';
-        let projectCwd;
-        try {
-            projectCwd = await this.worktrees.getProjectCwdInWorktree(record.worktreePath);
-        }
-        catch (err) {
-            log.warn(`registerExistingStaticPreview: project cwd failed for ${sessionId}/${workItemId}`, err);
-            return 'unavailable';
-        }
-        const entryFile = path_1.default.join(projectCwd, env.entryPath);
-        try {
-            await fs_1.default.promises.access(entryFile, fs_1.default.constants.R_OK);
-        }
-        catch (err) {
-            log.warn(`registerExistingStaticPreview: no entry HTML at ${entryFile} for ${sessionId}/${workItemId}; preview unavailable`, err);
-            (0, variantsTelemetry_1.trackPreviewFailed)(this.telemetry, {
-                sessionId,
-                variantId: workItemId,
-                projectContextKind: 'existing',
-                previewKind: 'static_artifact',
-                errorCode: 'STATIC_PREVIEW_ENTRY_MISSING',
-                reason: 'missing_static_entry',
-                durationMs: Date.now() - previewStartedAt,
-            });
-            this.previewRuntime.setFailure(sessionId, workItemId, {
-                reason: 'missing_static_entry',
-                portInUse: false,
-            });
-            return 'unavailable';
+            return;
+        switch (entry.kind) {
+            case 'unresolved':
+                return;
+            case 'missing':
+                log.warn(`registerExistingStaticPreview: no entry page (${entry.source}) for ${sessionId}/${workItemId}; preview unavailable`);
+                (0, variantsTelemetry_1.trackPreviewFailed)(this.telemetry, {
+                    sessionId,
+                    variantId: workItemId,
+                    projectContextKind: 'existing',
+                    previewKind: 'static_artifact',
+                    errorCode: 'STATIC_PREVIEW_ENTRY_MISSING',
+                    reason: 'missing_static_entry',
+                    durationMs: Date.now() - entry.startedAt,
+                    staticEntrySource: entry.source,
+                });
+                this.previewRuntime.setFailure(sessionId, workItemId, {
+                    reason: 'missing_static_entry',
+                    portInUse: false,
+                    detail: entry.detail,
+                });
+                return;
+            case 'found':
+                break;
+            default: {
+                const unhandled = entry;
+                throw new Error(`Unhandled static entry ${JSON.stringify(unhandled)}`);
+            }
         }
         let dir;
         try {
-            dir = fs_1.default.realpathSync(projectCwd);
+            dir = fs_1.default.realpathSync(entry.projectDirectory);
         }
         catch {
-            dir = projectCwd;
+            dir = entry.projectDirectory;
         }
         let siteFallbackBase;
         try {
-            const hostRealRoot = fs_1.default.realpathSync(env.projectPath);
+            const hostRealRoot = fs_1.default.realpathSync(entry.hostProjectPath);
             if (hostRealRoot !== dir)
-                siteFallbackBase = path_1.default.join(hostRealRoot, path_1.default.dirname(env.entryPath));
+                siteFallbackBase = path_1.default.join(hostRealRoot, path_1.default.dirname(entry.entryPath));
         }
         catch { }
         this.workspaceInventory.setStaticPreview(sessionId, {
             workItemId,
             briefId: input.briefId,
-            entryPath: path_1.default.basename(env.entryPath),
-            assetBase: path_1.default.dirname(path_1.default.join(dir, env.entryPath)),
+            entryPath: path_1.default.basename(entry.entryPath),
+            assetBase: path_1.default.dirname(path_1.default.join(dir, entry.entryPath)),
             hasAssets: true,
             ...(siteFallbackBase ? { assetFallbackBase: siteFallbackBase } : {}),
         });
         this.previewRuntime.clearFailure(sessionId, workItemId);
-        log.info(`Variant ${workItemId} served as a static preview (existing/static, no dev server; root ${projectCwd})`);
+        log.info(`Variant ${workItemId} served as a static preview (existing/static, no dev server; root ${entry.projectDirectory})`);
         (0, variantsTelemetry_1.trackPreviewReady)(this.telemetry, {
             sessionId,
             variantId: workItemId,
             projectContextKind: 'existing',
             previewKind: 'static_artifact',
             hasPort: false,
-            durationMs: Date.now() - previewStartedAt,
+            durationMs: Date.now() - entry.startedAt,
+            staticEntrySource: entry.source,
         });
-        return 'registered';
     }
     async prepareArtifactBase(sessionId) {
         const { projectPath } = await this.resolveEnv(sessionId);
@@ -2478,7 +2490,7 @@ class AgentVariantsOrchestrator {
     async createArtifactDiff(args) {
         const base = await this.prepareArtifactBase(args.sessionId);
         const env = await this.resolveEnv(args.sessionId);
-        const entryPath = env.framework === 'static' ? env.entryPath : 'index.html';
+        const entryPath = (env.framework === 'static' && env.entryPath) || 'index.html';
         const files = (0, staticPreviewFiles_1.prepareStaticPreviewProjectFiles)({
             sourceDir: args.sourceDir,
             entryPath,
@@ -2598,6 +2610,7 @@ class AgentVariantsOrchestrator {
                 sessionId: args.sessionId,
                 variantId: args.workItemId,
                 ...(input.requestId ? { requestId: input.requestId } : {}),
+                directionRef: this.store.claimDirectionRef(args),
                 label: input.briefLabel,
                 brief: input.briefBody ?? '',
                 references: input.references,
@@ -2746,6 +2759,7 @@ class AgentVariantsOrchestrator {
                 startedAt: Date.now(),
                 nextRoundIndex: 0,
                 rounds: new Map(),
+                requestTimes: new WorkItemRequestTimes_1.WorkItemRequestTimes(),
                 leasedAt: new Map(),
                 qaResults: new Map(),
                 qaRegenRetried: new Set(),

package/dist/agent-variants/contracts.d.ts

@@ -1,5 +1,7 @@
 import type { GuidanceDocument } from '../types/guidance';
 import type { WorkerSelection } from '../types/change-request-types';
+import type { DirectionRef } from '../types/direction-ref';
+import type { FailureReasonCode } from '../utils/failureReason';
 import { type VariantReference } from '../types/variant-reference';
 import { z } from 'zod/v3';
 import { ERROR_CODES, type ErrorCode } from './errors';
@@ -6343,6 +6345,7 @@ export interface SavedVariantPreview {
     references?: VariantReference[];
     previewRoutes?: string[];
     runLabel?: string;
+    directionRef?: DirectionRef;
 }
 export interface AdoptPastVariantArgs extends SavedVariantPreview {
     sessionId: string;
@@ -6361,6 +6364,7 @@ export interface ActiveVariantSnapshot {
     previewRoutes?: string[];
     workItemId: string;
     briefId: string;
+    directionRef?: DirectionRef;
     label: string;
     status: WorkItemStatus;
     workItemKind?: 'code_gen' | 'static_preview';
@@ -6384,6 +6388,9 @@ export interface ActiveVariantSnapshot {
         reason: 'spawn_error' | 'exited' | 'timeout' | 'compile_error' | 'dependency_install_failed' | 'missing_dev_script' | 'missing_static_entry' | 'idle_timeout' | 'unknown';
         portInUse?: boolean;
         detail?: string;
+        reasonCode?: FailureReasonCode;
+        reasonDetail?: string;
+        nodeVersion?: string;
     };
     actions?: ActiveVariantActions;
     refinement?: {
@@ -6443,6 +6450,7 @@ export interface HostVariantImplementationWorkItemSnapshot extends HostVariantWo
     kind: 'static_preview' | 'refine_variant' | 'code_gen';
     workspace: VariantAssignedWorkspace;
     mode: VariantExecutionMode;
+    directionRef?: DirectionRef;
     direction: VariantWorkerDirection;
     fidelity?: WorkerFidelity;
     sourceDirection?: VariantWorkerDirection;

package/dist/agent-variants/existingStaticEntry.d.ts

@@ -0,0 +1,34 @@
+import type { WorktreeRecord } from './WorkspaceInventory';
+import type { ProjectEnvironment, WorktreeManagerLike } from './variant-project-runtime';
+import { type VariantsTelemetry } from './variantsTelemetry';
+export type ExistingStaticEntrySource = 'configured' | 'root_page' | 'changed_page';
+export type ExistingStaticEntry = {
+    kind: 'found';
+    entryPath: string;
+    source: ExistingStaticEntrySource;
+} | {
+    kind: 'missing';
+    detail: string;
+    source: 'configured' | 'none';
+};
+export type ExistingStaticPreviewEntry = {
+    kind: 'unresolved';
+} | (ExistingStaticEntry & {
+    hostProjectPath: string;
+    projectDirectory: string;
+    startedAt: number;
+});
+export declare const resolveExistingStaticEntry: (args: {
+    worktreePath: string;
+    projectDirectory: string;
+    configuredEntryPath: string | undefined;
+    changedFiles: string[];
+}) => Promise<ExistingStaticEntry>;
+export declare const resolveExistingStaticPreviewEntry: (args: {
+    sessionId: string;
+    record: WorktreeRecord;
+    resolveEnv: (sessionId: string) => Promise<ProjectEnvironment>;
+    worktrees: WorktreeManagerLike;
+    telemetry: VariantsTelemetry;
+}) => Promise<ExistingStaticPreviewEntry | undefined>;
+//# sourceMappingURL=existingStaticEntry.d.ts.map

package/dist/agent-variants/existingStaticEntry.js

@@ -0,0 +1,136 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveExistingStaticPreviewEntry = exports.resolveExistingStaticEntry = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const staticProjectTarget_1 = require("../services/staticProjectTarget");
+const pathContainment_1 = require("../utils/pathContainment");
+const logger_1 = require("../utils/logger");
+const variantsTelemetry_1 = require("./variantsTelemetry");
+const log = (0, logger_1.createLogger)('ExistingStaticEntry');
+const INDEX_PAGE = 'index.html';
+const MISSING_PAGE_DETAIL = "This project has no index.html or package.json at its root, and this direction didn't add or change an HTML page. " +
+    "Run rivet open on the folder that contains your app's package.json or index.html, or pass --entry <page.html>.";
+const missingConfiguredEntryDetail = (entryPath) => `${entryPath} isn't in this direction's copy of the project. Directions start from committed and untracked files; ` +
+    `git-ignored files are left out. Commit ${entryPath} or remove it from .gitignore, then generate the direction again.`;
+const isPageInsideWorktree = async (worktreePath, pagePath) => {
+    const realPage = await (0, pathContainment_1.resolveRealPathWithinRoot)({
+        root: worktreePath,
+        candidate: pagePath,
+        containment: 'strict',
+    });
+    if (!realPage)
+        return false;
+    try {
+        await fs_1.default.promises.access(realPage, fs_1.default.constants.R_OK);
+        return (await fs_1.default.promises.stat(realPage)).isFile();
+    }
+    catch {
+        return false;
+    }
+};
+const pageDepth = (pagePath) => pagePath.split('/').length;
+const isIndexPage = (pagePath) => path_1.default.posix.basename(pagePath).toLowerCase() === INDEX_PAGE;
+const comparePreviewPages = (left, right) => pageDepth(left) - pageDepth(right) ||
+    Number(isIndexPage(right)) - Number(isIndexPage(left)) ||
+    left.localeCompare(right);
+const findRootPage = (projectDirectory) => {
+    try {
+        return (0, staticProjectTarget_1.resolveStaticProjectTarget)({ targetPath: projectDirectory })
+            .entryPath;
+    }
+    catch {
+        return undefined;
+    }
+};
+const toProjectPagePaths = (args) => args.changedFiles
+    .map((changedFile) => path_1.default.join(args.worktreePath, changedFile))
+    .filter((changedPath) => (0, pathContainment_1.isPathStrictlyInsideRoot)(args.projectDirectory, changedPath) &&
+    (0, staticProjectTarget_1.isStaticHtmlFilePath)(changedPath))
+    .map((changedPath) => path_1.default
+    .relative(args.projectDirectory, changedPath)
+    .split(path_1.default.sep)
+    .join('/'))
+    .sort(comparePreviewPages);
+const resolveExistingStaticEntry = async (args) => {
+    const isProjectPage = (entryPath) => isPageInsideWorktree(args.worktreePath, path_1.default.join(args.projectDirectory, entryPath));
+    if (args.configuredEntryPath) {
+        return (await isProjectPage(args.configuredEntryPath))
+            ? {
+                kind: 'found',
+                entryPath: args.configuredEntryPath,
+                source: 'configured',
+            }
+            : {
+                kind: 'missing',
+                detail: missingConfiguredEntryDetail(args.configuredEntryPath),
+                source: 'configured',
+            };
+    }
+    const rootPage = findRootPage(args.projectDirectory);
+    if (rootPage && (await isProjectPage(rootPage))) {
+        return { kind: 'found', entryPath: rootPage, source: 'root_page' };
+    }
+    for (const changedPage of toProjectPagePaths(args)) {
+        if (await isProjectPage(changedPage)) {
+            return { kind: 'found', entryPath: changedPage, source: 'changed_page' };
+        }
+    }
+    return { kind: 'missing', detail: MISSING_PAGE_DETAIL, source: 'none' };
+};
+exports.resolveExistingStaticEntry = resolveExistingStaticEntry;
+const resolveExistingStaticPreviewEntry = async (args) => {
+    const { sessionId, record } = args;
+    let env;
+    try {
+        env = await args.resolveEnv(sessionId);
+    }
+    catch (err) {
+        log.warn(`resolveEnv failed for ${sessionId}`, err);
+        return undefined;
+    }
+    if (env.framework !== 'static')
+        return undefined;
+    const startedAt = Date.now();
+    (0, variantsTelemetry_1.trackPreviewStarted)(args.telemetry, {
+        sessionId,
+        variantId: record.workItemId,
+        projectContextKind: 'existing',
+        previewKind: 'static_artifact',
+    });
+    let projectDirectory;
+    try {
+        projectDirectory = await args.worktrees.getProjectCwdInWorktree(record.worktreePath);
+    }
+    catch (err) {
+        log.warn(`project cwd failed for ${sessionId}/${record.workItemId}`, err);
+        return { kind: 'unresolved' };
+    }
+    let changedFiles = [];
+    if (!env.entryPath) {
+        try {
+            changedFiles =
+                (await args.worktrees.getChangedFiles?.(record.worktreePath)) ?? [];
+        }
+        catch (err) {
+            log.warn(`changed files unavailable for ${sessionId}/${record.workItemId}`, err);
+        }
+    }
+    const entry = await (0, exports.resolveExistingStaticEntry)({
+        worktreePath: record.worktreePath,
+        projectDirectory,
+        configuredEntryPath: env.entryPath,
+        changedFiles,
+    });
+    return {
+        ...entry,
+        hostProjectPath: env.projectPath,
+        projectDirectory,
+        startedAt,
+    };
+};
+exports.resolveExistingStaticPreviewEntry = resolveExistingStaticPreviewEntry;
+//# sourceMappingURL=existingStaticEntry.js.map

package/dist/agent-variants/staticPreviewFiles.js

@@ -33,7 +33,7 @@ const prepareStaticPreviewProjectFiles = ({ sourceDir, entryPath, isWebsite, })
 exports.prepareStaticPreviewProjectFiles = prepareStaticPreviewProjectFiles;
 const stageStaticPreviewFiles = ({ preview, workItemId, environment, isWebsite, briefMarkdown, }) => {
     const rootPath = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), `rivet-variant-${workItemId}-`));
-    const siteDirectory = isWebsite && environment?.framework === 'static'
+    const siteDirectory = isWebsite && environment?.framework === 'static' && environment.entryPath
         ? path_1.default.dirname(environment.entryPath)
         : '.';
     try {

package/dist/agent-variants/variant-project-runtime.d.ts

@@ -14,6 +14,7 @@ export interface WorktreeManagerLike {
     startDevServer(worktreePath: string, port: number, cmd: string, args: string[], env: Record<string, string>): Promise<ChildProcess>;
     stopDevServer(proc: ChildProcess, timeoutMs?: number): Promise<void>;
     getProjectCwdInWorktree(worktreePath: string): Promise<string>;
+    getChangedFiles?(worktreePath: string): Promise<string[]>;
     createFreshWorktrees?(sessionId: string, count: number, template: TemplateBundle, designContext: ReadonlyArray<DesignContextEntry | undefined> | undefined, destinationParent: string): Promise<string[]>;
 }
 type DevServerProjectEnvironment = {
@@ -31,7 +32,7 @@ type DevServerProjectEnvironment = {
 type StaticProjectEnvironment = {
     projectPath: string;
     framework: 'static';
-    entryPath: string;
+    entryPath?: string;
 };
 export type ProjectEnvironment = DevServerProjectEnvironment | StaticProjectEnvironment;
 export {};

package/dist/agent-variants/variantsTelemetry.d.ts

@@ -64,6 +64,7 @@ export interface VariantsTelemetry {
         hasPort: boolean;
         port?: number;
         durationMs?: number | null;
+        staticEntrySource?: string;
     }) => void;
     trackAgentVariantsPreviewFailed?: (data: {
         sessionId: string;
@@ -77,6 +78,7 @@ export interface VariantsTelemetry {
         exitCode?: number | null;
         signal?: string | null;
         missingDeps?: boolean;
+        staticEntrySource?: string;
         error?: unknown;
     }) => void;
     trackAgentVariantsBriefQuality?: (data: {
@@ -150,6 +152,7 @@ export declare const trackPreviewReady: (telemetry: VariantsTelemetry, data: {
     hasPort: boolean;
     port?: number;
     durationMs?: number | null;
+    staticEntrySource?: string;
 }) => void;
 export declare const trackPreviewFailed: (telemetry: VariantsTelemetry, data: {
     sessionId: string;
@@ -163,6 +166,7 @@ export declare const trackPreviewFailed: (telemetry: VariantsTelemetry, data: {
     exitCode?: number | null;
     signal?: string | null;
     missingDeps?: boolean;
+    staticEntrySource?: string;
     error?: unknown;
 }) => void;
 export declare const trackStaticPreviewCompleted: (telemetry: VariantsTelemetry, data: {

package/dist/agent-variants/variantsTelemetry.js

@@ -122,6 +122,7 @@ const trackPreviewReady = (telemetry, data) => {
         has_port: data.hasPort,
         port: data.port,
         duration_ms: data.durationMs,
+        static_entry_source: data.staticEntrySource,
     });
 };
 exports.trackPreviewReady = trackPreviewReady;
@@ -143,6 +144,7 @@ const trackPreviewFailed = (telemetry, data) => {
         exit_code: data.exitCode,
         term_signal: data.signal,
         missing_deps: data.missingDeps,
+        static_entry_source: data.staticEntrySource,
         ...(0, failureReason_1.failureReasonProperties)(data.error),
     });
 };