rivet-design 0.11.11 → 0.11.12

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

@@ -19,6 +19,17 @@ exports.DEFAULT_LEASE_TTL_MS = 20 * 60 * 1000;
  *  code_gen bump; scaffold timing has never bound, but a longer lease is safe. */
 exports.SCAFFOLD_LEASE_TTL_MS = 30 * 60 * 1000;
 const SYSTEM_CLOCK = { now: () => Date.now() };
+/** True when a work item is a past variant adopted into the active session
+ *  (see {@link SessionStore.appendAdoptedStaticVariant}). Adopted variants are
+ *  surfaced as session members but excluded from generation accounting. */
+function isAdoptedVariant(item) {
+    return Boolean(item.input.adoptedFrom);
+}
+/** True when a static preview is a Vary sibling forked from another variant. */
+function isForkedStaticPreviewVariant(item) {
+    return (item.kind === 'static_preview' &&
+        Boolean(item.input.sourceVariantId));
+}
 function fingerprint(parts) {
     return parts.map((p) => (p === undefined ? '∅' : String(p))).join('|');
 }
@@ -718,7 +729,23 @@ class SessionStore {
             }
             leasable = [target];
         }
-        const limit = args.requestedLeaseCount ?? leasable.length;
+        else if (args.workItemIds !== undefined) {
+            // Scoped lease: restrict to a specific batch's work items so concurrent
+            // owners (e.g. several watchers each handling their own Vary run) don't
+            // greedily lease each other's items. Leases whatever subset of the
+            // requested ids is still leasable; only errors if NONE are.
+            const wanted = new Set(args.workItemIds);
+            leasable = leasable.filter((item) => wanted.has(item.id));
+            if (leasable.length === 0) {
+                throw new errors_1.AgentVariantsError('INVALID_STAGE_ACTION', 'None of the requested work items are currently leasable (already leased, running, or done)');
+            }
+        }
+        // `workItemIds` takes precedence over `requestedLeaseCount`: a scoped batch
+        // leases ALL of its still-leasable items, not a count-capped subset (the
+        // scoping above already narrowed `leasable` to exactly that batch).
+        const limit = args.workItemIds !== undefined
+            ? leasable.length
+            : (args.requestedLeaseCount ?? leasable.length);
         const issued = leasable.slice(0, Math.max(0, limit));
         if (issued.length === 0) {
             throw new errors_1.AgentVariantsError('INVALID_STAGE_ACTION', 'No work items currently leasable (all running, blocked by deps, or done)');
@@ -811,6 +838,16 @@ class SessionStore {
         item.status = args.status;
         item.output = args.output;
         item.error = args.error;
+        // Apply an agent-synthesized title/description so the variant card shows a
+        // meaningful name (parent identity + the change) instead of the provisional
+        // instruction text. Only on success; capped so the label stays short.
+        if (args.status === 'succeeded' && (args.title || args.description)) {
+            const input = item.input;
+            if (args.title)
+                input.briefLabel = args.title.trim().slice(0, 80);
+            if (args.description)
+                input.briefBody = args.description.trim();
+        }
         item.acceptedReports.push(fp);
         item.lease = undefined;
         if (args.status === 'failed') {
@@ -824,21 +861,20 @@ class SessionStore {
         return result;
     }
     /**
-     * Re-open a succeeded variant work item for one aesthetic regeneration.
+     * Re-open a succeeded variant work item for one QA-driven regeneration.
      * Consumes the agent's report (validating the lease), then resets the item
      * to `pending` so it becomes leasable again via `request_work`, stashing the
-     * design critique onto its input so the re-leased descriptor carries the
-     * notes the agent must address before re-reporting.
+     * QA notes onto its input so the re-leased descriptor carries the notes the
+     * agent must address before re-reporting.
      *
      * The work item never reaches a terminal status, so the session stays in
-     * `waiting_for_results` and never goes terminal off the back of a
-     * design-quality failure. Idempotent on replay via the accepted-fingerprint
-     * cache.
+     * `waiting_for_results` and never goes terminal off the back of a QA
+     * failure. Idempotent on replay via the accepted-fingerprint cache.
      */
-    requeueForDesignCritique(args) {
+    requeueForRegeneration(args) {
         const session = this.requireSession(args.sessionId);
         const fp = fingerprint([
-            'requeueForDesignCritique',
+            'requeueForRegeneration',
             args.sessionId,
             args.workItemId,
             args.leaseId,
@@ -857,7 +893,7 @@ class SessionStore {
         item.output = undefined;
         item.error = undefined;
         const input = (item.input ?? {});
-        item.input = { ...input, designCritique: args.critique };
+        item.input = { ...input, qaRetry: args.qaRetry };
         const result = {
             stage: session.stage,
             progress: this.progressOf(session),
@@ -902,6 +938,8 @@ class SessionStore {
                 briefLabel: targetInput.briefLabel,
                 briefBody: targetInput.briefBody,
                 ...(args.currentHtml ? { currentHtml: args.currentHtml } : {}),
+                ...(args.targetElement ? { targetElement: args.targetElement } : {}),
+                ...(args.requestId ? { requestId: args.requestId } : {}),
                 projectContext: targetInput.projectContext ?? session.projectContext,
                 ...(targetInput.context ? { context: targetInput.context } : {}),
             },
@@ -912,6 +950,373 @@ class SessionStore {
         session.stage = 'work_items_ready';
         return item;
     }
+    /**
+     * Fork a completed static_preview variant into N NEW sibling variants. Unlike
+     * {@link createRefineVariantWorkItem} (which overwrites the source variant in
+     * place), each forked item is a fresh `static_preview` work item with its own
+     * id, seeded from the source variant's HTML (`currentHtml`) plus the user's
+     * instruction. This backs the "Vary" action, where `variantRequest.count`
+     * asks for N new explorations rather than an in-place edit. Returns the
+     * created items so the caller can lease them via the normal request-work path.
+     */
+    createForkedStaticPreviewWorkItems(args) {
+        const session = this.requireSession(args.sessionId);
+        const source = this.requireWorkItem(session, args.sourceVariantId);
+        if (source.kind !== 'static_preview' || source.status !== 'succeeded') {
+            throw new errors_1.AgentVariantsError('VARIANT_NOT_EDITABLE', 'Only completed static_preview variants can be varied');
+        }
+        if (session.variantPick) {
+            throw new errors_1.AgentVariantsError('PENDING_CHANGE_CONFLICT', 'Cannot vary a variant after one has already been sent');
+        }
+        const activeRefinement = [...session.workItems.values()].find((item) => {
+            if (item.kind !== 'refine_variant')
+                return false;
+            const input = item.input;
+            return (input.variantId === args.sourceVariantId &&
+                (item.status === 'pending' || item.status === 'running'));
+        });
+        if (activeRefinement) {
+            throw new errors_1.AgentVariantsError('PENDING_CHANGE_CONFLICT', 'Cannot vary a variant while an in-place refinement is pending or running');
+        }
+        const sourceInput = source.input;
+        const seedHtml = args.currentHtml ??
+            source.output?.html;
+        const total = Math.min(Math.max(Math.trunc(args.count) || 1, 1), contracts_1.VARIANT_COUNT_MAX);
+        // Label/describe forked variants by the CHANGE requested (the Vary
+        // instruction), not the source brief — otherwise every run on the same
+        // variant reads identically ("<source> · variation N") and concurrent runs
+        // are indistinguishable in the Directions list.
+        const instruction = args.instruction.trim();
+        const prettyInstruction = instruction
+            ? instruction.charAt(0).toUpperCase() + instruction.slice(1)
+            : (sourceInput.briefLabel ?? 'Variant');
+        const LABEL_MAX = 48;
+        const created = [];
+        for (let i = 0; i < total; i++) {
+            const suffix = total > 1 ? ` · ${i + 1}` : '';
+            const labelBase = prettyInstruction.length > LABEL_MAX - suffix.length
+                ? `${prettyInstruction.slice(0, LABEL_MAX - suffix.length - 1)}…`
+                : prettyInstruction;
+            const item = {
+                id: (0, crypto_1.randomUUID)(),
+                kind: 'static_preview',
+                status: 'pending',
+                attempt: 0,
+                dependsOn: [],
+                input: {
+                    briefId: `${sourceInput.briefId ?? 'v'}-vary-${(0, crypto_1.randomUUID)().slice(0, 8)}`,
+                    // Provisional name/description (the change) shown while generating;
+                    // the agent reports a synthesized title/description on completion.
+                    briefLabel: `${labelBase}${suffix}`,
+                    briefBody: prettyInstruction,
+                    instruction: args.instruction,
+                    sourceVariantId: args.sourceVariantId,
+                    // Parent identity, so the agent can synthesize a name/description that
+                    // combines the source variant with the requested change.
+                    ...(sourceInput.briefLabel
+                        ? { sourceLabel: sourceInput.briefLabel }
+                        : {}),
+                    ...(sourceInput.briefBody
+                        ? { sourceBody: sourceInput.briefBody }
+                        : {}),
+                    ...(seedHtml ? { currentHtml: seedHtml } : {}),
+                    ...(args.targetElement ? { targetElement: args.targetElement } : {}),
+                    ...(args.requestId ? { requestId: args.requestId } : {}),
+                    projectContext: sourceInput.projectContext ?? session.projectContext,
+                    ...(sourceInput.context ? { context: sourceInput.context } : {}),
+                },
+                acceptedReports: [],
+            };
+            session.workItems.set(item.id, item);
+            // Surface newest siblings at the top of the Directions list: unshift each
+            // in creation order so the batch ends up [variation N … variation 1]
+            // ahead of the pre-existing variants.
+            session.workItemOrder.unshift(item.id);
+            created.push(item);
+        }
+        session.stage = 'work_items_ready';
+        return created;
+    }
+    /**
+     * Append new code_gen variants to an EXISTING-project session that already
+     * holds variants — the worktree-backed analog of
+     * {@link createForkedStaticPreviewWorkItems}. A second "Vary" on an existing
+     * project lands here so its variants ACCUMULATE in the live session instead
+     * of orphaning the prior ones in a fresh, superseding session. The new items
+     * are leasable via {@link requestWork} exactly like the initial code_gen
+     * batch; the orchestrator provisions a worktree per item and runs each
+     * through the normal completion/preview pipeline.
+     *
+     * Reopens the session to `work_items_ready` so the appended pending work is
+     * visible and drives the stage back through generation to ready/degraded.
+     */
+    appendExistingCodeGenVariants(args) {
+        const session = this.requireSession(args.sessionId);
+        if (session.projectContext.kind !== 'existing') {
+            throw new errors_1.AgentVariantsError('INVALID_STAGE_ACTION', 'Only existing-project sessions can append code_gen variants');
+        }
+        if (session.variantPick) {
+            throw new errors_1.AgentVariantsError('PENDING_CHANGE_CONFLICT', 'Cannot append variants after one has already been committed');
+        }
+        if (session.stage === 'cancelled' || session.stage === 'failed') {
+            throw new errors_1.AgentVariantsError('INVALID_STAGE_ACTION', `Cannot append variants to a ${session.stage} session`);
+        }
+        if (args.briefs.length === 0) {
+            throw new errors_1.AgentVariantsError('MISSING_REQUIRED_INPUT', 'At least one brief is required to append variants');
+        }
+        const createdWorkItemIds = [];
+        for (const brief of args.briefs) {
+            const context = resolveVariantWorkItemContext({
+                bundle: args.variantContext ?? session.projectContext.variantContext,
+                projectContext: session.projectContext,
+                brief,
+                slotIndex: session.briefs.length,
+            });
+            const visualRef = brief.visualReferenceUrl
+                ? { visualReferenceUrl: brief.visualReferenceUrl }
+                : {};
+            const item = {
+                id: (0, crypto_1.randomUUID)(),
+                kind: 'code_gen',
+                status: 'pending',
+                attempt: 0,
+                dependsOn: [],
+                input: {
+                    briefId: brief.briefId,
+                    briefLabel: brief.label,
+                    briefBody: brief.body,
+                    ...visualRef,
+                    ...(args.runLabel ? { runLabel: args.runLabel } : {}),
+                    target: session.target,
+                    projectContext: session.projectContext,
+                    ...(context ? { context } : {}),
+                },
+                acceptedReports: [],
+            };
+            session.workItems.set(item.id, item);
+            // Surface the newest Vary batch at the top of the Directions list, matching
+            // the static-preview fork ordering.
+            session.workItemOrder.unshift(item.id);
+            session.briefs.push(brief);
+            createdWorkItemIds.push(item.id);
+        }
+        session.stage = 'work_items_ready';
+        return { createdWorkItemIds, briefs: args.briefs };
+    }
+    /**
+     * Fork a succeeded code_gen variant into N NEW sibling variants. Each forked
+     * item is seeded from the source variant's worktree (not git HEAD / Original)
+     * and carries `sourceVariantId` so the orchestrator can copy the parent's
+     * tree when provisioning. Backs code_gen "Vary" when the UI targets a parent
+     * variant with `variantRequest.count > 0`.
+     */
+    createForkedCodeGenWorkItems(args) {
+        const session = this.requireSession(args.sessionId);
+        const source = this.requireWorkItem(session, args.sourceVariantId);
+        if (source.kind !== 'code_gen' || source.status !== 'succeeded') {
+            throw new errors_1.AgentVariantsError('VARIANT_NOT_EDITABLE', 'Only completed code_gen variants can be varied');
+        }
+        if (session.projectContext.kind !== 'existing') {
+            throw new errors_1.AgentVariantsError('INVALID_STAGE_ACTION', 'Only existing-project sessions can fork code_gen variants');
+        }
+        if (session.variantPick) {
+            throw new errors_1.AgentVariantsError('PENDING_CHANGE_CONFLICT', 'Cannot vary a variant after one has already been committed');
+        }
+        if (session.stage === 'cancelled' || session.stage === 'failed') {
+            throw new errors_1.AgentVariantsError('INVALID_STAGE_ACTION', `Cannot fork variants in a ${session.stage} session`);
+        }
+        if (args.briefs.length === 0) {
+            throw new errors_1.AgentVariantsError('MISSING_REQUIRED_INPUT', 'At least one brief is required to fork variants');
+        }
+        const activeRefinement = [...session.workItems.values()].find((item) => {
+            if (item.kind !== 'refine_variant')
+                return false;
+            const input = item.input;
+            return (input.variantId === args.sourceVariantId &&
+                (item.status === 'pending' || item.status === 'running'));
+        });
+        if (activeRefinement) {
+            throw new errors_1.AgentVariantsError('PENDING_CHANGE_CONFLICT', 'Cannot vary a variant while an in-place refinement is pending or running');
+        }
+        const sourceInput = source.input;
+        const createdWorkItemIds = [];
+        for (const brief of args.briefs) {
+            const context = resolveVariantWorkItemContext({
+                bundle: args.variantContext ?? session.projectContext.variantContext,
+                projectContext: session.projectContext,
+                brief,
+                slotIndex: session.briefs.length,
+            });
+            const visualRef = brief.visualReferenceUrl
+                ? { visualReferenceUrl: brief.visualReferenceUrl }
+                : {};
+            const item = {
+                id: (0, crypto_1.randomUUID)(),
+                kind: 'code_gen',
+                status: 'pending',
+                attempt: 0,
+                dependsOn: [],
+                input: {
+                    briefId: brief.briefId,
+                    briefLabel: brief.label,
+                    briefBody: brief.body,
+                    ...visualRef,
+                    ...(args.runLabel ? { runLabel: args.runLabel } : {}),
+                    sourceVariantId: args.sourceVariantId,
+                    ...(sourceInput.briefLabel
+                        ? { sourceLabel: sourceInput.briefLabel }
+                        : {}),
+                    ...(sourceInput.briefBody ? { sourceBody: sourceInput.briefBody } : {}),
+                    target: session.target,
+                    projectContext: session.projectContext,
+                    ...(context ? { context } : {}),
+                },
+                acceptedReports: [],
+            };
+            session.workItems.set(item.id, item);
+            session.workItemOrder.unshift(item.id);
+            session.briefs.push(brief);
+            createdWorkItemIds.push(item.id);
+        }
+        session.stage = 'work_items_ready';
+        return { createdWorkItemIds, briefs: args.briefs };
+    }
+    /**
+     * Adopt a PAST variant (from a prior session's persisted history) into THIS
+     * active session as a first-class, already-`succeeded` `static_preview`
+     * variant. Triggered when the user makes their first edit (a comment or a
+     * Vary) on a selected past direction: the past variant is rehydrated as a
+     * live session member so the comment/refine machinery scopes and routes to it
+     * exactly like a freshly-generated variant. The caller (orchestrator) registers
+     * the static-preview record that points at the rehydrated files so the snapshot
+     * surfaces it as a `static_artifact`.
+     *
+     * Kept as `static_preview` regardless of the host session's primary variant
+     * kind so {@link createRefineVariantWorkItem} / {@link createForkedStaticPreviewWorkItems}
+     * accept it. Adopted variants are pre-completed artifacts, so they are excluded
+     * from progress/summary/terminal accounting and never reopen the session.
+     *
+     * Idempotent: re-adopting the same `{sessionId, variantId}` returns the
+     * existing work item id (`created: false`) rather than duplicating it.
+     */
+    appendAdoptedStaticVariant(args) {
+        const session = this.requireSession(args.sessionId);
+        if (session.stage === 'cancelled' || session.stage === 'failed') {
+            throw new errors_1.AgentVariantsError('INVALID_STAGE_ACTION', `Cannot adopt a variant into a ${session.stage} session`);
+        }
+        const existing = this.findAdoptedVariant(session, args.source);
+        if (existing) {
+            const input = existing.input;
+            return {
+                workItemId: existing.id,
+                briefId: input.briefId ?? '',
+                created: false,
+            };
+        }
+        if (session.variantPick) {
+            throw new errors_1.AgentVariantsError('PENDING_CHANGE_CONFLICT', 'Cannot adopt a variant after one has already been committed');
+        }
+        const briefId = `adopted-${(0, crypto_1.randomUUID)().slice(0, 8)}`;
+        const item = {
+            id: (0, crypto_1.randomUUID)(),
+            kind: 'static_preview',
+            status: 'succeeded',
+            attempt: 0,
+            dependsOn: [],
+            input: {
+                briefId,
+                briefLabel: args.label,
+                ...(args.description ? { briefBody: args.description } : {}),
+                ...(args.runLabel ? { runLabel: args.runLabel } : {}),
+                adoptedFrom: { ...args.source },
+                projectContext: session.projectContext,
+            },
+            acceptedReports: [],
+        };
+        session.workItems.set(item.id, item);
+        // Adoption is triggered by the user's first in-place edit (a comment /
+        // refine) on an ALREADY-DISPLAYED past direction — not a request for a new
+        // exploration. Appending (rather than unshifting to the top) preserves the
+        // positions of the existing active variants so a refined card does NOT
+        // leapfrog a newer Vary/fork batch. Genuinely new variants (Vary / fork /
+        // append) still surface at the top via their own `unshift` paths. Stage is
+        // intentionally left untouched — the adopted variant is already complete,
+        // so the session must not reopen to `work_items_ready`.
+        session.workItemOrder.push(item.id);
+        return { workItemId: item.id, briefId, created: true };
+    }
+    /**
+     * Create an active session whose initial visible direction is a static
+     * variant rehydrated from persisted history.
+     *
+     * This is the no-usable-session counterpart to
+     * {@link appendAdoptedStaticVariant}: the session starts terminal/ready
+     * because the adopted artifact is already generated, and the adopted work item
+     * remains excluded from generation progress because this run did not generate
+     * fresh variants.
+     */
+    createSessionFromStaticHistoryVariant(args) {
+        const sessionId = (0, crypto_1.randomUUID)();
+        const record = {
+            sessionId,
+            stage: 'ready',
+            prompt: args.prompt,
+            runLabel: args.runLabel?.trim() || undefined,
+            count: 0,
+            projectContext: args.projectContext,
+            briefs: [],
+            approvedBriefs: [],
+            workItems: new Map(),
+            workItemOrder: [],
+            acceptedFingerprints: new Map(),
+            createdAt: this.clock.now(),
+        };
+        this.sessions.set(sessionId, record);
+        const adopted = this.appendAdoptedStaticVariant({
+            sessionId,
+            source: args.source,
+            label: args.label,
+            description: args.description,
+            runLabel: args.runLabel,
+        });
+        return {
+            sessionId,
+            workItemId: adopted.workItemId,
+            briefId: adopted.briefId,
+        };
+    }
+    /** Find an already-adopted variant by its source identity, or undefined. */
+    findAdoptedVariant(session, source) {
+        for (const item of session.workItems.values()) {
+            if (item.removed)
+                continue;
+            const adoptedFrom = item.input
+                .adoptedFrom;
+            if (adoptedFrom &&
+                adoptedFrom.sessionId === source.sessionId &&
+                adoptedFrom.variantId === source.variantId) {
+                return item;
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Stamp a UI correlation id onto already-created variant work items so the
+     * snapshot surfaces it and the panel can map its optimistic placeholders to
+     * the real cards (see {@link ActiveVariantSnapshot.requestId}). Skips ids
+     * that are unknown to the session. Used by `start_variants` for both the
+     * initial batch and the appended (accumulated) batch.
+     */
+    assignVariantRequestId(sessionId, workItemIds, requestId) {
+        const session = this.requireSession(sessionId);
+        for (const id of workItemIds) {
+            const item = session.workItems.get(id);
+            if (!item)
+                continue;
+            const input = (item.input ?? {});
+            item.input = { ...input, requestId };
+        }
+    }
     /**
      * Fold a newer instruction into a variant's still-pending refinement. Used
      * when a second refinement is requested for a variant that already has a
@@ -1348,8 +1753,13 @@ class SessionStore {
         const kind = this.variantWorkItemKind(session);
         // Removed variants are excluded everywhere progress/summary/terminal
         // accounting reads from, so a removed variant neither blocks the session
-        // from going terminal nor inflates the ready/total counts.
-        return [...session.workItems.values()].filter((i) => i.kind === kind && !i.removed);
+        // from going terminal nor inflates the ready/total counts. Adopted past
+        // variants are likewise excluded: they are pre-completed artifacts pulled in
+        // for editing, not part of this run's generation, so they must not inflate
+        // progress/total or flip a failed run to degraded.
+        return [...session.workItems.values()].filter((i) => (i.kind === kind || isForkedStaticPreviewVariant(i)) &&
+            !i.removed &&
+            !isAdoptedVariant(i));
     }
     /**
      * The work-item kind that represents a user-facing variant for this
@@ -1433,6 +1843,13 @@ class SessionStore {
             }),
         };
     }
+    refinementSnapshotPriority(item) {
+        if (item.status === 'running')
+            return 2;
+        if (item.status === 'pending')
+            return 1;
+        return 0;
+    }
     variantsOf(session) {
         const kind = this.variantWorkItemKind(session);
         const refinementsByVariantId = new Map();
@@ -1442,30 +1859,58 @@ class SessionStore {
             const input = item.input;
             if (!input.variantId)
                 continue;
-            refinementsByVariantId.set(input.variantId, item);
+            const existing = refinementsByVariantId.get(input.variantId);
+            if (!existing ||
+                this.refinementSnapshotPriority(item) >
+                    this.refinementSnapshotPriority(existing)) {
+                refinementsByVariantId.set(input.variantId, item);
+            }
         }
-        return [...session.workItems.values()]
-            .filter((i) => i.kind === kind && !i.removed)
+        return session.workItemOrder
+            .map((id) => session.workItems.get(id))
+            .filter((i) => !!i &&
+            !i.removed &&
+            (i.kind === kind ||
+                isAdoptedVariant(i) ||
+                isForkedStaticPreviewVariant(i)))
             .map((item) => {
             const input = item.input;
+            const refineItem = refinementsByVariantId.get(item.id);
+            const refineRequestId = refineItem?.input
+                ?.requestId;
             return {
                 workItemId: item.id,
                 briefId: input.briefId ?? '',
                 label: input.briefLabel ?? 'Variant',
                 status: item.status,
                 createdAt: new Date(session.createdAt).toISOString(),
-                runLabel: session.runLabel ?? (0, runLabel_1.deriveRunLabel)(session.prompt),
+                // Prefer the per-item label stamped by an appended Vary batch; the
+                // session-level fallback is correct only for the first batch (its
+                // prompt is the session prompt). Without this, accumulated batches
+                // all show batch 1's tag.
+                runLabel: input.runLabel ??
+                    session.runLabel ??
+                    (0, runLabel_1.deriveRunLabel)(session.prompt),
+                // Correlation id of the UI request that produced this variant (a fork)
+                // or, for an in-place refine, the request driving its refinement —
+                // lets the UI map its optimistic placeholders to real cards.
+                ...(input.requestId
+                    ? { requestId: input.requestId }
+                    : refineRequestId
+                        ? { requestId: refineRequestId }
+                        : {}),
                 ...(input.briefBody ? { description: input.briefBody } : {}),
+                ...(input.adoptedFrom
+                    ? { adoptedSource: { ...input.adoptedFrom } }
+                    : {}),
                 design: variantDesignFromInput(input.designContextEntry),
-                ...(refinementsByVariantId.get(item.id)
+                ...(refineItem
                     ? {
                         refinement: {
-                            workItemId: refinementsByVariantId.get(item.id).id,
-                            status: refinementsByVariantId.get(item.id).status,
-                            ...(refinementsByVariantId.get(item.id).error?.code
-                                ? {
-                                    errorCode: String(refinementsByVariantId.get(item.id).error?.code),
-                                }
+                            workItemId: refineItem.id,
+                            status: refineItem.status,
+                            ...(refineItem.error?.code
+                                ? { errorCode: String(refineItem.error.code) }
                                 : {}),
                         },
                     }