agentgui 1.0.855 → 1.0.856

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); }
 

package/lib/stream-event-handler.js

@@ -1,3 +1,6 @@
+<<<<<<< HEAD
+export function createEventHandler({ queries, activeExecutions, broadcastSync, rateLimitState, batcherRef, sessionId, conversationId, messageId, content, agentId, model, subAgent, ownedSessionIds, allBlocksRef, currentSequenceRef, scheduleRetry, eagerTTS, debugLog, parseRateLimitResetTime }) {
+=======
 /**
  * Minimal Claude stdout event handler.
  *
@@ -11,10 +14,35 @@
  * No batcher, no broadcastSync for individual blocks.
  */
 export function createEventHandler({ queries, activeExecutions, broadcastSync, rateLimitState, batcherRef, sessionId, conversationId, messageId, content, agentId, model, subAgent, getJsonlWatcher, scheduleRetry, eagerTTS, debugLog, parseRateLimitResetTime }) {
+>>>>>>> 6bfde951cbeb65ec72b73da9c23b9c8c0ba0bbc1
   return function onEvent(parsed) {
     batcherRef.eventCount++;
     const entry = activeExecutions.get(conversationId);
     if (entry) entry.lastActivity = Date.now();
+<<<<<<< HEAD
+    if (parsed.session_id) {
+      ownedSessionIds.add(parsed.session_id);
+      if (!batcherRef.resumeSessionId || batcherRef.resumeSessionId !== parsed.session_id) {
+        batcherRef.resumeSessionId = parsed.session_id;
+        queries.setClaudeSessionId(conversationId, parsed.session_id, sessionId);
+      }
+    }
+    debugLog(`[stream] Event ${batcherRef.eventCount}: type=${parsed.type}`);
+
+    if (parsed.type === 'system') {
+      if (parsed.subtype === 'task_notification') return;
+      if (!parsed.model && !parsed.cwd && !parsed.tools) return;
+      const block = { type: 'system', subtype: parsed.subtype, model: parsed.model, cwd: parsed.cwd, tools: parsed.tools, session_id: parsed.session_id };
+      currentSequenceRef.val++;
+      batcherRef.batcher.add(sessionId, conversationId, currentSequenceRef.val, 'system', block);
+      broadcastSync({ type: 'streaming_progress', sessionId, conversationId, block, blockRole: 'system', blockIndex: allBlocksRef.val.length, seq: currentSequenceRef.val, timestamp: Date.now() });
+    } else if (parsed.type === 'assistant' && parsed.message?.content) {
+      for (const block of parsed.message.content) {
+        allBlocksRef.val.push(block);
+        currentSequenceRef.val++;
+        batcherRef.batcher.add(sessionId, conversationId, currentSequenceRef.val, block.type || 'assistant', block);
+        broadcastSync({ type: 'streaming_progress', sessionId, conversationId, block, blockRole: 'assistant', blockIndex: allBlocksRef.val.length - 1, seq: currentSequenceRef.val, timestamp: Date.now() });
+=======
 
     // Register session with file watcher as soon as we see the session_id.
     // This pre-maps claudeSessionId → (convId, dbSessionId) in JsonlParser before
@@ -32,15 +60,23 @@ export function createEventHandler({ queries, activeExecutions, broadcastSync, r
     // Rate-limit detection in assistant text blocks
     if (parsed.type === 'assistant' && parsed.message?.content) {
       for (const block of parsed.message.content) {
+>>>>>>> 6bfde951cbeb65ec72b73da9c23b9c8c0ba0bbc1
         if (block.type === 'text' && block.text) {
           const rateLimitMatch = block.text.match(/you'?ve hit your limit|rate limit exceeded/i);
           if (rateLimitMatch) {
             debugLog(`[rate-limit] Detected rate limit message in stream for conv ${conversationId}`);
             const retryAfterSec = parseRateLimitResetTime(block.text);
             const entry2 = activeExecutions.get(conversationId);
+<<<<<<< HEAD
+            if (entry2 && entry2.pid) { try { process.kill(entry2.pid); } catch (e) {} }
+            const existingCount = rateLimitState.get(conversationId)?.retryCount || 0;
+            if (existingCount >= 3) {
+              batcherRef.batcher.drain();
+=======
             if (entry2 && entry2.pid) { try { process.kill(entry2.pid); } catch (_) {} }
             const existingCount = rateLimitState.get(conversationId)?.retryCount || 0;
             if (existingCount >= 3) {
+>>>>>>> 6bfde951cbeb65ec72b73da9c23b9c8c0ba0bbc1
               activeExecutions.delete(conversationId);
               queries.setIsStreaming(conversationId, false);
               const errMsg = queries.createMessage(conversationId, 'assistant', `Error: Rate limit exceeded after ${existingCount + 1} attempts. Please try again later.`);
@@ -50,6 +86,10 @@ export function createEventHandler({ queries, activeExecutions, broadcastSync, r
             }
             rateLimitState.set(conversationId, { retryAt: Date.now() + (retryAfterSec * 1000), cooldownMs: retryAfterSec * 1000, retryCount: existingCount + 1, isStreamDetected: true });
             broadcastSync({ type: 'rate_limit_hit', sessionId, conversationId, retryAfterMs: retryAfterSec * 1000, retryAt: Date.now() + (retryAfterSec * 1000), retryCount: 1, timestamp: Date.now() });
+<<<<<<< HEAD
+            batcherRef.batcher.drain();
+=======
+>>>>>>> 6bfde951cbeb65ec72b73da9c23b9c8c0ba0bbc1
             activeExecutions.delete(conversationId);
             queries.setIsStreaming(conversationId, false);
             setTimeout(() => {
@@ -62,6 +102,61 @@ export function createEventHandler({ queries, activeExecutions, broadcastSync, r
           eagerTTS(block.text, conversationId, sessionId);
         }
       }
+<<<<<<< HEAD
+    } else if (parsed.type === 'user' && parsed.message?.content) {
+      for (const block of parsed.message.content) {
+        if (block.type === 'tool_result') {
+          const toolResultBlock = { type: 'tool_result', tool_use_id: block.tool_use_id, content: typeof block.content === 'string' ? block.content : JSON.stringify(block.content), is_error: block.is_error || false };
+          currentSequenceRef.val++;
+          batcherRef.batcher.add(sessionId, conversationId, currentSequenceRef.val, 'tool_result', toolResultBlock);
+          broadcastSync({ type: 'streaming_progress', sessionId, conversationId, block: toolResultBlock, blockRole: 'tool_result', blockIndex: allBlocksRef.val.length, seq: currentSequenceRef.val, timestamp: Date.now() });
+        }
+      }
+    } else if (parsed.type === 'result') {
+      const resultBlock = { type: 'result', subtype: parsed.subtype, duration_ms: parsed.duration_ms, total_cost_usd: parsed.total_cost_usd, num_turns: parsed.num_turns, is_error: parsed.is_error || false, result: parsed.result };
+      currentSequenceRef.val++;
+      batcherRef.batcher.add(sessionId, conversationId, currentSequenceRef.val, 'result', resultBlock);
+      broadcastSync({ type: 'streaming_progress', sessionId, conversationId, block: resultBlock, blockRole: 'result', blockIndex: allBlocksRef.val.length, isResult: true, seq: currentSequenceRef.val, timestamp: Date.now() });
+      if (parsed.result) {
+        const resultText = typeof parsed.result === 'string' ? parsed.result : JSON.stringify(parsed.result);
+        const rlMatch = resultText.match(/you'?ve hit your limit|rate limit exceeded/i);
+        if (rlMatch) {
+          debugLog(`[rate-limit] Detected rate limit in result for conv ${conversationId}`);
+          const retryAfterSec = parseRateLimitResetTime(resultText);
+          const entry3 = activeExecutions.get(conversationId);
+          if (entry3 && entry3.pid) { try { process.kill(entry3.pid); } catch (e) {} }
+          const existingCount2 = rateLimitState.get(conversationId)?.retryCount || 0;
+          if (existingCount2 >= 3) {
+            batcherRef.batcher.drain();
+            activeExecutions.delete(conversationId);
+            queries.setIsStreaming(conversationId, false);
+            const errMsg2 = queries.createMessage(conversationId, 'assistant', `Error: Rate limit exceeded after ${existingCount2 + 1} attempts. Please try again later.`);
+            broadcastSync({ type: 'message_created', conversationId, message: errMsg2, timestamp: Date.now() });
+            broadcastSync({ type: 'streaming_complete', sessionId, conversationId, interrupted: true, timestamp: Date.now() });
+            return;
+          }
+          rateLimitState.set(conversationId, { retryAt: Date.now() + (retryAfterSec * 1000), cooldownMs: retryAfterSec * 1000, retryCount: existingCount2 + 1, isStreamDetected: true });
+          broadcastSync({ type: 'rate_limit_hit', sessionId, conversationId, retryAfterMs: retryAfterSec * 1000, retryAt: Date.now() + (retryAfterSec * 1000), retryCount: existingCount2 + 1, timestamp: Date.now() });
+          batcherRef.batcher.drain();
+          activeExecutions.delete(conversationId);
+          queries.setIsStreaming(conversationId, false);
+          setTimeout(() => {
+            rateLimitState.delete(conversationId);
+            broadcastSync({ type: 'rate_limit_clear', conversationId, timestamp: Date.now() });
+            scheduleRetry(conversationId, messageId, content, agentId, model, subAgent);
+          }, retryAfterSec * 1000);
+          return;
+        }
+        if (resultText) eagerTTS(resultText, conversationId, sessionId);
+      }
+      if (parsed.result && allBlocksRef.val.length === 0) allBlocksRef.val.push({ type: 'text', text: String(parsed.result) });
+    } else if (parsed.type === 'tool_status') {
+      broadcastSync({ type: 'streaming_progress', sessionId, conversationId, block: { type: 'tool_status', tool_use_id: parsed.tool_use_id, status: parsed.status }, seq: currentSequenceRef.val, timestamp: Date.now() });
+    } else if (parsed.type === 'usage') {
+      broadcastSync({ type: 'streaming_progress', sessionId, conversationId, block: { type: 'usage', usage: parsed.usage }, seq: currentSequenceRef.val, timestamp: Date.now() });
+    } else if (parsed.type === 'plan') {
+      broadcastSync({ type: 'streaming_progress', sessionId, conversationId, block: { type: 'plan', entries: parsed.entries }, seq: currentSequenceRef.val, timestamp: Date.now() });
+=======
     }
 
     // Rate-limit detection in result blocks
@@ -94,6 +189,7 @@ export function createEventHandler({ queries, activeExecutions, broadcastSync, r
         return;
       }
       if (resultText) eagerTTS(resultText, conversationId, sessionId);
+>>>>>>> 6bfde951cbeb65ec72b73da9c23b9c8c0ba0bbc1
     }
   };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentgui",
-  "version": "1.0.855",
+  "version": "1.0.856",
   "description": "Multi-agent ACP client with real-time communication",
   "type": "module",
   "main": "electron/main.js",

package/static/css/main.css

@@ -1,3 +1,19 @@
+<<<<<<< HEAD
+    *, *::before, *::after { box-sizing: border-box; }
+
+    :root {
+      --color-primary: #3b82f6;
+      --color-primary-dark: #1e40af;
+      --color-bg-primary: #ffffff;
+      --color-bg-secondary: #f9fafb;
+      --color-bg-code: #f1f5f9;
+      --color-code-text: #1e293b;
+      --color-code-border: #cbd5e1;
+      --color-thinking-bg: #f5f3ff;
+      --color-text-primary: #111827;
+      --color-text-secondary: #6b7280;
+      --color-border: #e5e7eb;
+=======
     @import url('https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&display=swap');
 
     *, *::before, *::after { box-sizing: border-box; }
@@ -16,10 +32,30 @@
       --color-text-muted: #9ca3af;
       --color-border: #e5e7eb;
       --color-border-strong: #d1d5db;
+>>>>>>> 6bfde951cbeb65ec72b73da9c23b9c8c0ba0bbc1
       --color-success: #10b981;
       --color-error: #ef4444;
       --color-warning: #f59e0b;
       --color-info: #0891b2;
+<<<<<<< HEAD
+      --sidebar-width: 300px;
+      --header-height: 52px;
+      --msg-max-width: 800px;
+    }
+
+    html.dark {
+      --color-bg-primary: #1a1a1a;
+      --color-bg-secondary: #242424;
+      --color-text-primary: #e5e5e5;
+      --color-text-secondary: #a3a3a3;
+      --color-border: #333333;
+      --color-primary: #737373;
+      --color-primary-dark: #525252;
+      --color-bg-code: #1e293b;
+      --color-code-text: #e2e8f0;
+      --color-code-border: #334155;
+      --color-thinking-bg: #1e1a2e;
+=======
       --sidebar-width: 260px;
       --header-height: 48px;
       --msg-max-width: 800px;
@@ -51,17 +87,24 @@
       --shadow-sm: 0 1px 2px rgba(0,0,0,0.3);
       --shadow-md: 0 4px 12px rgba(0,0,0,0.4);
       --shadow-lg: 0 8px 24px rgba(0,0,0,0.5);
+>>>>>>> 6bfde951cbeb65ec72b73da9c23b9c8c0ba0bbc1
     }
 
     html, body {
       margin: 0;
       padding: 0;
       height: 100%;
+<<<<<<< HEAD
+      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, 'Helvetica Neue', Arial, sans-serif;
+      background-color: var(--color-bg-primary);
+      color: var(--color-text-primary);
+=======
       font-family: 'Inter', -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, 'Helvetica Neue', Arial, sans-serif;
       background-color: var(--color-bg-primary);
       color: var(--color-text-primary);
       -webkit-font-smoothing: antialiased;
       -moz-osx-font-smoothing: grayscale;
+>>>>>>> 6bfde951cbeb65ec72b73da9c23b9c8c0ba0bbc1
     }
 
     /* ===== ROOT LAYOUT: sidebar + main, full viewport ===== */
@@ -82,7 +125,10 @@
       display: flex;
       flex-direction: column;
       background-color: var(--color-bg-secondary);
+<<<<<<< HEAD
+=======
       border-right: 1px solid var(--color-border);
+>>>>>>> 6bfde951cbeb65ec72b73da9c23b9c8c0ba0bbc1
       overflow: hidden;
       transition: none !important;
       animation: none !important;
@@ -97,26 +143,51 @@
     }
 
     .sidebar-header {
+<<<<<<< HEAD
+      padding: 0.75rem 1rem;
+=======
       padding: 0.875rem 1rem 0.75rem;
+>>>>>>> 6bfde951cbeb65ec72b73da9c23b9c8c0ba0bbc1
       display: flex;
       justify-content: space-between;
       align-items: center;
       flex-shrink: 0;
       min-height: var(--header-height);
+<<<<<<< HEAD
+=======
       border-bottom: 1px solid var(--color-border);
+>>>>>>> 6bfde951cbeb65ec72b73da9c23b9c8c0ba0bbc1
     }
 
     .sidebar-header h2 {
       margin: 0;
+<<<<<<< HEAD
+      font-size: 0.875rem;
+      font-weight: 600;
+      text-transform: uppercase;
+      letter-spacing: 0.05em;
+      color: var(--color-text-secondary);
+=======
       font-size: 1rem;
       font-weight: 700;
       letter-spacing: -0.01em;
       color: var(--color-text-primary);
+>>>>>>> 6bfde951cbeb65ec72b73da9c23b9c8c0ba0bbc1
       white-space: nowrap;
       overflow: hidden;
     }
 
     .sidebar-new-btn {
+<<<<<<< HEAD
+      padding: 0.375rem 0.625rem;
+      font-size: 0.75rem;
+      background-color: var(--color-primary);
+      color: white;
+      border: none;
+      border-radius: 0.375rem;
+      cursor: pointer;
+      transition: background-color 0.2s;
+=======
       padding: 0.375rem 0.75rem;
       font-size: 0.8rem;
       font-weight: 600;
@@ -126,6 +197,7 @@
       border-radius: var(--radius-md);
       cursor: pointer;
       transition: background-color var(--transition-fast);
+>>>>>>> 6bfde951cbeb65ec72b73da9c23b9c8c0ba0bbc1
       white-space: nowrap;
       flex-shrink: 0;
     }
@@ -154,6 +226,8 @@
 
     .sidebar-clone-btn:hover { border-color: var(--color-primary); color: var(--color-primary); }
 
+<<<<<<< HEAD
+=======
     /* Sidebar overflow menu */
     .sidebar-overflow-btn {
       width: 28px;
@@ -205,6 +279,7 @@
     .sidebar-overflow-menu-item.danger { color: var(--color-error); }
     .sidebar-overflow-menu-wrapper { position: relative; }
 
+>>>>>>> 6bfde951cbeb65ec72b73da9c23b9c8c0ba0bbc1
     .clone-input-bar {
       display: flex;
       align-items: center;
@@ -285,6 +360,24 @@
     }
 
     .conversation-item {
+<<<<<<< HEAD
+      padding: 0.75rem 0.75rem;
+      margin: 0.125rem 0.5rem;
+      border-radius: 0.375rem;
+      cursor: pointer;
+      transition: background-color 0.15s;
+      border-left: 3px solid transparent;
+      user-select: none;
+    }
+
+    .conversation-item:hover { background-color: var(--color-bg-primary); }
+
+    .conversation-item.active {
+      background-color: var(--color-primary);
+      color: white;
+      border-left-color: var(--color-primary-dark);
+    }
+=======
       padding: 0.625rem 0.75rem;
       margin: 0.125rem 0.5rem;
       border-radius: var(--radius-md);
@@ -301,6 +394,7 @@
       color: var(--color-primary);
     }
     .conversation-item.active .conversation-item-meta { color: var(--color-primary); opacity: 0.7; }
+>>>>>>> 6bfde951cbeb65ec72b73da9c23b9c8c0ba0bbc1
 
     .conversation-item-title {
       font-weight: 500;
@@ -320,7 +414,11 @@
       text-overflow: ellipsis;
     }
 
+<<<<<<< HEAD
+    .conversation-item.active .conversation-item-meta { color: rgba(255,255,255,0.7); }
+=======
     /* conversation-item.active meta color handled in active block */
+>>>>>>> 6bfde951cbeb65ec72b73da9c23b9c8c0ba0bbc1
 
     .conversation-streaming-badge {
       display: inline-flex;
@@ -331,14 +429,22 @@
 
     .streaming-dot {
       display: inline-block;
+<<<<<<< HEAD
+      width: 0.5rem;
+      height: 0.5rem;
+=======
       width: 0.4rem;
       height: 0.4rem;
+>>>>>>> 6bfde951cbeb65ec72b73da9c23b9c8c0ba0bbc1
       border-radius: 50%;
       background-color: var(--color-success);
       animation: pulse 1.5s ease-in-out infinite;
     }
 
     .conversation-item.active .streaming-dot {
+<<<<<<< HEAD
+      background-color: #fff;
+=======
       background-color: var(--color-success);
     }
 
@@ -362,6 +468,7 @@
     @keyframes typing-bounce {
       0%, 80%, 100% { transform: scale(0.7); opacity: 0.5; }
       40% { transform: scale(1); opacity: 1; }
+>>>>>>> 6bfde951cbeb65ec72b73da9c23b9c8c0ba0bbc1
     }
 
     .conversation-item {
@@ -377,6 +484,8 @@
       overflow: hidden;
     }
 
+<<<<<<< HEAD
+=======
     /* Date group headers in sidebar */
     .conv-date-group-header {
       padding: 0.5rem 1.25rem 0.25rem;
@@ -402,6 +511,7 @@
       margin-right: 0.375rem;
     }
 
+>>>>>>> 6bfde951cbeb65ec72b73da9c23b9c8c0ba0bbc1
     .conversation-item.pinned { cursor: grab; }
     .conversation-item.pinned:active { cursor: grabbing; }
     .conversation-item-checkbox {
@@ -459,16 +569,25 @@
     .conversation-item.active .conversation-item-delete,
     .conversation-item.active .conversation-item-archive,
     .conversation-item.active .conversation-item-export {
+<<<<<<< HEAD
+      color: rgba(255,255,255,0.8);
+=======
       color: var(--color-primary);
       opacity: 0.7;
+>>>>>>> 6bfde951cbeb65ec72b73da9c23b9c8c0ba0bbc1
     }
 
     .conversation-item.active .conversation-item-delete:hover,
     .conversation-item.active .conversation-item-archive:hover,
     .conversation-item.active .conversation-item-export:hover {
+<<<<<<< HEAD
+      background-color: rgba(255,255,255,0.2);
+      color: white;
+=======
       background-color: rgba(var(--color-primary-rgb),0.15);
       color: var(--color-primary);
       opacity: 1;
+>>>>>>> 6bfde951cbeb65ec72b73da9c23b9c8c0ba0bbc1
     }
 
     .sidebar-empty {
@@ -494,11 +613,18 @@
       align-items: center;
       gap: 0.75rem;
       padding: 0 1rem;
+<<<<<<< HEAD
+      height: var(--header-height);
+      min-height: var(--header-height);
+      flex-shrink: 0;
+      background-color: var(--color-bg-secondary);
+=======
       height: 48px;
       min-height: 48px;
       flex-shrink: 0;
       background: var(--color-bg-primary);
       border-bottom: 1px solid var(--color-border);
+>>>>>>> 6bfde951cbeb65ec72b73da9c23b9c8c0ba0bbc1
     }
 
     .sidebar-toggle-btn {
@@ -528,9 +654,14 @@
     }
 
     .header-title {
+<<<<<<< HEAD
+      font-size: 1.125rem;
+      font-weight: 600;
+=======
       font-size: 0.9375rem;
       font-weight: 600;
       letter-spacing: -0.01em;
+>>>>>>> 6bfde951cbeb65ec72b73da9c23b9c8c0ba0bbc1
       margin: 0;
       flex: 1;
       min-width: 0;
@@ -693,6 +824,8 @@
       flex-direction: column;
     }
 
+<<<<<<< HEAD
+=======
     /* ===== MESSAGE BUBBLES ===== */
     .message-user-bubble {
       display: flex;
@@ -771,6 +904,7 @@
     .message-action-btn svg { width: 13px; height: 13px; }
     .message-wrapper { position: relative; }
 
+>>>>>>> 6bfde951cbeb65ec72b73da9c23b9c8c0ba0bbc1
     #output {
       display: flex;
       flex-direction: column;
@@ -1017,6 +1151,15 @@
       white-space: nowrap;
     }
 
+<<<<<<< HEAD
+    /* --- Input area: fixed at bottom --- */
+    .input-section {
+      flex-shrink: 0;
+      background-color: var(--color-bg-primary);
+      padding: 0.75rem 1rem;
+    }
+
+=======
     /* ===== INPUT AREA REDESIGN ===== */
     .input-section {
       flex-shrink: 0;
@@ -1139,6 +1282,7 @@
     .input-send-btn:disabled { opacity: 0.4; cursor: not-allowed; transform: none; }
     .input-send-btn svg { width: 16px; height: 16px; }
 
+>>>>>>> 6bfde951cbeb65ec72b73da9c23b9c8c0ba0bbc1
     .input-wrapper {
       max-width: var(--msg-max-width);
       margin: 0 auto;
@@ -1401,9 +1545,15 @@
     .permanently-expanded > summary::marker { display: none; content: ''; }
 
     /* ===== Folder Browser Modal ===== */
+<<<<<<< HEAD
+    .folder-modal-overlay { display:none; position:fixed; top:0; left:0; width:100%; height:100%; background:rgba(0,0,0,0.5); z-index:2000; align-items:center; justify-content:center; }
+    .folder-modal-overlay.visible { display:flex; }
+    .folder-modal { background:var(--color-bg-primary); border-radius:0.5rem; width:500px; max-width:90vw; max-height:80vh; display:flex; flex-direction:column; box-shadow:0 20px 60px rgba(0,0,0,0.3); }
+=======
     .folder-modal-overlay { display:none; position:fixed; top:0; left:0; width:100%; height:100%; background:rgba(0,0,0,0.5); backdrop-filter:blur(8px); -webkit-backdrop-filter:blur(8px); z-index:2000; align-items:center; justify-content:center; transition:opacity 0.15s ease; animation:fadeIn 0.15s ease; }
     .folder-modal-overlay.visible { display:flex; }
     .folder-modal { background:var(--color-bg-primary); border-radius:var(--radius-xl); width:500px; max-width:90vw; max-height:80vh; display:flex; flex-direction:column; box-shadow:var(--shadow-lg); animation:scaleIn 0.15s ease; }
+>>>>>>> 6bfde951cbeb65ec72b73da9c23b9c8c0ba0bbc1
     .folder-modal-header { padding:1rem; display:flex; justify-content:space-between; align-items:center; flex-shrink:0; }
     .folder-modal-header h3 { margin:0; font-size:1rem; font-weight:600; }
     .folder-modal-close { background:none; border:none; font-size:1.25rem; cursor:pointer; color:var(--color-text-secondary); padding:0.25rem; line-height:1; }
@@ -1423,6 +1573,8 @@
     .folder-modal-footer { padding:0.75rem 1rem; display:flex; justify-content:flex-end; gap:0.5rem; flex-shrink:0; }
     .folder-modal-footer .btn { padding:0.5rem 1rem; font-size:0.8rem; }
 
+<<<<<<< HEAD
+=======
     @keyframes fadeIn {
       from { opacity: 0; }
       to { opacity: 1; }
@@ -1432,6 +1584,7 @@
       to { opacity: 1; transform: scale(1); }
     }
 
+>>>>>>> 6bfde951cbeb65ec72b73da9c23b9c8c0ba0bbc1
     .btn { padding:0.5rem 1rem; border:none; border-radius:0.375rem; font-weight:500; cursor:pointer; transition:all 0.15s; font-size:0.875rem; }
     .btn-primary { background-color:var(--color-primary); color:white; }
     .btn-primary:hover:not(:disabled) { background-color:var(--color-primary-dark); }
@@ -1554,6 +1707,8 @@
       scrollbar-color: #475569 transparent;
     }
 
+<<<<<<< HEAD
+=======
     /* Modern thin scrollbars */
     .sidebar-list, #output-scroll, .message-scroll-area {
       scrollbar-width: thin;
@@ -1563,6 +1718,7 @@
       scrollbar-color: var(--color-border-strong) transparent;
     }
 
+>>>>>>> 6bfde951cbeb65ec72b73da9c23b9c8c0ba0bbc1
     .voice-mic-btn {
       position: absolute;
       top: 4px;
@@ -1818,6 +1974,8 @@
     .icon-sm svg { width: 1rem !important; height: 1rem !important; }
     .icon-lg svg { width: 1.5rem !important; height: 1.5rem !important; }
 
+<<<<<<< HEAD
+=======
     /* ===== STREAMING STATUS BAR ===== */
     .streaming-status-bar {
       max-width: var(--msg-max-width);
@@ -1942,6 +2100,7 @@
       line-height: 1.4;
     }
 
+>>>>>>> 6bfde951cbeb65ec72b73da9c23b9c8c0ba0bbc1
     /* ===== STREAMING BLOCK STYLES ===== */
     .block-text {
       margin-bottom: 0;

package/static/js/client.js

@@ -1,8 +1,11 @@
+<<<<<<< HEAD
+=======
 /**
  * AgentGUI Client
  * Main application orchestrator that integrates WebSocket, event processing,
  * and streaming renderer for real-time Claude Code execution visualization
  */
+>>>>>>> 6bfde951cbeb65ec72b73da9c23b9c8c0ba0bbc1
 
 class AgentGUIClient {
   constructor(config = {}) {
@@ -14,13 +17,19 @@ class AgentGUIClient {
       ...config
     };
 
+<<<<<<< HEAD
+=======
     // Initialize components - reuse global wsManager/wsClient if available
+>>>>>>> 6bfde951cbeb65ec72b73da9c23b9c8c0ba0bbc1
     this.renderer = new StreamingRenderer(config.renderer || {});
     this.wsManager = window.wsManager || new WebSocketManager(config.websocket || {});
     if (!window.wsManager) window.wsManager = this.wsManager;
     this.eventProcessor = new EventProcessor(config.eventProcessor || {});
 
+<<<<<<< HEAD
+=======
     // Application state
+>>>>>>> 6bfde951cbeb65ec72b73da9c23b9c8c0ba0bbc1
     this.state = {
       isInitialized: false,
       currentSession: null,
@@ -31,6 +40,21 @@ class AgentGUIClient {
       agents: []
     };
 
+<<<<<<< HEAD
+    this.conversationCache = new Map();
+    this.MAX_CACHE_SIZE = 10;
+
+    this.conversationListCache = {
+      data: [],
+      timestamp: 0,
+      ttl: 30000
+    };
+
+    this.draftPrompts = new Map();
+
+    this.eventHandlers = {};
+
+=======
     // Conversation DOM cache: store rendered DOM + scroll position per conversationId
     this.conversationCache = new Map();
     this.MAX_CACHE_SIZE = 10;
@@ -49,6 +73,7 @@ class AgentGUIClient {
     this.eventHandlers = {};
 
     // UI state
+>>>>>>> 6bfde951cbeb65ec72b73da9c23b9c8c0ba0bbc1
     this.ui = {
       statusIndicator: null,
       messageInput: null,
@@ -62,6 +87,17 @@ class AgentGUIClient {
     this._isLoadingConversation = false;
     this._modelCache = new Map();
 
+<<<<<<< HEAD
+    this._renderedSeqs = {};
+    this._inflightRequests = new Map();
+    this._previousConvAbort = null;
+
+    this._bgCache = new Map();
+    this.BG_CACHE_MAX = 50;
+
+    this._loadInProgress = {};
+    this._currentRequestId = 0;
+=======
     this._renderedSeqs = {}; // plain object: sessionId → Set<number>
     this._inflightRequests = new Map();
     this._previousConvAbort = null;
@@ -74,6 +110,7 @@ class AgentGUIClient {
     // PHASE 2: Request Lifetime Tracking
     this._loadInProgress = {}; // { [conversationId]: { requestId, abortController, timestamp, prevConversationId } }
     this._currentRequestId = 0; // Auto-incrementing request counter
+>>>>>>> 6bfde951cbeb65ec72b73da9c23b9c8c0ba0bbc1
 
 
     this._scrollTarget = 0;
@@ -85,7 +122,10 @@ class AgentGUIClient {
     this._lastSendTime = 0;
     this._countdownTimer = null;
 
+<<<<<<< HEAD
+=======
     // Router state
+>>>>>>> 6bfde951cbeb65ec72b73da9c23b9c8c0ba0bbc1
     this.routerState = {
       currentConversationId: null,
       currentSessionId: null
@@ -96,17 +136,25 @@ class AgentGUIClient {
 
   _dbg(...args) { if (this._debug) console.log('[AgentGUI]', ...args); }
 
+<<<<<<< HEAD
+=======
   /**
    * Initialize the client
    */
+>>>>>>> 6bfde951cbeb65ec72b73da9c23b9c8c0ba0bbc1
   async init() {
     try {
       this._dbg('Initializing AgentGUI client');
 
+<<<<<<< HEAD
+      const wsReady = this.config.autoConnect ? this.connectWebSocket() : Promise.resolve();
+
+=======
       // Start WebSocket connection immediately (don't wait for UI setup)
       const wsReady = this.config.autoConnect ? this.connectWebSocket() : Promise.resolve();
 
       // Initialize renderer and UI in parallel with WS connection
+>>>>>>> 6bfde951cbeb65ec72b73da9c23b9c8c0ba0bbc1
       this.renderer.init(this.config.outputContainerId, this.config.scrollContainerId);
 
       if (typeof ImageLoader !== 'undefined') {
@@ -117,7 +165,10 @@ class AgentGUIClient {
       this.setupRendererListeners();
       this.setupUI();
 
+<<<<<<< HEAD
+=======
       // Wait for WS, then load data in parallel
+>>>>>>> 6bfde951cbeb65ec72b73da9c23b9c8c0ba0bbc1
       await wsReady;
       await Promise.all([
         this.loadAgents(),
@@ -125,10 +176,15 @@ class AgentGUIClient {
         this.checkSpeechStatus()
       ]);
 
+<<<<<<< HEAD
+      this.enableControls();
+
+=======
       // Enable controls for initial interaction
       this.enableControls();
 
       // Restore state from URL on page load
+>>>>>>> 6bfde951cbeb65ec72b73da9c23b9c8c0ba0bbc1
       this.restoreStateFromUrl();
 
       this.state.isInitialized = true;
@@ -144,6 +200,8 @@ class AgentGUIClient {
     }
   }
 
+<<<<<<< HEAD
+=======
   /**
    * Setup WebSocket event listeners
    */
@@ -3552,6 +3610,7 @@ class AgentGUIClient {
     this.wsManager.destroy();
     this.eventHandlers = {};
   }
+>>>>>>> 6bfde951cbeb65ec72b73da9c23b9c8c0ba0bbc1
 }
 
 window.__convPerfMetrics = () => {
@@ -3559,6 +3618,11 @@ window.__convPerfMetrics = () => {
   return entries.map(e => ({ name: e.name, ms: Math.round(e.duration) }));
 };
 
+<<<<<<< HEAD
+let agentGUIClient = null;
+
+document.addEventListener('DOMContentLoaded', async () => {
+=======
 function updateWelcomeScreen() {
   const welcomeScreen = document.getElementById('welcomeScreen');
   const outputScroll = document.getElementById('output-scroll');
@@ -3615,6 +3679,7 @@ let agentGUIClient = null;
 // Initialize on DOM ready
 document.addEventListener('DOMContentLoaded', async () => {
   updateWelcomeScreen();
+>>>>>>> 6bfde951cbeb65ec72b73da9c23b9c8c0ba0bbc1
   try {
     agentGUIClient = new AgentGUIClient();
     window.agentGuiClient = agentGUIClient;
@@ -3625,7 +3690,10 @@ document.addEventListener('DOMContentLoaded', async () => {
   }
 });
 
+<<<<<<< HEAD
+=======
 // Export for testing
+>>>>>>> 6bfde951cbeb65ec72b73da9c23b9c8c0ba0bbc1
 if (typeof module !== 'undefined' && module.exports) {
   module.exports = AgentGUIClient;
 }

package/static/js/conversations.js

@@ -1,3 +1,5 @@
+<<<<<<< HEAD
+=======
 /**
  * Conversations Module
  * Manages conversation list sidebar with real-time updates
@@ -23,6 +25,7 @@ function getAgentColor(agentId) {
   return key ? AGENT_COLORS[key] : AGENT_COLORS.default;
 }
 
+>>>>>>> 6bfde951cbeb65ec72b73da9c23b9c8c0ba0bbc1
 function pathSplit(p) {
   return p.split(/[\/\\]/).filter(Boolean);
 }
@@ -134,6 +137,8 @@ class ConversationManager {
     return ' (' + model.replace(/^claude-/i, '').replace(/-\d{8,}.*$/, '').replace(/-/g, ' ') + ')';
   }
 
+<<<<<<< HEAD
+=======
   setupDelegatedListeners() {
     let draggedId = null;
     this.listEl.addEventListener('dragstart', (e) => {
@@ -801,11 +806,14 @@ class ConversationManager {
     });
   }
 
+>>>>>>> 6bfde951cbeb65ec72b73da9c23b9c8c0ba0bbc1
   escapeHtml(text) {
     return window._escHtml(text);
   }
 }
 
+<<<<<<< HEAD
+=======
 if (document.readyState === 'loading') {
   document.addEventListener('DOMContentLoaded', () => {
     window.conversationManager = new ConversationManager();
@@ -813,3 +821,4 @@ if (document.readyState === 'loading') {
 } else {
   window.conversationManager = new ConversationManager();
 }
+>>>>>>> 6bfde951cbeb65ec72b73da9c23b9c8c0ba0bbc1