Skip to content

Node-based terminal manager for AI coding agents — tmux-backed terminals and parallel agent sessions as draggable nodes on an infinite pan/zoom canvas. macOS, Linux, and a browser Server Edition.

Merge origin/feat/chat-view-codex into feat/chat-view-agents

review3a39bbf50827
diff --cc CLAUDE.md
index 46852a41e,fccc5ad61..121d79b35
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@@ -1738,7 -1738,7 +1738,7 @@@ else, and its context links must keep c
`PERMISSION_MODE_CAPABLE`, `MODEL_SWITCH_CAPABLE`, with helpers (`hasHooks`,
`canBranch`, `canContextLink`, `canChat`, `canRename`, `canReadTitle`, `hasPermissionMode`, …).
Branch stays **Claude-only** purely by being in only `BRANCH_CAPABLE`. The ⌘M **ChatPanel**
- transcript view (`CHAT_CAPABLE` / `canChat`) is **claude + grok** since 2026-09: grok's
- transcript view (`CHAT_CAPABLE` / `canChat`) is **claude + grok + codex** since 2026-09: grok's
++ transcript view (`CHAT_CAPABLE` / `canChat`) is **claude + grok + gemini + codex** since 2026-09 (each with its own reader): grok's
`chat_history.jsonl` gets its own reader, and `chat:read-transcript` routes by agent. That list had
to be SPLIT to do it — `CHAT_CAPABLE` carried two facts that coincided while claude was its only
member ("we can render this" and "claude's resolver can locate and parse this file"), and the
@@@ -1891,19 -1873,25 +1891,38 @@@
cost before the backgrounding. Full picture,
limits (permission prompt and ESC fire no hook) and the device checklist:
**`docs/antigravity-agent.md`**.
+ **No conversation view, and that is deliberate** (not in `CHAT_CAPABLE`): ⌘M shows the rendered
+ terminal output, and the phone's Chat screen answers `unsupported`. The
+ LOCATION is measured: every hook payload names `transcriptPath`, which is
+ `~/.gemini/antigravity-cli/brain/<conversationId>/.system_generated/logs/transcript_full.jsonl`,
+ keyed by the id `normalizeAntigravity` already records as `sessionId`. The RECORD SHAPES were never
+ captured; the 1.2.12 binary only describes them in prose. Four facts a parser needs are unknown:
+ the `tool_calls` element keys, how a tool result links back to its call, the serialized enum
+ spelling, and whether a line is rewritten when its step's status changes, which decides between
+ claude's paged read and grok's single capped read. A parser built from that prose would be a rule-14
+ wrong guess, so none ships, not even unwired. The capture recipe is §7.1 and §8.1 of the doc, using
+ `scripts/agy-transcript-shape.mjs`, which dumps shapes and never text. When it lands: locate
+ strictly by id (`brain/` holds every conversation on the machine), and have a remote node answer
- `remoteOnly` → unreadable like grok.
++ `remoteOnly` → unreadable like gemini.
+ - **Codex in the ⌘M chat view** (2026-09-28; the desktop panel, the kanban card modal, the phone's
+ `chat.page`). `core/codex-chat.ts` reads the rollout with codex's own rules, never claude's
+ resolver. It takes USER text from the UI stream only: `event_msg/user_message` (legacy, ≤ 0.146) or
+ an `item_completed` `UserMessage` (paginated, ≥ 0.151). Model-side `role:user` messages also carry
+ injected context (AGENTS.md, `<environment_context>`, image wrappers), so they are never read.
+ Assistant text and tools come from `response_item`, correlated by `call_id`. The UI copies
+ (`agent_message`, `AgentMessage`) and reasoning are skipped. Failed and interrupted turns become
+ `[error] …` / `[turn aborted…]` notes. A tool result drops codex's `… Output:` preamble. The rollout
+ is append-only, so it pages by byte offset like claude. The locator matches a WHOLE-uuid thread id
+ (`CODEX_THREAD_ID_RE`), because a uuid's last group passes `SESSION_ID_RE` and suffix-matches
+ another thread's file. It searches only the node's own account home, and uses the codex tail's hook
+ path only as a checked hint. An SSH node is read on its host (`main/remote-codex-chat-page.ts`,
+ through the same resolvers as its remote meter) or not at all. Because codex announces no session
+ end, a chat send first asks the kernel (`renderer/lib/chatPaneGate.ts`, `isAgentPane`). After a
+ `/quit` the store still reads `done`, and the message would otherwise run in the shell. **Not
+ supported:** images in prompts, reasoning summaries, the composer's model/effort labels (the
+ `/model` picker is measured for claude only), plan/question answer cards (codex never sets
+ `held`), and a closed REMOTE session's transcript. Record rules and fixtures:
+ `src/shared/chat-fixtures/codex/`.
- **Gemini + codex parity** (2026-08-09) — brought both up to grok's level in the lists above. Unlike
grok, **both CLIs are installed** and gemini **ships its own hook reference**
(`/usr/lib/node_modules/@google/gemini-cli/bundle/docs/hooks/reference.md`), so almost every fact is
diff --cc docs/mobile-chat-view.md
index b14522c78,62e45ee83..e4f0fd2e2
--- a/docs/mobile-chat-view.md
+++ b/docs/mobile-chat-view.md
@@@ -103,7 -103,7 +103,7 @@@ as `hostBridge.chat` in `main/index.ts`
| verb | params | reply | does |
|---|---|---|---|
- | `chat.page` | `{nodeId, before?, maxBytes?}` | `{page: ChatPage}` | Only for agents with a chat view — `canChat(capabilityAgentId(agent))` (claude, grok, and custom agents whose base harness is one of them); anything else is refused before any read. `readChatTranscript` with the ⌘M panel's own deps (paged ALWAYS — an absent page is the default 256 KB tail; grok unpaged) + `model`/`effort`, `version: 1`. Session id: the RENDERER's agent-status id first (what ⌘M reads — after a desktop restart a hook-fed id lives only there), then the mirror's, then the node's minted id; the fallbacks apply only when the renderer does not answer within 3 s or knows none. **Remote (SSH-project) nodes are read REMOTE-ONLY** (`remoteOnly`): over the live pty's ControlMaster, else the node's PROJECT's master (an idle tab / any node after a restart has no pty), and never from this machine's disk — a remote node with no reachable master, or a host that did not answer, is `Could not read the transcript.`, not an empty page. The host-side locate is TRI-STATE (`locateRemoteTranscriptRef`, `src/main/remote-transcript-page.ts`): a CLEAN MISS (the host looked and has no such file, or there is no session id to look for) is `found:false`, and only a failure to ask (no master, no resolved home, a failed ssh, a path outside the jail, a failed ranged read) is the error. For REMOTE nodes the desktop ⌘M panel follows the same remote-only rule and the same absent-vs-unreadable split (same deps): its IPC handler decides remoteness from the shell's own records (`isRemoteNode` — live remote pty or `workspaceStore.sshProjectIdForNode`, never a renderer flag) and applies `remoteOnly` to the paged read, the legacy unpaged read, the find-bar index and the presence probe (`unknown`); it shows `unreadable` as "Couldn't read the transcript." (a remote grok node is read on its host too — `core/remote-grok-chat.ts`, whole-file and unpaged, with the same absent-vs-unreadable split). LOCAL nodes on ⌘M are unchanged — the renderer still sends the cwd, so claude's cwd fallback still applies there; the cwd-only-when-remote rule below is the phone path's. The cwd rides ONLY for a remote node with a known id (the host-side locate needs it); locally a known-but-dead id must not fall back to the cwd's newest transcript (another node's), and with no id at all ⇒ `found:false`. `found:false` therefore always means "looked, and there is no transcript". The reply's `page.sessionId` is exactly the id that read used (absent when none was resolved); the phone should PREFER it over the mirror's `sessionId` as the page's thread identity — the mirror lags — every 4 s on SSH, up to ~30 s on relay (`projects.list` off-LAN) — so right after `/clear` or a resume it still names the old session while the page already comes from the new transcript, and merging by byte `key` across the two would splice threads. `sessionId` is present on a `found:false` page too (an id was resolved, its transcript is missing — e.g. a fresh session that has not written yet): a new id on such a page alone is NOT a confirmed thread switch, so the phone must not clear the thread on it. Additive field: `version` stays 1, and an older desktop simply omits it (fall back to the mirror). |
-| `chat.page` | `{nodeId, before?, maxBytes?}` | `{page: ChatPage}` | Only for agents with a chat view — `canChat(capabilityAgentId(agent))` (claude, grok, codex, and custom agents whose base harness is one of them; codex is read by its own reader, `src/core/codex-chat.ts`, locally and on an SSH host — fixtures and the record rules in `src/shared/chat-fixtures/codex/`); anything else is refused before any read. `readChatTranscript` with the ⌘M panel's own deps (paged ALWAYS — an absent page is the default 256 KB tail; grok unpaged) + `model`/`effort`, `version: 1`. Session id: the RENDERER's agent-status id first (what ⌘M reads — after a desktop restart a hook-fed id lives only there), then the mirror's, then the node's minted id; the fallbacks apply only when the renderer does not answer within 3 s or knows none. **Remote (SSH-project) nodes are read REMOTE-ONLY** (`remoteOnly`): over the live pty's ControlMaster, else the node's PROJECT's master (an idle tab / any node after a restart has no pty), and never from this machine's disk — a remote node with no reachable master, or a host that did not answer, is `Could not read the transcript.`, not an empty page. The host-side locate is TRI-STATE (`locateRemoteTranscriptRef`, `src/main/remote-transcript-page.ts`): a CLEAN MISS (the host looked and has no such file, or there is no session id to look for) is `found:false`, and only a failure to ask (no master, no resolved home, a failed ssh, a path outside the jail, a failed ranged read) is the error. For REMOTE nodes the desktop ⌘M panel follows the same remote-only rule and the same absent-vs-unreadable split (same deps): its IPC handler decides remoteness from the shell's own records (`isRemoteNode` — live remote pty or `workspaceStore.sshProjectIdForNode`, never a renderer flag) and applies `remoteOnly` to the paged read, the legacy unpaged read, the find-bar index and the presence probe (`unknown`); it shows `unreadable` as "Couldn't read the transcript." (a remote grok node, which has no remote reader, as "not supported yet"). LOCAL nodes on ⌘M are unchanged — the renderer still sends the cwd, so claude's cwd fallback still applies there; the cwd-only-when-remote rule below is the phone path's. The cwd rides ONLY for a remote node with a known id (the host-side locate needs it); locally a known-but-dead id must not fall back to the cwd's newest transcript (another node's), and with no id at all ⇒ `found:false`. `found:false` therefore always means "looked, and there is no transcript". The reply's `page.sessionId` is exactly the id that read used (absent when none was resolved); the phone should PREFER it over the mirror's `sessionId` as the page's thread identity — the mirror lags — every 4 s on SSH, up to ~30 s on relay (`projects.list` off-LAN) — so right after `/clear` or a resume it still names the old session while the page already comes from the new transcript, and merging by byte `key` across the two would splice threads. `sessionId` is present on a `found:false` page too (an id was resolved, its transcript is missing — e.g. a fresh session that has not written yet): a new id on such a page alone is NOT a confirmed thread switch, so the phone must not clear the thread on it. Additive field: `version` stays 1, and an older desktop simply omits it (fall back to the mirror). |
++| `chat.page` | `{nodeId, before?, maxBytes?}` | `{page: ChatPage}` | Only for agents with a chat view — `canChat(capabilityAgentId(agent))` (claude, grok, gemini, codex, and custom agents whose base harness is one of them; codex is read by its own reader, `src/core/codex-chat.ts`, locally and on an SSH host — fixtures and the record rules in `src/shared/chat-fixtures/codex/`); anything else is refused before any read. `readChatTranscript` with the ⌘M panel's own deps (paged ALWAYS — an absent page is the default 256 KB tail; grok unpaged) + `model`/`effort`, `version: 1`. Session id: the RENDERER's agent-status id first (what ⌘M reads — after a desktop restart a hook-fed id lives only there), then the mirror's, then the node's minted id; the fallbacks apply only when the renderer does not answer within 3 s or knows none. **Remote (SSH-project) nodes are read REMOTE-ONLY** (`remoteOnly`): over the live pty's ControlMaster, else the node's PROJECT's master (an idle tab / any node after a restart has no pty), and never from this machine's disk — a remote node with no reachable master, or a host that did not answer, is `Could not read the transcript.`, not an empty page. The host-side locate is TRI-STATE (`locateRemoteTranscriptRef`, `src/main/remote-transcript-page.ts`): a CLEAN MISS (the host looked and has no such file, or there is no session id to look for) is `found:false`, and only a failure to ask (no master, no resolved home, a failed ssh, a path outside the jail, a failed ranged read) is the error. For REMOTE nodes the desktop ⌘M panel follows the same remote-only rule and the same absent-vs-unreadable split (same deps): its IPC handler decides remoteness from the shell's own records (`isRemoteNode` — live remote pty or `workspaceStore.sshProjectIdForNode`, never a renderer flag) and applies `remoteOnly` to the paged read, the legacy unpaged read, the find-bar index and the presence probe (`unknown`); it shows `unreadable` as "Couldn't read the transcript." (a remote grok node is read on its host too — `core/remote-grok-chat.ts`, whole-file and unpaged, with the same absent-vs-unreadable split; a remote node of an agent with no remote reader — `CHAT_LOCAL_ONLY` — as "not supported yet"). LOCAL nodes on ⌘M are unchanged — the renderer still sends the cwd, so claude's cwd fallback still applies there; the cwd-only-when-remote rule below is the phone path's. The cwd rides ONLY for a remote node with a known id (the host-side locate needs it); locally a known-but-dead id must not fall back to the cwd's newest transcript (another node's), and with no id at all ⇒ `found:false`. `found:false` therefore always means "looked, and there is no transcript". The reply's `page.sessionId` is exactly the id that read used (absent when none was resolved); the phone should PREFER it over the mirror's `sessionId` as the page's thread identity — the mirror lags — every 4 s on SSH, up to ~30 s on relay (`projects.list` off-LAN) — so right after `/clear` or a resume it still names the old session while the page already comes from the new transcript, and merging by byte `key` across the two would splice threads. `sessionId` is present on a `found:false` page too (an id was resolved, its transcript is missing — e.g. a fresh session that has not written yet): a new id on such a page alone is NOT a confirmed thread switch, so the phone must not clear the thread on it. Additive field: `version` stays 1, and an older desktop simply omits it (fall back to the mirror). |
| `chat.status` | `{nodeId}` | `{status: ChatStatus}` | the renderer's agent-status entry (`state` null = unknown, `held`, hibernated/paused/dropped/sessionEnded) + `structuredAnswers` = the held ticket is in main's structured-ticket ledger (script revision ≥ 5) + the host mirror's `hostRefuses`/`refusal` + `version: 1`. |
| `chat.send` | `{nodeId, text}` | `ChatSendOutcome` = `{result, reason?}` | text capped at 64000 UTF-16 units RAW, then ESC + C0/C1 stripped (`\n`, `\t` kept; `sanitizeChatText`); refused FIRST (`reason` `working`/`dialog`) when the host's mirror says the agent is working / waiting / blocked or holds a question or approval ticket (renderer state is transient after a reload); refused `busy` while another send to the same node is still in flight (held until that send SETTLES, capped at 30 s); then the renderer runs the ⌘M composer's gate at send time (`chatSendRefusal` = `agentProcessInPane` + state ∈ {done, unknown} → its own kind as `reason`) plus "no held request" (`dialog`), then `pty.sendText`. `'sent'` only for `sendText === true`; a paste the pane refused is `refused`/`failed`. |
| `agent.answer` | `{nodeId, pendingId, answer}` | `{ok: boolean}` | `answerHeldPermission` with the node's own I/O (local fs, or the SSH project's ControlMaster — the same `heldPermissionIoFor` the desktop answer path uses): validated against the pending request file, structured-ticket gated, no `setMode auto`. The `pendingId` must belong to THIS node — one of the mirror's approval tickets for it, or the renderer's `held.pendingId` (plans / questions) — else `{ok:false}` with no I/O and no answered event. Success emits the same optimistic "answered" event. |
diff --cc src/core/transcript-ipc.ts
index cfac4b726,fda0f09e9..231bdef2d
--- a/src/core/transcript-ipc.ts
+++ b/src/core/transcript-ipc.ts
@@@ -12,16 -12,10 +12,17 @@@
import fsp from 'node:fs/promises'
import { IPC } from '../shared/ipc'
import type { ChatTranscriptResult, TranscriptLine, TranscriptPresence } from '../shared/types'
-import { CHAT_PAGE_MAX_BYTES, normalizeChatPage, type ChatTranscriptPage } from '../shared/chat-page'
+import {
+ CHAT_PAGE_MAX_BYTES,
+ GROK_AMBIGUOUS_SESSION_MESSAGE,
+ normalizeChatPage,
+ type ChatTranscriptPage
+} from '../shared/chat-page'
import { platform } from './platform'
-import { chatMessagesFromGrok } from './grok-chat'
+import { parseGrokChat } from './grok-chat'
+import type { RemoteGrokChat } from './remote-grok-chat'
+import { readGeminiChatTranscript } from './gemini-chat'
+ import { chatMessagesFromCodex, locateCodexRollout, parseCodexChatWindow } from './codex-chat'
import { locateGrok } from './handoff/locate'
import { capabilityAgentId } from '../shared/agents/config'
import {
@@@ -86,14 -81,20 +88,28 @@@ export interface TranscriptIpcDeps
* (the Server Edition — it runs ON the host) = no node is remote, which is correct there.
*/
isRemoteNode?(nodeId: string): boolean
+ /**
+ * A REMOTE grok node's conversation, read ON the host (`createReadRemoteGrokChat`). `null` = not
+ * a remote session (take the local path); `{ok:false}` = it IS remote and the host could not be
+ * read; `{ok:false, absent:true}` = the host looked and has no such session. Grok's own leg —
+ * claude's `readRemotePage` tails a claude file and must never answer for a grok node.
+ * Electron-only, like the other remote legs.
+ */
+ readRemoteGrok?(q: TranscriptQuery, opts?: { maxBytes?: number }): Promise<RemoteGrokChat | null>
+ /**
+ * The rollout path the CODEX context tail learned from a hook for this session (the `pathFor` above
+ * is CLAUDE's tail and must never answer for a codex id). A hint only: `locateCodexRollout` uses it
+ * when its file name names this very thread and it exists. Both shells wire it.
+ */
+ codexPathFor?(sessionId: string): string | undefined
+ /**
+ * ONE page of a REMOTE codex node's rollout, located ON the host under the node's own account home
+ * and read with the same ranged read claude's remote leg uses. Same conventions as
+ * `readRemotePage`: `null` = not a remote node; `{ok:false}` = remote and unreadable (terminal —
+ * never this machine's disk); `{ok:false, absent:true}` = the host looked and has no such rollout.
+ * Electron-only; the Server Edition runs on the host it reads.
+ */
+ readRemoteCodexPage?(q: TranscriptQuery, page: ChatTranscriptPage): Promise<RemoteTranscriptPage | null>
}
export type RemoteTranscriptPage = { ok: true; data: Buffer; start: number } | { ok: false; absent?: true }
@@@ -291,15 -276,34 +344,27 @@@ export async function readChatTranscrip
// Routed by agent BEFORE anything claude-shaped runs. `resolveTranscript` below falls back to
// the newest claude transcript for the cwd when its sessionId leg misses, and a grok id always
// misses — so reaching that fallback with a grok node would answer with a stranger's
- // conversation. The remote leg is claude-only too (its reader tails claude's file), so a grok
- // node is served locally or not at all rather than being handed the wrong host's claude log.
- if (agentId === 'grok') {
- // Grok is read locally only — a remote grok node's history is on the host.
- if (remoteOnly) return page ? unreadablePage() : { messages: [], found: false }
- const gp = sessionId ? await locateGrok(sessionId) : undefined
- // Grok does NOT page: its history is small and its reader has no byte-offset keys, so a
- // paged request gets the whole (capped) read with `olderCursor: null` — "nothing older to
- // fetch" — and no carried results. Keys are absent; the panel falls back to its own.
- const paging = page ? { olderCursor: null, unmatchedResults: [] } : {}
- if (!gp) return { messages: [], found: false, ...paging }
- const buf = await readCappedTail(gp)
- return buf === undefined
- ? { messages: [], found: false, ...paging }
- : { messages: chatMessagesFromGrok(buf), found: true, ...paging }
+ // conversation. Resolved through the base harness, so a custom agent built on grok (which the
+ // panel and the phone admit via `canChat`) is routed here too instead of into that fallback.
+ if (agentId !== undefined && capabilityAgentId(agentId) === 'grok') {
+ return readGrokChat({ sessionId, cwd, accountId, nodeId, ...(remoteOnly ? { remoteOnly } : {}) }, page, deps)
}
+ // Gemini, routed through the base harness so a custom agent built on it (which the relay serves)
+ // reads gemini's file too. Its own locator, keyed strictly on the session id in the file header —
+ // never claude's resolver, never a cwd — and local-only, like grok.
+ if (agentId && capabilityAgentId(agentId) === 'gemini') return readGeminiChatTranscript({ sessionId, remoteOnly }, page)
+ // Codex — the builtin or a custom agent whose base harness it is — is routed BEFORE the claude
+ // path for the same reason as grok: a codex thread id never resolves under claude's tree, and the
+ // cwd fallback would then answer with somebody else's claude session.
+ if (agentId && capabilityAgentId(agentId) === 'codex') {
+ if (page) return readCodexChatPage({ sessionId, cwd, accountId, nodeId, ...(remoteOnly ? { remoteOnly } : {}) }, page, deps)
+ // The unpaged (legacy) read has no live caller — the ⌘M panel and the phone always page — so it
+ // is served locally or not at all, like grok's: a remote node's rollout is on its host.
+ if (remoteOnly) return { messages: [], found: false }
+ const cp = await locateCodexRollout({ sessionId, accountId }, deps.codexPathFor)
+ const text = cp ? await readCappedTail(cp) : undefined
+ return text === undefined ? { messages: [], found: false } : { messages: chatMessagesFromCodex(text), found: true }
+ }
if (page) return readChatPage({ sessionId, cwd, accountId, nodeId, ...(remoteOnly ? { remoteOnly } : {}) }, page, deps)
const remote = deps.readRemote ? await deps.readRemote({ sessionId, cwd, accountId, nodeId }) : null
// A resolved-but-unreadable remote file is NOT "no conversation yet" — the read failed
diff --cc src/main/remote/host-chat.test.ts
index dc972c879,aa1b20a6e..b4fecf476
--- a/src/main/remote/host-chat.test.ts
+++ b/src/main/remote/host-chat.test.ts
@@@ -67,7 -67,7 +67,7 @@@ describe('host-chat page', () =>
await expect(createHostChat(d).page('n1', {})).rejects.toThrow()
})
it('serves only chat-capable agents (resolved through the base harness), and reads nothing otherwise', async () => {
- for (const agentId of ['codex', 'antigravity', undefined]) {
- for (const agentId of ['gemini', undefined]) {
++ for (const agentId of ['antigravity', undefined]) {
const d = deps({ lookupNode: () => ({ agentId, sessionId: 'sid-1' }) })
expect(await createHostChat(d).page('n1', {})).toBe('unsupported')
expect(d.readTranscript).not.toHaveBeenCalled()
@@@ -80,11 -80,11 +80,16 @@@
setCustomAgentBaseResolver(null)
}
})
+ it('serves gemini, handing its OWN agent id to the reader (which routes it off claude\'s resolver)', async () => {
+ const d = deps({ lookupNode: () => ({ agentId: 'gemini', sessionId: 'sid-1' }) })
+ expect(await createHostChat(d).page('n1', {})).toMatchObject({ version: 1 })
+ expect(d.readTranscript).toHaveBeenCalledWith(expect.objectContaining({ agentId: 'gemini', sessionId: 'sid-1' }), {})
+ })
+ it('serves a codex node, passing its own agent id so core routes it to the codex reader', async () => {
+ const d = deps({ lookupNode: () => ({ cwd: '/srv/app', agentId: 'codex', sessionId: 'sid-1', remote: true }) })
+ expect(await createHostChat(d).page('n1', {})).toMatchObject({ version: 1 })
+ expect(d.readTranscript).toHaveBeenCalledWith(expect.objectContaining({ agentId: 'codex', remoteOnly: true }), {})
+ })
it('an absent page is the default paged tail, not the legacy read', async () => {
const d = deps()
await createHostChat(d).page('n1', undefined)
diff --cc src/shared/agents/config.ts
index 2f4473c83,70905b7d8..d0cb2dfcc
--- a/src/shared/agents/config.ts
+++ b/src/shared/agents/config.ts
@@@ -296,16 -293,9 +296,19 @@@ export const USAGE_CAPABLE = ['claude'
// newest CLAUDE transcript for that cwd. A grok node in this list would therefore show a stranger's
// conversation in its find bar and rehydrate its meter from it. That exact bug already happened once
// with codex and gemini; transcriptGates.ts documents it.
+//
+// gemini joined in 2026-09 with its own reader (`core/gemini-chat.ts`): its session file is an upsert
+// log, not claude's shape, and it is located strictly by the session id in the file's header.
- export const CHAT_CAPABLE = ['claude', 'grok', 'gemini'] as const
+ // codex joined 2026-09-28 with its own reader (core/codex-chat.ts: the rollout's UI stream for what
+ // the user typed, the model stream for answers and tools), local and over SSH.
-export const CHAT_CAPABLE = ['claude', 'grok', 'codex'] as const
++export const CHAT_CAPABLE = ['claude', 'grok', 'gemini', 'codex'] as const
+// CHAT_CAPABLE agents whose reader has NO remote leg: a remote (SSH) node's session lives on its
+// host, so core answers `unreadable` before touching anything — and the local reader never sets that
+// flag. So an unreadable read of one of these can only mean "remote, unsupported", and the ⌘M panel
- // names it from the agent alone rather than offering a Retry that can never succeed. grok is NOT
- // here: its remote node is read on the host (`core/remote-grok-chat.ts`).
++// names it from the agent alone rather than offering a Retry that can never succeed. grok and codex
++// are NOT here: their remote nodes are read on the host (`core/remote-grok-chat.ts`,
++// `main/remote-codex-chat-page.ts`).
+export const CHAT_LOCAL_ONLY = ['gemini'] as const
// Agents whose transcript CLAUDE's own resolver can locate and parse — the gate for everything that
// goes through `resolveTranscript` (the find bar's index, the meter's mount-time rehydration).
//