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.
TypeScript adhdagent-orchestrationai-agentscanvasclaude-codecodexcoding-agentsdeveloper-toolselectrongeminilinuxmacosmultiplexeropencodeparallel-agentsterminalterminal-emulatorterminal-multiplexertmuxworkspace-manager
Merge origin/feat/chat-view-codex into feat/chat-view-agents
review3a39bbf50827
diff --cc CLAUDE.mdindex 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 hadto be SPLIT to do it — `CHAT_CAPABLE` carried two facts that coincided while claude was its onlymember ("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. Unlikegrok, **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 isdiff --cc docs/mobile-chat-view.mdindex 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.tsindex 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 faileddiff --cc src/main/remote/host-chat.test.tsindex 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.tsindex 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).//