rivet-design 0.27.0 → 0.28.0

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({

package/dist/cli/commands/variants.js

@@ -50,6 +50,7 @@ const handoff_1 = require("../handoff");
 const callerModel_1 = require("../callerModel");
 const shared_1 = require("./shared");
 const elementSelector_1 = require("./elementSelector");
+const directionTarget_1 = require("./directionTarget");
 const hostWorkNextAction_1 = require("../hostWorkNextAction");
 const runLabel_1 = require("../../agent-variants/runLabel");
 const contracts_1 = require("../../agent-variants/contracts");
@@ -116,44 +117,22 @@ const LIST_FLAG_SPEC = {
 const GET_FLAG_SPEC = {
     detail: { takesValue: false },
 };
-const parseVariantTarget = (raw) => {
-    if (raw === undefined) {
+const START_TARGET_USAGE = 'Usage: --target <directionRef>|<sessionId>:<variantId> (example: --target warm-editorial-green)';
+const GET_USAGE = 'Usage: rivet variants get <directionRef>|last|[<projectId>/]<sessionId>:<variantId> [--detail] [--project <path>]';
+const resolveStartTarget = async (args) => {
+    if (args.raw === undefined)
         return { ok: true };
-    }
-    const separatorIndex = raw.indexOf(':');
-    if (separatorIndex <= 0 || separatorIndex === raw.length - 1) {
-        return {
-            ok: false,
-            message: 'Usage: --target <sessionId>:<variantId> (example: --target abc:def)',
-        };
-    }
-    const sessionId = raw.slice(0, separatorIndex).trim();
-    const variantId = raw.slice(separatorIndex + 1).trim();
-    if (!sessionId || !variantId) {
-        return {
-            ok: false,
-            message: 'Usage: --target <sessionId>:<variantId> (example: --target abc:def)',
-        };
-    }
+    const resolved = await (0, directionTarget_1.resolveDirectionTarget)({
+        command: START_COMMAND,
+        projectPath: args.projectPath,
+        input: args.raw,
+        usage: START_TARGET_USAGE,
+    });
+    if (!resolved.ok)
+        return resolved;
+    const { sessionId, variantId } = resolved.target;
     return { ok: true, target: { kind: 'variant', sessionId, variantId } };
 };
-const variantReferenceFromString = (raw) => {
-    if (!raw)
-        return null;
-    const projectSeparator = raw.indexOf('/');
-    const projectId = projectSeparator === -1 ? undefined : raw.slice(0, projectSeparator);
-    const direction = projectSeparator === -1 ? raw : raw.slice(projectSeparator + 1);
-    if (projectSeparator !== -1 && (!projectId || direction.includes('/')))
-        return null;
-    const variantSeparator = direction.indexOf(':');
-    if (variantSeparator <= 0 || variantSeparator === direction.length - 1)
-        return null;
-    if (direction.indexOf(':', variantSeparator + 1) !== -1)
-        return null;
-    const sessionId = direction.slice(0, variantSeparator).trim();
-    const variantId = direction.slice(variantSeparator + 1).trim();
-    return sessionId && variantId ? { projectId, sessionId, variantId } : null;
-};
 const parseJsonFlag = (command, name, raw) => {
     if (raw === undefined) {
         return { ok: true };
@@ -437,7 +416,7 @@ const handleVariantsStart = async (args, options) => {
     }
     const instruction = (0, flags_1.stringFlag)(context.flags, 'instruction');
     if (!instruction?.trim()) {
-        return (0, envelope_1.errorResult)(START_COMMAND, 'USAGE_ERROR', 'Usage: rivet variants start --instruction <text> [--run-label <text>] [--briefs <json>] [--count N] [--fidelity low|medium|high] [--element <selector>] [--files <json>] [--fresh] [--context-images <json>] [--context-assets <json>] [--reference-pages <json>] [--reference-videos <json>] [--target <sessionId>:<variantId>]');
+        return (0, envelope_1.errorResult)(START_COMMAND, 'USAGE_ERROR', 'Usage: rivet variants start --instruction <text> [--run-label <text>] [--briefs <json>] [--count N] [--fidelity low|medium|high] [--element <selector>] [--files <json>] [--fresh] [--context-images <json>] [--context-assets <json>] [--reference-pages <json>] [--reference-videos <json>] [--target <directionRef>|<sessionId>:<variantId>]');
     }
     if (context.flags.errors.length > 0) {
         return (0, envelope_1.errorResult)(START_COMMAND, 'USAGE_ERROR', context.flags.errors.join('; '));
@@ -508,10 +487,12 @@ const handleVariantsStart = async (args, options) => {
         return (0, envelope_1.errorResult)(START_COMMAND, 'USAGE_ERROR', '--count must match --briefs length when both are provided.');
     }
     const isFresh = isFreshStart;
-    const parsedTarget = parseVariantTarget((0, flags_1.stringFlag)(context.flags, 'target'));
-    if (!parsedTarget.ok) {
-        return (0, envelope_1.errorResult)(START_COMMAND, 'USAGE_ERROR', parsedTarget.message);
-    }
+    const parsedTarget = await resolveStartTarget({
+        projectPath: context.projectPath,
+        raw: (0, flags_1.stringFlag)(context.flags, 'target'),
+    });
+    if (!parsedTarget.ok)
+        return parsedTarget.result;
     if (isFresh && parsedTarget.target) {
         return (0, envelope_1.errorResult)(START_COMMAND, 'USAGE_ERROR', '--fresh cannot be combined with --target; start fresh generation from the base project.');
     }
@@ -782,6 +763,7 @@ const handleSavedVariantGet = async (args) => {
                 return (0, envelope_1.errorResult)(GET_COMMAND, 'WORK_ITEM_NOT_FOUND', 'No saved variant exists for this project and reference.');
             const saved = 'detail' in found ? found.detail : found.summary;
             const { manifest, variantDir } = saved;
+            const directionRef = args.directionRef ?? manifest.directionRef;
             const kind = manifest.artifact.kind === 'diff' ? 'diff' : 'project-created';
             const artifactPath = path.join(variantDir, manifest.artifact.kind === 'diff'
                 ? manifest.artifact.diffPath
@@ -789,6 +771,7 @@ const handleSavedVariantGet = async (args) => {
             const variant = args.isDetailed && 'detail' in found
                 ? {
                     ...manifest,
+                    directionRef,
                     kind,
                     artifactPath,
                     diff: found.detail.diff,
@@ -796,6 +779,7 @@ const handleSavedVariantGet = async (args) => {
                     designMarkdown: found.detail.designMarkdown,
                 }
                 : {
+                    directionRef,
                     sessionId: manifest.sessionId,
                     variantId: manifest.variantId,
                     status: manifest.status,
@@ -825,12 +809,21 @@ const handleVariantsGet = async (args) => {
     if ((0, shared_1.isCommandResult)(context)) {
         return context;
     }
-    const reference = variantReferenceFromString(context.flags.positionals[0]);
-    if (!reference ||
+    const input = context.flags.positionals[0];
+    if (input === undefined ||
         context.flags.positionals.length !== 1 ||
         context.flags.errors.length > 0) {
-        return (0, envelope_1.errorResult)(GET_COMMAND, 'USAGE_ERROR', 'Usage: rivet variants get [<projectId>/]<sessionId>:<variantId> [--detail] [--project <path>]');
+        return (0, envelope_1.errorResult)(GET_COMMAND, 'USAGE_ERROR', GET_USAGE);
     }
+    const resolved = await (0, directionTarget_1.resolveDirectionTarget)({
+        command: GET_COMMAND,
+        projectPath: context.projectPath,
+        input,
+        usage: GET_USAGE,
+    });
+    if (!resolved.ok)
+        return resolved.result;
+    const reference = resolved.target;
     if (reference.projectId)
         return handleSavedVariantGet({
             ...reference,

package/dist/cli/envelope.d.ts

@@ -8,7 +8,7 @@ export declare const CLI_EXIT_CODES: {
     readonly waitTimeout: 5;
 };
 export type CliExitCode = (typeof CLI_EXIT_CODES)[keyof typeof CLI_EXIT_CODES];
-export type CliErrorCode = 'OPERATION_FAILED' | 'USAGE_ERROR' | 'AUTH_REQUIRED' | 'SERVER_UNAVAILABLE' | 'WAIT_TIMEOUT' | 'SESSION_NOT_FOUND' | 'WORK_ITEM_NOT_FOUND' | 'MCP_REMOVED';
+export type CliErrorCode = 'OPERATION_FAILED' | 'USAGE_ERROR' | 'AUTH_REQUIRED' | 'SERVER_UNAVAILABLE' | 'WAIT_TIMEOUT' | 'SESSION_NOT_FOUND' | 'WORK_ITEM_NOT_FOUND' | 'DIRECTION_AMBIGUOUS' | 'MCP_REMOVED';
 export type CliLoginAction = {
     action: 'login';
     command: 'rivet login';

package/dist/cli/envelope.js

@@ -24,6 +24,7 @@ const ERROR_EXIT_CODES = {
     WAIT_TIMEOUT: exports.CLI_EXIT_CODES.waitTimeout,
     SESSION_NOT_FOUND: exports.CLI_EXIT_CODES.operationFailed,
     WORK_ITEM_NOT_FOUND: exports.CLI_EXIT_CODES.operationFailed,
+    DIRECTION_AMBIGUOUS: exports.CLI_EXIT_CODES.usageError,
     MCP_REMOVED: exports.CLI_EXIT_CODES.usageError,
 };
 const loginRecovery = (authUrl) => ({

package/dist/cli/projectRuntimeUpgrade.d.ts

@@ -12,6 +12,17 @@ type RuntimeUpgradeOutcome = {
     restartArgs?: string[];
     interruptedWork?: RuntimeInterruption;
 };
+type RuntimeRetirement = {
+    outcome: 'retired';
+    restartArgs?: string[];
+} | {
+    outcome: 'kept';
+};
+export declare const retireUnavailablePreview: ({ attached, clientVersion, shutdownTimeoutMs, }: {
+    attached: AttachedServer;
+    clientVersion: string;
+    shutdownTimeoutMs: number;
+}) => Promise<RuntimeRetirement>;
 export declare const prepareRuntimeUpgrade: ({ attached, io, shutdownTimeoutMs, }: {
     attached: AttachedServer;
     io: CliIO;

package/dist/cli/projectRuntimeUpgrade.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.prepareRuntimeUpgrade = void 0;
+exports.prepareRuntimeUpgrade = exports.retireUnavailablePreview = void 0;
 const zod_1 = require("zod");
 const fs_1 = __importDefault(require("fs"));
 const client_1 = require("./client");
@@ -34,6 +34,43 @@ const INTERRUPTIBLE_REASONS = new Set([
     'active_work',
     'unknown_execution_state',
 ]);
+const awaitOwnedRuntimeShutdown = async ({ attached, processIdentity, shutdownTimeoutMs, }) => {
+    if (await (0, serverShutdown_1.waitForServerShutdown)(attached, shutdownTimeoutMs))
+        return;
+    await (0, stopRuntimeProcess_1.stopRuntimeProcess)({
+        pid: attached.handshake.pid,
+        timeoutMs: shutdownTimeoutMs,
+        isOwned: async () => {
+            return (processIdentity !== null &&
+                (0, stopRuntimeProcess_1.runtimeProcessIdentity)(attached.handshake.pid) === processIdentity);
+        },
+    });
+};
+const retireUnavailablePreview = async ({ attached, clientVersion, shutdownTimeoutMs, }) => {
+    const serverVersion = attached.handshake.rivetVersion;
+    if (!serverVersion || (0, serverVersion_1.isNewerVersion)(serverVersion, clientVersion))
+        return { outcome: 'kept' };
+    try {
+        const processIdentity = (0, stopRuntimeProcess_1.runtimeProcessIdentity)(attached.handshake.pid);
+        const upgrade = await (0, client_1.requestServer)(attached, '/api/cli/upgrade', {
+            method: 'POST',
+            body: { clientVersion, requireIdle: true },
+        });
+        const parsed = upgradeSchema.parse(upgrade.body);
+        if (upgrade.status !== 200 || parsed.stopping !== true)
+            return { outcome: 'kept' };
+        await awaitOwnedRuntimeShutdown({
+            attached,
+            processIdentity,
+            shutdownTimeoutMs,
+        });
+        return { outcome: 'retired', restartArgs: parsed.restartArgs };
+    }
+    catch {
+        return { outcome: 'kept' };
+    }
+};
+exports.retireUnavailablePreview = retireUnavailablePreview;
 const prepareRuntimeUpgrade = async ({ attached, io, shutdownTimeoutMs, }) => {
     const info = (0, serverVersion_1.serverVersionInfo)(attached.handshake);
     if (!info.staleServer)
@@ -92,16 +129,11 @@ const prepareRuntimeUpgrade = async ({ attached, io, shutdownTimeoutMs, }) => {
             : undefined;
         if (interruptedWork)
             io.writeProgress(`${interruptedWork.message} Recovery details: ${interruptedWork.receiptPath}`);
-        if (!(await (0, serverShutdown_1.waitForServerShutdown)(attached, shutdownTimeoutMs))) {
-            await (0, stopRuntimeProcess_1.stopRuntimeProcess)({
-                pid: attached.handshake.pid,
-                timeoutMs: shutdownTimeoutMs,
-                isOwned: async () => {
-                    return (processIdentity !== null &&
-                        (0, stopRuntimeProcess_1.runtimeProcessIdentity)(attached.handshake.pid) === processIdentity);
-                },
-            });
-        }
+        await awaitOwnedRuntimeShutdown({
+            attached,
+            processIdentity,
+            shutdownTimeoutMs,
+        });
         io.writeProgress(`Upgrading project server to rivet v${info.cliVersion}…`);
         return {
             outcome: 'spawn',

package/dist/config/pluginMetrics.js

@@ -120,6 +120,7 @@ const metricProperties = zod_1.z.object({
         'WAIT_TIMEOUT',
         'SESSION_NOT_FOUND',
         'WORK_ITEM_NOT_FOUND',
+        'DIRECTION_AMBIGUOUS',
         'MCP_REMOVED',
         'STATIC_PREVIEW_FAILED',
         'DEV_SERVER_FAILED',
@@ -164,6 +165,7 @@ const metricProperties = zod_1.z.object({
         'usage_error',
         'wait_timeout',
         'session_not_found',
+        'direction_ambiguous',
         'mcp_removed',
         'server_start_timeout',
         'handshake_missing',

package/dist/config/posthog.d.ts

@@ -0,0 +1,2 @@
+export declare const POSTHOG_PUBLIC_API_KEY = "phc_Ntj9tXHbS64XgYxlTfhglRmFivFsfm0AERph4ZlnNH";
+//# sourceMappingURL=posthog.d.ts.map

package/dist/config/posthog.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.POSTHOG_PUBLIC_API_KEY = void 0;
+exports.POSTHOG_PUBLIC_API_KEY = 'phc_Ntj9tXHbS64XgYxlTfhglRmFivFsfm0AERph4ZlnNH';
+//# sourceMappingURL=posthog.js.map

package/dist/mcp/explorationSchema.js

@@ -117,7 +117,7 @@ exports.explorationShape = {
     baseDirectionId: v3_1.z
         .string()
         .optional()
-        .describe('start: sessionId:variantId — refine an existing variant in place'),
+        .describe('start: direction ref (e.g. warm-editorial-green), sessionId:variantId, or projectId/sessionId:variantId — refine an existing variant in place'),
     project: v3_1.z.string().trim().min(1).describe('Absolute project root path'),
 };
 //# sourceMappingURL=explorationSchema.js.map

package/dist/mcp/getExploration.js

@@ -17,6 +17,8 @@ const ConfigManager_1 = require("../services/ConfigManager");
 const ProjectLibrary_1 = require("../services/ProjectLibrary");
 const VariantHistoryService_1 = require("../services/VariantHistoryService");
 const historyRoots_1 = require("../services/historyRoots");
+const directionRefs_1 = require("../services/directionRefs");
+const projectDirections_1 = require("../services/projectDirections");
 const profileAccess_1 = require("./profileAccess");
 const getExploration = async (input) => {
     const command = 'rivet_get_exploration';
@@ -68,12 +70,16 @@ const getExploration = async (input) => {
             ? registered.library.registry.historyRoots(registered.owner.id)
             : [project, ...(0, historyRoots_1.nestedFreshSessionWorkdirs)(project)];
         if (!hasLiveServer || input.includeHistory || input.sessionId) {
+            const directions = await (0, projectDirections_1.listProjectDirections)(registered
+                ? {
+                    kind: 'library',
+                    library: registered.library,
+                    projectId: registered.owner.id,
+                }
+                : { kind: 'history', history, projectPath: project });
             const entries = registered
-                ? await registered.library.listVariants(registered.owner.id)
-                : (await Promise.all(roots.map(async (projectPath) => (await history.listVariants({ projectPath })).map((entry) => ({
-                    ...entry,
-                    projectPath,
-                }))))).flat();
+                ? directions.filter((entry) => (0, directionRefs_1.isDirectionActive)(entry.manifest.status))
+                : directions;
             data.history = entries.filter((entry) => (!input.sessionId || entry.manifest.sessionId === input.sessionId) &&
                 (!input.variantId || entry.manifest.variantId === input.variantId));
             if (input.variantId && input.sessionId) {

package/dist/proxy-middleware/proxy-config.js

@@ -13,6 +13,10 @@ const TARGET_ADDRESSED_PREVIEW_PREFIX = '/__rivet/preview';
 const TARGET_ADDRESSED_PREVIEW_KIND_BASE = 'base';
 const TARGET_ADDRESSED_PREVIEW_KIND_HISTORY = 'history';
 const TARGET_ADDRESSED_PREVIEW_KIND_VARIANT = 'variant';
+const CACHE_VALIDATOR_REQUEST_HEADERS = [
+    'if-none-match',
+    'if-modified-since',
+];
 const hasValidUserDevPort = (userPort) => Number.isInteger(userPort) && userPort > 0;
 const resolveTargetAddressedPreview = (args) => {
     const parsed = new URL(args.rawUrl ?? '/', 'http://rivet.local');
@@ -152,6 +156,9 @@ const createUserDevServerProxy = (userPort, userHost = 'localhost', options = {}
         requestTargets.set(req, target);
         if (target.isTargetAddressed) {
             req.url = target.path;
+            for (const header of CACHE_VALIDATOR_REQUEST_HEADERS) {
+                delete req.headers[header];
+            }
         }
     };
     const getRouterTargetForLibrary = (req) => {