rivet-design 0.19.0 → 0.20.0

package/dist/agent-variants/WorktreeOrchestrator.js

@@ -3,19 +3,15 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AgentVariantsOrchestrator = void 0;
-exports.buildStaticPreviewDocument = buildStaticPreviewDocument;
+exports.AgentVariantsOrchestrator = exports.buildStaticPreviewDocument = void 0;
 const crypto_1 = require("crypto");
 const events_1 = require("events");
 const fs_1 = __importDefault(require("fs"));
 const os_1 = __importDefault(require("os"));
 const path_1 = __importDefault(require("path"));
 const DependencyPreparationService_1 = require("../services/DependencyPreparationService");
-const ProjectPackageManager_1 = require("../services/ProjectPackageManager");
-const devServerCommand_1 = require("../utils/devServerCommand");
 const simple_git_1 = require("simple-git");
 const logger_1 = require("../utils/logger");
-const devServerError_1 = require("../utils/devServerError");
 const errors_1 = require("./errors");
 const createProjectArtifacts_1 = require("./createProjectArtifacts");
 const contracts_1 = require("./contracts");
@@ -23,15 +19,18 @@ const workItemBriefing_1 = require("./workItemBriefing");
 const briefContent_1 = require("./briefContent");
 const runLabel_1 = require("./runLabel");
 const runPlan_1 = require("./runPlan");
-const viteReactTs_1 = require("../services/templates/viteReactTs");
-const StaticPreviewServer_1 = require("../services/StaticPreviewServer");
-const designCatalog_1 = require("../services/templates/designCatalog");
 const previewQa_1 = require("./previewQa");
-const VariantWorkspaceManager_1 = require("./VariantWorkspaceManager");
+const WorkspaceInventory_1 = require("./WorkspaceInventory");
+const WorkspaceProvisioning_1 = require("./WorkspaceProvisioning");
+const PreviewRuntime_1 = require("./PreviewRuntime");
 const diffQa_1 = require("./diffQa");
 const VariantHistoryService_1 = require("../services/VariantHistoryService");
 const variantContext_1 = require("./variantContext");
-const contextAssets_1 = require("./contextAssets");
+const designContextArtifacts_1 = require("./designContextArtifacts");
+const variantsTelemetry_1 = require("./variantsTelemetry");
+const variantWorkspaceFiles_1 = require("./variantWorkspaceFiles");
+var variantWorkspaceFiles_2 = require("./variantWorkspaceFiles");
+Object.defineProperty(exports, "buildStaticPreviewDocument", { enumerable: true, get: function () { return variantWorkspaceFiles_2.buildStaticPreviewDocument; } });
 const log = (0, logger_1.createLogger)('AgentVariantsOrchestrator');
 const FRESH_DEV_SERVER_HOST = '127.0.0.1';
 const BRIEF_LABEL_MAX_LENGTH = 48;
@@ -65,24 +64,9 @@ const BRIEF_LABEL_ALTERNATIVES = [
     'Density',
     'Color',
 ];
-const FALLBACK_DIRECTION_FOCI = [
-    'Emphasize hierarchy and one unmistakable primary action.',
-    'Use stronger contrast, scale shifts, and a more expressive visual system.',
-    'Favor a quieter, spacious composition with restrained supporting detail.',
-    'Make information density and fast scanning the organizing principle.',
-    'Lead with imagery and let content frame the visual story.',
-    'Use modular cards and clear grouping to expose the product structure.',
-    'Explore tactile depth, layering, and purposeful interaction cues.',
-    'Reduce the concept to its most essential typography and geometry.',
-];
 const SETTLE_PERSISTS_TEARDOWN_TIMEOUT_MS = 20_000;
 const RECIPE_PORT_SENTINEL = 65535;
-const FRESH_DEV_SERVER_DEFAULT_PORT = 5173;
-const DEV_SERVER_START_MAX_ATTEMPTS = 3;
-const DEV_SERVER_MAX_AUTO_RESTARTS = 2;
 const DEV_SERVER_RESTART_DELAY_MS = 1_000;
-const DESIGN_CONTEXT_ROUTE_SEGMENT = 'design-md';
-const DESIGN_CONTEXT_VIEW_SEGMENT = 'view';
 const DEFAULT_PROVISION_TIMEOUT_MS = 540_000;
 const PROVISION_TIMEOUT_MS = (() => {
     const raw = process.env.RIVET_VARIANTS_PROVISION_TIMEOUT_MS;
@@ -99,142 +83,6 @@ const ACTIVE_VARIANT_SERVER_IDLE_TTL_MS = (() => {
         ? parsed
         : DEFAULT_ACTIVE_VARIANT_SERVER_IDLE_TTL_MS;
 })();
-class ProvisionTimeoutError extends Error {
-    timeoutMs;
-    constructor(timeoutMs) {
-        super(`Worktree provisioning timed out after ${timeoutMs}ms`);
-        this.timeoutMs = timeoutMs;
-        this.name = 'ProvisionTimeoutError';
-    }
-}
-function withProvisionTimeout(work, timeoutMs) {
-    let timer;
-    const timeout = new Promise((_, reject) => {
-        timer = setTimeout(() => reject(new ProvisionTimeoutError(timeoutMs)), timeoutMs);
-        if (typeof timer.unref === 'function')
-            timer.unref();
-    });
-    return Promise.race([work, timeout]).finally(() => clearTimeout(timer));
-}
-const ALLOWED_INERT_ASSET_EXTENSIONS = new Set([
-    '.glb',
-    '.gltf',
-    '.obj',
-    '.fbx',
-    '.usdz',
-    '.png',
-    '.jpg',
-    '.jpeg',
-    '.gif',
-    '.webp',
-    '.svg',
-    '.avif',
-    '.bmp',
-    '.ico',
-    '.mp4',
-    '.webm',
-    '.mov',
-    '.mp3',
-    '.wav',
-    '.ogg',
-    '.m4a',
-    '.woff',
-    '.woff2',
-    '.ttf',
-    '.otf',
-    '.eot',
-    '.pdf',
-]);
-const SENSITIVE_PATH_SEGMENTS = new Set([
-    '.ssh',
-    '.aws',
-    '.gnupg',
-    '.kube',
-    '.docker',
-    '.config',
-    '.npm',
-    '.cargo',
-    '.gem',
-    '.netrc',
-    'private',
-    'secrets',
-    'credentials',
-]);
-function hasSensitivePathSegment(absolutePath) {
-    const segments = absolutePath.split(/[/\\]/).filter(Boolean);
-    return segments.some((segment) => SENSITIVE_PATH_SEGMENTS.has(segment.toLowerCase()));
-}
-function isPathWithinRoot(absolutePath, root) {
-    const relative = path_1.default.relative(root, absolutePath);
-    return (relative === '' ||
-        (relative.length > 0 &&
-            !relative.startsWith('..') &&
-            !path_1.default.isAbsolute(relative)));
-}
-function copyAssetIntoWorktree(worktreePath, entry, assetSourceRoot) {
-    if (!assetSourceRoot) {
-        throw new errors_1.AgentVariantsError('RUNTIME_VALIDATION_FAILED', `assetPlan.source requires an approved asset root before copying '${entry.source}'`);
-    }
-    if (!path_1.default.isAbsolute(assetSourceRoot)) {
-        throw new errors_1.AgentVariantsError('RUNTIME_VALIDATION_FAILED', `assetSourceRoot must be an absolute path, got '${assetSourceRoot}'`);
-    }
-    const absoluteSource = path_1.default.isAbsolute(entry.source)
-        ? entry.source
-        : path_1.default.resolve(assetSourceRoot, entry.source);
-    const ext = path_1.default.extname(absoluteSource).toLowerCase();
-    if (!ALLOWED_INERT_ASSET_EXTENSIONS.has(ext)) {
-        throw new errors_1.AgentVariantsError('RUNTIME_VALIDATION_FAILED', `assetPlan.source extension '${ext || '(none)'}' is not on the allowlist (got '${entry.source}'). Only inert media/font/document assets may be copied.`);
-    }
-    let lstat;
-    try {
-        lstat = fs_1.default.lstatSync(absoluteSource);
-    }
-    catch {
-        throw new errors_1.AgentVariantsError('RUNTIME_VALIDATION_FAILED', `assetPlan.source not found on disk: ${entry.source}`);
-    }
-    if (lstat.isSymbolicLink()) {
-        throw new errors_1.AgentVariantsError('RUNTIME_VALIDATION_FAILED', `assetPlan.source must not be a symlink: ${entry.source}`);
-    }
-    if (!lstat.isFile()) {
-        throw new errors_1.AgentVariantsError('RUNTIME_VALIDATION_FAILED', `assetPlan.source must be a regular file: ${entry.source}`);
-    }
-    let resolvedSource;
-    try {
-        resolvedSource = fs_1.default.realpathSync(absoluteSource);
-    }
-    catch {
-        throw new errors_1.AgentVariantsError('RUNTIME_VALIDATION_FAILED', `assetPlan.source could not be resolved: ${entry.source}`);
-    }
-    let resolvedAssetSourceRoot;
-    try {
-        resolvedAssetSourceRoot = fs_1.default.realpathSync(assetSourceRoot);
-    }
-    catch {
-        throw new errors_1.AgentVariantsError('RUNTIME_VALIDATION_FAILED', `assetSourceRoot could not be resolved: ${assetSourceRoot}`);
-    }
-    const resolvedStat = fs_1.default.statSync(resolvedSource);
-    if (!resolvedStat.isFile()) {
-        throw new errors_1.AgentVariantsError('RUNTIME_VALIDATION_FAILED', `assetPlan.source resolved target must be a regular file: ${entry.source}`);
-    }
-    if (!isPathWithinRoot(resolvedSource, resolvedAssetSourceRoot)) {
-        throw new errors_1.AgentVariantsError('RUNTIME_VALIDATION_FAILED', `assetPlan.source must stay inside the approved asset root: ${entry.source}`);
-    }
-    const relativeResolvedSource = path_1.default.relative(resolvedAssetSourceRoot, resolvedSource);
-    if (hasSensitivePathSegment(relativeResolvedSource)) {
-        throw new errors_1.AgentVariantsError('RUNTIME_VALIDATION_FAILED', `assetPlan.source traverses a sensitive directory and is refused: ${entry.source}`);
-    }
-    const resolvedExt = path_1.default.extname(resolvedSource).toLowerCase();
-    if (!ALLOWED_INERT_ASSET_EXTENSIONS.has(resolvedExt)) {
-        throw new errors_1.AgentVariantsError('RUNTIME_VALIDATION_FAILED', `assetPlan.source resolved extension '${resolvedExt || '(none)'}' is not on the allowlist (resolved from '${entry.source}').`);
-    }
-    const normalizedDest = path_1.default.normalize(entry.destination);
-    if (normalizedDest.startsWith('..') || path_1.default.isAbsolute(normalizedDest)) {
-        throw new errors_1.AgentVariantsError('RUNTIME_VALIDATION_FAILED', `assetPlan.destination must stay inside the worktree, got '${entry.destination}'`);
-    }
-    const absDest = path_1.default.join(worktreePath, normalizedDest);
-    fs_1.default.mkdirSync(path_1.default.dirname(absDest), { recursive: true });
-    fs_1.default.copyFileSync(resolvedSource, absDest);
-}
 const defaultPreviewQaRunner = ({ html }) => (0, previewQa_1.runPreviewQa)({ html });
 const buildViewDisabledReason = (args) => {
     if (args.status === 'failed') {
@@ -248,7 +96,6 @@ const buildViewDisabledReason = (args) => {
     }
     return 'Variant is still running';
 };
-const NOOP_TELEMETRY = { track: () => undefined };
 const isImplementationWorkItemKind = (kind) => kind === 'static_preview' || kind === 'refine_variant' || kind === 'code_gen';
 const DEFAULT_EXECUTION_MODE_BY_KIND = {
     static_preview: 'create',
@@ -350,41 +197,68 @@ class AgentVariantsOrchestrator {
     installDependencies;
     materializeProject;
     previewQaRunner;
-    switchPreviewPort;
-    setCommittedDevServerHealth;
     variantHistory;
-    startStaticPreviewServerImpl;
     provisionTimeoutMs;
     activeVariantServerIdleTtlMs;
     devServerRestartDelayMs;
     resources = new Map();
-    lingeringCommittedDevServers = new Map();
+    workspaceInventory;
+    workspaceProvisioning;
+    previewRuntime;
     inflightCommits = new Map();
     activeSessionId = null;
     events = new events_1.EventEmitter();
     constructor(deps) {
         this.store = deps.store;
         this.worktrees = deps.worktreeManager;
+        this.workspaceInventory = new WorkspaceInventory_1.WorkspaceInventory({
+            worktreeManager: deps.worktreeManager,
+        });
         this.resolveEnv = deps.resolveProjectEnvironment;
-        this.telemetry = deps.telemetry ?? NOOP_TELEMETRY;
+        this.telemetry = deps.telemetry ?? variantsTelemetry_1.NOOP_TELEMETRY;
         this.installDependencies =
-            deps.installDependencies ?? defaultInstallDependencies;
+            deps.installDependencies ?? variantWorkspaceFiles_1.defaultInstallDependencies;
         this.materializeProject =
-            deps.materializeProject ?? defaultMaterializeProject;
+            deps.materializeProject ?? variantWorkspaceFiles_1.defaultMaterializeProject;
         this.previewQaRunner = deps.previewQaRunner ?? defaultPreviewQaRunner;
-        this.switchPreviewPort = deps.switchPreviewPort;
-        this.setCommittedDevServerHealth = deps.setCommittedDevServerHealth;
         this.variantHistory = deps.variantHistory ?? new VariantHistoryService_1.VariantHistoryService();
-        this.startStaticPreviewServerImpl =
-            deps.startStaticPreviewServer ?? StaticPreviewServer_1.startStaticPreviewServer;
         this.provisionTimeoutMs = deps.provisionTimeoutMs ?? PROVISION_TIMEOUT_MS;
+        this.workspaceProvisioning = new WorkspaceProvisioning_1.WorkspaceProvisioning({
+            store: deps.store,
+            inventory: this.workspaceInventory,
+            worktreeManager: deps.worktreeManager,
+            telemetry: deps.telemetry ?? variantsTelemetry_1.NOOP_TELEMETRY,
+            resolveProjectEnvironment: deps.resolveProjectEnvironment,
+            installDependencies: deps.installDependencies ?? variantWorkspaceFiles_1.defaultInstallDependencies,
+            provisionTimeoutMs: this.provisionTimeoutMs,
+            cancelSession: (sessionId) => this.cancel({ sessionId, reason: 'provisioning_failed' }),
+            changed: () => this.emitChange(),
+            isSessionLive: (sessionId) => this.resources.has(sessionId),
+        });
         this.activeVariantServerIdleTtlMs =
             deps.activeVariantServerIdleTtlMs ?? ACTIVE_VARIANT_SERVER_IDLE_TTL_MS;
         this.devServerRestartDelayMs =
             deps.devServerRestartDelayMs ?? DEV_SERVER_RESTART_DELAY_MS;
+        this.previewRuntime = new PreviewRuntime_1.PreviewRuntime({
+            worktreeManager: deps.worktreeManager,
+            resolveProjectEnvironment: deps.resolveProjectEnvironment,
+            getProjectContext: (sessionId) => this.store.getProjectContext(sessionId),
+            getDependencySignal: (sessionId) => this.workspaceInventory.getDependencySignal(sessionId),
+            installDependencies: this.installDependencies,
+            telemetry: this.telemetry,
+            isSessionLive: (sessionId) => this.resources.has(sessionId),
+            isCleanupStarted: (sessionId) => this.workspaceInventory.isCleanupStarted(sessionId),
+            hasUiClients: () => this.uiClientCount > 0,
+            changed: () => this.emitChange(),
+            switchPreviewPort: deps.switchPreviewPort,
+            setCommittedDevServerHealth: deps.setCommittedDevServerHealth,
+            startStaticPreviewServer: deps.startStaticPreviewServer,
+            activeVariantServerIdleTtlMs: this.activeVariantServerIdleTtlMs,
+            devServerRestartDelayMs: this.devServerRestartDelayMs,
+        });
     }
     propose(args) {
-        void this.stopLingeringCommittedDevServers().catch((err) => {
+        void this.previewRuntime.stopLingeringCommitted().catch((err) => {
             log.warn('Stopping lingering committed dev servers failed', err);
         });
         const result = this.store.propose(args);
@@ -470,9 +344,9 @@ class AgentVariantsOrchestrator {
     }
     touchSession(sessionId) {
         const resources = this.resources.get(sessionId);
-        if (!resources || resources.cleanupStarted)
+        if (!resources || this.workspaceInventory.isCleanupStarted(sessionId))
             return;
-        this.scheduleActivePreviewIdleTimer(resources);
+        this.previewRuntime.touch(sessionId);
     }
     buildActiveSnapshot() {
         const sessionId = this.activeSessionId;
@@ -490,11 +364,11 @@ class AgentVariantsOrchestrator {
             : null;
         const variants = this.getVariants(sessionId);
         const sessionProjectContext = this.store.getProjectContext(sessionId);
-        const projectContext = toActiveProjectContext(sessionProjectContext);
+        const projectContext = (0, designContextArtifacts_1.toActiveProjectContext)(sessionProjectContext);
         const destinationPath = projectContext.kind === 'fresh'
             ? projectContext.workspacePath
             : undefined;
-        const artifacts = buildSessionArtifacts(sessionId, sessionProjectContext);
+        const artifacts = (0, designContextArtifacts_1.buildSessionArtifacts)(sessionId, sessionProjectContext);
         const hostWork = this.getHostWork(sessionId);
         const workerRuntime = this.store.getWorkerRuntime(sessionId);
         return {
@@ -547,14 +421,8 @@ class AgentVariantsOrchestrator {
                 return planningItem;
             }
             const input = (item.input ?? {});
-            const workspace = this.getAssignedWorkspace({
-                sessionId,
-                workItemId: item.workId,
-                kind,
-            });
-            const contextAssets = this.resources
-                .get(sessionId)
-                ?.contextAssets.get(item.workId);
+            const workspace = this.workspaceInventory.requireAssignedWorkspace(sessionId, item.workId, kind);
+            const contextAssets = this.workspaceInventory.getContextAssets(sessionId, item.workId);
             const mode = input.sourceVariantId
                 ? 'vary'
                 : DEFAULT_EXECUTION_MODE_BY_KIND[kind];
@@ -601,16 +469,6 @@ class AgentVariantsOrchestrator {
             return implementationItem;
         });
     }
-    getAssignedWorkspace(args) {
-        const workspace = this.resources
-            .get(args.sessionId)
-            ?.workspaceManager.getAssignedWorkspace(args.workItemId);
-        const expectedKind = args.kind === 'code_gen' ? 'git_worktree' : 'artifact_directory';
-        if (!workspace || workspace.kind !== expectedKind) {
-            throw new errors_1.AgentVariantsError('RUNTIME_VALIDATION_FAILED', `Variant ${args.workItemId} has no assigned ${expectedKind} workspace`);
-        }
-        return workspace;
-    }
     getVariantsTelemetryMode(projectContext, _target) {
         if (projectContext.kind === 'fresh' && projectContext.variantContext) {
             return 'source_grounded';
@@ -908,9 +766,9 @@ class AgentVariantsOrchestrator {
     }
     requestWork(args) {
         const result = this.store.requestWork(args);
+        const resources = this.ensureResources(args.sessionId);
         try {
-            this.ensureStaticWorkspaces(args.sessionId, result.leasedWorkItems);
-            this.materializeContextAssets(args.sessionId, result.leasedWorkItems);
+            this.workspaceProvisioning.assignImplementationWorkspaces(args.sessionId, result.leasedWorkItems);
         }
         catch (error) {
             for (const item of result.leasedWorkItems) {
@@ -937,12 +795,9 @@ class AgentVariantsOrchestrator {
             }
             throw error;
         }
-        const resources = this.resources.get(args.sessionId);
-        if (resources) {
-            const now = Date.now();
-            for (const item of result.leasedWorkItems) {
-                resources.leasedAt.set(item.id, now);
-            }
+        const now = Date.now();
+        for (const item of result.leasedWorkItems) {
+            resources.leasedAt.set(item.id, now);
         }
         this.writeLeasedWorkItemBriefings(args.sessionId, result.leasedWorkItems.map((item) => item.id));
         this.trackRefinementLeased({ sessionId: args.sessionId, lease: result });
@@ -962,38 +817,6 @@ class AgentVariantsOrchestrator {
         this.emitChange();
         return decorated;
     }
-    materializeContextAssets(sessionId, items) {
-        const resources = this.ensureResources(sessionId);
-        for (const item of items) {
-            if (!isImplementationWorkItemKind(item.kind))
-                continue;
-            const input = (item.input ?? {});
-            const assets = input.context?.contextAssets ?? [];
-            if (assets.length === 0)
-                continue;
-            const workspace = this.getAssignedWorkspace({
-                sessionId,
-                workItemId: item.id,
-                kind: item.kind,
-            });
-            const previewKind = workspace.kind === 'artifact_directory'
-                ? 'static_artifact'
-                : (resources.contextAssetPreviewKind ?? 'dev_server');
-            resources.contextAssets.set(item.id, (0, contextAssets_1.materializeContextAssets)({ assets, workspace, previewKind }));
-        }
-    }
-    async resolveContextAssetPreviewKind(sessionId) {
-        const resources = this.ensureResources(sessionId);
-        try {
-            const environment = await this.resolveEnv(sessionId);
-            resources.contextAssetPreviewKind =
-                environment.framework === 'static' ? 'static_artifact' : 'dev_server';
-        }
-        catch (error) {
-            resources.contextAssetPreviewKind = 'dev_server';
-            log.warn(`Failed to resolve context asset preview kind for ${sessionId}; using dev-server references`, error);
-        }
-    }
     writeLeasedWorkItemBriefings(sessionId, leasedWorkItemIds) {
         if (leasedWorkItemIds.length === 0)
             return;
@@ -1023,62 +846,6 @@ class AgentVariantsOrchestrator {
             }
         }
     }
-    ensureStaticWorkspaces(sessionId, items) {
-        const resources = this.ensureResources(sessionId);
-        const projectContext = this.store.getProjectContext(sessionId);
-        const provisionStartedAt = Date.now();
-        let assignedCount = 0;
-        for (const item of items) {
-            if (item.kind !== 'static_preview' && item.kind !== 'refine_variant') {
-                continue;
-            }
-            if (resources.workspaceManager.getAssignedWorkspace(item.id))
-                continue;
-            assignedCount += 1;
-            const input = (item.input ?? {});
-            const existingProjectPath = projectContext.kind === 'existing'
-                ? projectContext.projectPath
-                : undefined;
-            const existingParent = existingProjectPath && fs_1.default.existsSync(existingProjectPath)
-                ? path_1.default.join(existingProjectPath, '.rivet', 'variant-work', sessionId)
-                : path_1.default.join(os_1.default.tmpdir(), 'rivet-variant-work', sessionId);
-            const parent = projectContext.kind === 'fresh'
-                ? projectContext.workspacePath
-                : existingParent;
-            fs_1.default.mkdirSync(parent, { recursive: true });
-            const rootPath = projectContext.kind === 'fresh'
-                ? path_1.default.join(parent, `.rivet-preview-${item.id}`)
-                : path_1.default.join(parent, item.id);
-            const sourceVariantId = input.sourceVariantId ?? input.variantId;
-            const sourceDirectory = sourceVariantId
-                ? resources.staticPreviews.get(sourceVariantId)?.assetBase
-                : undefined;
-            resources.workspaceManager.assignArtifactWorkspace({
-                workItemId: item.id,
-                rootPath,
-                allowedRoot: parent,
-                entryPath: 'index.html',
-                sourceDirectory,
-                seedHtml: input.currentHtml,
-            });
-        }
-        if (assignedCount > 0) {
-            this.telemetry.track('agent_variants.provisioning_completed', {
-                source: 'mcp',
-                sessionId,
-                kind: 'artifact_directory',
-                variantCount: assignedCount,
-                durationMs: Date.now() - provisionStartedAt,
-            });
-        }
-    }
-    readAssignedStaticArtifact(sessionId, workItemId) {
-        const workspaceManager = this.resources.get(sessionId)?.workspaceManager;
-        if (!workspaceManager) {
-            throw new errors_1.AgentVariantsError('SESSION_NOT_FOUND', `No live resources for session ${sessionId}`);
-        }
-        return workspaceManager.readArtifact(workItemId);
-    }
     beginStaticPreviewRefinements(args) {
         const seenVariantIds = new Set();
         const droppedRefinements = [];
@@ -1215,8 +982,8 @@ class AgentVariantsOrchestrator {
             requestedCount: 1,
             sourceVariantId: args.source.variantId,
         });
-        const resources = this.ensureResources(args.sessionId);
-        resources.staticPreviews.set(append.workItemId, {
+        this.ensureResources(args.sessionId);
+        this.workspaceInventory.setStaticPreview(args.sessionId, {
             workItemId: append.workItemId,
             briefId: append.briefId,
             entryPath: args.entryPath,
@@ -1263,7 +1030,7 @@ class AgentVariantsOrchestrator {
             };
         }
         const { assetBase, hasAssets } = await this.resolveAdoptedStaticPreviewFiles(args.filesDir, args.entryPath);
-        void this.stopLingeringCommittedDevServers().catch((err) => {
+        void this.previewRuntime.stopLingeringCommitted().catch((err) => {
             log.warn('Stopping lingering committed dev servers failed', err);
         });
         const created = this.store.createSessionFromStaticHistoryVariant({
@@ -1276,8 +1043,8 @@ class AgentVariantsOrchestrator {
             projectContext: args.projectContext,
         });
         this.activeSessionId = created.sessionId;
-        const resources = this.ensureResources(created.sessionId);
-        resources.staticPreviews.set(created.workItemId, {
+        this.ensureResources(created.sessionId);
+        this.workspaceInventory.setStaticPreview(created.sessionId, {
             workItemId: created.workItemId,
             briefId: created.briefId,
             entryPath: args.entryPath,
@@ -1429,12 +1196,11 @@ class AgentVariantsOrchestrator {
         const resources = this.resources.get(sessionId);
         return this.store.getVariants(sessionId).map((variant) => {
             const port = this.getDevServerPort(sessionId, variant.workItemId);
-            const capturedDiff = resources?.worktrees.get(variant.workItemId)?.diff;
+            const capturedDiff = this.workspaceInventory.getWorktree(sessionId, variant.workItemId)?.diff;
             const changedFilesCount = typeof capturedDiff === 'string' && capturedDiff.length > 0
-                ? countDiffFiles(capturedDiff)
+                ? (0, variantWorkspaceFiles_1.countDiffFiles)(capturedDiff)
                 : undefined;
-            const staticPreview = resources?.staticPreviews.get(variant.workItemId) ??
-                this.getStaticPreviewByBriefId(sessionId, variant.briefId);
+            const staticPreview = this.workspaceInventory.getStaticPreview(sessionId, variant.workItemId) ?? this.getStaticPreviewByBriefId(sessionId, variant.briefId);
             let preview;
             if (staticPreview) {
                 preview = {
@@ -1461,7 +1227,7 @@ class AgentVariantsOrchestrator {
             const isSucceeded = variant.status === 'succeeded';
             const qaFailed = qa?.status === 'failed';
             const canView = Boolean(preview) || (isSucceeded && Boolean(port));
-            const previewFailure = resources?.previewFailures.get(variant.workItemId);
+            const previewFailure = this.previewRuntime.getFailure(sessionId, variant.workItemId);
             const previewUnavailable = !canView && isSucceeded && previewFailure
                 ? {
                     reason: previewFailure.reason,
@@ -1474,7 +1240,7 @@ class AgentVariantsOrchestrator {
                 : 'Wait for a successful variant';
             return {
                 ...variant,
-                design: enrichDesignSource(variant.design),
+                design: (0, designContextArtifacts_1.enrichDesignSource)(variant.design),
                 ...(preview ? { preview } : {}),
                 port,
                 ...(changedFilesCount !== undefined ? { changedFilesCount } : {}),
@@ -1508,55 +1274,35 @@ class AgentVariantsOrchestrator {
         return this.store.getProjectContext(sessionId);
     }
     getWorktreePath(sessionId, workItemId) {
-        return this.resources.get(sessionId)?.worktrees.get(workItemId)
+        return this.workspaceInventory.getWorktree(sessionId, workItemId)
             ?.worktreePath;
     }
     getProjectCwdInWorktree(worktreePath) {
         return this.worktrees.getProjectCwdInWorktree(worktreePath);
     }
     getDevServerPort(sessionId, workItemId) {
-        return this.resources.get(sessionId)?.worktrees.get(workItemId)?.port;
+        return this.previewRuntime.getPort(sessionId, workItemId);
     }
     async restoreVariantPreview(sessionId, workItemId, options = {}) {
         const resources = this.resources.get(sessionId);
-        const record = resources?.worktrees.get(workItemId);
-        if (!resources || !record || resources.cleanupStarted)
+        const record = this.workspaceInventory.getWorktree(sessionId, workItemId);
+        if (!resources ||
+            !record ||
+            this.workspaceInventory.isCleanupStarted(sessionId)) {
             return undefined;
-        if (record.previewRestoration)
-            return record.previewRestoration;
-        if (record.port !== undefined && record.devServerProcess) {
-            this.touchSession(sessionId);
-            return record.port;
         }
-        const failure = resources.previewFailures.get(workItemId);
         const isSucceeded = this.store
             .getVariants(sessionId)
             .some((variant) => variant.workItemId === workItemId && variant.status === 'succeeded');
-        const isExplicitRetry = options.retryFailed === true &&
-            failure?.reason !== 'missing_static_entry';
-        if (!failure ||
-            !isSucceeded ||
-            (failure.reason !== 'idle_timeout' && !isExplicitRetry)) {
-            return undefined;
-        }
-        resources.previewFailures.delete(workItemId);
-        record.devServerAutoRestarts = 0;
-        this.emitChange();
         const projectContext = this.store.getProjectContext(sessionId);
-        const restoration = this.startVariantDevServer({
+        return this.previewRuntime.restoreVariant({
             sessionId,
             workItemId,
-            record,
+            worktreePath: record.worktreePath,
             isFresh: projectContext.kind === 'fresh',
+            isSucceeded,
+            retryFailed: options.retryFailed,
         });
-        record.previewRestoration = restoration;
-        try {
-            return await restoration;
-        }
-        finally {
-            if (record.previewRestoration === restoration)
-                record.previewRestoration = undefined;
-        }
     }
     resolveDevServerPortForPreview(sessionId, workItemId) {
         const port = this.getDevServerPort(sessionId, workItemId);
@@ -1574,9 +1320,7 @@ class AgentVariantsOrchestrator {
         }
     }
     getStaticPreviewHtml(sessionId, workItemId) {
-        const preview = this.resources
-            .get(sessionId)
-            ?.staticPreviews.get(workItemId);
+        const preview = this.workspaceInventory.getStaticPreview(sessionId, workItemId);
         if (preview) {
             try {
                 const fromDisk = fs_1.default.readFileSync(path_1.default.join(preview.assetBase, preview.entryPath), 'utf8');
@@ -1588,7 +1332,7 @@ class AgentVariantsOrchestrator {
         try {
             const output = this.store.getWorkItemOutput(sessionId, workItemId);
             return typeof output?.html === 'string' && output.html.length > 0
-                ? buildStaticPreviewDocument({ html: output.html })
+                ? (0, variantWorkspaceFiles_1.buildStaticPreviewDocument)({ html: output.html })
                 : undefined;
         }
         catch {
@@ -1596,37 +1340,34 @@ class AgentVariantsOrchestrator {
         }
     }
     getDesignContextMarkdown(sessionId, artifactId) {
-        const artifact = findDesignContextArtifact(this.store.getProjectContext(sessionId), artifactId);
+        const artifact = (0, designContextArtifacts_1.findDesignContextArtifact)(this.store.getProjectContext(sessionId), artifactId);
         return artifact?.content;
     }
     getDesignContextViewerHtml(sessionId, artifactId) {
-        const artifact = findDesignContextArtifact(this.store.getProjectContext(sessionId), artifactId);
-        return artifact ? buildDesignContextViewerDocument(artifact) : undefined;
+        const artifact = (0, designContextArtifacts_1.findDesignContextArtifact)(this.store.getProjectContext(sessionId), artifactId);
+        return artifact ? (0, designContextArtifacts_1.buildDesignContextViewerDocument)(artifact) : undefined;
     }
     hasStaticPreviewAssets(sessionId, workItemId) {
-        const record = this.resources
-            .get(sessionId)
-            ?.staticPreviews.get(workItemId);
+        const record = this.workspaceInventory.getStaticPreview(sessionId, workItemId);
         return Boolean(record?.hasAssets);
     }
     resolveStaticPreviewAssetPath(sessionId, workItemId, requestedPath) {
-        const record = this.resources
-            .get(sessionId)
-            ?.staticPreviews.get(workItemId);
+        const record = this.workspaceInventory.getStaticPreview(sessionId, workItemId);
         if (!record?.assetBase)
             return undefined;
         if (!requestedPath || requestedPath.length === 0)
             return undefined;
-        return (resolveAssetWithinBase(record.assetBase, requestedPath) ??
+        return ((0, variantWorkspaceFiles_1.resolveAssetWithinBase)(record.assetBase, requestedPath) ??
             (record.assetFallbackBase
-                ? resolveAssetWithinBase(record.assetFallbackBase, requestedPath)
+                ? (0, variantWorkspaceFiles_1.resolveAssetWithinBase)(record.assetFallbackBase, requestedPath)
                 : undefined));
     }
     getStaticPreviewByBriefId(sessionId, briefId) {
-        const resources = this.resources.get(sessionId);
-        if (!resources)
+        if (!this.workspaceInventory.hasSession(sessionId))
             return undefined;
-        return [...resources.staticPreviews.values()].find((preview) => preview.briefId === briefId);
+        return this.workspaceInventory
+            .getStaticPreviews(sessionId)
+            .find((preview) => preview.briefId === briefId);
     }
     buildStaticPreviewUrl(sessionId, workItemId) {
         const safeSessionId = encodeURIComponent(sessionId);
@@ -1655,9 +1396,9 @@ class AgentVariantsOrchestrator {
         this.emitChange();
         try {
             if (projectContext.kind === 'existing') {
-                await this.resolveContextAssetPreviewKind(args.sessionId);
+                await this.workspaceProvisioning.resolveContextAssetPreviewKind(args.sessionId);
             }
-            await this.provisionWorktrees(args.sessionId, result);
+            await this.workspaceProvisioning.provision(args.sessionId, result);
             this.emitChange();
         }
         catch (err) {
@@ -1730,10 +1471,10 @@ class AgentVariantsOrchestrator {
                 workItemIds: createdWorkItemIds,
             });
             if (args.sourceVariantId) {
-                await this.provisionForkedFromVariantWorktrees(sessionId, args.sourceVariantId, createdWorkItemIds);
+                await this.workspaceProvisioning.provisionForked(sessionId, args.sourceVariantId, createdWorkItemIds);
             }
             else {
-                await this.provisionAppendedExistingWorktrees(sessionId, createdWorkItemIds);
+                await this.workspaceProvisioning.provisionAppended(sessionId, createdWorkItemIds);
             }
             this.telemetry.track('agent_variants.variants_appended', {
                 source: 'mcp',
@@ -1870,7 +1611,7 @@ class AgentVariantsOrchestrator {
         return Array.from({ length: args.count }, (_, i) => withUniqueLabel({
             briefId: briefId(i),
             label: args.count > 1 ? `${runLabel} ${i + 1}` : runLabel,
-            body: synthesizeUnifiedBriefBody(args.prompt, i + 1, args.count),
+            body: (0, variantWorkspaceFiles_1.synthesizeUnifiedBriefBody)(args.prompt, i + 1, args.count),
         }, i));
     }
     getAppendableExistingSessionId(projectPath) {
@@ -1887,96 +1628,6 @@ class AgentVariantsOrchestrator {
             return null;
         return sessionId;
     }
-    async registerWorktreeWorkspace(resources, record) {
-        let projectPath = record.worktreePath;
-        try {
-            projectPath = await this.worktrees.getProjectCwdInWorktree(record.worktreePath);
-        }
-        catch (err) {
-            log.warn(`Failed to resolve project path in worktree ${record.worktreePath}; using its root`, err);
-        }
-        resources.worktrees.set(record.workItemId, record);
-        resources.workspaceManager.registerGitWorkspace({
-            workItemId: record.workItemId,
-            rootPath: record.worktreePath,
-            projectPath,
-        });
-    }
-    async withProvisioningTelemetry(args, run) {
-        const startedAt = Date.now();
-        this.telemetry.track('agent_variants.provisioning_started', {
-            source: 'mcp',
-            sessionId: args.sessionId,
-            kind: args.kind,
-            variantCount: args.variantCount,
-        });
-        try {
-            const result = await run();
-            this.telemetry.track('agent_variants.provisioning_completed', {
-                source: 'mcp',
-                sessionId: args.sessionId,
-                kind: args.kind,
-                variantCount: args.variantCount,
-                durationMs: Date.now() - startedAt,
-            });
-            return result;
-        }
-        catch (err) {
-            const timedOut = err instanceof ProvisionTimeoutError;
-            this.telemetry.track('agent_variants.provisioning_failed', {
-                source: 'mcp',
-                sessionId: args.sessionId,
-                kind: args.kind,
-                variantCount: args.variantCount,
-                durationMs: Date.now() - startedAt,
-                timedOut,
-                errorCode: timedOut
-                    ? 'PROVISION_TIMEOUT'
-                    : err instanceof errors_1.AgentVariantsError
-                        ? err.code
-                        : 'PROVISION_FAILED',
-            });
-            throw err;
-        }
-    }
-    async provisionAppendedExistingWorktrees(sessionId, workItemIds) {
-        if (workItemIds.length === 0)
-            return;
-        await this.withProvisioningTelemetry({
-            sessionId,
-            kind: 'appended_existing',
-            variantCount: workItemIds.length,
-        }, async () => {
-            const resources = this.ensureResources(sessionId);
-            const instanceKeyPrefix = `a${(0, crypto_1.randomUUID)().slice(0, 8)}-`;
-            const paths = await withProvisionTimeout(this.worktrees.createWorktrees(sessionId, workItemIds.length, instanceKeyPrefix), this.provisionTimeoutMs);
-            await Promise.all(workItemIds.map((id, index) => this.registerWorktreeWorkspace(resources, {
-                workItemId: id,
-                worktreePath: paths[index],
-            })));
-        });
-    }
-    async provisionForkedFromVariantWorktrees(sessionId, sourceVariantId, workItemIds) {
-        if (workItemIds.length === 0)
-            return;
-        const sourcePath = this.getWorktreePath(sessionId, sourceVariantId);
-        if (!sourcePath) {
-            throw new errors_1.AgentVariantsError('VARIANT_NOT_EDITABLE', `Cannot fork from variant ${sourceVariantId}: no worktree path`);
-        }
-        const forkWorktreesFrom = this.worktrees.forkWorktreesFrom?.bind(this.worktrees);
-        if (!forkWorktreesFrom) {
-            throw new errors_1.AgentVariantsError('RUNTIME_VALIDATION_FAILED', 'worktreeManager does not implement forkWorktreesFrom');
-        }
-        await this.withProvisioningTelemetry({ sessionId, kind: 'forked_variant', variantCount: workItemIds.length }, async () => {
-            const resources = this.ensureResources(sessionId);
-            const instanceKeyPrefix = `f${(0, crypto_1.randomUUID)().slice(0, 8)}-`;
-            const paths = await withProvisionTimeout(forkWorktreesFrom(sourcePath, sessionId, workItemIds.length, instanceKeyPrefix), this.provisionTimeoutMs);
-            await Promise.all(workItemIds.map((id, index) => this.registerWorktreeWorkspace(resources, {
-                workItemId: id,
-                worktreePath: paths[index],
-            })));
-        });
-    }
     async reportComplete(args) {
         const reportReceivedAt = Date.now();
         if (this.store.hasSession(args.sessionId) &&
@@ -1999,14 +1650,14 @@ class AgentVariantsOrchestrator {
             args.output === undefined
             ? {
                 ...args,
-                output: this.readAssignedStaticArtifact(args.sessionId, args.workItemId),
+                output: this.workspaceProvisioning.readArtifact(args.sessionId, args.workItemId),
             }
             : args;
         if (resolvedArgs.status === 'succeeded' &&
             this.store.hasSession(args.sessionId) &&
             (workItemKind === 'static_preview' ||
                 workItemKind === 'refine_variant') &&
-            !parseStaticPreviewOutput(normalizeOutput(resolvedArgs.output))) {
+            !(0, variantWorkspaceFiles_1.parseStaticPreviewOutput)((0, variantWorkspaceFiles_1.normalizeOutput)(resolvedArgs.output))) {
             const telemetry = this.refinementTelemetryForWorkItem({
                 sessionId: args.sessionId,
                 workItemId: args.workItemId,
@@ -2082,7 +1733,7 @@ class AgentVariantsOrchestrator {
             const durationMs = leasedAt !== undefined ? Date.now() - leasedAt : null;
             const approveStartedAt = resources?.approveStartedAt;
             const approveToCompleteMs = approveStartedAt !== undefined ? Date.now() - approveStartedAt : null;
-            const outputBytes = estimateOutputBytes(effectiveArgs.output);
+            const outputBytes = (0, variantWorkspaceFiles_1.estimateOutputBytes)(effectiveArgs.output);
             const projectContextKind = this.store.getProjectContext(args.sessionId).kind;
             const mode = workItemKind !== undefined && isImplementationWorkItemKind(workItemKind)
                 ? this.store.isVaryForkWorkItem(args.sessionId, args.workItemId)
@@ -2106,7 +1757,7 @@ class AgentVariantsOrchestrator {
                 errorCode: effectiveArgs.error?.code ?? null,
                 errorMessage: effectiveArgs.error?.message ?? null,
                 errorApiStatus: effectiveArgs.error?.apiErrorStatus ?? null,
-                isScaffold: resources?.scaffoldBaseWorkItemId === args.workItemId,
+                isScaffold: this.workspaceInventory.isScaffoldBaseWorkItem(args.sessionId, args.workItemId),
                 projectContextKind,
                 tokensIn: args.tokensIn ?? null,
                 tokensOut: args.tokensOut ?? null,
@@ -2383,9 +2034,7 @@ class AgentVariantsOrchestrator {
                     log.warn(`persistVariantHistoryAtCommit (duplicate retry) failed for session ${args.sessionId}`, err);
                 });
             }
-            const lingering = this.lingeringCommittedDevServers.get(args.sessionId);
-            const live = this.resources.get(args.sessionId)?.committedDevServer;
-            const replayPort = lingering?.port ?? live?.port;
+            const replayPort = this.previewRuntime.getCommittedPort(args.sessionId);
             return {
                 enqueued: false,
                 duplicate: true,
@@ -2436,12 +2085,12 @@ class AgentVariantsOrchestrator {
             else {
                 const compareBase = realDestination ?? destinationPath;
                 const anyAssetBaseIsDestination = [
-                    ...resources.staticPreviews.values(),
+                    ...this.workspaceInventory.getStaticPreviews(args.sessionId),
                 ].some((sp) => sp.assetBase === compareBase);
                 if (!anyAssetBaseIsDestination) {
                     const allowed = new Set();
-                    for (const sp of resources.staticPreviews.values()) {
-                        if (sp.assetBase && isStrictlyInside(sp.assetBase, compareBase)) {
+                    for (const sp of this.workspaceInventory.getStaticPreviews(args.sessionId)) {
+                        if (sp.assetBase && (0, variantWorkspaceFiles_1.isStrictlyInside)(sp.assetBase, compareBase)) {
                             allowed.add(path_1.default.basename(sp.assetBase));
                         }
                     }
@@ -2449,16 +2098,16 @@ class AgentVariantsOrchestrator {
                 }
             }
             if (isViteApp) {
-                const record = resources.worktrees.get(args.variantId);
+                const record = this.workspaceInventory.getWorktree(args.sessionId, args.variantId);
                 if (!record) {
                     throw new errors_1.AgentVariantsError('WORK_ITEM_NOT_FOUND', `Unknown variantId ${args.variantId} for session ${args.sessionId}`);
                 }
                 let usedRename = false;
                 let isDependencyInstallRequired = false;
                 try {
-                    if (areSameVolume(record.worktreePath, destinationPath)) {
-                        await this.stopAllDevServersForSession(resources);
-                        isDependencyInstallRequired = await resolveNodeModulesSymlink(record.worktreePath);
+                    if ((0, variantWorkspaceFiles_1.areSameVolume)(record.worktreePath, destinationPath)) {
+                        await this.previewRuntime.stopVariantServers(args.sessionId);
+                        isDependencyInstallRequired = await (0, variantWorkspaceFiles_1.resolveNodeModulesSymlink)(record.worktreePath);
                         await this.renameWorktreeIntoDestination(record.worktreePath, destinationPath);
                         usedRename = true;
                     }
@@ -2470,11 +2119,11 @@ class AgentVariantsOrchestrator {
                     const message = err instanceof Error ? err.message : String(err);
                     throw new errors_1.AgentVariantsError('RUNTIME_VALIDATION_FAILED', `Failed to materialize vite_app variant to ${destinationPath}: ${message}`);
                 }
-                changedFilesCount = countWorktreeFiles(destinationPath);
+                changedFilesCount = (0, variantWorkspaceFiles_1.countWorktreeFiles)(destinationPath);
                 if (!usedRename) {
                     void this.installDependencies(destinationPath)
-                        .then(() => this.startCommittedDevServer({
-                        resources,
+                        .then(() => this.previewRuntime.startCommitted({
+                        sessionId: args.sessionId,
                         destinationPath,
                     }))
                         .catch((err) => {
@@ -2495,8 +2144,8 @@ class AgentVariantsOrchestrator {
                     catch (err) {
                         log.warn(`preserveUnchosenVariants failed for session ${args.sessionId}; continuing without history`, err);
                     }
-                    committedPreviewPort = await this.startCommittedDevServer({
-                        resources,
+                    committedPreviewPort = await this.previewRuntime.startCommitted({
+                        sessionId: args.sessionId,
                         destinationPath,
                         mode: 'vite_app',
                     });
@@ -2512,7 +2161,7 @@ class AgentVariantsOrchestrator {
                 envelopeDestination = destinationPath;
             }
             else {
-                const staticPreview = resources.staticPreviews.get(args.variantId);
+                const staticPreview = this.workspaceInventory.getStaticPreview(args.sessionId, args.variantId);
                 const htmlFromDir = staticPreview
                     ? this.getStaticPreviewHtml(args.sessionId, args.variantId)
                     : undefined;
@@ -2537,7 +2186,7 @@ class AgentVariantsOrchestrator {
                     }
                     const chosenAssetBase = staticPreview?.assetBase;
                     if (chosenAssetBase &&
-                        isStrictlyInside(chosenAssetBase, flattenBase)) {
+                        (0, variantWorkspaceFiles_1.isStrictlyInside)(chosenAssetBase, flattenBase)) {
                         for (const entry of fs_1.default.readdirSync(chosenAssetBase)) {
                             const src = path_1.default.join(chosenAssetBase, entry);
                             const dst = path_1.default.join(flattenBase, entry);
@@ -2560,11 +2209,11 @@ class AgentVariantsOrchestrator {
                         }
                         fs_1.default.rmSync(chosenAssetBase, { recursive: true, force: true });
                     }
-                    for (const other of resources.staticPreviews.values()) {
+                    for (const other of this.workspaceInventory.getStaticPreviews(args.sessionId)) {
                         if (other.workItemId === args.variantId)
                             continue;
                         if (other.assetBase &&
-                            isStrictlyInside(other.assetBase, flattenBase)) {
+                            (0, variantWorkspaceFiles_1.isStrictlyInside)(other.assetBase, flattenBase)) {
                             fs_1.default.rmSync(other.assetBase, { recursive: true, force: true });
                         }
                     }
@@ -2574,9 +2223,9 @@ class AgentVariantsOrchestrator {
                     const message = err instanceof Error ? err.message : String(err);
                     throw new errors_1.AgentVariantsError('RUNTIME_VALIDATION_FAILED', `Failed to write static preview to ${destinationPath}: ${message}`);
                 }
-                changedFilesCount = countWorktreeFiles(destinationPath);
-                committedPreviewPort = await this.startCommittedDevServer({
-                    resources,
+                changedFilesCount = (0, variantWorkspaceFiles_1.countWorktreeFiles)(destinationPath);
+                committedPreviewPort = await this.previewRuntime.startCommitted({
+                    sessionId: args.sessionId,
                     destinationPath,
                     mode: 'static_preview',
                 });
@@ -2591,7 +2240,7 @@ class AgentVariantsOrchestrator {
         }
         else {
             const env = await this.resolveEnv(args.sessionId);
-            const record = resources.worktrees.get(args.variantId);
+            const record = this.workspaceInventory.getWorktree(args.sessionId, args.variantId);
             const saved = record
                 ? null
                 : await this.getSavedVariant({
@@ -2606,7 +2255,7 @@ class AgentVariantsOrchestrator {
             if (diff === undefined) {
                 throw new errors_1.AgentVariantsError('INVALID_STAGE_ACTION', `Variant ${args.variantId} has no captured diff yet — wait for report_variant_complete(succeeded) first`);
             }
-            changedFilesCount = countDiffFiles(diff);
+            changedFilesCount = (0, variantWorkspaceFiles_1.countDiffFiles)(diff);
             if (!this.worktrees.applyDiffToProject) {
                 throw new errors_1.AgentVariantsError('RUNTIME_VALIDATION_FAILED', 'WorktreeManager does not support applying diffs to the project tree');
             }
@@ -2706,212 +2355,7 @@ class AgentVariantsOrchestrator {
         throw new errors_1.AgentVariantsError('DESTINATION_NOT_EMPTY', `Destination ${destinationPath} is not empty (${userVisibleEntries.length} entries) — refuse to materialize.`);
     }
     getVariantDiff(sessionId, variantId) {
-        return this.resources.get(sessionId)?.worktrees.get(variantId)?.diff;
-    }
-    async provisionWorktrees(sessionId, approveResult) {
-        const projectContext = this.store.getProjectContext(sessionId);
-        const variantCount = approveResult.codeGenWorkItemIds.length +
-            (approveResult.scaffoldBaseWorkItemId ? 1 : 0);
-        if ((0, runPlan_1.resolveRunPlanPolicy)(projectContext).provision === 'none') {
-            return;
-        }
-        const startedAt = Date.now();
-        this.telemetry.track('agent_variants.provisioning_started', {
-            source: 'mcp',
-            sessionId,
-            kind: projectContext.kind,
-            variantCount,
-        });
-        const run = async () => {
-            if (projectContext.kind === 'fresh') {
-                await this.provisionFreshWorktrees(sessionId, approveResult, projectContext);
-                return;
-            }
-            await this.provisionExistingWorktrees(sessionId, approveResult);
-        };
-        try {
-            await withProvisionTimeout(run(), this.provisionTimeoutMs);
-            this.telemetry.track('agent_variants.provisioning_completed', {
-                source: 'mcp',
-                sessionId,
-                kind: projectContext.kind,
-                variantCount,
-                durationMs: Date.now() - startedAt,
-            });
-        }
-        catch (err) {
-            const timedOut = err instanceof ProvisionTimeoutError;
-            this.telemetry.track('agent_variants.provisioning_failed', {
-                source: 'mcp',
-                sessionId,
-                kind: projectContext.kind,
-                variantCount,
-                durationMs: Date.now() - startedAt,
-                timedOut,
-                errorCode: timedOut
-                    ? 'PROVISION_TIMEOUT'
-                    : err instanceof errors_1.AgentVariantsError
-                        ? err.code
-                        : 'PROVISION_FAILED',
-            });
-            void this.cancel({ sessionId, reason: 'provisioning_failed' }).catch((teardownErr) => {
-                log.warn(`cleanup after provisioning failure for ${sessionId} failed`, teardownErr);
-            });
-            if (timedOut) {
-                throw new errors_1.AgentVariantsError('RUNTIME_VALIDATION_FAILED', `Provisioning ${variantCount} variant worktree(s) timed out after ` +
-                    `${Math.round(this.provisionTimeoutMs / 1000)}s. This usually means the ` +
-                    `project is very large or slow to clone (e.g. a big monorepo, or a ` +
-                    `React Native tree with native build dirs that aren't git-ignored). ` +
-                    `Try git-ignoring build artifacts, or generate standalone variants ` +
-                    `with start_variants(mode='zero_to_one') instead of cloning this project.`);
-            }
-            throw err;
-        }
-    }
-    async provisionExistingWorktrees(sessionId, approveResult) {
-        const resources = this.ensureResources(sessionId);
-        const totalCount = approveResult.codeGenWorkItemIds.length +
-            (approveResult.scaffoldBaseWorkItemId ? 1 : 0);
-        if (totalCount === 0)
-            return;
-        log.info(`Provisioning ${totalCount} worktree(s) for session ${sessionId}`);
-        const paths = await this.worktrees.createWorktrees(sessionId, totalCount);
-        let cursor = 0;
-        if (approveResult.scaffoldBaseWorkItemId) {
-            resources.scaffoldBaseWorkItemId = approveResult.scaffoldBaseWorkItemId;
-            await this.registerWorktreeWorkspace(resources, {
-                workItemId: approveResult.scaffoldBaseWorkItemId,
-                worktreePath: paths[cursor],
-            });
-            cursor += 1;
-        }
-        for (const id of approveResult.codeGenWorkItemIds) {
-            const p = paths[cursor];
-            cursor += 1;
-            await this.registerWorktreeWorkspace(resources, {
-                workItemId: id,
-                worktreePath: p,
-            });
-        }
-    }
-    async provisionFreshWorktrees(sessionId, approveResult, projectContext) {
-        const resources = this.ensureResources(sessionId);
-        const scaffoldId = approveResult.scaffoldBaseWorkItemId;
-        if (!scaffoldId) {
-            throw new errors_1.AgentVariantsError('INVALID_STAGE_ACTION', `Fresh session ${sessionId} approved without a scaffold_base item`);
-        }
-        const codeGenIds = approveResult.codeGenWorkItemIds;
-        if (codeGenIds.length === 0)
-            return;
-        const designContext = projectContext.designContext
-            ? codeGenIds.map((codeGenId) => {
-                const input = this.store.getWorkItemInput(sessionId, codeGenId);
-                return input.designContextEntry;
-            })
-            : undefined;
-        const createFresh = this.worktrees.createFreshWorktrees;
-        if (!createFresh) {
-            throw new errors_1.AgentVariantsError('RUNTIME_VALIDATION_FAILED', 'worktreeManager does not implement createFreshWorktrees');
-        }
-        const scaffoldStartedAt = Date.now();
-        trackScaffoldStarted(this.telemetry, {
-            sessionId,
-            variantCount: codeGenIds.length,
-            designContext: summarizeDesignContext(designContext),
-        });
-        log.info(`Provisioning ${codeGenIds.length} fresh worktree(s) for session ${sessionId}`);
-        const destinationParent = projectContext.workspaceRoot;
-        const paths = await createFresh.call(this.worktrees, sessionId, codeGenIds.length, viteReactTs_1.VITE_REACT_TS_TEMPLATE, designContext, destinationParent);
-        resources.scaffoldBaseWorkItemId = scaffoldId;
-        resources.freshDestinationParent = destinationParent;
-        await Promise.all(codeGenIds.map((workItemId, index) => this.registerWorktreeWorkspace(resources, {
-            workItemId,
-            worktreePath: paths[index],
-        })));
-        const assetPlan = projectContext.executionPlan?.assetPlan ?? [];
-        if (assetPlan.length > 0) {
-            try {
-                for (const worktreePath of paths) {
-                    for (const entry of assetPlan) {
-                        copyAssetIntoWorktree(worktreePath, entry, projectContext.assetSourceRoot);
-                    }
-                }
-            }
-            catch (err) {
-                const message = err instanceof Error ? err.message : String(err);
-                log.warn(`asset copy failed for session ${sessionId}; marking scaffold_base failed`, err);
-                trackScaffoldFailed(this.telemetry, {
-                    sessionId,
-                    errorCode: 'SCAFFOLD_FAILED',
-                    durationMs: Date.now() - scaffoldStartedAt,
-                });
-                try {
-                    this.store.failInternal({
-                        sessionId,
-                        workItemId: scaffoldId,
-                        error: { code: 'SCAFFOLD_FAILED', message },
-                    });
-                    this.emitChange();
-                }
-                catch (storeErr) {
-                    log.error(`failInternal failed for ${sessionId}/${scaffoldId}`, storeErr);
-                }
-                return;
-            }
-        }
-        void this.runBackgroundInstall(sessionId, scaffoldId, paths, scaffoldStartedAt).catch((err) => {
-            log.error(`runBackgroundInstall failed for session ${sessionId}`, err);
-        });
-    }
-    async runBackgroundInstall(sessionId, scaffoldWorkItemId, worktreePaths, scaffoldStartedAt) {
-        const installStartedAt = Date.now();
-        try {
-            await Promise.all(worktreePaths.map((worktreePath) => this.installDependencies(worktreePath, {
-                workspaceRoot: worktreePath,
-                signal: this.resources.get(sessionId)?.dependencyAbortController.signal,
-            })));
-        }
-        catch (err) {
-            const resources = this.resources.get(sessionId);
-            if (!resources || resources.cleanupStarted)
-                return;
-            const message = err instanceof Error ? err.message : String(err);
-            log.warn(`npm install failed for session ${sessionId}; marking scaffold_base failed`, err);
-            trackScaffoldFailed(this.telemetry, {
-                sessionId,
-                errorCode: 'SCAFFOLD_FAILED',
-                durationMs: Date.now() - scaffoldStartedAt,
-            });
-            try {
-                this.store.failInternal({
-                    sessionId,
-                    workItemId: scaffoldWorkItemId,
-                    error: { code: 'SCAFFOLD_FAILED', message },
-                });
-                this.emitChange();
-            }
-            catch (storeErr) {
-                log.error(`failInternal failed for ${sessionId}/${scaffoldWorkItemId}`, storeErr);
-            }
-            return;
-        }
-        try {
-            this.store.completeInternal({
-                sessionId,
-                workItemId: scaffoldWorkItemId,
-                output: { worktreePaths },
-            });
-            this.emitChange();
-        }
-        catch (err) {
-            log.warn(`completeInternal failed for ${sessionId}/${scaffoldWorkItemId}`, err);
-        }
-        trackScaffoldCompleted(this.telemetry, {
-            sessionId,
-            durationMs: Date.now() - scaffoldStartedAt,
-            installDurationMs: Date.now() - installStartedAt,
-            variantCount: worktreePaths.length,
-        });
+        return this.workspaceInventory.getWorktree(sessionId, variantId)?.diff;
     }
     async evaluateQaForReport(args) {
         if (args.status !== 'succeeded')
@@ -2929,7 +2373,7 @@ class AgentVariantsOrchestrator {
         let baseQa = null;
         const checkedSource = undefined;
         if (kind === 'static_preview') {
-            const parsed = parseStaticPreviewOutput(normalizeOutput(args.output));
+            const parsed = (0, variantWorkspaceFiles_1.parseStaticPreviewOutput)((0, variantWorkspaceFiles_1.normalizeOutput)(args.output));
             if (!parsed)
                 return null;
             baseQa = await this.runPreviewQaSafely(args, parsed.html);
@@ -2966,8 +2410,7 @@ class AgentVariantsOrchestrator {
         if (!isDesignCreationCodeGenInput(input, this.store.getPrompt(args.sessionId))) {
             return null;
         }
-        const resources = this.resources.get(args.sessionId);
-        const record = resources?.worktrees.get(args.workItemId);
+        const record = this.workspaceInventory.getWorktree(args.sessionId, args.workItemId);
         if (!record) {
             const qa = buildDiffCaptureFailureQa('diff:worktree-record-missing', 'The succeeded report could not be checked because its worktree record is missing.');
             this.memoizeQa(args.sessionId, args.workItemId, qa);
@@ -3086,248 +2529,31 @@ class AgentVariantsOrchestrator {
         resources.repairCompletionResults.set(repairCompletionKey(args), completionResult);
         return completionResult;
     }
-    async startVariantDevServer(args) {
-        if (args.record.port !== undefined && args.record.devServerProcess) {
-            return args.record.port;
-        }
-        if (!args.autoRestartTimer && args.record.pendingAutoRestart) {
-            clearTimeout(args.record.pendingAutoRestart);
-            args.record.pendingAutoRestart = undefined;
-        }
-        const canContinueStart = () => {
-            const resources = this.resources.get(args.sessionId);
-            const isAutoRestartCancelled = args.autoRestartTimer !== undefined &&
-                args.record.pendingAutoRestart !== args.autoRestartTimer;
-            return Boolean(resources && !resources.cleanupStarted && !isAutoRestartCancelled);
-        };
-        const previewStartedAt = Date.now();
-        const projectContextKind = args.isFresh ? 'fresh' : 'existing';
-        trackPreviewStarted(this.telemetry, {
-            sessionId: args.sessionId,
-            variantId: args.workItemId,
-            projectContextKind,
-            previewKind: 'dev_server',
-        });
-        const startPort = await this.resolveDevServerStartPort(args.sessionId, args.isFresh);
-        let scanFrom = startPort;
-        const maxAttempts = DEV_SERVER_START_MAX_ATTEMPTS;
-        let installRetried = false;
-        let lastDev;
-        for (let attempt = 1; attempt <= maxAttempts; attempt++) {
-            if (!canContinueStart())
-                return undefined;
-            let port;
-            try {
-                port = await this.worktrees.findFreePortFrom(scanFrom);
-                const dev = await this.resolveDevServer(args.sessionId, args.record.worktreePath, port, args.isFresh);
-                lastDev = dev;
-                if (!canContinueStart())
-                    return undefined;
-                const proc = await this.worktrees.startDevServer(dev.cwd, port, dev.cmd, dev.args, dev.env);
-                if (!canContinueStart()) {
-                    log.info(`Variant ${args.workItemId} dev server booted after preview cleanup; stopping it`);
-                    void this.worktrees.stopDevServer(proc).catch(() => undefined);
-                    return undefined;
-                }
-                if (args.autoRestartTimer) {
-                    args.record.pendingAutoRestart = undefined;
-                }
-                args.record.port = port;
-                args.record.devServerProcess = proc;
-                args.record.devCommand = dev;
-                proc.once('exit', (code, signal) => {
-                    if (args.record.devServerProcess !== proc)
-                        return;
-                    args.record.port = undefined;
-                    args.record.devServerProcess = undefined;
-                    const resources = this.resources.get(args.sessionId);
-                    const restartsUsed = args.record.devServerAutoRestarts ?? 0;
-                    const canRestart = restartsUsed < DEV_SERVER_MAX_AUTO_RESTARTS &&
-                        resources !== undefined &&
-                        !resources.cleanupStarted;
-                    log.warn(`Variant ${args.workItemId} dev server exited unexpectedly (code=${code ?? 'null'}, signal=${signal ?? 'null'}); ` +
-                        (canRestart
-                            ? `auto-restarting (${restartsUsed + 1}/${DEV_SERVER_MAX_AUTO_RESTARTS})`
-                            : 'preview disabled'));
-                    if (canRestart) {
-                        args.record.devServerAutoRestarts = restartsUsed + 1;
-                        this.emitChange();
-                        const timer = setTimeout(() => {
-                            const current = this.resources.get(args.sessionId);
-                            if (!current ||
-                                current.cleanupStarted ||
-                                args.record.pendingAutoRestart !== timer) {
-                                return;
-                            }
-                            this.startVariantDevServer({
-                                ...args,
-                                autoRestartTimer: timer,
-                            })
-                                .catch((err) => log.warn(`Auto-restart of variant ${args.workItemId} dev server failed`, err))
-                                .finally(() => {
-                                if (args.record.pendingAutoRestart === timer) {
-                                    args.record.pendingAutoRestart = undefined;
-                                }
-                            });
-                        }, this.devServerRestartDelayMs);
-                        args.record.pendingAutoRestart = timer;
-                        timer.unref?.();
-                        return;
-                    }
-                    resources?.previewFailures.set(args.workItemId, {
-                        reason: 'exited',
-                        portInUse: false,
-                    });
-                    this.emitChange();
-                });
-                this.resources
-                    .get(args.sessionId)
-                    ?.previewFailures.delete(args.workItemId);
-                this.emitChange();
-                trackFreshDevServerStarted(this.telemetry, {
-                    sessionId: args.sessionId,
-                    variantId: args.workItemId,
-                    port,
-                });
-                trackPreviewReady(this.telemetry, {
-                    sessionId: args.sessionId,
-                    variantId: args.workItemId,
-                    projectContextKind,
-                    previewKind: 'dev_server',
-                    hasPort: true,
-                    port,
-                    durationMs: Date.now() - previewStartedAt,
-                });
-                log.info(`Variant ${args.workItemId} dev server up on port ${port} (worktree ${args.record.worktreePath}; cmd: ${dev.cmd} ${dev.args.join(' ')})`);
-                this.touchSession(args.sessionId);
-                return port;
-            }
-            catch (err) {
-                if (!canContinueStart())
-                    return undefined;
-                const devErr = (0, devServerError_1.isDevServerStartError)(err) ? err : undefined;
-                const portInUse = devErr?.portInUse ?? false;
-                const reason = devErr?.reason ?? 'unknown';
-                const missingDepsOutput = (0, devServerError_1.isMissingDependencyOutput)(devErr?.detail ?? '');
-                const missingDeps = missingDepsOutput &&
-                    reason === 'exited' &&
-                    !installRetried &&
-                    lastDev !== undefined &&
-                    canInstallWithoutTouchingHost(lastDev.cwd);
-                const willRetry = attempt < maxAttempts &&
-                    (portInUse || missingDeps || (reason === 'exited' && attempt === 1));
-                scanFrom = (port ?? scanFrom) + 1;
-                log.warn(`Failed to start dev server for variant ${args.workItemId} on port ${port ?? 'unallocated'} ` +
-                    `(attempt ${attempt}/${maxAttempts}, reason=${reason}, portInUse=${portInUse}, missingDeps=${missingDeps})` +
-                    (willRetry
-                        ? missingDeps
-                            ? '; installing dependencies and retrying'
-                            : '; retrying on a fresh port'
-                        : '; live preview disabled for this variant'), err);
-                if (willRetry) {
-                    if (missingDeps && lastDev) {
-                        installRetried = true;
-                        try {
-                            await this.installDependencies(lastDev.cwd, {
-                                workspaceRoot: args.record.worktreePath,
-                                force: true,
-                                signal: this.resources.get(args.sessionId)
-                                    ?.dependencyAbortController.signal,
-                            });
-                        }
-                        catch (installErr) {
-                            log.warn(`Dependency preparation failed for variant ${args.workItemId}`, installErr);
-                            this.resources
-                                .get(args.sessionId)
-                                ?.previewFailures.set(args.workItemId, {
-                                reason: 'dependency_install_failed',
-                                portInUse: false,
-                            });
-                            trackPreviewFailed(this.telemetry, {
-                                sessionId: args.sessionId,
-                                variantId: args.workItemId,
-                                projectContextKind,
-                                previewKind: 'dev_server',
-                                errorCode: 'DEPENDENCY_INSTALL_FAILED',
-                                reason: 'dependency_install_failed',
-                                portInUse: false,
-                                durationMs: Date.now() - previewStartedAt,
-                            });
-                            this.emitChange();
-                            return undefined;
-                        }
-                    }
-                    continue;
-                }
-                this.resources
-                    .get(args.sessionId)
-                    ?.previewFailures.set(args.workItemId, {
-                    reason,
-                    portInUse,
-                });
-                let errorCode = 'DEV_SERVER_START_FAILED';
-                if (reason === 'dependency_install_failed')
-                    errorCode = 'DEPENDENCY_INSTALL_FAILED';
-                if (reason === 'missing_dev_script')
-                    errorCode = 'DEV_SCRIPT_MISSING';
-                trackFreshDevServerFailed(this.telemetry, {
-                    sessionId: args.sessionId,
-                    variantId: args.workItemId,
-                    errorCode,
-                    reason,
-                    portInUse,
-                    exitCode: devErr?.exitCode,
-                    signal: devErr?.signal,
-                    missingDeps: missingDepsOutput,
-                });
-                trackPreviewFailed(this.telemetry, {
-                    sessionId: args.sessionId,
-                    variantId: args.workItemId,
-                    projectContextKind,
-                    previewKind: 'dev_server',
-                    errorCode,
-                    reason,
-                    portInUse,
-                    durationMs: Date.now() - previewStartedAt,
-                    exitCode: devErr?.exitCode,
-                    signal: devErr?.signal,
-                    missingDeps: missingDepsOutput,
-                });
-                this.emitChange();
-                return undefined;
-            }
-            finally {
-                if (port !== undefined)
-                    this.worktrees.releasePort?.(port);
-            }
-        }
-        return undefined;
-    }
     async handleSucceededReport(args) {
         const { sessionId, workItemId } = args;
         const resources = this.resources.get(sessionId);
-        const record = resources?.worktrees.get(workItemId);
+        const record = this.workspaceInventory.getWorktree(sessionId, workItemId);
         if (resources && !record) {
-            const staticPreview = parseStaticPreviewOutput(normalizeOutput(args.output));
+            const staticPreview = (0, variantWorkspaceFiles_1.parseStaticPreviewOutput)((0, variantWorkspaceFiles_1.normalizeOutput)(args.output));
             if (staticPreview) {
                 const input = this.store.getWorkItemInput(sessionId, workItemId);
                 if (input.briefId) {
                     const projectContext = this.store.getProjectContext(sessionId);
                     const previewStartedAt = Date.now();
-                    trackPreviewStarted(this.telemetry, {
+                    (0, variantsTelemetry_1.trackPreviewStarted)(this.telemetry, {
                         sessionId,
                         variantId: workItemId,
                         projectContextKind: projectContext.kind,
                         previewKind: 'static_artifact',
                     });
-                    const resolvedAssetBase = resolveStaticPreviewAssetBase({
+                    const resolvedAssetBase = (0, variantWorkspaceFiles_1.resolveStaticPreviewAssetBase)({
                         assetBase: staticPreview.assetBase,
                         projectContext,
                     });
                     const workspacePath = projectContext.kind === 'fresh'
                         ? projectContext.workspacePath
                         : undefined;
-                    const assignedWorkspace = resources.workspaceManager.getAssignedWorkspace(workItemId);
+                    const assignedWorkspace = this.workspaceInventory.getAssignedWorkspace(sessionId, workItemId);
                     const assignedArtifactBase = assignedWorkspace?.kind === 'artifact_directory'
                         ? assignedWorkspace.rootPath
                         : undefined;
@@ -3338,7 +2564,7 @@ class AgentVariantsOrchestrator {
                             : undefined);
                     if (!dir) {
                         log.warn(`static preview for ${workItemId} has no workspace dir; skipping`);
-                        trackPreviewFailed(this.telemetry, {
+                        (0, variantsTelemetry_1.trackPreviewFailed)(this.telemetry, {
                             sessionId,
                             variantId: workItemId,
                             projectContextKind: projectContext.kind,
@@ -3367,10 +2593,10 @@ class AgentVariantsOrchestrator {
                         assetBase: dir,
                         hasAssets: Boolean(resolvedAssetBase || assignedArtifactBase),
                     };
-                    resources.staticPreviews.set(workItemId, record);
+                    this.workspaceInventory.setStaticPreview(sessionId, record);
                     if (assignedWorkspace?.kind === 'artifact_directory' &&
                         assignedWorkspace.rootPath !== record.assetBase) {
-                        resources.workspaceManager.removeArtifactWorkspace(workItemId);
+                        this.workspaceInventory.removeArtifactWorkspace(sessionId, workItemId);
                     }
                     this.trackHistoryPersist(this.persistCompletedArtifactVariant({
                         sessionId,
@@ -3379,12 +2605,12 @@ class AgentVariantsOrchestrator {
                         log.warn(`persistCompletedArtifactVariant failed for ${sessionId}/${workItemId}`, err);
                     }));
                     const leasedAt = resources.leasedAt.get(workItemId);
-                    trackStaticPreviewCompleted(this.telemetry, {
+                    (0, variantsTelemetry_1.trackStaticPreviewCompleted)(this.telemetry, {
                         sessionId,
                         variantId: workItemId,
                         durationMs: leasedAt !== undefined ? Date.now() - leasedAt : null,
                     });
-                    trackPreviewReady(this.telemetry, {
+                    (0, variantsTelemetry_1.trackPreviewReady)(this.telemetry, {
                         sessionId,
                         variantId: workItemId,
                         projectContextKind: projectContext.kind,
@@ -3401,7 +2627,7 @@ class AgentVariantsOrchestrator {
             log.warn(`No worktree record for ${sessionId}/${workItemId}; skipping diff capture`);
             return;
         }
-        if (resources.scaffoldBaseWorkItemId === workItemId) {
+        if (this.workspaceInventory.isScaffoldBaseWorkItem(sessionId, workItemId)) {
             log.info(`scaffold_base ${workItemId} succeeded; awaiting dependent code-gen`);
             return;
         }
@@ -3410,7 +2636,7 @@ class AgentVariantsOrchestrator {
         try {
             record.diff =
                 record.diff ?? (await this.worktrees.getDiff(record.worktreePath));
-            log.info(`Variant ${workItemId} diff captured (${countDiffFiles(record.diff)} files)`);
+            log.info(`Variant ${workItemId} diff captured (${(0, variantWorkspaceFiles_1.countDiffFiles)(record.diff)} files)`);
             this.emitChange();
         }
         catch (err) {
@@ -3440,10 +2666,10 @@ class AgentVariantsOrchestrator {
                 return;
             }
         }
-        await this.startVariantDevServer({
+        await this.previewRuntime.startVariant({
             sessionId,
             workItemId,
-            record,
+            worktreePath: record.worktreePath,
             isFresh,
         });
     }
@@ -3456,7 +2682,7 @@ class AgentVariantsOrchestrator {
         if (!input.variantId) {
             throw new errors_1.AgentVariantsError('MISSING_REQUIRED_INPUT', 'refine_variant work item is missing variantId');
         }
-        const parsed = parseStaticPreviewOutput(normalizeOutput(args.output));
+        const parsed = (0, variantWorkspaceFiles_1.parseStaticPreviewOutput)((0, variantWorkspaceFiles_1.normalizeOutput)(args.output));
         if (!parsed) {
             throw new errors_1.AgentVariantsError('SCHEMA_VALIDATION_FAILED', 'refine_variant report_variant_complete requires output.html');
         }
@@ -3464,12 +2690,12 @@ class AgentVariantsOrchestrator {
         if (!targetInput.briefId) {
             throw new errors_1.AgentVariantsError('VARIANT_NOT_EDITABLE', 'Target static_preview variant is missing briefId');
         }
-        const resolvedAssetBase = resolveStaticPreviewAssetBase({
+        const resolvedAssetBase = (0, variantWorkspaceFiles_1.resolveStaticPreviewAssetBase)({
             assetBase: parsed.assetBase,
             projectContext: this.store.getProjectContext(args.sessionId),
         });
-        const previousRecord = resources.staticPreviews.get(input.variantId);
-        const refinementWorkspace = resources.workspaceManager.getAssignedWorkspace(args.workItemId);
+        const previousRecord = this.workspaceInventory.getStaticPreview(args.sessionId, input.variantId);
+        const refinementWorkspace = this.workspaceInventory.getAssignedWorkspace(args.sessionId, args.workItemId);
         const assignedArtifactBase = refinementWorkspace?.kind === 'artifact_directory'
             ? refinementWorkspace.rootPath
             : undefined;
@@ -3488,7 +2714,7 @@ class AgentVariantsOrchestrator {
             ...(dir ? { assetBase: dir } : {}),
         });
         if (dir) {
-            resources.staticPreviews.set(input.variantId, {
+            this.workspaceInventory.setStaticPreview(args.sessionId, {
                 workItemId: input.variantId,
                 briefId: targetInput.briefId,
                 entryPath: 'index.html',
@@ -3500,7 +2726,8 @@ class AgentVariantsOrchestrator {
         }
         if (refinementWorkspace?.kind === 'artifact_directory' &&
             dir === refinementWorkspace.rootPath) {
-            resources.workspaceManager.promoteArtifactWorkspace({
+            this.workspaceInventory.promoteArtifactWorkspace({
+                sessionId: args.sessionId,
                 sourceWorkItemId: args.workItemId,
                 targetWorkItemId: input.variantId,
             });
@@ -3575,9 +2802,7 @@ class AgentVariantsOrchestrator {
                         !saved.diff?.trim() &&
                         !saved.files?.length))
                     return false;
-                const resources = this.resources.get(sessionId);
-                const preview = resources?.staticPreviews.get(variant.workItemId) ??
-                    this.getStaticPreviewByBriefId(sessionId, variant.briefId);
+                const preview = this.workspaceInventory.getStaticPreview(sessionId, variant.workItemId) ?? this.getStaticPreviewByBriefId(sessionId, variant.briefId);
                 if (preview) {
                     const currentHtml = await fs_1.default.promises.readFile(path_1.default.join(preview.assetBase, preview.entryPath), 'utf8');
                     const savedHtml = await this.variantHistory.readStaticPreview({
@@ -3588,7 +2813,7 @@ class AgentVariantsOrchestrator {
                     if (currentHtml !== savedHtml)
                         return false;
                 }
-                const diff = resources?.worktrees.get(variant.workItemId)?.diff;
+                const diff = this.workspaceInventory.getWorktree(sessionId, variant.workItemId)?.diff;
                 if (diff && saved.diff !== diff)
                     return false;
             }
@@ -3607,9 +2832,7 @@ class AgentVariantsOrchestrator {
             log.warn(`persistCompletedExistingVariant: resolveEnv failed for ${args.sessionId}`, err);
             return;
         }
-        const record = this.resources
-            .get(args.sessionId)
-            ?.worktrees.get(args.workItemId);
+        const record = this.workspaceInventory.getWorktree(args.sessionId, args.workItemId);
         let sourceDir;
         const staticEntryPath = env.framework === 'static' ? env.entryPath : undefined;
         if (env.framework === 'static' && record) {
@@ -3630,23 +2853,24 @@ class AgentVariantsOrchestrator {
         catch (err) {
             log.warn(`persistCompletedExistingVariant: git root resolution failed for ${args.sessionId}`, err);
         }
+        const runningPreview = this.previewRuntime.getRunningVariant(args.sessionId, args.workItemId);
         let serve;
         if (sourceDir && record && staticEntryPath) {
             const entryPath = path_1.default.relative(record.worktreePath, path_1.default.join(sourceDir, staticEntryPath));
             serve = { kind: 'static', entryPath };
         }
-        else if (record?.devCommand && record.port !== undefined) {
+        else if (record && runningPreview) {
             serve = {
                 kind: 'dev-server',
-                recipe: buildServeRecipeFromResolved(record.worktreePath, record.devCommand, record.port),
+                recipe: (0, variantWorkspaceFiles_1.buildServeRecipeFromResolved)(record.worktreePath, runningPreview.command, runningPreview.port),
             };
         }
         else if (record) {
             try {
-                const dev = await this.resolveDevServerCommand(args.sessionId, record.worktreePath, RECIPE_PORT_SENTINEL, false);
+                const dev = await this.previewRuntime.resolveCommand(args.sessionId, record.worktreePath, RECIPE_PORT_SENTINEL, false);
                 serve = {
                     kind: 'dev-server',
-                    recipe: buildServeRecipeFromResolved(record.worktreePath, dev, RECIPE_PORT_SENTINEL),
+                    recipe: (0, variantWorkspaceFiles_1.buildServeRecipeFromResolved)(record.worktreePath, dev, RECIPE_PORT_SENTINEL),
                 };
             }
             catch (err) {
@@ -3674,7 +2898,7 @@ class AgentVariantsOrchestrator {
             preview: sourceDir && staticEntryPath
                 ? { kind: 'static', entryPath: staticEntryPath }
                 : { kind: 'none', reason: 'diff_only' },
-            changedFilesCount: countDiffFiles(args.diff),
+            changedFilesCount: (0, variantWorkspaceFiles_1.countDiffFiles)(args.diff),
             projectKind: 'existing',
             snapshotDir,
             baseDir,
@@ -3699,7 +2923,7 @@ class AgentVariantsOrchestrator {
         if (env.framework !== 'static')
             return 'not_static';
         const previewStartedAt = Date.now();
-        trackPreviewStarted(this.telemetry, {
+        (0, variantsTelemetry_1.trackPreviewStarted)(this.telemetry, {
             sessionId,
             variantId: workItemId,
             projectContextKind: 'existing',
@@ -3725,7 +2949,7 @@ class AgentVariantsOrchestrator {
         }
         catch (err) {
             log.warn(`registerExistingStaticPreview: no entry HTML at ${entryFile} for ${sessionId}/${workItemId}; preview unavailable`, err);
-            trackPreviewFailed(this.telemetry, {
+            (0, variantsTelemetry_1.trackPreviewFailed)(this.telemetry, {
                 sessionId,
                 variantId: workItemId,
                 projectContextKind: 'existing',
@@ -3734,7 +2958,7 @@ class AgentVariantsOrchestrator {
                 reason: 'missing_static_entry',
                 durationMs: Date.now() - previewStartedAt,
             });
-            resources.previewFailures.set(workItemId, {
+            this.previewRuntime.setFailure(sessionId, workItemId, {
                 reason: 'missing_static_entry',
                 portInUse: false,
             });
@@ -3754,7 +2978,7 @@ class AgentVariantsOrchestrator {
                 assetFallbackBase = hostRealRoot;
         }
         catch { }
-        resources.staticPreviews.set(workItemId, {
+        this.workspaceInventory.setStaticPreview(sessionId, {
             workItemId,
             briefId: input.briefId,
             entryPath: env.entryPath,
@@ -3762,9 +2986,9 @@ class AgentVariantsOrchestrator {
             hasAssets: true,
             ...(assetFallbackBase ? { assetFallbackBase } : {}),
         });
-        resources.previewFailures.delete(workItemId);
+        this.previewRuntime.clearFailure(sessionId, workItemId);
         log.info(`Variant ${workItemId} served as a static preview (existing/static, no dev server; root ${projectCwd})`);
-        trackPreviewReady(this.telemetry, {
+        (0, variantsTelemetry_1.trackPreviewReady)(this.telemetry, {
             sessionId,
             variantId: workItemId,
             projectContextKind: 'existing',
@@ -3787,7 +3011,7 @@ class AgentVariantsOrchestrator {
         const env = await this.resolveEnv(args.sessionId);
         const entryPath = env.framework === 'static' ? env.entryPath : 'index.html';
         const entryFile = path_1.default.resolve(args.sourceDir, entryPath);
-        if (!isStrictlyInside(entryFile, args.sourceDir)) {
+        if (!(0, variantWorkspaceFiles_1.isStrictlyInside)(entryFile, args.sourceDir)) {
             throw new errors_1.AgentVariantsError('RUNTIME_VALIDATION_FAILED', 'Artifact entry must be inside its project directory.');
         }
         const isEntryMapped = entryFile !== path_1.default.join(args.sourceDir, 'index.html');
@@ -3835,10 +3059,9 @@ class AgentVariantsOrchestrator {
             : [historyProjectPath];
         const input = this.store.getWorkItemInput(args.sessionId, args.workItemId);
         const sessionPrompt = this.store.getPrompt(args.sessionId);
-        const designArtifact = resolveDesignArtifact(input.designContextEntry);
-        const resources = this.resources.get(args.sessionId);
-        const worktreeRecord = resources?.worktrees.get(args.workItemId);
-        const staticPreview = resources?.staticPreviews.get(args.workItemId);
+        const designArtifact = (0, designContextArtifacts_1.resolveDesignArtifact)(input.designContextEntry);
+        const worktreeRecord = this.workspaceInventory.getWorktree(args.sessionId, args.workItemId);
+        const staticPreview = this.workspaceInventory.getStaticPreview(args.sessionId, args.workItemId);
         let sourceDir = null;
         let tmpStagingDir = null;
         if (worktreeRecord && fs_1.default.existsSync(worktreeRecord.worktreePath)) {
@@ -3846,7 +3069,7 @@ class AgentVariantsOrchestrator {
         }
         else if (staticPreview) {
             tmpStagingDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), `rivet-variant-${args.workItemId}-`));
-            copyStaticPreviewDirectory(staticPreview.assetBase, tmpStagingDir);
+            (0, variantWorkspaceFiles_1.copyStaticPreviewDirectory)(staticPreview.assetBase, tmpStagingDir);
             let stagedHtml = '';
             try {
                 stagedHtml = fs_1.default.readFileSync(path_1.default.join(staticPreview.assetBase, 'index.html'), 'utf8');
@@ -3864,7 +3087,8 @@ class AgentVariantsOrchestrator {
             log.warn(`persistCompletedArtifactVariant: no source for ${args.workItemId} (session ${args.sessionId}); skipping`);
             return;
         }
-        const changedFilesCount = staticPreview ? 1 : countWorktreeFiles(sourceDir);
+        const changedFilesCount = staticPreview ? 1 : (0, variantWorkspaceFiles_1.countWorktreeFiles)(sourceDir);
+        const runningPreview = this.previewRuntime.getRunningVariant(args.sessionId, args.workItemId);
         const preview = staticPreview
             ? { kind: 'static', entryPath: 'index.html' }
             : {
@@ -3877,10 +3101,10 @@ class AgentVariantsOrchestrator {
             };
         const serve = staticPreview
             ? { kind: 'static', entryPath: 'index.html' }
-            : worktreeRecord?.devCommand && worktreeRecord.port !== undefined
+            : worktreeRecord && runningPreview
                 ? {
                     kind: 'dev-server',
-                    recipe: buildServeRecipeFromResolved(worktreeRecord.worktreePath, worktreeRecord.devCommand, worktreeRecord.port),
+                    recipe: (0, variantWorkspaceFiles_1.buildServeRecipeFromResolved)(worktreeRecord.worktreePath, runningPreview.command, runningPreview.port),
                 }
                 : {
                     kind: 'dev-server',
@@ -3927,7 +3151,7 @@ class AgentVariantsOrchestrator {
                 ...(diff !== undefined ? { diff } : {}),
                 sourceDir,
                 preview,
-                changedFilesCount: diff === undefined ? changedFilesCount : countDiffFiles(diff),
+                changedFilesCount: diff === undefined ? changedFilesCount : (0, variantWorkspaceFiles_1.countDiffFiles)(diff),
                 projectKind: projectContext.kind,
                 designMarkdown: designArtifact?.markdown,
                 designSource: designArtifact?.source,
@@ -4080,109 +3304,6 @@ class AgentVariantsOrchestrator {
             return undefined;
         }
     }
-    async resolveDevServerStartPort(sessionId, isFresh) {
-        if (isFresh)
-            return FRESH_DEV_SERVER_DEFAULT_PORT;
-        try {
-            const env = await this.resolveEnv(sessionId);
-            return env.framework === 'static' ? 3000 : (env.defaultPort ?? 3000);
-        }
-        catch {
-            return 3000;
-        }
-    }
-    async resolveDevServer(sessionId, worktreePath, port, isFresh) {
-        const resolved = await this.resolveDevServerCommand(sessionId, worktreePath, port, isFresh);
-        await this.ensureProjectDependencies({
-            signal: this.resources.get(sessionId)?.dependencyAbortController.signal,
-            cwd: resolved.cwd,
-            workspaceRoot: worktreePath,
-        });
-        return resolved;
-    }
-    async resolveDevServerCommand(sessionId, worktreePath, port, isFresh) {
-        if (isFresh) {
-            return {
-                cwd: worktreePath,
-                cmd: 'npm',
-                args: [
-                    'run',
-                    'dev',
-                    '--',
-                    '--port',
-                    String(port),
-                    '--host',
-                    FRESH_DEV_SERVER_HOST,
-                ],
-                env: { PORT: String(port) },
-                packageManager: 'npm',
-            };
-        }
-        const env = await this.resolveEnv(sessionId);
-        if (env.framework === 'static') {
-            throw new Error('Static projects do not have a dev server command');
-        }
-        const cwd = await this.resolveExistingProjectCwd(sessionId, worktreePath, env);
-        if (env.devCommand) {
-            assertDevScriptExists(cwd, env.devCommand);
-        }
-        const detected = fs_1.default.existsSync(path_1.default.join(cwd, 'package.json'))
-            ? await (0, ProjectPackageManager_1.resolveProjectPackageManager)({
-                cwd,
-                workspaceRoot: worktreePath,
-            }).catch((error) => {
-                throw new devServerError_1.DevServerStartError({
-                    message: error instanceof Error ? error.message : String(error),
-                    detail: '',
-                    reason: 'dependency_install_failed',
-                    portInUse: false,
-                });
-            })
-            : null;
-        const packageManager = detected?.name ?? env.packageManager;
-        if (packageManager !== env.packageManager) {
-            return {
-                cwd,
-                packageManager,
-                ...(0, devServerCommand_1.buildDevServerCommand)(env.framework, packageManager, env.devCommand, port),
-            };
-        }
-        if (env.buildDevCommand) {
-            return { cwd, packageManager, ...env.buildDevCommand(port) };
-        }
-        return {
-            cwd,
-            cmd: env.packageManager,
-            args: [env.devCommand, '--port', String(port)],
-            env: { PORT: String(port) },
-            packageManager,
-        };
-    }
-    async ensureProjectDependencies(args) {
-        if (!fs_1.default.existsSync(path_1.default.join(args.cwd, 'package.json')))
-            return;
-        await this.installDependencies(args.cwd, {
-            workspaceRoot: args.workspaceRoot,
-            signal: args.signal,
-        });
-    }
-    async resolveExistingProjectCwd(sessionId, worktreePath, env) {
-        const fallback = await this.worktrees.getProjectCwdInWorktree(worktreePath);
-        try {
-            const projectContext = this.store.getProjectContext(sessionId);
-            if (projectContext.kind !== 'existing' || !projectContext.projectPath) {
-                return fallback;
-            }
-            const rel = path_1.default.relative(path_1.default.resolve(env.projectPath), path_1.default.resolve(projectContext.projectPath));
-            if (!rel || rel.startsWith('..') || path_1.default.isAbsolute(rel)) {
-                return fallback;
-            }
-            return path_1.default.join(worktreePath, rel);
-        }
-        catch {
-            return fallback;
-        }
-    }
     preserveUnchosenVariants(args) {
         const resources = this.resources.get(args.sessionId);
         const runnablePaths = new Map();
@@ -4216,7 +3337,7 @@ class AgentVariantsOrchestrator {
                 });
                 continue;
             }
-            const record = resources.worktrees.get(variant.workItemId);
+            const record = this.workspaceInventory.getWorktree(args.sessionId, variant.workItemId);
             if (!record) {
                 manifestEntries.push({
                     variantId: variant.workItemId,
@@ -4281,7 +3402,7 @@ class AgentVariantsOrchestrator {
         catch (err) {
             log.warn(`Writing variants history manifest failed for ${historyDir}`, err);
         }
-        resources.vitePreservedSiblings = true;
+        this.workspaceInventory.preserveViteSibling(args.sessionId);
         return runnablePaths;
     }
     async renameWorktreeIntoDestination(sourceWorktreePath, destinationPath) {
@@ -4357,218 +3478,31 @@ class AgentVariantsOrchestrator {
             log.warn(`Initial git history setup at ${destinationPath} failed`, err);
         }
     }
-    async stopAllDevServersForSession(resources) {
-        this.clearActivePreviewIdleTimer(resources);
-        const stops = [];
-        for (const record of resources.worktrees.values()) {
-            if (record.pendingAutoRestart) {
-                clearTimeout(record.pendingAutoRestart);
-                record.pendingAutoRestart = undefined;
-            }
-            if (!record.devServerProcess)
-                continue;
-            const proc = record.devServerProcess;
-            stops.push(this.worktrees
-                .stopDevServer(proc)
-                .catch((err) => log.warn(`stopDevServer pre-commit failed for ${resources.sessionId}/${record.workItemId}`, err)));
-            record.devServerProcess = undefined;
-            record.port = undefined;
-        }
-        await Promise.all(stops);
-        return stops.length;
-    }
-    scheduleActivePreviewIdleTimer(resources) {
-        if (!Number.isFinite(this.activeVariantServerIdleTtlMs) ||
-            this.activeVariantServerIdleTtlMs <= 0) {
-            return;
-        }
-        this.clearActivePreviewIdleTimer(resources);
-        resources.activePreviewIdleTimer = setTimeout(() => {
-            resources.activePreviewIdleTimer = undefined;
-            void this.stopIdleVariantDevServers(resources.sessionId);
-        }, this.activeVariantServerIdleTtlMs);
-        resources.activePreviewIdleTimer.unref?.();
-    }
-    clearActivePreviewIdleTimer(resources) {
-        if (!resources.activePreviewIdleTimer)
-            return;
-        clearTimeout(resources.activePreviewIdleTimer);
-        resources.activePreviewIdleTimer = undefined;
-    }
-    async stopIdleVariantDevServers(sessionId) {
-        const resources = this.resources.get(sessionId);
-        if (!resources || resources.cleanupStarted)
-            return;
-        if (this.uiClientCount > 0) {
-            this.scheduleActivePreviewIdleTimer(resources);
-            return;
-        }
-        if (resources.activePreviewIdleStop) {
-            await resources.activePreviewIdleStop;
-            return;
-        }
-        const stop = (async () => {
-            const expiringRecords = Array.from(resources.worktrees.values()).filter((record) => Boolean(record.devServerProcess) ||
-                Boolean(record.pendingAutoRestart));
-            const expiringWorkItemIds = expiringRecords.map((record) => record.workItemId);
-            const pendingRestartCount = expiringRecords.filter((record) => Boolean(record.pendingAutoRestart)).length;
-            const stoppedCount = await this.stopAllDevServersForSession(resources);
-            if (expiringWorkItemIds.length === 0)
-                return;
-            for (const workItemId of expiringWorkItemIds) {
-                resources.previewFailures.set(workItemId, {
-                    reason: 'idle_timeout',
-                    portInUse: false,
-                });
-            }
-            log.info(`Reclaimed ${expiringWorkItemIds.length} idle variant preview(s) for session ${sessionId} ` +
-                `(${stoppedCount} running, ${pendingRestartCount} restarting)`);
-            try {
-                this.switchPreviewPort?.(null);
-            }
-            catch (err) {
-                log.warn(`switchPreviewPort(null) after idle variant server cleanup failed for ${sessionId}`, err);
-            }
-            this.emitChange();
-        })().finally(() => {
-            if (resources.activePreviewIdleStop === stop) {
-                resources.activePreviewIdleStop = undefined;
-            }
-        });
-        resources.activePreviewIdleStop = stop;
-        await stop;
-    }
-    async startCommittedDevServer(args) {
-        const mode = args.mode ?? 'vite_app';
-        try {
-            const port = await this.worktrees.getFreePort();
-            const proc = mode === 'static_preview'
-                ? await this.startStaticPreviewServerImpl({
-                    rootPath: args.destinationPath,
-                    port,
-                    host: FRESH_DEV_SERVER_HOST,
-                })
-                : await this.worktrees.startDevServer(args.destinationPath, port, 'npm', [
-                    'run',
-                    'dev',
-                    '--',
-                    '--port',
-                    String(port),
-                    '--host',
-                    FRESH_DEV_SERVER_HOST,
-                ], { PORT: String(port) });
-            args.resources.committedDevServer = {
-                proc,
-                port,
-                path: args.destinationPath,
-            };
-            try {
-                this.setCommittedDevServerHealth?.(port);
-            }
-            catch (err) {
-                log.warn(`setCommittedDevServerHealth(${port}) after committed dev server start failed`, err);
-            }
-            try {
-                this.switchPreviewPort?.(port);
-            }
-            catch (err) {
-                log.warn(`switchPreviewPort(${port}) after committed dev server start failed`, err);
-            }
-            log.info(`Committed ${mode} dev server up at ${args.destinationPath} on port ${port}`);
-            return port;
-        }
-        catch (err) {
-            log.warn(`Failed to start committed ${mode} dev server at ${args.destinationPath} — iframe may show "preview disconnected" until user runs the dev server manually`, err);
-            return undefined;
-        }
-    }
-    async stopLingeringCommittedDevServers() {
-        const entries = [...this.lingeringCommittedDevServers.entries()];
-        this.lingeringCommittedDevServers.clear();
-        if (entries.length > 0) {
-            try {
-                this.setCommittedDevServerHealth?.(null);
-            }
-            catch (err) {
-                log.warn('setCommittedDevServerHealth(null) on lingering teardown failed', err);
-            }
-        }
-        await Promise.all(entries.map(async ([sessionId, entry]) => {
-            try {
-                await this.worktrees.stopDevServer(entry.proc);
-            }
-            catch (err) {
-                log.warn(`stopDevServer for lingering committed server (session ${sessionId}, port ${entry.port}) failed`, err);
-            }
-        }));
-    }
     async teardownSession(sessionId, reason) {
         const resources = this.resources.get(sessionId);
         if (!resources)
             return;
-        if (resources.cleanupStarted)
+        if (!this.workspaceInventory.beginCleanup(sessionId))
             return;
-        resources.cleanupStarted = true;
-        this.clearActivePreviewIdleTimer(resources);
         log.info(`Tearing down session ${sessionId} (reason: ${reason})`);
-        resources.dependencyAbortController.abort();
-        await Promise.all([...resources.worktrees.values()].map((record) => DependencyPreparationService_1.previewDependencies.settle(record.worktreePath)));
+        await Promise.all(this.workspaceInventory
+            .getWorktrees(sessionId)
+            .map((record) => DependencyPreparationService_1.previewDependencies.settle(record.worktreePath)));
         await Promise.race([
             this.settleHistoryPersists(),
             new Promise((resolve) => setTimeout(resolve, SETTLE_PERSISTS_TEARDOWN_TIMEOUT_MS)),
         ]);
-        const stops = [...resources.worktrees.values()]
-            .filter((r) => r.devServerProcess)
-            .map((r) => this.worktrees
-            .stopDevServer(r.devServerProcess)
-            .catch((err) => log.warn(`stopDevServer failed for ${sessionId}/${r.workItemId}`, err)));
-        await Promise.all(stops);
-        if (resources.committedDevServer && reason === 'committed') {
-            this.lingeringCommittedDevServers.set(sessionId, resources.committedDevServer);
-        }
-        else if (resources.committedDevServer) {
-            try {
-                await this.worktrees.stopDevServer(resources.committedDevServer.proc);
-            }
-            catch (err) {
-                log.warn(`stopDevServer for committed dev server (session ${sessionId}) failed`, err);
-            }
-        }
-        if (!resources.vitePreservedSiblings) {
-            try {
-                await this.worktrees.cleanupSession(sessionId, resources.freshDestinationParent);
-            }
-            catch (err) {
-                log.warn(`cleanupSession (worktree removal) failed for ${sessionId}`, err);
-            }
-        }
-        const ownedArtifactRoots = new Set(resources.workspaceManager.getOwnedArtifactRoots());
-        resources.workspaceManager.removeOwnedArtifactWorkspaces();
-        const staticDirectories = new Set();
-        if (reason !== 'committed') {
-            let isFresh = false;
-            try {
-                isFresh = this.store.getProjectContext(sessionId).kind === 'fresh';
-            }
-            catch {
-                isFresh = false;
-            }
-            if (isFresh) {
-                for (const preview of resources.staticPreviews.values()) {
-                    if (!ownedArtifactRoots.has(preview.assetBase)) {
-                        staticDirectories.add(preview.assetBase);
-                    }
-                }
-            }
-        }
-        for (const staticDirectory of staticDirectories) {
-            try {
-                fs_1.default.rmSync(staticDirectory, { recursive: true, force: true });
-            }
-            catch (err) {
-                log.warn(`failed to remove static preview dir ${staticDirectory} for ${sessionId}`, err);
-            }
+        await this.previewRuntime.closeSession(sessionId, reason);
+        let isFresh = false;
+        try {
+            isFresh = this.store.getProjectContext(sessionId).kind === 'fresh';
         }
+        catch { }
+        await this.workspaceInventory.disposeAssignments({
+            sessionId,
+            isFresh,
+            isCommitted: reason === 'committed',
+        });
         this.resources.delete(sessionId);
     }
     ensureResources(sessionId) {
@@ -4576,12 +3510,6 @@ class AgentVariantsOrchestrator {
         if (!r) {
             r = {
                 sessionId,
-                worktrees: new Map(),
-                staticPreviews: new Map(),
-                workspaceManager: new VariantWorkspaceManager_1.VariantWorkspaceManager(),
-                contextAssets: new Map(),
-                cleanupStarted: false,
-                dependencyAbortController: new AbortController(),
                 committedVariantIds: new Set(),
                 startedAt: Date.now(),
                 nextRoundIndex: 0,
@@ -4590,964 +3518,13 @@ class AgentVariantsOrchestrator {
                 qaResults: new Map(),
                 qaRegenRetried: new Set(),
                 repairCompletionResults: new Map(),
-                previewFailures: new Map(),
-                vitePreservedSiblings: false,
             };
             this.resources.set(sessionId, r);
+            this.workspaceInventory.openSession(sessionId);
+            this.previewRuntime.openSession(sessionId);
         }
         return r;
     }
 }
 exports.AgentVariantsOrchestrator = AgentVariantsOrchestrator;
-function estimateOutputBytes(output) {
-    if (output === undefined || output === null)
-        return 0;
-    try {
-        return typeof output === 'string'
-            ? output.length
-            : JSON.stringify(output).length;
-    }
-    catch {
-        return 0;
-    }
-}
-function normalizeOutput(output) {
-    if (typeof output === 'string') {
-        try {
-            return JSON.parse(output);
-        }
-        catch {
-            return output;
-        }
-    }
-    return output;
-}
-function isStrictlyInside(child, parent) {
-    const c = path_1.default.resolve(child);
-    const p = path_1.default.resolve(parent);
-    return c !== p && c.startsWith(p + path_1.default.sep);
-}
-function resolveAssetWithinBase(base, requestedPath) {
-    const target = path_1.default.resolve(base, '.' + path_1.default.sep + requestedPath);
-    if (target !== base && !target.startsWith(base + path_1.default.sep)) {
-        return undefined;
-    }
-    let realTarget;
-    try {
-        realTarget = fs_1.default.realpathSync(target);
-    }
-    catch {
-        return undefined;
-    }
-    if (realTarget !== base && !realTarget.startsWith(base + path_1.default.sep)) {
-        return undefined;
-    }
-    try {
-        const stat = fs_1.default.statSync(realTarget);
-        if (!stat.isFile())
-            return undefined;
-        if (stat.nlink !== 1)
-            return undefined;
-        return realTarget;
-    }
-    catch {
-        return undefined;
-    }
-}
-function resolveStaticPreviewAssetBase(args) {
-    if (!args.assetBase)
-        return undefined;
-    if (args.projectContext.kind !== 'fresh')
-        return undefined;
-    let workspace;
-    let resolved;
-    try {
-        const wsStat = fs_1.default.lstatSync(args.projectContext.workspacePath);
-        if (wsStat.isSymbolicLink()) {
-            log.warn(`Static preview workspacePath ${args.projectContext.workspacePath} is a symlink — refusing assetBase`);
-            return undefined;
-        }
-        const realWorkspaceRoot = fs_1.default.realpathSync(args.projectContext.workspaceRoot);
-        workspace = fs_1.default.realpathSync(args.projectContext.workspacePath);
-        if (!workspace.startsWith(realWorkspaceRoot + path_1.default.sep)) {
-            log.warn(`Static preview workspacePath ${workspace} is not a strict descendant of workspaceRoot ${realWorkspaceRoot} — refusing assetBase`);
-            return undefined;
-        }
-        const candidate = path_1.default.isAbsolute(args.assetBase)
-            ? args.assetBase
-            : path_1.default.join(workspace, args.assetBase);
-        resolved = fs_1.default.realpathSync(candidate);
-    }
-    catch {
-        log.warn(`Static preview assetBase ${args.assetBase} could not be resolved — ignoring`);
-        return undefined;
-    }
-    if (resolved !== workspace && !resolved.startsWith(workspace + path_1.default.sep)) {
-        log.warn(`Static preview assetBase ${args.assetBase} escapes workspace ${workspace} — ignoring`);
-        return undefined;
-    }
-    try {
-        const stat = fs_1.default.statSync(resolved);
-        if (!stat.isDirectory()) {
-            log.warn(`Static preview assetBase ${resolved} is not a directory — ignoring`);
-            return undefined;
-        }
-        return resolved;
-    }
-    catch {
-        log.warn(`Static preview assetBase ${resolved} does not exist — ignoring`);
-        return undefined;
-    }
-}
-function parseStaticPreviewOutput(output) {
-    if (!output || typeof output !== 'object')
-        return null;
-    const html = output.html;
-    if (typeof html !== 'string' || html.trim().length === 0)
-        return null;
-    const css = output.css;
-    const js = output.js;
-    const assetBase = output.assetBase;
-    return {
-        html: buildStaticPreviewDocument({
-            html,
-            css: typeof css === 'string' ? css : undefined,
-            js: typeof js === 'string' ? js : undefined,
-        }),
-        ...(typeof assetBase === 'string' && assetBase.length > 0
-            ? { assetBase }
-            : {}),
-    };
-}
-function buildStaticPreviewDocument(input) {
-    const style = input.css ? `<style>\n${input.css}\n</style>` : '';
-    const script = input.js ? `<script>\n${input.js}\n</script>` : '';
-    if (/<!doctype html>|<html[\s>]/i.test(input.html)) {
-        let doc = input.html;
-        if (style) {
-            if (/<\/head>/i.test(doc)) {
-                doc = doc.replace(/<\/head>/i, () => `${style}\n</head>`);
-            }
-            else {
-                doc += `\n${style}`;
-            }
-        }
-        if (script) {
-            if (/<\/body>/i.test(doc)) {
-                doc = doc.replace(/<\/body>/i, () => `${script}\n</body>`);
-            }
-            else {
-                doc += `\n${script}`;
-            }
-        }
-        return doc;
-    }
-    return `<!doctype html>
-<html lang="en">
-  <head>
-    <meta charset="UTF-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    ${style}
-  </head>
-  <body>
-${input.html}
-    ${script}
-  </body>
-</html>`;
-}
-function countDiffFiles(diff) {
-    return (diff.match(/^diff --git /gm) ?? []).length;
-}
-function countWorktreeFiles(destinationPath) {
-    let count = 0;
-    const walk = (dir) => {
-        let entries;
-        try {
-            entries = fs_1.default.readdirSync(dir, { withFileTypes: true });
-        }
-        catch {
-            return;
-        }
-        for (const entry of entries) {
-            if (MATERIALIZE_EXCLUDE.has(entry.name))
-                continue;
-            const full = path_1.default.join(dir, entry.name);
-            if (entry.isDirectory())
-                walk(full);
-            else if (entry.isFile())
-                count += 1;
-        }
-    };
-    walk(destinationPath);
-    return count;
-}
-const enrichDesignSource = (design) => {
-    if (!design || design.kind !== 'slug')
-        return design;
-    return {
-        ...design,
-        displayName: (0, designCatalog_1.getDesignSystemBySlug)(design.slug)?.name ?? design.slug,
-    };
-};
-const toActiveProjectContext = (projectContext) => {
-    const sourceCount = projectContext.variantContext?.userContext.filter((source) => source.transport !== 'prompt').length ?? 0;
-    const hasSourceContextSummary = Boolean(sourceCount > 0 ||
-        (projectContext.variantContext?.rivetMetadata.length ?? 0) > 0);
-    const activeSourceContext = hasSourceContextSummary
-        ? {
-            sourceCount,
-            isSourceGrounded: Boolean(sourceCount > 0 ||
-                projectContext.designContext?.length ||
-                projectContext.variantContext?.rivetMetadata.length),
-        }
-        : undefined;
-    if (projectContext.kind === 'existing') {
-        return {
-            kind: 'existing',
-            designContext: projectContext.designContext?.map((entry) => entry.kind === 'slug'
-                ? { kind: 'slug', slug: entry.slug }
-                : { kind: 'markdown', label: entry.label }),
-            ...(activeSourceContext ? { sourceContext: activeSourceContext } : {}),
-        };
-    }
-    return {
-        kind: 'fresh',
-        workspacePath: projectContext.workspacePath,
-        workspaceRoot: projectContext.workspaceRoot,
-        framework: projectContext.framework,
-        designContext: projectContext.designContext?.map((entry) => entry.kind === 'slug'
-            ? { kind: 'slug', slug: entry.slug }
-            : { kind: 'markdown', label: entry.label }),
-        ...(activeSourceContext ? { sourceContext: activeSourceContext } : {}),
-        ...(projectContext.executionPlan
-            ? {
-                executionPlan: {
-                    mode: projectContext.executionPlan.mode,
-                    confidence: projectContext.executionPlan.confidence,
-                    reason: projectContext.executionPlan.reason,
-                    assetCount: projectContext.executionPlan.assetPlan?.length ?? 0,
-                    runtimeRequirementCount: projectContext.executionPlan.runtimeRequirements?.length ?? 0,
-                },
-            }
-            : {}),
-    };
-};
-const buildSessionArtifacts = (sessionId, projectContext) => {
-    const artifacts = buildResolvedDesignContextArtifacts(projectContext);
-    return artifacts.map(({ content: _content, ...artifact }) => ({
-        ...artifact,
-        rawUrl: buildDesignContextRawUrl(sessionId, artifact.id),
-        viewUrl: buildDesignContextViewUrl(sessionId, artifact.id),
-    }));
-};
-const findDesignContextArtifact = (projectContext, artifactId) => {
-    return buildResolvedDesignContextArtifacts(projectContext).find((artifact) => artifact.id === artifactId);
-};
-const buildResolvedDesignContextArtifacts = (projectContext) => {
-    const designContext = projectContext.designContext;
-    if (!designContext || designContext.length === 0)
-        return [];
-    const artifactsByContent = new Map();
-    designContext.forEach((entry, slot) => {
-        if (!entry)
-            return;
-        if (entry.kind === 'slug') {
-            const markdown = (0, designCatalog_1.loadDesignSystemMarkdown)(entry.slug);
-            if (!markdown)
-                return;
-            const catalogEntry = (0, designCatalog_1.getDesignSystemBySlug)(entry.slug);
-            addDesignContextArtifact(artifactsByContent, {
-                id: `design_context:${slot}:${entry.slug}`,
-                kind: 'design_context',
-                label: catalogEntry?.name ?? entry.slug,
-                ...(catalogEntry?.description
-                    ? { summary: catalogEntry.description }
-                    : {}),
-                status: 'ready',
-                source: 'static',
-                contentType: 'text/markdown',
-                content: markdown,
-            });
-            return;
-        }
-        if (!entry.content)
-            return;
-        addDesignContextArtifact(artifactsByContent, {
-            id: `design_context:${slot}:${entry.label}`,
-            kind: 'design_context',
-            label: entry.label,
-            status: 'ready',
-            source: 'agent_browser',
-            contentType: 'text/markdown',
-            content: entry.content,
-        });
-    });
-    return [...artifactsByContent.values()].map((artifact) => {
-        if (artifact.usedByVariantCount <= 1)
-            return artifact;
-        return {
-            ...artifact,
-            summary: artifact.summary
-                ? `${artifact.summary} Used by ${artifact.usedByVariantCount} directions.`
-                : `Used by ${artifact.usedByVariantCount} directions.`,
-        };
-    });
-};
-const addDesignContextArtifact = (artifactsByContent, artifact) => {
-    const existing = artifactsByContent.get(artifact.content);
-    if (existing) {
-        existing.usedByVariantCount += 1;
-        return;
-    }
-    artifactsByContent.set(artifact.content, {
-        ...artifact,
-        usedByVariantCount: 1,
-    });
-};
-const buildDesignContextRawUrl = (sessionId, artifactId) => {
-    return `/api/variants/${encodeURIComponent(sessionId)}/${DESIGN_CONTEXT_ROUTE_SEGMENT}/${encodeURIComponent(artifactId)}`;
-};
-const buildDesignContextViewUrl = (sessionId, artifactId) => {
-    return `${buildDesignContextRawUrl(sessionId, artifactId)}/${DESIGN_CONTEXT_VIEW_SEGMENT}`;
-};
-const buildDesignContextViewerDocument = (artifact) => {
-    const title = `${artifact.label} DESIGN.md`;
-    const visualHtml = renderDesignMarkdown(artifact.content, artifact.label);
-    return `<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8" />
-  <meta name="viewport" content="width=device-width, initial-scale=1" />
-  <title>${escapeHtml(title)}</title>
-  <style>
-    :root {
-      color-scheme: dark;
-      --font-main: 'Satoshi', 'Inter', system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
-      --font-mono: ui-monospace, "SFMono-Regular", Menlo, Consolas, monospace;
-      --main: #1C1C20;
-      --main-light: #1E1E22;
-      --main-input: #2E2E2E;
-      --main-border: #232328;
-      --main-hover: #404040;
-      --content: #ffffff;
-      --content-muted: #d1d5db;
-      --content-subtle: #9ca3af;
-      --divider: #4b5563;
-      --primary: #FF3300;
-      --primary-border: #ff6b35;
-    }
-    * { box-sizing: border-box; }
-    body {
-      margin: 0;
-      min-height: 100vh;
-      background: var(--main);
-      color: var(--content);
-      font-family: var(--font-main);
-    }
-    .page-shell {
-      min-height: 100vh;
-      padding: 22px 28px 56px;
-    }
-    .topbar {
-      display: flex;
-      align-items: center;
-      justify-content: space-between;
-      margin-bottom: 28px;
-    }
-    .brand {
-      display: inline-flex;
-      align-items: center;
-      min-height: 28px;
-    }
-    .brand-logo {
-      display: block;
-      width: 64px;
-      height: auto;
-    }
-    .avatar {
-      width: 28px;
-      height: 28px;
-      border: 1px solid var(--main-border);
-      border-radius: 8px;
-      background: var(--main-light);
-    }
-    main {
-      width: min(1120px, calc(100vw - 56px));
-      margin: 0 auto;
-    }
-    .document {
-      overflow: hidden;
-      border: 1px solid var(--main-border);
-      border-radius: 22px;
-      background: var(--main-light);
-      box-shadow: 0 18px 60px rgb(0 0 0 / 18%);
-    }
-    .document-title {
-      padding: 42px 46px 32px;
-    }
-    .eyebrow {
-      margin: 0 0 14px;
-      color: var(--content-subtle);
-      font-size: 0.68rem;
-      font-weight: 700;
-      letter-spacing: 0.16em;
-      text-transform: uppercase;
-    }
-    .file-title {
-      margin: 0;
-      color: var(--content);
-      font-size: clamp(2.35rem, 6vw, 4.9rem);
-      font-weight: 600;
-      letter-spacing: -0.07em;
-      line-height: 0.94;
-    }
-    .visual {
-      border-top: 1px solid var(--main-border);
-      max-width: none;
-      margin: 0 auto;
-      padding: 36px 46px 48px;
-    }
-    .visual-inner {
-      max-width: 720px;
-      margin: 0 auto;
-    }
-    .visual h1,
-    .visual h2,
-    .visual h3 {
-      margin: 1.2em 0 0.4em;
-      color: var(--content);
-      font-weight: 600;
-      letter-spacing: -0.02em;
-      line-height: 1.15;
-    }
-    .visual h1:first-child,
-    .visual h2:first-child,
-    .visual h3:first-child {
-      margin-top: 0;
-    }
-    .visual h1 { font-size: 1.25rem; }
-    .visual h2 { font-size: 1.1rem; }
-    .visual h3 { font-size: 1rem; }
-    .visual h2 + p,
-    .visual h2 + ul {
-      border-left: 1px solid var(--main-border);
-      padding-left: 14px;
-    }
-    .visual p,
-    .visual li,
-    .visual blockquote {
-      color: var(--content-muted);
-      font-size: 0.88rem;
-      line-height: 1.6;
-    }
-    .visual strong {
-      color: var(--content);
-      font-weight: 650;
-    }
-    .visual a {
-      color: var(--primary-border);
-    }
-    .visual ul {
-      display: grid;
-      gap: 8px;
-      padding-left: 1.1rem;
-    }
-    .visual blockquote {
-      margin: 18px 0;
-      border-left: 3px solid var(--primary);
-      padding-left: 14px;
-      color: var(--content-subtle);
-    }
-    .visual code {
-      border-radius: 6px;
-      border: 1px solid var(--main-border);
-      background: var(--main-input);
-      color: var(--content);
-      padding: 0.12rem 0.34rem;
-      font-family: var(--font-mono);
-      font-size: 0.92em;
-    }
-    pre {
-      margin: 0;
-      overflow: auto;
-      background: var(--main);
-      color: var(--content-muted);
-      padding: 16px;
-      font: 0.78rem/1.55 var(--font-mono);
-      white-space: pre-wrap;
-      word-break: break-word;
-    }
-    @media (max-width: 900px) {
-      .page-shell { padding: 18px 12px 34px; }
-      .topbar { margin-bottom: 18px; padding: 0 4px; }
-      main { width: min(100vw - 24px, 760px); }
-      .document { border-radius: 18px; }
-      .document-title { padding: 30px 24px 24px; }
-      .file-title { font-size: clamp(2rem, 12vw, 3.6rem); }
-      .visual { padding: 26px 24px 34px; }
-    }
-  </style>
-</head>
-<body>
-  <div class="page-shell">
-    <header class="topbar" aria-label="Rivet">
-      <div class="brand"><img class="brand-logo" src="/assets/logo.png" alt="Rivet" /></div>
-      <div class="avatar" aria-hidden="true"></div>
-    </header>
-    <main>
-      <article class="document" id="designmd-visual" aria-label="DesignMD artifact">
-        <div class="document-title">
-          <p class="eyebrow">Design Context</p>
-          <h1 class="file-title">${escapeHtml(title)}</h1>
-        </div>
-        <div class="visual"><div class="visual-inner">${visualHtml}</div></div>
-      </article>
-    </main>
-  </div>
-</body>
-</html>`;
-};
-const renderDesignMarkdown = (markdown, artifactLabel) => {
-    const lines = markdown.replace(/\r\n/g, '\n').split('\n');
-    const output = [];
-    const paragraph = [];
-    const listItems = [];
-    const codeLines = [];
-    let isCodeBlock = false;
-    let skippedFirstH1 = false;
-    const flushParagraph = () => {
-        if (paragraph.length === 0)
-            return;
-        output.push(`<p>${renderInlineMarkdown(paragraph.join(' '))}</p>`);
-        paragraph.length = 0;
-    };
-    const flushList = () => {
-        if (listItems.length === 0)
-            return;
-        output.push(`<ul>${listItems.map((item) => `<li>${renderInlineMarkdown(item)}</li>`).join('')}</ul>`);
-        listItems.length = 0;
-    };
-    const flushCode = () => {
-        if (codeLines.length === 0)
-            return;
-        output.push(`<pre>${escapeHtml(codeLines.join('\n'))}</pre>`);
-        codeLines.length = 0;
-    };
-    lines.forEach((line) => {
-        if (line.trim().startsWith('```')) {
-            if (isCodeBlock) {
-                flushCode();
-                isCodeBlock = false;
-                return;
-            }
-            flushParagraph();
-            flushList();
-            isCodeBlock = true;
-            return;
-        }
-        if (isCodeBlock) {
-            codeLines.push(line);
-            return;
-        }
-        const trimmed = line.trim();
-        if (!trimmed) {
-            flushParagraph();
-            flushList();
-            return;
-        }
-        if (/^---+$/.test(trimmed)) {
-            flushParagraph();
-            flushList();
-            output.push('<hr />');
-            return;
-        }
-        const headingMatch = trimmed.match(/^(#{1,6})\s+(.+)$/);
-        if (headingMatch) {
-            flushParagraph();
-            flushList();
-            const level = Math.min(headingMatch[1].length, 3);
-            const headingText = headingMatch[2].trim();
-            const isDuplicateTitle = headingText === artifactLabel ||
-                headingText === `${artifactLabel} DESIGN.md`;
-            if (level === 1 && !skippedFirstH1 && isDuplicateTitle) {
-                skippedFirstH1 = true;
-                return;
-            }
-            output.push(`<h${level}>${renderInlineMarkdown(headingText)}</h${level}>`);
-            return;
-        }
-        const listMatch = trimmed.match(/^[-*]\s+(.+)$/);
-        if (listMatch) {
-            flushParagraph();
-            listItems.push(listMatch[1]);
-            return;
-        }
-        const quoteMatch = trimmed.match(/^>\s?(.+)$/);
-        if (quoteMatch) {
-            flushParagraph();
-            flushList();
-            output.push(`<blockquote>${renderInlineMarkdown(quoteMatch[1])}</blockquote>`);
-            return;
-        }
-        paragraph.push(trimmed);
-    });
-    flushCode();
-    flushParagraph();
-    flushList();
-    return output.join('\n');
-};
-const renderInlineMarkdown = (value) => {
-    return escapeHtml(value)
-        .replace(/\*\*([^*]+)\*\*/g, '<strong>$1</strong>')
-        .replace(/`([^`]+)`/g, '<code>$1</code>')
-        .replace(/\*([^*]+)\*/g, '<em>$1</em>');
-};
-const escapeHtml = (value) => {
-    return value
-        .replace(/&/g, '&amp;')
-        .replace(/</g, '&lt;')
-        .replace(/>/g, '&gt;')
-        .replace(/"/g, '&quot;')
-        .replace(/'/g, '&#39;');
-};
-const resolveDesignArtifact = (entry) => {
-    if (!entry)
-        return null;
-    if (entry.kind === 'markdown') {
-        return {
-            markdown: entry.content,
-            source: { kind: 'markdown', label: entry.label },
-        };
-    }
-    const markdown = (0, designCatalog_1.loadDesignSystemMarkdown)(entry.slug);
-    if (!markdown)
-        return null;
-    const catalogEntry = (0, designCatalog_1.getDesignSystemBySlug)(entry.slug);
-    return {
-        markdown,
-        source: {
-            kind: 'slug',
-            slug: entry.slug,
-            label: catalogEntry?.name ?? entry.slug,
-        },
-    };
-};
-const summarizeDesignContext = (designContext) => {
-    if (!designContext)
-        return null;
-    return designContext.reduce((entries, entry, slot) => {
-        if (!entry)
-            return entries;
-        if (entry.kind === 'slug') {
-            entries.push({ slot, kind: 'slug', slug: entry.slug });
-            return entries;
-        }
-        entries.push({
-            slot,
-            kind: 'markdown',
-            markdownLabel: entry.label,
-        });
-        return entries;
-    }, []);
-};
-const trackScaffoldStarted = (telemetry, data) => {
-    if (telemetry.trackAgentVariantsScaffoldStarted) {
-        telemetry.trackAgentVariantsScaffoldStarted(data);
-        return;
-    }
-    telemetry.track('agent_variants.scaffold_started', {
-        source: 'mcp',
-        session_id: data.sessionId,
-        variant_count: data.variantCount,
-        design_context: data.designContext ?? null,
-    });
-};
-const trackScaffoldCompleted = (telemetry, data) => {
-    if (telemetry.trackAgentVariantsScaffoldCompleted) {
-        telemetry.trackAgentVariantsScaffoldCompleted(data);
-        return;
-    }
-    telemetry.track('agent_variants.scaffold_completed', {
-        source: 'mcp',
-        session_id: data.sessionId,
-        duration_ms: data.durationMs,
-        install_duration_ms: data.installDurationMs,
-        variant_count: data.variantCount,
-    });
-};
-const trackScaffoldFailed = (telemetry, data) => {
-    if (telemetry.trackAgentVariantsScaffoldFailed) {
-        telemetry.trackAgentVariantsScaffoldFailed(data);
-        return;
-    }
-    telemetry.track('agent_variants.scaffold_failed', {
-        source: 'mcp',
-        session_id: data.sessionId,
-        error_code: data.errorCode,
-        duration_ms: data.durationMs,
-    });
-};
-const trackFreshDevServerStarted = (telemetry, data) => {
-    if (telemetry.trackAgentVariantsFreshDevServerStarted) {
-        telemetry.trackAgentVariantsFreshDevServerStarted(data);
-        return;
-    }
-    telemetry.track('agent_variants.fresh_dev_server_started', {
-        source: 'mcp',
-        session_id: data.sessionId,
-        variant_id: data.variantId,
-        port: data.port,
-    });
-};
-const trackFreshDevServerFailed = (telemetry, data) => {
-    if (telemetry.trackAgentVariantsFreshDevServerFailed) {
-        telemetry.trackAgentVariantsFreshDevServerFailed(data);
-        return;
-    }
-    telemetry.track('agent_variants.fresh_dev_server_failed', {
-        source: 'mcp',
-        session_id: data.sessionId,
-        variant_id: data.variantId,
-        error_code: data.errorCode,
-        failure_reason: data.reason,
-        port_in_use: data.portInUse,
-        exit_code: data.exitCode,
-        term_signal: data.signal,
-        missing_deps: data.missingDeps,
-    });
-};
-const trackPreviewStarted = (telemetry, data) => {
-    if (telemetry.trackAgentVariantsPreviewStarted) {
-        telemetry.trackAgentVariantsPreviewStarted(data);
-        return;
-    }
-    telemetry.track('agent_variants.preview_started', {
-        source: 'mcp',
-        session_id: data.sessionId,
-        variant_id: data.variantId,
-        project_context_kind: data.projectContextKind,
-        preview_kind: data.previewKind,
-    });
-};
-const trackPreviewReady = (telemetry, data) => {
-    if (telemetry.trackAgentVariantsPreviewReady) {
-        telemetry.trackAgentVariantsPreviewReady(data);
-        return;
-    }
-    telemetry.track('agent_variants.preview_ready', {
-        source: 'mcp',
-        session_id: data.sessionId,
-        variant_id: data.variantId,
-        project_context_kind: data.projectContextKind,
-        preview_kind: data.previewKind,
-        has_port: data.hasPort,
-        port: data.port,
-        duration_ms: data.durationMs,
-    });
-};
-const trackPreviewFailed = (telemetry, data) => {
-    if (telemetry.trackAgentVariantsPreviewFailed) {
-        telemetry.trackAgentVariantsPreviewFailed(data);
-        return;
-    }
-    telemetry.track('agent_variants.preview_failed', {
-        source: 'mcp',
-        session_id: data.sessionId,
-        variant_id: data.variantId,
-        project_context_kind: data.projectContextKind,
-        preview_kind: data.previewKind,
-        error_code: data.errorCode,
-        failure_reason: data.reason,
-        port_in_use: data.portInUse,
-        duration_ms: data.durationMs,
-        exit_code: data.exitCode,
-        term_signal: data.signal,
-        missing_deps: data.missingDeps,
-    });
-};
-const trackStaticPreviewCompleted = (telemetry, data) => {
-    if (telemetry.trackAgentVariantsStaticPreviewCompleted) {
-        telemetry.trackAgentVariantsStaticPreviewCompleted(data);
-        return;
-    }
-    telemetry.track('agent_variants.static_preview_completed', {
-        source: 'mcp',
-        session_id: data.sessionId,
-        variant_id: data.variantId,
-        duration_ms: data.durationMs,
-    });
-};
-const MATERIALIZE_EXCLUDE = new Set([
-    'node_modules',
-    '.git',
-    '.rivet',
-    'dist',
-    '.next',
-    '.cache',
-    '.vite',
-]);
-const STATIC_PREVIEW_HISTORY_EXCLUDE = new Set([
-    ...MATERIALIZE_EXCLUDE,
-    '.rivet',
-]);
-const STATIC_PREVIEW_HISTORY_FILE_EXTENSIONS = new Set([
-    ...ALLOWED_INERT_ASSET_EXTENSIONS,
-    '.css',
-    '.htm',
-    '.html',
-    '.js',
-]);
-function copyStaticPreviewDirectory(src, dest) {
-    fs_1.default.mkdirSync(dest, { recursive: true });
-    let entries;
-    try {
-        entries = fs_1.default.readdirSync(src, { withFileTypes: true });
-    }
-    catch {
-        return;
-    }
-    for (const entry of entries) {
-        if (entry.name.startsWith('.') ||
-            STATIC_PREVIEW_HISTORY_EXCLUDE.has(entry.name)) {
-            continue;
-        }
-        const from = path_1.default.join(src, entry.name);
-        const to = path_1.default.join(dest, entry.name);
-        if (entry.isDirectory()) {
-            copyStaticPreviewDirectory(from, to);
-        }
-        else if (entry.isFile()) {
-            const extension = path_1.default.extname(entry.name).toLowerCase();
-            if (!STATIC_PREVIEW_HISTORY_FILE_EXTENSIONS.has(extension))
-                continue;
-            let stat;
-            try {
-                stat = fs_1.default.statSync(from);
-            }
-            catch {
-                continue;
-            }
-            if (!stat.isFile() || stat.nlink !== 1)
-                continue;
-            fs_1.default.mkdirSync(path_1.default.dirname(to), { recursive: true });
-            fs_1.default.copyFileSync(from, to);
-        }
-    }
-}
-const defaultInstallDependencies = async (worktreePath, options) => {
-    await DependencyPreparationService_1.previewDependencies.prepare({
-        cwd: worktreePath,
-        workspaceRoot: options?.workspaceRoot ?? worktreePath,
-        force: options?.force,
-        signal: options?.signal,
-    });
-};
-const buildServeRecipeFromResolved = (snapshotRoot, dev, port) => {
-    const portPattern = new RegExp(`(?<![0-9])${port}(?![0-9])`, 'g');
-    const sub = (value) => value.replace(portPattern, '${PORT}');
-    const relativeCwd = path_1.default.relative(snapshotRoot, dev.cwd);
-    return {
-        cwd: relativeCwd === '' ? '.' : relativeCwd,
-        cmd: dev.cmd,
-        argsTemplate: dev.args.map(sub),
-        envTemplate: Object.fromEntries(Object.entries(dev.env).map(([key, value]) => [key, sub(value)])),
-    };
-};
-const canInstallWithoutTouchingHost = (cwd) => {
-    try {
-        return !fs_1.default.lstatSync(path_1.default.join(cwd, 'node_modules')).isSymbolicLink();
-    }
-    catch {
-        return true;
-    }
-};
-const assertDevScriptExists = (cwd, scriptName) => {
-    let scripts;
-    try {
-        const raw = fs_1.default.readFileSync(path_1.default.join(cwd, 'package.json'), 'utf8');
-        const parsed = JSON.parse(raw);
-        if (parsed && typeof parsed === 'object' && 'scripts' in parsed) {
-            const candidate = parsed.scripts;
-            if (candidate && typeof candidate === 'object') {
-                scripts = candidate;
-            }
-        }
-    }
-    catch {
-        return;
-    }
-    if (scripts && typeof scripts[scriptName] === 'string')
-        return;
-    const available = Object.keys(scripts ?? {});
-    throw new devServerError_1.DevServerStartError({
-        message: `package.json at ${cwd} has no "${scriptName}" script` +
-            (available.length ? ` (available: ${available.join(', ')})` : ''),
-        reason: 'missing_dev_script',
-        portInUse: false,
-        detail: available.length
-            ? `available scripts: ${available.join(', ')}`
-            : '',
-    });
-};
-function areSameVolume(a, b) {
-    try {
-        const statA = fs_1.default.statSync(a);
-        const parentB = fs_1.default.existsSync(b) ? b : path_1.default.dirname(b);
-        const statB = fs_1.default.statSync(parentB);
-        return statA.dev === statB.dev;
-    }
-    catch {
-        return false;
-    }
-}
-async function resolveNodeModulesSymlink(worktreePath) {
-    const nodeModulesPath = path_1.default.join(worktreePath, 'node_modules');
-    try {
-        if (!(await fs_1.default.promises.lstat(nodeModulesPath)).isSymbolicLink())
-            return false;
-        await fs_1.default.promises.rm(nodeModulesPath, { force: true });
-        return true;
-    }
-    catch (error) {
-        if (error.code === 'ENOENT')
-            return true;
-        throw error;
-    }
-}
-const defaultMaterializeProject = async (sourceWorktreePath, destinationPath) => {
-    await fs_1.default.promises.mkdir(destinationPath, { recursive: true });
-    await fs_1.default.promises.cp(sourceWorktreePath, destinationPath, {
-        recursive: true,
-        filter: (sourcePath) => {
-            const rel = path_1.default.relative(sourceWorktreePath, sourcePath);
-            if (!rel)
-                return true;
-            const top = rel.split(path_1.default.sep)[0];
-            return !MATERIALIZE_EXCLUDE.has(top);
-        },
-    });
-    const git = (0, simple_git_1.simpleGit)(destinationPath);
-    await git.raw(['init']);
-    await git.raw(['add', '-A']);
-    await git
-        .raw([
-        '-c',
-        'user.name=Rivet',
-        '-c',
-        'user.email=hello@tryrivet.design',
-        'commit',
-        '--no-gpg-sign',
-        '-m',
-        'Initial commit (created with Rivet)',
-    ])
-        .catch(() => { });
-};
-function synthesizeUnifiedBriefBody(prompt, index, total) {
-    const trimmed = prompt.trim().replace(/\s+/g, ' ').slice(0, 200);
-    const intent = trimmed.length > 0 ? trimmed : 'Create this variant';
-    if (total <= 1)
-        return intent;
-    const focus = FALLBACK_DIRECTION_FOCI[(Math.max(index, 1) - 1) % FALLBACK_DIRECTION_FOCI.length];
-    return `${intent} Direction ${index} of ${total}: ${focus}`;
-}
 //# sourceMappingURL=WorktreeOrchestrator.js.map