@yeaft/webchat-agent 0.1.496 → 0.1.498

package/package.json

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

package/unify/threads/store.js

@@ -518,6 +518,44 @@ export class ThreadStore {
     this.#idleArchiveDays = normaliseIdleDays(days);
   }
 
+  /**
+   * task-317: auto-archive pass. Scans every non-archived thread (except
+   * `main`, which is never auto-archived) and archives those whose
+   * `lastMessageAt` (fallback: `lastActivityAt`, fallback: `createdAt`)
+   * is older than `now - idleArchiveDays * 86400000 ms`.
+   *
+   * Returns the list of newly-archived thread ids so callers can decide
+   * whether to broadcast a UI update (no archived → no broadcast).
+   *
+   * Constraints:
+   *  - `idleArchiveDays === 0` disables the feature entirely (returns []).
+   *  - The main thread is NEVER archived regardless of its activity.
+   *  - Already-archived threads are skipped (idempotent).
+   *  - Threads with no recorded activity fall back to `createdAt`; a
+   *    thread created 100 days ago with zero messages IS archived when
+   *    idleArchiveDays ≤ 100 — silent threads aren't a special case.
+   *
+   * @param {number} [now] — override the clock for tests
+   * @returns {{ archived: string[] }}
+   */
+  runArchivePass(now = Date.now()) {
+    if (this.#idleArchiveDays <= 0) return { archived: [] };
+    const cutoff = now - this.#idleArchiveDays * 86400000;
+    const archived = [];
+    for (const t of this.#threads.values()) {
+      if (t.id === MAIN_THREAD_ID) continue;
+      if (t.archived || t.status === 'archived') continue;
+      const ref = t.lastMessageAt ?? t.lastActivityAt ?? t.createdAt ?? now;
+      if (ref > cutoff) continue;
+      t.status = 'archived';
+      t.archived = true;
+      t.updatedAt = now;
+      this.#markDirty(t.id);
+      archived.push(t.id);
+    }
+    return { archived };
+  }
+
   get(id) { return this.#threads.get(id) || null; }
   list() { return [...this.#threads.values()]; }
   has(id) { return this.#threads.has(id); }

package/unify/web-bridge.js

@@ -16,13 +16,22 @@
 import { loadSession } from './session.js';
 import { sendToServer } from '../connection/buffer.js';
 import ctx from '../context.js';
-import { getThreadStore } from './threads/store.js';
+import { getThreadStore, MAIN_THREAD_ID } from './threads/store.js';
 
 /** @type {import('./session.js').Session | null} */
 let session = null;
 
-/** @type {AbortController | null} */
-let currentAbort = null;
+/**
+ * task-320: per-thread in-flight AbortController registry.
+ *
+ * A new message only cancels the prior round on the SAME thread; a message
+ * routed to a different thread runs concurrently without aliasing. Keyed by
+ * the resolved `targetThreadId` from the dispatcher's `routing_decision`
+ * event (we don't know the thread until the router has classified).
+ *
+ * @type {Map<string, AbortController>}
+ */
+const abortByThread = new Map();
 
 /** Query timeout in ms — abort if LLM doesn't respond within this window */
 const QUERY_TIMEOUT_MS = 120_000;
@@ -30,10 +39,22 @@ const QUERY_TIMEOUT_MS = 120_000;
 /** Virtual conversationId for the Unify session */
 let unifyConversationId = null;
 
-/** Accumulated conversation messages for context continuity across queries.
- *  Each entry is { role: 'user'|'assistant', content: string|Array }.
- *  Cleared on session reset or consolidation. */
-let conversationMessages = [];
+/**
+ * task-320: per-thread accumulated conversation messages for context
+ * continuity. Previously a single flat array — which cross-contaminated
+ * history across threads. Keyed by threadId. Cleared on session reset or
+ * by a `consolidate` event for that thread only.
+ *
+ * @type {Map<string, Array<{role: 'user'|'assistant', content: string|Array}>>}
+ */
+const messagesByThread = new Map();
+
+function getThreadMessages(threadId) {
+  if (!threadId) return [];
+  let arr = messagesByThread.get(threadId);
+  if (!arr) { arr = []; messagesByThread.set(threadId, arr); }
+  return arr;
+}
 
 /** Whether we've already sent a permission warning to the UI */
 let _permissionDiagnosticSent = false;
@@ -101,10 +122,78 @@ export function installUnifyRuntimeBridge(s) {
       if (typeof s.threadStore?.setIdleArchiveDays === 'function') {
         s.threadStore.setIdleArchiveDays(v);
       }
+      // task-317: re-sweep right after the cap changes so a user who
+      // lowers the threshold sees stale threads disappear immediately
+      // rather than having to wait for the hourly tick.
+      runAutoArchiveSweep(s);
     },
   };
 }
 
+/**
+ * task-317: idle thread auto-archive.
+ *
+ * A single sweep = ask the ThreadStore to archive every non-main,
+ * non-archived thread whose last activity predates the configured idle
+ * window. When any thread is archived we push a fresh `thread_list_updated`
+ * so the sidebar reflects reality within the same tick.
+ *
+ * Safe on stores with `idleArchiveDays === 0` (returns no-op) and on
+ * sessions missing a threadStore handle (defensive; should never happen
+ * once `installUnifyRuntimeBridge` has run).
+ *
+ * @param {import('./session.js').Session|null} s
+ * @returns {string[]} archived thread ids (empty when nothing changed)
+ */
+export function runAutoArchiveSweep(s) {
+  try {
+    const store = s?.threadStore ?? (typeof getThreadStore === 'function' ? getThreadStore() : null);
+    if (!store || typeof store.runArchivePass !== 'function') return [];
+    const { archived } = store.runArchivePass();
+    if (archived && archived.length > 0) {
+      sendThreadListUpdate();
+    }
+    return archived || [];
+  } catch (err) {
+    console.warn('[Unify] runAutoArchiveSweep failed:', err?.message || err);
+    return [];
+  }
+}
+
+/**
+ * task-317: schedule the hourly auto-archive tick bound to the given
+ * session. Returns the `Timeout` handle so tests can assert / clear it.
+ * Re-calling replaces any prior timer (idempotent per-session).
+ *
+ * The timer is `unref()`'d so a pending tick never keeps the Node loop
+ * alive during shutdown; an explicit `clearAutoArchiveSchedule()` is
+ * provided for tests.
+ */
+let autoArchiveTimer = null;
+const AUTO_ARCHIVE_TICK_MS = 60 * 60 * 1000; // 1h
+
+export function scheduleAutoArchive(s, { intervalMs = AUTO_ARCHIVE_TICK_MS } = {}) {
+  if (autoArchiveTimer) {
+    clearInterval(autoArchiveTimer);
+    autoArchiveTimer = null;
+  }
+  if (!s) return null;
+  autoArchiveTimer = setInterval(() => {
+    runAutoArchiveSweep(s);
+  }, intervalMs);
+  if (autoArchiveTimer && typeof autoArchiveTimer.unref === 'function') {
+    autoArchiveTimer.unref();
+  }
+  return autoArchiveTimer;
+}
+
+export function clearAutoArchiveSchedule() {
+  if (autoArchiveTimer) {
+    clearInterval(autoArchiveTimer);
+    autoArchiveTimer = null;
+  }
+}
+
 /**
  * task-301 Part 2: push the full thread list snapshot to the web client.
  * Called after any ThreadStore-mutating tool completes and at turn_end so
@@ -327,8 +416,13 @@ function handleEngineEvent(event, threadId, hctx) {
       break;
 
     case 'consolidate':
-      // Engine compressed the context — clear our accumulated history.
-      conversationMessages = [];
+      // Engine compressed the context — clear our accumulated history for
+      // THIS thread only (task-320: per-thread history map).
+      if (threadId) {
+        messagesByThread.set(threadId, []);
+      } else {
+        messagesByThread.clear();
+      }
       sendUnifyEvent({
         type: 'consolidate',
         archivedCount: event.archivedCount,
@@ -436,15 +530,24 @@ export async function handleUnifyChat(msg) {
       // code — the config file was updated on disk but the running
       // session continued with the old caps until next restart.
       installUnifyRuntimeBridge(session);
+      // task-317: run one idle-archive sweep at bootstrap, then schedule
+      // the hourly tick bound to this session.
+      runAutoArchiveSweep(session);
+      scheduleAutoArchive(session);
 
       // Create a stable conversationId for the Unify session
       unifyConversationId = `unify-${Date.now()}`;
 
-      // Restore conversationMessages from persisted history for LLM context
+      // Restore per-thread history from persisted conversation store.
+      // task-320: bucket by threadId so each thread keeps its own context.
+      messagesByThread.clear();
       const recent = session.conversationStore.loadRecent(50);
-      conversationMessages = recent
-        .filter(m => m.role === 'user' || m.role === 'assistant')
-        .map(m => ({ role: m.role, content: m.content }));
+      for (const m of recent) {
+        if (m.role !== 'user' && m.role !== 'assistant') continue;
+        const tid = m.threadId || MAIN_THREAD_ID;
+        const bucket = getThreadMessages(tid);
+        bucket.push({ role: m.role, content: m.content });
+      }
 
       // Notify UI: session is ready with model info + conversationId
       sendUnifyEvent({
@@ -461,13 +564,14 @@ export async function handleUnifyChat(msg) {
       sendThreadListUpdate();
     }
 
-    // ─── Cancel any in-flight query ──
-    if (currentAbort) {
-      currentAbort.abort();
-      currentAbort = null;
-    }
-
-    currentAbort = new AbortController();
+    // ─── Per-call AbortController (task-320) ──
+    // Each call owns its own controller. Only once the router resolves the
+    // target thread do we register it into `abortByThread` and abort any
+    // prior controller on THAT same thread. Messages routed to different
+    // threads never alias each other's signals.
+    const abortCtrl = new AbortController();
+    /** @type {string | null} — set on routing_decision */
+    let resolvedThreadId = null;
 
     // ─── Timeout guard: abort query if LLM hangs beyond threshold ──
     // Resets on every event — fires only after prolonged silence.
@@ -475,9 +579,9 @@ export async function handleUnifyChat(msg) {
     const resetQueryTimer = () => {
       if (queryTimer) clearTimeout(queryTimer);
       queryTimer = setTimeout(() => {
-        if (currentAbort) {
+        if (!abortCtrl.signal.aborted) {
           console.error(`[Unify] query timeout after ${QUERY_TIMEOUT_MS / 1000}s of silence — aborting`);
-          currentAbort.abort();
+          abortCtrl.abort();
         }
       }, QUERY_TIMEOUT_MS);
     };
@@ -518,17 +622,31 @@ export async function handleUnifyChat(msg) {
       onError: (err) => { throw err; },
     };
 
-    for await (const pev of session.dispatcher.drain({ signal: currentAbort.signal })) {
+    for await (const pev of session.dispatcher.drain({ signal: abortCtrl.signal })) {
       resetQueryTimer();
+      // task-320: on routing_decision, bind this abort controller to the
+      // resolved target thread and abort any prior in-flight controller
+      // owned by that thread. Different threads don't alias.
+      if (pev && pev.type === 'routing_decision' && pev.targetThreadId && !resolvedThreadId) {
+        resolvedThreadId = pev.targetThreadId;
+        const prior = abortByThread.get(resolvedThreadId);
+        if (prior && prior !== abortCtrl) {
+          prior.abort();
+        }
+        abortByThread.set(resolvedThreadId, abortCtrl);
+      }
       forwardPipelineEvent(pev, pipelineCtx);
     }
 
     // ─── Query complete — accumulate messages for context continuity ──
-    conversationMessages.push({ role: 'user', content: cleanedPrompt });
+    // task-320: per-thread history (no cross-thread contamination).
+    const historyThread = resolvedThreadId || MAIN_THREAD_ID;
+    const threadMessages = getThreadMessages(historyThread);
+    threadMessages.push({ role: 'user', content: cleanedPrompt });
 
     const fullText = assistantTextParts.join('');
     if (fullText) {
-      conversationMessages.push({ role: 'assistant', content: fullText });
+      threadMessages.push({ role: 'assistant', content: fullText });
     }
 
     // ─── Signal turn end to UI ──
@@ -549,17 +667,14 @@ export async function handleUnifyChat(msg) {
     }
 
   } catch (err) {
-    // Don't report abort errors — but still send result to unblock frontend
-    if (err.name === 'AbortError') {
-      sendUnifyOutput({
-        type: 'assistant',
-        message: {
-          content: [{
-            type: 'text',
-            text: '⚠️ Query timed out — no response from LLM. Please try again.',
-          }],
-        },
-      });
+    // task-320: classify both DOM AbortError and LLMAbortError as
+    // "aborted" — LLMAbortError is thrown by the LLM adapters when the
+    // signal trips and must NOT render as a session error bubble.
+    const isAbort = err && (err.name === 'AbortError' || err.name === 'LLMAbortError');
+    if (isAbort) {
+      // Silent abort — the new in-flight round (on the same thread) will
+      // produce its own output. Still send `result` so the frontend's
+      // processing spinner for this exact send clears.
       sendUnifyOutput({
         type: 'result',
         result_text: '',
@@ -600,7 +715,12 @@ export async function handleUnifyChat(msg) {
       result_text: '',
     });
   } finally {
-    currentAbort = null;
+    // task-320: only clear the per-thread slot if THIS controller is still
+    // the registered one. If a newer message already overwrote it, leaving
+    // the newer controller in the map is the correct state.
+    if (resolvedThreadId && abortByThread.get(resolvedThreadId) === abortCtrl) {
+      abortByThread.delete(resolvedThreadId);
+    }
   }
 }
 
@@ -785,14 +905,22 @@ export async function handleUnifyLoadHistory(msg) {
     });
     // task-318 rev-1 fix: wire live setters; see handleUnifyChat.
     installUnifyRuntimeBridge(session);
+    // task-317: sweep + schedule auto-archive on history-load path too.
+    runAutoArchiveSweep(session);
+    scheduleAutoArchive(session);
 
     unifyConversationId = `unify-${Date.now()}`;
 
-    // Restore conversationMessages from persisted history for LLM context
+    // Restore per-thread history from persisted conversation store.
+    // task-320: bucket by threadId so each thread keeps its own context.
+    messagesByThread.clear();
     const recent = session.conversationStore.loadRecent(50);
-    conversationMessages = recent
-      .filter(m => m.role === 'user' || m.role === 'assistant')
-      .map(m => ({ role: m.role, content: m.content }));
+    for (const m of recent) {
+      if (m.role !== 'user' && m.role !== 'assistant') continue;
+      const tid = m.threadId || MAIN_THREAD_ID;
+      const bucket = getThreadMessages(tid);
+      bucket.push({ role: m.role, content: m.content });
+    }
 
     sendUnifyEvent({
       type: 'session_ready',
@@ -840,16 +968,19 @@ export async function handleUnifyLoadHistory(msg) {
  * session_ready so the frontend picks up updated models/config.
  */
 export async function resetUnifySession() {
-  if (currentAbort) {
-    currentAbort.abort();
-    currentAbort = null;
+  // task-320: abort ALL in-flight controllers (every thread) before
+  // tearing down the session. Leaves no dangling round still writing
+  // to stdout after shutdown.
+  for (const ctrl of abortByThread.values()) {
+    try { ctrl.abort(); } catch { /* ignore */ }
   }
+  abortByThread.clear();
   if (session) {
     await session.shutdown();
     session = null;
   }
   unifyConversationId = null;
-  conversationMessages = [];
+  messagesByThread.clear();
 
   // Re-initialize session immediately so frontend gets updated config
   try {
@@ -861,14 +992,21 @@ export async function resetUnifySession() {
     });
     // task-318 rev-1 fix: wire live setters; see handleUnifyChat.
     installUnifyRuntimeBridge(session);
+    // task-317: sweep + re-schedule auto-archive on reset too (the old
+    // interval was bound to the previous session; reschedule against the
+    // fresh one so timer references don't dangle).
+    runAutoArchiveSweep(session);
+    scheduleAutoArchive(session);
 
     unifyConversationId = `unify-${Date.now()}`;
 
-    // Restore conversation history for LLM context
+    // Restore per-thread history for LLM context (task-320).
     const recent = session.conversationStore.loadRecent(50);
-    conversationMessages = recent
-      .filter(m => m.role === 'user' || m.role === 'assistant')
-      .map(m => ({ role: m.role, content: m.content }));
+    for (const m of recent) {
+      if (m.role !== 'user' && m.role !== 'assistant') continue;
+      const tid = m.threadId || MAIN_THREAD_ID;
+      getThreadMessages(tid).push({ role: m.role, content: m.content });
+    }
 
     sendUnifyEvent({
       type: 'session_ready',