@xingular/harness 0.0.0-stage → 0.1.0

package/src/sessions/sessions.test.ts

@@ -0,0 +1,434 @@
+import { mkdtempSync, realpathSync, utimesSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { afterEach, describe, expect, it } from 'vitest'
+
+import { memorySecretStore } from '../accounts/secrets'
+import { createHarness, type Harness } from '../harness'
+import type { RunEvent } from './contracts'
+import { grant, type ApprovalFacts } from './approvals'
+import { selectHistory } from './history'
+import type { ToolPolicy } from './policy'
+import type { PiEvent, PiSessionLike, SessionFactory } from './runner'
+import { loadRun, readEvents } from './runStore'
+import type { SessionRunInput } from './sessions'
+
+const tick = (ms = 20) => new Promise((resolve) => setTimeout(resolve, ms))
+const open: Harness[] = []
+afterEach(async () => {
+  for (const harness of open.splice(0)) await harness.close()
+})
+
+function setup(factory: SessionFactory, policy: ToolPolicy = {}) {
+  const harness = createHarness({ dataRoot: mkdtempSync(join(tmpdir(), 'harness-data-')), stateDir: mkdtempSync(join(tmpdir(), 'harness-state-')), secrets: memorySecretStore(), sessionFactory: factory, policy })
+  open.push(harness)
+  harness.accounts.create('Main', 'apiKey')
+  const events: RunEvent[] = []
+  harness.runs.listen((event) => void events.push(event))
+  const sessionDir = join(harness.env.root, 'sessions', 'agent-1')
+  const run = (id: string, extra: Partial<SessionRunInput> = {}) =>
+    harness.sessions.run({ run: { id, sessionId: 'agent-1' }, cwd: harness.env.root, sessionDir, text: 'hello', caller: { agentId: 'agent-1', agentName: 'Helper', actor: 'Chat' }, tools: { allow: ['read', 'bash'], gated: ['bash'] }, ...extra })
+  return { harness, events, run, sessionDir }
+}
+
+function fakeSession(script: (emit: (event: PiEvent) => void, gateCheck: () => Promise<string | null>) => Promise<void>, gate: { check: (name: string, input: unknown) => Promise<string | null> }): PiSessionLike & { aborted: boolean } {
+  let listener: (event: PiEvent) => void = () => undefined
+  const session = {
+    sessionId: 'native-1',
+    aborted: false,
+    subscribe: (fn: (event: PiEvent) => void) => {
+      listener = fn
+      return () => undefined
+    },
+    prompt: () => script((event) => listener(event), () => gate.check('bash', { command: 'ls' })),
+    sendCustomMessage: async () => undefined,
+    abort: async () => {
+      session.aborted = true
+    },
+    dispose: () => undefined
+  }
+  return session
+}
+
+describe('session turns on Pi', () => {
+  it('rejects image-required turns before any prompt reaches a text-only model', async () => {
+    let requested = false
+    let disposed = false
+    const { run, harness } = setup(async ({ gate }) => ({
+      ...fakeSession(async () => { requested = true }, gate),
+      model: { input: ['text'] },
+      dispose: () => { disposed = true }
+    }))
+    expect(await run('image-unsupported', { requiresImageInput: true })).toEqual({ runId: 'image-unsupported', nativeSessionId: null })
+    expect(requested).toBe(false)
+    expect(disposed).toBe(true)
+    expect(loadRun(harness.env.root, 'image-unsupported')).toMatchObject({ status: 'failed', terminalReason: expect.stringContaining('supports images') })
+  })
+
+  it('passes image pixels using Pi image content fields with the existing stable prefix', async () => {
+    let observed: unknown
+    const { run } = setup(async ({ gate }) => ({
+      ...fakeSession(async () => undefined, gate),
+      model: { input: ['text', 'image'] },
+      prompt: async (_text, options) => { observed = options }
+    }))
+    await run('image-supported', { requiresImageInput: true, images: [{ mediaType: 'image/png', data: 'cGl4ZWxz' }] })
+    await tick()
+    expect(observed).toEqual({ images: [{ type: 'image', mimeType: 'image/png', data: 'cGl4ZWxz' }] })
+  })
+
+  it('saves the context update in native history before the request, without another model turn', async () => {
+    const delivered: unknown[] = []
+    const { run, events, harness } = setup(async ({ gate, params }) => ({
+      ...fakeSession(async () => undefined, gate),
+      sendCustomMessage: async (message, options) => void delivered.push({ type: message.customType, display: message.display, options, snapshot: Object.keys(message.details as object) }),
+      prompt: async (text) => void delivered.push({ text, system: params.system.startsWith('# Xingular Harness context\n') })
+    }))
+    const started = await run('context-run', { preamble: '[Group context]', text: 'The user request' })
+    await tick()
+    expect(started).toEqual({ runId: 'context-run', nativeSessionId: 'native-1' })
+    expect(delivered).toEqual([
+      { type: 'xingular-context', display: false, options: { triggerTurn: false }, snapshot: ['xingularContext'] },
+      { text: '[Group context]\n\nThe user request', system: true }
+    ])
+    expect(events.filter((event) => event.type === 'usage.updated')).toHaveLength(0)
+    expect(events.at(-1)?.type).toBe('completed')
+    expect(loadRun(harness.env.root, 'context-run')).toMatchObject({ status: 'completed', nativeSessionId: 'native-1', mode: 'chat', harness: 'pi', goal: 'The user request', agentId: 'agent-1' })
+    expect(readEvents(harness.env.root, 'context-run').map((event) => event.sequence)).toEqual(events.map((_, index) => index))
+  })
+
+  it('streams Pi events as contract events and completes', async () => {
+    const { events, run } = setup(async ({ gate }) =>
+      fakeSession(async (emit) => {
+        emit({ type: 'message_start', message: { role: 'assistant' } })
+        emit({ type: 'message_update', message: { role: 'assistant' }, assistantMessageEvent: { type: 'text_delta', delta: 'Hi' } })
+        emit({ type: 'message_end', message: { role: 'assistant', content: [{ type: 'text', text: 'Hi' }], usage: { input: 3, output: 1 } } })
+      }, gate)
+    )
+    await run('run-1')
+    await tick()
+    expect(events.map((event) => event.type)).toEqual(['started', 'status.changed', 'context.snapshot', 'message.delta', 'message.completed', 'usage.updated', 'completed'])
+    expect(events.map((event) => event.sequence)).toEqual([0, 1, 2, 3, 4, 5, 6])
+  })
+
+  it('reports cache, reasoning, cost and context size across the requests of a reply', async () => {
+    const { events, run } = setup(async ({ gate }) => ({
+      ...fakeSession(async (emit) => {
+        emit({ type: 'message_end', message: { role: 'assistant', content: [], model: 'sonnet', provider: 'anthropic', usage: { input: 10, output: 4, cacheRead: 100, cacheWrite: 20, reasoning: 1, cost: { total: 0.01 } } } })
+        emit({ type: 'message_end', message: { role: 'assistant', content: [{ type: 'text', text: 'Done' }], model: 'sonnet', provider: 'anthropic', usage: { input: 5, output: 6, cacheRead: 130, cacheWrite: 0, reasoning: 2, cost: { total: 0.02 } } } })
+        emit({ type: 'message_end', message: { role: 'assistant', content: [], usage: { input: 1, output: 1 } } })
+      }, gate),
+      model: { input: ['text'], contextWindow: 200_000 }
+    }))
+    await run('run-1')
+    await tick()
+    const usage = events.filter((event) => event.type === 'usage.updated').map((event) => event.payload as Record<string, unknown>)
+    expect(usage[1]).toMatchObject({ inputTokens: 15, outputTokens: 10, cacheReadTokens: 230, cacheWriteTokens: 20, reasoningTokens: 3, requests: 2, contextTokens: 135, contextWindow: 200_000, model: 'sonnet', provider: 'anthropic' })
+    expect(usage[1].costUsd).toBeCloseTo(0.03)
+    // A request without the optional figures leaves the running totals intact.
+    expect(usage[2]).toMatchObject({ inputTokens: 16, cacheReadTokens: 230, reasoningTokens: 3, requests: 3, contextTokens: 1 })
+    expect(usage[2]).not.toHaveProperty('model')
+  })
+
+  it('reports each model request on its own, with its model, cost and timing', async () => {
+    const { events, run } = setup(async ({ gate }) =>
+      fakeSession(async (emit) => {
+        emit({ type: 'turn_start' })
+        emit({ type: 'message_update', message: { role: 'assistant' }, assistantMessageEvent: { type: 'thinking_delta' } })
+        emit({ type: 'message_end', message: { role: 'assistant', content: [], model: 'sonnet', provider: 'anthropic', responseId: 'resp-1', stopReason: 'toolUse', usage: { input: 10, output: 4, cacheRead: 100, cacheWrite: 20, reasoning: 1, cost: { total: 0.01 } } } })
+        emit({ type: 'tool_execution_start', toolCallId: 't1', toolName: 'read', args: { path: 'a.md' } })
+        emit({ type: 'tool_execution_end', toolCallId: 't1', toolName: 'read', isError: false, result: { content: [{ type: 'text', text: 'x'.repeat(1200) }, { type: 'image' }] } })
+        emit({ type: 'turn_start' })
+        emit({ type: 'message_end', message: { role: 'assistant', content: [{ type: 'text', text: 'Done' }], model: 'haiku', provider: 'anthropic', usage: { input: 5, output: 6 } } })
+      }, gate)
+    )
+    await run('run-1')
+    await tick()
+    const requests = events.filter((event) => event.type === 'usage.updated').map((event) => (event.payload as { request: Record<string, unknown> }).request)
+    expect(requests[0]).toMatchObject({ index: 1, responseId: 'resp-1', model: 'sonnet', provider: 'anthropic', inputTokens: 10, cacheReadTokens: 100, cacheWriteTokens: 20, outputTokens: 4, reasoningTokens: 1, costUsd: 0.01, costSource: 'harness', stopReason: 'toolUse' })
+    expect(requests[0]).not.toHaveProperty('reasoningSummary')
+    expect(requests[0].durationMs).toBeGreaterThanOrEqual(0)
+    expect(requests[0].ttftMs).toBeGreaterThanOrEqual(0)
+    // The second request reported no cost and produced no streamed output.
+    expect(requests[1]).toMatchObject({ index: 2, model: 'haiku', inputTokens: 5, outputTokens: 6, cacheReadTokens: 0 })
+    for (const key of ['costUsd', 'costSource', 'ttftMs', 'reasoningTokens', 'responseId']) expect(requests[1]).not.toHaveProperty(key)
+    const tool = events.find((event) => event.type === 'tool.completed')!.payload as Record<string, unknown>
+    // Stored evidence is redacted, which rewrites JSON carried as text in its compact form.
+    expect(events.find((event) => event.type === 'tool.started')?.payload).toMatchObject({ toolCallId: 't1', input: '{"path":"a.md"}' })
+    expect(tool).toMatchObject({ toolCallId: 't1', ok: true, resultChars: 1200 })
+    expect(tool.output).toContain('x'.repeat(1200))
+  })
+
+  it('persists only an explicitly captured provider summary without inventing usage figures', async () => {
+    const { events, run } = setup(async ({ gate }) =>
+      fakeSession(async (emit) => {
+        emit({ type: 'turn_start' })
+        emit({ type: 'message_end', message: { role: 'assistant', api: 'openai-codex-responses', content: [
+          { type: 'thinking', thinkingSignature: JSON.stringify({ type: 'reasoning', summary: [{ type: 'summary_text', text: 'I will check the saved state before changing the file.' }], content: [{ text: 'private reasoning' }], encrypted_content: 'private replay payload' }) },
+          { type: 'text', text: 'Done.' }
+        ], model: 'gpt-6', provider: 'openai', responseId: 'response-1' } })
+      }, gate)
+    )
+    await run('summary-run')
+    await tick()
+    const usage = events.find((event) => event.type === 'usage.updated')!.payload as Record<string, unknown>
+    expect(usage).toMatchObject({ requests: 1, model: 'gpt-6', provider: 'openai' })
+    expect(usage).not.toHaveProperty('inputTokens')
+    expect(usage.request).toMatchObject({ index: 1, responseId: 'response-1', reasoningSummary: 'I will check the saved state before changing the file.' })
+    expect(usage.request).not.toHaveProperty('outputTokens')
+    expect(JSON.stringify(events)).not.toContain('private reasoning')
+    expect(JSON.stringify(events)).not.toContain('private replay payload')
+  })
+
+  it('records the compiled prompt and schemas for the tools actually declared to the model', async () => {
+    const { events, run } = setup(async ({ gate }) => ({
+      ...fakeSession(async () => undefined, gate),
+      sendCustomMessage: async () => undefined,
+      getActiveToolNames: () => ['read'],
+      getAllTools: () => [
+        { name: 'read', description: 'Read a file', parameters: { type: 'object', properties: { path: { type: 'string' } } } },
+        { name: 'write', description: 'Write a file', parameters: { type: 'object' } }
+      ]
+    }))
+    await run('run-1')
+    await tick()
+    const snapshot = events.find((event) => event.type === 'context.snapshot')!.payload as { systemPrompt: string; contextUpdate: string; tools: unknown[] }
+    expect(snapshot.systemPrompt).toContain('## Context updates')
+    expect(snapshot.contextUpdate).toContain('<block label="persona"')
+    expect(snapshot.tools).toEqual([{ name: 'read', description: 'Read a file', parameters: { type: 'object', properties: { path: { type: 'string' } } } }])
+  })
+
+  it('caps saved tool inputs and outputs at 24,000 characters with truncation flags', async () => {
+    const large = 'x'.repeat(25_000)
+    const { events, run } = setup(async ({ gate }) =>
+      fakeSession(async (emit) => {
+        emit({ type: 'tool_execution_start', toolCallId: 't1', toolName: 'computer_type_text', args: { app: 'Editor', text: large } })
+        emit({ type: 'tool_execution_end', toolCallId: 't1', toolName: 'computer_type_text', isError: false, result: large })
+      }, gate)
+    )
+    await run('run-1')
+    await tick()
+    const started = events.find((event) => event.type === 'tool.started')!.payload as { input: string; inputTruncated: boolean }
+    const completed = events.find((event) => event.type === 'tool.completed')!.payload as { output: string; outputTruncated: boolean }
+    expect([started.inputTruncated, completed.outputTruncated]).toEqual([true, true])
+    expect(started.input.length).toBeLessThanOrEqual(24_000)
+    expect(completed.output.length).toBeLessThanOrEqual(24_000)
+  })
+
+  it('records bounded retry and compaction events without exposing thinking text', async () => {
+    const { events, run } = setup(async ({ gate }) =>
+      fakeSession(async (emit) => {
+        emit({ type: 'auto_retry_start', attempt: 1, maxAttempts: 3, delayMs: 250, errorMessage: 'Temporary failure' } as unknown as PiEvent)
+        emit({ type: 'auto_retry_end', attempt: 1, success: true } as unknown as PiEvent)
+        emit({ type: 'compaction_start', reason: 'threshold' } as unknown as PiEvent)
+        emit({ type: 'compaction_end', reason: 'threshold', aborted: false, willRetry: true, result: { summary: 'kept the latest messages' } } as unknown as PiEvent)
+      }, gate)
+    )
+    await run('run-1')
+    await tick()
+    expect(events.filter((event) => event.type.startsWith('retry.') || event.type.startsWith('compaction.')).map((event) => event.type)).toEqual(['retry.started', 'retry.ended', 'compaction.started', 'compaction.ended'])
+    expect(events.find((event) => event.type === 'compaction.ended')?.payload).toMatchObject({ aborted: false, willRetry: true, summary: '{"summary":"kept the latest messages"}' })
+  })
+
+  it('leaves out the cost and reasoning figures nobody reported', async () => {
+    const { events, run } = setup(async ({ gate }) => fakeSession(async (emit) => emit({ type: 'message_end', message: { role: 'assistant', content: [], usage: { input: 1, output: 1 } } }), gate))
+    await run('run-1')
+    await tick()
+    const usage = events.find((event) => event.type === 'usage.updated')!.payload as Record<string, unknown>
+    for (const key of ['costUsd', 'reasoningTokens', 'contextWindow']) expect(usage).not.toHaveProperty(key)
+    expect(usage.request).not.toHaveProperty('durationMs')
+  })
+
+  it('pauses gated tools for approval and blocks on deny', async () => {
+    let blockReason: string | null | undefined
+    const { events, run, harness } = setup(async ({ gate }) => fakeSession(async (_emit, check) => void (blockReason = await check()), gate))
+    await run('run-2', { text: 'list files' })
+    await tick()
+    const approval = events.find((event) => event.type === 'approval.requested')!.payload as { approvalId: string }
+    expect(approval).toMatchObject({ target: 'bash', action: 'ls', rememberable: true })
+    expect(loadRun(harness.env.root, 'run-2').status).toBe('waiting_for_approval')
+    harness.runs.resolveApproval('run-2', approval.approvalId, 'denied')
+    await tick()
+    expect(blockReason).toMatch(/denied/)
+    expect(events.some((event) => event.type === 'approval.resolved')).toBe(true)
+  })
+
+  it("asks before a tool an extension brought, and relays the extension's question and notice as run events", async () => {
+    let blockReason: string | null | undefined
+    let answered: unknown
+    const { events, run, harness } = setup(async ({ gate, extensions }) => ({
+      ...fakeSession(async () => undefined, gate),
+      prompt: async () => {
+        // What a loaded extension does: registers a tool nobody switched on by name, shows a line, and asks.
+        gate.ask?.(['kit_scan'])
+        extensions!.notice({ kind: 'status', key: 'kit', text: 'Scanning' })
+        answered = await extensions!.ask({ question: 'Scan the whole folder?', options: [{ label: 'Yes' }, { label: 'No' }], multiSelect: false, allowText: false })
+        blockReason = await gate.check('kit_scan', { path: '.' })
+      }
+    }))
+    await run('run-ext', { text: 'scan' })
+    await tick()
+    expect(events.find((event) => event.type === 'extension.notice')?.payload).toEqual({ kind: 'status', key: 'kit', text: 'Scanning' })
+    const question = events.find((event) => event.type === 'question.requested')!.payload as { questionId: string }
+    expect(question).toMatchObject({ question: 'Scan the whole folder?' })
+    harness.runs.answerQuestion('run-ext', question.questionId, { selected: ['Yes'] })
+    await tick()
+    expect(answered).toEqual({ selected: ['Yes'] })
+    const approval = events.find((event) => event.type === 'approval.requested')!.payload as { approvalId: string }
+    expect(approval).toMatchObject({ target: 'kit_scan' })
+    harness.runs.resolveApproval('run-ext', approval.approvalId, 'approved')
+    await tick()
+    expect(blockReason).toBeNull()
+  })
+
+  it('gives an unattended run no extension interface', async () => {
+    let offered: unknown = 'unset'
+    const { run } = setup(async ({ gate, extensions }) => {
+      offered = extensions
+      return fakeSession(async () => undefined, gate)
+    })
+    await run('run-auto-ext', { text: 'tidy', automatic: true })
+    await tick()
+    expect(offered).toBeUndefined()
+  })
+
+  it('skips the prompt for a tool the user already allowed in this session', async () => {
+    let blockReason: string | null | undefined
+    const { events, run, harness } = setup(async ({ gate }) => fakeSession(async (_emit, check) => void (blockReason = await check()), gate))
+    harness.approvals.remember('agent-1', 'bash')
+    await run('run-auto', { text: 'list files' })
+    await tick()
+    expect(blockReason).toBeNull()
+    expect(events.find((event) => event.type === 'approval.requested')?.payload).toMatchObject({ target: 'bash', rememberable: true, automatic: 'remembered' })
+    expect(events.find((event) => event.type === 'approval.resolved')?.payload).toMatchObject({ decision: 'approved', automatic: 'remembered' })
+    expect(events.some((event) => event.type === 'status.changed' && (event.payload as { status: string }).status === 'waiting_for_approval')).toBe(false)
+    expect(events.at(-1)?.type).toBe('completed')
+  })
+
+  it('still asks when the application cannot say what is allowed', async () => {
+    const { events, run } = setup(async ({ gate }) => fakeSession(async (_emit, check) => void (await check()), gate), { approval: async () => { throw new Error('down') } })
+    await run('run-ask', { text: 'list files' })
+    await tick()
+    expect(events.some((event) => event.type === 'status.changed' && (event.payload as { status: string }).status === 'waiting_for_approval')).toBe(true)
+    expect(events.some((event) => event.type === 'approval.resolved')).toBe(false)
+  })
+
+  it('lets the application refuse a call that is outside an unattended run\'s scope, and switch a tool off', async () => {
+    const reasons: (string | null)[] = []
+    let authorized = 0
+    const policy: ToolPolicy = {
+      scope: async ({ tool }) => ({ automatic: true, allowed: tool !== 'bash', reason: 'Scheduled workers may use scoped file tools only.' }),
+      authorize: async () => {
+        authorized += 1
+        if (authorized > 1) throw new Error('Tool unavailable in the app settings.')
+      }
+    }
+    const { run } = setup(async ({ gate }) => fakeSession(async () => {
+      reasons.push(await gate.check('bash', {}), await gate.check('read', {}), await gate.check('read', {}))
+    }, gate), policy)
+    await run('run-scope')
+    await tick()
+    expect(reasons).toEqual(['Scheduled workers may use scoped file tools only.', null, 'Tool unavailable in the app settings.'])
+  })
+
+  it('aborts the Pi session on interrupt', async () => {
+    let session: (PiSessionLike & { aborted: boolean }) | null = null
+    const { events, run, harness } = setup(async ({ gate }) => (session = fakeSession(() => new Promise((resolve) => setTimeout(resolve, 50)), gate)))
+    await run('run-3')
+    await tick()
+    await harness.runs.interrupt('run-3')
+    await tick(80)
+    expect(session!.aborted).toBe(true)
+    expect(events.at(-1)).toMatchObject({ type: 'status.changed', payload: { status: 'interrupted' } })
+    expect(loadRun(harness.env.root, 'run-3').status).toBe('interrupted')
+  })
+
+  it('gives every session the memory, recall and Wiki tools, a question tool, and the application\'s tools in order', async () => {
+    let received: Parameters<SessionFactory>[0] | null = null
+    const { run, harness } = setup(async (input) => {
+      received = input
+      return fakeSession(async () => undefined, input.gate)
+    })
+    harness.sessions.provide(() => [{ name: 'react', label: 'React', description: 'React', parameters: (Type) => Type.Object({}), execute: async () => 'ok' }])
+    await run('run-5', { tools: { allow: ['react'] } })
+    await tick()
+    expect(received!.allow.slice(0, 3)).toEqual(['react', 'ask_user', 'plugin_propose'])
+    expect(received!.allow).toEqual(expect.arrayContaining(['memory_append', 'history_search', 'wiki_search', 'wiki_read', 'wiki_propose']))
+    expect(received!.tools.map((tool) => tool.name)).toEqual(['memory_append', 'memory_replace', 'memory_rethink', 'history_search', 'history_read', 'wiki_search', 'wiki_read', 'wiki_list', 'skill_load', 'memory_facts', 'wiki_propose', 'ask_user', 'plugin_propose', 'react'])
+    expect(await received!.tools[0].execute({ block: 'notes', text: 'Remember this.' })).toContain('Updated the notes block')
+    expect(received!.params.system).toContain('# Xingular Harness context')
+  })
+
+  it('refuses missing continuation history before creating a run or opening a session', async () => {
+    let called = false
+    const { run, events, harness } = setup(async ({ gate }) => {
+      called = true
+      return fakeSession(async () => undefined, gate)
+    })
+    await expect(run('resume-run', { resume: { sessionFile: '/tmp/missing-history/saved.jsonl', nativeSessionId: 'native-1' } })).rejects.toMatchObject({ code: 'native_resume_unavailable' })
+    expect(called).toBe(false)
+    expect(events).toEqual([])
+    expect(() => loadRun(harness.env.root, 'resume-run')).toThrow()
+  })
+
+  it('fails the run when the session cannot start', async () => {
+    const { events, run, harness } = setup(async () => {
+      throw new Error('No provider')
+    })
+    expect(await run('run-4')).toEqual({ runId: 'run-4', nativeSessionId: null })
+    expect(events.at(-1)).toMatchObject({ type: 'failed', payload: { message: 'No provider' } })
+    expect(loadRun(harness.env.root, 'run-4')).toMatchObject({ status: 'failed', terminalReason: 'No provider' })
+  })
+
+  it('needs an account before it records anything', async () => {
+    const harness = createHarness({ dataRoot: mkdtempSync(join(tmpdir(), 'harness-data-')), stateDir: mkdtempSync(join(tmpdir(), 'harness-state-')), secrets: memorySecretStore(), sessionFactory: async () => { throw new Error('unreachable') } })
+    open.push(harness)
+    await expect(harness.sessions.run({ run: { id: 'r', sessionId: 's' }, cwd: '/tmp', sessionDir: join(harness.env.root, 's'), text: 'x', caller: { agentId: 'a' }, tools: { allow: [] } })).rejects.toMatchObject({ code: 'account_required' })
+    expect(() => loadRun(harness.env.root, 'r')).toThrow()
+  })
+})
+
+describe('history selection', () => {
+  it('opens the newest history, or exactly the recorded one for a continuation', () => {
+    const dir = mkdtempSync(join(tmpdir(), 'context-history-'))
+    expect(selectHistory({ sessionDir: dir })).toBeNull()
+    expect(selectHistory({ sessionDir: join(dir, 'missing') })).toBeNull()
+    const first = join(dir, 'first.jsonl')
+    const newer = join(dir, 'newer.jsonl')
+    writeFileSync(first, `${JSON.stringify({ type: 'session', id: 'first' })}\n`)
+    writeFileSync(newer, `${JSON.stringify({ type: 'session', id: 'newer' })}\n`)
+    writeFileSync(join(dir, 'notes.txt'), '')
+    utimesSync(newer, new Date(Date.now() + 1000), new Date(Date.now() + 1000))
+    utimesSync(join(dir, 'notes.txt'), new Date(Date.now() + 5000), new Date(Date.now() + 5000))
+    expect(selectHistory({ sessionDir: dir })).toBe(realpathSync(newer))
+    expect(selectHistory({ sessionDir: dir, resume: { sessionFile: first, nativeSessionId: 'first' } })).toBe(realpathSync(first))
+    expect(() => selectHistory({ sessionDir: dir, resume: { sessionFile: first, nativeSessionId: 'newer' } })).toThrow(/saved conversation/)
+    expect(() => selectHistory({ sessionDir: dir, resume: { sessionFile: join(dir, 'missing'), nativeSessionId: 'first' } })).toThrow(/saved conversation/)
+    expect(() => selectHistory({ sessionDir: dir, resume: { sessionFile: first } })).toThrow(/saved conversation/)
+    const outside = join(mkdtempSync(join(tmpdir(), 'other-history-')), 'outside.jsonl')
+    writeFileSync(outside, `${JSON.stringify({ type: 'session', id: 'outside' })}\n`)
+    expect(() => selectHistory({ sessionDir: dir, resume: { sessionFile: outside, nativeSessionId: 'outside' } })).toThrow(/saved conversation/)
+  })
+
+  it('never opens a newest file that is not a native history', () => {
+    const dir = mkdtempSync(join(tmpdir(), 'context-history-'))
+    writeFileSync(join(dir, 'broken.jsonl'), 'not json\n')
+    expect(() => selectHistory({ sessionDir: dir })).toThrow(/saved conversation/)
+  })
+})
+
+describe('standing approvals', () => {
+  const policy = { auto: { pi: true }, remembered: { 'pane-1': ['shell'] } }
+  const facts = (unattended: boolean, readOnly: boolean): ApprovalFacts => ({ unattended, readOnly })
+
+  it('the switch reaches attended sessions but not unattended or read-only ones', () => {
+    expect(grant(policy, 'pi', 'pane-1', 'edit files', facts(false, false))).toBe('always')
+    expect(grant(policy, 'pi', 'pane-1', 'edit files', facts(true, false))).toBeNull()
+    expect(grant(policy, 'pi', 'pane-1', 'edit files', facts(false, true))).toBeNull()
+    expect(grant(policy, 'pi', 'pane-1', 'shell', facts(false, true))).toBe('remembered')
+    expect(grant(policy, 'pi', 'pane-1', 'shell', facts(true, false))).toBeNull()
+    expect(grant(policy, 'chat', 'pane-1', 'edit files', facts(false, false))).toBeNull()
+    expect(grant(policy, 'pi', 'pane-2', 'shell', {})).toBe('always')
+    expect(grant({ auto: {}, remembered: policy.remembered }, 'pi', 'pane-2', 'shell', {})).toBeNull()
+  })
+})