import { mkdtemp, rm } from 'node:fs/promises' import { tmpdir } from 'node:os' import { join } from 'node:path' import { afterEach, beforeEach, describe, expect, it } from 'vitest' import type { AgentSessionOwnerProbe } from '../../shared/agent-session-lease-adjudication' import { AgentSessionJournal } from '../native-chat/agent-session-journal/journal-store' import { openTestJournalHostDatabase } from '../native-chat/agent-session-journal/journal-host-database-test-support' import { providerContextBoundaryForClear, type AgentSessionConversationClear } from './agent-session-conversation-command-record' import { isAgentSessionRefusalError } from '../../shared/agent-session-wire-refusals' import { claudeProviderHandle } from '../../shared/agent-session-provider-handle-encoding' import type { AgentSessionRecordStore } from './agent-session-record-store' import { openTestAgentSessionRecordStore } from './agent-session-record-store-test-harness' const NOW = 1_800_000_000_000 const SOURCE = 'session-alpha' const INDETERMINATE: AgentSessionOwnerProbe = { outcome: 'indeterminate', reason: 'no answer' } let directory: string beforeEach(async () => { directory = await mkdtemp(join(tmpdir(), 'orca-agent-session-clear-commit-')) }) afterEach(async () => { await rm(directory, { recursive: true, force: true }) }) const open = () => openTestAgentSessionRecordStore(directory) async function storeWithSource(): Promise { const store = await open() await store.reserveOwner({ sessionId: SOURCE, location: { executionHostId: 'local', wslDistro: null, workspaceId: 'workspace-1', workspaceKind: 'folder' }, provider: 'claude', accountHome: { variable: 'CLAUDE_CONFIG_DIR', path: '/home/dev/.claude-work' }, launchArgs: ['--flag'], options: { model: 'sonnet' }, expectedFence: null, spawnToken: 'spawn-a', claimKeyId: 'key-1', handoffOperationId: null, probe: INDETERMINATE, operation: { callerKey: 'client-1', operationId: `${NOW}-${'1'.repeat(32)}`, fingerprint: 'fp' }, now: NOW }) const fence = store.getRecord(SOURCE)!.lease.runtimeFence await store.commitProcessIdentity({ sessionId: SOURCE, fence, process: { hostId: 'local', pid: 4242, processStartTimeMs: NOW, spawnToken: 'spawn-a' }, now: NOW }) await store.proveOwner({ sessionId: SOURCE, fence, link: { linkId: 'pre-clear-proof', origin: 'created', mintedAtFence: fence, observedAt: NOW, handle: claudeProviderHandle('pre-clear-provider-context', null) }, now: NOW }) await store.setSessionTabVisibility(SOURCE, true, 'tab-alpha') return store } function clear(fence: number): AgentSessionConversationClear { return { sessionId: SOURCE, fence, now: NOW + 5, command: { command: 'clear', state: 'completed', phase: 'committed', runtimeFence: fence, operationId: `${NOW}-${'2'.repeat(32)}`, callerKey: 'client-1' } } } async function prepare(released = true) { const store = await storeWithSource() if (released) { await store.evictProvenDeadOwner({ sessionId: SOURCE, expectedFence: store.getRecord(SOURCE)!.lease.runtimeFence, probe: { outcome: 'exit-observed' }, now: NOW + 1 }) } const journal = new AgentSessionJournal({ database: openTestJournalHostDatabase(directory), identity: { sessionId: SOURCE, workspaceId: 'workspace-1', hostId: 'local', agent: 'claude', providerHandle: null }, now: () => NOW + 5 }) await journal.open() const completed = clear(store.getRecord(SOURCE)!.lease.runtimeFence) const operation = { callerKey: completed.command.callerKey, operationId: completed.command.operationId } await store.admitOperation({ ...operation, fingerprint: 'clear', now: NOW }) const append = (input = completed) => journal.context.clear( providerContextBoundaryForClear(input), store.conversationReceipts.clear(() => input, operation) ) return { store, journal, completed, operation, append } } async function queueClearCards(journal: AgentSessionJournal) { for (const messageId of ['first', 'command', 'last']) { await journal.queuedMessages.insert({ messageId, body: { kind: 'message', role: 'user', blocks: [{ type: 'text', text: messageId }], ...(messageId === 'command' ? { command: { name: 'compact' } } : {}) } }) } } describe('clear transaction', () => { it.each([false, true])('clears only automatic names (user=%s)', async (user) => { const { store, journal, completed, operation, append } = await prepare() await (user ? store.setUserConversationName(SOURCE, 'Saved name', 'rename') : store.setConversationName(SOURCE, 'Saved name')) const before = store.getRecord(SOURCE)! expect(before.providerHandleChain).toHaveLength(1) await queueClearCards(journal) const epoch = journal.cursor().epoch await append() const reopened = await open() expect(reopened.listRecords()).toHaveLength(1) expect(reopened.getRecord(SOURCE)).toMatchObject({ providerContextBoundary: providerContextBoundaryForClear(completed), providerHandleChain: [], lease: { provenHandleLinkId: null }, accountHome: before.accountHome, options: before.options, conversationCommand: completed.command }) expect(reopened.getRecord(SOURCE)?.conversationName).toBe(user ? 'Saved name' : undefined) const context = providerContextBoundaryForClear(completed).operationId expect( await reopened.compareAndSetConversationName(SOURCE, 'Saved name', null, context) ).toEqual(user ? null : expect.objectContaining({ conversationName: 'Saved name' })) expect( await reopened.compareAndSetConversationName(SOURCE, 'Stale result', 'Saved name', null) ).toBeNull() expect( await reopened.compareAndSetConversationName(SOURCE, 'Saved name', 'Saved name', null) ).toBeNull() expect((await open()).getRecord(SOURCE)?.conversationName).toBe('Saved name') expect(reopened.getSessionTabId(SOURCE)).toBe('tab-alpha') expect(JSON.stringify(reopened.getRecord(SOURCE))).not.toContain('pre-clear-provider-context') expect(journal.cursor().epoch).toBe(epoch) expect(journal.queuedMessages.get('command')).toMatchObject({ state: 'withdrawn' }) expect(journal.queuedMessages.pauses()).toMatchObject([{ messageIds: ['first', 'last'] }]) expect( reopened.getOperationRow(operation.callerKey, operation.operationId)?.outcome.status ).toBe('succeeded') }) it('rolls the divider and receipt back when the fence moved', async () => { const { store, journal, completed, operation, append } = await prepare() await queueClearCards(journal) await store.setConversationName(SOURCE, 'Saved name') const before = journal.cursor() const previousChain = store.getRecord(SOURCE)!.providerHandleChain const refused = await append({ ...completed, fence: completed.fence + 1 }).catch( (error: unknown) => error ) expect(isAgentSessionRefusalError(refused)).toBe(true) expect(journal.cursor()).toEqual(before) expect((await open()).getRecord(SOURCE)?.conversationName).toBe('Saved name') expect( journal.queuedMessages.list().map(({ messageId, state }) => ({ messageId, state })) ).toEqual(['first', 'command', 'last'].map((messageId) => ({ messageId, state: 'waiting' }))) expect(journal.queuedMessages.pauses()).toEqual([]) expect((await open()).getRecord(SOURCE)?.providerContextBoundary).toBeUndefined() expect((await open()).getRecord(SOURCE)?.providerHandleChain).toEqual(previousChain) expect(store.getOperationRow(operation.callerKey, operation.operationId)?.outcome.status).toBe( 'pending' ) }) it('refuses a boundary while ownership is still reserved', async () => { const { store, journal, append } = await prepare(false) const before = journal.cursor() await expect(append()).rejects.toMatchObject({ refusal: { code: 'agent_session_ownership_unknown' } }) expect(journal.cursor()).toEqual(before) expect(store.getRecord(SOURCE)?.providerContextBoundary).toBeUndefined() }) })