rivet-design 0.27.0 → 0.27.1

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),
     });
 };

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

@@ -1,5 +1,6 @@
 import { z } from 'zod/v3';
 import type { WorkerSelection } from '../types/change-request-types';
+import type { DirectionRef } from '../types/direction-ref';
 import type { StaticPreviewTargetElement, VariantWorkItem, WorkItem, WorkItemKind } from './contracts';
 export declare const VARIANT_WORK_ITEM_KINDS: readonly ["static_preview", "refine_variant", "code_gen"];
 export type VariantWorkItemKind = (typeof VARIANT_WORK_ITEM_KINDS)[number];
@@ -613,6 +614,8 @@ declare const variantWorkItemInputSchemas: {
         }>;
         briefBody: z.ZodOptional<z.ZodString>;
         briefNotes: z.ZodOptional<z.ZodString>;
+        directionRef: z.ZodOptional<z.ZodType<DirectionRef, z.ZodTypeDef, DirectionRef>>;
+        sourceDirectionRef: z.ZodOptional<z.ZodType<DirectionRef, z.ZodTypeDef, DirectionRef>>;
         visualReferenceUrl: z.ZodOptional<z.ZodString>;
         instruction: z.ZodOptional<z.ZodString>;
         guidance: z.ZodOptional<z.ZodArray<z.ZodType<{
@@ -1427,6 +1430,8 @@ declare const variantWorkItemInputSchemas: {
         workerSelection?: WorkerSelection | undefined;
         briefBody?: string | undefined;
         briefNotes?: string | undefined;
+        directionRef?: DirectionRef | undefined;
+        sourceDirectionRef?: DirectionRef | undefined;
         visualReferenceUrl?: string | undefined;
         guidance?: {
             id: string;
@@ -1927,6 +1932,8 @@ declare const variantWorkItemInputSchemas: {
         workerSelection?: WorkerSelection | undefined;
         briefBody?: string | undefined;
         briefNotes?: string | undefined;
+        directionRef?: DirectionRef | undefined;
+        sourceDirectionRef?: DirectionRef | undefined;
         visualReferenceUrl?: string | undefined;
         guidance?: {
             id: string;
@@ -2595,6 +2602,8 @@ declare const variantWorkItemInputSchemas: {
         briefLabel: z.ZodOptional<z.ZodString>;
         briefBody: z.ZodOptional<z.ZodString>;
         briefNotes: z.ZodOptional<z.ZodString>;
+        directionRef: z.ZodOptional<z.ZodType<DirectionRef, z.ZodTypeDef, DirectionRef>>;
+        sourceDirectionRef: z.ZodOptional<z.ZodType<DirectionRef, z.ZodTypeDef, DirectionRef>>;
         visualReferenceUrl: z.ZodOptional<z.ZodString>;
         guidance: z.ZodOptional<z.ZodArray<z.ZodType<{
             id: string;
@@ -3407,6 +3416,8 @@ declare const variantWorkItemInputSchemas: {
         briefLabel?: string | undefined;
         briefBody?: string | undefined;
         briefNotes?: string | undefined;
+        directionRef?: DirectionRef | undefined;
+        sourceDirectionRef?: DirectionRef | undefined;
         visualReferenceUrl?: string | undefined;
         guidance?: {
             id: string;
@@ -3907,6 +3918,8 @@ declare const variantWorkItemInputSchemas: {
         briefLabel?: string | undefined;
         briefBody?: string | undefined;
         briefNotes?: string | undefined;
+        directionRef?: DirectionRef | undefined;
+        sourceDirectionRef?: DirectionRef | undefined;
         visualReferenceUrl?: string | undefined;
         guidance?: {
             id: string;
@@ -4572,6 +4585,8 @@ declare const variantWorkItemInputSchemas: {
             assetSourceRoot?: string | undefined;
         }>;
         briefNotes: z.ZodOptional<z.ZodString>;
+        directionRef: z.ZodOptional<z.ZodType<DirectionRef, z.ZodTypeDef, DirectionRef>>;
+        sourceDirectionRef: z.ZodOptional<z.ZodType<DirectionRef, z.ZodTypeDef, DirectionRef>>;
         visualReferenceUrl: z.ZodOptional<z.ZodString>;
         instruction: z.ZodOptional<z.ZodString>;
         guidance: z.ZodOptional<z.ZodArray<z.ZodType<{
@@ -5387,6 +5402,8 @@ declare const variantWorkItemInputSchemas: {
         } | undefined;
         workerSelection?: WorkerSelection | undefined;
         briefNotes?: string | undefined;
+        directionRef?: DirectionRef | undefined;
+        sourceDirectionRef?: DirectionRef | undefined;
         visualReferenceUrl?: string | undefined;
         guidance?: {
             id: string;
@@ -5887,6 +5904,8 @@ declare const variantWorkItemInputSchemas: {
         } | undefined;
         workerSelection?: WorkerSelection | undefined;
         briefNotes?: string | undefined;
+        directionRef?: DirectionRef | undefined;
+        sourceDirectionRef?: DirectionRef | undefined;
         visualReferenceUrl?: string | undefined;
         guidance?: {
             id: string;
@@ -5951,6 +5970,9 @@ export type VariantWorkItemInputByKind = {
     [Kind in VariantWorkItemKind]: z.infer<(typeof variantWorkItemInputSchemas)[Kind]>;
 };
 export type VariantWorkItemInput = VariantWorkItemInputByKind[VariantWorkItemKind];
+export declare const shownDirectionRef: (input: Pick<VariantWorkItemInput, "directionRef" | "sourceDirectionRef">) => {
+    directionRef?: DirectionRef;
+};
 export declare const parseVariantWorkItemInput: <Kind extends VariantWorkItemKind>(item: {
     id: string;
     kind: Kind;

package/dist/agent-variants/workItemInput.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseVariantWorkItemInput = exports.isVariantWorkItem = exports.isVariantWorkItemKind = exports.VARIANT_WORK_ITEM_KINDS = void 0;
+exports.parseVariantWorkItemInput = exports.shownDirectionRef = exports.isVariantWorkItem = exports.isVariantWorkItemKind = exports.VARIANT_WORK_ITEM_KINDS = void 0;
 const v3_1 = require("zod/v3");
 const errors_1 = require("./errors");
 exports.VARIANT_WORK_ITEM_KINDS = [
@@ -21,6 +21,12 @@ const variantWorkItemInputFields = v3_1.z.object({
     briefLabel: v3_1.z.string().optional(),
     briefBody: v3_1.z.string().optional(),
     briefNotes: v3_1.z.string().optional(),
+    directionRef: v3_1.z
+        .custom((value) => typeof value === 'string')
+        .optional(),
+    sourceDirectionRef: v3_1.z
+        .custom((value) => typeof value === 'string')
+        .optional(),
     visualReferenceUrl: v3_1.z.string().optional(),
     instruction: v3_1.z.string().optional(),
     guidance: v3_1.z.array(recordOf()).optional(),
@@ -59,6 +65,11 @@ const variantWorkItemInputSchemas = {
         briefBody: v3_1.z.string(),
     }),
 };
+const shownDirectionRef = (input) => {
+    const directionRef = input.directionRef ?? input.sourceDirectionRef;
+    return directionRef ? { directionRef } : {};
+};
+exports.shownDirectionRef = shownDirectionRef;
 const variantWorkItemInputParsers = {
     static_preview: (input) => variantWorkItemInputSchemas.static_preview.safeParse(input),
     refine_variant: (input) => variantWorkItemInputSchemas.refine_variant.safeParse(input),

package/dist/cli/commands/directionTarget.d.ts

@@ -0,0 +1,23 @@
+import { type CliCommandResult } from '../envelope';
+import type { DirectionRef } from '../../types/direction-ref';
+export type DirectionTarget = {
+    projectId?: string;
+    sessionId: string;
+    variantId: string;
+    directionRef?: DirectionRef;
+};
+type DirectionTargetResult = {
+    ok: true;
+    target: DirectionTarget;
+} | {
+    ok: false;
+    result: CliCommandResult;
+};
+export declare const resolveDirectionTarget: (args: {
+    command: string;
+    projectPath: string;
+    input: string;
+    usage: string;
+}) => Promise<DirectionTargetResult>;
+export {};
+//# sourceMappingURL=directionTarget.d.ts.map

package/dist/cli/commands/directionTarget.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveDirectionTarget = void 0;
+const envelope_1 = require("../envelope");
+const libraryErrors_1 = require("../../services/libraryErrors");
+const ProjectLibrary_1 = require("../../services/ProjectLibrary");
+const VariantHistoryService_1 = require("../../services/VariantHistoryService");
+const directionRefs_1 = require("../../services/directionRefs");
+const projectDirections_1 = require("../../services/projectDirections");
+const errorMessage_1 = require("../../utils/errorMessage");
+const resolveInProject = async (args) => {
+    const library = ProjectLibrary_1.ProjectLibrary.openReadOnly();
+    try {
+        const owner = library?.registry.findByPath(args.projectPath);
+        if (library && owner)
+            return {
+                projectId: owner.id,
+                resolution: await (0, projectDirections_1.resolveProjectDirection)({
+                    source: { kind: 'library', library, projectId: owner.id },
+                    address: args.address,
+                }),
+            };
+        const history = new VariantHistoryService_1.VariantHistoryService();
+        try {
+            return {
+                resolution: await (0, projectDirections_1.resolveProjectDirection)({
+                    source: { kind: 'history', history, projectPath: args.projectPath },
+                    address: args.address,
+                }),
+            };
+        }
+        finally {
+            history.metadata.closeAll();
+        }
+    }
+    finally {
+        library?.close();
+    }
+};
+const resolveDirectionTarget = async (args) => {
+    const address = (0, directionRefs_1.parseDirectionAddress)(args.input);
+    if (!address)
+        return {
+            ok: false,
+            result: (0, envelope_1.errorResult)(args.command, 'USAGE_ERROR', args.usage),
+        };
+    if (address.kind === 'ids') {
+        const { projectId, sessionId, variantId } = address;
+        return {
+            ok: true,
+            target: { ...(projectId ? { projectId } : {}), sessionId, variantId },
+        };
+    }
+    try {
+        const { projectId, resolution } = await resolveInProject({
+            projectPath: args.projectPath,
+            address,
+        });
+        if (!resolution.isResolved)
+            return {
+                ok: false,
+                result: (0, envelope_1.errorResult)(args.command, resolution.code, resolution.message, {
+                    input: args.input.trim(),
+                    candidates: resolution.candidates,
+                }),
+            };
+        const { directionRef, sessionId, variantId } = resolution.direction;
+        return {
+            ok: true,
+            target: {
+                ...(projectId ? { projectId } : {}),
+                sessionId,
+                variantId,
+                directionRef,
+            },
+        };
+    }
+    catch (error) {
+        const isMissingProject = error instanceof libraryErrors_1.LibraryError && error.code === 'project_not_found';
+        return {
+            ok: false,
+            result: (0, envelope_1.errorResult)(args.command, isMissingProject ? 'WORK_ITEM_NOT_FOUND' : 'OPERATION_FAILED', (0, errorMessage_1.errorMessage)(error)),
+        };
+    }
+};
+exports.resolveDirectionTarget = resolveDirectionTarget;
+//# sourceMappingURL=directionTarget.js.map

package/dist/cli/commands/open.js

@@ -47,6 +47,7 @@ const flags_1 = require("../flags");
 const client_1 = require("../client");
 const serverHandshake_1 = require("../serverHandshake");
 const serverVersion_1 = require("../serverVersion");
+const telemetry_1 = require("../telemetry");
 const handoff_1 = require("../handoff");
 const callerRunnerPaths_1 = require("../callerRunnerPaths");
 const runnerSelection_1 = require("../runnerSelection");
@@ -149,6 +150,15 @@ const passthroughServeArgs = (context) => {
     }
     return args;
 };
+const USER_PORT_FLAG = '--user-port';
+const withoutUserPort = (args) => args.filter((arg, index) => arg !== USER_PORT_FLAG && args[index - 1] !== USER_PORT_FLAG);
+const previewRecoveryServeArgs = (context, retiredArgs) => {
+    const userPort = (0, flags_1.stringFlag)(context.flags, 'user-port');
+    return [
+        ...withoutUserPort(retiredArgs ?? passthroughServeArgs(context)),
+        ...(userPort === undefined ? [] : [USER_PORT_FLAG, userPort]),
+    ];
+};
 const serveEnvFor = (handoff, baseEnv) => ({
     ...(0, subprocessEnvironment_1.subprocessEnvironment)('rivetRuntime', baseEnv),
     ...(0, callerRunnerPaths_1.callerRunnerPathsEnvEntry)(baseEnv),
@@ -283,12 +293,26 @@ const ensureProjectRuntime = async (context, io, dependencies = {}) => {
             }
             if (replacement.outcome === 'attach') {
                 const readinessError = await verifyRuntimeReadiness(existing, Math.min(serverStartTimeoutMs, APP_HEALTH_TIMEOUT_MS));
-                if (readinessError)
+                if (!readinessError) {
+                    return finishProjectOpen(await openedData(existing, true), io);
+                }
+                if ((0, telemetry_1.serverUnavailableReasonForEnvelope)(readinessError.envelope) !==
+                    'app_health_failed')
+                    return readinessError;
+                const retirement = await (0, projectRuntimeUpgrade_1.retireUnavailablePreview)({
+                    attached: existing,
+                    clientVersion: (0, serverVersion_1.serverVersionInfo)(existing.handshake).cliVersion,
+                    shutdownTimeoutMs: timeoutFromEnv(env, UPGRADE_SHUTDOWN_TIMEOUT_ENV, DEFAULT_UPGRADE_SHUTDOWN_TIMEOUT_MS),
+                });
+                if (retirement.outcome === 'kept')
                     return readinessError;
-                return finishProjectOpen(await openedData(existing, true), io);
+                restartArgs = previewRecoveryServeArgs(context, retirement.restartArgs);
+                io.writeProgress('The project server is restarting because the app preview is unavailable…');
+            }
+            else {
+                interruptedWork = replacement.interruptedWork;
+                restartArgs = replacement.restartArgs;
             }
-            interruptedWork = replacement.interruptedWork;
-            restartArgs = replacement.restartArgs;
         }
         io.writeProgress(`Starting Rivet server for ${projectPath}…`);
         const handle = spawnServer({