@yeaft/webchat-agent 0.1.493 → 0.1.494

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, handleUnifyMergeThread } from '../unify/web-bridge.js';
+import { handleUnifyChat, handleUnifyModeSwitch, handleUnifyModelSwitch, resetUnifySession, handleUnifyLoadHistory, handleUnifyMergeThread, handleUnifyForkThread } from '../unify/web-bridge.js';
 
 export async function handleMessage(msg) {
   switch (msg.type) {
@@ -345,6 +345,10 @@ export async function handleMessage(msg) {
       handleUnifyMergeThread(msg);
       break;
 
+    case 'unify_fork_thread':
+      handleUnifyForkThread(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.493",
+  "version": "0.1.494",
   "description": "Remote agent for Yeaft WebChat — connects worker machines to the central server",
   "main": "index.js",
   "type": "module",

package/unify/conversation/persist.js

@@ -175,7 +175,8 @@ export class ConversationStore {
   #coldDir;     // ~/.yeaft/conversation/cold
   #indexPath;   // ~/.yeaft/conversation/index.md
   #compactPath; // ~/.yeaft/conversation/compact.md
-  #nextSeq;     // next message sequence number
+  #nextSeq;     // next message sequence number (global, legacy)
+  #nextSeqByThread; // Map<threadId, number> — per-thread counters (task-314)
 
   /**
    * @param {string} dir — Yeaft root directory (e.g. ~/.yeaft)
@@ -188,6 +189,7 @@ export class ConversationStore {
     this.#indexPath = join(dir, 'conversation', 'index.md');
     this.#compactPath = join(dir, 'conversation', 'compact.md');
     this.#nextSeq = null;
+    this.#nextSeqByThread = new Map();
 
     // Ensure directories exist (graceful on permission errors)
     for (const d of [this.#convDir, this.#msgDir, this.#coldDir]) {
@@ -523,6 +525,201 @@ export class ConversationStore {
     return rewritten;
   }
 
+  /**
+   * Copy every message on `sourceId` whose sequence id is <= `atMessageId`
+   * into new message files stamped with `threadId: targetId` and
+   * `sourceThreadId: sourceId` (symmetric with reassignThread's pill).
+   *
+   * Implementation notes:
+   *  - Scans both hot (`messages/`) and cold (`cold/`) directories so a
+   *    fork off a partially-compacted thread still works.
+   *  - Copies are appended via `append()` so they receive fresh globally
+   *    unique ids (m{NNNN}) — chronological order is preserved because we
+   *    sort by filename before copying.
+   *  - The source is NEVER modified. This is the key invariant separating
+   *    fork from merge.
+   *  - Returns the number of messages copied. `atMessageId` is inclusive.
+   *
+   * @param {string} sourceId
+   * @param {string} targetId
+   * @param {string} atMessageId — e.g. "m0007"; copy stops after this id
+   * @returns {number} copied count
+   */
+  copyThreadUpTo(sourceId, targetId, atMessageId) {
+    if (!sourceId || !targetId || sourceId === targetId) return 0;
+    if (!atMessageId || typeof atMessageId !== 'string') return 0;
+    // task-314 (rev-2 feedback): the target (forked) thread owns its own
+    // per-thread id namespace restarting at m0001. Source files are never
+    // touched, so there is no id-collision across threads (each thread
+    // loads from its own directory or by threadId filter on the shared
+    // legacy dir).
+    const targetDir = this.#threadMsgDir(targetId);
+    try {
+      if (!existsSync(targetDir)) mkdirSync(targetDir, { recursive: true, mode: 0o755 });
+    } catch (err) {
+      if (isPermissionError(err)) return 0;
+      throw err;
+    }
+
+    // Collect source-thread candidate files from both hot + cold dirs.
+    const candidates = [];
+    for (const dir of [this.#coldDir, this.#msgDir]) {
+      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 f of files) candidates.push(join(dir, f));
+    }
+    // Also pick up any already-forked sub-thread dir (chain fork).
+    const sourceSubDir = this.#threadMsgDir(sourceId);
+    if (existsSync(sourceSubDir)) {
+      try {
+        for (const f of readdirSync(sourceSubDir).filter(x => x.endsWith('.md'))) {
+          candidates.push(join(sourceSubDir, f));
+        }
+      } catch (err) {
+        if (!isPermissionError(err)) throw err;
+      }
+    }
+    // Sort by the "m{NNNN}" basename. For chain-fork, sub-thread ids also
+    // restart at m0001 so sorting by basename alone is ambiguous across
+    // dirs; but a given source thread stores messages in exactly ONE place
+    // (either legacy flat dir OR its sub-dir — see below), so ties never
+    // arise. Sorting by (path, seq) is still well-defined.
+    candidates.sort((a, b) => {
+      const ma = a.match(/m(\d+)\.md$/);
+      const mb = b.match(/m(\d+)\.md$/);
+      if (!ma || !mb) return 0;
+      return parseInt(ma[1], 10) - parseInt(mb[1], 10);
+    });
+    const cutoffMatch = atMessageId.match(/^m?(\d+)$/);
+    if (!cutoffMatch) return 0;
+    const cutoffSeq = parseInt(cutoffMatch[1], 10);
+
+    let copied = 0;
+    for (const path of candidates) {
+      const fileMatch = path.match(/m(\d+)\.md$/);
+      if (!fileMatch) continue;
+      const seq = parseInt(fileMatch[1], 10);
+      if (seq > cutoffSeq) continue; // do not break — sub-thread dir mixed in may interleave
+      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;
+      // Mint a fresh per-thread id restarting at m0001 under the target
+      // thread's own namespace.
+      const nextSeq = this.#getNextThreadSeq(targetId);
+      const newId = `m${String(nextSeq).padStart(4, '0')}`;
+      const { id: _id, ...rest } = msg;
+      const copy = {
+        ...rest,
+        id: newId,
+        threadId: targetId,
+        sourceThreadId: msg.sourceThreadId || sourceId,
+        time: rest.time || new Date().toISOString(),
+        tokens_est: rest.tokens_est || estimateTokens(rest.content || ''),
+      };
+      const filePath = join(targetDir, `${newId}.md`);
+      try {
+        writeFileSync(filePath, serializeMessage(copy), { encoding: 'utf8', mode: 0o644 });
+        this.#nextSeqByThread.set(targetId, nextSeq + 1);
+        copied += 1;
+      } catch (err) {
+        if (isPermissionError(err)) continue;
+        throw err;
+      }
+    }
+    return copied;
+  }
+
+  /**
+   * Load messages for a specific thread. Reads from the per-thread subdir
+   * (created by forkThread via copyThreadUpTo) if present, otherwise
+   * filters the legacy flat `messages/` + `cold/` dirs by `threadId`.
+   * Results are sorted chronologically by file sequence number.
+   *
+   * @param {string} threadId
+   * @returns {object[]}
+   */
+  load(threadId) {
+    if (!threadId) return [];
+    const subDir = this.#threadMsgDir(threadId);
+    if (existsSync(subDir)) {
+      // Per-thread namespace: just load the whole dir, filtered by
+      // threadId for safety (guards against hand-edited files).
+      const out = [];
+      for (const f of readdirSync(subDir).filter(x => x.endsWith('.md')).sort()) {
+        try {
+          const raw = readFileSync(join(subDir, f), 'utf8');
+          const msg = parseMessage(raw);
+          if (msg && msg.threadId === threadId) out.push(msg);
+        } catch (err) {
+          if (!isPermissionError(err)) throw err;
+        }
+      }
+      return out;
+    }
+    // Legacy: messages live in the flat dir stamped with threadId.
+    const collected = [];
+    for (const dir of [this.#coldDir, this.#msgDir]) {
+      if (!existsSync(dir)) continue;
+      for (const f of readdirSync(dir).filter(x => x.endsWith('.md'))) {
+        try {
+          const raw = readFileSync(join(dir, f), 'utf8');
+          const msg = parseMessage(raw);
+          if (msg && msg.threadId === threadId) collected.push({ msg, f });
+        } catch (err) {
+          if (!isPermissionError(err)) throw err;
+        }
+      }
+    }
+    collected.sort((a, b) => {
+      const ma = a.f.match(/m(\d+)\.md$/);
+      const mb = b.f.match(/m(\d+)\.md$/);
+      return (parseInt(ma?.[1] || '0', 10)) - (parseInt(mb?.[1] || '0', 10));
+    });
+    return collected.map(x => x.msg);
+  }
+
+  // task-314: per-thread sub-directory for forked threads.
+  #threadMsgDir(threadId) {
+    return join(this.#convDir, 'threads', threadId, 'messages');
+  }
+
+  // task-314: next per-thread sequence number, restarting at 1 for each
+  // new thread. Scans the per-thread sub-dir (not the global flat dir).
+  #getNextThreadSeq(threadId) {
+    const cached = this.#nextSeqByThread.get(threadId);
+    if (cached != null) return cached;
+    const dir = this.#threadMsgDir(threadId);
+    let maxSeq = 0;
+    if (existsSync(dir)) {
+      try {
+        for (const f of readdirSync(dir)) {
+          const m = f.match(/^m(\d+)\.md$/);
+          if (m) {
+            const s = parseInt(m[1], 10);
+            if (s > maxSeq) maxSeq = s;
+          }
+        }
+      } catch (err) {
+        if (!isPermissionError(err)) throw err;
+      }
+    }
+    const next = maxSeq + 1;
+    this.#nextSeqByThread.set(threadId, next);
+    return next;
+  }
+
   /**
    * Load messages from a directory, sorted by filename, limited.
    * @param {string} dir

package/unify/threads/store.js

@@ -68,6 +68,7 @@ const FLUSH_DEBOUNCE_MS = 8;
  * @returns {string}
  */
 function serializeThread(t) {
+  const forkedFrom = serializeForkedFrom(t.forkedFrom);
   const fm = [
     '---',
     `id: ${t.id}`,
@@ -77,6 +78,7 @@ function serializeThread(t) {
     `status: ${t.status}`,
     `archived: ${t.archived ? 'true' : 'false'}`,
     `mergedInto: ${t.mergedInto == null ? 'null' : t.mergedInto}`,
+    `forkedFrom: ${forkedFrom}`,
     `messageCount: ${t.messageCount | 0}`,
     `lastMessageAt: ${t.lastMessageAt == null ? 'null' : t.lastMessageAt}`,
     `lastActivityAt: ${t.lastActivityAt == null ? 'null' : t.lastActivityAt}`,
@@ -91,6 +93,31 @@ function serializeThread(t) {
   return fm.join('\n') + '\n';
 }
 
+/**
+ * Serialise `forkedFrom` as a single-line scalar so the YAML stays flat.
+ * Shape: `{threadId}|{messageId}|{timestamp}`. Null becomes literal `null`.
+ */
+function serializeForkedFrom(ff) {
+  if (!ff || typeof ff !== 'object') return 'null';
+  if (!ff.threadId || !ff.messageId) return 'null';
+  const ts = Number.isFinite(ff.timestamp) ? ff.timestamp : 0;
+  return `${ff.threadId}|${ff.messageId}|${ts}`;
+}
+
+function parseForkedFrom(raw) {
+  if (!raw || raw === 'null') return null;
+  const parts = String(raw).split('|');
+  if (parts.length < 2) return null;
+  const [threadId, messageId, tsStr] = parts;
+  if (!threadId || !messageId) return null;
+  const ts = parseInt(tsStr || '0', 10);
+  return {
+    threadId,
+    messageId,
+    timestamp: Number.isFinite(ts) ? ts : 0,
+  };
+}
+
 function escapeScalar(v) {
   if (v == null) return '';
   // Keep on one physical line; any embedded newline becomes a space so YAML
@@ -134,6 +161,8 @@ function parseThread(raw) {
   if (!THREAD_STATUSES.includes(record.status)) record.status = 'active';
   record.archived = record.status === 'archived';
   if (!('mergedInto' in record)) record.mergedInto = null;
+  // forkedFrom is a packed scalar — decode back to {threadId, messageId, timestamp}.
+  record.forkedFrom = parseForkedFrom(record.forkedFrom);
   record.messageCount = Number.isFinite(record.messageCount) ? record.messageCount : 0;
   record.unread = Number.isFinite(record.unread) ? record.unread : 0;
   record.preview = body;
@@ -311,6 +340,7 @@ export class ThreadStore {
       lastActivityAt: null,
       archived: false,
       mergedInto: null,
+      forkedFrom: null,
       unread: 0,
       preview: '',
       ...base,
@@ -625,6 +655,56 @@ export class ThreadStore {
     return { source, target };
   }
 
+  /**
+   * Fork a new thread from an existing one at a specific message cursor.
+   * ThreadStore only creates the new thread record (with `forkedFrom`
+   * pointing at source + message + timestamp); the actual copying of
+   * messages up to `atMessageId` is done by ConversationStore.copyThreadUpTo
+   * — this keeps the two stores' responsibilities separate.
+   *
+   * Validation:
+   *  - source must exist
+   *  - source must not be archived (forking a dead thread is confusing)
+   *  - atMessageId must be a non-empty string (actual existence check is
+   *    the caller's responsibility, since ThreadStore doesn't own messages)
+   *  - source may itself be a fork (chain is supported)
+   *
+   * @param {string} sourceId
+   * @param {string} atMessageId
+   * @param {{ name?: string, title?: string, timestamp?: number }} [opts]
+   * @returns {Thread} the newly created forked thread record
+   */
+  forkThread(sourceId, atMessageId, opts = {}) {
+    if (!sourceId) throw new Error('forkThread: sourceId required');
+    if (!atMessageId || typeof atMessageId !== 'string') {
+      throw new Error('forkThread: atMessageId required');
+    }
+    const source = this.#threads.get(sourceId);
+    if (!source) throw new Error(`thread not found: ${sourceId}`);
+    if (source.archived || source.status === 'archived') {
+      throw new Error(`forkThread: cannot fork an archived thread (${sourceId})`);
+    }
+    const now = Date.now();
+    const id = `thr-${randomUUID().slice(0, 8)}`;
+    const defaultName = source.id === MAIN_THREAD_ID ? 'inbox-fork' : `${source.name}-fork`;
+    const thread = this.#newThreadRecord({
+      id,
+      name: (opts.name && opts.name.trim()) || defaultName,
+      goal: source.goal || '',
+      parentThreadId: sourceId,
+      createdAt: now,
+      updatedAt: now,
+      forkedFrom: {
+        threadId: sourceId,
+        messageId: atMessageId,
+        timestamp: Number.isFinite(opts.timestamp) ? opts.timestamp : now,
+      },
+    });
+    this.#threads.set(id, thread);
+    this.#markDirty(id);
+    return thread;
+  }
+
   setStatus(id, status) {
     if (!THREAD_STATUSES.includes(status)) {
       throw new Error(`invalid status: ${status}`);

package/unify/web-bridge.js

@@ -626,6 +626,75 @@ export function handleUnifyMergeThread(msg) {
   sendThreadListUpdate();
 }
 
+/**
+ * task-314: fork a new thread from an existing one at a specific message.
+ * Copies every message up to (and including) `atMessageId` from the source
+ * thread onto a fresh thread, stamps `forkedFrom` on the new thread record,
+ * and broadcasts `thread_forked` + refreshed thread list. The source is not
+ * modified.
+ *
+ * @param {{ sourceThreadId: string, atMessageId: string, name?: string }} msg
+ */
+export function handleUnifyForkThread(msg) {
+  if (!session) {
+    console.warn('[Unify] unify_fork_thread received before session init — ignored');
+    return;
+  }
+  const { sourceThreadId, atMessageId, name } = msg || {};
+  if (!sourceThreadId || !atMessageId) {
+    sendUnifyEvent({
+      type: 'thread_fork_failed',
+      sourceThreadId,
+      atMessageId,
+      error: 'sourceThreadId and atMessageId required',
+    });
+    return;
+  }
+
+  let copied = 0;
+  let newThread;
+  try {
+    // 1. Create the fork record on ThreadStore (sets forkedFrom pointer).
+    const store = session.threadStore || getThreadStore();
+    newThread = store.forkThread(sourceThreadId, atMessageId, { name });
+    // 2. Copy messages up to the cursor (inclusive) into the new thread.
+    if (session.conversationStore && typeof session.conversationStore.copyThreadUpTo === 'function') {
+      copied = session.conversationStore.copyThreadUpTo(
+        sourceThreadId,
+        newThread.id,
+        atMessageId,
+      );
+    }
+    // 3. Roll cached counters on the new thread so the sidebar shows the
+    // copied messages without needing a rebuild pass.
+    if (copied > 0) {
+      newThread.messageCount = copied;
+      newThread.lastMessageAt = Date.now();
+      newThread.lastActivityAt = newThread.lastMessageAt;
+    }
+    // 4. Flush so the new thread is durable before the UI refreshes.
+    if (typeof store.flush === 'function') store.flush();
+  } catch (err) {
+    sendUnifyEvent({
+      type: 'thread_fork_failed',
+      sourceThreadId,
+      atMessageId,
+      error: err?.message || String(err),
+    });
+    return;
+  }
+
+  // 5. Broadcast the fork + refreshed thread list.
+  sendUnifyEvent({
+    type: 'thread_forked',
+    sourceThreadId,
+    targetThreadId: newThread.id,
+    forkedAtMessageId: atMessageId,
+    copiedMessages: copied,
+  });
+  sendThreadListUpdate();
+}
+
 /**
  * Handle model switch from the web UI.
  * Updates Engine's config so the next query uses the new model.