fix(opencode): report OpenCode 2 status from each pane's own TUI

src/main/agent-hooks/server-opencode-binder.test.ts

@@ -29,25 +29,25 @@ class BinderTestServer extends AgentHookServer {
     this.startOpenCodeBinderLoop()
   }
 
-  public ingest(source: AgentHookSource, body: unknown): void {
-    this.normalizeLocalHookPayload(source, body)
+  public ingest(source: AgentHookSource, body: unknown): string | undefined {
+    return this.normalizeLocalHookPayload(source, body).event?.paneKey
   }
 
   public readRegistry(sessionId: string): string | undefined {
     return lookupOpenCodeSessionPane(this._getStateForTests(), sessionId)?.paneKey
   }
 }
 
-function writeDb(dbPath: string, table: 'session_v2' | 'session'): void {
+function writeDb(dbPath: string, table: 'session_v2' | 'session', id = 'ses_live'): void {
   const db = new SyncDatabase(dbPath)
   try {
     db.exec(
-      `CREATE TABLE ${table} (id TEXT PRIMARY KEY, directory TEXT NOT NULL, time_created INTEGER NOT NULL, parent_id TEXT)`
+      `CREATE TABLE IF NOT EXISTS ${table} (id TEXT PRIMARY KEY, directory TEXT NOT NULL, time_created INTEGER NOT NULL, parent_id TEXT)`
     )
     const insert = db.prepare(
       `INSERT INTO ${table} (id, directory, time_created, parent_id) VALUES (?, ?, ?, ?)`
     )
-    insert.run('ses_live', DIR, Date.now() - 60_000, null)
+    insert.run(id, DIR, Date.now() - 60_000, null)
   } finally {
     db.close()
   }
@@ -85,22 +85,21 @@ describe('opencode binder loop', () => {
     rmSync(dir, { recursive: true, force: true })
   })
 
-  it('binds a fresh session to its pane', async () => {
-    writeDb(dbPath, 'session_v2')
+  it('binds a fresh OpenCode 1 session to its pane', async () => {
+    writeDb(dbPath, 'session')
     const applied = await server.runBinderRound()
     expect(applied).toBe(1)
     expect(server.readRegistry('ses_live')).toBe(PANE_A)
   })
 
-  it('falls back to the v1 session table', async () => {
-    writeDb(dbPath, 'session')
-    const applied = await server.runBinderRound()
-    expect(applied).toBe(1)
-    expect(server.readRegistry('ses_live')).toBe(PANE_A)
+  it('never binds an OpenCode 2 session', async () => {
+    writeDb(dbPath, 'session_v2')
+    expect(await server.runBinderRound()).toBe(0)
+    expect(server.readRegistry('ses_live')).toBeUndefined()
   })
 
   it('an opencode SessionStart kicks a round that binds before the poll', async () => {
-    writeDb(dbPath, 'session_v2')
+    writeDb(dbPath, 'session')
     vi.useFakeTimers()
     try {
       // Birth arrives stamped with the wrong (server-starter) pane.
@@ -117,21 +116,40 @@ describe('opencode binder loop', () => {
     }
   })
 
+  it('an OpenCode 2 SessionStart kicks no round', async () => {
+    writeDb(dbPath, 'session')
+    const sweep = vi.fn(async () => [])
+    server.bindDeps({ sweep })
+    vi.useFakeTimers()
+    try {
+      server.ingest('opencode', {
+        paneKey: PANE_B,
+        launchToken: '',
+        opencodeMajor: 2,
+        payload: { hook_event_name: 'SessionStart', sessionID: 'ses_live' }
+      })
+      await vi.advanceTimersByTimeAsync(10_000)
+      expect(sweep).not.toHaveBeenCalled()
+    } finally {
+      vi.useRealTimers()
+    }
+  })
+
   it('pane teardown unbinds its sessions', async () => {
-    writeDb(dbPath, 'session_v2')
+    writeDb(dbPath, 'session')
     await server.runBinderRound()
     expect(server.readRegistry('ses_live')).toBe(PANE_A)
     server.clearPaneState(PANE_A)
     expect(server.readRegistry('ses_live')).toBeUndefined()
   })
 
   it('stops the loop without hanging the process', () => {
-    writeDb(dbPath, 'session_v2')
+    writeDb(dbPath, 'session')
     expect(() => server.stop()).not.toThrow()
   })
 
   it('runs a round immediately on loop start', async () => {
-    writeDb(dbPath, 'session_v2')
+    writeDb(dbPath, 'session')
     server.startBinderLoop()
     try {
       await vi.waitFor(() => expect(server.readRegistry('ses_live')).toBe(PANE_A))
@@ -141,7 +159,7 @@ describe('opencode binder loop', () => {
   })
 
   it('discards a round that was in flight across stop', async () => {
-    writeDb(dbPath, 'session_v2')
+    writeDb(dbPath, 'session')
     let releaseSweep!: () => void
     const sweepGate = new Promise<void>((resolve) => {
       releaseSweep = resolve
@@ -168,7 +186,7 @@ describe('opencode binder loop', () => {
   })
 
   it('an obsolete round does not clear the new round running flag', async () => {
-    writeDb(dbPath, 'session_v2')
+    writeDb(dbPath, 'session')
     let releaseFirst!: () => void
     let releaseLater!: () => void
     const firstGate = new Promise<void>((resolve) => {
@@ -212,6 +230,61 @@ describe('opencode binder loop', () => {
   })
 })
 
+// OpenCode 1 `serve` in pane A stamps every post with pane A; `attach` in pane B drives the session.
+describe('OpenCode 1 serve + attach', () => {
+  let dir = ''
+  let dbPath = ''
+  let server: BinderTestServer
+
+  beforeEach(() => {
+    dir = mkdtempSync(join(tmpdir(), 'binder-attach-'))
+    dbPath = join(dir, 'opencode.db')
+    writeDb(dbPath, 'session')
+    const startedAtMs = Date.now() - 120_000
+    server = new BinderTestServer()
+    server.bindDeps({
+      now: () => Date.now(),
+      dbPath: () => dbPath,
+      listPanes: () => [
+        { paneKey: PANE_A, directory: DIR, worktreeId: `repo::${DIR}`, shellPid: 111 },
+        { paneKey: PANE_B, directory: DIR, worktreeId: `repo::${DIR}`, shellPid: 211 }
+      ],
+      sweep: async () => [
+        { pid: 112, ppid: 111, startedAtMs, executable: 'opencode', argv: ['opencode', 'serve'] },
+        {
+          pid: 212,
+          ppid: 211,
+          startedAtMs,
+          executable: 'opencode',
+          argv: ['opencode', 'attach', 'http://127.0.0.1:4096']
+        }
+      ]
+    })
+  })
+
+  afterEach(() => {
+    server.stop()
+    rmSync(dir, { recursive: true, force: true })
+  })
+
+  const busy = (extra: Record<string, unknown> = {}): Record<string, unknown> => ({
+    paneKey: PANE_A,
+    launchToken: '',
+    ...extra,
+    payload: { hook_event_name: 'SessionBusy', sessionID: 'ses_live' }
+  })
+
+  it("reports the session on the attaching pane, not the server's", async () => {
+    expect(await server.runBinderRound()).toBe(1)
+    expect(server.ingest('opencode', busy())).toBe(PANE_B)
+  })
+
+  it('never moves an OpenCode 2 post with the same shape', async () => {
+    await server.runBinderRound()
+    expect(server.ingest('opencode', busy({ opencodeMajor: 2 }))).toBe(PANE_A)
+  })
+})
+
 describe('listOpenCodeDbSessions', () => {
   let dir = ''
   let dbPath = ''
@@ -225,14 +298,22 @@ describe('listOpenCodeDbSessions', () => {
     rmSync(dir, { recursive: true, force: true })
   })
 
-  it('reads session_v2 rows newer than the watermark', () => {
-    writeDb(dbPath, 'session_v2')
+  it('reads OpenCode 1 session rows newer than the watermark', () => {
+    writeDb(dbPath, 'session')
     const rows = listOpenCodeDbSessions(dbPath, { ms: 0, id: '' })
     expect(rows).toHaveLength(1)
     expect(rows[0]).toMatchObject({ id: 'ses_live', directory: DIR, parentId: null })
     expect(listOpenCodeDbSessions(dbPath, { ms: Date.now(), id: '' })).toEqual([])
   })
 
+  it('skips OpenCode 2 rows in a database both versions wrote', () => {
+    writeDb(dbPath, 'session', 'ses_v1')
+    writeDb(dbPath, 'session_v2', 'ses_v2')
+    expect(listOpenCodeDbSessions(dbPath, { ms: 0, id: '' }).map((row) => row.id)).toEqual([
+      'ses_v1'
+    ])
+  })
+
   it('returns [] for a missing database instead of throwing', () => {
     expect(listOpenCodeDbSessions(join(dir, 'absent.db'), { ms: 0, id: '' })).toEqual([])
   })

src/main/agent-hooks/server-process-lifetime-status.test.ts

@@ -0,0 +1,112 @@
+import { mkdtempSync, rmSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { afterEach, beforeEach, describe, expect, it } from 'vitest'
+import { AgentHookServer } from './server'
+import { buildBody, PANE, postHookEvent } from './server.test-fixtures'
+
+let dir: string
+let server: AgentHookServer
+
+beforeEach(async () => {
+  dir = mkdtempSync(join(tmpdir(), 'orca-process-lifetime-'))
+  server = new AgentHookServer()
+  await server.start({ env: 'production', userDataPath: dir })
+})
+
+afterEach(() => {
+  server.stop()
+  rmSync(dir, { recursive: true, force: true })
+})
+
+function processLifetime(state: 'working' | 'done', yieldsToHookSince: number): void {
+  server.ingestTerminalStatus({
+    paneKey: PANE,
+    tabId: 'tab-1',
+    worktreeId: 'wt-1',
+    connectionId: null,
+    origin: 'process',
+    yieldsToHookSince,
+    payload: { state, prompt: '', agentType: 'opencode' }
+  })
+}
+
+async function openCodeHook(hookEventName: string): Promise<void> {
+  const response = await postHookEvent(
+    server,
+    buildBody({ hook_event_name: hookEventName, sessionID: 'ses_1' }),
+    '/hook/opencode'
+  )
+  expect(response.status).toBe(204)
+}
+
+function paneState(): string {
+  return server.getStatusSnapshotForPane(PANE)[0]?.state ?? 'missing'
+}
+
+async function nextMillisecond(): Promise<void> {
+  await new Promise((resolve) => setTimeout(resolve, 5))
+}
+
+// One `opencode run` command in one pane: the host reports it from the process lifetime unless a
+// hook producer (OpenCode 1's in-process plugin) reports the same pane during that command.
+describe('process-lifetime status', () => {
+  it('reports Working, then Done, when no hook speaks for the command', () => {
+    const commandStartedAt = Date.now()
+    processLifetime('working', commandStartedAt)
+    expect(paneState()).toBe('working')
+    processLifetime('done', commandStartedAt)
+    expect(paneState()).toBe('done')
+  })
+
+  it('yields the rest of the command once a hook reports the pane', async () => {
+    const commandStartedAt = Date.now()
+    processLifetime('working', commandStartedAt)
+    await openCodeHook('SessionBusy')
+    // The hook is still Working, so the process exit must not write a second Done over it.
+    processLifetime('done', commandStartedAt)
+    expect(paneState()).toBe('working')
+    await openCodeHook('SessionIdle')
+    expect(paneState()).toBe('done')
+  })
+
+  it('writes no Working over a hook that already claimed the command', async () => {
+    const commandStartedAt = Date.now()
+    await openCodeHook('SessionIdle')
+    processLifetime('working', commandStartedAt)
+    expect(paneState()).toBe('done')
+  })
+
+  it('does not yield to a hook row from before the command started', async () => {
+    await openCodeHook('SessionIdle')
+    await nextMillisecond()
+    const commandStartedAt = Date.now()
+    processLifetime('working', commandStartedAt)
+    expect(paneState()).toBe('working')
+    processLifetime('done', commandStartedAt)
+    expect(paneState()).toBe('done')
+  })
+
+  // Why: a pane where an Orca-launched agent exited is retired; a new `opencode run` there is a new run.
+  it('revives a retired pane on its Working, as a hook new-turn event does', () => {
+    server.retirePaneAuthority(PANE)
+    const commandStartedAt = Date.now()
+    processLifetime('working', commandStartedAt)
+    expect(paneState()).toBe('working')
+    processLifetime('done', commandStartedAt)
+    expect(paneState()).toBe('done')
+  })
+
+  it('keeps OSC status and a lone process Done out of a retired pane', () => {
+    server.retirePaneAuthority(PANE)
+    server.ingestTerminalStatus({
+      paneKey: PANE,
+      tabId: 'tab-1',
+      worktreeId: 'wt-1',
+      connectionId: null,
+      payload: { state: 'working', prompt: '', agentType: 'opencode' }
+    })
+    processLifetime('done', Date.now())
+    expect(paneState()).toBe('missing')
+  })
+})

src/main/agent-hooks/server/server-ingest-normalization.ts

@@ -1,6 +1,7 @@
 import { buildSpoolHookBody, type SpoolRecord } from '../../../shared/agent-hook-spool'
 import { normalizeHookPayload } from '../../../shared/agent-hook-listener'
 import { isAgentHookSource, type AgentHookSource } from '../../../shared/agent-hook-relay'
+import { isOpenCodeSharedServerPost } from '../../../shared/agent-hook-listener/opencode-session-registry'
 import type { NormalizedLocalHook } from './server-types'
 import { AgentHookServerOpenCodeBinder } from './server-opencode-binder'
 
@@ -27,8 +28,8 @@ export abstract class AgentHookServerIngestNormalization extends AgentHookServer
       const event = normalizeHookPayload(this.state, source, body, this.env)
       if (
         event &&
-        (source === 'opencode' || source === 'mimo-code') &&
-        event.hookEventName === 'SessionStart'
+        event.hookEventName === 'SessionStart' &&
+        isOpenCodeSharedServerPost(source, body)
       ) {
         // Why: a birth just arrived; bind it now instead of waiting out the poll interval.
         this.kickOpenCodeBinder()