perf: v0.2.38 — skip window matching for claimed windows (#122)

## Summary

- Filter `matchWindowsToLogsByExactRg` to only unclaimed windows in the
match worker
- When all windows are already associated with sessions, matching is
skipped entirely
- Eliminates ~90 `rg` subprocess spawns and 12 `tmux capture-pane` calls
per poll cycle

## Measured impact

| Scenario | Before | After |
|---|---|---|
| Steady-state (all windows claimed, warm) | ~2,049ms | ~150ms |
| Under load (load avg 28+) | ~2,200ms avg, 5s spikes | ~300ms est |

## Why this is safe

- The main thread already refuses to steal claimed windows
(`logPoller.ts:769-780`)
- Slug-based supersede handles legitimate window handoffs independently
of rg matching
- `noMessageWindows` deferral already filters claimed windows on the
main thread

## Test plan

- [x] 761 tests passing (2 new tests added)
- [x] New test: window recovered after orphan cleanup
- [x] New test: slug supersede works without rg matching
- [x] Lint and typecheck passing

Author: gbasin

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gbasin/agentboard",
-  "version": "0.2.37",
+  "version": "0.2.38",
   "type": "module",
   "description": "Web GUI for tmux optimized for AI agent TUIs",
   "author": "gbasin",

src/server/__tests__/logPoller.test.ts

@@ -985,6 +985,144 @@ describe('LogPoller', () => {
     db.close()
   })
 
+  test('matches new session to window when existing session is orphaned between polls', async () => {
+    const db = initDatabase({ path: ':memory:' })
+    const registry = new SessionRegistry()
+    registry.replaceSessions([baseSession])
+
+    const tokensA = Array.from({ length: 60 }, (_, i) => `token${i}`).join(' ')
+    setTmuxOutput(baseSession.tmuxWindow, buildLastExchangeOutput(tokensA))
+
+    const projectPath = baseSession.projectPath
+    const encoded = encodeProjectPath(projectPath)
+    const logDir = path.join(
+      process.env.CLAUDE_CONFIG_DIR ?? '',
+      'projects',
+      encoded
+    )
+    await fs.mkdir(logDir, { recursive: true })
+
+    // Poll 1: Session A is discovered and matched to the window
+    const logPathA = path.join(logDir, 'session-a.jsonl')
+    const lineA = buildUserLogEntry(tokensA, {
+      sessionId: 'claude-session-a',
+      cwd: projectPath,
+    })
+    const assistantLineA = JSON.stringify({
+      type: 'assistant',
+      message: { content: [{ type: 'text', text: tokensA }] },
+    })
+    await fs.writeFile(logPathA, `${lineA}\n${assistantLineA}\n`)
+
+    const poller = new LogPoller(db, registry, {
+      matchWorkerClient: new InlineMatchWorkerClient(),
+    })
+    await poller.pollOnce()
+
+    const recordA = db.getSessionById('claude-session-a')
+    expect(recordA?.currentWindow).toBe(baseSession.tmuxWindow)
+
+    // Between polls: Session A's window claim is removed (simulating orphan cleanup)
+    db.updateSession('claude-session-a', { currentWindow: null })
+    const orphanedA = db.getSessionById('claude-session-a')
+    expect(orphanedA?.currentWindow).toBeNull()
+
+    // Poll 2: Session B appears with different content.
+    // The window is now unclaimed, so the optimization should allow matching.
+    const tokensB = Array.from({ length: 60 }, (_, i) => `next${i}`).join(' ')
+    setTmuxOutput(baseSession.tmuxWindow, buildLastExchangeOutput(tokensB))
+
+    const logPathB = path.join(logDir, 'session-b.jsonl')
+    const lineB = buildUserLogEntry(tokensB, {
+      sessionId: 'claude-session-b',
+      cwd: projectPath,
+    })
+    const assistantLineB = JSON.stringify({
+      type: 'assistant',
+      message: { content: [{ type: 'text', text: tokensB }] },
+    })
+    await fs.writeFile(logPathB, `${lineB}\n${assistantLineB}\n`)
+
+    await poller.pollOnce()
+
+    // Session B should get matched to the now-unclaimed window
+    const newRecord = db.getSessionById('claude-session-b')
+    expect(newRecord?.currentWindow).toBe(baseSession.tmuxWindow)
+
+    db.close()
+  })
+
+  test('new session with slug supersedes claimed window without needing match', async () => {
+    const db = initDatabase({ path: ':memory:' })
+    const registry = new SessionRegistry()
+    registry.replaceSessions([baseSession])
+
+    const tokensA = Array.from({ length: 60 }, (_, i) => `token${i}`).join(' ')
+    setTmuxOutput(baseSession.tmuxWindow, buildLastExchangeOutput(tokensA))
+
+    const projectPath = baseSession.projectPath
+    const encoded = encodeProjectPath(projectPath)
+    const logDir = path.join(
+      process.env.CLAUDE_CONFIG_DIR ?? '',
+      'projects',
+      encoded
+    )
+    await fs.mkdir(logDir, { recursive: true })
+
+    // Poll 1: Session A gets matched to the window (with slug)
+    const logPathA = path.join(logDir, 'session-a.jsonl')
+    const lineA = buildUserLogEntry(tokensA, {
+      sessionId: 'claude-session-a',
+      cwd: projectPath,
+      slug: 'supersede-slug',
+    })
+    const assistantLineA = JSON.stringify({
+      type: 'assistant',
+      message: { content: [{ type: 'text', text: tokensA }] },
+    })
+    await fs.writeFile(logPathA, `${lineA}\n${assistantLineA}\n`)
+
+    const poller = new LogPoller(db, registry, {
+      matchWorkerClient: new InlineMatchWorkerClient(),
+    })
+    await poller.pollOnce()
+
+    const recordA = db.getSessionById('claude-session-a')
+    expect(recordA?.currentWindow).toBe(baseSession.tmuxWindow)
+
+    // Poll 2: Session B appears with the same slug + project.
+    // The window is still claimed by A, so match-based matching is skipped
+    // for this window. However, slug supersede should detach A and give
+    // the window to B without needing rg matching.
+    const tokensB = Array.from({ length: 60 }, (_, i) => `next${i}`).join(' ')
+    setTmuxOutput(baseSession.tmuxWindow, buildLastExchangeOutput(tokensB))
+
+    const logPathB = path.join(logDir, 'session-b.jsonl')
+    const lineB = buildUserLogEntry(tokensB, {
+      sessionId: 'claude-session-b',
+      cwd: projectPath,
+      slug: 'supersede-slug',
+    })
+    const assistantLineB = JSON.stringify({
+      type: 'assistant',
+      message: { content: [{ type: 'text', text: tokensB }] },
+    })
+    await fs.writeFile(logPathB, `${lineB}\n${assistantLineB}\n`)
+
+    await poller.pollOnce()
+
+    // Session A should be detached (superseded by slug)
+    const oldRecord = db.getSessionById('claude-session-a')
+    expect(oldRecord?.currentWindow).toBeNull()
+
+    // Session B should claim the window via slug supersede,
+    // even though the optimization skipped rg matching for claimed windows
+    const newRecord = db.getSessionById('claude-session-b')
+    expect(newRecord?.currentWindow).toBe(baseSession.tmuxWindow)
+
+    db.close()
+  })
+
   test('ignores external windows in name-based orphan fallback', async () => {
     const db = initDatabase({ path: ':memory:' })
     const registry = new SessionRegistry()

src/server/logMatchWorker.ts

@@ -93,17 +93,29 @@ export function handleMatchWorkerRequest(
       payload.windows.map((w) => [w.tmuxWindow, w] as const)
     )
 
+    // Only match against unclaimed windows — claimed windows would be
+    // rejected by the main thread anyway (logPoller refuses to steal),
+    // so capturing their scrollback and running rg is wasted work.
+    const claimedWindows = new Set(
+      payload.sessions
+        .map((s) => s.currentWindow)
+        .filter(Boolean) as string[]
+    )
+    const unclaimedWindows = payload.windows.filter(
+      (w) => !claimedWindows.has(w.tmuxWindow)
+    )
+
     const entriesToMatch = getEntriesNeedingMatch(entries, payload.sessions, {
       minTokens: payload.minTokensForMatch ?? 0,
       skipMatchingPatterns: payload.skipMatchingPatterns ?? [],
     })
-    if (entriesToMatch.length === 0) {
+    if (entriesToMatch.length === 0 || unclaimedWindows.length === 0) {
       matchSkipped = true
     } else {
       const matchStart = performance.now()
       const matchLogPaths = entriesToMatch.map((entry) => entry.logPath)
       const matchResult = matchWindowsToLogsByExactRg(
-        payload.windows,
+        unclaimedWindows,
         logDirs,
         payload.scrollbackLines ?? DEFAULT_SCROLLBACK_LINES,
         {
@@ -114,7 +126,7 @@ export function handleMatchWorkerRequest(
         }
       )
       matchMs = performance.now() - matchStart
-      matchWindowCount = payload.windows.length
+      matchWindowCount = unclaimedWindows.length
       matchLogCount = matchLogPaths.length
       resolved = Array.from(matchResult.matches.entries()).map(([logPath, window]) => ({
         logPath,
@@ -139,7 +151,7 @@ export function handleMatchWorkerRequest(
           Math.min(os.cpus().length, 4)
         )
         const orphanMatchResult = matchWindowsToLogsByExactRg(
-          payload.windows,
+          unclaimedWindows,
           logDirs,
           payload.scrollbackLines ?? DEFAULT_SCROLLBACK_LINES,
           {