@pi-in-go/pigpen-acp 0.1.0

package/port/oracle/pi-acp/test/component/session-list-and-load.test.ts

@@ -0,0 +1,129 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import { mkdtempSync, writeFileSync, mkdirSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+
+import { PiAcpAgent } from '../../src/acp/agent.js'
+import { FakeAgentSideConnection, asAgentConn } from '../helpers/fakes.js'
+
+// We mock PiRpcProcess.spawn so loadSession doesn't actually spawn `pi`.
+import { PiRpcProcess } from '../../src/pi-rpc/process.js'
+
+test('PiAcpAgent: listSessions lists pi sessions and loadSession replays history', async () => {
+  // Create a fake PI_CODING_AGENT_DIR with one session.
+  const root = mkdtempSync(join(tmpdir(), 'pi-acp-test-'))
+  const sessionsDir = join(root, 'sessions', '--tmp--project--')
+  const sessionFile = join(sessionsDir, '0000_aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.jsonl')
+
+  // Ensure parent dirs.
+  mkdirSync(sessionsDir, { recursive: true })
+
+  writeFileSync(
+    sessionFile,
+    [
+      JSON.stringify({
+        type: 'session',
+        version: 3,
+        id: 'sess-1',
+        timestamp: '2026-02-11T00:00:00.000Z',
+        cwd: '/tmp/project'
+      }),
+      JSON.stringify({
+        type: 'message',
+        id: 'a1b2c3d4',
+        parentId: null,
+        timestamp: '2026-02-11T00:00:01.000Z',
+        message: { role: 'user', content: 'Hello' }
+      }),
+      JSON.stringify({
+        type: 'message',
+        id: 'b2c3d4e5',
+        parentId: 'a1b2c3d4',
+        timestamp: '2026-02-11T00:00:02.000Z',
+        message: { role: 'assistant', content: [{ type: 'text', text: 'Hi there!' }] }
+      }),
+      JSON.stringify({
+        type: 'session_info',
+        id: 'c3d4e5f6',
+        parentId: 'b2c3d4e5',
+        timestamp: '2026-02-11T00:00:03.000Z',
+        name: 'My Named Session'
+      })
+    ].join('\n') + '\n',
+    { encoding: 'utf8' }
+  )
+
+  const oldEnv = process.env.PI_CODING_AGENT_DIR
+  process.env.PI_CODING_AGENT_DIR = root
+
+  try {
+    const conn = new FakeAgentSideConnection()
+    const agent = new PiAcpAgent(asAgentConn(conn))
+
+    // 1) list sessions
+    const listed = await agent.listSessions({ cwd: null, cursor: null, _meta: null } as any)
+    assert.ok(listed.sessions.length >= 1)
+
+    const s = listed.sessions.find(x => x.sessionId === 'sess-1')
+    assert.ok(s)
+    assert.equal(s?.cwd, '/tmp/project')
+    assert.equal(s?.title, 'My Named Session')
+
+    // 2) load session: mock spawn to return fake proc with getMessages
+    const originalSpawn = PiRpcProcess.spawn
+
+    ;(PiRpcProcess as any).spawn = async (params: any) => {
+      // ensure loadSession resolves to some jsonl that ends with our expected filename
+      assert.ok(typeof params.sessionPath === 'string')
+      assert.ok(params.sessionPath.endsWith('/0000_aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.jsonl'))
+
+      return {
+        onEvent: () => () => {
+          // noop unsubscribe
+        },
+        getMessages: async () => ({
+          messages: [
+            { role: 'user', content: 'Hello' },
+            { role: 'assistant', content: [{ type: 'text', text: 'Hi there!' }] }
+          ]
+        }),
+        getAvailableThinkingLevels: async () => ['medium'],
+        getSessionStats: async () => ({ contextUsage: { tokens: 12_345, contextWindow: 200_000 } }),
+        getAvailableModels: async () => ({ models: [] }),
+        getState: async () => ({ thinkingLevel: 'medium' })
+      } as any
+    }
+
+    try {
+      await agent.loadSession({ sessionId: 'sess-1', cwd: '/tmp/project', mcpServers: [], _meta: null } as any)
+
+      // loadSession should have replayed messages as session/update notifications.
+      const texts = conn.updates
+        .map(u => (u as any).update)
+        .filter(Boolean)
+        .map(u => ({ kind: u.sessionUpdate, text: u.content?.text }))
+
+      assert.ok(texts.some(t => t.kind === 'user_message_chunk' && t.text === 'Hello'))
+      assert.ok(texts.some(t => t.kind === 'agent_message_chunk' && t.text === 'Hi there!'))
+
+      // loadSession schedules the usage publish after returning (client must know the sessionId first).
+      assert.equal(
+        conn.updates.some(u => (u as any).update?.sessionUpdate === 'usage_update'),
+        false
+      )
+      await new Promise(r => setTimeout(r, 0))
+      await new Promise(r => setTimeout(r, 0))
+
+      assert.deepEqual(
+        conn.updates.filter(u => (u as any).update?.sessionUpdate === 'usage_update'),
+        [{ sessionId: 'sess-1', update: { sessionUpdate: 'usage_update', used: 12_345, size: 200_000 } }]
+      )
+    } finally {
+      PiRpcProcess.spawn = originalSpawn
+    }
+  } finally {
+    if (oldEnv === undefined) delete process.env.PI_CODING_AGENT_DIR
+    else process.env.PI_CODING_AGENT_DIR = oldEnv
+  }
+})

package/port/oracle/pi-acp/test/component/session-list-custom-session-dir.test.ts

@@ -0,0 +1,52 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import { mkdtempSync, writeFileSync, mkdirSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+
+import { listPiSessions } from '../../src/acp/pi-sessions.js'
+
+test('listPiSessions: respects sessionDir from pi settings.json', async () => {
+  const root = mkdtempSync(join(tmpdir(), 'pi-acp-test-'))
+  const customSessionsDir = join(root, 'somewhere-else', '--p--')
+  mkdirSync(customSessionsDir, { recursive: true })
+
+  writeFileSync(
+    join(root, 'settings.json'),
+    JSON.stringify({ sessionDir: join(root, 'somewhere-else') }, null, 2),
+    'utf8'
+  )
+
+  writeFileSync(
+    join(customSessionsDir, 's.jsonl'),
+    [
+      JSON.stringify({
+        type: 'session',
+        version: 3,
+        id: 'sess-custom',
+        timestamp: '2026-01-01T00:00:00.000Z',
+        cwd: '/tmp/project'
+      }),
+      JSON.stringify({
+        type: 'message',
+        id: 'm1',
+        parentId: null,
+        timestamp: '2026-01-01T00:00:01.000Z',
+        message: { role: 'user', content: 'hi' }
+      })
+    ].join('\n') + '\n',
+    { encoding: 'utf8' }
+  )
+
+  const oldEnv = process.env.PI_CODING_AGENT_DIR
+  process.env.PI_CODING_AGENT_DIR = root
+
+  try {
+    const s = listPiSessions().find(x => x.sessionId === 'sess-custom')
+    assert.ok(s)
+    assert.equal(s?.sessionFile, join(customSessionsDir, 's.jsonl'))
+  } finally {
+    if (oldEnv === undefined) delete process.env.PI_CODING_AGENT_DIR
+    else process.env.PI_CODING_AGENT_DIR = oldEnv
+  }
+})

package/port/oracle/pi-acp/test/component/session-list-scoped.test.ts

@@ -0,0 +1,76 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import { mkdtempSync, writeFileSync, mkdirSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+
+import { PiAcpAgent } from '../../src/acp/agent.js'
+import { FakeAgentSideConnection, asAgentConn } from '../helpers/fakes.js'
+
+test('PiAcpAgent: listSessions defaults to lastSessionCwd when cwd param is omitted', async () => {
+  const root = mkdtempSync(join(tmpdir(), 'pi-acp-test-'))
+
+  const dirA = join(root, 'sessions', '--a--')
+  const dirB = join(root, 'sessions', '--b--')
+  mkdirSync(dirA, { recursive: true })
+  mkdirSync(dirB, { recursive: true })
+
+  writeFileSync(
+    join(dirA, '1.jsonl'),
+    JSON.stringify({
+      type: 'session',
+      version: 3,
+      id: 'sess-a',
+      timestamp: '2026-01-01T00:00:00.000Z',
+      cwd: '/cwd/a'
+    }) +
+      '\n' +
+      JSON.stringify({
+        type: 'session_info',
+        id: 'a1b2c3d4',
+        parentId: null,
+        timestamp: '2026-01-01T00:00:01.000Z',
+        name: 'A'
+      }) +
+      '\n',
+    { encoding: 'utf8' }
+  )
+
+  writeFileSync(
+    join(dirB, '2.jsonl'),
+    JSON.stringify({
+      type: 'session',
+      version: 3,
+      id: 'sess-b',
+      timestamp: '2026-01-01T00:00:00.000Z',
+      cwd: '/cwd/b'
+    }) +
+      '\n' +
+      JSON.stringify({
+        type: 'session_info',
+        id: 'b1b2c3d4',
+        parentId: null,
+        timestamp: '2026-01-01T00:00:01.000Z',
+        name: 'B'
+      }) +
+      '\n',
+    { encoding: 'utf8' }
+  )
+
+  const oldEnv = process.env.PI_CODING_AGENT_DIR
+  process.env.PI_CODING_AGENT_DIR = root
+
+  try {
+    const conn = new FakeAgentSideConnection()
+    const agent = new PiAcpAgent(asAgentConn(conn))
+
+    ;(agent as any).lastSessionCwd = '/cwd/a'
+
+    const listed = await agent.listSessions({} as any)
+    assert.equal(listed.sessions.length, 1)
+    assert.equal(listed.sessions[0]?.sessionId, 'sess-a')
+  } finally {
+    if (oldEnv === undefined) delete process.env.PI_CODING_AGENT_DIR
+    else process.env.PI_CODING_AGENT_DIR = oldEnv
+  }
+})

package/port/oracle/pi-acp/test/component/session-load-toolresult.test.ts

@@ -0,0 +1,68 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+
+import { PiAcpAgent } from '../../src/acp/agent.js'
+import { FakeAgentSideConnection, asAgentConn } from '../helpers/fakes.js'
+import { PiRpcProcess } from '../../src/pi-rpc/process.js'
+
+class FakeStore {
+  get(_sessionId: string) {
+    return { sessionId: 's1', cwd: '/tmp/project', sessionFile: '/tmp/s.jsonl', updatedAt: new Date().toISOString() }
+  }
+  upsert() {}
+}
+
+test('PiAcpAgent: loadSession replays toolResult as tool_call + tool_call_update', async () => {
+  const originalSpawn = PiRpcProcess.spawn
+  ;(PiRpcProcess as any).spawn = async () => {
+    return {
+      onEvent: () => () => {},
+      getMessages: async () => ({
+        messages: [
+          {
+            role: 'toolResult',
+            toolCallId: 'call_1',
+            toolName: 'bash',
+            args: { command: 'echo hello' },
+            content: [{ type: 'text', text: 'hello from bash' }],
+            isError: false
+          }
+        ]
+      }),
+      getAvailableThinkingLevels: async () => ['medium'],
+      getAvailableModels: async () => ({ models: [] }),
+      getState: async () => ({ thinkingLevel: 'medium' })
+    } as any
+  }
+
+  try {
+    const conn = new FakeAgentSideConnection()
+    const agent = new PiAcpAgent(asAgentConn(conn))
+    ;(agent as any).store = new FakeStore()
+
+    await agent.loadSession({ sessionId: 's1', cwd: '/tmp/project', mcpServers: [] } as any)
+
+    const updates = conn.updates.map(u => (u as any).update)
+
+    const toolCall = updates.find(u => u?.sessionUpdate === 'tool_call')
+    assert.ok(toolCall)
+    assert.equal(toolCall.toolCallId, 'call_1')
+    assert.equal(toolCall.title, 'echo hello')
+    assert.equal(toolCall.kind, 'execute')
+    assert.deepEqual(toolCall.content, [{ type: 'terminal', terminalId: 'call_1' }])
+    assert.deepEqual(toolCall._meta, { terminal_info: { terminal_id: 'call_1', cwd: '/tmp/project' } })
+    assert.equal(toolCall.rawOutput, undefined)
+
+    const toolCallUpdate = updates.find(u => u?.sessionUpdate === 'tool_call_update')
+    assert.ok(toolCallUpdate)
+    assert.equal(toolCallUpdate.toolCallId, 'call_1')
+    assert.equal(toolCallUpdate.status, 'completed')
+    assert.deepEqual(toolCallUpdate._meta, {
+      terminal_output: { terminal_id: 'call_1', data: 'hello from bash' },
+      terminal_exit: { terminal_id: 'call_1', exit_code: 0, signal: null }
+    })
+    assert.equal(toolCallUpdate.rawOutput, undefined)
+  } finally {
+    PiRpcProcess.spawn = originalSpawn
+  }
+})

package/port/oracle/pi-acp/test/component/session-queue-cancel.test.ts

@@ -0,0 +1,43 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import { PiAcpSession } from '../../src/acp/session.js'
+import { FakeAgentSideConnection, FakePiRpcProcess, asAgentConn } from '../helpers/fakes.js'
+
+test('PiAcpSession: cancel clears queued prompts', async () => {
+  const conn = new FakeAgentSideConnection()
+  const proc = new FakePiRpcProcess()
+
+  const session = new PiAcpSession({
+    sessionId: 's1',
+    cwd: process.cwd(),
+    mcpServers: [],
+    proc: proc as any,
+    conn: asAgentConn(conn),
+    fileCommands: []
+  })
+
+  const first = session.prompt('one')
+  const second = session.prompt('two')
+  const third = session.prompt('three')
+
+  // first started, second+third queued
+  assert.equal(proc.prompts.length, 1)
+
+  await session.cancel()
+
+  assert.equal(proc.abortCount, 1)
+
+  // queued prompts should resolve as cancelled
+  assert.equal(await second, 'cancelled')
+  assert.equal(await third, 'cancelled')
+
+  // finish first prompt as cancelled after abort
+  proc.emit({ type: 'agent_start' })
+  proc.emit({ type: 'turn_end' })
+  proc.emit({ type: 'agent_end' })
+  proc.emit({ type: 'agent_settled' })
+  assert.equal(await first, 'cancelled')
+
+  // queue should have been cleared, so no further prompt started
+  assert.equal(proc.prompts.length, 1)
+})

package/port/oracle/pi-acp/test/component/session-slash-commands.test.ts

@@ -0,0 +1,37 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import { PiAcpSession } from '../../src/acp/session.js'
+import { FakeAgentSideConnection, FakePiRpcProcess, asAgentConn } from '../helpers/fakes.js'
+
+test('PiAcpSession: expands /command before sending to pi', async () => {
+  const conn = new FakeAgentSideConnection()
+  const proc = new FakePiRpcProcess()
+
+  const session = new PiAcpSession({
+    sessionId: 's1',
+    cwd: process.cwd(),
+    mcpServers: [],
+    proc: proc as any,
+    conn: asAgentConn(conn),
+    fileCommands: [
+      {
+        name: 'hello',
+        description: '(user)',
+        content: 'Expanded $1',
+        source: '(user)'
+      }
+    ]
+  })
+
+  const p = session.prompt('/hello world')
+
+  proc.emit({ type: 'agent_start' })
+  proc.emit({ type: 'turn_end' })
+  proc.emit({ type: 'agent_end' })
+  proc.emit({ type: 'agent_settled' })
+  const reason = await p
+
+  assert.equal(reason, 'end_turn')
+  assert.equal(proc.prompts.length, 1)
+  assert.equal(proc.prompts[0]!.message, 'Expanded world')
+})

package/port/oracle/pi-acp/test/component/session-thinking-modes.test.ts

@@ -0,0 +1,22 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import { PiAcpAgent } from '../../src/acp/agent.js'
+
+class FakeConn {
+  updates: any[] = []
+  async sessionUpdate(msg: any) {
+    this.updates.push(msg)
+  }
+}
+
+test('PiAcpAgent: setSessionMode maps to pi setThinkingLevel + emits current_mode_update', async () => {
+  const conn = new FakeConn()
+  const agent = new PiAcpAgent(conn as any)
+
+  // Create a fake session by calling newSession is heavyweight (spawns pi).
+  // Instead, reach into session manager via loadSession isn't possible either.
+  // So we unit-test the mapping via a minimal fake session manager would require refactor.
+  // For now we just assert the method exists and rejects unknown session IDs.
+
+  await assert.rejects(() => agent.setSessionMode({ sessionId: 'nope', modeId: 'invalid' } as any), /invalid params/i)
+})

package/port/oracle/pi-acp/test/component/session-title-long-session.test.ts

@@ -0,0 +1,56 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import { mkdtempSync, writeFileSync, mkdirSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+
+import { listPiSessions } from '../../src/acp/pi-sessions.js'
+
+// Ensures we still pick up session_info.name even if it is older than the tail window.
+
+test('listPiSessions: finds session_info.name even when it is outside the tail window', async () => {
+  const root = mkdtempSync(join(tmpdir(), 'pi-acp-test-'))
+  const sessionsDir = join(root, 'sessions', '--p--')
+  mkdirSync(sessionsDir, { recursive: true })
+
+  const sessionFile = join(sessionsDir, 's.jsonl')
+
+  const header = JSON.stringify({
+    type: 'session',
+    version: 3,
+    id: 'sess-1',
+    timestamp: '2026-01-01T00:00:00.000Z',
+    cwd: '/tmp/project'
+  })
+  const info = JSON.stringify({
+    type: 'session_info',
+    id: 'i1',
+    parentId: null,
+    timestamp: '2026-01-01T00:00:01.000Z',
+    name: 'Named Early'
+  })
+
+  // Create a large filler so the name is far outside the last 256KB tail.
+  const fillerLine = JSON.stringify({
+    type: 'message',
+    id: 'm',
+    parentId: null,
+    timestamp: '2026-01-01T00:00:02.000Z',
+    message: { role: 'user', content: 'x'.repeat(2000) }
+  })
+  const filler = Array.from({ length: 400 }, () => fillerLine).join('\n')
+
+  writeFileSync(sessionFile, [header, info, filler].join('\n') + '\n', { encoding: 'utf8' })
+
+  const oldEnv = process.env.PI_CODING_AGENT_DIR
+  process.env.PI_CODING_AGENT_DIR = root
+
+  try {
+    const s = listPiSessions().find(x => x.sessionId === 'sess-1')
+    assert.ok(s)
+    assert.equal(s?.title, 'Named Early')
+  } finally {
+    if (oldEnv === undefined) delete process.env.PI_CODING_AGENT_DIR
+    else process.env.PI_CODING_AGENT_DIR = oldEnv
+  }
+})

package/port/oracle/pi-acp/test/component/session-updatedAt-message-only.test.ts

@@ -0,0 +1,57 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import { mkdtempSync, writeFileSync, mkdirSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+
+import { listPiSessions } from '../../src/acp/pi-sessions.js'
+
+test('listPiSessions: updatedAt prefers last message timestamp over later non-message entries', async () => {
+  const root = mkdtempSync(join(tmpdir(), 'pi-acp-test-'))
+  const sessionsDir = join(root, 'sessions', '--p--')
+  mkdirSync(sessionsDir, { recursive: true })
+
+  const sessionFile = join(sessionsDir, 's.jsonl')
+
+  // Last message at 00:00:02, but a later session_info at 00:00:10.
+  // We want updatedAt == 00:00:02.
+  writeFileSync(
+    sessionFile,
+    [
+      JSON.stringify({
+        type: 'session',
+        version: 3,
+        id: 'sess-1',
+        timestamp: '2026-01-01T00:00:00.000Z',
+        cwd: '/tmp/project'
+      }),
+      JSON.stringify({
+        type: 'message',
+        id: 'a1b2c3d4',
+        parentId: null,
+        timestamp: '2026-01-01T00:00:02.000Z',
+        message: { role: 'user', content: 'hi' }
+      }),
+      JSON.stringify({
+        type: 'session_info',
+        id: 'b1b2c3d4',
+        parentId: 'a1b2c3d4',
+        timestamp: '2026-01-01T00:00:10.000Z',
+        name: 'named'
+      })
+    ].join('\n') + '\n',
+    { encoding: 'utf8' }
+  )
+
+  const oldEnv = process.env.PI_CODING_AGENT_DIR
+  process.env.PI_CODING_AGENT_DIR = root
+
+  try {
+    const sessions = listPiSessions().filter(s => s.sessionId === 'sess-1')
+    assert.equal(sessions.length, 1)
+    assert.equal(sessions[0]?.updatedAt, '2026-01-01T00:00:02.000Z')
+  } finally {
+    if (oldEnv === undefined) delete process.env.PI_CODING_AGENT_DIR
+    else process.env.PI_CODING_AGENT_DIR = oldEnv
+  }
+})

package/port/oracle/pi-acp/test/helpers/fakes.ts

@@ -0,0 +1,87 @@
+import type { AgentSideConnection } from '@agentclientprotocol/sdk'
+import type { PiRpcEvent, PiSessionStats } from '../../src/pi-rpc/process.js'
+
+type SessionUpdateMsg = Parameters<AgentSideConnection['sessionUpdate']>[0]
+
+export class FakeAgentSideConnection {
+  readonly updates: SessionUpdateMsg[] = []
+  readonly permissionRequests: unknown[] = []
+  nextPermissionResponse: { outcome: { outcome: 'selected'; optionId: string } | { outcome: 'cancelled' } } = {
+    outcome: { outcome: 'selected', optionId: 'allow' }
+  }
+
+  async sessionUpdate(msg: SessionUpdateMsg): Promise<void> {
+    this.updates.push(msg)
+  }
+
+  async requestPermission(
+    params: unknown
+  ): Promise<{ outcome: { outcome: 'selected'; optionId: string } | { outcome: 'cancelled' } }> {
+    this.permissionRequests.push(params)
+    return this.nextPermissionResponse
+  }
+}
+
+export class FakePiRpcProcess {
+  private handlers: Array<(ev: PiRpcEvent) => void> = []
+
+  // spies
+  readonly prompts: Array<{ message: string; attachments: unknown[] }> = []
+  readonly extensionUiResponses: unknown[] = []
+  abortCount = 0
+  getSessionStatsCount = 0
+
+  sessionStats: PiSessionStats = {}
+  /** When set, `getSessionStats()` rejects with this error. */
+  sessionStatsError: unknown = null
+
+  onEvent(handler: (ev: PiRpcEvent) => void): () => void {
+    this.handlers.push(handler)
+    return () => {
+      this.handlers = this.handlers.filter(h => h !== handler)
+    }
+  }
+
+  emit(ev: PiRpcEvent) {
+    for (const h of this.handlers) h(ev)
+  }
+
+  async prompt(message: string, attachments: unknown[] = []): Promise<void> {
+    this.prompts.push({ message, attachments })
+  }
+
+  async abort(): Promise<void> {
+    this.abortCount += 1
+  }
+
+  async sendExtensionUiResponse(response: unknown): Promise<void> {
+    this.extensionUiResponses.push(response)
+  }
+
+  async getState(): Promise<any> {
+    return {}
+  }
+
+  async getAvailableModels(): Promise<any> {
+    return { models: [{ provider: 'test', id: 'model', name: 'model' }] }
+  }
+
+  async getAvailableThinkingLevels(): Promise<string[]> {
+    return ['medium', 'high']
+  }
+
+  async getMessages(): Promise<any> {
+    return { messages: [] }
+  }
+
+  async getSessionStats(): Promise<PiSessionStats> {
+    this.getSessionStatsCount += 1
+    if (this.sessionStatsError) throw this.sessionStatsError
+    return this.sessionStats
+  }
+}
+
+export function asAgentConn(conn: FakeAgentSideConnection): AgentSideConnection {
+  // We only implement the method(s) used by PiAcpSession in tests.
+  return conn as unknown as AgentSideConnection
+}

package/port/oracle/pi-acp/test/unit/auth-methods-terminal-auth-meta.test.ts

@@ -0,0 +1,22 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import { getAuthMethods, PI_SETUP_METHOD_ID } from '../../src/acp/auth.js'
+
+test('getAuthMethods: includes Zed terminal-auth metadata when enabled', () => {
+  const methods = getAuthMethods({ supportsTerminalAuthMeta: true })
+  assert.equal(methods.length, 1)
+  const m: any = methods[0]
+
+  assert.equal(m.id, PI_SETUP_METHOD_ID)
+  assert.ok(m._meta)
+  assert.ok(m._meta['terminal-auth'])
+  assert.ok(typeof m._meta['terminal-auth'].command === 'string')
+  assert.deepEqual(m._meta['terminal-auth'].args, ['--terminal-login'])
+  assert.equal(m._meta['terminal-auth'].label, 'Launch pi')
+})
+
+test('getAuthMethods: omits Zed terminal-auth metadata when disabled', () => {
+  const methods = getAuthMethods({ supportsTerminalAuthMeta: false })
+  const m: any = methods[0]
+  assert.ok(!m._meta || !m._meta['terminal-auth'])
+})