sailfork / t3code-github / apps/ web/ src/ composerDraftStore.test.ts

import { PrimaryConnectionTarget } from "@t3tools/client-runtime/connection";
import { createEnvironmentThreadShellAtoms } from "@t3tools/client-runtime/state/threads";
import {
  applyShellStreamEvent,
  createEnvironmentSnapshotAtom,
  EMPTY_SHELL_STATE,
  type EnvironmentShellState,
  type EnvironmentShellStatus,
} from "@t3tools/client-runtime/state/shell";
import { makeThreadProjectionFixture } from "./test-fixtures";
import * as Option from "effect/Option";
import { AsyncResult, Atom, AtomRegistry } from "effect/reactivity";
import {
  scopedProjectKey,
  scopedThreadKey,
  scopeProjectRef,
  scopeThreadRef,
} from "@t3tools/client-runtime/environment";
import { DEFAULT_UNIFIED_SETTINGS } from "@t3tools/contracts/settings";
import {
  defaultInstanceIdForDriver,
  DEFAULT_MODEL,
  DEFAULT_MODEL_BY_PROVIDER,
  EnvironmentId,
  ProjectId,
  ProviderDriverKind,
  ProviderInstanceId,
  PROVIDER_SEND_TURN_MAX_ATTACHMENTS,
  RunId,
  ThreadId,
  type OrchestrationV2ThreadShell,
  type OrchestrationV2ShellSnapshot,
  type ModelSelection,
  type PreviewAnnotationPayload,
  type ProviderOptionSelection,
  type ScopedThreadRef,
} from "@t3tools/contracts";
import { createModelSelection } from "@t3tools/shared/model";

const CODEX_INSTANCE = ProviderInstanceId.make("codex");
const CODEX_SECONDARY_INSTANCE = ProviderInstanceId.make("codex_secondary");
const CLAUDE_AGENT_INSTANCE = ProviderInstanceId.make("claudeAgent");
const CURSOR_INSTANCE = ProviderInstanceId.make("cursor");
const CODEX_DRIVER = ProviderDriverKind.make("codex");
const CLAUDE_AGENT_DRIVER = ProviderDriverKind.make("claudeAgent");
const CURSOR_DRIVER = ProviderDriverKind.make("cursor");

type ProviderOptionSelectionBag = ReadonlyArray<ProviderOptionSelection>;
type ProviderOptionSelectionsByProvider = Partial<Record<string, ProviderOptionSelectionBag>>;

function toSelections(
  options: Record<string, string | boolean | undefined> | undefined,
): ReadonlyArray<ProviderOptionSelection> {
  const result: Array<ProviderOptionSelection> = [];
  if (!options) return result;
  for (const [id, value] of Object.entries(options)) {
    if (typeof value === "string" || typeof value === "boolean") {
      result.push({ id, value });
    }
  }
  return result;
}

function selectionsByProvider(
  options: Partial<Record<ProviderDriverKind, Record<string, string | boolean | undefined>>>,
): ProviderOptionSelectionsByProvider {
  const result: ProviderOptionSelectionsByProvider = {};
  for (const [provider, bag] of Object.entries(options) as Array<
    [ProviderDriverKind, Record<string, string | boolean | undefined>]
  >) {
    result[provider] = toSelections(bag);
  }
  return result;
}
import { afterEach, beforeEach, describe, expect, it, onTestFinished, vi } from "vite-plus/test";

import {
  COMPOSER_DRAFT_STORAGE_KEY,
  subscribeComposerDraftModelReconciliation,
  deriveEffectiveComposerModelState,
  clearComposerDraftsEnvironment,
  beginBackgroundDraftSubmissionByRef,
  clearBackgroundDraftSubmissionByRef,
  finalizePromotedDraftThreadByRef,
  markPromotedDraftThreadByRef,
  resolveDraftPromotionNavigationTarget,
  restoreFailedDraftThread,
  subscribeDraftThreadPromotion,
  type ComposerFileAttachment,
  type ComposerImageAttachment,
  composerFileNeedsReattach,
  partializeComposerDraftStoreState,
  useComposerDraftStore,
  DraftId,
} from "./composerDraftStore";
import { waitForDraftHeroTransition } from "./components/chat/draftHeroTransition";
import { insertInlineContextReference } from "./lib/composerContextReferences";
import {
  buildMessageContext,
  environmentContextRecord,
  terminalContextReference,
} from "./lib/composerContextRecords";
import { threadContextRecord } from "@t3tools/shared/composerContextReferences";
import {
  copiedComposerAttachmentFile,
  rememberCopiedComposerAttachments,
} from "./lib/copiedComposerAttachments";
import { formatTerminalContextReference, type TerminalContextDraft } from "./lib/terminalContext";
import { createDeferredStorage } from "./lib/storage";
import { applyPreviewServerSnapshot, resetPreviewStateForTests } from "./previewStateStore";

function makeImage(input: {
  id: string;
  previewUrl: string;
  name?: string;
  mimeType?: string;
  sizeBytes?: number;
  lastModified?: number;
}): ComposerImageAttachment {
  const name = input.name ?? "image.png";
  const mimeType = input.mimeType ?? "image/png";
  const sizeBytes = input.sizeBytes ?? 4;
  const lastModified = input.lastModified ?? 1_700_000_000_000;
  const file = new File([new Uint8Array(sizeBytes).fill(1)], name, {
    type: mimeType,
    lastModified,
  });
  return {
    type: "image",
    id: input.id,
    name,
    mimeType,
    sizeBytes: file.size,
    previewUrl: input.previewUrl,
    file,
  };
}

function makeFile(id: string): ComposerFileAttachment {
  const file = new File(["report"], "report.pdf", { type: "application/pdf" });
  return {
    type: "file",
    id,
    name: file.name,
    mimeType: file.type,
    sizeBytes: file.size,
    file,
  };
}

function makeTerminalContext(input: {
  id: string;
  text?: string;
  terminalId?: string;
  terminalLabel?: string;
  lineStart?: number;
  lineEnd?: number;
}): TerminalContextDraft {
  return {
    id: input.id,
    threadId: ThreadId.make("thread-dedupe"),
    terminalId: input.terminalId ?? "default",
    terminalLabel: input.terminalLabel ?? "Terminal 1",
    lineStart: input.lineStart ?? 4,
    lineEnd: input.lineEnd ?? 5,
    text: input.text ?? "git status\nOn branch main",
    createdAt: "2026-03-13T12:00:00.000Z",
  };
}

function resetComposerDraftStore() {
  useComposerDraftStore.setState({
    rewindingThreadKeys: new Set(),
    draftsByThreadKey: {},
    draftThreadsByThreadKey: {},
    logicalProjectDraftThreadKeyByLogicalProjectKey: {},
    backgroundSubmissionThreadKeys: {},
    promotedDraftRedirects: {},
    stickyModelSelectionByProvider: {},
    stickyOptionsByModelByProvider: {},
    stickyActiveProvider: null,
  });
}

function modelSelection(
  provider: ProviderDriverKind,
  model: string,
  options?: Record<string, string | boolean | undefined>,
): ModelSelection {
  return createModelSelection(defaultInstanceIdForDriver(provider), model, toSelections(options));
}

function providerModelOptions(
  options: Partial<Record<string, Record<string, string | boolean | undefined>>>,
): ProviderOptionSelectionsByProvider {
  return selectionsByProvider(options);
}

const TEST_ENVIRONMENT_ID = EnvironmentId.make("environment-local");
const OTHER_TEST_ENVIRONMENT_ID = EnvironmentId.make("environment-remote");
const LEGACY_TEST_ENVIRONMENT_ID = EnvironmentId.make("__legacy__");

function threadKeyFor(
  threadId: ThreadId,
  environmentId: EnvironmentId = LEGACY_TEST_ENVIRONMENT_ID,
): string {
  if (environmentId === LEGACY_TEST_ENVIRONMENT_ID) {
    return threadId;
  }
  return scopedThreadKey(scopeThreadRef(environmentId, threadId));
}

function draftFor(threadId: ThreadId, environmentId: EnvironmentId = LEGACY_TEST_ENVIRONMENT_ID) {
  const store = useComposerDraftStore.getState().draftsByThreadKey;
  return store[threadKeyFor(threadId, environmentId)] ?? store[threadId] ?? undefined;
}

function draftByKey(key: string) {
  return useComposerDraftStore.getState().draftsByThreadKey[key] ?? undefined;
}

describe("composerDraftStore addImages", () => {
  const threadId = ThreadId.make("thread-dedupe");
  const threadRef = scopeThreadRef(TEST_ENVIRONMENT_ID, threadId);
  let originalRevokeObjectUrl: typeof URL.revokeObjectURL;
  let revokeSpy: ReturnType<typeof vi.fn<(url: string) => void>>;

  beforeEach(() => {
    resetComposerDraftStore();
    originalRevokeObjectUrl = URL.revokeObjectURL;
    revokeSpy = vi.fn();
    URL.revokeObjectURL = revokeSpy;
  });

  afterEach(() => {
    URL.revokeObjectURL = originalRevokeObjectUrl;
  });

  it("restores images with matching metadata without replacing unsent bytes", () => {
    const store = useComposerDraftStore.getState();
    const unsent = makeImage({ id: "unsent", previewUrl: "blob:unsent" });
    const restored = {
      ...unsent,
      id: "restored",
      previewUrl: "blob:restored",
      file: new File([new Uint8Array(unsent.sizeBytes).fill(2)], unsent.name, {
        type: unsent.mimeType,
        lastModified: unsent.file.lastModified,
      }),
    };
    store.addImages(threadRef, [unsent]);
    store.addImages(threadRef, [restored, restored], { allowDuplicates: true });

    const images = store.getComposerDraft(threadRef)?.images;
    expect(images?.map((image) => image.id)).toEqual(["unsent", "restored"]);
    expect(images?.[0]?.file).toBe(unsent.file);
    expect(images?.[1]?.file).toBe(restored.file);
    expect(revokeSpy).not.toHaveBeenCalled();
  });

  it("deduplicates against existing images across calls by file signature", () => {
    const first = makeImage({
      id: "img-a",
      previewUrl: "blob:a",
      name: "same.png",
      mimeType: "image/png",
      sizeBytes: 9,
      lastModified: 777,
    });
    const duplicateLater = makeImage({
      id: "img-b",
      previewUrl: "blob:b",
      name: "same.png",
      mimeType: "image/png",
      sizeBytes: 9,
      lastModified: 999,
    });

    expect(useComposerDraftStore.getState().addImage(threadRef, first)).toBe(true);
    expect(useComposerDraftStore.getState().addImage(threadRef, duplicateLater)).toBe(false);

    const draft = draftFor(threadId, TEST_ENVIRONMENT_ID);
    expect(draft?.images.map((image) => image.id)).toEqual(["img-a"]);
    expect(revokeSpy).toHaveBeenCalledWith("blob:b");
  });
});

describe("composerDraftStore copied attachments", () => {
  beforeEach(resetComposerDraftStore);
  afterEach(() => {
    rememberCopiedComposerAttachments(TEST_ENVIRONMENT_ID, new Map());
    resetComposerDraftStore();
    vi.restoreAllMocks();
  });

  it("keeps unsent image and file bytes usable in another draft after source removal", async () => {
    const source = scopeThreadRef(TEST_ENVIRONMENT_ID, ThreadId.make("copy-source"));
    const target = scopeThreadRef(TEST_ENVIRONMENT_ID, ThreadId.make("copy-target"));
    const image = makeImage({ id: "uploading-image", previewUrl: "blob:source" });
    const file = makeFile("uploading-file");
    const revoke = vi.spyOn(URL, "revokeObjectURL").mockImplementation(() => {});
    const store = useComposerDraftStore.getState();
    store.addImages(source, [image]);
    store.addFiles(source, [file]);
    rememberCopiedComposerAttachments(
      TEST_ENVIRONMENT_ID,
      new Map([
        [image.id, image.file],
        [file.id, file.file!],
      ]),
    );

    store.removeImage(source, image.id);
    store.clearComposerContent(source);
    expect(store.getComposerDraft(source)).toBeNull();
    expect(revoke).toHaveBeenCalledWith(image.previewUrl);

    const copiedImage = copiedComposerAttachmentFile(TEST_ENVIRONMENT_ID, image.id);
    const copiedFile = copiedComposerAttachmentFile(TEST_ENVIRONMENT_ID, file.id);
    expect(copiedImage).toBe(image.file);
    expect(copiedFile).toBe(file.file);
    store.addImages(target, [{ ...image, file: copiedImage!, previewUrl: "blob:target" }]);
    store.addFiles(target, [{ ...file, file: copiedFile! }]);
    const draft = store.getComposerDraft(target)!;
    expect([...new Uint8Array(await draft.images[0]!.file.arrayBuffer())]).toEqual([1, 1, 1, 1]);
    expect(await draft.files[0]!.file!.text()).toBe("report");
  });

  it("does not reuse bytes from another environment or a superseded clipboard copy", () => {
    const first = makeImage({ id: "first", previewUrl: "blob:first" });
    const second = makeFile("second");
    rememberCopiedComposerAttachments(TEST_ENVIRONMENT_ID, new Map([[first.id, first.file]]));
    expect(copiedComposerAttachmentFile(OTHER_TEST_ENVIRONMENT_ID, first.id)).toBeUndefined();

    rememberCopiedComposerAttachments(TEST_ENVIRONMENT_ID, new Map([[second.id, second.file!]]));
    expect(copiedComposerAttachmentFile(TEST_ENVIRONMENT_ID, first.id)).toBeUndefined();
    expect(copiedComposerAttachmentFile(TEST_ENVIRONMENT_ID, second.id)).toBe(second.file);

    rememberCopiedComposerAttachments(TEST_ENVIRONMENT_ID, new Map());
    expect(copiedComposerAttachmentFile(TEST_ENVIRONMENT_ID, second.id)).toBeUndefined();
  });
});

describe("composerDraftStore unsent draft marker", () => {
  const threadId = ThreadId.make("thread-unsent-marker");

  beforeEach(() => {
    resetComposerDraftStore();
  });

  // regression: #11338 rewind locks are session-only and must not survive a reload
  it("does not persist active rewind locks", () => {
    const threadKey = threadKeyFor(threadId, TEST_ENVIRONMENT_ID);
    useComposerDraftStore.setState({ rewindingThreadKeys: new Set([threadKey]) });

    expect(useComposerDraftStore.getState().rewindingThreadKeys.has(threadKey)).toBe(true);
    expect(partializeComposerDraftStoreState(useComposerDraftStore.getState())).not.toHaveProperty(
      "rewindingThreadKeys",
    );
  });
});

describe("composerDraftStore file attachments", () => {
  const threadId = ThreadId.make("thread-files");
  const threadRef = scopeThreadRef(TEST_ENVIRONMENT_ID, threadId);

  beforeEach(() => {
    resetComposerDraftStore();
  });

  it("persists uploaded file references without including file contents", () => {
    const store = useComposerDraftStore.getState();
    store.addFiles(threadRef, [
      { ...makeFile("file-1"), source: { _tag: "pasted-text" as const } },
    ]);
    store.setFileUpload(threadRef, "file-1", TEST_ENVIRONMENT_ID, "pending-report-pdf");

    const persistApi = useComposerDraftStore.persist as unknown as {
      getOptions: () => {
        merge: (
          persistedState: unknown,
          currentState: ReturnType<typeof useComposerDraftStore.getState>,
        ) => ReturnType<typeof useComposerDraftStore.getState>;
      };
    };
    const options = persistApi.getOptions();
    const persisted = partializeComposerDraftStoreState(useComposerDraftStore.getState());

    expect(persisted.draftsByThreadKey[threadKeyFor(threadId, TEST_ENVIRONMENT_ID)]?.files).toEqual(
      [
        {
          id: "file-1",
          name: "report.pdf",
          mimeType: "application/pdf",
          sizeBytes: 6,
          attachmentId: "pending-report-pdf",
          environmentId: TEST_ENVIRONMENT_ID,
          source: { _tag: "pasted-text" },
        },
      ],
    );

    const hydrated = options.merge(persisted, useComposerDraftStore.getState());
    expect(hydrated.draftsByThreadKey[threadKeyFor(threadId, TEST_ENVIRONMENT_ID)]?.files).toEqual([
      {
        type: "file",
        id: "file-1",
        name: "report.pdf",
        mimeType: "application/pdf",
        sizeBytes: 6,
        file: null,
        uploadedAttachmentId: "pending-report-pdf",
        uploadEnvironmentId: TEST_ENVIRONMENT_ID,
        source: { _tag: "pasted-text" },
      },
    ]);
  });

  it("persists a pending file as a needs-reattach marker instead of dropping it", () => {
    const store = useComposerDraftStore.getState();
    store.addFiles(threadRef, [makeFile("file-pending")]);

    const persistApi = useComposerDraftStore.persist as unknown as {
      getOptions: () => {
        merge: (
          persistedState: unknown,
          currentState: ReturnType<typeof useComposerDraftStore.getState>,
        ) => ReturnType<typeof useComposerDraftStore.getState>;
      };
    };
    const options = persistApi.getOptions();
    const persisted = partializeComposerDraftStoreState(useComposerDraftStore.getState());

    expect(persisted.draftsByThreadKey[threadKeyFor(threadId, TEST_ENVIRONMENT_ID)]?.files).toEqual(
      [
        {
          id: "file-pending",
          name: "report.pdf",
          mimeType: "application/pdf",
          sizeBytes: 6,
        },
      ],
    );

    const hydrated = options.merge(persisted, useComposerDraftStore.getState());
    const hydratedFiles =
      hydrated.draftsByThreadKey[threadKeyFor(threadId, TEST_ENVIRONMENT_ID)]?.files;
    expect(hydratedFiles).toEqual([
      {
        type: "file",
        id: "file-pending",
        name: "report.pdf",
        mimeType: "application/pdf",
        sizeBytes: 6,
        file: null,
      },
    ]);
    expect(hydratedFiles?.every(composerFileNeedsReattach)).toBe(true);
  });

  it("marks only the matching byte-less upload as missing", () => {
    const store = useComposerDraftStore.getState();
    const hydrated: ComposerFileAttachment = {
      ...makeFile("file-hydrated"),
      file: null,
      uploadedAttachmentId: "pending-old",
      uploadEnvironmentId: TEST_ENVIRONMENT_ID,
    };
    const local: ComposerFileAttachment = {
      ...makeFile("file-local"),
      name: "local.txt",
      mimeType: "text/plain",
    };
    store.addFiles(threadRef, [hydrated, local]);
    store.setFileUpload(threadRef, hydrated.id, TEST_ENVIRONMENT_ID, "pending-new");
    store.setFileUpload(threadRef, local.id, TEST_ENVIRONMENT_ID, "pending-local");

    expect(
      store.markFileUploadMissing(threadRef, hydrated.id, OTHER_TEST_ENVIRONMENT_ID, "pending-new"),
    ).toBe(false);
    expect(
      store.markFileUploadMissing(threadRef, hydrated.id, TEST_ENVIRONMENT_ID, "pending-old"),
    ).toBe(false);
    expect(
      store.markFileUploadMissing(threadRef, local.id, TEST_ENVIRONMENT_ID, "pending-local"),
    ).toBe(false);

    expect(store.getComposerDraft(threadRef)?.files).toMatchObject([
      {
        id: hydrated.id,
        uploadedAttachmentId: "pending-new",
        uploadEnvironmentId: TEST_ENVIRONMENT_ID,
      },
      {
        id: local.id,
        file: local.file,
        uploadedAttachmentId: "pending-local",
        uploadEnvironmentId: TEST_ENVIRONMENT_ID,
      },
    ]);

    expect(
      store.markFileUploadMissing(threadRef, hydrated.id, TEST_ENVIRONMENT_ID, "pending-new"),
    ).toBe(true);
    const marker = store.getComposerDraft(threadRef)?.files[0];
    expect(marker && composerFileNeedsReattach(marker)).toBe(true);
    expect(marker?.uploadedAttachmentId).toBeUndefined();
    expect(marker?.uploadEnvironmentId).toBeUndefined();
  });

  it("enforces the combined file and image limit across separate updates", () => {
    const store = useComposerDraftStore.getState();
    const images = Array.from({ length: PROVIDER_SEND_TURN_MAX_ATTACHMENTS - 1 }, (_, index) =>
      makeImage({
        id: `image-${index}`,
        name: `image-${index}.png`,
        previewUrl: `blob:image-${index}`,
      }),
    );
    store.addImages(threadRef, images);
    store.addFiles(threadRef, [
      makeFile("file-accepted"),
      { ...makeFile("file-overflow"), name: "other.pdf" },
    ]);
    expect(
      store.addImage(
        threadRef,
        makeImage({ id: "image-overflow", name: "overflow.png", previewUrl: "blob:overflow" }),
      ),
    ).toBe(false);

    const draft = store.getComposerDraft(threadRef);
    expect(draft?.images).toHaveLength(PROVIDER_SEND_TURN_MAX_ATTACHMENTS - 1);
    expect(draft?.files.map((file) => file.id)).toEqual(["file-accepted"]);
  });

  it("reattaches a DNG with an older generic-MIME marker at attachment capacity", () => {
    const store = useComposerDraftStore.getState();
    const file = new File(["raw"], "photo.DNG", { type: "image/x-adobe-dng" });
    const marker: ComposerFileAttachment = {
      type: "file",
      id: "dng-marker",
      name: file.name,
      mimeType: "application/octet-stream",
      sizeBytes: file.size,
      file: null,
    };
    store.addFiles(threadRef, [marker]);
    store.addImages(
      threadRef,
      Array.from({ length: PROVIDER_SEND_TURN_MAX_ATTACHMENTS - 1 }, (_, index) =>
        makeImage({
          id: `image-${index}`,
          name: `image-${index}.png`,
          previewUrl: `blob:image-${index}`,
        }),
      ),
    );

    const repicked: ComposerFileAttachment = {
      ...marker,
      id: "dng-repicked",
      mimeType: file.type,
      file,
    };
    store.addFiles(threadRef, [repicked]);

    const files = store.getComposerDraft(threadRef)?.files;
    expect(files).toEqual([repicked]);
    expect(files?.some(composerFileNeedsReattach)).toBe(false);
  });

  it("replaces a needs-reattach marker when the same file is picked again", () => {
    const store = useComposerDraftStore.getState();
    const marker: ComposerFileAttachment = { ...makeFile("file-marker"), file: null };
    store.addFiles(threadRef, [marker]);
    expect(store.getComposerDraft(threadRef)?.files.every(composerFileNeedsReattach)).toBe(true);

    const repicked = makeFile("file-repicked");
    store.addFiles(threadRef, [repicked]);

    const files = store.getComposerDraft(threadRef)?.files;
    expect(files?.map((file) => file.id)).toEqual(["file-repicked"]);
    expect(files?.[0]?.file).not.toBeNull();
    expect(files?.some(composerFileNeedsReattach)).toBe(false);
  });
});

describe("composerDraftStore terminal contexts", () => {
  const threadId = ThreadId.make("thread-dedupe");
  const threadRef = scopeThreadRef(TEST_ENVIRONMENT_ID, threadId);

  beforeEach(() => {
    useComposerDraftStore.setState({
      draftsByThreadKey: {},
      draftThreadsByThreadKey: {},
      logicalProjectDraftThreadKeyByLogicalProjectKey: {},
      stickyModelSelectionByProvider: {},
      stickyActiveProvider: null,
    });
  });

  it("deduplicates identical terminal contexts by selection signature", () => {
    const first = makeTerminalContext({ id: "ctx-1" });
    const duplicate = makeTerminalContext({ id: "ctx-2" });

    useComposerDraftStore.getState().addTerminalContexts(threadRef, [first, duplicate]);

    const draft = draftFor(threadId, TEST_ENVIRONMENT_ID);
    expect(draft?.terminalContexts.map((context) => context.id)).toEqual(["ctx-1"]);
  });

  it("inserts terminal contexts at the requested inline prompt position", () => {
    const first = makeTerminalContext({ id: "ctx-1" });
    const second = makeTerminalContext({
      id: "ctx-2",
      terminalLabel: "Terminal 2",
      lineStart: 9,
      lineEnd: 10,
    });
    const firstInsertion = insertInlineContextReference(
      "alpha beta",
      6,
      terminalContextReference(first),
    );
    const secondInsertion = insertInlineContextReference(
      firstInsertion.prompt,
      0,
      terminalContextReference(second),
    );

    expect(
      useComposerDraftStore
        .getState()
        .insertTerminalContext(threadRef, firstInsertion.prompt, first, 0),
    ).toBe(true);
    expect(
      useComposerDraftStore
        .getState()
        .insertTerminalContext(threadRef, secondInsertion.prompt, second, 0),
    ).toBe(true);

    const draft = draftFor(threadId, TEST_ENVIRONMENT_ID);
    expect(draft?.prompt).toBe(
      `${formatTerminalContextReference(second)} alpha ${formatTerminalContextReference(first)} beta`,
    );
    expect(draft?.terminalContexts.map((context) => context.id)).toEqual(["ctx-2", "ctx-1"]);
  });

  it("sanitizes malformed persisted drafts during merge", () => {
    const persistApi = useComposerDraftStore.persist as unknown as {
      getOptions: () => {
        merge: (
          persistedState: unknown,
          currentState: ReturnType<typeof useComposerDraftStore.getState>,
        ) => ReturnType<typeof useComposerDraftStore.getState>;
      };
    };
    const mergedState = persistApi.getOptions().merge(
      {
        draftsByThreadId: {
          [threadId]: {
            prompt: "",
            attachments: "not-an-array",
            terminalContexts: "not-an-array",
            provider: "bogus-provider",
            modelOptions: "not-an-object",
          },
        },
        draftThreadsByThreadId: "not-an-object",
        projectDraftThreadIdByProjectKey: "not-an-object",
      },
      useComposerDraftStore.getInitialState(),
    );

    expect(mergedState.draftsByThreadKey[threadKeyFor(threadId)]).toBeUndefined();
    expect(mergedState.draftThreadsByThreadKey).toEqual({});
    expect(mergedState.logicalProjectDraftThreadKeyByLogicalProjectKey).toEqual({});
  });
});

describe("composerDraftStore context persistence", () => {
  const threadRef = scopeThreadRef(TEST_ENVIRONMENT_ID, ThreadId.make("context-persistence"));
  const annotation: PreviewAnnotationPayload = {
    id: "retry-note",
    pageUrl: "http://localhost:3000/checkout",
    pageTitle: "Checkout",
    comment: "Keep the cart after a failed payment",
    elements: [],
    regions: [{ id: "error-region", rect: { x: 10, y: 20, width: 100, height: 50 } }],
    strokes: [],
    styleChanges: [],
    screenshot: null,
    createdAt: "2026-09-06T10:00:00.000Z",
  };

  beforeEach(resetComposerDraftStore);

  it("preserves snapshots and inline positions through repeated persistence and hydration", () => {
    const terminal = {
      ...makeTerminalContext({ id: "checkout-console" }),
      threadId: threadRef.threadId,
    };
    const store = useComposerDraftStore.getState();
    store.addTerminalContexts(threadRef, [terminal]);
    store.addPreviewAnnotation(threadRef, annotation);
    const terminalLink = formatTerminalContextReference(terminal);
    const prompt = `Inspect ${terminalLink}. Apply [Retry note](t3-context://v1/preview-annotation/preview-annotation_retry-note). Compare ${terminalLink} again.`;
    store.setPrompt(threadRef, prompt);
    let state = useComposerDraftStore.getState();
    const merge = useComposerDraftStore.persist.getOptions().merge!;

    for (let reload = 0; reload < 3; reload++) {
      state = merge(
        JSON.parse(JSON.stringify(partializeComposerDraftStoreState(state))),
        useComposerDraftStore.getInitialState(),
      );
      const draft = state.draftsByThreadKey[scopedThreadKey(threadRef)];
      expect(draft?.prompt).toBe(prompt);
      expect(draft?.terminalContexts).toEqual([terminal]);
      expect(draft?.previewAnnotations).toEqual([annotation]);
    }
  });
});

describe("composerDraftStore thread contexts", () => {
  const threadId = ThreadId.make("thread-with-context");
  const threadRef = scopeThreadRef(TEST_ENVIRONMENT_ID, threadId);
  const attached = threadContextRecord(
    scopeThreadRef(TEST_ENVIRONMENT_ID, ThreadId.make("attached-thread")),
    "Fix [login] flow",
  );

  beforeEach(resetComposerDraftStore);

  it("attaches once per thread, appends one chip, and survives persistence", () => {
    const store = useComposerDraftStore.getState();
    store.setPrompt(threadRef, "Compare with");
    store.addThreadContexts(threadRef, [attached]);
    store.addThreadContexts(threadRef, [attached, { ...attached, title: "renamed" }]);

    const draft = draftFor(threadId, TEST_ENVIRONMENT_ID);
    expect(draft?.threadContexts).toEqual([attached]);
    expect(attached.label).toBe("Fix login flow");
    expect(draft?.prompt).toBe(
      `Compare with [${attached.label}](t3-context://v1/thread/${attached.contextId}) `,
    );

    const merge = useComposerDraftStore.persist.getOptions().merge!;
    const hydrated = merge(
      JSON.parse(
        JSON.stringify(partializeComposerDraftStoreState(useComposerDraftStore.getState())),
      ),
      useComposerDraftStore.getInitialState(),
    );
    expect(hydrated.draftsByThreadKey[scopedThreadKey(threadRef)]?.threadContexts).toEqual([
      attached,
    ]);
    expect(hydrated.draftsByThreadKey[scopedThreadKey(threadRef)]?.prompt).toBe(draft?.prompt);
  });
});

describe("composerDraftStore environment contexts", () => {
  const threadId = ThreadId.make("thread-with-machine");
  const threadRef = scopeThreadRef(TEST_ENVIRONMENT_ID, threadId);
  const vps = environmentContextRecord(EnvironmentId.make("environment-vps"), "Hetzner [vps]");

  beforeEach(resetComposerDraftStore);

  it("mentions a machine once, survives persistence, and sends only its identity", () => {
    const store = useComposerDraftStore.getState();
    store.setPrompt(threadRef, "Run it on");
    store.addEnvironmentContexts(threadRef, [vps]);
    store.addEnvironmentContexts(threadRef, [{ ...vps, label: "renamed" }]);

    const draft = draftFor(threadId, TEST_ENVIRONMENT_ID);
    expect(draft?.environmentContexts).toEqual([vps]);
    expect(vps.label).toBe("Hetzner vps");
    expect(draft?.prompt).toBe(
      `Run it on [${vps.label}](t3-context://v1/environment/${vps.contextId}) `,
    );

    const merge = useComposerDraftStore.persist.getOptions().merge!;
    const hydrated = merge(
      JSON.parse(
        JSON.stringify(partializeComposerDraftStoreState(useComposerDraftStore.getState())),
      ),
      useComposerDraftStore.getInitialState(),
    );
    const restored = hydrated.draftsByThreadKey[scopedThreadKey(threadRef)];
    expect(restored?.environmentContexts).toEqual([vps]);
    expect(restored?.prompt).toBe(draft?.prompt);

    expect(
      buildMessageContext({
        terminalContexts: [],
        reviewComments: [],
        previewAnnotations: [],
        environmentContexts: restored?.environmentContexts ?? [],
      })?.records,
    ).toEqual([
      {
        version: 1,
        kind: "environment",
        contextId: vps.contextId,
        label: "Hetzner vps",
        environmentId: "environment-vps",
      },
    ]);
  });

  it("drops the chip with the record and removes an otherwise empty draft", () => {
    const store = useComposerDraftStore.getState();
    store.addEnvironmentContexts(threadRef, [vps]);
    store.setEnvironmentContexts(threadRef, []);
    expect(draftFor(threadId, TEST_ENVIRONMENT_ID)).toBeUndefined();
  });
});

describe("composerDraftStore project draft thread mapping", () => {
  const projectId = ProjectId.make("project-a");
  const otherProjectId = ProjectId.make("project-b");
  const projectRef = scopeProjectRef(TEST_ENVIRONMENT_ID, projectId);
  const otherProjectRef = scopeProjectRef(TEST_ENVIRONMENT_ID, otherProjectId);
  const remoteProjectRef = scopeProjectRef(OTHER_TEST_ENVIRONMENT_ID, projectId);
  const threadId = ThreadId.make("thread-a");
  const otherThreadId = ThreadId.make("thread-b");
  const draftId = DraftId.make("draft-a");
  const otherDraftId = DraftId.make("draft-b");
  const sharedDraftId = DraftId.make("draft-shared");
  const localDraftId = DraftId.make("draft-local");
  const remoteDraftId = DraftId.make("draft-remote");

  beforeEach(() => {
    resetComposerDraftStore();
  });

  it("clears composer data for one environment without touching another", () => {
    const store = useComposerDraftStore.getState();
    const localThreadRef = scopeThreadRef(TEST_ENVIRONMENT_ID, threadId);
    const remoteThreadRef = scopeThreadRef(OTHER_TEST_ENVIRONMENT_ID, otherThreadId);
    const originalRevokeObjectUrl = URL.revokeObjectURL;
    const revokeSpy = vi.fn<(url: string) => void>();
    URL.revokeObjectURL = revokeSpy;

    try {
      store.setProjectDraftThreadId(projectRef, localDraftId, { threadId });
      store.setProjectDraftThreadId(remoteProjectRef, remoteDraftId, {
        threadId: otherThreadId,
      });
      store.setPrompt(localDraftId, "local draft");
      store.setPrompt(remoteDraftId, "remote draft");
      store.addImage(localDraftId, makeImage({ id: "img-local", previewUrl: "blob:local-draft" }));
      store.setPrompt(localThreadRef, "local thread draft");
      store.setPrompt(remoteThreadRef, "remote thread draft");
      useComposerDraftStore.setState({
        rewindingThreadKeys: new Set([
          threadKeyFor(threadId, TEST_ENVIRONMENT_ID),
          threadKeyFor(otherThreadId, OTHER_TEST_ENVIRONMENT_ID),
        ]),
      });

      clearComposerDraftsEnvironment(TEST_ENVIRONMENT_ID);

      const next = useComposerDraftStore.getState();
      expect([...next.rewindingThreadKeys]).toEqual([
        threadKeyFor(otherThreadId, OTHER_TEST_ENVIRONMENT_ID),
      ]);
      expect(next.getDraftThreadByProjectRef(projectRef)).toBeNull();
      expect(next.getDraftThreadByProjectRef(remoteProjectRef)).not.toBeNull();
      expect(next.getComposerDraft(localDraftId)).toBeNull();
      expect(next.getComposerDraft(remoteDraftId)?.prompt).toBe("remote thread draft");
      expect(next.getComposerDraft(localThreadRef)).toBeNull();
      expect(next.getComposerDraft(remoteThreadRef)?.prompt).toBe("remote thread draft");
      expect(revokeSpy).toHaveBeenCalledWith("blob:local-draft");
    } finally {
      URL.revokeObjectURL = originalRevokeObjectUrl;
    }
  });

  it("removes a draft's previous project mapping when retargeted in place", () => {
    const store = useComposerDraftStore.getState();
    store.setProjectDraftThreadId(projectRef, draftId, { threadId });
    store.setPrompt(draftId, "keep this prompt");

    store.setProjectDraftThreadId(otherProjectRef, draftId, { threadId });

    expect(store.getDraftThreadByProjectRef(projectRef)).toBeNull();
    expect(store.getDraftThreadByProjectRef(otherProjectRef)?.draftId).toBe(draftId);
    expect(store.getComposerDraft(draftId)?.prompt).toBe("keep this prompt");
  });

  it("rotates a failed bootstrap thread id without losing its draft", () => {
    const store = useComposerDraftStore.getState();
    const retryThreadId = ThreadId.make("thread-retry");
    store.setProjectDraftThreadId(projectRef, draftId, {
      threadId,
      branch: "feature/test",
      worktreePath: null,
      createdAt: "2026-01-01T00:00:00.000Z",
      envMode: "worktree",
      startFromOrigin: true,
      runtimeMode: "approval-required",
      interactionMode: "plan",
    });
    store.setPrompt(draftId, "keep this prompt");
    markPromotedDraftThreadByRef(scopeThreadRef(TEST_ENVIRONMENT_ID, threadId));

    store.setLogicalProjectDraftThreadId(scopedProjectKey(projectRef), projectRef, draftId, {
      threadId: retryThreadId,
      createdAt: "2026-01-01T00:01:00.000Z",
    });

    expect(useComposerDraftStore.getState().getDraftThread(draftId)).toMatchObject({
      threadId: retryThreadId,
      branch: "feature/test",
      worktreePath: null,
      createdAt: "2026-01-01T00:01:00.000Z",
      envMode: "worktree",
      startFromOrigin: true,
      runtimeMode: "approval-required",
      interactionMode: "plan",
      promotedTo: null,
    });
    expect(useComposerDraftStore.getState().getComposerDraft(draftId)?.prompt).toBe(
      "keep this prompt",
    );
  });

  it("clears only matching project draft mapping entries", () => {
    const store = useComposerDraftStore.getState();
    store.setProjectDraftThreadId(projectRef, draftId, { threadId });
    store.setPrompt(draftId, "hello");

    store.clearProjectDraftThreadById(projectRef, otherDraftId);
    expect(useComposerDraftStore.getState().getDraftThreadByProjectRef(projectRef)?.threadId).toBe(
      threadId,
    );

    store.clearProjectDraftThreadById(projectRef, draftId);
    expect(useComposerDraftStore.getState().getDraftThreadByProjectRef(projectRef)).toBeNull();
    expect(useComposerDraftStore.getState().getDraftThread(draftId)).toBeNull();
    expect(draftByKey(draftId)).toBeUndefined();
  });

  // regression: #1264 deleting a project must release its draft thread's image blob URLs
  it("revokes draft image blob URLs when clearing a project's draft thread", () => {
    const store = useComposerDraftStore.getState();
    const originalRevokeObjectUrl = URL.revokeObjectURL;
    const revokeSpy = vi.fn<(url: string) => void>();
    URL.revokeObjectURL = revokeSpy;

    try {
      store.setProjectDraftThreadId(projectRef, draftId, { threadId });
      store.addImage(draftId, makeImage({ id: "img-project-clear", previewUrl: "blob:clear" }));

      store.clearProjectDraftThreadId(projectRef);

      expect(useComposerDraftStore.getState().getDraftThreadByProjectRef(projectRef)).toBeNull();
      expect(useComposerDraftStore.getState().getDraftThread(draftId)).toBeNull();
      expect(revokeSpy).toHaveBeenCalledWith("blob:clear");
    } finally {
      URL.revokeObjectURL = originalRevokeObjectUrl;
    }
  });

  it("clears empty composer drafts when remapping a project to a new draft thread", () => {
    const store = useComposerDraftStore.getState();
    store.setProjectDraftThreadId(projectRef, draftId, { threadId });

    store.setProjectDraftThreadId(projectRef, otherDraftId, { threadId: otherThreadId });

    expect(useComposerDraftStore.getState().getDraftThreadByProjectRef(projectRef)?.threadId).toBe(
      otherThreadId,
    );
    expect(useComposerDraftStore.getState().getDraftThread(draftId)).toBeNull();
    expect(draftByKey(draftId)).toBeUndefined();
  });

  it("keeps a draft with an open page when remapping a project to a new draft thread", () => {
    const store = useComposerDraftStore.getState();
    store.setProjectDraftThreadId(projectRef, draftId, { threadId });
    applyPreviewServerSnapshot(scopeThreadRef(TEST_ENVIRONMENT_ID, threadId), {
      threadId,
      tabId: "tab-link",
      navStatus: { _tag: "Success", url: "https://example.com/", title: "Example" },
      canGoBack: false,
      canGoForward: false,
      updatedAt: "2026-10-09T00:00:00.000Z",
    });
    try {
      store.setProjectDraftThreadId(projectRef, otherDraftId, { threadId: otherThreadId });

      expect(useComposerDraftStore.getState().getDraftThread(draftId)?.threadId).toBe(threadId);
      const persisted = partializeComposerDraftStoreState(useComposerDraftStore.getState());
      expect(persisted.draftThreadsByThreadKey[draftId]?.threadId).toBe(threadId);
    } finally {
      resetPreviewStateForTests();
    }
  });

  it("keeps invested composer drafts alive unmapped when remapping a project to a new draft thread", () => {
    const store = useComposerDraftStore.getState();
    store.setProjectDraftThreadId(projectRef, draftId, { threadId });
    store.setPrompt(draftId, "keep me around");

    store.setProjectDraftThreadId(projectRef, otherDraftId, { threadId: otherThreadId });

    expect(useComposerDraftStore.getState().getDraftThreadByProjectRef(projectRef)?.threadId).toBe(
      otherThreadId,
    );
    expect(useComposerDraftStore.getState().getDraftThread(draftId)?.threadId).toBe(threadId);
    expect(draftByKey(draftId)?.prompt).toBe("keep me around");
  });

  it("clears every session for a project, including unmapped invested drafts", () => {
    const store = useComposerDraftStore.getState();
    store.setProjectDraftThreadId(projectRef, draftId, { threadId });
    store.setPrompt(draftId, "invested");
    store.setProjectDraftThreadId(projectRef, otherDraftId, { threadId: otherThreadId });

    store.clearProjectDraftThreadId(projectRef);

    expect(useComposerDraftStore.getState().getDraftThreadByProjectRef(projectRef)).toBeNull();
    expect(useComposerDraftStore.getState().getDraftThread(draftId)).toBeNull();
    expect(useComposerDraftStore.getState().getDraftThread(otherDraftId)).toBeNull();
    expect(draftByKey(draftId)).toBeUndefined();
  });

  it("keeps composer drafts when the thread is still mapped by another project", () => {
    const store = useComposerDraftStore.getState();
    store.setProjectDraftThreadId(projectRef, draftId, { threadId });
    store.setProjectDraftThreadId(otherProjectRef, sharedDraftId, { threadId });
    store.setPrompt(sharedDraftId, "keep me");

    store.clearProjectDraftThreadId(projectRef);

    expect(useComposerDraftStore.getState().getDraftThreadByProjectRef(projectRef)).toBeNull();
    expect(
      useComposerDraftStore.getState().getDraftThreadByProjectRef(otherProjectRef)?.threadId,
    ).toBe(threadId);
    expect(draftByKey(sharedDraftId)?.prompt).toBe("keep me");
  });

  it("does not clear composer drafts for existing server threads during promotion cleanup", () => {
    const store = useComposerDraftStore.getState();
    const threadRef = scopeThreadRef(TEST_ENVIRONMENT_ID, threadId);
    store.setPrompt(threadRef, "keep me");

    markPromotedDraftThreadByRef(scopeThreadRef(TEST_ENVIRONMENT_ID, threadId));

    expect(useComposerDraftStore.getState().getDraftThread(threadRef)).toBeNull();
    expect(draftFor(threadId, TEST_ENVIRONMENT_ID)?.prompt).toBe("keep me");
  });

  it("promotes matching thread ids separately for each environment", () => {
    const store = useComposerDraftStore.getState();
    const localThreadRef = scopeThreadRef(TEST_ENVIRONMENT_ID, threadId);
    const remoteThreadRef = scopeThreadRef(OTHER_TEST_ENVIRONMENT_ID, threadId);

    store.setProjectDraftThreadId(projectRef, localDraftId, { threadId });
    store.setPrompt(localDraftId, "local draft");
    store.setProjectDraftThreadId(remoteProjectRef, remoteDraftId, { threadId });
    store.setPrompt(remoteDraftId, "remote draft");

    markPromotedDraftThreadByRef(localThreadRef);

    expect(store.getDraftThreadByProjectRef(projectRef)).toBeNull();
    expect(store.getDraftThreadByProjectRef(remoteProjectRef)?.threadId).toBe(threadId);
    expect(store.getDraftThreadByRef(localThreadRef)?.promotedTo).toEqual(localThreadRef);
    expect(store.getDraftThreadByRef(remoteThreadRef)?.promotedTo).toBeNull();
    expect(draftByKey(localDraftId)?.prompt).toBe("local draft");
    expect(draftByKey(remoteDraftId)?.prompt).toBe("remote draft");

    markPromotedDraftThreadByRef(remoteThreadRef);

    expect(store.getDraftThreadByProjectRef(projectRef)).toBeNull();
    expect(store.getDraftThreadByProjectRef(remoteProjectRef)).toBeNull();
    expect(store.getDraftThreadByRef(localThreadRef)?.promotedTo).toEqual(localThreadRef);
    expect(store.getDraftThreadByRef(remoteThreadRef)?.promotedTo).toEqual(remoteThreadRef);
    expect(draftByKey(localDraftId)?.prompt).toBe("local draft");
    expect(draftByKey(remoteDraftId)?.prompt).toBe("remote draft");
  });

  it("keeps background submission pending until navigation or failure releases it", () => {
    const store = useComposerDraftStore.getState();
    store.setProjectDraftThreadId(projectRef, draftId, { threadId });
    const ref = scopeThreadRef(TEST_ENVIRONMENT_ID, threadId);
    const key = scopedThreadKey(ref);
    beginBackgroundDraftSubmissionByRef(ref);
    expect(useComposerDraftStore.getState().backgroundSubmissionThreadKeys[key]).toBe(true);
    clearBackgroundDraftSubmissionByRef(ref);
    expect(useComposerDraftStore.getState().backgroundSubmissionThreadKeys[key]).toBeUndefined();
    expect(useComposerDraftStore.getState().getDraftSession(draftId)).not.toBeNull();
    beginBackgroundDraftSubmissionByRef(ref);
    finalizePromotedDraftThreadByRef(ref);
    expect(useComposerDraftStore.getState().backgroundSubmissionThreadKeys[key]).toBeUndefined();
    expect(useComposerDraftStore.getState().getDraftSession(draftId)).toBeNull();
  });

  it("restores a failed draft without changing the fresh draft", () => {
    const store = useComposerDraftStore.getState();
    store.setProjectDraftThreadId(projectRef, draftId, { threadId });
    const sentDraft = useComposerDraftStore.getState().getDraftSession(draftId)!;
    markPromotedDraftThreadByRef(scopeThreadRef(TEST_ENVIRONMENT_ID, threadId));
    const freshId = DraftId.make("fresh-background-draft");
    store.setProjectDraftThreadId(projectRef, freshId, { threadId: ThreadId.make("fresh-thread") });
    store.setPrompt(freshId, "new work");
    store.setDraftThreadContext(draftId, { branch: "retry-base" });
    restoreFailedDraftThread(draftId, sentDraft, ThreadId.make("retry-thread"));
    store.setPrompt(draftId, "retry work");
    expect(useComposerDraftStore.getState().getDraftSession(draftId)?.promotedTo).toBeNull();
    expect(useComposerDraftStore.getState().getDraftSession(draftId)?.threadId).toBe(
      "retry-thread",
    );
    expect(useComposerDraftStore.getState().getDraftSession(draftId)?.branch).toBe("retry-base");
    expect(draftByKey(freshId)?.prompt).toBe("new work");
    expect(draftByKey(draftId)?.prompt).toBe("retry work");
  });

  it("moves composer edits made during promotion to the canonical thread", () => {
    const store = useComposerDraftStore.getState();
    store.setProjectDraftThreadId(projectRef, draftId, { threadId });
    markPromotedDraftThreadByRef(scopeThreadRef(TEST_ENVIRONMENT_ID, threadId));
    store.setPrompt(draftId, "typed during setup");

    finalizePromotedDraftThreadByRef(scopeThreadRef(TEST_ENVIRONMENT_ID, threadId));

    expect(useComposerDraftStore.getState().getDraftThreadByProjectRef(projectRef)).toBeNull();
    expect(useComposerDraftStore.getState().getDraftThread(draftId)).toBeNull();
    expect(draftByKey(draftId)).toBeUndefined();
    expect(draftFor(threadId, TEST_ENVIRONMENT_ID)?.prompt).toBe("typed during setup");
  });

  it("finalizes a matching materialized draft even when promotion was not pre-marked", () => {
    const store = useComposerDraftStore.getState();
    store.setProjectDraftThreadId(projectRef, draftId, { threadId });
    store.setPrompt(draftId, "promote me");

    finalizePromotedDraftThreadByRef(scopeThreadRef(TEST_ENVIRONMENT_ID, threadId));

    expect(useComposerDraftStore.getState().getDraftThreadByProjectRef(projectRef)).toBeNull();
    expect(useComposerDraftStore.getState().getDraftThread(draftId)).toBeNull();
    expect(draftByKey(draftId)).toBeUndefined();
    expect(draftFor(threadId, TEST_ENVIRONMENT_ID)?.prompt).toBe("promote me");
  });

  it("preserves existing branch and worktree when setProjectDraftThreadId receives undefined", () => {
    const store = useComposerDraftStore.getState();
    store.setProjectDraftThreadId(projectRef, draftId, {
      threadId,
      branch: "main",
      worktreePath: "/tmp/main-worktree",
    });
    const runtimeUndefinedOptions = {
      branch: undefined,
      worktreePath: undefined,
    } as unknown as {
      branch?: string | null;
      worktreePath?: string | null;
    };
    store.setProjectDraftThreadId(projectRef, draftId, runtimeUndefinedOptions);

    expect(useComposerDraftStore.getState().getDraftThread(draftId)).toMatchObject({
      environmentId: TEST_ENVIRONMENT_ID,
      projectId,
      branch: "main",
      worktreePath: "/tmp/main-worktree",
      envMode: "worktree",
    });
  });

  it("clears branch and worktree but keeps env mode when remapping a draft to another environment", () => {
    const store = useComposerDraftStore.getState();
    store.setProjectDraftThreadId(projectRef, draftId, {
      threadId,
      branch: "feature/local-only",
      worktreePath: "/tmp/local-worktree",
      envMode: "worktree",
      startFromOrigin: true,
    });

    store.setLogicalProjectDraftThreadId(scopedProjectKey(projectRef), remoteProjectRef, draftId, {
      threadId,
    });

    expect(useComposerDraftStore.getState().getDraftThread(draftId)).toMatchObject({
      environmentId: OTHER_TEST_ENVIRONMENT_ID,
      projectId,
      branch: null,
      worktreePath: null,
      envMode: "worktree",
      startFromOrigin: true,
    });
  });

  it("clears stale upload metadata when retargeting a draft to another environment", () => {
    const store = useComposerDraftStore.getState();
    const hydratedFile: ComposerFileAttachment = {
      ...makeFile("file-cross-environment"),
      file: null,
      uploadedAttachmentId: "local-environment-upload",
      uploadEnvironmentId: TEST_ENVIRONMENT_ID,
    };

    store.setProjectDraftThreadId(projectRef, draftId, { threadId });
    store.addFiles(draftId, [hydratedFile]);

    store.setProjectDraftThreadId(remoteProjectRef, draftId, { threadId });

    const file = store.getComposerDraft(draftId)?.files[0];
    expect(file).toMatchObject({
      id: hydratedFile.id,
      file: null,
    });
    expect(file?.uploadedAttachmentId).toBeUndefined();
    expect(file?.uploadEnvironmentId).toBeUndefined();
    expect(file && composerFileNeedsReattach(file)).toBe(true);
  });

  it("rechecks balancing when an empty draft is remapped to another project member", () => {
    const store = useComposerDraftStore.getState();
    store.setProjectDraftThreadId(projectRef, draftId, {
      threadId,
      environmentSelection: "auto",
      loadBalancedEnvironmentId: TEST_ENVIRONMENT_ID,
    });
    store.setProjectDraftThreadId(remoteProjectRef, draftId, { threadId });
    expect(store.getDraftThread(draftId)).toMatchObject({
      environmentSelection: "auto",
      loadBalancedEnvironmentId: null,
    });
    store.setDraftThreadContext(draftId, { loadBalancedEnvironmentId: OTHER_TEST_ENVIRONMENT_ID });
    store.setDraftThreadContext(draftId, { projectRef });
    expect(store.getDraftThread(draftId)).toMatchObject({
      environmentSelection: "auto",
      loadBalancedEnvironmentId: null,
    });
  });

  it("pins manual workspace choices and can return to automatic routing without losing the prompt", () => {
    const store = useComposerDraftStore.getState();
    store.setProjectDraftThreadId(projectRef, draftId, { threadId });
    store.setPrompt(draftId, "keep this prompt");
    store.setDraftThreadContext(draftId, {
      projectRef: remoteProjectRef,
      environmentSelection: "auto",
      loadBalancedEnvironmentId: OTHER_TEST_ENVIRONMENT_ID,
    });
    expect(store.getDraftThread(draftId)).toMatchObject({
      environmentId: OTHER_TEST_ENVIRONMENT_ID,
      environmentSelection: "auto",
      loadBalancedEnvironmentId: OTHER_TEST_ENVIRONMENT_ID,
    });
    store.setDraftThreadContext(draftId, { branch: "feature/pinned" });
    expect(store.getDraftThread(draftId)?.environmentSelection).toBe("manual");
    store.setDraftThreadContext(draftId, {
      branch: null,
      environmentSelection: "auto",
      loadBalancedEnvironmentId: null,
    });
    expect(store.getDraftThread(draftId)).toMatchObject({
      branch: null,
      environmentSelection: "auto",
      loadBalancedEnvironmentId: null,
    });
    expect(store.getComposerDraft(draftId)?.prompt).toBe("keep this prompt");
  });
});

function modelReconciliationHarness(
  environmentId: EnvironmentId,
  threadId: ThreadId,
  initialStatus: EnvironmentShellStatus = "live",
) {
  const tasks: Array<() => void> = [];
  const registry = AtomRegistry.make({
    scheduleTask: (task) => {
      tasks.push(task);
      return () => {};
    },
  });
  onTestFinished(() => registry.dispose());
  const flush = () => {
    for (let task = tasks.shift(); task !== undefined; task = tasks.shift()) task();
  };
  const selectedThreadId = ThreadId.make("another-selected-thread");
  const thread: OrchestrationV2ThreadShell = {
    ...makeThreadProjectionFixture().thread,
    latestRunId: null,
    activeRunId: null,
    status: "idle",
    pendingRuntimeRequest: null,
    latestVisibleMessage: null,
    latestUserMessageAt: null,
    hasActionableProposedPlan: false,
    itemCount: 0,
    visibleItemCount: 0,
  };
  const initialSnapshot: OrchestrationV2ShellSnapshot = {
    schemaVersion: 1,
    snapshotSequence: 0,
    projects: [],
    archivedThreads: [],
    threads: [
      { ...thread, id: threadId },
      { ...thread, id: selectedThreadId },
    ],
  };
  const shellStateAtom = Atom.make<EnvironmentShellState>({
    ...EMPTY_SHELL_STATE,
    snapshot: Option.some(initialSnapshot),
    status: initialStatus,
  });
  const shellResultAtom = Atom.map(shellStateAtom, AsyncResult.success);
  const snapshotAtom = createEnvironmentSnapshotAtom(() => shellResultAtom)(environmentId);
  const catalogValueAtom = Atom.make({
    isReady: true,
    entries: new Map([
      [
        environmentId,
        {
          target: new PrimaryConnectionTarget({
            environmentId,
            label: "Environment",
            httpBaseUrl: "https://example.test",
            wsBaseUrl: "wss://example.test",
          }),
          profile: Option.none(),
          enabled: true,
        },
      ],
    ]),
  });
  const shells = createEnvironmentThreadShellAtoms({
    catalogValueAtom,
    snapshotAtom: () => snapshotAtom,
    hiddenThreadTagsAtom: () => Atom.make(null),
  });
  const selectedShell = shells.threadShellAtom({ environmentId, threadId: selectedThreadId });
  onTestFinished(registry.mount(selectedShell));
  onTestFinished(
    subscribeComposerDraftModelReconciliation({
      registry,
      threadShellAtom: shells.threadShellAtom,
      threadRefsAtom: shells.threadRefsAtom,
      shellStateAtom: () => shellResultAtom,
    }),
  );
  flush();
  return {
    flush,
    setStatus(status: EnvironmentShellStatus) {
      registry.set(shellStateAtom, { ...registry.get(shellStateAtom), status });
      flush();
    },
    update(changes: Partial<OrchestrationV2ThreadShell>, status?: EnvironmentShellStatus) {
      const state = registry.get(shellStateAtom);
      const snapshot = Option.getOrThrow(state.snapshot);
      registry.set(shellStateAtom, {
        ...state,
        status: status ?? state.status,
        snapshot: Option.some(
          applyShellStreamEvent(snapshot, {
            kind: "thread.updated",
            location: "active",
            sequence: snapshot.snapshotSequence + 1,
            thread: { ...snapshot.threads[0]!, ...changes },
          }),
        ),
      });
      flush();
      expect(registry.get(selectedShell)?.id).toBe(selectedThreadId);
    },
    model: () => registry.get(shells.threadShellAtom({ environmentId, threadId }))!.modelSelection,
  };
}

type PromotionShell = NonNullable<
  Parameters<typeof resolveDraftPromotionNavigationTarget>[0]["serverThread"]
>;

function draftPromotionHarness() {
  const tasks: Array<() => void> = [];
  const registry = AtomRegistry.make({
    scheduleTask: (task) => {
      tasks.push(task);
      return () => {};
    },
  });
  onTestFinished(() => registry.dispose());
  const flush = () => {
    for (let task = tasks.shift(); task !== undefined; task = tasks.shift()) task();
  };
  const threadRefsAtom = Atom.make<ReadonlyArray<ScopedThreadRef>>([]);
  const shellAtoms = new Map<string, Atom.Writable<PromotionShell | null>>();
  const shellAtom = (ref: ScopedThreadRef) => {
    const key = scopedThreadKey(ref);
    let atom = shellAtoms.get(key);
    if (!atom) {
      atom = Atom.make<PromotionShell | null>(null);
      shellAtoms.set(key, atom);
    }
    return atom;
  };
  onTestFinished(
    subscribeDraftThreadPromotion({ registry, threadRefsAtom, threadShellAtom: shellAtom }),
  );
  flush();
  return {
    flush,
    arrive(ref: ScopedThreadRef, shell: PromotionShell | null = null) {
      registry.set(shellAtom(ref), shell);
      registry.set(threadRefsAtom, [...registry.get(threadRefsAtom), ref]);
      flush();
    },
    updateShell(ref: ScopedThreadRef, shell: PromotionShell) {
      registry.set(shellAtom(ref), shell);
      flush();
    },
  };
}

describe("composerDraftStore draft promotion", () => {
  const projectRef = scopeProjectRef(TEST_ENVIRONMENT_ID, ProjectId.make("project-promotion"));
  const draftId = DraftId.make("draft-promotion");
  const threadId = ThreadId.make("thread-promotion");
  const threadRef = scopeThreadRef(TEST_ENVIRONMENT_ID, threadId);
  const preparingRun = {
    runId: RunId.make("run-promotion"),
    status: "preparing" as const,
    requestedAt: "2026-03-29T00:00:00.000Z",
    startedAt: null,
    completedAt: null,
    assistantMessageId: null,
  };

  beforeEach(resetComposerDraftStore);

  it("stays on the draft until the server owns the send", () => {
    expect(
      resolveDraftPromotionNavigationTarget({
        serverThreadRef: threadRef,
        serverThread: { latestRun: preparingRun, latestUserMessageAt: null },
        backgroundSubmissionPending: false,
      }),
    ).toBeNull();
    expect(
      resolveDraftPromotionNavigationTarget({
        serverThreadRef: threadRef,
        serverThread: { latestRun: null, latestUserMessageAt: null },
        backgroundSubmissionPending: false,
      }),
    ).toBeNull();
    const persisted = { latestRun: preparingRun, latestUserMessageAt: "2026-03-29T00:00:00.000Z" };
    expect(
      resolveDraftPromotionNavigationTarget({
        serverThreadRef: threadRef,
        serverThread: persisted,
        backgroundSubmissionPending: false,
      }),
    ).toBe(threadRef);
    expect(
      resolveDraftPromotionNavigationTarget({
        serverThreadRef: threadRef,
        serverThread: persisted,
        backgroundSubmissionPending: true,
      }),
    ).toBeNull();
  });

  it("marks a draft promoting when its reserved thread arrives, then finalizes into it", async () => {
    const h = draftPromotionHarness();
    const store = useComposerDraftStore.getState();
    store.setProjectDraftThreadId(projectRef, draftId, { threadId });
    store.setPrompt(draftId, "typed during setup");
    h.flush();
    expect(store.getDraftSession(draftId)?.promotedTo).toBeNull();

    h.arrive(threadRef, { latestRun: preparingRun, latestUserMessageAt: null });
    expect(useComposerDraftStore.getState().getDraftSession(draftId)?.promotedTo).toEqual(
      threadRef,
    );

    h.updateShell(threadRef, {
      latestRun: preparingRun,
      latestUserMessageAt: "2026-03-29T00:00:00.000Z",
    });
    await waitForDraftHeroTransition();

    const state = useComposerDraftStore.getState();
    expect(state.getDraftSession(draftId)).toBeNull();
    expect(state.getPromotedDraftRedirect(draftId)).toEqual(threadRef);
    expect(draftFor(threadId, TEST_ENVIRONMENT_ID)?.prompt).toBe("typed during setup");
  });

  it("holds a background submission on its draft until the send settles", async () => {
    const h = draftPromotionHarness();
    const store = useComposerDraftStore.getState();
    store.setProjectDraftThreadId(projectRef, draftId, { threadId });
    beginBackgroundDraftSubmissionByRef(threadRef);
    h.arrive(threadRef, {
      latestRun: preparingRun,
      latestUserMessageAt: "2026-03-29T00:00:00.000Z",
    });
    await waitForDraftHeroTransition();
    expect(useComposerDraftStore.getState().getDraftSession(draftId)?.promotedTo).toEqual(
      threadRef,
    );

    clearBackgroundDraftSubmissionByRef(threadRef);
    h.flush();
    await waitForDraftHeroTransition();
    expect(useComposerDraftStore.getState().getDraftSession(draftId)).toBeNull();
  });

  it("does not finalize a draft whose send failed and was restored", async () => {
    const h = draftPromotionHarness();
    const store = useComposerDraftStore.getState();
    store.setProjectDraftThreadId(projectRef, draftId, { threadId });
    const sent = useComposerDraftStore.getState().getDraftSession(draftId)!;
    h.arrive(threadRef, {
      latestRun: { ...preparingRun, status: "failed" as const },
      latestUserMessageAt: null,
    });
    restoreFailedDraftThread(draftId, sent, ThreadId.make("retry-thread"));
    h.flush();
    await waitForDraftHeroTransition();
    expect(useComposerDraftStore.getState().getDraftSession(draftId)?.threadId).toBe(
      "retry-thread",
    );
  });
});

describe("composerDraftStore modelSelection", () => {
  const threadId = ThreadId.make("thread-model-options");
  const threadRef = scopeThreadRef(TEST_ENVIRONMENT_ID, threadId);

  beforeEach(() => {
    resetComposerDraftStore();
  });

  it("retains a pick matching cached state until the live shell confirms it", () => {
    const h = modelReconciliationHarness(TEST_ENVIRONMENT_ID, threadId, "cached");
    const pick = h.model();
    useComposerDraftStore.getState().setModelSelection(threadRef, pick, { explicit: true });
    h.flush();
    const before = draftFor(threadId, TEST_ENVIRONMENT_ID);
    expect(before?.modelSelectionByProvider[pick.instanceId]).toEqual(pick);

    for (const status of ["empty", "synchronizing", "cached"] as const) {
      h.setStatus(status);
      expect(draftFor(threadId, TEST_ENVIRONMENT_ID)).toEqual(before);
    }
    h.update({ modelSelection: { ...pick, model: "remote-model" } }, "live");
    expect(draftFor(threadId, TEST_ENVIRONMENT_ID)).toEqual(before);
    h.update({ modelSelection: pick }, "synchronizing");
    expect(draftFor(threadId, TEST_ENVIRONMENT_ID)).toEqual(before);
    h.setStatus("live");
    expect(draftFor(threadId, TEST_ENVIRONMENT_ID)).toBeUndefined();
  });

  it("releases an inactive thread pick only after its queued model becomes durable", () => {
    const store = useComposerDraftStore.getState();
    const pick = modelSelection(CODEX_DRIVER, "gpt-5.5", { fastMode: false });
    store.setPrompt(threadRef, "keep this unsent follow-up");
    store.addImage(threadRef, makeImage({ id: "image", previewUrl: "blob:keep-image" }));
    store.setTerminalContexts(threadRef, [makeTerminalContext({ id: "terminal" })]);
    store.setRuntimeMode(threadRef, "approval-required");
    store.setInteractionMode(threadRef, "plan");
    store.setModelSelection(threadRef, pick, { explicit: true });
    const before = draftFor(threadId, TEST_ENVIRONMENT_ID)!;
    const remoteRef = scopeThreadRef(OTHER_TEST_ENVIRONMENT_ID, threadId);
    store.setModelSelection(remoteRef, pick, { explicit: true });
    const remoteBefore = draftFor(threadId, OTHER_TEST_ENVIRONMENT_ID);
    const h = modelReconciliationHarness(TEST_ENVIRONMENT_ID, threadId);

    h.update({ status: "queued" });
    expect(draftFor(threadId, TEST_ENVIRONMENT_ID)).toEqual(before);
    h.update({ status: "running", modelSelection: modelSelection(CODEX_DRIVER, "gpt-5.5") });
    expect(draftFor(threadId, TEST_ENVIRONMENT_ID)).toEqual({
      ...before,
      activeProvider: null,
      modelSelectionByProvider: {},
      modelSelectionExplicit: undefined,
    });
    expect(draftFor(threadId, OTHER_TEST_ENVIRONMENT_ID)).toEqual(remoteBefore);

    const remoteModel = DEFAULT_MODEL_BY_PROVIDER[CLAUDE_AGENT_DRIVER]!;
    h.update({ modelSelection: modelSelection(CLAUDE_AGENT_DRIVER, remoteModel) });
    const effective = deriveEffectiveComposerModelState({
      draft: draftFor(threadId, TEST_ENVIRONMENT_ID),
      providers: [
        {
          instanceId: CLAUDE_AGENT_INSTANCE,
          driver: CLAUDE_AGENT_DRIVER,
          enabled: true,
          installed: true,
          version: null,
          status: "ready",
          auth: { status: "authenticated" },
          checkedAt: "2026-01-01T00:00:00.000Z",
          models: [{ slug: remoteModel, name: remoteModel, isCustom: false, capabilities: {} }],
          slashCommands: [],
          skills: [],
        },
      ],
      selectedProvider: CLAUDE_AGENT_DRIVER,
      selectedInstanceId: CLAUDE_AGENT_INSTANCE,
      threadModelSelection: h.model(),
      projectModelSelection: null,
      settings: DEFAULT_UNIFIED_SETTINGS,
    });
    expect(effective.selectedModel).toBe(remoteModel);
    expect(draftFor(threadId, TEST_ENVIRONMENT_ID)?.modelSelectionByProvider).toEqual({});
  });

  it("retains an unavailable provider pick through differing durable model updates", () => {
    const store = useComposerDraftStore.getState();
    const pick = createModelSelection(CODEX_SECONDARY_INSTANCE, "gpt-5.5", [
      { id: "reasoningEffort", value: "high" },
      { id: "fastMode", value: true },
    ]);
    // A remembered primary pick is the visible fallback while the secondary is unavailable.
    const primary = modelSelection(CODEX_DRIVER, DEFAULT_MODEL);
    store.setModelSelection(threadRef, primary);
    store.setModelSelection(threadRef, pick, { explicit: true });
    const before = draftFor(threadId, TEST_ENVIRONMENT_ID);
    const h = modelReconciliationHarness(TEST_ENVIRONMENT_ID, threadId);
    h.update({ modelSelection: primary });
    const fallback = deriveEffectiveComposerModelState({
      draft: before,
      providers: [],
      selectedProvider: CODEX_DRIVER,
      selectedInstanceId: CODEX_INSTANCE,
      threadModelSelection: h.model(),
      projectModelSelection: null,
      settings: DEFAULT_UNIFIED_SETTINGS,
    });
    expect(fallback.selectedModel).toBe(h.model().model);
    expect(draftFor(threadId, TEST_ENVIRONMENT_ID)).toEqual(before);

    for (const modelSelection of [
      { ...pick, instanceId: CODEX_INSTANCE },
      { ...pick, model: "gpt-5.4" },
      { ...pick, options: [{ id: "reasoningEffort", value: "high" }] },
      {
        ...pick,
        options: [
          { id: "reasoningEffort", value: "low" },
          { id: "fastMode", value: true },
        ],
      },
    ]) {
      h.update({ modelSelection });
      expect(draftFor(threadId, TEST_ENVIRONMENT_ID)).toEqual(before);
    }
    h.update({ modelSelection: { ...pick, options: pick.options!.toReversed() } });
    expect(draftFor(threadId, TEST_ENVIRONMENT_ID)).toBeUndefined();
  });

  it("marks picker writes explicit and seeding writes non-explicit", () => {
    const store = useComposerDraftStore.getState();
    store.setModelSelection(threadRef, modelSelection(CODEX_DRIVER, "gpt-5.4"));
    expect(draftFor(threadId, TEST_ENVIRONMENT_ID)?.modelSelectionExplicit).toBeUndefined();

    store.setModelSelection(threadRef, modelSelection(CODEX_DRIVER, "gpt-5.4"), {
      explicit: true,
    });
    expect(draftFor(threadId, TEST_ENVIRONMENT_ID)?.modelSelectionExplicit).toBe(true);

    store.setModelSelection(threadRef, modelSelection(CODEX_DRIVER, "gpt-5.4"), {
      replaceOptions: true,
    });
    expect(draftFor(threadId, TEST_ENVIRONMENT_ID)?.modelSelectionExplicit).toBeUndefined();
  });

  it("replaces only the targeted provider options on the current model selection", () => {
    const store = useComposerDraftStore.getState();

    store.setModelSelection(
      threadRef,
      modelSelection(CLAUDE_AGENT_DRIVER, "claude-opus-4-6", {
        effort: "max",
        fastMode: true,
      }),
    );
    store.setStickyModelSelection(
      modelSelection(CLAUDE_AGENT_DRIVER, "claude-opus-4-6", {
        effort: "max",
        fastMode: true,
      }),
    );

    store.setProviderModelOptions(
      threadRef,
      CLAUDE_AGENT_DRIVER,
      toSelections({ thinking: false }),
      {