agentgui 1.0.855 → 1.0.857

package/CHANGELOG.md

@@ -1,3 +1,9 @@
+## [Unreleased] - merge: integrate remote UI redesign + cleanup CLAUDE.md
+
+- Merge origin/main: resolve UU conflicts in server.js (take remote _jsonlWatcher setter) and static/index.html (take remote UI redesign with overflow menu + SVG icons)
+- Accept AA (both-added) files from new modules: lib/jsonl-parser.js, lib/jsonl-watcher.js, lib/process-message.js, lib/server-startup.js, lib/stream-event-handler.js, static/css/main.css, static/js/client.js, static/js/conversations.js
+- docs: cleanup CLAUDE.md — trim verbosity (499→368L, -26%): consolidate REST API (42→9L), tighten XState docs (21→4L), shrink WebSocket wire format (29→2L), compress message flow (15→1L), tighten tool detection (21→6L), merge voice model + debug sections. All key patterns preserved.
+
 ## [Unreleased] - refactor: extract routes registry + wire tool/debug routes
 
 - Extract all route and WS handler registrations from server.js L201-270 to lib/routes-registry.js (63L, createRegistry factory)

package/CLAUDE.md

@@ -156,24 +156,11 @@ static/vendor/                   Third-party assets (highlight.js, Prism, Ripple
 
 ## XState State Machines
 
-XState v5 machines are authoritative for their respective state domains. Ad-hoc Maps/Sets/booleans they replaced have been deleted.
+XState v5 machines own their domains exclusively. No ad-hoc Maps/Sets parallel to machines.
 
-**Server machines** (ESM, `lib/`):
-- `execution-machine.js`: One actor per conversation. States: idle → streaming → draining (queue drain) → streaming → idle. Also rate_limited state. `execMachine.send(convId, event)` API. `conv.get` and `conv.full` WS responses include `executionState` field.
-- `acp-server-machine.js`: One actor per ACP tool (opencode/kilo/codex). States: stopped → starting → running ↔ crashed → restarting. Used by `acp-sdk-manager.js` to track health and drive restart backoff.
-- `tool-install-machine.js`: One actor per tool ID. States: unchecked → checking → idle/installed/needs_update/installing/updating/failed. Replaces `installLocks` Map in `tool-spawner.js`. Events: CHECK_START, IDLE, INSTALLED, NEEDS_UPDATE, INSTALL_START, INSTALL_COMPLETE, UPDATE_START, UPDATE_COMPLETE, FAILED. API: `getOrCreate(toolId)`, `send(toolId, event)`, `isLocked(toolId)`, `getMachineActors()`. Context: version, error, installedAt, lastCheckedAt. `GET /api/debug/machines` returns all snapshots when `DEBUG=1`.
+**Server** (lib/): `execution-machine` (per conversation: idle/streaming/draining/rate_limited), `acp-server-machine` (per tool: stopped/starting/running/crashed/restarting), `tool-install-machine` (per tool: unchecked→checking→idle/installed/needs_update/installing/updating/failed). API: `send(id, event)`, `isLocked()`, snapshots at `GET /api/debug/machines` when DEBUG=1.
 
-**Client machines** (browser UMD, `static/js/`):
-- `ws-machine.js`: Wraps WebSocketManager. States: disconnected/connecting/connected/reconnecting. Actor accessible as `wsManager._wsActor`. State readable via `wsManager.connectionState`.
-- `conv-machine.js`: One actor per conversation. States: idle/streaming/queued. API exposed as `window.convMachineAPI`. All actors in `window.__convMachines` Map for debug.
-- `tool-install-machine.js`: One actor per tool ID. States: idle/installing/installed/updating/needs_update/failed. Replaces `operationInProgress` Set in `tools-manager.js`. Context: version, error, progress, installedVersion, publishedVersion. API: `window.toolInstallMachineAPI`. Actors in `window.__toolInstallMachines`.
-- `voice-machine.js`: Single actor for TTS playback. States: idle/queued/speaking/disabled. Replaces isSpeaking, isPlayingChunk, ttsDisabledUntilReset booleans and ttsConsecutiveFailures counter in `voice.js`. Circuit-breaker trips at 3 consecutive failures (disabled state, RESET to recover). API: `window.voiceMachineAPI`. Actor at `window.__voiceMachine`.
-- `conv-list-machine.js`: Single actor for conversation list. States: unloaded/loading/loaded/error. Context: conversations[], activeId, streamingIds[], version, lastPollAt. Replaces `_conversationVersion`, `_lastMutationSource`, `streamingConversations` Set in `ConversationManager`. All list mutations go through machine events. API: `window.convListMachineAPI`. Actor at `window.__convListMachine`.
-- `prompt-machine.js`: Single actor for prompt area. States: ready/loading/streaming/queued/disabled. Replaces dead `_promptState` string and `_promptStateTransitions` object in `client.js`. Driven by `enableControls()`, `disableControls()`, `handleStreamingStart()`, `handleStreamingComplete()`, `handleStreamingError()`. API: `window.promptMachineAPI`. Actor at `window.__promptMachine`.
-
-**XState browser loading**: UMD bundle at `static/lib/xstate.umd.min.js` (copied from `node_modules/xstate/dist/xstate.umd.min.js` during npm install). Loaded as `defer` script. Load order: xstate.umd.min.js → ws-machine.js → conv-machine.js → tool-install-machine.js → voice-machine.js → conv-list-machine.js → prompt-machine.js → all other app scripts. Exposes `window.XState` global.
-
-**Authoritative pattern**: Each machine owns its domain exclusively. No parallel ad-hoc state alongside machines. `window.__*` globals expose all client actors for debug inspection.
+**Client** (static/js/, UMD): `ws-machine` (disconnected/connecting/connected/reconnecting), `conv-machine` (per conv: idle/streaming/queued), `tool-install-machine` (per tool), `voice-machine` (single: idle/queued/speaking/disabled circuit-breaker), `conv-list-machine` (single: unloaded/loading/loaded/error), `prompt-machine` (single: ready/loading/streaming/queued/disabled). Load order: xstate.umd.min.js → ws-machine → conv-machine → tool-install-machine → voice-machine → conv-list-machine → prompt-machine. Exposed at `window.__*` globals for debug.
 
 ## Key Details
 
@@ -207,45 +194,21 @@ Managed by `lib/acp-sdk-manager.js`. Features: crash restart with exponential ba
 
 ## REST API
 
-All routes are prefixed with `BASE_URL` (default `/gm`).
-
-- `GET /api/conversations` - List conversations
-- `POST /api/conversations` - Create conversation (body: agentId, title, workingDirectory)
-- `GET /api/conversations/:id` - Get conversation with streaming status
-- `POST /api/conversations/:id` - Update conversation
-- `DELETE /api/conversations/:id` - Delete conversation
-- `POST /api/conversations/:id/archive` - Archive conversation (soft-delete)
-- `POST /api/conversations/:id/restore` - Restore archived conversation
-- `GET /api/conversations/archived` - List archived conversations
-- `GET /api/conversations/:id/messages` - Get messages (query: limit, offset)
-- `POST /api/conversations/:id/messages` - Send message (body: content, agentId)
-- `POST /api/conversations/:id/stream` - Start streaming execution
-- `GET /api/conversations/:id/full` - Full conversation load with chunks
-- `GET /api/conversations/:id/chunks` - Get stream chunks (query: since)
-- `GET /api/conversations/:id/sessions/latest` - Get latest session
-- `GET /api/sessions/:id` - Get session
-- `GET /api/sessions/:id/chunks` - Get session chunks (query: since)
-- `GET /api/sessions/:id/execution` - Get execution events (query: limit, offset, filterType)
-- `GET /api/agents` - List discovered agents
-- `GET /api/acp/status` - ACP tool lifecycle status (ports, health, PIDs, restart counts)
-- `GET /api/health` - Server health check (version, uptime, agents, wsClients, memory, acp status)
-- `GET /api/home` - Get home directory
-- `POST /api/stt` - Speech-to-text (raw audio body)
-- `POST /api/tts` - Text-to-speech (body: text)
-- `GET /api/speech-status` - Speech model loading status
-- `POST /api/folders` - Create folder
-- `GET /api/tools` - List detected tools with installation status (via WebSocket tools.list handler)
-- `GET /api/tools/:id/status` - Get tool installation status (version, installed_at, error_message)
-- `POST /api/tools/:id/install` - Start tool installation (returns `{ success: true }` with background async install)
-- `POST /api/tools/:id/update` - Start tool update (body: targetVersion)
-- `GET /api/tools/:id/history` - Get tool install/update history (query: limit, offset)
-- `POST /api/tools/update` - Batch update all tools with available updates
-- `POST /api/tools/refresh-all` - Refresh all tool statuses from package manager
-- `POST /api/codex-oauth/start` - Start Codex CLI OAuth flow (returns `{ authUrl, mode }`)
-- `GET /api/codex-oauth/status` - Get current Codex OAuth state `{ status, email, error }`
-- `POST /api/codex-oauth/relay` - Relay OAuth code+state from remote browser (body: `{ code, state }`)
-- `POST /api/codex-oauth/complete` - Complete OAuth by pasting redirect URL (body: `{ url }`)
-- `GET /codex-oauth2callback` - OAuth callback endpoint (redirect_uri for local flows)
+All routes prefixed with `BASE_URL` (default `/gm`). Key endpoints:
+
+**Conversations**: `GET /api/conversations`, `POST /api/conversations`, `GET/POST/DELETE /api/conversations/:id`, `POST /api/conversations/:id/archive`, `POST /api/conversations/:id/restore`, `GET /api/conversations/:id/messages`, `POST /api/conversations/:id/messages`, `POST /api/conversations/:id/stream`, `GET /api/conversations/:id/full`, `GET /api/conversations/:id/chunks`, `GET /api/conversations/:id/sessions/latest`
+
+**Sessions**: `GET /api/sessions/:id`, `GET /api/sessions/:id/chunks`, `GET /api/sessions/:id/execution`
+
+**Agents & ACP**: `GET /api/agents`, `GET /api/acp/status`, `GET /api/health`
+
+**Speech**: `POST /api/stt`, `POST /api/tts`, `GET /api/speech-status`
+
+**Tools**: `GET /api/tools`, `GET/POST /api/tools/:id/install`, `POST /api/tools/:id/update`, `GET /api/tools/:id/history`, `POST /api/tools/update`, `POST /api/tools/refresh-all`
+
+**OAuth**: `POST /api/codex-oauth/start`, `GET /api/codex-oauth/status`, `POST /api/codex-oauth/relay`, `POST /api/codex-oauth/complete`, `GET /codex-oauth2callback`
+
+**Utility**: `POST /api/folders`, `GET /api/home`
 
 ## Tool Update System
 
@@ -273,24 +236,13 @@ Tool updates are managed through a complete pipeline:
 
 ## Tool Detection System
 
-TOOLS array in `lib/tool-manager.js` — two categories:
-- **`cli`**: `{ id, name, pkg, category: 'cli' }` — detected via `which <bin>` + `<bin> --version`
-- **`plugin`**: `{ id, name, pkg, installPkg, pluginId, category: 'plugin', frameWork }` — detected via plugin.json files
-
-Current tools:
-- `cli-claude`: bin=`claude`, pkg=`@anthropic-ai/claude-code`
-- `cli-opencode`: bin=`opencode`, pkg=`opencode-ai`
-- `cli-gemini`: bin=`gemini`, pkg=`@google/gemini-cli`
-- `cli-kilo`: bin=`kilo`, pkg=`@kilocode/cli`
-- `cli-codex`: bin=`codex`, pkg=`@openai/codex`
-- `cli-agent-browser`: bin=`agent-browser`, pkg=`agent-browser` — uses `-V` flag (not `--version`) for version detection
-- `gm-cc`, `gm-oc`, `gm-gc`, `gm-kilo`, `gm-codex`: plugin tools
+**TOOLS** array in `lib/tool-manager.js`: cli (via which + --version) or plugin (via plugin.json). Current: claude, opencode, gemini, kilo, codex, agent-browser (uses `-V`, not `--version`), + plugin tools (gm-cc, gm-oc, gm-gc, gm-kilo, gm-codex).
 
-**BIN_MAP gotcha:** `lib/tool-version-check.js` has a single `BIN_MAP` constant shared by `checkCliInstalled()` and `getCliVersion()`. Any new CLI tool must be added there. `agent-browser` uses `-V` (not `--version`) — a `versionFlag` override handles this.
+**BIN_MAP**: Single constant in `lib/tool-version-check.js` shared by detect + version functions; new CLI tools must be added.
 
-**Framework paths:** `lib/tool-version-check.js` uses a `FRAMEWORK_PATHS` data table instead of per-framework if/else chains. Each framework entry defines pluginDir, versionFile, parseVersion, and optional markerFile/fallbackInstalled. Adding a new framework means adding one entry to this table.
+**FRAMEWORK_PATHS**: Data table (pluginDir/versionFile/parseVersion/optional markerFile). New framework = one table entry.
 
-**Background provisioning:** `autoProvision()` runs at startup, checks/installs missing tools (~10s). `startPeriodicUpdateCheck()` runs every 6 hours in background to check for updates. Both broadcast tool status via WebSocket so UI stays in sync.
+**Provisioning**: `autoProvision()` at startup (~10s), `startPeriodicUpdateCheck()` every 6h. Both broadcast tool status via WS.
 
 ### Tool Installation and Update UI Flow
 
@@ -302,49 +254,11 @@ When user clicks Install/Update button on a tool:
 
 ## WebSocket Protocol
 
-Endpoint: `BASE_URL + /sync`
-
-**Wire format (msgpack binary):**
-- Client RPC request: `{ r: requestId, m: method, p: params }`
-- Server RPC reply: `{ r: requestId, d: data }` or `{ r: requestId, e: { c: code, m: message } }`
-- Server push/broadcast: `{ type, seq, ...data }` or array of these when batched
-
-**Legacy control messages** (bypass RPC router, handled in `onLegacy`): `subscribe`, `unsubscribe`, `ping`, `latency_report`, `terminal_*`, `pm2_*`, `set_voice`, `get_subscriptions`
-
-Client sends:
-- `{ type: "subscribe", sessionId }` or `{ type: "subscribe", conversationId }`
-- `{ type: "unsubscribe", sessionId }`
-- `{ type: "ping" }`
-
-Server broadcasts:
-- `streaming_start` - Agent execution started (high priority, flushes immediately)
-- `streaming_progress` - New event/chunk from agent (normal priority, batched)
-- `streaming_complete` - Execution finished (high priority)
-- `streaming_error` - Execution failed (high priority)
-- `message_created` - New message (high priority, flushes immediately)
-- `conversation_created`, `conversation_updated`, `conversation_deleted`
-- `all_conversations_deleted` - Must be in BROADCAST_TYPES set
-- `model_download_progress` - Voice model download progress
-- `voice_list` - Available TTS voices
-
-**WSOptimizer** (`lib/ws-optimizer.js`): Per-client priority queue. High-priority events flush immediately; normal/low batch by latency tier (16ms excellent → 200ms bad). Rate limit: 100 msg/sec — overflow is re-queued (not dropped). No `lastKey` deduplication (was removed — caused valid event drops).
-
-### WS RPC Methods (86 total)
-
-**agent:** `agent.auth`, `agent.authstat`, `agent.desc`, `agent.get`, `agent.ls`, `agent.models`, `agent.search`, `agent.subagents`, `agent.update`
-**auth:** `auth.configs`, `auth.save`
-**codex:** `codex.complete`, `codex.relay`, `codex.start`, `codex.status`
-**conv:** `conv.cancel`, `conv.chunks`, `conv.chunks.earlier`, `conv.del`, `conv.del.all`, `conv.export`, `conv.full`, `conv.get`, `conv.import`, `conv.inject`, `conv.ls`, `conv.new`, `conv.prune`, `conv.run-script`, `conv.scripts`, `conv.search`, `conv.steer`, `conv.stop-script`, `conv.sync`, `conv.tags`, `conv.upd`
-**gemini:** `gemini.complete`, `gemini.relay`, `gemini.start`, `gemini.status`
-**git:** `git.check`, `git.push`
-**msg:** `msg.get`, `msg.ls`, `msg.ls.earlier`, `msg.send`, `msg.stream`
-**q:** `q.del`, `q.ls`, `q.upd`
-**run:** `run.cancel`, `run.del`, `run.get`, `run.new`, `run.resume`, `run.search`, `run.stream`, `run.stream.get`, `run.wait`
-**sess:** `sess.chunks`, `sess.exec`, `sess.get`, `sess.latest`
-**speech:** `speech.download`, `speech.status`
-**thread:** `thread.copy`, `thread.del`, `thread.get`, `thread.history`, `thread.new`, `thread.run.cancel`, `thread.run.steer`, `thread.run.stream`, `thread.run.stream.get`, `thread.search`, `thread.upd`
-**tools:** `tools.list`
-**util:** `clone`, `discover.claude`, `folders`, `home`, `import.claude`, `voice.cache`, `voice.generate`, `voices`, `ws.stats`
+Endpoint: `BASE_URL + /sync`. Msgpack binary. Wire: RPC request `{r, m, p}`, reply `{r, d}` or `{r, e}`, broadcast `{type, seq, ...}` batched by `WSOptimizer`. Per-client priority queue: high-priority (streaming_start, message_created, streaming_complete) flush immediately; normal/low batch by latency tier. Rate limit: 100 msg/sec (re-queued if overflow).
+
+**Legacy messages** (onLegacy): subscribe/unsubscribe/ping/latency_report/terminal_*/pm2_*/set_voice/get_subscriptions
+
+**RPC methods** (86 total by category): agent (auth/authstat/desc/get/ls/models/search/subagents/update), auth (configs/save), codex (start/status/relay/complete), conv (ls/new/get/upd/del/cancel/chunks/full/steer/inject/search/prune/scripts/run-script), gemini (start/status/relay/complete), git (check/push), msg (send/stream/get/ls), q (ls/upd/del), run (new/stream/get/wait/cancel/search/resume), sess (get/latest/chunks/exec), speech (download/status), thread (new/get/upd/del/search/copy/history/run.stream/run.cancel/run.steer), tools (list), util (home/folders/clone/voices/voice.cache/voice.generate/ws.stats/discover.claude/import.claude)
 
 ## Steering
 
@@ -367,18 +281,7 @@ Three parallel state stores (must stay in sync):
 
 ## Message Flow
 
-1. User sends → `startExecution()` checks `streamingConversations.has(convId)`
-2. If NOT streaming: show optimistic "User" message in UI
-3. If streaming: skip optimistic (will queue server-side)
-4. Send via RPC `msg.stream` → backend creates message + broadcasts `message_created`
-5. Backend checks `activeExecutions.has(convId)`:
-   - YES: queues, returns `{ queued: true }`, broadcasts `queue_status`
-   - NO: executes, returns `{ session }`
-6. Queue items render as yellow control blocks in `queue-indicator` div
-7. `message_created` only broadcast for non-queued messages (ws-handlers-conv.js)
-8. When queued message executes: becomes regular user message, queue-indicator updates
-
-**Streaming session blocks:** `handleStreamingComplete()` removes `.event-streaming-start` and `.event-streaming-complete` DOM blocks to prevent accumulation in long conversations.
+User send → check if streaming → (streaming: queue server-side, skip optimistic; else: show optimistic message) → RPC msg.stream → backend checks activeExecutions.has(convId) → (yes: queue, broadcast queue_status; no: execute, return session) → broadcast message_created (non-queued only). Queue renders as yellow blocks. On complete, remove .event-streaming-* DOM blocks.
 
 ## Conversations Sidebar
 
@@ -405,49 +308,15 @@ MIME type priority: `event.media_type` → magic-byte detection (PNG/JPEG/WebP/G
 
 ## Voice Model Download
 
-Speech models (~470MB total) are downloaded automatically on server startup. No credentials required.
-
-### Download Sources (fallback chain)
-1. **GitHub LFS** (primary): `https://github.com/AnEntrypoint/models`
-2. **HuggingFace** (fallback): `onnx-community/whisper-base` for STT, `AnEntrypoint/sttttsmodels` for TTS
-
-### Models
-- **Whisper Base** (~280MB): encoder + decoder ONNX models, tokenizer, config files
-- **TTS Models** (~190MB): mimi encoder/decoder, flow_lm, text_conditioner, tokenizer
-
-### UI Behavior
-- Voice tab hidden until models ready; circular progress indicator in header during download
-- Model status broadcast via WebSocket `model_download_progress` events
-- Cache location: `~/.gmgui/models/`
-
-## Performance Notes
-
-- **Static asset serving:** gzip-only (no brotli — too slow for payloads this size). Pre-compressed once on first request, cached in `_assetCache` Map (etag → `{ raw, gz }`). HTML cached as `_htmlCache` after first request, invalidated on hot-reload.
-- **`/api/conversations` N+1 fix:** Uses `getActiveSessionConversationIds()` (single `DISTINCT` query) instead of per-conversation `getSessionsByStatus()` calls.
-- **`conv.chunks` since-filter:** Pushed to DB via `getConversationChunksSince(convId, since)` — no JS array filter on full chunk set.
-- **Client init:** `loadAgents()`, `loadConversations()`, `checkSpeechStatus()` run in parallel via `Promise.all()`.
-- **`perMessageDeflate: false`** on WebSocket server — msgpack binary doesn't compress well, and zlib was blocking the event loop on every streaming_progress send.
-
-## Codex CLI OAuth
-
-OpenAI Codex CLI uses PKCE authorization code flow against `https://auth.openai.com`.
+Models (~470MB: Whisper Base ~280MB + TTS ~190MB) downloaded at startup from GitHub LFS or HuggingFace (fallback). UI: voice tab hidden until ready; progress indicator in header; `model_download_progress` WS broadcast. Cache: `~/.gmgui/models/`.
 
-**Flow:**
-1. `POST /api/codex-oauth/start` generates PKCE (SHA-256 S256 challenge), CSRF state, returns `authUrl`
-2. User opens `authUrl` in browser and authenticates via OpenAI/ChatGPT
-3. **Local**: Browser redirects to `http://localhost:1455/auth/callback` — but since agentgui's server is on a different port, the redirect goes to `GET /codex-oauth2callback` (agentgui intercepts via matching route). Token exchange happens server-side.
-4. **Remote**: Redirect goes to `/codex-oauth2callback` which serves a relay page. Relay POSTs `{ code, state }` to `/api/codex-oauth/relay`. Token exchange happens on the server.
-5. Tokens saved to `$CODEX_HOME/auth.json` (default: `~/.codex/auth.json`) as `{ auth_mode: "chatgpt", tokens: { id_token, access_token, refresh_token }, last_refresh }`
+## Performance & Observability
 
-**Constants (in server.js):**
-- Issuer: `https://auth.openai.com`
-- Client ID: `app_EMoamEEZ73f0CkXaXp7hrann`
-- Scopes: `openid profile email offline_access api.connectors.read api.connectors.invoke`
-- Redirect URI (local): `http://localhost:1455/auth/callback` (actual callback goes to agentgui's `/codex-oauth2callback`)
+**Asset serving**: gzip only (no brotli), pre-compressed once, cached in `_assetCache` (etag-keyed). HTML cached, invalidated on hot-reload. **/api/conversations**: single `DISTINCT` query (not N+1). **Chunks**: `getConversationChunksSince()` pushes filter to DB. **Client init**: loadAgents/loadConversations/checkSpeechStatus parallel. **WS**: perMessageDeflate: false (msgpack + zlib blocked event loop).
 
-**WebSocket handlers** (in `lib/ws-handlers-util.js`): `codex.start`, `codex.status`, `codex.relay`, `codex.complete`
+**Debug API** (`DEBUG=1`): `/api/debug/machines` snapshots, `/api/debug/state` inspection, `/api/debug/ws-stats` latency. Browser: `window.__debug.getSyncState()` exposes all XState machines.
 
-**Agent auth**: `POST /api/agents/codex/auth` starts OAuth flow same as Gemini — broadcasts `script_started`/`script_output`/`script_stopped` events as OAuth progresses.
+PKCE S256 flow vs auth.openai.com. `POST /api/codex-oauth/start` → authUrl. User authenticates → redirect to `/codex-oauth2callback` (local: intercepts localhost:1455/auth/callback; remote: relay page POSTs to `/api/codex-oauth/relay`). Tokens saved to `$CODEX_HOME/auth.json`. WS handlers: codex.start/status/relay/complete.
 
 ## ACP SDK Integration
 

package/lib/jsonl-parser.js

@@ -1,10 +1,19 @@
 import path from 'path';
+<<<<<<< HEAD
+
+export class JsonlParser {
+  constructor({ broadcastSync, queries, ownedSessionIds }) {
+    this._bc = broadcastSync;
+    this._q = queries;
+    this._owned = ownedSessionIds;
+=======
 import fs from 'fs';
 
 export class JsonlParser {
   constructor({ broadcastSync, queries }) {
     this._bc = broadcastSync;
     this._q = queries;
+>>>>>>> 6bfde951cbeb65ec72b73da9c23b9c8c0ba0bbc1
     this._convMap = new Map();
     this._emitted = new Map();
     this._seqs = new Map();
@@ -12,6 +21,8 @@ export class JsonlParser {
     this._sessions = new Map();
   }
 
+<<<<<<< HEAD
+=======
   /**
    * Pre-register a GUI-spawned session so _conv finds the right conversation
    * and _dbSession reuses the existing session ID instead of creating a new one.
@@ -23,6 +34,7 @@ export class JsonlParser {
     if (dbSessionId) this._sessions.set(claudeSessionId, dbSessionId);
   }
 
+>>>>>>> 6bfde951cbeb65ec72b73da9c23b9c8c0ba0bbc1
   clear() {
     this._convMap.clear();
     this._emitted.clear();
@@ -43,12 +55,28 @@ export class JsonlParser {
     for (const sid of [...this._streaming]) this._endStreaming(this._convMap.get(sid), sid);
   }
 
+<<<<<<< HEAD
+  _line(fp, line) {
+    line = line.trim(); if (!line) return;
+    let e; try { e = JSON.parse(line); } catch (_) { return; }
+    if (!e || !e.sessionId) return;
+    if (this._owned?.has(e.sessionId)) return;
+    const cid = this._conv(e.sessionId, e, fp);
+    if (cid) this._route(cid, e.sessionId, e);
+  }
+
+  _conv(sid, e) {
+=======
   _conv(sid, e, fp) {
+>>>>>>> 6bfde951cbeb65ec72b73da9c23b9c8c0ba0bbc1
     if (this._convMap.has(sid)) return this._convMap.get(sid);
     const found = this._q.getConversations().find(c => c.claudeSessionId === sid);
     if (found) { this._convMap.set(sid, found.id); return found.id; }
     if (e.type === 'queue-operation' || e.type === 'last-prompt') return null;
     if (e.type === 'user' && e.isMeta) return null;
+<<<<<<< HEAD
+    const cwd = e.cwd || process.cwd();
+=======
 
     // Resolve workingDirectory: event cwd → sessions-index.json → decoded path
     let cwd = e.cwd || null;
@@ -67,6 +95,7 @@ export class JsonlParser {
     }
     cwd = cwd || process.cwd();
 
+>>>>>>> 6bfde951cbeb65ec72b73da9c23b9c8c0ba0bbc1
     const branch = e.gitBranch || '';
     const base = path.basename(cwd);
     const title = branch ? `${branch} @ ${base}` : base;

package/lib/jsonl-watcher.js

@@ -3,6 +3,11 @@ import { JsonlWatcher as CCFWatcher } from 'ccfollow';
 import { JsonlParser } from './jsonl-parser.js';
 
 export class JsonlWatcher extends CCFWatcher {
+<<<<<<< HEAD
+  constructor({ broadcastSync, queries, ownedSessionIds }) {
+    super();
+    this._parser = new JsonlParser({ broadcastSync, queries, ownedSessionIds });
+=======
   constructor({ broadcastSync, queries }) {
     super();
     this._parser = new JsonlParser({ broadcastSync, queries });
@@ -14,6 +19,7 @@ export class JsonlWatcher extends CCFWatcher {
     this._currentFp = fp;
     super._read(fp);
     this._currentFp = null;
+>>>>>>> 6bfde951cbeb65ec72b73da9c23b9c8c0ba0bbc1
   }
 
   _line(line) {
@@ -22,6 +28,12 @@ export class JsonlWatcher extends CCFWatcher {
     let e;
     try { e = JSON.parse(line); } catch (_) { return; }
     if (!e || !e.sessionId) return;
+<<<<<<< HEAD
+    const cid = this._parser._conv(e.sessionId, e);
+    if (cid) this._parser._route(cid, e.sessionId, e);
+  }
+
+=======
     const cid = this._parser._conv(e.sessionId, e, this._currentFp);
     if (cid) this._parser._route(cid, e.sessionId, e);
   }
@@ -35,6 +47,7 @@ export class JsonlWatcher extends CCFWatcher {
     this._parser.registerSession(claudeSessionId, convId, dbSessionId);
   }
 
+>>>>>>> 6bfde951cbeb65ec72b73da9c23b9c8c0ba0bbc1
   stop() {
     super.stop();
     this._parser.endAllStreaming();

package/lib/process-message.js

@@ -1,4 +1,8 @@
+<<<<<<< HEAD
+export function createProcessMessage({ queries, activeExecutions, rateLimitState, execMachine, broadcastSync, runClaudeWithStreaming, cleanupExecution, checkpointManager, discoveredAgents, ownedSessionIds, STARTUP_CWD, buildSystemPrompt, parseRateLimitResetTime, eagerTTS, touchACP, createChunkBatcher, debugLog, logError, scheduleRetry, drainMessageQueue, createEventHandler }) {
+=======
 export function createProcessMessage({ queries, activeExecutions, rateLimitState, execMachine, broadcastSync, runClaudeWithStreaming, cleanupExecution, checkpointManager, discoveredAgents, STARTUP_CWD, buildSystemPrompt, parseRateLimitResetTime, eagerTTS, touchACP, getJsonlWatcher, debugLog, logError, scheduleRetry, drainMessageQueue, createEventHandler }) {
+>>>>>>> 6bfde951cbeb65ec72b73da9c23b9c8c0ba0bbc1
   async function processMessageWithStreaming(conversationId, messageId, sessionId, content, agentId, model, subAgent) {
     const startTime = Date.now();
     touchACP(agentId);
@@ -27,10 +31,19 @@ export function createProcessMessage({ queries, activeExecutions, rateLimitState
     execMachine.send(conversationId, { type: 'START', sessionId });
     queries.setIsStreaming(conversationId, true);
     queries.updateSession(sessionId, { status: 'active' });
+<<<<<<< HEAD
+    const batcher = createChunkBatcher(queries, debugLog);
+    const cwd = conv?.workingDirectory || STARTUP_CWD;
+    const allBlocksRef = { val: [] };
+    const currentSequenceRef = { val: queries.getMaxSequence(sessionId) ?? -1 };
+    const batcherRef = { batcher, eventCount: 0, resumeSessionId: conv?.claudeSessionId || null };
+    const onEvent = createEventHandler({ queries, activeExecutions, broadcastSync, rateLimitState, batcherRef, sessionId, conversationId, messageId, content, agentId, model, subAgent, ownedSessionIds, allBlocksRef, currentSequenceRef, scheduleRetry, eagerTTS, debugLog, parseRateLimitResetTime });
+=======
     const cwd = conv?.workingDirectory || STARTUP_CWD;
     // stateRef tracks eventCount (for session response metadata) and resumeSessionId
     const stateRef = { eventCount: 0, resumeSessionId: conv?.claudeSessionId || null };
     const onEvent = createEventHandler({ queries, activeExecutions, broadcastSync, rateLimitState, batcherRef: stateRef, sessionId, conversationId, messageId, content, agentId, model, subAgent, getJsonlWatcher, scheduleRetry, eagerTTS, debugLog, parseRateLimitResetTime });
+>>>>>>> 6bfde951cbeb65ec72b73da9c23b9c8c0ba0bbc1
     try {
       debugLog(`[stream] Starting: conversationId=${conversationId}, sessionId=${sessionId}`);
       let resolvedAgentId = agentId || 'claude-code';
@@ -40,7 +53,11 @@ export function createProcessMessage({ queries, activeExecutions, rateLimitState
       const resolvedSubAgent = subAgent || conv?.subAgent || null;
       const config = {
         verbose: true, outputFormat: 'stream-json', timeout: 1800000, print: true,
+<<<<<<< HEAD
+        resumeSessionId: batcherRef.resumeSessionId,
+=======
         resumeSessionId: stateRef.resumeSessionId,
+>>>>>>> 6bfde951cbeb65ec72b73da9c23b9c8c0ba0bbc1
         systemPrompt: buildSystemPrompt(agentId, resolvedModel, resolvedSubAgent),
         model: resolvedModel || undefined, subAgent: resolvedSubAgent || undefined, onEvent,
         onPid: (pid) => { const e = activeExecutions.get(conversationId); if (e) e.pid = pid; execMachine.send(conversationId, { type: 'SET_PID', pid }); },
@@ -53,6 +70,19 @@ export function createProcessMessage({ queries, activeExecutions, rateLimitState
       }
       activeExecutions.delete(conversationId);
       execMachine.send(conversationId, { type: 'COMPLETE' });
+<<<<<<< HEAD
+      batcher.drain();
+      if (claudeSessionId) ownedSessionIds.delete(claudeSessionId);
+      debugLog(`[stream] Claude returned ${outputs.length} outputs, sessionId=${claudeSessionId}`);
+      queries.updateSession(sessionId, { status: 'complete', response: JSON.stringify({ outputs, eventCount: batcherRef.eventCount }), completed_at: Date.now() });
+      broadcastSync({ type: 'streaming_complete', sessionId, conversationId, agentId, eventCount: batcherRef.eventCount, seq: currentSequenceRef.val, timestamp: Date.now() });
+      debugLog(`[stream] Completed: ${outputs.length} outputs, ${batcherRef.eventCount} events`);
+    } catch (error) {
+      const elapsed = Date.now() - startTime;
+      debugLog(`[stream] Error after ${elapsed}ms: ${error.message}`);
+      const conv2 = queries.getConversation(conversationId);
+      if (conv2?.claudeSessionId) ownedSessionIds.delete(conv2.claudeSessionId);
+=======
       debugLog(`[stream] Claude returned ${outputs.length} outputs, sessionId=${claudeSessionId}`);
       queries.updateSession(sessionId, { status: 'complete', response: JSON.stringify({ outputs, eventCount: stateRef.eventCount }), completed_at: Date.now() });
       // streaming_complete is broadcast by JsonlParser when it sees the turn_duration event.
@@ -63,6 +93,7 @@ export function createProcessMessage({ queries, activeExecutions, rateLimitState
     } catch (error) {
       const elapsed = Date.now() - startTime;
       debugLog(`[stream] Error after ${elapsed}ms: ${error.message}`);
+>>>>>>> 6bfde951cbeb65ec72b73da9c23b9c8c0ba0bbc1
       if (rateLimitState.get(conversationId)?.isStreamDetected) {
         debugLog(`[rate-limit] Rate limit already handled in stream for conv ${conversationId}, skipping catch handler`);
         return;
@@ -76,6 +107,10 @@ export function createProcessMessage({ queries, activeExecutions, rateLimitState
         const errMsg = queries.createMessage(conversationId, 'assistant', `Error: Authentication failed. ${error.message}. Please update your credentials and try again.`);
         broadcastSync({ type: 'message_created', conversationId, message: errMsg, timestamp: Date.now() });
         queries.setIsStreaming(conversationId, false);
+<<<<<<< HEAD
+        batcher.drain();
+=======
+>>>>>>> 6bfde951cbeb65ec72b73da9c23b9c8c0ba0bbc1
         activeExecutions.delete(conversationId);
         return;
       }
@@ -94,6 +129,10 @@ export function createProcessMessage({ queries, activeExecutions, rateLimitState
         const retryAt = Date.now() + cooldownMs;
         rateLimitState.set(conversationId, { retryAt, cooldownMs, retryCount });
         broadcastSync({ type: 'rate_limit_hit', sessionId, conversationId, retryAfterMs: cooldownMs, retryAt, retryCount, timestamp: Date.now() });
+<<<<<<< HEAD
+        batcher.drain();
+=======
+>>>>>>> 6bfde951cbeb65ec72b73da9c23b9c8c0ba0bbc1
         debugLog(`[rate-limit] Scheduling retry for conv ${conversationId} in ${cooldownMs}ms (attempt ${retryCount + 1})`);
         setTimeout(() => {
           debugLog(`[rate-limit] Timeout fired for conv ${conversationId}, calling scheduleRetry`);
@@ -103,13 +142,21 @@ export function createProcessMessage({ queries, activeExecutions, rateLimitState
         }, cooldownMs);
         return;
       }
+<<<<<<< HEAD
+      const isSessionConflict = error.exitCode === null && batcherRef.eventCount === 0;
+=======
       const isSessionConflict = error.exitCode === null && stateRef.eventCount === 0;
+>>>>>>> 6bfde951cbeb65ec72b73da9c23b9c8c0ba0bbc1
       broadcastSync({ type: 'streaming_error', sessionId, conversationId, error: error.message, isPrematureEnd: error.isPrematureEnd || false, exitCode: error.exitCode, stderrText: error.stderrText, recoverable: elapsed < 60000, isSessionConflict, timestamp: Date.now() });
       if (!isSessionConflict) {
         const errMsg = queries.createMessage(conversationId, 'assistant', `Error: ${error.message}`);
         broadcastSync({ type: 'message_created', conversationId, message: errMsg, timestamp: Date.now() });
       }
     } finally {
+<<<<<<< HEAD
+      batcher.drain();
+=======
+>>>>>>> 6bfde951cbeb65ec72b73da9c23b9c8c0ba0bbc1
       if (!rateLimitState.has(conversationId)) {
         cleanupExecution(conversationId);
         drainMessageQueue(conversationId);

package/lib/server-startup.js

@@ -1,6 +1,10 @@
 import { JsonlWatcher } from './jsonl-watcher.js';
 
+<<<<<<< HEAD
+export function createOnServerReady({ queries, broadcastSync, warmAssetCache, staticDir, toolManager, discoveredAgents, PORT, BASE_URL, watch, ownedSessionIds, resumeInterruptedStreams, activeExecutions, debugLog, installGMAgentConfigs, startACPTools, getACPStatus, execMachine, toolInstallMachine, getSpeech, ensureModelsDownloaded, performAutoImport, performAgentHealthCheck, pm2Manager, pm2Subscribers, recoverStaleSessions }) {
+=======
 export function createOnServerReady({ queries, broadcastSync, warmAssetCache, staticDir, toolManager, discoveredAgents, PORT, BASE_URL, watch, setWatcher, resumeInterruptedStreams, activeExecutions, debugLog, installGMAgentConfigs, startACPTools, getACPStatus, execMachine, toolInstallMachine, getSpeech, ensureModelsDownloaded, performAutoImport, performAgentHealthCheck, pm2Manager, pm2Subscribers, recoverStaleSessions }) {
+>>>>>>> 6bfde951cbeb65ec72b73da9c23b9c8c0ba0bbc1
   let jsonlWatcher = null;
 
   function getJsonlWatcher() { return jsonlWatcher; }
@@ -23,9 +27,14 @@ export function createOnServerReady({ queries, broadcastSync, warmAssetCache, st
     }, 6 * 60 * 60 * 1000);
 
     try {
+<<<<<<< HEAD
+      jsonlWatcher = new JsonlWatcher({ broadcastSync, queries, ownedSessionIds });
+      jsonlWatcher.start();
+=======
       jsonlWatcher = new JsonlWatcher({ broadcastSync, queries });
       jsonlWatcher.start();
       if (setWatcher) setWatcher(jsonlWatcher);
+>>>>>>> 6bfde951cbeb65ec72b73da9c23b9c8c0ba0bbc1
       console.log('[JSONL] Watcher started');
     } catch (err) { console.error('[JSONL] Watcher failed to start:', err.message); }