Hide the context panel for agents that aren't Claude-backed

Context occupancy is read out of Claude's session jsonl, so a Codex or
Cursor tab could never produce a snapshot. The panel still rendered
"No context data yet. Updates after each turn." for them, promising
something that was never coming. It now hides entirely for those tabs,
and for shell / diff / browser tabs, the way JsonClaudeTodosPanel does.
A Claude tab with no turns yet still gets the message, because there it
is true.

The same assumption was a live bug on the main side. Every agent tab
was eligible for the latestSessionId fallback, which looks in
~/.claude/projects — so a Codex tab in a worktree that had also been
used with Claude would adopt Claude's transcript and report another
agent's numbers as its own. Codex and Cursor also fire Stop hooks, and
their transcript_path points at their own format, which analyzeContext
would have read as Claude jsonl and turned into confident nonsense.
Both paths are now gated.

The predicate lives in shared/state/terminals.ts rather than being
written twice, since main and renderer both need it. A missing
agentKind counts as Claude — that's the PanesFSM default and what tabs
created before the field have.

Author: frenchie4111

src/main/context-tracker.ts

@@ -26,7 +26,12 @@ import { join } from 'path'
 import type { Store } from './store'
 import type { StateEvent } from '../shared/state'
 import { onStopEvent, type StopEvent } from './hooks'
-import { findLeafByTabId, getLeaves } from '../shared/state/terminals'
+import {
+  findLeafByTabId,
+  findTabById,
+  getLeaves,
+  isClaudeBackedTab
+} from '../shared/state/terminals'
 import type { ContextSnapshot } from '../shared/state/context-window'
 import { analyzeContext } from './context-window'
 import { latestSessionId } from './agents/claude'
@@ -95,9 +100,25 @@ export class ContextTracker {
   }
 
   private handleStop(ev: StopEvent): void {
+    // Codex and Cursor fire Stop hooks too, but `transcript_path` then
+    // points at their own format — analyzeContext would read it as Claude
+    // jsonl and produce confident nonsense. Drop it before it's recorded,
+    // so backfillAll can't resurrect it later either.
+    if (!this.isClaudeBacked(ev.terminalId)) return
     this.lastStops.set(ev.terminalId, ev)
     if (this.interestedClients.size === 0) return
-    this.analyzeAndDispatch(ev.terminalId, ev.sessionId, ev.transcriptPath, this.worktreeForTerminal(ev.terminalId))
+    this.analyzeAndDispatch(
+      ev.terminalId,
+      ev.sessionId,
+      ev.transcriptPath,
+      this.worktreeForTerminal(ev.terminalId)
+    )
+  }
+
+  private isClaudeBacked(terminalId: string): boolean {
+    return isClaudeBackedTab(
+      findTabById(this.store.getSnapshot().state.terminals.panes, terminalId)
+    )
   }
 
   private handleStoreEvent(event: StateEvent): void {
@@ -213,6 +234,11 @@ export class ContextTracker {
       for (const leaf of getLeaves(tree)) {
         for (const tab of leaf.tabs) {
           if (tab.type !== 'agent') continue
+          // Without this, a Codex or Cursor tab in a worktree that also
+          // has Claude history would adopt Claude's transcript via the
+          // latestSessionId fallback below and show another agent's
+          // numbers as its own.
+          if (!isClaudeBackedTab(tab)) continue
           if (this.lastStops.has(tab.id)) continue
           const cwd = tab.cwd || worktreePath
           // Prefer the tab's own session id, but fall back to the most

src/renderer/components/ContextPanel.tsx

@@ -1,7 +1,8 @@
 import { useMemo, useState } from 'react'
 import { RightPanel } from './RightPanel'
-import { useContextWindow } from '../store'
+import { useContextWindow, usePanes } from '../store'
 import { useBackend } from '../backend'
+import { findTabById, isClaudeBackedTab } from '../../shared/state/terminals'
 import type { ContextSnapshot } from '../../shared/state/context-window'
 
 interface ContextPanelProps {
@@ -117,11 +118,24 @@ function buildRows(snapshot: ContextSnapshot): Row[] {
 
 export function ContextPanel({ focusedTabId }: ContextPanelProps): JSX.Element | null {
   const backend = useBackend()
+  const panes = usePanes()
   const snapshot = useContextWindow(focusedTabId)
   const [showDiscoverable, setShowDiscoverable] = useState(false)
 
+  // Codex and Cursor never produce a snapshot, so a "no data yet"
+  // message would promise something that is never coming.
+  const supported = useMemo(
+    () => isClaudeBackedTab(focusedTabId ? findTabById(panes, focusedTabId) : null),
+    [panes, focusedTabId]
+  )
+
   const rows = useMemo(() => (snapshot ? buildRows(snapshot) : []), [snapshot])
 
+  // Hide the panel outright rather than render an empty shell — same
+  // pattern as JsonClaudeTodosPanel. Shell / diff / browser tabs take
+  // this path too.
+  if (!supported) return null
+
   const body = (): JSX.Element => {
     if (!snapshot) {
       return (

src/shared/state/terminals.test.ts

@@ -11,9 +11,11 @@ import {
   findLeafByTabId,
   findTabById,
   hasAnyTabs,
+  isClaudeBackedTab,
   mapLeaves,
   replaceNode,
-  removeLeaf
+  removeLeaf,
+  type TerminalTab
 } from './terminals'
 
 function apply(state: TerminalsState, event: TerminalsEvent): TerminalsState {
@@ -1070,3 +1072,39 @@ describe('terminalsReducer', () => {
     ).toBe(start)
   })
 })
+
+describe('isClaudeBackedTab', () => {
+  const tab = (over: Partial<TerminalTab>): TerminalTab =>
+    ({ id: 't', type: 'agent', label: 'Agent', ...over }) as TerminalTab
+
+  it('accepts a json-claude chat tab', () => {
+    expect(isClaudeBackedTab(tab({ type: 'json-claude' }))).toBe(true)
+  })
+
+  it('accepts a claude agent tab', () => {
+    expect(isClaudeBackedTab(tab({ type: 'agent', agentKind: 'claude' }))).toBe(true)
+  })
+
+  it('treats a missing agentKind as claude', () => {
+    // Tabs created before agentKind existed, plus PanesFSM's default.
+    expect(isClaudeBackedTab(tab({ type: 'agent', agentKind: undefined }))).toBe(true)
+  })
+
+  it('rejects codex and cursor agent tabs', () => {
+    // They write their own transcript formats; reading those as Claude
+    // jsonl would produce confident nonsense.
+    expect(isClaudeBackedTab(tab({ type: 'agent', agentKind: 'codex' }))).toBe(false)
+    expect(isClaudeBackedTab(tab({ type: 'agent', agentKind: 'cursor' }))).toBe(false)
+  })
+
+  it('rejects non-agent tab types', () => {
+    for (const type of ['shell', 'diff', 'file', 'browser', 'review'] as const) {
+      expect(isClaudeBackedTab(tab({ type }))).toBe(false)
+    }
+  })
+
+  it('rejects null and undefined', () => {
+    expect(isClaudeBackedTab(null)).toBe(false)
+    expect(isClaudeBackedTab(undefined)).toBe(false)
+  })
+})

src/shared/state/terminals.ts

@@ -131,6 +131,19 @@ export function findTabById(
   return null
 }
 
+/** Whether a tab talks to Claude, and so writes a session jsonl under
+ *  ~/.claude/projects. Codex and Cursor agent tabs write their own
+ *  formats, so anything reading Claude transcripts must exclude them
+ *  rather than assume every agent tab is Claude.
+ *
+ *  A missing `agentKind` means Claude — tabs created before the field
+ *  existed, and the default in PanesFSM.addTab. */
+export function isClaudeBackedTab(tab: TerminalTab | null | undefined): boolean {
+  if (!tab) return false
+  if (tab.type === 'json-claude') return true
+  return tab.type === 'agent' && (tab.agentKind ?? 'claude') === 'claude'
+}
+
 export function hasAnyTabs(node: PaneNode): boolean {
   if (node.type === 'leaf') return node.tabs.length > 0
   return hasAnyTabs(node.children[0]) || hasAnyTabs(node.children[1])