stageflow 0.32.0 → 0.35.0

package/dist/ui/index.html

@@ -5,16 +5,16 @@
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <script>
       try {
-        var t = localStorage.getItem("sf-theme");
-        if (t && t !== "system") document.documentElement.setAttribute("data-theme", t);
+        document.documentElement.setAttribute("data-theme", "dark");
+        document.documentElement.setAttribute("data-redesign", "on");
       } catch (e) {}
     </script>
     <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
     <link rel="stylesheet" href="https://fonts.googleapis.com/css2?family=Figtree:wght@400;500;600;700&display=swap" />
     <link rel="icon" type="image/svg+xml" href="/stageflow-icon.svg" />
     <title>Stageflow</title>
-    <script type="module" crossorigin src="/assets/index-59cjF0OA.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-Bv4p1aPK.css">
+    <script type="module" crossorigin src="/assets/index-BoFPkKFg.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-CIPbbBUi.css">
   </head>
   <body>
     <div id="root"></div>

package/dist/workshop/autosave.d.ts

@@ -22,11 +22,11 @@ export type WorkshopAutosaveRecord = {
     savedPath?: string | null;
     savedTaskPath?: string | null;
     diskFingerprints?: Record<string, string>;
+    projectRoot?: string | null;
 };
 export declare function workshopAutosaveSlotKey(pipelinePath: string | null | undefined): string;
-export declare function resolveWorkshopAutosaveStoreRoot(options: {
+export declare function resolveWorkshopAutosaveStoreRoot(_options?: {
     projectRoot?: string | null;
-    isGitProject?: boolean;
 }): string;
 export declare function workshopAutosaveDir(storeRoot: string): string;
 export declare function workshopAutosaveFilePath(storeRoot: string, key: string): string;

package/dist/workshop/autosave.js

@@ -1,7 +1,6 @@
 import { existsSync, mkdirSync, readFileSync, statSync, unlinkSync, writeFileSync, } from "node:fs";
 import path from "node:path";
 import { globalStageflowHome } from "../project/globalHome.js";
-import { storeRootFor } from "../runstore/paths.js";
 export const WORKSHOP_UNTITLED_AUTOSAVE_KEY = "__untitled__";
 export function workshopAutosaveSlotKey(pipelinePath) {
     const trimmed = pipelinePath?.trim();
@@ -9,11 +8,7 @@ export function workshopAutosaveSlotKey(pipelinePath) {
         return WORKSHOP_UNTITLED_AUTOSAVE_KEY;
     return trimmed.replace(/\\/g, "/");
 }
-export function resolveWorkshopAutosaveStoreRoot(options) {
-    const root = options.projectRoot?.trim();
-    if (root && options.isGitProject !== false) {
-        return storeRootFor(path.resolve(root));
-    }
+export function resolveWorkshopAutosaveStoreRoot(_options) {
     return globalStageflowHome();
 }
 export function workshopAutosaveDir(storeRoot) {
@@ -114,6 +109,9 @@ export function parseWorkshopAutosaveRecord(value) {
         }
         record.diskFingerprints = fps;
     }
+    if (value.projectRoot === null || typeof value.projectRoot === "string") {
+        record.projectRoot = value.projectRoot;
+    }
     return record;
 }
 export function readWorkshopAutosave(storeRoot, key) {

package/dist/workshop/buildStore.d.ts

@@ -55,6 +55,8 @@ export type WorkshopPickerRow = {
     name: string;
     projectRoot: string | null;
     relativePath: string | null;
+    /** True when this row's pipeline path appears in the catalog scan (Tasks/Pipelines lists). */
+    catalogListed?: boolean;
 };
 export type FocusUnboundWorkshopBuildInput = {
     projectRoot: string;

package/dist/workshop/chatAttachments.d.ts

@@ -0,0 +1,27 @@
+export declare const WORKSHOP_CHAT_ATTACHMENT_MAX_FILES = 5;
+export declare const WORKSHOP_CHAT_ATTACHMENT_MAX_BYTES: number;
+export declare const WORKSHOP_DOCS_REFERENCE_PATHS: readonly ["docs/yaml-catalog.md", "skills/stageflow-author/references/catalog-mapping.md"];
+export type WorkshopDocsReference = {
+    path: string;
+    text: string;
+};
+export type WorkshopChatAttachment = {
+    name: string;
+    mediaType: string;
+    size: number;
+    content: string;
+};
+export type WorkshopChatContext = {
+    docs?: boolean;
+};
+export type ParseWorkshopChatAttachmentsResult = {
+    ok: true;
+    attachments: WorkshopChatAttachment[];
+} | {
+    ok: false;
+    error: string;
+};
+export declare function parseWorkshopChatAttachments(value: unknown): ParseWorkshopChatAttachmentsResult;
+export declare function parseWorkshopChatContext(value: unknown): WorkshopChatContext;
+export declare function readWorkshopDocsReference(rootDir?: string): Promise<WorkshopDocsReference | null>;
+export declare function buildWorkshopChatPrompt(message: string, attachments: readonly WorkshopChatAttachment[], docsReference: WorkshopDocsReference | null): string;

package/dist/workshop/chatAttachments.js

@@ -0,0 +1,98 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { resolveWorkshopCatalogRoot } from "../operatorAgent/docsRetrieval.js";
+export const WORKSHOP_CHAT_ATTACHMENT_MAX_FILES = 5;
+export const WORKSHOP_CHAT_ATTACHMENT_MAX_BYTES = 256 * 1024;
+export const WORKSHOP_DOCS_REFERENCE_PATHS = [
+    "docs/yaml-catalog.md",
+    "skills/stageflow-author/references/catalog-mapping.md",
+];
+function isPlainObject(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+export function parseWorkshopChatAttachments(value) {
+    if (value === undefined || value === null) {
+        return { ok: true, attachments: [] };
+    }
+    if (!Array.isArray(value)) {
+        return { ok: false, error: "attachments must be an array" };
+    }
+    if (value.length > WORKSHOP_CHAT_ATTACHMENT_MAX_FILES) {
+        return {
+            ok: false,
+            error: `At most ${WORKSHOP_CHAT_ATTACHMENT_MAX_FILES} attachments per message`,
+        };
+    }
+    const attachments = [];
+    for (const [index, entry] of value.entries()) {
+        if (!isPlainObject(entry)) {
+            return { ok: false, error: `attachments[${index}] must be an object` };
+        }
+        const name = typeof entry.name === "string" ? entry.name.replace(/\s+/g, " ").trim() : "";
+        if (!name) {
+            return { ok: false, error: `attachments[${index}].name is required` };
+        }
+        if (typeof entry.content !== "string") {
+            return {
+                ok: false,
+                error: `attachments[${index}].content must be a string (${name})`,
+            };
+        }
+        if (entry.mediaType !== undefined && typeof entry.mediaType !== "string") {
+            return {
+                ok: false,
+                error: `attachments[${index}].mediaType must be a string (${name})`,
+            };
+        }
+        const size = Buffer.byteLength(entry.content, "utf8");
+        if (size > WORKSHOP_CHAT_ATTACHMENT_MAX_BYTES) {
+            return {
+                ok: false,
+                error: `Attachment ${name} exceeds ${WORKSHOP_CHAT_ATTACHMENT_MAX_BYTES / 1024} KB`,
+            };
+        }
+        attachments.push({
+            name,
+            mediaType: entry.mediaType?.trim() || "text/plain",
+            size,
+            content: entry.content,
+        });
+    }
+    return { ok: true, attachments };
+}
+export function parseWorkshopChatContext(value) {
+    return isPlainObject(value) && value.docs === true ? { docs: true } : {};
+}
+function fenceFor(content) {
+    const longest = (content.match(/`+/g) ?? []).reduce((max, run) => Math.max(max, run.length), 0);
+    return "`".repeat(Math.max(3, longest + 1));
+}
+function fencedBlock(heading, content) {
+    const fence = fenceFor(content);
+    const body = content.endsWith("\n") ? content : `${content}\n`;
+    return `${heading}\n${fence}\n${body}${fence}`;
+}
+export async function readWorkshopDocsReference(rootDir) {
+    const root = resolveWorkshopCatalogRoot(rootDir);
+    for (const relPath of WORKSHOP_DOCS_REFERENCE_PATHS) {
+        try {
+            const text = await readFile(path.join(root, relPath), "utf8");
+            if (text.trim())
+                return { path: relPath, text };
+        }
+        catch {
+            continue;
+        }
+    }
+    return null;
+}
+export function buildWorkshopChatPrompt(message, attachments, docsReference) {
+    const sections = [message];
+    for (const attachment of attachments) {
+        sections.push(fencedBlock(`Attached file: ${attachment.name}`, attachment.content));
+    }
+    if (docsReference) {
+        sections.push(fencedBlock(`Stageflow YAML authoring reference (${docsReference.path}):`, docsReference.text));
+    }
+    return sections.join("\n\n");
+}

package/dist/workshop/chatTurn.d.ts

@@ -1,5 +1,6 @@
 import type { DraftPackage } from "../config/draftPackage.js";
 import { type OperatorAgentHost, type OperatorAgentProposal, type OperatorAgentSession, type OperatorAgentSessionEvent, type ProposalArtifactDiff, type WorkshopToolActivityUpdate } from "../operatorAgent/index.js";
+import { type WorkshopChatAttachment, type WorkshopChatContext } from "./chatAttachments.js";
 import { WorkshopSessionStoreError } from "./sessionStore.js";
 import { type WorkshopPointerChange } from "./workshopPin.js";
 export type { WorkshopPointerChange };
@@ -51,8 +52,9 @@ export type WorkshopChatTurnInput = {
     sessionId: string;
     draft: DraftPackage;
     message: string;
-    /** @deprecated Ignored — mutations apply immediately (Accept = soft undo). */
     autoApply?: boolean;
+    attachments?: WorkshopChatAttachment[];
+    context?: WorkshopChatContext;
     /** Session model override from Workshop chrome. */
     model?: string | null;
     /** Settings default from factory settings /api/settings. */
@@ -75,6 +77,8 @@ export type WorkshopChatTurnInput = {
     onActivity?: (update: WorkshopToolActivityUpdate) => void;
     /** Fired when this turn changes the session pointer. */
     onPointerChange?: (frame: WorkshopPointerChange) => void;
+    /** Writable catalog root (absolute path) for agent save; host-resolved. */
+    projectRoot?: string;
 };
 export type WorkshopChatTurnResult = {
     sessionId: string;
@@ -86,7 +90,6 @@ export type WorkshopChatTurnResult = {
      * Accept/undo. Name is historical — not a pending gated apply.
      */
     pending: WorkshopChatProposalPayload | null;
-    /** Always false — auto-apply chrome removed; mutations apply immediately. */
     autoApply: boolean;
     model: string;
     /** Build this turn edited. Null when the chat stayed unlinked. */

package/dist/workshop/chatTurn.js

@@ -1,17 +1,28 @@
-import { createWorkshopDraftContext, createWorkshopOperatorHost, isWorkshopDraftContext, readDraftFromContext, withDraft, WORKSHOP_AUTHOR_PROFILE_ID, } from "../operatorAgent/index.js";
+import { createWorkshopDraftContext, createWorkshopOperatorHost, isWorkshopDraftContext, readDraftFromContext, withDraft, withProjectRoot, WORKSHOP_AUTHOR_PROFILE_ID, } from "../operatorAgent/index.js";
 import { resolveWorkshopModel } from "./modelSettings.js";
 import { getWorkshopBuild, updateWorkshopBuild } from "./buildStore.js";
+import { buildWorkshopChatPrompt, readWorkshopDocsReference, } from "./chatAttachments.js";
+import { transcriptMessagesForTurn } from "./workshopTranscriptTurn.js";
 import { appendWorkshopSessionMessages, getWorkshopSession, resolveWorkshopSessionStoreRoot, WorkshopSessionStoreError, } from "./sessionStore.js";
 import { bindPinnedBuildContext, enqueueSessionWrite, registerLiveWorkshopSession, resetWorkshopPinStateForTests, unregisterLiveWorkshopSession, } from "./workshopPin.js";
-function markUnlinkedChatContext(current, sessionId, draft) {
+function markUnlinkedChatContext(current, sessionId, draft, projectRoot) {
     const base = isWorkshopDraftContext(current)
         ? { ...current, draft }
         : { draft };
     delete base.buildId;
     base.chatSessionId = sessionId;
     base.draft = draft;
+    if (projectRoot?.trim()) {
+        base.projectRoot = projectRoot.trim();
+    }
     return base;
 }
+function bindChatProjectRoot(context, projectRoot) {
+    const trimmed = projectRoot?.trim();
+    if (!trimmed || context.projectRoot)
+        return context;
+    return withProjectRoot(context, trimmed);
+}
 /**
  * In-memory map of Workshop session id → open OperatorAgentSession.
  * Survives across chat turns until process restart (disk transcript remains).
@@ -207,17 +218,6 @@ export function toWorkshopChatWireEvent(event, fallbackDraft) {
     }
     return { type: "error", message: event.message };
 }
-function transcriptMessagesForTurn(userMessage, events) {
-    const messages = [
-        { role: "user", text: userMessage },
-    ];
-    for (const event of events) {
-        if (event.type === "message") {
-            messages.push({ role: event.role, text: event.text });
-        }
-    }
-    return messages;
-}
 /**
  * One Workshop Author turn on a durable Operator Agent Host session.
  * Requires an existing session store record (New / POST sessions first).
@@ -240,6 +240,8 @@ export async function runWorkshopChatTurn(input) {
         sessionOverride: input.model,
         settingsDefault: input.settingsDefault,
     });
+    const attachments = input.attachments ?? [];
+    const prompt = buildWorkshopChatPrompt(message, attachments, input.context?.docs === true ? await readWorkshopDocsReference() : null);
     const registry = input.registry ?? getDefaultRegistry(input.host);
     if (input.host && registry.host !== input.host) {
         throw new Error("host does not match workshop chat session registry");
@@ -253,10 +255,10 @@ export async function runWorkshopChatTurn(input) {
         const draftForOpen = pinnedBuild?.draft ?? input.draft;
         const { session: agentSession, created } = registry.getOrOpen(sessionId, draftForOpen);
         if (pinnedBuild) {
-            agentSession.setContext(bindPinnedBuildContext(agentSession.getContext(), pinnedBuild, sessionId));
+            agentSession.setContext(bindChatProjectRoot(bindPinnedBuildContext(agentSession.getContext(), pinnedBuild, sessionId), input.projectRoot));
         }
         else {
-            agentSession.setContext(markUnlinkedChatContext(agentSession.getContext(), sessionId, draftForOpen));
+            agentSession.setContext(bindChatProjectRoot(markUnlinkedChatContext(agentSession.getContext(), sessionId, draftForOpen, input.projectRoot), input.projectRoot));
         }
         registry.bindTurn(sessionId, {
             storeRoot,
@@ -272,7 +274,7 @@ export async function runWorkshopChatTurn(input) {
                 typeof agentSession.prepareRestart === "function") {
                 await agentSession.prepareRestart(storeRecord.transcript);
             }
-            rawEvents = await agentSession.send(message, {
+            rawEvents = await agentSession.send(prompt, {
                 onDelta: input.onDelta,
                 onActivity: (update) => {
                     const buildId = registry.getPinnedBuildId(sessionId);
@@ -302,7 +304,9 @@ export async function runWorkshopChatTurn(input) {
         const pendingRaw = agentSession.getPendingProposal();
         const events = rawEvents.map((event) => toWorkshopChatWireEvent(event, draft));
         await enqueueSessionWrite(sessionId, () => {
-            appendWorkshopSessionMessages(storeRoot, sessionId, transcriptMessagesForTurn(message, events));
+            appendWorkshopSessionMessages(storeRoot, sessionId, transcriptMessagesForTurn(message, attachments, events, {
+                autoApply: input.autoApply === true,
+            }));
         });
         return {
             sessionId,
@@ -311,7 +315,7 @@ export async function runWorkshopChatTurn(input) {
             pending: pendingRaw
                 ? serializeWorkshopProposal(pendingRaw, draft)
                 : null,
-            autoApply: false,
+            autoApply: input.autoApply === true,
             model,
             buildId: resultBuildId,
         };

package/dist/workshop/sessionMutations.d.ts

@@ -0,0 +1,17 @@
+import type { ProposalArtifactDiff } from "../operatorAgent/proposals.js";
+import type { WorkshopChatProposalPayload } from "./chatTurn.js";
+type SnapshotDraft = WorkshopChatProposalPayload["baseDraft"];
+export type WorkshopSessionMutationSnapshot = {
+    id: string;
+    summary: string;
+    affectedStageIds: string[];
+    artifacts: ProposalArtifactDiff[];
+    status: "accepted" | "rejected";
+    autoApplied?: boolean;
+    baseDraft?: SnapshotDraft;
+    nextDraft?: SnapshotDraft;
+    baseFingerprint?: string;
+};
+export declare function parseWorkshopSessionMutationSnapshot(value: unknown): WorkshopSessionMutationSnapshot | null;
+export declare function mutationSnapshotsFromProposals(proposals: readonly WorkshopChatProposalPayload[], autoApply: boolean): WorkshopSessionMutationSnapshot[];
+export {};

package/dist/workshop/sessionMutations.js

@@ -0,0 +1,107 @@
+function isPlainObject(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function parseDraft(value) {
+    if (!isPlainObject(value))
+        return undefined;
+    const pipeline = value.pipeline;
+    if (!isPlainObject(pipeline))
+        return undefined;
+    if (typeof pipeline.id !== "string")
+        return undefined;
+    if (!Array.isArray(pipeline.stages))
+        return undefined;
+    if (pipeline.stages.some((stage) => !isPlainObject(stage)))
+        return undefined;
+    if (value.stages !== undefined) {
+        if (!Array.isArray(value.stages))
+            return undefined;
+        for (const entry of value.stages) {
+            if (!isPlainObject(entry) ||
+                typeof entry.path !== "string" ||
+                !isPlainObject(entry.body)) {
+                return undefined;
+            }
+        }
+    }
+    if (value.task !== undefined) {
+        if (!isPlainObject(value.task) ||
+            typeof value.task.filename !== "string" ||
+            !isPlainObject(value.task.body)) {
+            return undefined;
+        }
+    }
+    return structuredClone(value);
+}
+function parseArtifact(value) {
+    if (!isPlainObject(value))
+        return null;
+    if (typeof value.path !== "string" || !value.path)
+        return null;
+    if (value.kind !== "added" &&
+        value.kind !== "removed" &&
+        value.kind !== "modified") {
+        return null;
+    }
+    const artifact = {
+        path: value.path,
+        kind: value.kind,
+    };
+    if (typeof value.before === "string")
+        artifact.before = value.before;
+    if (typeof value.after === "string")
+        artifact.after = value.after;
+    return artifact;
+}
+export function parseWorkshopSessionMutationSnapshot(value) {
+    if (!isPlainObject(value))
+        return null;
+    if (typeof value.id !== "string" || !value.id)
+        return null;
+    if (typeof value.summary !== "string")
+        return null;
+    if (!Array.isArray(value.affectedStageIds))
+        return null;
+    const affectedStageIds = value.affectedStageIds.filter((id) => typeof id === "string" && id.length > 0);
+    if (!Array.isArray(value.artifacts))
+        return null;
+    const artifacts = [];
+    for (const entry of value.artifacts) {
+        const parsed = parseArtifact(entry);
+        if (!parsed)
+            return null;
+        artifacts.push(parsed);
+    }
+    const status = value.status === "rejected" ? "rejected" : "accepted";
+    const baseDraft = parseDraft(value.baseDraft);
+    const nextDraft = parseDraft(value.nextDraft);
+    const baseFingerprint = typeof value.baseFingerprint === "string" && value.baseFingerprint
+        ? value.baseFingerprint
+        : undefined;
+    return {
+        id: value.id,
+        summary: value.summary,
+        affectedStageIds,
+        artifacts,
+        status,
+        ...(value.autoApplied === true ? { autoApplied: true } : {}),
+        ...(baseDraft ? { baseDraft } : {}),
+        ...(nextDraft ? { nextDraft } : {}),
+        ...(baseFingerprint ? { baseFingerprint } : {}),
+    };
+}
+export function mutationSnapshotsFromProposals(proposals, autoApply) {
+    return proposals.map((proposal) => ({
+        id: proposal.id,
+        summary: proposal.summary,
+        affectedStageIds: [...proposal.affectedStageIds],
+        artifacts: proposal.artifacts.map((artifact) => ({ ...artifact })),
+        status: "accepted",
+        baseDraft: structuredClone(proposal.baseDraft),
+        nextDraft: structuredClone(proposal.nextDraft),
+        ...(proposal.baseFingerprint
+            ? { baseFingerprint: proposal.baseFingerprint }
+            : {}),
+        ...(autoApply ? { autoApplied: true } : {}),
+    }));
+}

package/dist/workshop/sessionStore.d.ts

@@ -1,10 +1,18 @@
+import { type WorkshopSessionMutationSnapshot } from "./sessionMutations.js";
 export declare const WORKSHOP_SESSION_TITLE_MAX_LENGTH = 80;
 export type WorkshopSessionMessageRole = "assistant" | "user" | "system";
+export type WorkshopSessionAttachment = {
+    name: string;
+    size: number;
+    mediaType: string;
+};
 export type WorkshopSessionMessage = {
     id: string;
     role: WorkshopSessionMessageRole;
     text: string;
     createdAt: string;
+    attachments?: WorkshopSessionAttachment[];
+    mutations?: WorkshopSessionMutationSnapshot[];
 };
 export type WorkshopSessionRecord = {
     version: 1;
@@ -28,6 +36,8 @@ export type WorkshopSessionAppendMessage = {
     role: WorkshopSessionMessageRole;
     text: string;
     createdAt?: string;
+    attachments?: WorkshopSessionAttachment[];
+    mutations?: WorkshopSessionMutationSnapshot[];
 };
 export type WorkshopSessionStoreErrorCode = "workshop_session_not_found";
 export declare class WorkshopSessionStoreError extends Error {

package/dist/workshop/sessionStore.js

@@ -2,6 +2,7 @@ import { randomUUID } from "node:crypto";
 import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync, } from "node:fs";
 import path from "node:path";
 import { globalStageflowHome } from "../project/globalHome.js";
+import { parseWorkshopSessionMutationSnapshot, } from "./sessionMutations.js";
 export const WORKSHOP_SESSION_TITLE_MAX_LENGTH = 80;
 export class WorkshopSessionStoreError extends Error {
     code;
@@ -63,13 +64,46 @@ function parseMessage(value) {
         return null;
     if (typeof value.createdAt !== "string" || !value.createdAt)
         return null;
+    const attachments = Array.isArray(value.attachments)
+        ? value.attachments.flatMap((entry) => {
+            const parsed = parseAttachment(entry);
+            return parsed ? [parsed] : [];
+        })
+        : [];
+    let mutations;
+    if (value.mutations !== undefined) {
+        if (!Array.isArray(value.mutations))
+            return null;
+        const parsedMutations = [];
+        for (const entry of value.mutations) {
+            const parsed = parseWorkshopSessionMutationSnapshot(entry);
+            if (!parsed)
+                return null;
+            parsedMutations.push(parsed);
+        }
+        if (parsedMutations.length > 0)
+            mutations = parsedMutations;
+    }
     return {
         id: value.id,
         role: value.role,
         text: value.text,
         createdAt: value.createdAt,
+        ...(attachments.length > 0 ? { attachments } : {}),
+        ...(mutations ? { mutations } : {}),
     };
 }
+function parseAttachment(value) {
+    if (!isPlainObject(value))
+        return null;
+    if (typeof value.name !== "string" || !value.name)
+        return null;
+    if (typeof value.size !== "number" || !Number.isFinite(value.size))
+        return null;
+    if (typeof value.mediaType !== "string")
+        return null;
+    return { name: value.name, size: value.size, mediaType: value.mediaType };
+}
 export function parseWorkshopSessionRecord(value) {
     if (!isPlainObject(value))
         return null;
@@ -211,6 +245,24 @@ export function appendWorkshopSessionMessages(storeRoot, sessionId, messages, op
             role: msg.role,
             text: msg.text,
             createdAt: msg.createdAt || now,
+            ...(msg.attachments && msg.attachments.length > 0
+                ? {
+                    attachments: msg.attachments.map(({ name, size, mediaType }) => ({
+                        name,
+                        size,
+                        mediaType,
+                    })),
+                }
+                : {}),
+            ...(msg.mutations && msg.mutations.length > 0
+                ? {
+                    mutations: msg.mutations.map((mutation) => ({
+                        ...mutation,
+                        affectedStageIds: [...mutation.affectedStageIds],
+                        artifacts: mutation.artifacts.map((artifact) => ({ ...artifact })),
+                    })),
+                }
+                : {}),
         };
         appended.push(entry);
         if (!title && entry.role === "user" && entry.text.trim()) {

package/dist/workshop/workshopPin.d.ts

@@ -35,17 +35,18 @@ export declare function resolveLiveWorkshopBinding(context: unknown): {
  * An unlinked chat turn fails the tool and does not create a build.
  */
 export declare function rejectUnlinkedWorkshopDraftTool(context: unknown, toolName: string): OperatorAgentToolResult | null;
-/** Tied builds save to the stored path. Untitled builds keep the caller's destination. */
-export declare function resolvePinnedSaveDestination(context: unknown): {
+/** Tied builds save to the stored path when the write root matches the build tie. */
+export declare function resolvePinnedSaveDestination(context: unknown, writeProjectRoot?: string | null): {
     directory: string;
     pipelineFilename: string;
 } | null;
-/** A successful save of an untitled build records the operator destination on that id. */
+/** A successful catalog save updates the build tie and in-memory pointer. */
 export declare function recordPinnedWorkshopSave(context: unknown, saved: {
     directory: string;
     pipelineFilename?: string;
     projectRoot: string;
     draft: DraftPackage;
+    relativePath?: string;
 }): void;
 /**
  * Create an untitled build and move this turn's pin onto it.

package/dist/workshop/workshopPin.js

@@ -117,8 +117,8 @@ export function rejectUnlinkedWorkshopDraftTool(context, toolName) {
         error: WORKSHOP_UNLINKED_DRAFT_TOOL_ERROR,
     };
 }
-/** Tied builds save to the stored path. Untitled builds keep the caller's destination. */
-export function resolvePinnedSaveDestination(context) {
+/** Tied builds save to the stored path when the write root matches the build tie. */
+export function resolvePinnedSaveDestination(context, writeProjectRoot) {
     if (!isWorkshopDraftContext(context) ||
         !context.buildId ||
         !context.chatSessionId) {
@@ -130,9 +130,21 @@ export function resolvePinnedSaveDestination(context) {
     const build = readWorkshopBuild(live.storeRoot, context.buildId);
     if (!build?.projectRoot || !build.relativePath)
         return null;
+    if (writeProjectRoot?.trim()) {
+        const tieRoot = path.resolve(build.projectRoot);
+        const writeRoot = path.resolve(writeProjectRoot.trim());
+        if (tieRoot !== writeRoot)
+            return null;
+    }
     return destinationFromRelativePath(build.relativePath);
 }
-/** A successful save of an untitled build records the operator destination on that id. */
+function normalizeSavedRelativePath(value) {
+    let trimmed = value.trim().replace(/\\/g, "/");
+    while (trimmed.startsWith("./"))
+        trimmed = trimmed.slice(2);
+    return trimmed;
+}
+/** A successful catalog save updates the build tie and in-memory pointer. */
 export function recordPinnedWorkshopSave(context, saved) {
     if (!isWorkshopDraftContext(context) ||
         !context.buildId ||
@@ -143,15 +155,23 @@ export function recordPinnedWorkshopSave(context, saved) {
     if (!live)
         return;
     const build = readWorkshopBuild(live.storeRoot, context.buildId);
-    if (!build || (build.projectRoot && build.relativePath))
+    if (!build)
         return;
     const pipelineFilename = saved.pipelineFilename?.trim() ||
         `${saved.draft.pipeline.id}.pipeline.yaml`;
-    updateWorkshopBuild(live.storeRoot, build.id, {
+    const relativePath = saved.relativePath?.trim()
+        ? normalizeSavedRelativePath(saved.relativePath)
+        : relativePathFromDestination(saved.directory, pipelineFilename);
+    const updated = updateWorkshopBuild(live.storeRoot, build.id, {
         draft: saved.draft,
         projectRoot: path.resolve(saved.projectRoot),
-        relativePath: relativePathFromDestination(saved.directory, pipelineFilename),
+        relativePath,
     });
+    const session = live.registry.get(context.chatSessionId);
+    if (session) {
+        session.setContext(bindPinnedBuildContext(session.getContext(), updated, context.chatSessionId));
+    }
+    emitPointerChange(live.registry, context.chatSessionId, updated);
 }
 /**
  * Create an untitled build and move this turn's pin onto it.

package/dist/workshop/workshopTranscriptTurn.d.ts

@@ -0,0 +1,8 @@
+import type { WorkshopChatAttachment } from "./chatAttachments.js";
+import type { WorkshopChatProposalPayload, WorkshopChatWireEvent } from "./chatTurn.js";
+import type { WorkshopSessionAppendMessage } from "./sessionStore.js";
+export declare function assistantTranscriptTextFromEvents(events: readonly WorkshopChatWireEvent[]): string;
+export declare function proposalPayloadsFromEvents(events: readonly WorkshopChatWireEvent[]): WorkshopChatProposalPayload[];
+export declare function transcriptMessagesForTurn(userMessage: string, attachments: readonly WorkshopChatAttachment[], events: readonly WorkshopChatWireEvent[], options?: {
+    autoApply?: boolean;
+}): WorkshopSessionAppendMessage[];