nothumanallowed 10.9.1 → 11.0.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nothumanallowed",
-  "version": "10.9.1",
+  "version": "11.0.1",
   "description": "NotHumanAllowed — 38 AI agents, 53 tools. Email, calendar, browser automation, screen capture, canvas, cron/heartbeat, GitHub, Notion, Slack, voice chat, 28 languages. Zero-dependency CLI.",
   "type": "module",
   "bin": {

package/src/commands/collab.mjs

@@ -121,7 +121,14 @@ function getOrCreateIdentity() {
   let id = loadIdentity();
   if (!id) {
     id = generateKeypair();
-    id.displayName = `Agent-${id.fingerprint.slice(0, 6)}`;
+    // Use profile name from config if available, otherwise generate default
+    try {
+      const { loadConfig } = await import('../config.mjs');
+      const cfg = loadConfig();
+      id.displayName = cfg.profile?.name || `Agent-${id.fingerprint.slice(0, 6)}`;
+    } catch {
+      id.displayName = `Agent-${id.fingerprint.slice(0, 6)}`;
+    }
     id.createdAt = new Date().toISOString();
     saveIdentity(id);
     info(`Identity created: ${id.fingerprint}`);

package/src/commands/ui.mjs

@@ -38,6 +38,11 @@ import {
   setActiveId,
   getHistory,
   addMessages,
+  retryMessage,
+  addRetryResponse,
+  editMessage,
+  navigateFork,
+  getForkInfo,
   exportAsMarkdown,
   exportAsJson,
   migrateOldHistory,
@@ -1430,6 +1435,61 @@ export async function cmdUI(args) {
         return;
       }
 
+      // ── Fork/Retry/Navigate API ────────────────────────────────────────
+
+      // POST /api/conversations/:id/retry — retry a message (create fork)
+      if (method === 'POST' && pathname.match(/^\/api\/conversations\/[a-z0-9-]+\/retry$/)) {
+        const convId = pathname.split('/')[3];
+        const body = await parseBody(req);
+        const conv = loadConversation(convId);
+        if (!conv) { sendJSON(res, 404, { error: 'Not found' }); logRequest(method, pathname, 404, Date.now() - start); return; }
+        const userNodeId = retryMessage(conv, body.assistantNodeId);
+        if (!userNodeId) { sendJSON(res, 400, { error: 'Invalid message' }); logRequest(method, pathname, 400, Date.now() - start); return; }
+        sendJSON(res, 200, { userNodeId, userContent: conv.tree?.[userNodeId]?.content });
+        logRequest(method, pathname, 200, Date.now() - start);
+        return;
+      }
+
+      // POST /api/conversations/:id/retry-response — add the retry result
+      if (method === 'POST' && pathname.match(/^\/api\/conversations\/[a-z0-9-]+\/retry-response$/)) {
+        const convId = pathname.split('/')[3];
+        const body = await parseBody(req);
+        const conv = loadConversation(convId);
+        if (!conv) { sendJSON(res, 404, { error: 'Not found' }); logRequest(method, pathname, 404, Date.now() - start); return; }
+        const newId = addRetryResponse(conv, body.userNodeId, body.content);
+        sendJSON(res, 200, { nodeId: newId, messages: getHistory(conv) });
+        logRequest(method, pathname, 200, Date.now() - start);
+        return;
+      }
+
+      // POST /api/conversations/:id/navigate — switch fork direction
+      if (method === 'POST' && pathname.match(/^\/api\/conversations\/[a-z0-9-]+\/navigate$/)) {
+        const convId = pathname.split('/')[3];
+        const body = await parseBody(req);
+        const conv = loadConversation(convId);
+        if (!conv) { sendJSON(res, 404, { error: 'Not found' }); logRequest(method, pathname, 404, Date.now() - start); return; }
+        const ok = navigateFork(conv, body.nodeId, body.direction);
+        sendJSON(res, 200, { ok, messages: getHistory(conv) });
+        logRequest(method, pathname, 200, Date.now() - start);
+        return;
+      }
+
+      // GET /api/conversations/:id/forks — get fork info for all messages
+      if (method === 'GET' && pathname.match(/^\/api\/conversations\/[a-z0-9-]+\/forks$/)) {
+        const convId = pathname.split('/')[3];
+        const conv = loadConversation(convId);
+        if (!conv) { sendJSON(res, 404, { error: 'Not found' }); logRequest(method, pathname, 404, Date.now() - start); return; }
+        const messages = getHistory(conv);
+        const forks = {};
+        for (const msg of messages) {
+          const info = getForkInfo(conv, msg.id);
+          if (info) forks[msg.id] = info;
+        }
+        sendJSON(res, 200, { forks });
+        logRequest(method, pathname, 200, Date.now() - start);
+        return;
+      }
+
       // ── Streaming Chat API ─────────────────────────────────────────────
 
       // POST /api/chat/stream — SSE streaming chat with conversation persistence
@@ -1720,7 +1780,20 @@ export async function cmdUI(args) {
               }
               const conv = loadConversation(convId);
               if (conv) {
-                addMessages(conv, msg, persistedResponse);
+                if (body.isRetry) {
+                  // Retry: find the user node and add a new sibling response (fork)
+                  const activePath = getHistory(conv);
+                  // Find the last user message that matches
+                  const userNodes = activePath.filter(m => m.role === 'user' && m.content === msg);
+                  const userNode = userNodes[userNodes.length - 1];
+                  if (userNode && userNode.id) {
+                    addRetryResponse(conv, userNode.id, persistedResponse);
+                  } else {
+                    addMessages(conv, msg, persistedResponse);
+                  }
+                } else {
+                  addMessages(conv, msg, persistedResponse);
+                }
               }
             } catch {}
           }

package/src/constants.mjs

@@ -5,7 +5,7 @@ import { fileURLToPath } from 'url';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
-export const VERSION = '10.9.1';
+export const VERSION = '11.0.1';
 export const BASE_URL = 'https://nothumanallowed.com/cli';
 export const API_BASE = 'https://nothumanallowed.com/api/v1';
 

package/src/services/conversations.mjs

@@ -1,8 +1,15 @@
 /**
- * Multi-conversation manager for NHA Chat.
+ * Multi-conversation manager for NHA Chat — with fork/branching support.
  *
  * Stores conversations in ~/.nha/conversations/ as JSON files.
- * Each conversation has an ID, auto-generated title, and message history.
+ * Each conversation has an ID, auto-generated title, and message tree.
+ *
+ * Message tree structure:
+ *   Each message node: { id, role, content, parentId, children: [id, id, ...], activeChild: 0 }
+ *   The "active path" follows activeChild at each fork point.
+ *   Retry creates a new sibling (branch), not a replacement.
+ *
+ * Backward compatible: old conversations with flat messages[] are auto-upgraded.
  *
  * Zero npm dependencies.
  */
@@ -31,10 +38,10 @@ function generateId() {
   return crypto.randomUUID().slice(0, 8);
 }
 
-/**
- * Auto-generate a title from the first user message.
- * Takes the first ~50 chars, trims to last word boundary.
- */
+function msgId() {
+  return crypto.randomUUID().slice(0, 12);
+}
+
 function autoTitle(firstMessage) {
   if (!firstMessage) return 'New Chat';
   let title = firstMessage.replace(/\s+/g, ' ').trim();
@@ -47,12 +54,139 @@ function autoTitle(firstMessage) {
   return title;
 }
 
-// ── CRUD ─────────────────────────────────────────────────────────────────────
+// ── Tree Helpers ─────────────────────────────────────────────────────────────
+
+/**
+ * Upgrade a flat messages array to tree format.
+ * Each message gets an id, parentId, children[].
+ */
+function upgradeToTree(conv) {
+  if (conv.tree) return; // already upgraded
+
+  const nodes = {};
+  const messages = conv.messages || [];
+  let prevId = null;
+
+  for (let i = 0; i < messages.length; i++) {
+    const msg = messages[i];
+    const id = msg.id || msgId();
+    const node = {
+      id,
+      role: msg.role,
+      content: msg.content,
+      parentId: prevId,
+      children: [],
+      activeChild: 0,
+    };
+    nodes[id] = node;
+    if (prevId && nodes[prevId]) {
+      nodes[prevId].children.push(id);
+    }
+    prevId = id;
+  }
+
+  conv.tree = nodes;
+  conv.rootId = messages.length > 0 ? Object.keys(nodes)[0] : null;
+}
+
+/**
+ * Get the active message path (following activeChild at each fork).
+ * Returns flat array of {role, content, id} for the LLM.
+ */
+function getActivePath(conv) {
+  upgradeToTree(conv);
+  if (!conv.tree || !conv.rootId) return [];
+
+  const path = [];
+  let currentId = conv.rootId;
+
+  while (currentId) {
+    const node = conv.tree[currentId];
+    if (!node) break;
+    path.push({ id: node.id, role: node.role, content: node.content });
+    if (node.children.length === 0) break;
+    const nextIdx = Math.min(node.activeChild || 0, node.children.length - 1);
+    currentId = node.children[nextIdx];
+  }
+
+  return path;
+}
+
+/**
+ * Add a message to the tree. Returns the new node ID.
+ * parentId = null means append to the end of the active path.
+ */
+function addNode(conv, role, content, parentId = null) {
+  upgradeToTree(conv);
+  if (!conv.tree) conv.tree = {};
+
+  const id = msgId();
+
+  // Find parent: if not specified, use the last node in active path
+  if (!parentId) {
+    const activePath = getActivePath(conv);
+    if (activePath.length > 0) {
+      parentId = activePath[activePath.length - 1].id;
+    }
+  }
+
+  const node = { id, role, content, parentId, children: [], activeChild: 0 };
+  conv.tree[id] = node;
+
+  if (parentId && conv.tree[parentId]) {
+    conv.tree[parentId].children.push(id);
+    // Set this as the active child
+    conv.tree[parentId].activeChild = conv.tree[parentId].children.length - 1;
+  }
+
+  if (!conv.rootId) conv.rootId = id;
+
+  return id;
+}
+
+/**
+ * Get fork info for a specific node: how many siblings and which is active.
+ * Returns { total, current, siblingIds } or null if no fork.
+ */
+function getForkInfo(conv, nodeId) {
+  upgradeToTree(conv);
+  const node = conv.tree?.[nodeId];
+  if (!node || !node.parentId) return null;
+
+  const parent = conv.tree[node.parentId];
+  if (!parent || parent.children.length <= 1) return null;
+
+  const current = parent.children.indexOf(nodeId);
+  return {
+    total: parent.children.length,
+    current: current,
+    siblingIds: parent.children,
+    parentId: parent.id,
+  };
+}
 
 /**
- * Create a new conversation and set it as active.
- * @returns {{ id: string, title: string, messages: Array, createdAt: string, updatedAt: string }}
+ * Switch to a different sibling at a fork point.
+ * direction: -1 (previous) or +1 (next)
  */
+function switchFork(conv, nodeId, direction) {
+  upgradeToTree(conv);
+  const node = conv.tree?.[nodeId];
+  if (!node || !node.parentId) return false;
+
+  const parent = conv.tree[node.parentId];
+  if (!parent || parent.children.length <= 1) return false;
+
+  const currentIdx = parent.children.indexOf(nodeId);
+  const newIdx = currentIdx + direction;
+  if (newIdx < 0 || newIdx >= parent.children.length) return false;
+
+  parent.activeChild = newIdx;
+  return true;
+}
+
+// ── CRUD ─────────────────────────────────────────────────────────────────────
+
 export function createConversation(title = '') {
   ensureDir();
   const id = generateId();
@@ -61,6 +195,8 @@ export function createConversation(title = '') {
     id,
     title: title || 'New Chat',
     messages: [],
+    tree: {},
+    rootId: null,
     createdAt: now,
     updatedAt: now,
   };
@@ -69,48 +205,37 @@ export function createConversation(title = '') {
   return conv;
 }
 
-/**
- * Load a conversation by ID.
- * @returns {object|null}
- */
 export function loadConversation(id) {
   try {
     const data = fs.readFileSync(convPath(id), 'utf-8');
-    return JSON.parse(data);
+    const conv = JSON.parse(data);
+    // Auto-upgrade old format
+    if (!conv.tree && conv.messages && conv.messages.length > 0) {
+      upgradeToTree(conv);
+      saveConversation(conv);
+    }
+    return conv;
   } catch {
     return null;
   }
 }
 
-/**
- * Save a conversation (full overwrite).
- */
 export function saveConversation(conv) {
   ensureDir();
   conv.updatedAt = new Date().toISOString();
+  // Keep messages[] in sync with active path for backward compat
+  conv.messages = getActivePath(conv);
   fs.writeFileSync(convPath(conv.id), JSON.stringify(conv, null, 2) + '\n', 'utf-8');
 }
 
-/**
- * Delete a conversation by ID.
- * If it was active, clears active state.
- * @returns {boolean} true if deleted
- */
 export function deleteConversation(id) {
   const filePath = convPath(id);
   if (!fs.existsSync(filePath)) return false;
   fs.unlinkSync(filePath);
-  if (getActiveId() === id) {
-    clearActiveId();
-  }
+  if (getActiveId() === id) clearActiveId();
   return true;
 }
 
-/**
- * List all conversations, sorted by updatedAt (newest first).
- * Returns summary objects (no messages).
- * @returns {Array<{ id: string, title: string, messageCount: number, createdAt: string, updatedAt: string }>}
- */
 export function listConversations() {
   ensureDir();
   const files = fs.readdirSync(CONVERSATIONS_DIR)
@@ -127,12 +252,11 @@ export function listConversations() {
         createdAt: data.createdAt,
         updatedAt: data.updatedAt,
       });
-    } catch { /* skip corrupt files */ }
+    } catch {}
   }
 
   convs.sort((a, b) => new Date(b.updatedAt) - new Date(a.updatedAt));
 
-  // Auto-prune old conversations beyond limit
   if (convs.length > MAX_CONVERSATIONS) {
     for (const old of convs.slice(MAX_CONVERSATIONS)) {
       try { fs.unlinkSync(convPath(old.id)); } catch {}
@@ -145,38 +269,19 @@ export function listConversations() {
 
 // ── Active Conversation ──────────────────────────────────────────────────────
 
-/**
- * Get the active conversation ID.
- * @returns {string|null}
- */
 export function getActiveId() {
-  try {
-    return fs.readFileSync(ACTIVE_FILE, 'utf-8').trim() || null;
-  } catch {
-    return null;
-  }
+  try { return fs.readFileSync(ACTIVE_FILE, 'utf-8').trim() || null; } catch { return null; }
 }
 
-/**
- * Set the active conversation ID.
- */
 export function setActiveId(id) {
   ensureDir();
   fs.writeFileSync(ACTIVE_FILE, id, 'utf-8');
 }
 
-/**
- * Clear the active conversation.
- */
-export function clearActiveId() {
+function clearActiveId() {
   try { fs.unlinkSync(ACTIVE_FILE); } catch {}
 }
 
-/**
- * Get or create the active conversation.
- * If none exists, creates a new one.
- * @returns {object} conversation object
- */
 export function getOrCreateActive() {
   const activeId = getActiveId();
   if (activeId) {
@@ -188,77 +293,121 @@ export function getOrCreateActive() {
 
 /**
  * Add a message pair (user + assistant) to a conversation.
- * Auto-titles the conversation from the first user message.
+ * Creates tree nodes. Auto-titles from first user message.
  */
 export function addMessages(conv, userContent, assistantContent) {
-  conv.messages.push({ role: 'user', content: userContent });
-  conv.messages.push({ role: 'assistant', content: assistantContent });
+  const userId = addNode(conv, 'user', userContent);
+  const assistantId = addNode(conv, 'assistant', assistantContent, userId);
 
-  // Auto-title from first user message
-  if (conv.title === 'New Chat' && conv.messages.length === 2) {
+  if (conv.title === 'New Chat' && Object.keys(conv.tree || {}).length <= 2) {
     conv.title = autoTitle(userContent);
   }
 
   saveConversation(conv);
+  return { userId, assistantId };
 }
 
 /**
- * Get the message history from a conversation, capped at maxTurns pairs.
- * @returns {Array<{role: string, content: string}>}
+ * Retry: add a NEW assistant response as a sibling of the existing one.
+ * This creates a fork — the user can navigate between variants.
+ * Returns the ID of the user message (parent) so the caller knows which message to re-send.
  */
-export function getHistory(conv, maxTurns = 20) {
-  const messages = conv.messages || [];
-  return messages.slice(-(maxTurns * 2));
+export function retryMessage(conv, assistantNodeId) {
+  upgradeToTree(conv);
+  const node = conv.tree?.[assistantNodeId];
+  if (!node || node.role !== 'assistant') return null;
+
+  // The parent is the user message
+  const parentId = node.parentId;
+  if (!parentId) return null;
+
+  // Return the parent (user) ID — the caller will generate a new response
+  // and call addRetryResponse() with the result
+  return parentId;
 }
 
-// ── Export ────────────────────────────────────────────────────────────────────
+/**
+ * Add a retry response as a new sibling branch.
+ * @param {object} conv - conversation
+ * @param {string} userNodeId - the user message ID (parent)
+ * @param {string} newContent - the new assistant response
+ * @returns {string} the new assistant node ID
+ */
+export function addRetryResponse(conv, userNodeId, newContent) {
+  const newId = addNode(conv, 'assistant', newContent, userNodeId);
+  saveConversation(conv);
+  return newId;
+}
 
 /**
- * Export conversation as Markdown.
+ * Edit a user message: creates a new branch from the parent of the edited message.
+ * Returns the new user node ID.
  */
+export function editMessage(conv, userNodeId, newContent) {
+  upgradeToTree(conv);
+  const node = conv.tree?.[userNodeId];
+  if (!node || node.role !== 'user') return null;
+
+  const parentId = node.parentId; // could be null (first message) or previous assistant
+
+  const newId = addNode(conv, 'user', newContent, parentId);
+  saveConversation(conv);
+  return newId;
+}
+
+/**
+ * Navigate fork: switch to previous/next sibling at a fork point.
+ */
+export function navigateFork(conv, nodeId, direction) {
+  const result = switchFork(conv, nodeId, direction);
+  if (result) saveConversation(conv);
+  return result;
+}
+
+/**
+ * Get fork info for a node (for UI rendering).
+ */
+export { getForkInfo };
+
+/**
+ * Get the active path as flat messages array.
+ */
+export function getHistory(conv, maxTurns = 20) {
+  const activePath = getActivePath(conv);
+  return activePath.slice(-(maxTurns * 2));
+}
+
+// ── Export ────────────────────────────────────────────────────────────────────
+
 export function exportAsMarkdown(conv) {
+  const messages = getActivePath(conv);
   const lines = [
     `# ${conv.title}`,
     `*Created: ${new Date(conv.createdAt).toLocaleString()}*`,
-    `*Messages: ${conv.messages.length}*`,
-    '',
-    '---',
-    '',
+    `*Messages: ${messages.length}*`,
+    '', '---', '',
   ];
-
-  for (const msg of conv.messages) {
-    if (msg.role === 'user') {
-      lines.push(`### You`);
-      lines.push(msg.content);
-    } else {
-      lines.push(`### NHA`);
-      lines.push(msg.content);
-    }
+  for (const msg of messages) {
+    lines.push(msg.role === 'user' ? '### You' : '### NHA');
+    lines.push(msg.content);
     lines.push('');
   }
-
   return lines.join('\n');
 }
 
-/**
- * Export conversation as JSON.
- */
 export function exportAsJson(conv) {
   return JSON.stringify({
     id: conv.id,
     title: conv.title,
     createdAt: conv.createdAt,
     updatedAt: conv.updatedAt,
-    messages: conv.messages,
+    messages: getActivePath(conv),
+    tree: conv.tree,
   }, null, 2);
 }
 
 // ── Migration ────────────────────────────────────────────────────────────────
 
-/**
- * Migrate old single-file chat history to multi-conversation format.
- * Called once on first run if old history exists.
- */
 export function migrateOldHistory() {
   const oldFile = path.join(NHA_DIR, 'memory', 'chat-history.json');
   if (!fs.existsSync(oldFile)) return;
@@ -269,9 +418,9 @@ export function migrateOldHistory() {
 
     const conv = createConversation('Previous Chat');
     conv.messages = messages;
+    upgradeToTree(conv);
     saveConversation(conv);
 
-    // Rename old file to avoid re-migration
     fs.renameSync(oldFile, oldFile + '.migrated');
-  } catch { /* migration failed — non-critical */ }
+  } catch {}
 }

package/src/services/web-ui.mjs

@@ -474,15 +474,31 @@ function renderMessages(){
     var safe=raw.replace(/!\\[([^\\]]*)\\]\\((\\/api\\/screenshots\\/[a-zA-Z0-9._-]+)\\)/g,function(_,alt,src){var ph='__IMG'+idx+'__';imgs.push({ph:ph,alt:alt,src:src});idx++;return ph;});
     var content=esc(safe);
     for(var i=0;i<imgs.length;i++){content=content.replace(imgs[i].ph,'<img class="screenshot-preview" alt="'+esc(imgs[i].alt)+'" src="'+imgs[i].src+'">');}
-    // Action buttons
+    // Action buttons + fork navigation
     var acts='<div class="msg__actions">';
     acts+='<button onclick="copyMsg('+mi+')">Copy</button>';
     if(isA){acts+='<button onclick="retryMsg('+mi+')">Retry</button>';}
     else{acts+='<button onclick="editMsg('+mi+')">Edit</button>';}
+    // Fork navigation placeholder (filled after render by loadForkInfo)
+    if(m.id){acts+='<span class="msg__fork" data-node-id="'+m.id+'"></span>';}
     acts+='</div>';
     h+='<div class="msg msg--'+esc(m.role)+'"><div class="msg__label">'+esc(m.role==='user'?'You':'NHA')+'</div><div class="msg__bubble">'+content+'</div>'+acts+'</div>';
   });
   el.innerHTML=h;el.scrollTop=el.scrollHeight;
+  // Load fork info for messages that have IDs
+  if(activeConvId){
+    apiGet('/api/conversations/'+activeConvId+'/forks').then(function(r){
+      if(!r||!r.forks)return;
+      var forkEls=document.querySelectorAll('.msg__fork');
+      for(var fi=0;fi<forkEls.length;fi++){
+        var nodeId=forkEls[fi].getAttribute('data-node-id');
+        var forkInfo=r.forks[nodeId];
+        if(forkInfo&&forkInfo.total>1){
+          forkEls[fi].innerHTML='<button onclick="navigateFork(\\x27'+nodeId+'\\x27,-1)" style="background:none;border:none;color:var(--dim);cursor:pointer;font-size:11px">&#x25C0;</button><span style="font-size:9px;color:var(--dim);margin:0 2px">'+(forkInfo.current+1)+'/'+forkInfo.total+'</span><button onclick="navigateFork(\\x27'+nodeId+'\\x27,1)" style="background:none;border:none;color:var(--dim);cursor:pointer;font-size:11px">&#x25B6;</button>';
+        }
+      }
+    }).catch(function(){});
+  }
 }
 var chatAttachedFile=null;
 var chatAttachedImage=null;
@@ -710,16 +726,66 @@ function copyMsg(i){
 }
 function retryMsg(i){
   if(i<1||chatHistory[i].role!=='assistant')return;
-  var userMsg=chatHistory[i-1];if(!userMsg||userMsg.role!=='user')return;
-  chatHistory.splice(i,1);renderMessages();
-  var inp=document.getElementById('chatInput');if(inp){inp.value=userMsg.content;}
-  sendChat();
+  if(chatStreaming)return;
+  var userMsg=chatHistory[i-1];
+  if(!userMsg||userMsg.role!=='user')return;
+
+  // Keep the old response — just re-stream a new one
+  // The old response stays in the tree as a sibling branch
+  chatHistory[i]={role:'assistant',content:'Generating alternative...'};
+  renderMessages();
+
+  // Stream a new response for the same user message
+  chatStreaming=true;
+  chatAbortController=new AbortController();
+  var streamIdx=i;
+  var allHistory=chatHistory.slice(0,i-1).map(function(m){return{role:m.role,content:(m.content||'')};});
+  var payload={message:userMsg.content,history:allHistory,conversationId:activeConvId,isRetry:true};
+
+  fetch(API+'/api/chat/stream',{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify(payload),signal:chatAbortController.signal}).then(function(response){
+    if(!response.ok||!response.body){chatHistory[streamIdx].content='Error: retry failed';endStreaming();renderMessages();return;}
+    var reader=response.body.getReader();var decoder=new TextDecoder();var buffer='';var currentEvent='';
+    function pump(){
+      reader.read().then(function(result){
+        if(result.done){endStreaming();renderMessages();return;}
+        buffer+=decoder.decode(result.value,{stream:true});
+        var lines=buffer.split('\\n');buffer=lines.pop()||'';
+        for(var li=0;li<lines.length;li++){
+          var line=lines[li];
+          if(line.startsWith('event: ')){currentEvent=line.slice(7).trim();continue;}
+          if(!line.startsWith('data: '))continue;
+          try{
+            var data=JSON.parse(line.slice(6));
+            if(currentEvent==='token'&&data.content){
+              if(chatHistory[streamIdx].content==='Generating alternative...')chatHistory[streamIdx].content='';
+              chatHistory[streamIdx].content+=data.content;
+              var el=document.getElementById('chatMessages');
+              if(el){var msgs=el.querySelectorAll('.msg');var last=msgs[streamIdx];if(last){var bub=last.querySelector('.msg__bubble');if(bub)bub.textContent=chatHistory[streamIdx].content;}el.scrollTop=el.scrollHeight;}
+            }
+            if(currentEvent==='tool_synthesis'){chatHistory[streamIdx].content='';renderMessages();}
+            if(currentEvent==='done'){endStreaming();if(data.content)chatHistory[streamIdx].content=data.content;renderMessages();loadConvList();}
+            if(currentEvent==='error'){endStreaming();chatHistory[streamIdx].content='Error: '+(data.message||'Unknown');renderMessages();}
+          }catch(e){}
+        }
+        pump();
+      }).catch(function(e){endStreaming();if(e.name!=='AbortError'){chatHistory[streamIdx].content='Error: '+e.message;renderMessages();}});
+    }
+    pump();
+  }).catch(function(e){endStreaming();chatHistory[streamIdx].content='Error: '+e.message;renderMessages();});
 }
 function editMsg(i){
   if(chatHistory[i].role!=='user')return;
   var inp=document.getElementById('chatInput');if(!inp)return;
   inp.value=chatHistory[i].content;inp.focus();
-  chatHistory.splice(i);renderMessages();
+  // Truncate to before this message — new message creates a branch
+  chatHistory=chatHistory.slice(0,i);
+  renderMessages();
+}
+function navigateFork(nodeId,dir){
+  if(!activeConvId)return;
+  apiPost('/api/conversations/'+activeConvId+'/navigate',{nodeId:nodeId,direction:dir}).then(function(r){
+    if(r&&r.ok&&r.messages){chatHistory=r.messages;renderMessages();}
+  });
 }
 function sendChat(){
   var inp=document.getElementById('chatInput');if(!inp)return;