rivet-design 0.12.3 → 0.13.0

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

@@ -1,1165 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.normalizeAgentOutput = exports.slugifyPrompt = void 0;
-exports.registerAgentVariantsTools = registerAgentVariantsTools;
-exports.buildQaFailurePrompt = buildQaFailurePrompt;
-exports.buildRegeneratePrompt = buildRegeneratePrompt;
-const path_1 = __importDefault(require("path"));
-const crypto_1 = require("crypto");
-const variantContext_1 = require("./variantContext");
-const contracts_1 = require("./contracts");
-const VariantHistoryService_1 = require("../../services/VariantHistoryService");
-const errors_1 = require("./errors");
-const generatedDestination_1 = require("./generatedDestination");
-Object.defineProperty(exports, "slugifyPrompt", { enumerable: true, get: function () { return generatedDestination_1.slugifyPrompt; } });
-const createZeroToOneTool_1 = require("./createZeroToOneTool");
-const ProjectDetectionService_1 = require("../../services/ProjectDetectionService");
-const BrowserAgentClient_1 = require("../../services/BrowserAgentClient");
-/**
- * Coerce `output` to a structured value when an agent (incorrectly) sends a
- * stringified JSON. The MCP schema accepts `z.unknown()` so the call doesn't
- * fail validation, but downstream consumers (e.g. `output.html` in
- * WorktreeOrchestrator) expect an object and silently no-op on strings —
- * leaving the variant stuck at "not ready" until session expiry.
- */
-const normalizeAgentOutput = (output) => {
-    if (typeof output !== 'string')
-        return output;
-    try {
-        return JSON.parse(output);
-    }
-    catch {
-        return output;
-    }
-};
-exports.normalizeAgentOutput = normalizeAgentOutput;
-/** Builds the required host-agent action for a live visual editor session. */
-const buildVisualEditorWatchAction = (sessionId, timing) => ({
-    tool: 'watch_for_changes',
-    arguments: { sessionId },
-    required: true,
-    timing,
-    loopUntil: 'close_visual_editor',
-    onTimeout: 'call_again',
-    afterHandlingChanges: 'call_again',
-});
-const manifestKind = (manifest) => {
-    return manifest.artifact.kind === 'diff' ? 'diff' : 'project-created';
-};
-const normalizeEvidenceUrl = (url) => {
-    try {
-        return new URL(url).href;
-    }
-    catch {
-        return url;
-    }
-};
-const startVariantsTelemetryFor = (args) => {
-    const userContext = args.userContext ?? [];
-    const mode = args.mode === 'zero_to_one'
-        ? userContext.length > 0
-            ? 'source_grounded'
-            : 'zero_to_one'
-        : args.sourceVariantId
-            ? 'vary'
-            : 'initial_generation';
-    return {
-        requestId: args.requestId,
-        entryPoint: 'mcp_tool',
-        mode,
-        projectContextKind: args.mode === 'zero_to_one' ? 'fresh' : 'existing',
-        requestedCount: args.briefs?.length ?? args.count,
-        sourceCount: userContext.length,
-        sourceUrlCount: userContext.filter((source) => source.transport === 'url')
-            .length,
-        sourceFileCount: userContext.filter((source) => source.transport === 'file_path').length,
-        sourceDirectoryCount: userContext.filter((source) => source.transport === 'directory_path').length,
-        sourceTextCount: userContext.filter((source) => source.transport === 'text')
-            .length,
-        briefCount: args.briefs?.length,
-        briefLabelCount: args.briefs?.filter((brief) => brief.label.length > 0)
-            .length,
-        instructionLength: args.prompt.length,
-    };
-};
-const evidenceKey = (url) => normalizeEvidenceUrl(url);
-const designSystemMetadataBySourceId = (sourcePlan) => {
-    const bySourceId = new Map();
-    for (const metadata of sourcePlan.metadata) {
-        if (metadata.kind !== 'design_system')
-            continue;
-        for (const sourceId of metadata.sourceIds) {
-            bySourceId.set(sourceId, [...(bySourceId.get(sourceId) ?? []), metadata]);
-        }
-    }
-    return bySourceId;
-};
-const urlDesignSourceIds = (sourcePlan) => {
-    const sourceIds = new Set();
-    for (const action of sourcePlan.actions) {
-        if (action.kind !== 'extract_design_system')
-            continue;
-        action.sourceIds.forEach((sourceId) => sourceIds.add(sourceId));
-    }
-    for (const metadata of sourcePlan.metadata) {
-        if (metadata.kind !== 'design_system')
-            continue;
-        metadata.sourceIds.forEach((sourceId) => sourceIds.add(sourceId));
-    }
-    return sourceIds;
-};
-/**
- * Requires every URL-backed design-system source to prove the browser evidence
- * route was attempted before source planning is accepted.
- */
-const assertBrowserEvidenceForUrlDesignSources = (args) => {
-    const workItemInput = args.workItemInput;
-    const urlSourcesById = new Map();
-    for (const source of workItemInput.userContext ?? []) {
-        if (source.transport === 'url' &&
-            typeof source.id === 'string' &&
-            typeof source.url === 'string') {
-            urlSourcesById.set(source.id, source.url);
-        }
-    }
-    const metadataBySourceId = designSystemMetadataBySourceId(args.sourcePlan);
-    for (const sourceId of urlDesignSourceIds(args.sourcePlan)) {
-        const sourceUrl = urlSourcesById.get(sourceId);
-        if (!sourceUrl)
-            continue;
-        const attempt = args.attempts.get(evidenceKey(sourceUrl));
-        if (!attempt) {
-            throw new errors_1.AgentVariantsError('SOURCE_CONTEXT_INVALID', `URL source ${sourceId} must call capture_design_evidence before report_work_item(kind='source_plan').`);
-        }
-        const metadata = metadataBySourceId.get(sourceId) ?? [];
-        for (const entry of metadata) {
-            if (!entry.data.evidenceStatus) {
-                throw new errors_1.AgentVariantsError('SOURCE_CONTEXT_INVALID', `design_system metadata ${entry.id} must set data.evidenceStatus after capture_design_evidence.`);
-            }
-            if (attempt.evidenceStatus === 'inferred' &&
-                entry.data.evidenceStatus !== 'inferred') {
-                throw new errors_1.AgentVariantsError('SOURCE_CONTEXT_INVALID', `design_system metadata ${entry.id} cannot claim captured browser evidence after capture_design_evidence returned no rendered evidence.`);
-            }
-        }
-    }
-};
-const registerVariantTool = (mcp, name, description, input, handler) => {
-    const tool = mcp.tool.bind(mcp);
-    tool(name, description, input, handler);
-};
-function registerAgentVariantsTools(mcp, deps) {
-    const browserEvidenceAttemptsBySession = new Map();
-    const browserEvidenceAttemptsByUrl = new Map();
-    const recordBrowserEvidenceAttempt = (sessionId, url, attempt) => {
-        browserEvidenceAttemptsByUrl.set(evidenceKey(url), attempt);
-        if (!sessionId)
-            return;
-        const sessionAttempts = browserEvidenceAttemptsBySession.get(sessionId) ?? new Map();
-        sessionAttempts.set(evidenceKey(url), attempt);
-        browserEvidenceAttemptsBySession.set(sessionId, sessionAttempts);
-    };
-    // --- Unified report_work_item handlers (formerly report_variant_briefs,
-    // report_source_plan, report_variant_complete). Each keeps its original body
-    // verbatim; report_work_item dispatches on `kind`. ---
-    const handleReportBriefs = async (args) => {
-        try {
-            const reported = deps.orchestrator.reportBriefs({
-                sessionId: args.sessionId,
-                workItemId: args.workItemId,
-                attempt: args.attempt,
-                leaseId: args.leaseId,
-                briefs: args.briefs,
-                bindings: args.bindings,
-            });
-            // Start every reported brief immediately — no in-chat approval gate.
-            // Mirrors start_variants' single-call kickoff so directions begin
-            // generating without waiting on user confirmation.
-            const approved = await deps.orchestrator.approve({
-                sessionId: args.sessionId,
-                selections: reported.briefs.map((b) => ({ briefId: b.briefId })),
-            });
-            const out = {
-                stage: 'work_items_ready',
-                approvedCount: approved.approvedCount,
-                codeGenWorkItemIds: approved.codeGenWorkItemIds,
-                scaffoldBaseWorkItemId: approved.scaffoldBaseWorkItemId ?? null,
-                nextAction: 'continue_variants',
-            };
-            return jsonResponse(out);
-        }
-        catch (err) {
-            return errorResponse(err);
-        }
-    };
-    const handleReportSourcePlan = async (args) => {
-        try {
-            const attempts = new Map(browserEvidenceAttemptsByUrl);
-            const sessionAttempts = browserEvidenceAttemptsBySession.get(args.sessionId);
-            for (const [key, attempt] of sessionAttempts ?? []) {
-                attempts.set(key, attempt);
-            }
-            assertBrowserEvidenceForUrlDesignSources({
-                sourcePlan: args.sourcePlan,
-                workItemInput: deps.orchestrator.getWorkItemInput(args.sessionId, args.workItemId),
-                attempts,
-            });
-            const result = deps.orchestrator.reportSourcePlan({
-                sessionId: args.sessionId,
-                workItemId: args.workItemId,
-                leaseId: args.leaseId,
-                attempt: args.attempt,
-                sourcePlan: args.sourcePlan,
-            });
-            const plan = args.sourcePlan.executionPlan;
-            const out = {
-                stage: 'awaiting_briefs',
-                briefWorkItem: {
-                    id: result.briefWorkItem.id,
-                    kind: 'brief',
-                    attempt: result.briefWorkItem.attempt,
-                    input: result.briefWorkItem.input,
-                    output_schema: {
-                        briefs: 'Array<{briefId, label: "1–5 word plain-English title naming the direction", body: "one or two plain-English sentences describing the complete variant direction, including the page scope that must remain complete"}>',
-                    },
-                },
-                executionPlan: {
-                    mode: plan.mode,
-                    confidence: plan.confidence,
-                    reason: plan.reason,
-                    assetCount: plan.assetPlan?.length ?? 0,
-                    runtimeRequirementCount: plan.runtimeRequirements?.length ?? 0,
-                },
-                nextAction: 'report_work_item',
-            };
-            return jsonResponse(out);
-        }
-        catch (err) {
-            return errorResponse(err);
-        }
-    };
-    registerVariantTool(mcp, 'capture_design_evidence', 'Render a reference URL on a real browser (server-side) and return RENDERED DESIGN EVIDENCE for you to interpret — NOT a finished design system. You get: the page\'s `:root` design tokens (verbatim), computed styles of key elements (colors, type scale, spacing, radius, transitions), the resolved font families, and a screenshot. Pass the current variants sessionId whenever this is part of source planning. Call this for every URL source during source planning BEFORE reporting design_system, then SYNTHESIZE design_system.data.designMarkdown yourself from the evidence: map role-named tokens (--primary/--background/--foreground/--muted/--accent/--border/--radius) to DESIGN.md roles; resolve shadcn HSL-triplet tokens (e.g. "0 0% 9%" means hsl(0 0% 9%)); read the display font from heading element styles and the body font from body/paragraph; use the screenshot to choose the brand/accent color and overall feel. Mark only genuinely-unobservable values as unknown — do not invent. Set data.evidenceStatus to the evidence\'s evidenceStatus. If ok=false, no rendered evidence is available: inspect the URL natively and report design_system with data.evidenceStatus="inferred". Provider keys stay server-side; you only pass the URL.', contracts_1.captureDesignEvidenceInput, async (args) => {
-        try {
-            const client = deps.browserAgentClient ?? new BrowserAgentClient_1.BrowserAgentClient();
-            const result = await client.captureDesignEvidence(args.url, {
-                viewport: args.viewport,
-                screenshot: true,
-            });
-            if (!result.ok) {
-                recordBrowserEvidenceAttempt(args.sessionId, args.url, {
-                    evidenceStatus: 'inferred',
-                    available: result.available,
-                });
-                const out = {
-                    ok: false,
-                    available: result.available,
-                    evidenceStatus: 'inferred',
-                    reason: result.reason,
-                    guidance: result.available
-                        ? 'The browser agent is enabled but this render failed (likely transient). You may retry capture_design_evidence once; if it still fails, inspect the URL natively and report design_system with data.evidenceStatus = "inferred".'
-                        : 'No browser agent is available. Inspect the URL natively (read whatever static content you can) and report design_system with data.evidenceStatus = "inferred" — do not present inferred values as extracted.',
-                };
-                return jsonResponse(out);
-            }
-            const { evidence } = result;
-            // The renderer only emits 'inferred' on hard failure (ok=false); any
-            // successful render is at least 'partial'.
-            const evidenceStatus = evidence.evidenceStatus === 'captured' ? 'captured' : 'partial';
-            recordBrowserEvidenceAttempt(args.sessionId, args.url, {
-                evidenceStatus,
-                available: true,
-            });
-            const guidance = [
-                `Rendered design evidence for ${evidence.finalUrl} (evidenceStatus: ${evidenceStatus}).`,
-                'Synthesize design_system.data.designMarkdown from this evidence; set data.evidenceStatus to the value above.',
-                '- Map role-named :root variables to DESIGN.md roles (--primary, --background, --foreground, --muted, --accent, --border, --ring, --card, --radius, ...).',
-                '- Resolve shadcn HSL-triplet tokens: a value like "0 0% 9%" means hsl(0 0% 9%) — convert to a concrete color.',
-                '- Read the display font from the heading element styles and the body font from body/paragraph; do not scrape font URLs.',
-                '- Use the screenshot to pick the brand/accent color and capture the overall feel where tokens are ambiguous.',
-                '- Mark only genuinely-unobservable values as unknown; do not invent responsive/motion/elevation behavior absent from the evidence.',
-            ].join('\n');
-            const payload = {
-                finalUrl: evidence.finalUrl,
-                evidenceStatus,
-                rootVariables: evidence.rootVariables,
-                elementStyles: evidence.elementStyles,
-                fonts: evidence.fonts,
-                warnings: evidence.warnings,
-            };
-            const content = [
-                {
-                    type: 'text',
-                    text: `${guidance}\n\nEVIDENCE:\n${JSON.stringify(payload, null, 2)}`,
-                },
-            ];
-            if (evidence.screenshotBase64) {
-                content.push({
-                    type: 'image',
-                    data: evidence.screenshotBase64,
-                    mimeType: 'image/png',
-                });
-            }
-            return { content };
-        }
-        catch (err) {
-            recordBrowserEvidenceAttempt(args.sessionId, args.url, {
-                evidenceStatus: 'inferred',
-                available: true,
-            });
-            const out = {
-                ok: false,
-                available: true,
-                evidenceStatus: 'inferred',
-                reason: err instanceof Error
-                    ? err.message
-                    : 'Browser evidence capture failed.',
-                guidance: 'The browser evidence capture attempt failed unexpectedly. Inspect the URL natively and report design_system with data.evidenceStatus = "inferred" — do not present inferred values as extracted.',
-            };
-            return jsonResponse(out);
-        }
-    });
-    registerVariantTool(mcp, 'commit_variant', "Call AFTER all variants have been generated AND you've shown each variant's diff/changes to the user in chat AND the user has picked one. Set confirmedByUser=true when the user confirms the pick. Only use bypassRequestedByUser=true (with bypassReason) if the user explicitly asks to bypass confirmation. Pass the variantId (the workItemId of the chosen variant). Rivet looks up that variant's captured diff and enqueues it onto the existing pending-changes channel — call get_pending_changes next to retrieve and apply. Idempotent on (sessionId, variantId).", contracts_1.commitVariantInput, async (args) => {
-        try {
-            assertExplicitUserConfirmation('commit_variant', args, 'commit a variant');
-            const isVariantSendEnabled = deps.isVariantSendEnabled === undefined
-                ? true
-                : await deps.isVariantSendEnabled();
-            if (!isVariantSendEnabled) {
-                deps.telemetry?.trackAgentVariantsCommitFailed?.({
-                    sessionId: args.sessionId,
-                    targetVariantId: args.variantId,
-                    mode: 'commit',
-                    requestStatus: 'failed',
-                    failureReason: 'feature_disabled',
-                });
-                throw new errors_1.AgentVariantsError('INVALID_STAGE_ACTION', 'Variant send is not enabled.');
-            }
-            const result = await deps.orchestrator.commitVariant({
-                sessionId: args.sessionId,
-                variantId: args.variantId,
-            });
-            const out = {
-                stage: deps.orchestrator.getStage(args.sessionId),
-                enqueued: result.enqueued,
-                duplicate: result.duplicate,
-                changedFilesCount: result.changedFilesCount,
-                payloadKind: result.payloadKind,
-                destinationPath: result.destinationPath,
-            };
-            return jsonResponse(out);
-        }
-        catch (err) {
-            return errorResponse(err);
-        }
-    });
-    /**
-     * Snapshot the variant-request FIFO depth at response-build time as the
-     * `pendingVariantRequests` field. Read AFTER any batch a call consumed, so it
-     * tells the agent how many MORE batches are still queued (`> 0` ⇒ keep
-     * draining). Returns an empty object when no accessor is wired (unit tests).
-     */
-    const pendingVariantRequestsField = () => deps.pendingVariantRequestCount
-        ? { pendingVariantRequests: deps.pendingVariantRequestCount() }
-        : {};
-    registerVariantTool(mcp, 'continue_variants', 'Long-poll/state-pump the variants flow. action=check returns immediately; action=wait blocks up to ~5min for state changes; action=request_work picks up ready work items (source_research, static_preview, or code_gen depending on stage). For request_work, pass `workItemIds` (e.g. the ids a static_preview_refine batch reported) to lease ONLY that batch — letting concurrent runs handle their own work in parallel; omit it (optionally with requestedLeaseCount) to lease the next ready items. A re-leased work item carrying `input.qaRetry` failed the diff QA gate — read the QA notes, edit the worktree until the diff shows CSS or markup changes, then report_work_item(kind=status) again (one retry max). static_preview is for fresh zero-to-one sessions and should return {html, css?, js?} so Rivet can show fast visual previews before Vite/code generation finishes.', contracts_1.continueVariantsInput, async (args) => {
-        try {
-            const stage = deps.orchestrator.getStage(args.sessionId);
-            if (args.action === 'refine_variant') {
-                if (!args.variantId || !args.instruction) {
-                    throw new errors_1.AgentVariantsError('MISSING_REQUIRED_INPUT', 'continue_variants(action="refine_variant") requires variantId and instruction');
-                }
-                const lease = deps.orchestrator.refineVariant({
-                    sessionId: args.sessionId,
-                    variantId: args.variantId,
-                    instruction: args.instruction,
-                    leaseOwner: deps.leaseOwner(),
-                });
-                return jsonResponse({
-                    stage: 'work_items_ready',
-                    leaseId: lease.leaseId,
-                    leaseTtlMs: lease.leaseTtlMs,
-                    leasedWorkItems: lease.leasedWorkItems,
-                });
-            }
-            if (stage === 'awaiting_briefs') {
-                // continue_variants while still awaiting briefs means the agent
-                // hasn't run the brief work item yet — that's a programming error.
-                throw new errors_1.AgentVariantsError('INVALID_STAGE_ACTION', "Run the brief work item and call report_work_item(kind='brief') before continue_variants");
-            }
-            if (stage === 'awaiting_approval') {
-                const briefs = deps.orchestrator.getBriefs(args.sessionId);
-                return jsonResponse({
-                    stage: 'awaiting_approval',
-                    briefs,
-                    approvalPrompt: buildApprovalPrompt(briefs),
-                });
-            }
-            if (args.action === 'request_work' &&
-                (stage === 'awaiting_source_plan' ||
-                    stage === 'work_items_ready' ||
-                    stage === 'waiting_for_results')) {
-                // SessionStore.requestWork accepts both stages and expires stale
-                // leases before issuing new ones, so this also recycles wedged
-                // variants whose leases expired while the session was already in
-                // waiting_for_results.
-                const lease = deps.orchestrator.requestWork({
-                    sessionId: args.sessionId,
-                    leaseOwner: deps.leaseOwner(),
-                    requestedLeaseCount: args.requestedLeaseCount,
-                    ...(args.workItemIds ? { workItemIds: args.workItemIds } : {}),
-                });
-                const postLeaseStage = deps.orchestrator.getStage(args.sessionId);
-                const leasePayload = {
-                    leaseId: lease.leaseId,
-                    leaseTtlMs: lease.leaseTtlMs,
-                    leasedWorkItems: lease.leasedWorkItems,
-                    ...pendingVariantRequestsField(),
-                };
-                return jsonResponse(postLeaseStage === 'awaiting_source_plan'
-                    ? { stage: 'awaiting_source_plan', ...leasePayload }
-                    : { stage: 'work_items_ready', ...leasePayload });
-            }
-            if (stage === 'work_items_ready' || stage === 'waiting_for_results') {
-                return jsonResponse({
-                    stage: 'waiting_for_results',
-                    progress: deps.orchestrator.getProgress(args.sessionId),
-                    ...pendingVariantRequestsField(),
-                });
-            }
-            if (stage === 'awaiting_source_plan') {
-                return jsonResponse({
-                    stage: 'awaiting_source_plan',
-                    progress: deps.orchestrator.getProgress(args.sessionId),
-                    ...pendingVariantRequestsField(),
-                });
-            }
-            // Terminal stages
-            {
-                const summary = deps.orchestrator.getSummary(args.sessionId);
-                const variants = deps.orchestrator.getVariants(args.sessionId);
-                const previewUrls = variants
-                    .filter((v) => v.preview?.kind === 'static_artifact')
-                    .map((v) => ({
-                    label: v.label,
-                    url: v.preview.url,
-                }));
-                const qaSurfacing = buildQaSurfacing(variants);
-                return jsonResponse({
-                    stage,
-                    summary,
-                    ...(previewUrls.length > 0 ? { previewUrls } : {}),
-                    ...qaSurfacing,
-                    ...pendingVariantRequestsField(),
-                });
-            }
-        }
-        catch (err) {
-            return errorResponse(err);
-        }
-    });
-    const handleReportComplete = async (args) => {
-        try {
-            const result = await deps.orchestrator.reportComplete({
-                sessionId: args.sessionId,
-                workItemId: args.workItemId,
-                leaseId: args.leaseId,
-                attempt: args.attempt,
-                status: args.status,
-                output: (0, exports.normalizeAgentOutput)(args.output),
-                error: args.error,
-                tokensIn: args.tokensIn,
-                tokensOut: args.tokensOut,
-                model: args.model,
-                title: args.title,
-                description: args.description,
-            });
-            deps.completeVariantRequestWork?.({
-                sessionId: args.sessionId,
-                workItemId: args.workItemId,
-                status: args.status,
-                requeuedForRegeneration: result.requeuedForRegeneration,
-                aborted: result.aborted,
-            });
-            let out;
-            if (result.aborted) {
-                // The work item was removed/cancelled mid-flight. Tell the agent to
-                // drop it now rather than retry against a cleared lease.
-                out = {
-                    aborted: true,
-                    stage: result.stage,
-                    progress: result.progress,
-                };
-            }
-            else if (result.stage === 'ready' ||
-                result.stage === 'degraded' ||
-                result.stage === 'failed' ||
-                result.stage === 'cancelled') {
-                const summary = result.summary ?? deps.orchestrator.getSummary(args.sessionId);
-                const variants = deps.orchestrator.getVariants(args.sessionId);
-                const previewUrls = variants
-                    .filter((v) => v.preview?.kind === 'static_artifact')
-                    .map((v) => ({
-                    label: v.label,
-                    url: v.preview.url,
-                }));
-                const qaSurfacing = buildQaSurfacing(variants);
-                out = {
-                    stage: result.stage,
-                    summary,
-                    ...(previewUrls.length > 0 ? { previewUrls } : {}),
-                    ...qaSurfacing,
-                };
-            }
-            else if (result.requeuedForRegeneration) {
-                // The variant was rejected by the diff QA gate and reset to
-                // pending for its one regeneration. Tell the agent explicitly to
-                // re-lease and regenerate — a bare waiting_for_results reply looks
-                // identical to a sibling still in flight, so without this the agent
-                // abandons the variant and the session sticks at ready:0.
-                const label = deps.orchestrator
-                    .getVariants(args.sessionId)
-                    .find((v) => v.workItemId === args.workItemId)?.label;
-                out = {
-                    stage: 'waiting_for_results',
-                    progress: result.progress,
-                    regenerate: true,
-                    qaPrompt: buildRegeneratePrompt(label, result.qa),
-                    ...(result.qa
-                        ? { qa: [{ workItemId: args.workItemId, label, qa: result.qa }] }
-                        : {}),
-                };
-            }
-            else {
-                out = {
-                    stage: 'waiting_for_results',
-                    progress: result.progress,
-                };
-            }
-            return jsonResponse(out);
-        }
-        catch (err) {
-            return errorResponse(err);
-        }
-    };
-    registerVariantTool(mcp, 'report_work_item', 'Unified hand-back for a work item. `kind` selects the payload:\n' +
-        "• kind='brief' (brief work item) — pass `briefs` (one per direction) and optional `bindings`. Each brief: label = a 1–5 word plain-English title naming what THIS direction changes (describe the change, not the vibe — no marketing adjectives; a standalone title, never a \"Title — descriptor\" compound). body = one or two plain-English sentences describing the complete direction and the page scope it must preserve. Keep the original deliverable intact. On success every brief starts immediately (no in-chat approval gate) and the session lands in work_items_ready.\n" +
-        "• kind='source_plan' (source_plan work item) — pass `sourcePlan` { actions, metadata, bindings?, executionPlan }. Inspect raw userContext natively, choose actions from input.availableActions, and report the metadata they produce (extract_design_system → design_system, describe_motion → motion_guidance). For URL sources, call `capture_design_evidence({ sessionId, url })` FIRST and synthesize design_system.data.designMarkdown from that rendered evidence, setting data.evidenceStatus accordingly — Rivet rejects URL-backed design_system reports without a recorded capture_design_evidence attempt. Choose vite_app for large local assets / model-viewer / Three.js / route structure / package deps / files under public/; choose static_preview only when one HTML/CSS/JS file preserves the full scope. If ambiguous, set executionPlan.userQuestion instead of guessing. Unlocks the brief work item.\n" +
-        "• kind='status' (per-work-item status) — requires `leaseId` + `status` (running heartbeat | succeeded | failed | cancelled) with the matching `attempt` from continue_variants(action='request_work'). For existing-project code_gen items, verify the worktree diff includes CSS or markup changes before status=\"succeeded\" (empty/deletion-only diffs fail QA and trigger a one-time re-lease). OUTPUT SHAPE per work-item kind: static_preview succeeded MUST pass output = { html, css?, js?, assetBase? } — inline the full HTML (Rivet renders it directly; disk file lists do NOT work). If the HTML references sibling files, write them under a dir inside input.projectContext.workspacePath and pass that dir as assetBase. For a forked Vary variant (input carries sourceLabel/sourceBody + instruction) ALSO pass title (≤6 words) and description (one sentence) synthesizing the parent identity with the requested change. code_gen / scaffold_base succeeded passes the captured diff in output. Optionally include tokensIn/tokensOut/model for cost instrumentation. ABORT: if the response is { aborted: true }, the user removed this direction — stop immediately, do NOT retry, move on. Send periodic status=\"running\" heartbeats on long generations to pick up aborts early.\n" +
-        'All kinds share the lease header { sessionId, workItemId, attempt }. Full protocol in the rivet skill.', contracts_1.reportWorkItemInput, async (args) => {
-        try {
-            if (args.kind === 'brief') {
-                if (!args.briefs || args.briefs.length === 0) {
-                    throw new errors_1.AgentVariantsError('MISSING_REQUIRED_INPUT', "report_work_item(kind='brief') requires a non-empty briefs array");
-                }
-                return await handleReportBriefs({
-                    sessionId: args.sessionId,
-                    workItemId: args.workItemId,
-                    attempt: args.attempt,
-                    leaseId: args.leaseId,
-                    briefs: args.briefs,
-                    bindings: args.bindings,
-                });
-            }
-            if (args.kind === 'source_plan') {
-                if (!args.sourcePlan) {
-                    throw new errors_1.AgentVariantsError('MISSING_REQUIRED_INPUT', "report_work_item(kind='source_plan') requires sourcePlan");
-                }
-                return await handleReportSourcePlan({
-                    sessionId: args.sessionId,
-                    workItemId: args.workItemId,
-                    attempt: args.attempt,
-                    leaseId: args.leaseId,
-                    sourcePlan: args.sourcePlan,
-                });
-            }
-            // kind === 'status'
-            if (!args.leaseId || !args.status) {
-                throw new errors_1.AgentVariantsError('MISSING_REQUIRED_INPUT', "report_work_item(kind='status') requires leaseId and status");
-            }
-            return await handleReportComplete({
-                sessionId: args.sessionId,
-                workItemId: args.workItemId,
-                leaseId: args.leaseId,
-                attempt: args.attempt,
-                status: args.status,
-                output: args.output,
-                error: args.error,
-                tokensIn: args.tokensIn,
-                tokensOut: args.tokensOut,
-                model: args.model,
-                title: args.title,
-                description: args.description,
-            });
-        }
-        catch (err) {
-            return errorResponse(err);
-        }
-    });
-    registerVariantTool(mcp, 'cancel_variants', 'Cancel variant work. Pass `variantId` to cancel ONLY that variant within an in-flight session (siblings keep generating) — idempotent on terminal states (already cancelled / succeeded / failed returns alreadyTerminal=true with the actual finalStatus); this is what the Rivet UI calls when the user clicks the cancel button on a variant card. Omit `variantId` to cancel the ENTIRE session — stops accepting new work, marks running items cancelled, and triggers cleanup. Per-variant worktree teardown happens at session commit/cancel time.', contracts_1.cancelVariantsInput, async (args) => {
-        try {
-            if (args.variantId) {
-                const result = await deps.orchestrator.cancelVariant({
-                    sessionId: args.sessionId,
-                    variantId: args.variantId,
-                    reason: args.reason,
-                });
-                const out = {
-                    sessionId: result.sessionId,
-                    variantId: result.variantId,
-                    finalStatus: result.finalStatus,
-                    sessionStage: result.sessionStage,
-                    alreadyTerminal: result.alreadyTerminal,
-                };
-                return jsonResponse(out);
-            }
-            const result = await deps.orchestrator.cancel({
-                sessionId: args.sessionId,
-                reason: args.reason,
-            });
-            const out = {
-                stage: 'cancelled',
-                cleanupStatus: result.cleanupStatus,
-            };
-            return jsonResponse(out);
-        }
-        catch (err) {
-            return errorResponse(err);
-        }
-    });
-    registerVariantTool(mcp, 'start_variants', 'Single-call kickoff for variants exploration, and the single entry point for fresh projects. Spawns N variant worktrees, opens the visual editor, and returns the variant work items + worktreePaths — no follow-up open_visual_editor / continue_variants needed for the initial generation lease. Pass `briefs` (one per variant) so each card has a distinct, plain-English name (a 1–5 word title naming what the direction changes) and description; omitting them derives a shared run-intent label per variant from `runLabel`/the prompt (e.g. "Brighter 1", "Brighter 2") with the prompt as each description — the same fallback for fresh and existing. Also pass `runLabel` — a 1–2 word label for the whole run\'s intent (e.g. prompt "make it brighter" → "Brighter"), shown as a tag on every variant row. `briefs.length` sets the count. mode="existing" for existing projects, "zero_to_one" for fresh projects. For source-grounded runs pass `userContext` — an array of raw sources ({transport:"url",url} | {transport:"file_path",path} | {transport:"directory_path",path} | {transport:"text",content}). With mode="zero_to_one" this runs the source-research flow and returns stage="awaiting_source_plan" instead of work_items_ready; with mode="existing" the raw context is threaded into each variant\'s code-gen. When the response includes visualEditor/editorNextAction, start or resume the hosted watch_for_changes loop on visualEditor.sessionId; direct start_variants is a kickoff tool, not a durable watcher. Full protocol in the rivet skill.', contracts_1.startVariantsInput, async (args) => {
-        const requestTelemetry = startVariantsTelemetryFor(args);
-        deps.telemetry?.trackAgentVariantsRequestStarted?.(requestTelemetry);
-        try {
-            const out = args.mode === 'zero_to_one'
-                ? await handleStartVariantsZeroToOne(args, deps)
-                : await handleStartVariantsExisting(args, deps);
-            if (out.stage === 'failed') {
-                deps.telemetry?.trackAgentVariantsRequestRejected?.({
-                    ...requestTelemetry,
-                    failureReason: out.errorCode,
-                });
-                return jsonResponse(out);
-            }
-            deps.telemetry?.trackAgentVariantsRequestAccepted?.({
-                ...requestTelemetry,
-                sessionId: out.sessionId,
-                requestStatus: 'accepted',
-                acceptedCount: out.stage === 'work_items_ready'
-                    ? out.variants.length
-                    : requestTelemetry.requestedCount,
-                workItemCount: out.stage === 'work_items_ready'
-                    ? out.variants.length
-                    : undefined,
-            });
-            // The user has now kicked off a variants run — retire the first-run
-            // onboarding nudge (idempotent; only the first call writes).
-            deps.markFirstVariantsRun?.();
-            return jsonResponse(out);
-        }
-        catch (err) {
-            deps.telemetry?.trackAgentVariantsRequestRejected?.({
-                ...requestTelemetry,
-                failureReason: err,
-            });
-            return errorResponse(err);
-        }
-    });
-    const variantHistory = deps.variantHistory ?? new VariantHistoryService_1.VariantHistoryService();
-    // Shared by the list and detail modes of list_past_variants. Defaulting to
-    // `process.cwd()` reads the wrong tree when the active visual editor is bound
-    // to a generated project folder, so prefer the editor's project path.
-    const resolveHistoryProjectPath = (projectPathArg) => {
-        const projectPath = projectPathArg ?? deps.getProjectPath?.() ?? process.cwd();
-        if (!path_1.default.isAbsolute(projectPath)) {
-            throw new errors_1.AgentVariantsError('SCHEMA_VALIDATION_FAILED', `projectPath must be absolute; got '${projectPath}'.`);
-        }
-        return projectPath;
-    };
-    registerVariantTool(mcp, 'list_past_variants', "Read persisted variants for the current project from `<projectPath>/.rivet/variants/`. LIST mode (default): returns a newest-first summary list — filter by `status` (completed | committed | rejected | cancelled) or cap with `limit`. DETAIL mode: pass BOTH `sessionId` and `variantId` to fetch one variant's manifest plus its diff body (kind=diff) or file list (kind=project-created); pass `includeBody: false` to skip the diff/file list when you just need metadata. Defaults to the active editor session's project path; falls back to the MCP server cwd when no editor is open.", contracts_1.listPastVariantsInput, async (args) => {
-        try {
-            const projectPath = resolveHistoryProjectPath(args.projectPath);
-            // DETAIL mode (merged from the former get_variant tool): both
-            // sessionId and variantId identify a single persisted variant.
-            if (args.sessionId || args.variantId) {
-                if (!args.sessionId || !args.variantId) {
-                    throw new errors_1.AgentVariantsError('MISSING_REQUIRED_INPUT', 'Detail mode requires both sessionId and variantId; omit both for the newest-first list.');
-                }
-                const detail = await variantHistory.getVariant({
-                    projectPath,
-                    sessionId: args.sessionId,
-                    variantId: args.variantId,
-                });
-                if (!detail) {
-                    throw new errors_1.AgentVariantsError('WORK_ITEM_NOT_FOUND', `No persisted variant for session ${args.sessionId} variant ${args.variantId} under ${projectPath}/.rivet/variants/.`);
-                }
-                const includeBody = args.includeBody !== false;
-                const detailOut = {
-                    projectPath,
-                    variant: {
-                        sessionId: detail.manifest.sessionId,
-                        variantId: detail.manifest.variantId,
-                        ...(detail.manifest.requestId
-                            ? { requestId: detail.manifest.requestId }
-                            : {}),
-                        label: detail.manifest.label,
-                        brief: detail.manifest.brief,
-                        kind: manifestKind(detail.manifest),
-                        status: detail.manifest.status,
-                        createdAt: detail.manifest.createdAt,
-                        statusChangedAt: detail.manifest.statusChangedAt,
-                        changedFilesCount: detail.manifest.changedFilesCount,
-                        sessionPrompt: detail.manifest.sessionPrompt,
-                        baseSha: detail.manifest.baseSha,
-                        destinationPath: detail.manifest.destinationPath,
-                        artifact: detail.manifest.artifact,
-                        preview: detail.manifest.preview,
-                        ...(detail.manifest.designSource
-                            ? { designSource: detail.manifest.designSource }
-                            : {}),
-                        ...(includeBody && detail.diff !== undefined
-                            ? { diff: detail.diff }
-                            : {}),
-                        ...(includeBody && detail.files !== undefined
-                            ? { files: detail.files }
-                            : {}),
-                        ...(includeBody && detail.designMarkdown !== undefined
-                            ? { designMarkdown: detail.designMarkdown }
-                            : {}),
-                    },
-                };
-                return jsonResponse(detailOut);
-            }
-            const entries = await variantHistory.listVariants({
-                projectPath,
-                limit: args.limit,
-                status: args.status,
-            });
-            // Removed and cancelled variants are retained on disk but never
-            // surfaced in the default history listing — only when explicitly
-            // queried with the matching status filter.
-            const visibleEntries = args.status === 'removed'
-                ? entries
-                : entries.filter((entry) => entry.manifest.status !== 'removed' &&
-                    (args.status === 'cancelled' ||
-                        entry.manifest.status !== 'cancelled'));
-            const summaries = visibleEntries.map((entry) => ({
-                sessionId: entry.manifest.sessionId,
-                variantId: entry.manifest.variantId,
-                ...(entry.manifest.requestId
-                    ? { requestId: entry.manifest.requestId }
-                    : {}),
-                label: entry.manifest.label,
-                brief: entry.manifest.brief,
-                kind: manifestKind(entry.manifest),
-                status: entry.manifest.status,
-                createdAt: entry.manifest.createdAt,
-                statusChangedAt: entry.manifest.statusChangedAt,
-                changedFilesCount: entry.manifest.changedFilesCount,
-                artifact: entry.manifest.artifact,
-                preview: entry.manifest.preview,
-            }));
-            const out = {
-                projectPath,
-                variants: summaries,
-            };
-            return jsonResponse(out);
-        }
-        catch (err) {
-            return errorResponse(err);
-        }
-    });
-}
-// --- Helpers --------------------------------------------------------------
-// Return type is left implicit so the MCP SDK's overload selection picks the
-// raw-shape variant; tagging an explicit interface here breaks the index
-// signature the SDK expects.
-function jsonResponse(payload) {
-    return {
-        content: [
-            {
-                type: 'text',
-                text: JSON.stringify(payload),
-            },
-        ],
-    };
-}
-function errorResponse(err) {
-    const code = err instanceof errors_1.AgentVariantsError ? err.code : 'SCHEMA_VALIDATION_FAILED';
-    const message = err instanceof Error ? err.message : 'Unknown error in agent-variants tool';
-    return {
-        content: [
-            {
-                type: 'text',
-                text: JSON.stringify({
-                    stage: 'failed',
-                    errorCode: code,
-                    message,
-                }),
-            },
-        ],
-        isError: true,
-    };
-}
-function assertExplicitUserConfirmation(toolName, confirmation, actionLabel) {
-    if (confirmation.confirmedByUser) {
-        return;
-    }
-    if (confirmation.bypassRequestedByUser &&
-        confirmation.bypassReason?.trim().length) {
-        return;
-    }
-    throw new errors_1.AgentVariantsError('MISSING_REQUIRED_INPUT', `${toolName} requires explicit user confirmation to ${actionLabel}. Set confirmedByUser=true after user confirmation, or set bypassRequestedByUser=true with bypassReason when the user explicitly asks to bypass.`);
-}
-function buildApprovalPrompt(briefs) {
-    const formattedBriefs = briefs
-        .map((brief, index) => `${index + 1}. name: ${brief.label}\n   description: ${brief.body}`)
-        .join('\n');
-    return (`Review these variant briefs:\n${formattedBriefs}\n\n` +
-        'Do these look good, or do you want any adjustments before I proceed?');
-}
-/**
- * Compose the QA surfacing block (`qaPrompt`, `qa[]`) attached to terminal
- * tool responses. Returns an empty object when no variant has a recorded
- * QA verdict so existing-project flows (which never trigger preview QA)
- * remain a no-op.
- *
- * Exported indirectly via the orchestrator's terminal tool responses so
- * the calling agent can show the user a concrete retry/continue/cancel
- * choice when one or more variants fail QA.
- */
-function buildQaSurfacing(variants) {
-    const withQa = variants.filter((v) => Boolean(v.qa) && v.qa.status !== 'not_run');
-    if (withQa.length === 0)
-        return {};
-    const qaEntries = withQa.map((v) => ({
-        workItemId: v.workItemId,
-        label: v.label,
-        qa: v.qa,
-    }));
-    const failures = withQa.filter((v) => v.qa.status === 'failed');
-    if (failures.length === 0) {
-        return { qa: qaEntries };
-    }
-    return {
-        qa: qaEntries,
-        qaPrompt: buildQaFailurePrompt(failures.map((v) => ({ label: v.label, qa: v.qa })), withQa.length - failures.length),
-    };
-}
-/**
- * User-facing prompt template for QA failures. Lists each failed variant
- * with its summary + first asset/console issue, then asks the user
- * whether to retry, continue with healthy variants, or cancel. Kept as
- * data (not a log line) so the calling agent can present the choice
- * directly to the human.
- */
-function buildQaFailurePrompt(failures, healthyCount) {
-    if (failures.length === 0) {
-        return '';
-    }
-    const lines = failures.map((failure) => {
-        const firstIssue = failure.qa.issues[0];
-        const issueDetail = firstIssue
-            ? ` (${describeIssue(firstIssue.kind)}: ${firstIssue.detail}${firstIssue.message ? ` — ${firstIssue.message}` : ''})`
-            : '';
-        return `• ${failure.label}: ${failure.qa.summary}${issueDetail}`;
-    });
-    const healthyLine = healthyCount > 0
-        ? `\n\n${healthyCount} other variant${healthyCount === 1 ? '' : 's'} passed QA and can still be committed.`
-        : '';
-    const intro = failures.length === 1
-        ? '1 variant failed QA:'
-        : `${failures.length} variants failed QA:`;
-    return `${intro}\n${lines.join('\n')}${healthyLine}\n\nWould you like to retry the failed variant${failures.length === 1 ? '' : 's'}, continue with healthy variants only, or cancel?`;
-}
-/**
- * Compose the agent-facing instruction for a variant the QA gate re-queued
- * for its single regeneration. Names the variant, surfaces the QA notes, and
- * spells out the exact next call so the agent re-leases and regenerates
- * instead of treating `waiting_for_results` as "nothing to do".
- */
-function buildRegeneratePrompt(label, qa) {
-    const name = label ? `"${label}"` : 'This variant';
-    const detail = qa?.summary;
-    const notes = detail ? `\n\nQA notes: ${detail}` : '';
-    return (`${name} did not pass the QA gate and was re-queued for ONE regeneration — ` +
-        'it is no longer counted as done. Call ' +
-        "continue_variants(action='request_work') to re-lease it (it carries the " +
-        "QA notes on its input), address the feedback, then report_work_item(kind='status') " +
-        `again. This is its only retry.${notes}`);
-}
-const describeIssue = (kind) => {
-    switch (kind) {
-        case 'asset_load_failed':
-            return 'asset load failed';
-        case 'console_error':
-            return 'console/runtime error';
-        case 'preview_unavailable':
-            return 'preview unavailable';
-        case 'design_quality':
-            return 'design quality below bar';
-    }
-};
-/**
- * Handle the zero-to-one branch of `start_variants` — the single entry point
- * for fresh projects. Prompt-only sessions take the single-call path
- * (`startUnified` → `work_items_ready`). Source-grounded sessions (inspiration
- * URLs / source artifacts) delegate to `kickoffSourceGroundedZeroToOne`, which
- * runs the source-research flow and returns a multi-step `awaiting_*` stage.
- */
-async function handleStartVariantsZeroToOne(args, deps) {
-    const framework = args.framework ?? 'vite';
-    if (framework !== 'vite') {
-        return {
-            stage: 'failed',
-            errorCode: 'UNSUPPORTED_FRAMEWORK',
-            message: `start_variants(mode='zero_to_one') only supports framework='vite'; got '${framework}'.`,
-        };
-    }
-    // Source-grounded sessions (raw user context — inspiration URLs, images,
-    // videos, files, directories, or pasted text) need the source-research flow.
-    // Route them through the shared kickoff, which returns a multi-step
-    // `awaiting_*` stage rather than `work_items_ready` — the agent inspects raw
-    // context, reports a source plan, then continues.
-    const hasUserContext = (args.userContext?.length ?? 0) > 0;
-    if (hasUserContext) {
-        const out = await (0, createZeroToOneTool_1.kickoffSourceGroundedZeroToOne)({
-            prompt: args.prompt,
-            count: args.count,
-            destinationParent: args.destinationParent,
-            framework: args.framework,
-            userContext: args.userContext,
-        }, deps);
-        if (out.stage === 'failed')
-            return out;
-        return {
-            ...out,
-            mode: 'zero_to_one',
-            ...(out.visualEditor
-                ? {
-                    editorNextAction: buildVisualEditorWatchAction(out.visualEditor.sessionId, 'after_variant_work_dispatch'),
-                }
-                : {}),
-        };
-    }
-    // Prompt-only: single-call path. Shared destination derivation with the
-    // source-grounded kickoff — resolve the destination parent (arg → open
-    // editor project → cwd), slugify, collapse any nested `.rivet/`, and create
-    // `<workspaceRoot>/.rivet/`.
-    const cwd = deps.cwd ?? (() => process.cwd());
-    const dest = (0, generatedDestination_1.deriveGeneratedDestination)({
-        prompt: args.prompt,
-        destinationParent: args.destinationParent,
-        editorProjectPath: deps.getProjectPath?.() ?? undefined,
-        cwd,
-    });
-    if (!dest.ok) {
-        return {
-            stage: 'failed',
-            errorCode: dest.errorCode,
-            message: dest.message,
-        };
-    }
-    const { workspaceRoot, destinationPath } = dest;
-    const projectContext = {
-        kind: 'fresh',
-        workspacePath: destinationPath,
-        workspaceRoot,
-        framework: 'vite',
-    };
-    const visualEditor = deps.ensureVisualEditorOpen
-        ? await deps.ensureVisualEditorOpen({
-            projectPath: destinationPath,
-            workspaceRoot,
-            framework: 'vite',
-        })
-        : undefined;
-    const result = await deps.orchestrator.startUnified({
-        prompt: args.prompt,
-        count: args.count,
-        target: args.target,
-        projectContext,
-        runLabel: args.runLabel,
-        leaseOwner: deps.leaseOwner(),
-        briefs: args.briefs,
-        ...(args.requestId ? { requestId: args.requestId } : {}),
-    });
-    const response = assembleStartVariantsResponse({
-        mode: 'zero_to_one',
-        result,
-        destinationPath,
-        visualEditor,
-        ...(deps.pendingVariantRequestCount
-            ? { pendingVariantRequests: deps.pendingVariantRequestCount() }
-            : {}),
-    });
-    claimStartVariantsRequestLease(args, deps, response);
-    return response;
-}
-/**
- * Handle the existing-project branch of `start_variants`. Detects the
- * project's framework server-side (cwd or the provided projectPath) so
- * the agent doesn't need a separate project-detection call, auto-opens the
- * visual editor on the resolved projectPath, and leases all variant
- * work items so they're ready to code in the same response.
- */
-async function handleStartVariantsExisting(args, deps) {
-    const cwd = deps.cwd ?? (() => process.cwd());
-    const resolvedProjectPath = args.requestId
-        ? (deps.resolveVariantRequestProjectPath?.(args.requestId) ?? null)
-        : null;
-    if (args.requestId && !args.projectPath && !resolvedProjectPath) {
-        return {
-            stage: 'failed',
-            errorCode: 'SCHEMA_VALIDATION_FAILED',
-            message: `Could not resolve projectPath for requestId '${args.requestId}'. Pass projectPath explicitly or retry from the active visual editor session.`,
-        };
-    }
-    const projectPath = args.projectPath ?? resolvedProjectPath ?? cwd();
-    if (!path_1.default.isAbsolute(projectPath)) {
-        return {
-            stage: 'failed',
-            errorCode: 'SCHEMA_VALIDATION_FAILED',
-            message: `projectPath must be absolute; got '${projectPath}'.`,
-        };
-    }
-    let framework;
-    try {
-        framework = new ProjectDetectionService_1.ProjectDetectionService().detectFramework(projectPath);
-    }
-    catch (err) {
-        const msg = err instanceof Error ? err.message : 'Unknown detection error';
-        return {
-            stage: 'failed',
-            errorCode: 'SCHEMA_VALIDATION_FAILED',
-            message: `Could not detect project at '${projectPath}': ${msg}. Ensure it has a package.json, or pass projectPath explicitly.`,
-        };
-    }
-    // Auto-open the editor for the modes the visual-editor attach hooks support —
-    // 'vite' (scaffolded apps) and 'static' (empty / HTML-only workspaces, which
-    // open in static mode with no dev server). For other frameworks (next, etc.)
-    // the agent opens the editor itself via the standalone open_visual_editor
-    // tool. workspaceRoot === projectPath for existing-project sessions — there's
-    // no subproject nesting, the project is the workspace.
-    const editorFramework = framework === 'vite' || framework === 'static' ? framework : undefined;
-    const ensureExistingEditorOpen = deps.ensureExistingVisualEditorOpen ?? deps.ensureVisualEditorOpen;
-    const visualEditor = ensureExistingEditorOpen && editorFramework
-        ? await ensureExistingEditorOpen({
-            projectPath,
-            workspaceRoot: projectPath,
-            framework: editorFramework,
-        })
-        : undefined;
-    // Existing-project source grounding: store any raw userContext as a
-    // read-only context bundle and thread it into the code_gen work items. No
-    // source_plan stage runs for existing projects (single-call kickoff is
-    // preserved) — the agent reads the raw sources directly during code-gen.
-    const sessionId = (0, crypto_1.randomUUID)();
-    const variantContext = (args.userContext?.length ?? 0) > 0
-        ? (0, variantContext_1.createVariantContextBundle)({
-            sessionId,
-            prompt: args.prompt,
-            workspaceRoot: projectPath,
-            userContextInputs: args.userContext,
-            allowedRoots: [projectPath, cwd()],
-        })
-        : undefined;
-    const result = await deps.orchestrator.startUnified({
-        prompt: args.prompt,
-        count: args.count,
-        target: args.target,
-        sessionId,
-        projectContext: {
-            kind: 'existing',
-            projectPath,
-            ...(args.designContext ? { designContext: args.designContext } : {}),
-            ...(variantContext ? { variantContext } : {}),
-        },
-        runLabel: args.runLabel,
-        leaseOwner: deps.leaseOwner(),
-        briefs: args.briefs,
-        ...(args.requestId ? { requestId: args.requestId } : {}),
-        // Sequential Varys on a live existing-project session accumulate into it
-        // rather than superseding it (the inline-element flow opts out).
-        allowAccumulate: true,
-        ...(args.sourceVariantId ? { sourceVariantId: args.sourceVariantId } : {}),
-    });
-    const response = assembleStartVariantsResponse({
-        mode: 'existing',
-        result,
-        project: { projectPath, framework },
-        visualEditor,
-        ...(deps.pendingVariantRequestCount
-            ? { pendingVariantRequests: deps.pendingVariantRequestCount() }
-            : {}),
-    });
-    claimStartVariantsRequestLease(args, deps, response);
-    return response;
-}
-/**
- * Binds a visual-editor request to variant work only after the agent response
- * includes the work items needed to complete that request.
- */
-function claimStartVariantsRequestLease(args, deps, response) {
-    if (!args.requestId || response.stage !== 'work_items_ready')
-        return;
-    deps.claimVariantRequestLease?.({
-        requestId: args.requestId,
-        sessionId: response.sessionId,
-        workItemIds: response.variants.map((variant) => variant.variantId),
-    });
-}
-/**
- * Build the StartVariantsOutput from a startUnified result + the lease
- * info it surfaced. Pairs each variant in the original `variants` list
- * with its `leasedWorkItems[]` entry from requestWork so the agent sees
- * one consistent per-variant object with everything it needs.
- */
-function assembleStartVariantsResponse(args) {
-    const { result } = args;
-    if (result.leaseId === undefined ||
-        result.leaseTtlMs === undefined ||
-        result.leasedWorkItems === undefined) {
-        return {
-            stage: 'failed',
-            errorCode: 'INVALID_STAGE_ACTION',
-            message: 'start_variants expected startUnified to start the variants but none were returned.',
-        };
-    }
-    const itemById = new Map(result.leasedWorkItems.map((item) => [item.id, item]));
-    const variants = [];
-    for (const v of result.variants) {
-        const workItem = itemById.get(v.variantId);
-        if (!workItem) {
-            return {
-                stage: 'failed',
-                errorCode: 'INVALID_STAGE_ACTION',
-                message: `start_variants leased fewer items than variants — missing workItem for ${v.variantId}.`,
-            };
-        }
-        variants.push({ ...v, workItem });
-    }
-    return {
-        sessionId: result.sessionId,
-        stage: 'work_items_ready',
-        mode: args.mode,
-        leaseId: result.leaseId,
-        leaseTtlMs: result.leaseTtlMs,
-        variants,
-        scaffoldBaseWorkItemId: result.scaffoldBaseWorkItemId,
-        ...(args.destinationPath ? { destinationPath: args.destinationPath } : {}),
-        ...(args.visualEditor ? { visualEditor: args.visualEditor } : {}),
-        ...(args.visualEditor
-            ? {
-                editorNextAction: buildVisualEditorWatchAction(args.visualEditor.sessionId, 'after_variant_work_dispatch'),
-            }
-            : {}),
-        ...(args.project ? { project: args.project } : {}),
-        ...(args.pendingVariantRequests !== undefined
-            ? { pendingVariantRequests: args.pendingVariantRequests }
-            : {}),
-        nextAction: 'report_work_item',
-    };
-}
-//# sourceMappingURL=tools.js.map