@yeaft/webchat-agent 0.1.491 → 0.1.492

package/connection/message-router.js

@@ -25,7 +25,7 @@ import { sendToServer, flushMessageBuffer } from './buffer.js';
 import { handleRestartAgent, handleUpgradeAgent } from './upgrade.js';
 import { loadMcpServers, updateMcpConfig } from '../mcp.js';
 import { getLlmConfig, updateLlmConfig } from '../unify/config-api.js';
-import { handleUnifyChat, handleUnifyModeSwitch, handleUnifyModelSwitch, resetUnifySession, handleUnifyLoadHistory } from '../unify/web-bridge.js';
+import { handleUnifyChat, handleUnifyModeSwitch, handleUnifyModelSwitch, resetUnifySession, handleUnifyLoadHistory, handleUnifyMergeThread } from '../unify/web-bridge.js';
 
 export async function handleMessage(msg) {
   switch (msg.type) {
@@ -341,6 +341,10 @@ export async function handleMessage(msg) {
       await resetUnifySession();
       break;
 
+    case 'unify_merge_thread':
+      handleUnifyMergeThread(msg);
+      break;
+
     // Expert roles definition (for ExpertPanel detail view)
     case 'get_expert_roles': {
       const { getExpertRolesDefinition } = await import('../expert-roles.js');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "0.1.491",
+  "version": "0.1.492",
   "description": "Remote agent for Yeaft WebChat — connects worker machines to the central server",
   "main": "index.js",
   "type": "module",

package/unify/conversation/persist.js

@@ -60,6 +60,10 @@ function serializeMessage(msg) {
   // routing can filter/replay by thread without rescanning JSON blobs.
   // Defaults to 'main' for legacy messages (see migrate-messages-threadid.js).
   fm.push(`threadId: ${msg.threadId || 'main'}`);
+  // task-313: when a thread is merged into another, the messages keep
+  // their original thread id in `sourceThreadId` so the UI can still
+  // render a small "#source" pill next to each bubble.
+  if (msg.sourceThreadId) fm.push(`sourceThreadId: ${msg.sourceThreadId}`);
 
   // Token estimate
   const content = msg.content || '';
@@ -116,6 +120,7 @@ export function parseMessage(raw) {
       case 'isError': msg.isError = value === 'true'; break;
       case 'tokens_est': msg.tokens_est = parseInt(value, 10); break;
       case 'threadId': msg.threadId = value; break;
+      case 'sourceThreadId': msg.sourceThreadId = value; break;
       // toolCalls are multi-line YAML — handled separately below
     }
   }
@@ -461,6 +466,63 @@ export class ConversationStore {
 
   // ─── Internal ───────────────────────────────────────────
 
+  /**
+   * Reassign every message in this store whose `threadId === sourceId`
+   * to `targetId`. The original thread id is preserved in
+   * `sourceThreadId` so the UI can still render a "#source" pill.
+   * Scans both hot (`messages/`) and cold (`cold/`) directories.
+   *
+   * Idempotent: messages already carrying `sourceThreadId` are not
+   * overwritten, and messages not on `sourceId` are skipped.
+   *
+   * @param {string} sourceId
+   * @param {string} targetId
+   * @returns {number} number of messages rewritten
+   */
+  reassignThread(sourceId, targetId) {
+    if (!sourceId || !targetId || sourceId === targetId) return 0;
+    let rewritten = 0;
+    for (const dir of [this.#msgDir, this.#coldDir]) {
+      if (!existsSync(dir)) continue;
+      let files;
+      try {
+        files = readdirSync(dir).filter(f => f.endsWith('.md'));
+      } catch (err) {
+        if (isPermissionError(err)) continue;
+        throw err;
+      }
+      for (const file of files) {
+        const path = join(dir, file);
+        let raw;
+        try {
+          raw = readFileSync(path, 'utf8');
+        } catch (err) {
+          if (isPermissionError(err)) continue;
+          throw err;
+        }
+        const msg = parseMessage(raw);
+        if (!msg || msg.threadId !== sourceId) continue;
+        // Preserve original thread id for UI pill; only stamp once.
+        if (!msg.sourceThreadId) msg.sourceThreadId = sourceId;
+        msg.threadId = targetId;
+        try {
+          writeFileSync(path, serializeMessage(msg), { encoding: 'utf8', mode: 0o644 });
+          rewritten += 1;
+        } catch (err) {
+          if (isPermissionError(err)) {
+            if (!_permissionWarned) {
+              console.warn(`[Yeaft] Cannot rewrite message ${file}: ${err.code}`);
+              _permissionWarned = true;
+            }
+            continue;
+          }
+          throw err;
+        }
+      }
+    }
+    return rewritten;
+  }
+
   /**
    * Load messages from a directory, sorted by filename, limited.
    * @param {string} dir

package/unify/threads/store.js

@@ -76,6 +76,7 @@ function serializeThread(t) {
     `parentThreadId: ${t.parentThreadId == null ? 'null' : t.parentThreadId}`,
     `status: ${t.status}`,
     `archived: ${t.archived ? 'true' : 'false'}`,
+    `mergedInto: ${t.mergedInto == null ? 'null' : t.mergedInto}`,
     `messageCount: ${t.messageCount | 0}`,
     `lastMessageAt: ${t.lastMessageAt == null ? 'null' : t.lastMessageAt}`,
     `lastActivityAt: ${t.lastActivityAt == null ? 'null' : t.lastActivityAt}`,
@@ -132,6 +133,7 @@ function parseThread(raw) {
   // Default to safe values if the file pre-dates a field.
   if (!THREAD_STATUSES.includes(record.status)) record.status = 'active';
   record.archived = record.status === 'archived';
+  if (!('mergedInto' in record)) record.mergedInto = null;
   record.messageCount = Number.isFinite(record.messageCount) ? record.messageCount : 0;
   record.unread = Number.isFinite(record.unread) ? record.unread : 0;
   record.preview = body;
@@ -308,6 +310,7 @@ export class ThreadStore {
       lastMessageAt: null,
       lastActivityAt: null,
       archived: false,
+      mergedInto: null,
       unread: 0,
       preview: '',
       ...base,
@@ -543,6 +546,85 @@ export class ThreadStore {
     this.#markDirty(id);
   }
 
+  /**
+   * Merge the source thread into the target (task-313). The source is
+   * marked archived and gets `mergedInto: targetId`; target's cached
+   * counters pick up the source's message count and activity. Callers
+   * are still expected to reassign the actual messages on disk via
+   * `ConversationStore.reassignThread(sourceId, targetId)`.
+   *
+   * Constraints:
+   *  - source !== target
+   *  - both threads must exist
+   *  - source cannot be the main thread (main cannot be archived)
+   *  - source cannot already have been merged elsewhere (idempotency)
+   *
+   * @param {string} sourceId
+   * @param {string} targetId
+   * @returns {{ source: Thread, target: Thread }}
+   */
+  mergeThread(sourceId, targetId) {
+    if (!sourceId || !targetId) {
+      throw new Error('mergeThread: sourceId and targetId required');
+    }
+    if (sourceId === targetId) {
+      throw new Error('mergeThread: cannot merge a thread into itself');
+    }
+    if (sourceId === MAIN_THREAD_ID) {
+      throw new Error('mergeThread: cannot merge the main thread into another');
+    }
+    const source = this.#threads.get(sourceId);
+    if (!source) throw new Error(`thread not found: ${sourceId}`);
+    const target = this.#threads.get(targetId);
+    if (!target) throw new Error(`thread not found: ${targetId}`);
+    if (source.mergedInto) {
+      throw new Error(`thread ${sourceId} already merged into ${source.mergedInto}`);
+    }
+
+    const now = Date.now();
+
+    // Accumulate counters onto target.
+    target.messageCount += source.messageCount;
+    if (source.lastMessageAt && (!target.lastMessageAt || source.lastMessageAt > target.lastMessageAt)) {
+      target.lastMessageAt = source.lastMessageAt;
+    }
+    if (source.lastActivityAt && (!target.lastActivityAt || source.lastActivityAt > target.lastActivityAt)) {
+      target.lastActivityAt = source.lastActivityAt;
+    }
+    target.updatedAt = now;
+    // Revive target if it was archived — a merge is an activity signal.
+    if (target.status === 'archived') {
+      target.status = 'active';
+      target.archived = false;
+    }
+
+    // Mark source as archived + pointer to target.
+    source.status = 'archived';
+    source.archived = true;
+    source.mergedInto = targetId;
+    source.updatedAt = now;
+
+    // If source was current, move the pointer to target.
+    if (this.#currentId === sourceId) {
+      this.#currentId = targetId;
+    }
+
+    // Drop any task attachment on source (it now belongs to target).
+    if (this.#attachments.has(sourceId)) {
+      const taskId = this.#attachments.get(sourceId);
+      this.#attachments.delete(sourceId);
+      // Preserve attachment on target if it had none; otherwise keep target's.
+      if (!this.#attachments.has(targetId)) {
+        this.#attachments.set(targetId, taskId);
+      }
+      this.#markAttachmentsDirty();
+    }
+
+    this.#markDirty(sourceId);
+    this.#markDirty(targetId);
+    return { source, target };
+  }
+
   setStatus(id, status) {
     if (!THREAD_STATUSES.includes(status)) {
       throw new Error(`invalid status: ${status}`);

package/unify/web-bridge.js

@@ -568,6 +568,64 @@ export function handleUnifyModeSwitch(_msg) {
   console.warn('[Unify] unify_mode_switch is deprecated and ignored — Unify now runs in a single unified mode.');
 }
 
+/**
+ * task-313: merge a source thread into a target thread.
+ * Reassigns messages, archives source with `mergedInto`, terminates source
+ * engine instance, broadcasts `thread_merged` + `thread_list_updated`.
+ *
+ * @param {{ sourceId: string, targetId: string }} msg
+ */
+export function handleUnifyMergeThread(msg) {
+  if (!session) {
+    console.warn('[Unify] unify_merge_thread received before session init — ignored');
+    return;
+  }
+  const { sourceId, targetId } = msg || {};
+  if (!sourceId || !targetId) {
+    sendUnifyEvent({ type: 'thread_merge_failed', sourceId, targetId, error: 'sourceId and targetId required' });
+    return;
+  }
+
+  let reassigned = 0;
+  try {
+    // 1. Reassign messages (ConversationStore) — preserves sourceThreadId pill.
+    if (session.conversationStore && typeof session.conversationStore.reassignThread === 'function') {
+      reassigned = session.conversationStore.reassignThread(sourceId, targetId);
+    }
+    // 2. Mutate ThreadStore (mergedInto + archived + counter rollup).
+    const store = session.threadStore || getThreadStore();
+    store.mergeThread(sourceId, targetId);
+    // 3. Terminate + forget the source engine instance — releases its slot.
+    if (session.engineRegistry) {
+      session.engineRegistry.delete(sourceId);
+      // If the registry was tracking source as current, move to target.
+      if (typeof session.engineRegistry.setCurrent === 'function'
+          && session.engineRegistry.currentThreadId === sourceId) {
+        session.engineRegistry.setCurrent(targetId);
+      }
+    }
+    // 4. Flush ThreadStore so the merge is durable before the UI refreshes.
+    if (typeof store.flush === 'function') store.flush();
+  } catch (err) {
+    sendUnifyEvent({
+      type: 'thread_merge_failed',
+      sourceId,
+      targetId,
+      error: err?.message || String(err),
+    });
+    return;
+  }
+
+  // 5. Broadcast the merge + refreshed thread list.
+  sendUnifyEvent({
+    type: 'thread_merged',
+    sourceId,
+    targetId,
+    reassignedMessages: reassigned,
+  });
+  sendThreadListUpdate();
+}
+
 /**
  * Handle model switch from the web UI.
  * Updates Engine's config so the next query uses the new model.