Skip to content

armgit / cindy

Public Imported from GitHub
0

Consider it done. The open-source AI agent that works out of the box · 想到,就能做到。开源、开箱即用的 AI Agent。

79.9 KB
Raw Blame
/**
 * 新建会话乐观管线(newSessionCreation)状态机测试:
 *  - start 同步段:合成会话行(pendingLocalCreation)+ 乐观排队气泡即时入 store;
 *  - createSession 收到预生成 id;瞬态失败 probe-before-retry(回执丢失不重复建会话);
 *    确定性失败不盲重、直接 create-failed;
 *  - enqueue 失败的分辨:队列 / 消息含 clientId → 按成功收敛;确认未应用 →
 *    enqueue-failed(乐观气泡摘除,草稿留给会话页回填);
 *  - retry(同 id 幂等)与 dismiss(返回编辑)收口。
 */
import { beforeEach, describe, expect, it, vi } from 'vitest';
import type { MobileMakerTransport } from '@/device-link/mobileMakerTransport';
import type { RemoteSerializedAttachment } from '@/session/types';
import { createDurableOutbox, type DurableOutboxRecord } from '@/session/durableOutbox';
import { buildOutboxItem } from '@/session/sessionOutbox';
import { createOutboxMessageLeases, outboxNeedsReconciliation, outboxSessionIsHidden } from '@/session/mobileOutboxSessionAdapter';

const recoveryStorage = vi.hoisted(() => new Map<string, string>());
const persistCancelledDraft = vi.hoisted(() => vi.fn(async () => {}));
const editOutbox = vi.hoisted(() => ({ records: vi.fn((): DurableOutboxRecord[] => []), update: vi.fn(async (_record: DurableOutboxRecord, _patch: Partial<DurableOutboxRecord>) => {}) }));
vi.mock('@/session/mobileDurableOutbox', () => ({
  persistCancelledCreationDraft: persistCancelledDraft,
  suspendCreationDraftForCleanup: vi.fn(async () => {}),
  getCurrentMobileOutboxRecords: editOutbox.records,
  isDurableOutboxCreationHeld: () => false,
  mobileDurableOutbox: { update: editOutbox.update, subscribe: () => () => {}, reconcileDrafts: async () => {} },
}));
import { getMobileAuthOwner, setMobileAuthOwner } from '@/auth/authOwnerGeneration';
import { returnNewSessionToEdit } from '@/session/returnNewSessionToEdit';
const recoveryAsyncStorage = vi.hoisted(() => ({
  getItem: vi.fn(async (key: string) => recoveryStorage.get(key) ?? null),
  setItem: vi.fn(async (key: string, value: string) => {
    recoveryStorage.set(key, value);
  }),
  removeItem: vi.fn(async (key: string) => {
    recoveryStorage.delete(key);
  }),
}));

vi.mock('@react-native-async-storage/async-storage', () => ({
  default: recoveryAsyncStorage,
}));

// expo-crypto 是原生模块(createUuid 的 CSPRNG 兜底;node 环境有 crypto.randomUUID
// 不会走到),node 下 import 副作用不可控,mock 掉。
vi.mock('expo-crypto', () => ({
  getRandomBytes: (n: number) => new Uint8Array(n).fill(7),
}));
import {
  completeNewSessionDurableEdit,
  findNewSessionEditDraft,
  appendNewSessionEditComposer,
  dismissNewSessionCreation,
  dismissRecoveredPrecreatedSession,
  drainStashedNewSessionDraft,
  getNewSessionCreationTask,
  prepareNewSessionCreationForEdit,
  retryNewSessionCreation,
  restoreNewSessionDurableEdit,
  shouldBlockSessionSync,
  stashNewSessionDraftForEdit,
  startNewSessionCreation,
  withNewSessionCreationRemoval,
  type NewSessionCreationParams,
} from '@/session/newSessionCreation';
import { remoteSessionStore } from '@/session/remoteSessionStore';
import { takeOrcaStartFailure } from '@/session/orcaTeam';
import { sessionFromCreateResult, type NewSessionDraft } from '@/session/newSession';
import {
  __testing as recoveryTesting,
  listPendingPrecreatedWorktrees,
  registerPendingPrecreatedWorktree,
} from '@/session/precreatedWorktreeRecovery';

const DRAFT: NewSessionDraft = {
  agentKind: 'claude-code',
  workspaceKind: 'project',
  workingDir: '/repo',
  model: 'claude-sonnet-4-6',
  providerId: null,
  effort: 'medium',
  permissionMode: 'auto',
  fastMode: false,
  firstMessage: 'hello world',
};

// Exercise the production lease manager with the real session store, including
// hydration, cancellation cleanup and message-work lease release.
function outboxLeaseHarness(initial: DurableOutboxRecord[]) {
  let records = initial;
  const visible = new Set<string>();
  const manager = createOutboxMessageLeases({
    isCurrent: () => true,
    getRecords: () => records,
    hidden: record => outboxSessionIsHidden(record, remoteSessionStore.getSessions()),
    needsReconciliation: record => outboxNeedsReconciliation(record, visible.has(record.item.sessionId)),
    restoreEditable: restoreNewSessionDurableEdit,
    dismissCancelled: dismissRecoveredPrecreatedSession,
    store: remoteSessionStore,
  });
  return { ...manager, visible, setRecords: (next: DurableOutboxRecord[]) => { records = next; } };
}
function recoveryOutboxRecord(sessionId: string): DurableOutboxRecord {
  return { version: 1, accountId: 'owner-a', deviceId: 'dev-1', createdAt: 1, state: 'failed', uploads: [],
    creation: { draft: DRAFT, deviceName: 'PC', planModeArm: false, restorePermissionMode: null },
    item: buildOutboxItem({ clientId: `message-${sessionId}`, sessionId, text: DRAFT.firstMessage,
      quotesEncoded: false, agentReferences: [], pastedTextRanges: [], slashCommandRanges: [],
      permissionModeAtSend: DRAFT.permissionMode, readyAttachments: [], readyPreviews: [], claimedUploads: [] }) };
}

interface MakerMock {
  createSession: ReturnType<typeof vi.fn>;
  getSession: ReturnType<typeof vi.fn>;
  listMessages: ReturnType<typeof vi.fn>;
  setPlanMode: ReturnType<typeof vi.fn>;
  setPermissionMode: ReturnType<typeof vi.fn>;
  worktree: {
    discardPrecreated: ReturnType<typeof vi.fn>;
    cancelPrecreated?: ReturnType<typeof vi.fn>;
  };
  input: {
    enqueue: ReturnType<typeof vi.fn>;
    getProjection: ReturnType<typeof vi.fn>;
  };
}

function makeMaker(overrides: Partial<MakerMock> = {}): MakerMock {
  return {
    createSession: vi.fn(async (opts: { id?: string }) => ({ sessionId: opts.id })),
    getSession: vi.fn(async () => {
      throw new Error('NOT_FOUND');
    }),
    listMessages: vi.fn(async () => []),
    setPlanMode: vi.fn(async () => undefined),
    setPermissionMode: vi.fn(async () => undefined),
    worktree: {
      discardPrecreated: vi.fn(async () => ({ discarded: true })),
    },
    ...overrides,
    input: {
      enqueue: vi.fn(async () => ({ sessionId: 's', pendingQueue: [] })),
      getProjection: vi.fn(async () => ({ sessionId: 's', pendingQueue: [] })),
      ...(overrides.input ?? {}),
    },
  };
}

function makeParams(sessionId: string, maker: MakerMock, patch: Partial<NewSessionCreationParams> = {}): NewSessionCreationParams {
  return {
    sessionId,
    deviceId: 'dev-1',
    deviceName: 'Mac',
    draft: DRAFT,
    attachments: [],
    planModeArm: false,
    legacyPlanRestore: null,
    confirmUnauthenticated: () => Promise.resolve({ unauthenticated: false, fresh: null }),
    authGateHint: '请先在电脑端完成登录。',
    onUnauthenticated: () => undefined,
    transport: {
      maker: maker as unknown as MobileMakerTransport,
      openLink: vi.fn(async () => undefined),
      subscribe: vi.fn(async () => undefined),
    },
    // 退避 / enqueue 分辨轮询的 sleep 注入为立即返回,测试不真等。
    sleep: async () => undefined,
    ...patch,
  };
}

async function flushPipeline(): Promise<void> {
  // 管线全程无真实网络且 sleep 已注入为立即返回,靠让出事件循环多个宏任务收敛
  //(enqueue 分辨轮询最多 4 轮 × 每轮 2 个远程查询)。setImmediate 不受
  // Windows 约 15ms 的 setTimeout(0) 粒度影响;8 轮覆盖管线所有异步边界。
  for (let i = 0; i < 8; i += 1) {
    await new Promise<void>((resolve) => setImmediate(resolve));
  }
}

describe('newSessionCreation pipeline', () => {
  it('carries unsent composer text and files through legacy memory recovery', async () => {
    const maker = makeMaker({ createSession: vi.fn(async () => { throw new Error('[MODEL_UNAVAILABLE] unavailable'); }) });
    startNewSessionCreation(makeParams('s1', maker));
    await flushPipeline();
    await returnNewSessionToEdit({ sessionId: 's1', deviceId: 'dev-1', isCurrent: () => true, onReady: vi.fn() });
    const file = { id: 'new-file', path: 'oss://new-file', category: 'image', name: 'new.png', ext: 'png', size: 1 } as RemoteSerializedAttachment;
    await appendNewSessionEditComposer('s1', 'dev-1', { text: 'unsent addition', attachments: [file], notice: 'one pending upload' });
    const restored = drainStashedNewSessionDraft('s1', 'dev-1')!;
    expect(restored.draft.firstMessage).toBe(`${DRAFT.firstMessage}\n\nunsent addition`);
    expect(restored.attachments).toEqual([file]);
    expect(restored.notice).toBe('one pending upload');
  });
  it.each([false, true])('deletes a failed local task only after worktree cleanup (cleanup fails: %s)', async fails => {
    const maker = makeMaker();
    startNewSessionCreation(makeParams('s1', maker, {
      draft: { ...DRAFT, workingDir: '/repo/.cindy-worktrees/a' },
      precreatedWorktree: { path: '/repo/.cindy-worktrees/a', recoveryKey: 'cleanup-a', originalWorkingDir: '/repo' },
      confirmUnauthenticated: async () => ({ unauthenticated: true, fresh: null }),
    }));
    await flushPipeline();
    if (fails) maker.worktree.discardPrecreated.mockRejectedValueOnce(new Error('cleanup refused'));
    const remove = vi.fn();
    const removal = withNewSessionCreationRemoval('s1', 'dev-1', 'deleted', remove);
    if (fails) {
      await expect(removal).rejects.toThrow('cleanup refused');
      expect(getNewSessionCreationTask('s1')).toMatchObject({ status: 'create-failed', returningToEdit: false });
      expect(remoteSessionStore.getSessions().some(row => row.id === 's1')).toBe(true);
    } else {
      await removal;
      expect(getNewSessionCreationTask('s1')).toBeNull();
      expect(remoteSessionStore.getSessions()).toEqual([]);
    }
    expect(maker.worktree.discardPrecreated).toHaveBeenCalledOnce();
    expect(remove).not.toHaveBeenCalled();
  });

  beforeEach(async () => {
    persistCancelledDraft.mockReset();
    editOutbox.records.mockReset().mockReturnValue([]);
    editOutbox.update.mockReset().mockResolvedValue(undefined);
    setMobileAuthOwner(null);
    setMobileAuthOwner('owner-a');
    await recoveryTesting.drainMutations();
    recoveryStorage.clear();
    recoveryTesting.resetVolatileLedgers();
    remoteSessionStore.clear();
    // 清残留 task(上个用例失败态)。
    for (const id of [
      's1',
      's2',
      's3',
      's4',
      's5',
      's6',
      's7',
      's8',
      's9',
      's10',
      's11',
      's12',
      's13',
      's14',
      's15',
      's16',
      's17',
      's18',
      's19',
      's20',
      's21',
      's22',
      's23',
    ]) dismissNewSessionCreation(id);
  });

  it('recovers the original draft and attachments from a group rejection before source metadata exists', async () => {
    const attachments = [{ id: 'attachment-a', name: 'notes.txt', ext: '.txt', path: '/uploads/notes.txt', category: 'file' as const, mimeType: 'text/plain', size: 10 }];
    const maker = makeMaker({ createSession: vi.fn(async () => { throw new Error('[REMOTE_AGENT_GROUP_UNAVAILABLE] group unavailable'); }) });
    startNewSessionCreation(makeParams('s1', maker, { attachments }));
    await flushPipeline();
    expect(getNewSessionCreationTask('s1')?.status).toBe('create-failed');
    expect(remoteSessionStore.getSessions().find(s => s.id === 's1')?.source).toBeUndefined();
    const onReady = vi.fn();
    await returnNewSessionToEdit({ sessionId: 's1', deviceId: 'dev-1', isCurrent: () => true, onReady });
    expect(drainStashedNewSessionDraft('s1', 'dev-1')).toMatchObject({ draft: DRAFT, attachments });
    expect(getNewSessionCreationTask('s1')).toBeNull();
    expect(onReady).toHaveBeenCalledWith({ deviceId: 'dev-1', deviceName: 'Mac', editSessionId: 's1' });
  });

  it.each([false, true])('keeps durable recovery bytes and only leaves after suspension is saved (save fails: %s)', async (fails) => {
    const maker = makeMaker({ createSession: vi.fn(async () => { throw new Error('[MODEL_UNAVAILABLE] unavailable'); }) });
    startNewSessionCreation(makeParams('s1', maker));
    await flushPipeline();
    const record = { ...recoveryOutboxRecord('s1'), accountId: getMobileAuthOwner().accountKey };
    editOutbox.records.mockReturnValue([record]);
    if (fails) editOutbox.update.mockRejectedValueOnce(new Error('storage full'));
    const onReady = vi.fn();
    const recovery = returnNewSessionToEdit({ sessionId: 's1', deviceId: 'dev-1', isCurrent: () => true, onReady });
    if (fails) {
      await expect(recovery).rejects.toThrow('storage full');
      expect(getNewSessionCreationTask('s1')?.status).toBe('create-failed');
      expect(getNewSessionCreationTask('s1')?.returningToEdit).toBe(false);
      expect(onReady).not.toHaveBeenCalled();
      retryNewSessionCreation('s1');
      await flushPipeline();
      expect(maker.createSession).toHaveBeenCalledTimes(2);
    } else {
      await recovery;
      expect(getNewSessionCreationTask('s1')?.readyForEdit).toBe('durable');
      expect(onReady).toHaveBeenCalledWith({ deviceId: 'dev-1', deviceName: 'Mac', recoverySessionId: 's1' });
      completeNewSessionDurableEdit('s1', 'another-device');
      expect(getNewSessionCreationTask('s1')?.readyForEdit).toBe('durable');
      completeNewSessionDurableEdit('s1', 'dev-1');
      expect(getNewSessionCreationTask('s1')).toBeNull();
    }
    expect(editOutbox.update).toHaveBeenCalledWith(record, expect.objectContaining({
      suspended: true, state: 'failed', error: '[MODEL_UNAVAILABLE] unavailable',
    }));
    expect(record.item.text).toBe(DRAFT.firstMessage);
    expect(record.creation?.draft).toEqual(DRAFT);
    expect(drainStashedNewSessionDraft('s1', 'dev-1')).toBeNull();
  });

  it.each(['editReady', 'cancelled'] as const)('restores a persisted %s edit entry after restart and keeps it until the matching form claims it', async marker => {
    const bytes = new Map<string, string>();
    const storage = { getAllKeys: async () => [...bytes.keys()], getItem: async (key: string) => bytes.get(key) ?? null,
      setItem: async (key: string, value: string) => { bytes.set(key, value); },
      removeItem: async (key: string) => { bytes.delete(key); } };
    const owner = getMobileAuthOwner();
    const original = recoveryOutboxRecord('s1');
    const record = { ...original, accountId: owner.accountKey, suspended: true,
      creation: { ...original.creation!, [marker]: true as const } };
    const beforeRestart = createDurableOutbox(storage);
    await beforeRestart.activate(owner.accountKey);
    await beforeRestart.add(record);
    const diskSnapshot = [...bytes];
    const afterRestart = createDurableOutbox(storage);
    await afterRestart.activate(owner.accountKey);
    editOutbox.records.mockImplementation(() => [...afterRestart.getSnapshot()]);
    const bridge = outboxLeaseHarness([...afterRestart.getSnapshot()]);
    bridge.refresh();
    expect(remoteSessionStore.getSessions()).toEqual([]);
    expect(bridge.leases.size).toBe(0);
    expect(getNewSessionCreationTask('s1')).toMatchObject({ readyForEdit: 'durable', draft: DRAFT });
    expect(getNewSessionCreationTask('s1')).toBe(getNewSessionCreationTask('s1'));
    expect(shouldBlockSessionSync('s1')).toBe(true);
    const onReady = vi.fn();
    await returnNewSessionToEdit({ sessionId: 's1', deviceId: 'dev-1', isCurrent: () => true, onReady });
    expect(onReady).toHaveBeenCalledWith({ deviceId: 'dev-1', deviceName: 'PC', recoverySessionId: 's1' });
    completeNewSessionDurableEdit('s1', 'wrong-device');
    expect(getNewSessionCreationTask('s1')?.readyForEdit).toBe('durable');
    completeNewSessionDurableEdit('s1', 'dev-1');
    bridge.refresh();
    expect(getNewSessionCreationTask('s1')).toBeNull();
    expect(remoteSessionStore.getSessions()).toEqual([]);
    expect([...bytes]).toEqual(diskSnapshot);
    expect(editOutbox.update).not.toHaveBeenCalled();
    if (marker === 'editReady') {
      remoteSessionStore.upsertDeviceSession('dev-1', 'PC', {
        ...sessionFromCreateResult({ sessionId: 's1' }, DRAFT), pendingLocalCreation: false,
      });
      bridge.refresh();
      expect(remoteSessionStore.getSessions().some(row => row.id === 's1')).toBe(true);
      remoteSessionStore.clear();
    }
    // If the editor is lost in another restart before submitting, the saved draft is reachable again.
    setMobileAuthOwner(null);
    setMobileAuthOwner('owner-a');
    const secondRestart = createDurableOutbox(storage);
    await secondRestart.activate(owner.accountKey);
    editOutbox.records.mockImplementation(() => [...secondRestart.getSnapshot()]);
    bridge.setRecords([...secondRestart.getSnapshot()]);
    bridge.refresh();
    expect(getNewSessionCreationTask('s1')?.readyForEdit).toBe('durable');
    setMobileAuthOwner('owner-b');
    expect(getNewSessionCreationTask('s1')).toBeNull();
  });

  it.each(['editReady', 'cancelled'] as const)('releases the %s claim only after the last editor leaves and can be claimed again', marker => {
    const original = recoveryOutboxRecord('s1');
    const record = { ...original, accountId: getMobileAuthOwner().accountKey, suspended: true,
      creation: { ...original.creation!, [marker]: true as const } };
    editOutbox.records.mockReturnValue([record]);
    restoreNewSessionDurableEdit(record);
    const releaseFirst = completeNewSessionDurableEdit('s1', 'dev-1');
    const releaseSecond = completeNewSessionDurableEdit('s1', 'dev-1');
    expect(releaseFirst).toBeTypeOf('function');
    expect(releaseSecond).toBeTypeOf('function');
    releaseFirst!();
    releaseFirst!();
    expect(getNewSessionCreationTask('s1')).toBeNull();
    expect(remoteSessionStore.getSessions()).toEqual([]);
    releaseSecond!();
    expect(getNewSessionCreationTask('s1')?.readyForEdit).toBe('durable');
    expect(remoteSessionStore.getSessions()).toEqual([]);
    const releaseReopened = completeNewSessionDurableEdit('s1', 'dev-1');
    releaseSecond!();
    expect(getNewSessionCreationTask('s1')).toBeNull();
    releaseReopened!();
    expect(getNewSessionCreationTask('s1')?.draft).toEqual(DRAFT);
    expect(editOutbox.update).not.toHaveBeenCalled();
  });

  it.each(['submitted', 'removed', 'replaced', 'account'] as const)('does not resurrect an old edit entry on form cleanup after %s', change => {
    const original = recoveryOutboxRecord('s1');
    const record = { ...original, accountId: getMobileAuthOwner().accountKey, suspended: true,
      creation: { ...original.creation!, editReady: true as const } };
    editOutbox.records.mockReturnValue([record]);
    restoreNewSessionDurableEdit(record);
    const release = completeNewSessionDurableEdit('s1', 'dev-1');
    if (change === 'submitted') editOutbox.records.mockReturnValue([{ ...record, suspended: false, state: 'queued' }]);
    if (change === 'removed') editOutbox.records.mockReturnValue([]);
    let releaseReplacement: (() => void) | undefined;
    if (change === 'replaced') {
      editOutbox.records.mockReturnValue([{ ...record }]);
      releaseReplacement = completeNewSessionDurableEdit('s1', 'dev-1');
    }
    if (change === 'account') setMobileAuthOwner('owner-b');
    release!();
    expect(remoteSessionStore.getSessions()).toEqual([]);
    expect(getNewSessionCreationTask('s1')).toBeNull();
    expect(editOutbox.update).not.toHaveBeenCalled();
    releaseReplacement?.();
  });

  it.each(['cancellation-save', 'edit-save'])('keeps creation locked after worktree cleanup when %s fails, then retries only recovery', async failure => {
    const maker = makeMaker();
    startNewSessionCreation(makeParams('s1', maker, {
      draft: { ...DRAFT, workingDir: '/repo/.cindy-worktrees/a' },
      precreatedWorktree: { path: '/repo/.cindy-worktrees/a', recoveryKey: 'cleanup-a', originalWorkingDir: '/repo' },
      confirmUnauthenticated: async () => ({ unauthenticated: true, fresh: null }),
    }));
    await flushPipeline();
    const record = { ...recoveryOutboxRecord('s1'), accountId: getMobileAuthOwner().accountKey };
    editOutbox.records.mockReturnValue([record]);
    if (failure === 'cancellation-save') persistCancelledDraft.mockRejectedValueOnce(new Error('disk full'));
    else editOutbox.update.mockRejectedValueOnce(new Error('disk full'));
    const onReady = vi.fn();
    await expect(returnNewSessionToEdit({ sessionId: 's1', deviceId: 'dev-1', isCurrent: () => true, onReady })).rejects.toThrow('disk full');
    expect(getNewSessionCreationTask('s1')).toMatchObject({ worktreeCleanupAcknowledged: true, returningToEdit: false });
    expect(onReady).not.toHaveBeenCalled();
    retryNewSessionCreation('s1');
    await flushPipeline();
    expect(maker.createSession).not.toHaveBeenCalled();
    await returnNewSessionToEdit({ sessionId: 's1', deviceId: 'dev-1', isCurrent: () => true, onReady });
    expect(maker.worktree.discardPrecreated).toHaveBeenCalledTimes(1);
    expect(getNewSessionCreationTask('s1')?.readyForEdit).toBe('durable');
    expect(onReady).toHaveBeenCalledWith({ deviceId: 'dev-1', deviceName: 'Mac', recoverySessionId: 's1' });
    expect(editOutbox.update).toHaveBeenLastCalledWith(record, expect.objectContaining({
      suspended: true, creation: expect.objectContaining({ editReady: true }),
    }));
  });

  it('lets the mounted composer stash its follow-ups before dismissing the task or navigating', async () => {
    const maker = makeMaker({ createSession: vi.fn(async () => { throw new Error('[MODEL_UNAVAILABLE] unavailable'); }) });
    startNewSessionCreation(makeParams('s1', maker));
    await flushPipeline();
    const stashDraft = vi.fn((task) => {
      expect(getNewSessionCreationTask('s1')?.status).toBe('create-failed');
      expect(remoteSessionStore.getSessions().find(s => s.id === 's1')?.status).toBe('active');
      stashNewSessionDraftForEdit(task, { draft: { ...task.draft, firstMessage: 'hello world\n\nfollow-up' } });
    });
    const onReady = vi.fn(() => {
      expect(stashDraft).toHaveBeenCalledOnce();
      expect(getNewSessionCreationTask('s1')?.readyForEdit).toBe('memory');
      expect(drainStashedNewSessionDraft('s1', 'dev-1')?.draft.firstMessage).toBe('hello world\n\nfollow-up');
      expect(getNewSessionCreationTask('s1')).toBeNull();
    });
    await returnNewSessionToEdit({ sessionId: 's1', deviceId: 'dev-1', isCurrent: () => true, stashDraft, onReady });
    expect(onReady).toHaveBeenCalledOnce();
  });

  it.each(['failure', 'success', 'leave', 'switch-account'])('preserves the worktree compensation gate when returning to edit: %s', async (outcome) => {
    let resolveDiscard!: (value: { discarded: boolean }) => void;
    let rejectDiscard!: (error: Error) => void;
    const maker = makeMaker({ worktree: { discardPrecreated: vi.fn(() => new Promise((resolve, reject) => {
      resolveDiscard = resolve; rejectDiscard = reject;
    })) } });
    startNewSessionCreation(makeParams('s1', maker, {
      draft: { ...DRAFT, workingDir: '/repo/.cindy-worktrees/new-task' },
      precreatedWorktree: { path: '/repo/.cindy-worktrees/new-task', recoveryKey: 'edit-recovery-key', originalWorkingDir: '/repo' },
      confirmUnauthenticated: async () => ({ unauthenticated: true, fresh: null }),
    }));
    await flushPipeline();
    let current = true;
    const onReady = vi.fn();
    const recovery = returnNewSessionToEdit({ sessionId: 's1', deviceId: 'dev-1', isCurrent: () => current, onReady });
    await flushPipeline();
    expect(onReady).not.toHaveBeenCalled();
    expect(drainStashedNewSessionDraft('s1', 'dev-1')).toBeNull();
    expect(getNewSessionCreationTask('s1')).not.toBeNull();
    expect(getNewSessionCreationTask('s1')?.returningToEdit).toBe(true);
    retryNewSessionCreation('s1');
    await returnNewSessionToEdit({ sessionId: 's1', deviceId: 'dev-1', isCurrent: () => true, onReady });
    expect(maker.worktree.discardPrecreated).toHaveBeenCalledTimes(1);
    expect(getNewSessionCreationTask('s1')?.status).toBe('create-failed');
    if (outcome === 'failure') {
      rejectDiscard(new Error('[PRECONDITION_FAILED] cleanup pending'));
      await expect(recovery).rejects.toThrow('cleanup pending');
      expect(getNewSessionCreationTask('s1')?.returningToEdit).toBe(false);
    } else {
      if (outcome === 'leave') current = false;
      if (outcome === 'switch-account') setMobileAuthOwner('owner-b');
      resolveDiscard({ discarded: true });
      await recovery;
    }
    if (outcome === 'success' || outcome === 'leave') {
      expect(getNewSessionCreationTask('s1')?.readyForEdit).toBe('memory');
      expect(drainStashedNewSessionDraft('s1', 'dev-1')?.draft.workingDir).toBe('/repo');
      expect(getNewSessionCreationTask('s1')).toBeNull();
      expect(remoteSessionStore.getSessions().find(s => s.id === 's1')).toBeUndefined();
      expect(onReady).toHaveBeenCalledTimes(outcome === 'success' ? 1 : 0);
    } else {
      expect(drainStashedNewSessionDraft('s1', 'dev-1')).toBeNull();
      if (outcome === 'switch-account') expect(getNewSessionCreationTask('s1')).toBeNull();
      else expect(getNewSessionCreationTask('s1')?.status).toBe('create-failed');
      expect(onReady).not.toHaveBeenCalled();
    }
  });

  it.each(['leave', 'switch-account'])('finishes durable edit recovery after leaving but fences account changes: %s', async (outcome) => {
    const maker = makeMaker({ createSession: vi.fn(async () => { throw new Error('[MODEL_UNAVAILABLE] unavailable'); }) });
    startNewSessionCreation(makeParams('s1', maker));
    await flushPipeline();
    const record = { ...recoveryOutboxRecord('s1'), accountId: getMobileAuthOwner().accountKey };
    editOutbox.records.mockReturnValue([record]);
    let finishSave!: () => void;
    editOutbox.update.mockImplementationOnce(() => new Promise<void>(resolve => { finishSave = resolve; }));
    let current = true;
    const onReady = vi.fn();
    const recovery = returnNewSessionToEdit({ sessionId: 's1', deviceId: 'dev-1', isCurrent: () => current, onReady });
    await flushPipeline();
    expect(editOutbox.update).toHaveBeenCalledWith(record, expect.objectContaining({ suspended: true, state: 'failed' }));
    expect(getNewSessionCreationTask('s1')?.status).toBe('create-failed');
    current = false;
    // A fresh page has no local busy flag: the task itself must exclude both actions.
    expect(getNewSessionCreationTask('s1')?.returningToEdit).toBe(true);
    const createCalls = maker.createSession.mock.calls.length;
    retryNewSessionCreation('s1');
    await returnNewSessionToEdit({ sessionId: 's1', deviceId: 'dev-1', isCurrent: () => true, onReady });
    await flushPipeline();
    expect(maker.createSession).toHaveBeenCalledTimes(createCalls);
    expect(editOutbox.update).toHaveBeenCalledTimes(1);
    expect(getNewSessionCreationTask('s1')?.status).toBe('create-failed');
    if (outcome === 'switch-account') setMobileAuthOwner('owner-b');
    finishSave();
    await recovery;
    expect(onReady).not.toHaveBeenCalled();
    if (outcome === 'leave') {
      expect(getNewSessionCreationTask('s1')?.readyForEdit).toBe('durable');
      expect(remoteSessionStore.getSessions().some(s => s.id === 's1')).toBe(true);
      retryNewSessionCreation('s1');
      expect(getNewSessionCreationTask('s1')?.status).toBe('create-failed');
      await returnNewSessionToEdit({ sessionId: 's1', deviceId: 'dev-1', isCurrent: () => true, onReady });
      expect(onReady).toHaveBeenCalledWith({ deviceId: 'dev-1', deviceName: 'Mac', recoverySessionId: 's1' });
      expect(editOutbox.update).toHaveBeenCalledTimes(1);
      expect(maker.createSession).toHaveBeenCalledTimes(createCalls);
      completeNewSessionDurableEdit('s1', 'dev-1');
      expect(getNewSessionCreationTask('s1')).toBeNull();
    } else {
      expect(getNewSessionCreationTask('s1')).toBeNull();
    }
    expect(drainStashedNewSessionDraft('s1', 'dev-1')).toBeNull();
  });

  it('keeps a cancelled durable worktree recovery visible until its form accepts it', async () => {
    const maker = makeMaker();
    startNewSessionCreation(makeParams('s1', maker, {
      draft: { ...DRAFT, workingDir: '/repo/.cindy-worktrees/a' },
      precreatedWorktree: { path: '/repo/.cindy-worktrees/a', recoveryKey: 'durable-a', originalWorkingDir: '/repo' },
      confirmUnauthenticated: async () => ({ unauthenticated: true, fresh: null }),
    }));
    await flushPipeline();
    const record = { ...recoveryOutboxRecord('s1'), accountId: getMobileAuthOwner().accountKey };
    persistCancelledDraft.mockImplementationOnce(async () => { record.creation!.cancelled = true; });
    editOutbox.records.mockReturnValue([record]);
    let finishSave!: () => void;
    editOutbox.update.mockImplementationOnce(() => new Promise<void>(resolve => { finishSave = resolve; }));
    let current = true;
    const onReady = vi.fn();
    const recovery = returnNewSessionToEdit({ sessionId: 's1', deviceId: 'dev-1', isCurrent: () => current, onReady });
    await flushPipeline();
    current = false;
    finishSave();
    await recovery;
    const bridge = outboxLeaseHarness([record]);
    bridge.refresh();
    expect(record.creation?.cancelled).toBe(true);
    expect(getNewSessionCreationTask('s1')?.readyForEdit).toBe('durable');
    expect(remoteSessionStore.getSessions().some(s => s.id === 's1')).toBe(true);
    expect(onReady).not.toHaveBeenCalled();
    await returnNewSessionToEdit({ sessionId: 's1', deviceId: 'dev-1', isCurrent: () => true, onReady });
    expect(onReady).toHaveBeenCalledWith({ deviceId: 'dev-1', deviceName: 'Mac', recoverySessionId: 's1' });
    expect(maker.worktree.discardPrecreated).toHaveBeenCalledTimes(1);
    expect(editOutbox.update).toHaveBeenCalledTimes(1);
    completeNewSessionDurableEdit('s1', 'dev-1');
    bridge.refresh();
    expect(getNewSessionCreationTask('s1')).toBeNull();
    expect(remoteSessionStore.getSessions().some(s => s.id === 's1')).toBe(false);
    expect(record.item.text).toBe(DRAFT.firstMessage);
  });

  it.each([false, true])('isolates a late background edit draft from another task (other form already claimed: %s)', async claimed => {
    let finishCleanup!: (value: { discarded: boolean }) => void;
    const makerA = makeMaker({ worktree: { discardPrecreated: vi.fn(() => new Promise(resolve => { finishCleanup = resolve; })) } });
    const filesA = [{ id: 'a-file', name: 'a.txt', ext: '.txt', path: '/uploads/a.txt', category: 'file' as const, mimeType: 'text/plain', size: 1 }];
    startNewSessionCreation(makeParams('s1', makerA, {
      draft: { ...DRAFT, firstMessage: 'draft A', workingDir: '/repo/.cindy-worktrees/a' }, attachments: filesA,
      precreatedWorktree: { path: '/repo/.cindy-worktrees/a', recoveryKey: 'recovery-a', originalWorkingDir: '/repo' },
      confirmUnauthenticated: async () => ({ unauthenticated: true, fresh: null }),
    }));
    await flushPipeline();
    let currentA = true;
    const onReadyA = vi.fn();
    const recoveryA = returnNewSessionToEdit({ sessionId: 's1', deviceId: 'dev-1', isCurrent: () => currentA, onReady: onReadyA });
    await flushPipeline();
    currentA = false;
    const makerB = makeMaker({ createSession: vi.fn(async () => { throw new Error('[MODEL_UNAVAILABLE] unavailable'); }) });
    startNewSessionCreation(makeParams('s2', makerB, { draft: { ...DRAFT, firstMessage: 'draft B' } }));
    await flushPipeline();
    const onReadyB = vi.fn();
    await returnNewSessionToEdit({ sessionId: 's2', deviceId: 'dev-1', isCurrent: () => true, onReady: onReadyB });
    expect(onReadyB).toHaveBeenCalledWith({ deviceId: 'dev-1', deviceName: 'Mac', editSessionId: 's2' });
    const formB = claimed ? drainStashedNewSessionDraft('s2', 'dev-1') : null;
    finishCleanup({ discarded: true });
    await recoveryA;
    expect(onReadyA).not.toHaveBeenCalled();
    expect(drainStashedNewSessionDraft()).toBeNull();
    expect(drainStashedNewSessionDraft('s1', 'another-device')).toBeNull();
    expect((formB ?? drainStashedNewSessionDraft('s2', 'dev-1'))?.draft.firstMessage).toBe('draft B');
    expect(getNewSessionCreationTask('s1')?.readyForEdit).toBe('memory');
    expect(remoteSessionStore.getSessions().some(s => s.id === 's1')).toBe(true);
    retryNewSessionCreation('s1');
    expect(getNewSessionCreationTask('s1')?.status).toBe('create-failed');
    await returnNewSessionToEdit({ sessionId: 's1', deviceId: 'dev-1', isCurrent: () => true, onReady: onReadyA });
    expect(makerA.worktree.discardPrecreated).toHaveBeenCalledTimes(1);
    expect(onReadyA).toHaveBeenCalledWith({ deviceId: 'dev-1', deviceName: 'Mac', editSessionId: 's1' });
    expect(drainStashedNewSessionDraft('s1', 'dev-1')).toMatchObject({
      draft: { firstMessage: 'draft A', workingDir: '/repo' }, attachments: filesA,
    });
    expect(getNewSessionCreationTask('s1')).toBeNull();
    expect(drainStashedNewSessionDraft('s1', 'dev-1')).toBeNull();
  });

  it('does not deliver a prepared draft to a different account or a later login generation', async () => {
    const maker = makeMaker({ createSession: vi.fn(async () => { throw new Error('[MODEL_UNAVAILABLE] unavailable'); }) });
    startNewSessionCreation(makeParams('s1', maker));
    await flushPipeline();
    await returnNewSessionToEdit({ sessionId: 's1', deviceId: 'dev-1', isCurrent: () => true, onReady: vi.fn() });
    setMobileAuthOwner('owner-b');
    expect(drainStashedNewSessionDraft('s1', 'dev-1')).toBeNull();
    setMobileAuthOwner('owner-a');
    expect(drainStashedNewSessionDraft('s1', 'dev-1')).toBeNull();
  });

  it.each(['create-failed', 'enqueue-failed'] as const)('retires %s guards across account generations without changing durable recovery', async status => {
    const maker = makeMaker(status === 'create-failed'
      ? { createSession: vi.fn(async () => { throw new Error('INVALID_PARAMS'); }) } : {});
    const params = makeParams('s1', maker);
    params.transport.handoffFirstMessage = async () => { throw new Error('disk full'); };
    startNewSessionCreation(params);
    await flushPipeline();
    expect(getNewSessionCreationTask('s1')?.status).toBe(status);
    const record = { ...recoveryOutboxRecord('s1'), accountId: getMobileAuthOwner().accountKey };
    editOutbox.records.mockReturnValue([record]);
    const savedRecord = structuredClone(record);
    const originalTask = getNewSessionCreationTask('s1');
    setMobileAuthOwner('owner-a');
    expect(getNewSessionCreationTask('s1')).toBe(originalTask);

    setMobileAuthOwner('owner-b');
    expect(getNewSessionCreationTask('s1')).toBeNull();
    expect(shouldBlockSessionSync('s1')).toBe(false);
    setMobileAuthOwner('owner-a');
    expect(getNewSessionCreationTask('s1')).toBeNull();
    expect(shouldBlockSessionSync('s1')).toBe(false);
    expect(editOutbox.records()).toEqual([savedRecord]);
    expect(editOutbox.update).not.toHaveBeenCalled();
    expect(maker.worktree.discardPrecreated).not.toHaveBeenCalled();
    retryNewSessionCreation('s1');
    await flushPipeline();
    expect(maker.createSession).toHaveBeenCalledTimes(1);
  });

  it('ignores an old create reply after switching back and starting a replacement task', async () => {
    let finishCreate!: (value: { sessionId: string }) => void;
    const oldMaker = makeMaker({ createSession: vi.fn(() => new Promise(resolve => { finishCreate = resolve; })) });
    startNewSessionCreation(makeParams('s1', oldMaker));
    await flushPipeline();
    setMobileAuthOwner('owner-b');
    expect(getNewSessionCreationTask('s1')).toBeNull();
    expect(shouldBlockSessionSync('s1')).toBe(false);
    setMobileAuthOwner('owner-a');
    const newMaker = makeMaker({ createSession: vi.fn(async () => { throw new Error('INVALID_PARAMS'); }) });
    startNewSessionCreation(makeParams('s1', newMaker, { draft: { ...DRAFT, firstMessage: 'new draft' } }));
    await flushPipeline();
    const replacement = getNewSessionCreationTask('s1');
    expect(replacement?.status).toBe('create-failed');
    finishCreate({ sessionId: 's1' });
    await flushPipeline();
    expect(getNewSessionCreationTask('s1')).toBe(replacement);
    expect(getNewSessionCreationTask('s1')?.draft.firstMessage).toBe('new draft');
    expect(oldMaker.input.enqueue).not.toHaveBeenCalled();
    expect(shouldBlockSessionSync('s1')).toBe(true);
  });

  it('start 同步段即入 store:合成行带 pendingLocalCreation,首条消息以排队气泡上屏', () => {
    const maker = makeMaker({
      // 挂起 createSession,锁定同步段状态。
      createSession: vi.fn(() => new Promise(() => undefined)),
    });
    startNewSessionCreation(makeParams('s1', maker));
    const row = remoteSessionStore.getSessions().find((s) => s.id === 's1');
    expect(row?.pendingLocalCreation).toBe(true);
    expect(row?.workingDir).toBe('/repo');
    expect(row?.title).toBe('hello world');
    const projection = remoteSessionStore.getInputProjection('s1');
    expect(projection.pendingQueue).toHaveLength(1);
    expect(projection.pendingQueue[0]?.text).toBe('hello world');
    expect(projection.pendingQueue[0]?.clientId).toBe(getNewSessionCreationTask('s1')?.firstMessageClientId);
    expect(shouldBlockSessionSync('s1')).toBe(true);
  });

  it('成功链路:createSession 收到预生成 id、enqueue 用同 clientId,task 移除、守卫解除、禁发标清除', async () => {
    const maker = makeMaker();
    startNewSessionCreation(makeParams('s2', maker));
    const clientId = getNewSessionCreationTask('s2')?.firstMessageClientId;
    await flushPipeline();
    expect(maker.createSession).toHaveBeenCalledWith(expect.objectContaining({ id: 's2' }));
    expect(maker.input.enqueue).toHaveBeenCalledWith(
      's2',
      expect.objectContaining({ clientId }),
      expect.anything(),
    );
    expect(getNewSessionCreationTask('s2')).toBeNull();
    expect(shouldBlockSessionSync('s2')).toBe(false);
    // fresh getSession 失败(makeMaker 默认抛 NOT_FOUND)时权威覆盖没发生,管线
    // 收口前必须主动清 pendingLocalCreation 禁发标(codex P2)。
    expect(remoteSessionStore.getSessions().find((s) => s.id === 's2')?.pendingLocalCreation).toBe(false);
    // 入队成功只解禁,标题预览要等到权威标题离开哨兵才让位。
    remoteSessionStore.setDeviceSessions('dev-1', 'Mac', [
      sessionFromCreateResult({ sessionId: 's2' }, { ...DRAFT, firstMessage: '' }),
    ]);
    expect(remoteSessionStore.getSessions().find((s) => s.id === 's2')?.title).toBe('hello world');
    remoteSessionStore.setDeviceSessions('dev-1', 'Mac', [
      { ...sessionFromCreateResult({ sessionId: 's2' }, DRAFT), title: '登录失败排查' },
    ]);
    expect(remoteSessionStore.getSessions().find((s) => s.id === 's2')?.title).toBe('登录失败排查');
  });

  it('首条消息 enqueue 前应用手机控制端准备的可信引用快照', async () => {
    const maker = makeMaker();
    remoteSessionStore.upsertDeviceSession(
      'dev-source',
      'Source Mac',
      sessionFromCreateResult({ sessionId: 'source' }, DRAFT),
    );
    const prepareQueuedMessage = vi.fn(async (item) => ({
      ...item,
      trustedSessionReferenceContexts: [{
        sessionId: 'source',
        source: 'device-link' as const,
        deviceId: 'dev-source',
        messages: [{ role: 'user' as const, content: 'trusted source' }],
        range: 'recent' as const,
        messageCount: 1,
        truncated: false,
      }],
    }));
    startNewSessionCreation(makeParams('s12', maker, {
      draft: { ...DRAFT, firstMessage: 'review cindy://session/source' },
      transport: {
        maker: maker as unknown as MobileMakerTransport,
        openLink: vi.fn(async () => undefined),
        subscribe: vi.fn(async () => undefined),
        prepareQueuedMessage,
      },
    }));

    expect(remoteSessionStore.getInputProjection('s12').pendingQueue[0]?.sessionRefs)
      .toEqual([{ sessionId: 'source', deviceId: 'dev-source' }]);
    remoteSessionStore.setDeviceSessions('dev-source', 'Source Mac', []);

    await flushPipeline();

    expect(prepareQueuedMessage).toHaveBeenCalledTimes(1);
    expect(prepareQueuedMessage).toHaveBeenCalledWith(expect.objectContaining({
      sessionRefs: [{ sessionId: 'source', deviceId: 'dev-source' }],
    }));
    expect(maker.input.enqueue).toHaveBeenCalledWith(
      's12',
      expect.objectContaining({
        sessionRefs: [{ sessionId: 'source', deviceId: 'dev-source' }],
        trustedSessionReferenceContexts: [expect.objectContaining({
          sessionId: 'source',
          deviceId: 'dev-source',
        })],
      }),
      expect.anything(),
    );
  });

  it('权威 getSession 落地后、enqueue 落定前禁发标保持(弱网窗口不提前解禁,防抢发插队)', async () => {
    const maker = makeMaker({
      getSession: vi.fn(async () => ({ id: 's10', status: 'active' })),
    });
    // enqueue 永久挂起:锁定「getSession 已成功、首条消息还没入队」的窗口。
    maker.input.enqueue.mockImplementation(() => new Promise(() => undefined));
    startNewSessionCreation(makeParams('s10', maker));
    await flushPipeline();
    expect(remoteSessionStore.getSessions().find((s) => s.id === 's10')?.pendingLocalCreation).toBe(true);
    expect(getNewSessionCreationTask('s10')?.status).toBe('running');
  });

  it('dialogue 会话 getSession 失败时,queued.createOpts.workingDir 用 createSession 返回的分配目录兜底', async () => {
    const maker = makeMaker({
      createSession: vi.fn(async (opts: { id?: string }) => ({ sessionId: opts.id, workDir: '/allocated/dialogue-dir' })),
      // getSession 恒失败:走 synthesizeSession fallback(dialogue 草稿 workingDir 为空)。
    });
    startNewSessionCreation(makeParams('s11', maker, {
      draft: { ...DRAFT, workspaceKind: 'dialogue', workingDir: '' },
    }));
    await flushPipeline();
    expect(maker.input.enqueue).toHaveBeenCalledWith(
      's11',
      expect.objectContaining({
        workingDir: '/allocated/dialogue-dir',
        createOpts: expect.objectContaining({ workingDir: '/allocated/dialogue-dir' }),
      }),
      expect.anything(),
    );
    expect(getNewSessionCreationTask('s11')).toBeNull();
  });

  it('started 写盘后二次重验修正草稿 + getSession 失败 → 乐观行回写修正版(codex P1)', async () => {
    // 首次 auth 刷新 fail-open(fresh:null → 管线内 draftPatch 保持 null),但
    // started 写盘后二次重验拿到 fresh 并修正 (model, providerId);getSession
    // 失败走合成 fallback——若乐观行回写只认 draftPatch,此处会跳过,UI/后续
    // 发送仍用已删除来源;排队 lazy-create 材料与乐观行同源,必须一并修正。
    let authCalls = 0;
    const maker = makeMaker();
    startNewSessionCreation(makeParams('s21', maker, {
      draft: {
        ...DRAFT,
        workingDir: '/repo/.cindy-worktrees/auto-one',
        providerId: 'provider-a',
        model: 'model-a',
      },
      precreatedWorktree: {
        path: '/repo/.cindy-worktrees/auto-one',
        recoveryKey: 'recovery-key-1234567890',
        originalWorkingDir: '/repo',
      },
      precreatedWorktreeAccountId: 'owner-a',
      confirmUnauthenticated: async () => {
        authCalls += 1;
        return authCalls === 1
          ? { unauthenticated: false, fresh: null }
          : { unauthenticated: false, fresh: { providers: [] } };
      },
      revalidateDraftAfterAuth: async () => ({ providerId: 'provider-b', model: 'model-b' }),
    }));
    await flushPipeline();
    expect(authCalls).toBe(2);
    // 乐观行回写修正版(不修则 UI 显示 provider-a)
    const row = remoteSessionStore.getSessions().find((s) => s.id === 's21');
    expect(row?.providerId).toBe('provider-b');
    expect(row?.model).toBe('model-b');
    // 排队 lazy-create 材料与乐观行同源
    expect(maker.input.enqueue).toHaveBeenCalledWith(
      's21',
      expect.objectContaining({
        createOpts: expect.objectContaining({ providerId: 'provider-b', model: 'model-b' }),
      }),
      expect.anything(),
    );
  });

  it('started 写盘后二次鉴权中止:账本降回 precreated,任务可返回编辑(codex P2)', async () => {
    // 首次鉴权通过、precreated 账本写成 session-create-started 后,二次鉴权发现
    // 来源全断开——createSession 尚未调用,必须先把账本降回 precreated 再失败:
    // 否则 precreatedWorktreeSessionCreateStarted=true 会让 retry 拒绝重试、
    // prepareForEdit 拒绝返回编辑、recovery 不回收未认领的 started 记录,
    // 用户被困失败页且 worktree 无法自动回收(codex review P2 补强)。
    const precreated = {
      sessionId: 's22',
      deviceId: 'dev-1',
      path: '/repo/.cindy-worktrees/auto-two',
      recoveryKey: 'recovery-key-2222222222',
      originalWorkingDir: '/repo',
    };
    let authCalls = 0;
    const maker = makeMaker();
    startNewSessionCreation(makeParams('s22', maker, {
      draft: { ...DRAFT, workingDir: precreated.path },
      precreatedWorktree: precreated,
      precreatedWorktreeAccountId: 'owner-a',
      // 第 1 次 = 管线内鉴权(persist 之前):通过,fresh fail-open;
      // 第 2 次 = started 写盘后二次鉴权(persist 之后):来源全断开 → 中止,
      // 但 createSession 尚未调用,必须先降级账本。
      confirmUnauthenticated: async () => {
        authCalls += 1;
        return authCalls === 1
          ? { unauthenticated: false, fresh: null }
          : { unauthenticated: true, fresh: null };
      },
      // 二次鉴权分支的开关:revalidateDraftAfterAuth 非空才执行 started 写盘后重验
      revalidateDraftAfterAuth: async () => null,
    }));
    await flushPipeline();
    expect(getNewSessionCreationTask('s22')?.status).toBe('create-failed');
    expect(maker.createSession).not.toHaveBeenCalled();
    // 账本降回 precreated(recovery 可回收未认领 worktree)
    const pending = await listPendingPrecreatedWorktrees('owner-a');
    expect(pending).toHaveLength(1);
    expect(pending[0]).toMatchObject({
      sessionId: 's22',
      deviceId: 'dev-1',
      path: precreated.path,
      recoveryKey: 'recovery-key-2222222222',
      phase: 'precreated',
    });
    // 任务可返回编辑(不再 retain-only 拒绝)——prepare 会 discard + forget
    const prepared = await prepareNewSessionCreationForEdit('s22');
    expect(prepared).not.toBeNull();
    expect(maker.worktree.discardPrecreated).toHaveBeenCalled();
    await expect(listPendingPrecreatedWorktrees('owner-a')).resolves.toEqual([]);
  });

  it('started 二次鉴权中止 + 账本降级写盘失败:任务不锁死,可返回编辑(codex P1)', async () => {
    // 降级(写回 precreated)罕见失败时,resolveStartedDowngradeOrCommit 走 commit
    // 分支(restoreStarted 把账本写回 started)——第 60 轮无条件抛错会保留
    // sessionCreateStarted=true → retry 拒绝/prepareForEdit 报 cleanup pending/
    // recovery 不回收 = 永久锁死(codex review P1)。修复后两种结果都复位任务。
    const rec = await import('@/session/precreatedWorktreeRecovery');
    const original = rec.registerPendingPrecreatedWorktree;
    let precreatedWrites = 0;
    const spy = vi.spyOn(rec, 'registerPendingPrecreatedWorktree')
      .mockImplementation(async (accountId, record) => {
        if (record.phase === 'precreated') {
          precreatedWrites += 1;
          // 首次降级写盘失败(commit 分支),中止前重试一次持久降级成功——重试
          // 必须真正走 original 写盘,否则调用方以为成功但账本未变。
          if (precreatedWrites <= 1) return false;
          return original(accountId, record);
        }
        return original(accountId, record);
      });
    try {
      const precreated = {
        sessionId: 's23',
        deviceId: 'dev-1',
        path: '/repo/.cindy-worktrees/auto-three',
        recoveryKey: 'recovery-key-3333333333',
        originalWorkingDir: '/repo',
      };
      let authCalls = 0;
      const maker = makeMaker();
      startNewSessionCreation(makeParams('s23', maker, {
        draft: { ...DRAFT, workingDir: precreated.path },
        precreatedWorktree: precreated,
        precreatedWorktreeAccountId: 'owner-a',
        confirmUnauthenticated: async () => {
          authCalls += 1;
          return authCalls === 1
            ? { unauthenticated: false, fresh: null }
            : { unauthenticated: true, fresh: null };
        },
        revalidateDraftAfterAuth: async () => null,
      }));
      await flushPipeline();
      expect(getNewSessionCreationTask('s23')?.status).toBe('create-failed');
      expect(maker.createSession).not.toHaveBeenCalled();
      // 降级失败 → 中止前重试一次持久降级成功 → 账本回 precreated(recovery 可
      // 回收未认领 worktree),且任务可返回编辑(codex review P2)
      const pending = await listPendingPrecreatedWorktrees('owner-a');
      expect(pending[0]?.phase).toBe('precreated');
      expect(precreatedWrites).toBeGreaterThanOrEqual(2);
      const prepared = await prepareNewSessionCreationForEdit('s23');
      expect(prepared).not.toBeNull();
      expect(maker.worktree.discardPrecreated).toHaveBeenCalled();
    } finally {
      spy.mockRestore();
    }
  });

  it('createSession 返回的 id 与预生成 id 不一致 → 确定性 create-failed,不把首条消息发进错误会话', async () => {
    const maker = makeMaker({
      createSession: vi.fn(async () => ({ sessionId: 'mock-created-123' })),
    });
    startNewSessionCreation(makeParams('s8', maker));
    await flushPipeline();
    expect(getNewSessionCreationTask('s8')?.status).toBe('create-failed');
    expect(maker.input.enqueue).not.toHaveBeenCalled();
    // 确定性失败不盲重:createSession 只调一次。
    expect(maker.createSession).toHaveBeenCalledTimes(1);
  });

  it('createSession 瞬态失败 → probe 命中 getSession(回执丢失)→ 不重复建会话,继续走 enqueue', async () => {
    const maker = makeMaker({
      createSession: vi.fn(async () => {
        throw new Error('INVOKE_TIMEOUT');
      }),
      // probe 命中:会话其实已在被控端建成。
      getSession: vi.fn(async () => ({ id: 's3' })),
    });
    startNewSessionCreation(makeParams('s3', maker));
    await flushPipeline();
    // 首次失败后 probe 即命中,不应再有第二次 createSession。
    expect(maker.createSession).toHaveBeenCalledTimes(1);
    expect(maker.input.enqueue).toHaveBeenCalledTimes(1);
    expect(getNewSessionCreationTask('s3')).toBeNull();
  });

  it('最后一次 createSession 瞬态超时但会话已建成 → 终局 probe 命中,按已创建收敛(codex P2)', async () => {
    // createSession 恒瞬态超时;getSession 前两次 probe(attempt 1/2 前)仍 NOT_FOUND,
    // 终局 probe(第 3 次)命中——不得误判 create-failed。
    let getSessionCalls = 0;
    const maker = makeMaker({
      createSession: vi.fn(async () => {
        throw new Error('INVOKE_TIMEOUT');
      }),
      getSession: vi.fn(async () => {
        getSessionCalls += 1;
        if (getSessionCalls >= 3) return { id: 's9' };
        throw new Error('NOT_FOUND');
      }),
    });
    startNewSessionCreation(makeParams('s9', maker));
    await flushPipeline();
    expect(maker.createSession).toHaveBeenCalledTimes(3);
    expect(maker.input.enqueue).toHaveBeenCalledTimes(1);
    expect(getNewSessionCreationTask('s9')).toBeNull();
  });

  it('createSession 确定性失败 → 不重试,create-failed(重试面),守卫仍挡同步', async () => {
    const maker = makeMaker({
      createSession: vi.fn(async () => {
        throw new Error('CHANNEL_NOT_ALLOWED: maker:create-session');
      }),
    });
    startNewSessionCreation(makeParams('s4', maker));
    await flushPipeline();
    expect(maker.createSession).toHaveBeenCalledTimes(1);
    const task = getNewSessionCreationTask('s4');
    expect(task?.status).toBe('create-failed');
    expect(shouldBlockSessionSync('s4')).toBe(true);
    // 重试(同 id 幂等):这次放行。
    maker.createSession.mockImplementation(async (opts: { id?: string }) => ({ sessionId: opts.id }));
    retryNewSessionCreation('s4');
    await flushPipeline();
    expect(getNewSessionCreationTask('s4')).toBeNull();
  });

  it('enqueue 失败且确认未应用 → enqueue-failed:乐观气泡摘除、草稿留在 task 供回填', async () => {
    const maker = makeMaker();
    maker.input.enqueue.mockImplementation(async () => {
      throw new Error('INVOKE_TIMEOUT');
    });
    startNewSessionCreation(makeParams('s5', maker));
    await flushPipeline();
    const task = getNewSessionCreationTask('s5');
    expect(task?.status).toBe('enqueue-failed');
    expect(task?.draft.firstMessage).toBe('hello world');
    expect(remoteSessionStore.getInputProjection('s5').pendingQueue).toHaveLength(0);
    // 会话已建成:同步不再被挡(会话页可正常拉权威数据)。
    expect(shouldBlockSessionSync('s5')).toBe(false);
    // 禁发标同步清除:用户要用 composer 重发回填草稿,不能被 pendingLocalCreation
    // 卡到 load 成功才解禁(codex P2)。
    expect(remoteSessionStore.getSessions().find((s) => s.id === 's5')?.pendingLocalCreation).toBe(false);
    expect(remoteSessionStore.getSessions().find((s) => s.id === 's5')?.title).toBe('New Maker');
  });

  it('enqueue 回执丢失但队列里已有该 clientId → 按成功收敛,不打扰用户', async () => {
    const maker = makeMaker();
    maker.input.enqueue.mockImplementation(async () => {
      throw new Error('INVOKE_TIMEOUT');
    });
    startNewSessionCreation(makeParams('s6', maker));
    const clientId = getNewSessionCreationTask('s6')?.firstMessageClientId;
    maker.input.getProjection.mockImplementation(async () => ({
      sessionId: 's6',
      pendingQueue: [{ clientId, text: 'hello world' }],
    }));
    await flushPipeline();
    expect(getNewSessionCreationTask('s6')).toBeNull();
  });

  it('enqueue 回执丢失、消息瞬间进 activeTurn(首查两路皆空)→ 轮询等到消息落库,不误判 enqueue-failed(codex P1)', async () => {
    const maker = makeMaker();
    maker.input.enqueue.mockImplementation(async () => {
      throw new Error('INVOKE_TIMEOUT');
    });
    // 首轮分辨:队列空 + 消息列表空(drain 窗口);第二轮起消息 row 已落库回流。
    let listCalls = 0;
    startNewSessionCreation(makeParams('s7', maker));
    const clientId = getNewSessionCreationTask('s7')?.firstMessageClientId;
    maker.listMessages.mockImplementation(async () => {
      listCalls += 1;
      return listCalls >= 2 ? [{ clientId }] : [];
    });
    await flushPipeline();
    // 第一轮 false 不足以判死(需连续两次确认),第二轮观测到已应用 → 成功收敛。
    expect(getNewSessionCreationTask('s7')).toBeNull();
    expect(remoteSessionStore.getInputProjection('s7')).toBeDefined();
  });

  it('dismiss removeSyntheticRow:合成行从列表隐藏、气泡清空(返回编辑路径)', () => {
    const maker = makeMaker({
      createSession: vi.fn(() => new Promise(() => undefined)),
    });
    startNewSessionCreation(makeParams('s1', maker));
    dismissNewSessionCreation('s1', { removeSyntheticRow: true });
    expect(getNewSessionCreationTask('s1')).toBeNull();
    // store 对 status:'deleted' 的 patch 是直接把行移出 shard(首页不再可见)。
    expect(remoteSessionStore.getSessions().find((s) => s.id === 's1')).toBeUndefined();
    expect(remoteSessionStore.getInputProjection('s1').pendingQueue).toHaveLength(0);
  });

  it('create-failed 返回编辑前回收预创建 worktree,并把原项目目录放回草稿', async () => {
    const maker = makeMaker({
      createSession: vi.fn(async () => {
        throw new Error('INVALID_PARAMS: cannot create session');
      }),
    });
    const params = makeParams('s13', maker, {
      draft: {
        ...DRAFT,
        workingDir: '/repo/.cindy-worktrees/auto-one',
      },
      precreatedWorktree: {
        path: '/repo/.cindy-worktrees/auto-one',
        recoveryKey: 'recovery-key-1234567890',
        originalWorkingDir: '/repo',
      },
    });
    startNewSessionCreation(params);
    await flushPipeline();

    const failed = getNewSessionCreationTask('s13');
    expect(failed?.status).toBe('create-failed');

    const prepared = await prepareNewSessionCreationForEdit('s13');
    expect(prepared).not.toBeNull();
    expect(params.transport.openLink).toHaveBeenCalledWith('dev-1');
    expect(maker.worktree.discardPrecreated).toHaveBeenCalledWith({
      sessionId: 's13',
      recoveryKey: 'recovery-key-1234567890',
    });

    stashNewSessionDraftForEdit(prepared!);
    expect(drainStashedNewSessionDraft('s13', 'dev-1')?.draft.workingDir).toBe('/repo');
  });

  it('带回创建期间后续消息时仍恢复预创建 worktree 的原项目目录', async () => {
    const task = {
      ...makeParams('s13-override', makeMaker(), {
        draft: {
          ...DRAFT,
          workingDir: '/repo/.cindy-worktrees/auto-override',
        },
        precreatedWorktree: {
          path: '/repo/.cindy-worktrees/auto-override',
          recoveryKey: 'recovery-key-override-123456',
          originalWorkingDir: '/repo',
        },
      }),
      status: 'create-failed' as const,
      startedAt: 0,
      phase: 'creating' as const,
      error: 'create failed',
      firstMessageClientId: 'client-override',
    };

    startNewSessionCreation({ ...makeParams('s13-override', makeMaker()),
      draft: task.draft, precreatedWorktree: task.precreatedWorktree,
      confirmUnauthenticated: async () => ({ unauthenticated: true, fresh: null }) });
    await flushPipeline();
    stashNewSessionDraftForEdit(task, {
      draft: {
        ...task.draft,
        firstMessage: 'hello world\n\nfollow up',
      },
    });

    expect(drainStashedNewSessionDraft('s13-override', 'dev-1')?.draft).toMatchObject({
      workingDir: '/repo',
      firstMessage: 'hello world\n\nfollow up',
    });
  });

  it('create-failed cleanup preserves the task when the new channel fails', async () => {
    const maker = makeMaker({
      createSession: vi.fn(async () => {
        throw new Error('INVALID_PARAMS: cannot create session');
      }),
      worktree: {
        discardPrecreated: vi.fn(async () => {
          throw Object.assign(new Error('registered path mismatch'), {
            code: 'PERMISSION_DENIED',
          });
        }),
      },
    });
    startNewSessionCreation(makeParams('s14', maker, {
      draft: {
        ...DRAFT,
        workingDir: '/repo/.cindy-worktrees/auto-two',
      },
      precreatedWorktree: {
        path: '/repo/.cindy-worktrees/auto-two',
        recoveryKey: 'recovery-key-1234567890',
        originalWorkingDir: '/repo',
      },
    }));
    await flushPipeline();

    await expect(
      prepareNewSessionCreationForEdit('s14'),
    ).rejects.toMatchObject({ code: 'PERMISSION_DENIED' });
    expect(getNewSessionCreationTask('s14')?.status).toBe('create-failed');
  });

  it('old desktop without discard-precreated keeps the cleanup obligation fail-closed', async () => {
    const maker = makeMaker({
      createSession: vi.fn(async () => {
        throw new Error('INVALID_PARAMS: cannot create session');
      }),
      worktree: {
        discardPrecreated: vi.fn(async () => {
          throw Object.assign(new Error('channel not allowed remotely'), {
            code: 'CHANNEL_NOT_ALLOWED',
          });
        }),
      },
    });
    startNewSessionCreation(makeParams('s15', maker, {
      draft: {
        ...DRAFT,
        workingDir: '/repo/.cindy-worktrees/auto-three',
      },
      precreatedWorktree: {
        path: '/repo/.cindy-worktrees/auto-three',
        recoveryKey: 'recovery-key-1234567890',
        originalWorkingDir: '/repo',
      },
    }));
    await flushPipeline();

    await expect(
      prepareNewSessionCreationForEdit('s15'),
    ).rejects.toMatchObject({ code: 'CHANNEL_NOT_ALLOWED' });
    expect(maker.worktree.discardPrecreated).toHaveBeenCalledTimes(1);
    expect(getNewSessionCreationTask('s15')?.status).toBe('create-failed');
  });

  it('回收发现会话已认领时重新对账真实会话,不把用户困在 create-failed', async () => {
    const worktreePath = '/repo/.cindy-worktrees/auto-four';
    const claimedSession = sessionFromCreateResult(
      { sessionId: 's16', workDir: worktreePath },
      DRAFT,
    );
    const maker = makeMaker({
      createSession: vi.fn(async () => {
        throw new Error('INVALID_PARAMS: create response lost');
      }),
      getSession: vi.fn(async () => claimedSession),
      worktree: {
        discardPrecreated: vi.fn(async () => {
          throw Object.assign(new Error('session already owns worktree'), {
            code: 'PRECONDITION_FAILED',
          });
        }),
      },
    });
    startNewSessionCreation(makeParams('s16', maker, {
      draft: { ...DRAFT, workingDir: worktreePath },
      precreatedWorktree: {
        path: worktreePath,
        recoveryKey: 'recovery-key-1234567890',
        originalWorkingDir: '/repo',
      },
    }));
    await flushPipeline();
    expect(getNewSessionCreationTask('s16')?.status).toBe('create-failed');

    await expect(prepareNewSessionCreationForEdit('s16')).resolves.toBeNull();
    expect(getNewSessionCreationTask('s16')?.status).toBe('enqueue-failed');
    expect(remoteSessionStore.getSessions().find((s) => s.id === 's16')).toMatchObject({
      id: 's16',
      workingDir: worktreePath,
      pendingLocalCreation: false,
    });
    expect(remoteSessionStore.getInputProjection('s16').pendingQueue).toHaveLength(0);
  });

  it('managed create 的 wrong-id + malformed ownership probe 持久进入 retain-only,禁止重试或返回编辑删除', async () => {
    const createdAt = Date.now();
    const precreated = {
      sessionId: 's18',
      deviceId: 'dev-1',
      path: '/repo/.cindy-worktrees/auto-unsafe',
      recoveryKey: 'recovery-key-unsafe-123456',
      createdAt,
      phase: 'precreated' as const,
    };
    await registerPendingPrecreatedWorktree('owner-a', precreated);
    const maker = makeMaker({
      createSession: vi.fn(async () => ({ sessionId: 'wrong-session-id' })),
      getSession: vi.fn(async () => null),
    });
    startNewSessionCreation(makeParams('s18', maker, {
      draft: { ...DRAFT, workingDir: precreated.path },
      precreatedWorktree: {
        path: precreated.path,
        recoveryKey: precreated.recoveryKey,
        originalWorkingDir: '/repo',
        createdAt,
      },
      precreatedWorktreeAccountId: 'owner-a',
    }));
    await flushPipeline();

    expect(getNewSessionCreationTask('s18')).toMatchObject({
      status: 'create-failed',
    });
    expect(maker.createSession).toHaveBeenCalledTimes(1);
    expect(maker.input.enqueue).not.toHaveBeenCalled();
    retryNewSessionCreation('s18');
    await flushPipeline();
    expect(maker.createSession).toHaveBeenCalledTimes(1);
    await expect(prepareNewSessionCreationForEdit('s18')).rejects.toThrow(
      'worktree',
    );
    expect(maker.worktree.discardPrecreated).not.toHaveBeenCalled();
    await expect(listPendingPrecreatedWorktrees('owner-a')).resolves.toEqual([{
      ...precreated,
      phase: 'session-create-started',
    }]);
  });

  it('returns the original draft after an uncertain create is cancelled by the host', async () => {
    const record = { sessionId: 'cancel-me', deviceId: 'dev-1', path: '/repo/.cindy-worktrees/orphan', recoveryKey: 'recovery-cancel-key', createdAt: Date.now(), phase: 'precreated' as const };
    await registerPendingPrecreatedWorktree('owner-a', record);
    const maker = makeMaker({
      createSession: vi.fn(async () => { throw new Error('INVOKE_TIMEOUT'); }),
      worktree: { discardPrecreated: vi.fn(), cancelPrecreated: vi.fn(async () => ({ discarded: true })) },
    });
    startNewSessionCreation(makeParams(record.sessionId, maker, {
      draft: { ...DRAFT, workingDir: record.path },
      precreatedWorktree: { path: record.path, recoveryKey: record.recoveryKey, originalWorkingDir: '/repo', createdAt: record.createdAt },
      precreatedWorktreeAccountId: 'owner-a',
    }));
    await flushPipeline();
    const task = await prepareNewSessionCreationForEdit(record.sessionId);
    expect(task?.draft.firstMessage).toBe(DRAFT.firstMessage);
    expect(task?.precreatedWorktree?.originalWorkingDir).toBe('/repo');
    expect(maker.worktree.cancelPrecreated).toHaveBeenCalledWith({ sessionId: record.sessionId, recoveryKey: record.recoveryKey });
    expect(maker.worktree.discardPrecreated).not.toHaveBeenCalled();
    expect(persistCancelledDraft).toHaveBeenCalledWith({ sessionId: record.sessionId, deviceId: record.deviceId, originalWorkingDir: '/repo' });
    expect(await listPendingPrecreatedWorktrees('owner-a')).toEqual([]);
  });

  it('retry reconciles a late exact-id success without another create', async () => {
    const maker = makeMaker({ createSession: vi.fn(async () => { throw new Error('INVOKE_TIMEOUT'); }) });
    startNewSessionCreation(makeParams('late-success', maker, {
      precreatedWorktree: { path: '/repo/worktree', recoveryKey: 'late-recovery-key', originalWorkingDir: '/repo' },
      precreatedWorktreeAccountId: 'owner-a',
    }));
    await flushPipeline();
    expect(getNewSessionCreationTask('late-success')?.status).toBe('create-failed');
    maker.getSession.mockResolvedValue(sessionFromCreateResult({ sessionId: 'late-success', workDir: '/repo/worktree' }, DRAFT));
    retryNewSessionCreation('late-success');
    await flushPipeline();
    expect(maker.createSession).toHaveBeenCalledTimes(1);
    expect(maker.input.enqueue).toHaveBeenCalledTimes(1);
    expect(getNewSessionCreationTask('late-success')).toBeNull();
  });

  it('keeps the edit recovery obligation when persisting the cancelled draft fails', async () => {
    const record = { sessionId: 'cancel-save-fails', deviceId: 'dev-1', path: '/repo/.cindy-worktrees/orphan',
      recoveryKey: 'recovery-cancel-save-key', createdAt: Date.now(), phase: 'precreated' as const };
    await registerPendingPrecreatedWorktree('owner-a', record);
    const maker = makeMaker({ createSession: vi.fn(async () => { throw new Error('INVOKE_TIMEOUT'); }),
      worktree: { discardPrecreated: vi.fn(), cancelPrecreated: vi.fn(async () => ({ discarded: true })) } });
    startNewSessionCreation(makeParams(record.sessionId, maker, {
      draft: { ...DRAFT, workingDir: record.path }, precreatedWorktreeAccountId: 'owner-a',
      precreatedWorktree: { path: record.path, recoveryKey: record.recoveryKey, originalWorkingDir: '/repo', createdAt: record.createdAt },
    }));
    await flushPipeline();
    persistCancelledDraft.mockRejectedValueOnce(new Error('disk full'));
    await expect(prepareNewSessionCreationForEdit(record.sessionId)).rejects.toThrow('disk full');
    expect(await listPendingPrecreatedWorktrees('owner-a')).toHaveLength(1);
    expect(getNewSessionCreationTask(record.sessionId)?.status).toBe('create-failed');
    await prepareNewSessionCreationForEdit(record.sessionId);
    expect(await listPendingPrecreatedWorktrees('owner-a')).toEqual([]);
    dismissNewSessionCreation(record.sessionId);
  });

  it.each([true, false, undefined])('removes the host-confirmed cancelled row on the matching device (pendingLocalCreation=%s)', (pendingLocalCreation) => {
    const row = { ...sessionFromCreateResult({ sessionId: 'orphan' }, DRAFT), pendingLocalCreation };
    remoteSessionStore.upsertDeviceSession('dev-1', 'PC', row);
    dismissRecoveredPrecreatedSession({ sessionId: 'orphan', deviceId: 'other-device' });
    expect(remoteSessionStore.getSessions()).toHaveLength(1);
    dismissRecoveredPrecreatedSession({ sessionId: 'orphan', deviceId: 'dev-1' });
    expect(remoteSessionStore.getSessions()).toHaveLength(0);
  });

  it('does not dismiss a row still owned by a live creation pipeline', async () => {
    const maker = makeMaker({ createSession: vi.fn(async () => { throw new Error('failed startup'); }) });
    startNewSessionCreation(makeParams('s1', maker));
    dismissRecoveredPrecreatedSession({ sessionId: 's1', deviceId: 'dev-1' });
    expect(remoteSessionStore.getSessions().find((row) => row.id === 's1')).toBeDefined();
    expect(getNewSessionCreationTask('s1')).not.toBeNull();
    await flushPipeline();
    dismissNewSessionCreation('s1');
  });

  it.each(['cindy-make', 'cindy-make-merge'])('releases only a disabled %s task lease while retaining its raw metadata', source => {
    const hidden = recoveryOutboxRecord('legacy-make');
    const ordinary = recoveryOutboxRecord('ordinary');
    const session = sessionFromCreateResult({ sessionId: 'legacy-make' }, DRAFT);
    remoteSessionStore.upsertDeviceSession('dev-1', 'PC', { ...session, source: 'cc' });
    const bridge = outboxLeaseHarness([hidden, ordinary]);
    bridge.refresh();
    expect(bridge.leases.size).toBe(2);
    const release = vi.spyOn(bridge.leases.get(JSON.stringify(['dev-1', 'legacy-make']))!, 'release');
    remoteSessionStore.upsertDeviceSession('dev-1', 'PC', { ...session, source });
    bridge.refresh();
    expect(release).toHaveBeenCalledOnce();
    expect(bridge.leases.size).toBe(1);
    expect(bridge.leases.has(JSON.stringify(['dev-1', 'ordinary']))).toBe(true);
    expect(remoteSessionStore.getSessions().find(row => row.id === 'legacy-make')?.source).toBe(source);
    bridge.setRecords([]); bridge.refresh();
  });

  it('releases hidden accepted message windows and resumes handoff on reentry', () => {
    const accepted = { ...recoveryOutboxRecord('accepted'), state: 'host-owned' as const, retrySafe: true };
    const sending = recoveryOutboxRecord('sending');
    const bridge = outboxLeaseHarness([accepted, sending]);
    bridge.refresh();
    expect(bridge.leases.size).toBe(1);
    bridge.visible.add('accepted');
    bridge.refresh();
    expect(bridge.leases.size).toBe(2);
    const release = vi.spyOn(bridge.leases.get(JSON.stringify(['dev-1', 'accepted']))!, 'release');
    bridge.visible.clear();
    bridge.refresh();
    expect(release).toHaveBeenCalledOnce();
    // An explicit cancel still needs remote reconciliation while the task is hidden.
    bridge.setRecords([{ ...accepted, cancelRequested: true }]);
    bridge.refresh();
    expect(bridge.leases.has(JSON.stringify(['dev-1', 'accepted']))).toBe(true);
    bridge.setRecords([]); bridge.refresh();
  });

  it('removes a cold-hydrated cancelled row and releases only its lease without resurrecting it', () => {
    const orphan = recoveryOutboxRecord('cold-orphan');
    const other = recoveryOutboxRecord('other-draft');
    const bridge = outboxLeaseHarness([orphan, other]);
    bridge.refresh();
    expect(remoteSessionStore.getSessions().find((row) => row.id === 'cold-orphan')?.pendingLocalCreation).toBeUndefined();
    expect(bridge.leases.size).toBe(2);
    const releaseOrphan = vi.spyOn(bridge.leases.get(JSON.stringify(['dev-1', 'cold-orphan']))!, 'release');
    const releaseOther = vi.spyOn(bridge.leases.get(JSON.stringify(['dev-1', 'other-draft']))!, 'release');
    const cancelled = { ...orphan, suspended: true, creation: { ...orphan.creation!, cancelled: true as const } };
    bridge.setRecords([cancelled, other]);
    bridge.refresh();
    expect(remoteSessionStore.getSessions().map((row) => row.id)).toEqual(['other-draft']);
    expect(releaseOrphan).toHaveBeenCalledOnce();
    expect(releaseOther).not.toHaveBeenCalled();
    bridge.refresh();
    expect(remoteSessionStore.getSessions().map((row) => row.id)).toEqual(['other-draft']);
    expect(cancelled.item.text).toBe(DRAFT.firstMessage);
    expect(cancelled.creation.cancelled).toBe(true);
    bridge.setRecords([]);
    bridge.refresh();
  });

  it('does not materialize an already cancelled draft on cold startup', () => {
    const orphan = recoveryOutboxRecord('cancelled-before-restart');
    const bridge = outboxLeaseHarness([{ ...orphan, creation: { ...orphan.creation!, cancelled: true } }]);
    bridge.refresh();
    bridge.refresh();
    expect(remoteSessionStore.getSessions()).toEqual([]);
    expect(bridge.leases.size).toBe(0);
  });

  it.each([
    ['null', null],
    ['empty object', {}],
    ['wrong id', { id: 'another-session' }],
  ])('managed create 丢 ACK 后 probe %s 仍 retain-only,不重建、不入队、不回收', async (_label, probeResult) => {
    const createdAt = Date.now();
    const precreated = {
      sessionId: 's20',
      deviceId: 'dev-1',
      path: '/repo/.cindy-worktrees/auto-unknown',
      recoveryKey: 'recovery-key-unknown-123456',
      createdAt,
      phase: 'precreated' as const,
    };
    await registerPendingPrecreatedWorktree('owner-a', precreated);
    const maker = makeMaker({
      createSession: vi.fn(async () => {
        throw new Error('INVOKE_TIMEOUT');
      }),
      getSession: vi.fn(async () => probeResult),
    });
    startNewSessionCreation(makeParams('s20', maker, {
      draft: { ...DRAFT, workingDir: precreated.path },
      precreatedWorktree: {
        path: precreated.path,
        recoveryKey: precreated.recoveryKey,
        originalWorkingDir: '/repo',
        createdAt,
      },
      precreatedWorktreeAccountId: 'owner-a',
    }));
    await flushPipeline();

    expect(getNewSessionCreationTask('s20')?.status).toBe('create-failed');
    expect(maker.createSession).toHaveBeenCalledTimes(1);
    expect(maker.getSession).toHaveBeenCalledTimes(1);
    expect(maker.input.enqueue).not.toHaveBeenCalled();
    retryNewSessionCreation('s20');
    await flushPipeline();
    expect(maker.createSession).toHaveBeenCalledTimes(1);
    expect(maker.getSession).toHaveBeenCalledTimes(2);
    await expect(prepareNewSessionCreationForEdit('s20')).rejects.toThrow('worktree');
    expect(maker.worktree.discardPrecreated).not.toHaveBeenCalled();
    await expect(listPendingPrecreatedWorktrees('owner-a')).resolves.toEqual([{
      ...precreated,
      phase: 'session-create-started',
    }]);
  });

  it.each([
    ['null', null],
    ['empty object', {}],
    ['negative ACK', { discarded: false }],
    ['invalid branchDeleted', { discarded: true, branchDeleted: 'yes' }],
  ])('返回编辑只接受完整 discard ACK:%s 回包保留 task 与账本', async (_label, discardAck) => {
    const createdAt = Date.now();
    const maker = makeMaker({
      worktree: {
        discardPrecreated: vi.fn(async () => discardAck),
      },
    });
    startNewSessionCreation(makeParams('s19', maker, {
      draft: { ...DRAFT, workingDir: '/repo/.cindy-worktrees/auto-ack' },
      precreatedWorktree: {
        path: '/repo/.cindy-worktrees/auto-ack',
        recoveryKey: 'recovery-key-ack-123456',
        originalWorkingDir: '/repo',
        createdAt,
      },
      precreatedWorktreeAccountId: 'owner-a',
      confirmUnauthenticated: async () => ({ unauthenticated: true, fresh: null }),
    }));
    await flushPipeline();
    await expect(prepareNewSessionCreationForEdit('s19')).rejects.toThrow();
    expect(getNewSessionCreationTask('s19')?.status).toBe('create-failed');
    expect(maker.worktree.discardPrecreated).toHaveBeenCalledWith({
      sessionId: 's19',
      recoveryKey: 'recovery-key-ack-123456',
    });
  });

  it('账号在 create retry 等待期间切换时停止旧任务并保留旧账号 recovery ledger', async () => {
    const record = {
      sessionId: 's17',
      deviceId: 'dev-1',
      path: '/repo/.cindy-worktrees/auto-owner-a',
      recoveryKey: 'recovery-key-owner-a-123456',
      createdAt: Date.now(),
      phase: 'precreated' as const,
    };
    await expect(
      registerPendingPrecreatedWorktree('owner-a', record),
    ).resolves.toBe(true);

    let currentOwner = 'owner-a';
    const maker = makeMaker({
      createSession: vi.fn(async () => {
        throw new Error('INVOKE_TIMEOUT');
      }),
      getSession: vi.fn(async () => {
        currentOwner = 'owner-b';
        throw new Error('NOT_FOUND');
      }),
    });

    startNewSessionCreation(makeParams('s17', maker, {
      draft: { ...DRAFT, workingDir: record.path },
      precreatedWorktree: {
        path: record.path,
        recoveryKey: record.recoveryKey,
        originalWorkingDir: '/repo',
        createdAt: record.createdAt,
      },
      precreatedWorktreeAccountId: 'owner-a',
      isCurrentOwner: () => currentOwner === 'owner-a',
    }));
    await flushPipeline();

    expect(maker.createSession).toHaveBeenCalledTimes(1);
    expect(maker.getSession).toHaveBeenCalledTimes(1);
    expect(maker.input.enqueue).not.toHaveBeenCalled();
    expect(getNewSessionCreationTask('s17')).toBeNull();
    expect(remoteSessionStore.getSessions().find((session) => session.id === 's17')).toBeUndefined();
    await expect(listPendingPrecreatedWorktrees('owner-a')).resolves.toEqual([{
      ...record,
      phase: 'session-create-started',
    }]);
  });
  it('hands the persisted first message to the outbox without issuing a competing enqueue', async () => {
    const maker = makeMaker();
    const params = makeParams('durable-first', maker, { firstMessageClientId: 'persisted-first-id', planModeArm: true });
    const handoff = vi.fn(async () => undefined);
    params.transport.handoffFirstMessage = handoff;
    startNewSessionCreation(params);
    await flushPipeline();
    expect(handoff).toHaveBeenCalledWith(expect.objectContaining({ clientId: 'persisted-first-id', text: DRAFT.firstMessage }));
    expect(maker.input.enqueue).not.toHaveBeenCalled();
    expect(maker.setPlanMode).not.toHaveBeenCalled();
    expect(getNewSessionCreationTask('durable-first')).toBeNull();
    expect(remoteSessionStore.getSessions().find((session) => session.id === 'durable-first')?.pendingLocalCreation).toBe(false);
  });
  it('keeps the creation task recoverable when saving the first-message handoff fails', async () => {
    const maker = makeMaker(); const params = makeParams('durable-first-failed', maker, { firstMessageClientId: 'saved-id' });
    params.transport.handoffFirstMessage = async () => { throw new Error('disk full'); };
    startNewSessionCreation(params); await flushPipeline();
    expect(maker.input.enqueue).not.toHaveBeenCalled();
    expect(getNewSessionCreationTask('durable-first-failed')).toMatchObject({ status: 'enqueue-failed', firstMessageClientId: 'saved-id' });
  });

  describe('collaboration on create', () => {
    const orcaEnable = { workerAgent: 'codex' as const, role: 'developer', label: 'developer', workerPermissionMode: 'auto' as const };
    function withOrca(maker: MakerMock, enable: ReturnType<typeof vi.fn>) {
      return Object.assign(maker, {
        getCapabilities: vi.fn(async () => ({ supportsOrcaWorkerPermissionMode: true })),
        orca: { enable, listWorkers: vi.fn(async () => []) },
      });
    }

    it('brings the collaboration draft back with the draft when a failed create returns to editing', async () => {
      const maker = withOrca(makeMaker({
        createSession: vi.fn(async () => { throw new Error('INVALID_PARAMS: cannot create session'); }),
      }), vi.fn());
      const collabDraft = {
        role: 'reviewer', agent: 'codex' as const, model: null, permissionMode: 'auto' as const, initialTask: 'check tests',
      };
      startNewSessionCreation(makeParams('orca-edit', maker, { orcaEnable, collabDraft }));
      await flushPipeline();
      expect(getNewSessionCreationTask('orca-edit')?.status).toBe('create-failed');
      const prepared = await prepareNewSessionCreationForEdit('orca-edit');
      stashNewSessionDraftForEdit(prepared!);
      expect(drainStashedNewSessionDraft('orca-edit', 'dev-1')?.collabDraft).toEqual(collabDraft);
    });

    it('starts collaboration after createSession and before the first message is queued', async () => {
      const enable = vi.fn(async () => ({ workerSessionId: 'worker-1' }));
      const maker = withOrca(makeMaker(), enable);
      startNewSessionCreation(makeParams('orca-ok', maker, { orcaEnable }));
      await flushPipeline();
      expect(enable).toHaveBeenCalledWith('orca-ok', orcaEnable);
      expect(enable.mock.invocationCallOrder[0]).toBeGreaterThan(maker.createSession.mock.invocationCallOrder[0]!);
      expect(enable.mock.invocationCallOrder[0]).toBeLessThan(maker.input.enqueue.mock.invocationCallOrder[0]!);
      expect(remoteSessionStore.getSessions().find((session) => session.id === 'orca-ok')?.orcaRole).toBe('lead');
      expect(takeOrcaStartFailure('orca-ok')).toBeNull();
    });

    it('continues as a single task and hands the reason to the session page when collaboration fails', async () => {
      const enable = vi.fn(async () => { throw new Error('[PRECONDITION_FAILED] disabled'); });
      const maker = withOrca(makeMaker(), enable);
      startNewSessionCreation(makeParams('orca-fail', maker, { orcaEnable }));
      await flushPipeline();
      expect(maker.input.enqueue).toHaveBeenCalledTimes(1);
      expect(getNewSessionCreationTask('orca-fail')).toBeNull();
      expect(takeOrcaStartFailure('orca-fail')).toBeTruthy();
    });

    it('does not start collaboration twice when the authoritative row is already a Lead', async () => {
      const enable = vi.fn(async () => ({}));
      const maker = withOrca(makeMaker({
        getSession: vi.fn(async () => ({ ...sessionFromCreateResult({ sessionId: 'orca-lead' }, DRAFT), orcaRole: 'lead' })),
      }), enable);
      startNewSessionCreation(makeParams('orca-lead', maker, { orcaEnable }));
      await flushPipeline();
      expect(enable).not.toHaveBeenCalled();
      expect(maker.input.enqueue).toHaveBeenCalledTimes(1);
    });
  });
});