@yeaft/webchat-agent 0.1.796 → 0.1.798

package/connection/message-router.js

@@ -36,7 +36,7 @@ import { sendToServer, flushMessageBuffer } from './buffer.js';
 import { handleRestartAgent, handleUpgradeAgent } from './upgrade.js';
 import { loadMcpServers, updateMcpConfig } from '../mcp.js';
 import { getLlmConfig, updateLlmConfig, getUnifySettings, updateUnifySettings, getSearchSettings, updateSearchSettings, fetchTavilyUsage } from '../unify/config-api.js';
-import { handleUnifyGroupChat, handleUnifyModeSwitch, handleUnifyModelSwitch, resetUnifySession, handleUnifyLoadHistory, handleUnifyLoadMoreHistory, handleUnifyAbortThread, handleUnifyAbortAll, handleUnifyAbortTurn, handleUnifyVpSubscribe, handleUnifyVpCreate, handleUnifyVpUpdate, handleUnifyVpDelete, handleUnifyVpRead, handleUnifyListGroups, handleUnifyCreateGroup, handleUnifyRenameGroup, handleUnifyUpdateGroup, handleUnifyArchiveGroup, handleUnifyDeleteGroup, handleUnifyAddMember, handleUnifyRemoveMember, handleUnifySetDefaultVp, handleUnifyDreamTrigger, handleUnifyFetchToolStats, broadcastLanguageChange } from '../unify/web-bridge.js';
+import { handleUnifyGroupChat, handleUnifyModeSwitch, handleUnifyModelSwitch, resetUnifySession, handleUnifyLoadHistory, handleUnifyLoadMoreHistory, handleUnifyAbortThread, handleUnifyAbortAll, handleUnifyAbortTurn, handleUnifyVpSubscribe, handleUnifyVpCreate, handleUnifyVpUpdate, handleUnifyVpDelete, handleUnifyVpRead, handleUnifyListGroups, handleUnifyCreateGroup, handleUnifyRenameGroup, handleUnifyUpdateGroup, handleUnifyArchiveGroup, handleUnifyDeleteGroup, handleUnifyAddMember, handleUnifyRemoveMember, handleUnifySetDefaultVp, handleUnifyDreamTrigger, handleUnifyFetchToolStats, handleUnifyFetchDebugHistory, broadcastLanguageChange } from '../unify/web-bridge.js';
 
 export async function handleMessage(msg) {
   switch (msg.type) {
@@ -502,6 +502,14 @@ export async function handleMessage(msg) {
       await handleUnifyFetchToolStats(msg);
       break;
 
+    // fix-vp-multi-thread (bug 4): hydrate the Unify debug panel from
+    // the persistent SQLite trace. Without this, the panel only shows
+    // turns that happened after the panel was opened — every previous
+    // turn is invisible.
+    case 'unify_fetch_debug_history':
+      await handleUnifyFetchDebugHistory(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.796",
+  "version": "0.1.798",
   "description": "Remote agent for Yeaft WebChat — connects worker machines to the central server",
   "main": "index.js",
   "type": "module",

package/unify/debug-trace.js

@@ -28,7 +28,18 @@ const SCHEMA = `
     latency_ms INTEGER,
     response_text TEXT,
     started_at INTEGER NOT NULL,
-    ended_at INTEGER
+    ended_at INTEGER,
+    group_id TEXT,
+    vp_id TEXT,
+    thread_id TEXT,
+    system_prompt TEXT,
+    messages_json TEXT,
+    tool_calls_json TEXT,
+    usage_json TEXT,
+    ttfb_ms INTEGER,
+    raw_request TEXT,
+    raw_response TEXT,
+    user_prompt TEXT
   );
 
   CREATE TABLE IF NOT EXISTS trace_tools (
@@ -61,9 +72,47 @@ const SCHEMA = `
   CREATE INDEX IF NOT EXISTS idx_events_type ON trace_events(event_type);
 `;
 
+/**
+ * Indexes that reference columns added by the v0.1.x fix-vp-multi-thread
+ * migration. Must be executed AFTER `migrateAddColumn` for those columns
+ * — running them inside the main SCHEMA block would fail on an old DB
+ * whose `trace_turns` table predates `group_id` / `vp_id` / `thread_id`
+ * (`CREATE TABLE IF NOT EXISTS` is a no-op when the table already
+ * exists, so the columns are never added by SCHEMA alone).
+ */
+const POST_MIGRATION_INDEXES = `
+  CREATE INDEX IF NOT EXISTS idx_turns_group_id ON trace_turns(group_id);
+  CREATE INDEX IF NOT EXISTS idx_turns_vp_id ON trace_turns(vp_id);
+  CREATE INDEX IF NOT EXISTS idx_turns_thread_id ON trace_turns(thread_id);
+`;
+
+/**
+ * Idempotent column-adds for pre-existing trace databases. `ALTER TABLE …
+ * ADD COLUMN` throws if the column already exists, so we wrap each call.
+ * Mirrors the columns introduced above so older DBs upgrade in place.
+ */
+function migrateAddColumn(db, table, column, type) {
+  try {
+    db.exec(`ALTER TABLE ${table} ADD COLUMN ${column} ${type}`);
+  } catch (err) {
+    if (!String(err?.message || err).match(/duplicate column name/i)) {
+      throw err;
+    }
+  }
+}
+
 /** Max tool_output size stored (10KB). Longer outputs are truncated. */
 const MAX_TOOL_OUTPUT = 10240;
 
+/**
+ * Max per-loop payload (system prompt, messages JSON, raw request /
+ * response, response text) stored per row. Larger than MAX_TOOL_OUTPUT
+ * because real-world LLM exchanges (system prompt + 30K-token message
+ * trail + raw response) routinely cross 10KB. 256KB lets us replay the
+ * panel verbatim for the most recent traces without bloating the DB.
+ */
+const MAX_LOOP_PAYLOAD = 256 * 1024;
+
 /**
  * Truncate a string to a max length, appending "... [truncated]" if needed.
  * @param {string|null|undefined} str
@@ -98,29 +147,53 @@ export class DebugTrace {
     this.#db.exec('PRAGMA journal_mode = WAL');
     this.#db.exec('PRAGMA foreign_keys = ON');
     this.#db.exec(SCHEMA);
+    // Forward-compat: a DB created by an older version of the bridge
+    // will be missing the group/vp/thread + per-loop snapshot columns.
+    // Add them on open; no-op for fresh DBs (column already exists
+    // from SCHEMA above).
+    migrateAddColumn(this.#db, 'trace_turns', 'group_id', 'TEXT');
+    migrateAddColumn(this.#db, 'trace_turns', 'vp_id', 'TEXT');
+    migrateAddColumn(this.#db, 'trace_turns', 'thread_id', 'TEXT');
+    migrateAddColumn(this.#db, 'trace_turns', 'system_prompt', 'TEXT');
+    migrateAddColumn(this.#db, 'trace_turns', 'messages_json', 'TEXT');
+    migrateAddColumn(this.#db, 'trace_turns', 'tool_calls_json', 'TEXT');
+    migrateAddColumn(this.#db, 'trace_turns', 'usage_json', 'TEXT');
+    migrateAddColumn(this.#db, 'trace_turns', 'ttfb_ms', 'INTEGER');
+    migrateAddColumn(this.#db, 'trace_turns', 'raw_request', 'TEXT');
+    migrateAddColumn(this.#db, 'trace_turns', 'raw_response', 'TEXT');
+    // C2 fix: explicit `user_prompt` column. Deriving the prompt from
+    // `messages_json` is unsafe because every loop after turn 1 in a
+    // multi-loop tool-call cycle persists the *cumulative* conversation
+    // snapshot — `messages.find(role==='user')` would return turn 1's
+    // text for every subsequent turn, mislabeling every Turn header.
+    migrateAddColumn(this.#db, 'trace_turns', 'user_prompt', 'TEXT');
+    // Indexes on the just-added columns. Must run AFTER the ALTER TABLEs
+    // — running them inside SCHEMA's CREATE INDEX IF NOT EXISTS block
+    // would fail with "no such column: group_id" on a pre-bugfix DB.
+    this.#db.exec(POST_MIGRATION_INDEXES);
   }
 
   // ─── Write API ───────────────────────────────────────────────
 
   /**
    * Start a new turn.
-   * @param {{ traceId: string, messageId?: string, mode?: string, turnNumber?: number }} opts
+   * @param {{ traceId: string, messageId?: string, mode?: string, turnNumber?: number, groupId?: string, vpId?: string, threadId?: string, userPrompt?: string }} opts
    * @returns {string} — turnId
    */
-  startTurn({ traceId, messageId = null, mode = null, turnNumber = null }) {
+  startTurn({ traceId, messageId = null, mode = null, turnNumber = null, groupId = null, vpId = null, threadId = null, userPrompt = null }) {
     const id = randomUUID();
     const now = Date.now();
     this.#prepare('insertTurn', `
-      INSERT INTO trace_turns (id, trace_id, message_id, mode, turn_number, started_at)
-      VALUES (?, ?, ?, ?, ?, ?)
-    `).run(id, traceId, messageId, mode, turnNumber, now);
+      INSERT INTO trace_turns (id, trace_id, message_id, mode, turn_number, started_at, group_id, vp_id, thread_id, user_prompt)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(id, traceId, messageId, mode, turnNumber, now, groupId, vpId, threadId, truncate(userPrompt, MAX_LOOP_PAYLOAD));
     return id;
   }
 
   /**
    * End a turn with model response info.
    * @param {string} turnId
-   * @param {{ model?: string, inputTokens?: number, outputTokens?: number, cacheReadTokens?: number, cacheWriteTokens?: number, stopReason?: string, latencyMs?: number, responseText?: string }} info
+   * @param {{ model?: string, inputTokens?: number, outputTokens?: number, cacheReadTokens?: number, cacheWriteTokens?: number, stopReason?: string, latencyMs?: number, responseText?: string, systemPrompt?: string, messages?: unknown, toolCalls?: unknown, usage?: unknown, ttfbMs?: number, rawRequest?: unknown, rawResponse?: unknown }} info
    */
   endTurn(turnId, {
     model = null,
@@ -131,19 +204,68 @@ export class DebugTrace {
     stopReason = null,
     latencyMs = null,
     responseText = null,
+    systemPrompt = null,
+    messages = null,
+    toolCalls = null,
+    usage = null,
+    ttfbMs = null,
+    rawRequest = null,
+    rawResponse = null,
   } = {}) {
     const now = Date.now();
+    // JSON-stringify the structured fields so they round-trip through
+    // SQLite as TEXT. JSON serialisation might fail (cyclic structure /
+    // BigInt) — guard with try/catch and persist null on failure so a
+    // single bad message can never tank the whole turn record.
+    //
+    // I2 fix: if the serialised JSON exceeds MAX_LOOP_PAYLOAD, the naïve
+    // `truncate(s, MAX)` would append `... [truncated]` mid-string and
+    // make the row's JSON unparseable. The reader's `parseJsonSafe` would
+    // then silently return null and the panel would render the loop with
+    // empty messages / toolCalls / usage. Persist a structured sentinel
+    // instead so the panel can render a "[truncated, N bytes]" notice.
+    const safeStringify = (v) => {
+      if (v == null) return null;
+      try {
+        const s = JSON.stringify(v);
+        if (s.length <= MAX_LOOP_PAYLOAD) return s;
+        return JSON.stringify({
+          __truncated: true,
+          originalBytes: s.length,
+          maxBytes: MAX_LOOP_PAYLOAD,
+        });
+      } catch { return null; }
+    };
+    // For raw request/response, accept either a pre-stringified blob
+    // (treat as opaque text — truncation here is fine because
+    // parseJsonSafe is not used on raw_*) or a structured object (route
+    // through safeStringify which preserves JSON validity).
+    const stringifyRaw = (v) => {
+      if (v == null) return null;
+      if (typeof v === 'string') return truncate(v, MAX_LOOP_PAYLOAD);
+      return safeStringify(v);
+    };
     this.#prepare('endTurn', `
       UPDATE trace_turns SET
         model = ?, input_tokens = ?, output_tokens = ?,
         cache_read_tokens = ?, cache_write_tokens = ?,
-        stop_reason = ?, latency_ms = ?, response_text = ?, ended_at = ?
+        stop_reason = ?, latency_ms = ?, response_text = ?, ended_at = ?,
+        system_prompt = ?, messages_json = ?, tool_calls_json = ?,
+        usage_json = ?, ttfb_ms = ?, raw_request = ?, raw_response = ?
       WHERE id = ?
     `).run(
       model, inputTokens, outputTokens,
       cacheReadTokens, cacheWriteTokens,
-      stopReason, latencyMs, truncate(responseText, MAX_TOOL_OUTPUT),
-      now, turnId,
+      stopReason, latencyMs, truncate(responseText, MAX_LOOP_PAYLOAD),
+      now,
+      truncate(systemPrompt, MAX_LOOP_PAYLOAD),
+      safeStringify(messages),
+      safeStringify(toolCalls),
+      safeStringify(usage),
+      ttfbMs,
+      stringifyRaw(rawRequest),
+      stringifyRaw(rawResponse),
+      turnId,
     );
   }
 
@@ -236,6 +358,125 @@ export class DebugTrace {
     `).all(limit);
   }
 
+  /**
+   * Fetch the recent debug history for the UnifyDebugPanel. Returns one
+   * record per LLM loop (ordered oldest → newest) with the structured
+   * fields the panel expects. JSON columns are parsed; truncated /
+   * malformed payloads degrade to null instead of failing the call.
+   *
+   * @param {{ limit?: number, groupId?: string|null, threadId?: string|null }} [opts]
+   * @returns {{ loops: object[], turns: object[] }}
+   */
+  fetchRecentDebugHistory({ limit = 100, groupId = null, threadId = null } = {}) {
+    const lim = Math.max(1, Math.min(500, Number(limit) || 100));
+    const where = [];
+    const args = [];
+    if (groupId) { where.push('group_id = ?'); args.push(groupId); }
+    if (threadId) { where.push('thread_id = ?'); args.push(threadId); }
+    const sql = `
+      SELECT * FROM trace_turns
+      ${where.length ? `WHERE ${where.join(' AND ')}` : ''}
+      ORDER BY started_at DESC
+      LIMIT ?
+    `;
+    args.push(lim);
+    const rows = this.#db.prepare(sql).all(...args);
+    const turnIds = rows.map(r => r.id);
+    const tools = turnIds.length > 0
+      ? this.#db.prepare(
+          `SELECT * FROM trace_tools WHERE turn_id IN (${turnIds.map(() => '?').join(',')}) ORDER BY created_at`
+        ).all(...turnIds)
+      : [];
+    const parseJsonSafe = (s) => {
+      if (s == null) return null;
+      try { return JSON.parse(s); }
+      catch { return null; }
+    };
+    // Group rows by (turnId, threadId, groupId, vpId) → frontend Turn
+    // record. Each row is also surfaced as a Loop.
+    const turnsById = new Map();
+    const loops = rows.map((r) => {
+      const parsedMessages = parseJsonSafe(r.messages_json) || [];
+      const parsedUsage = parseJsonSafe(r.usage_json);
+      const loop = {
+        turnId: r.trace_id, // panel groups loops by trace_id-as-turnId
+        loopNumber: r.turn_number || 0,
+        model: r.model || null,
+        systemPrompt: r.system_prompt || '',
+        messages: parsedMessages,
+        response: r.response_text || '',
+        toolCalls: parseJsonSafe(r.tool_calls_json) || [],
+        usage: parsedUsage || {
+          inputTokens: r.input_tokens || 0,
+          outputTokens: r.output_tokens || 0,
+          totalTokens: (r.input_tokens || 0) + (r.output_tokens || 0),
+        },
+        latencyMs: r.latency_ms || 0,
+        ttfbMs: r.ttfb_ms || null,
+        stopReason: r.stop_reason || null,
+        rawRequest: r.raw_request || null,
+        rawResponse: r.raw_response || null,
+        groupId: r.group_id || null,
+        vpId: r.vp_id || null,
+        threadId: r.thread_id || null,
+      };
+      if (!turnsById.has(r.trace_id)) {
+        turnsById.set(r.trace_id, {
+          turnId: r.trace_id,
+          // C2 fix: read the explicit `user_prompt` column persisted at
+          // startTurn time. Deriving from messages_json is unsafe — each
+          // tool-loop iteration overwrites messages_json with the
+          // cumulative conversation snapshot, so `messages[0].content`
+          // would be turn-1's prompt for every subsequent turn header.
+          userPrompt: r.user_prompt || '',
+          groupId: r.group_id || null,
+          vpId: r.vp_id || null,
+          threadId: r.thread_id || null,
+          openedAt: r.started_at || 0,
+          closedAt: r.ended_at || null,
+          totalMs: 0,
+          totalTokens: 0,
+          loopCount: 0,
+          memoryLoaded: null,
+          memoryAdjust: null,
+          tools: [],
+        });
+      }
+      const t = turnsById.get(r.trace_id);
+      t.loopCount += 1;
+      // Aggregate per-loop latency / tokens so the Turn header shows the
+      // same totals the live `turn_close` event would have stamped.
+      t.totalMs += r.latency_ms || 0;
+      const usageTokens = parsedUsage && Number.isFinite(parsedUsage.totalTokens)
+        ? parsedUsage.totalTokens
+        : (r.input_tokens || 0) + (r.output_tokens || 0);
+      t.totalTokens += usageTokens;
+      if (r.ended_at && (!t.closedAt || r.ended_at > t.closedAt)) t.closedAt = r.ended_at;
+      return loop;
+    });
+    // Attach tools to their parent Turn so the panel can render per-tool
+    // timing without scanning the loop bodies.
+    for (const tool of tools) {
+      // Find which loop row this tool belongs to → that row's trace_id
+      // identifies the Turn.
+      const owner = rows.find(r => r.id === tool.turn_id);
+      if (!owner) continue;
+      const t = turnsById.get(owner.trace_id);
+      if (!t) continue;
+      t.tools.push({
+        loopNumber: owner.turn_number || 0,
+        callId: tool.id,
+        name: tool.tool_name,
+        durationMs: tool.duration_ms || 0,
+        isError: !!tool.is_error,
+      });
+    }
+    // Reverse to oldest-first so the panel's existing append-driven UI
+    // renders in chronological order on hydration.
+    loops.reverse();
+    return { loops, turns: Array.from(turnsById.values()) };
+  }
+
   /**
    * Query tool calls with optional filters.
    * @param {{ name?: string, since?: number }} [filters={}]
@@ -383,6 +624,7 @@ export class NullTrace {
   cleanup() { return { deletedTurns: 0, deletedTools: 0, deletedEvents: 0 }; }
   purge() {}
   close() {}
+  fetchRecentDebugHistory() { return { loops: [], turns: [] }; }
 }
 
 /**

package/unify/engine.js

@@ -1468,6 +1468,18 @@ export class Engine {
       const turnId = this.#trace.startTurn({
         traceId: this.#traceId,
         turnNumber,
+        // fix-vp-multi-thread (bug 4): stamp routing context so the
+        // debug-trace SQL row carries enough info to be filtered by
+        // group / thread / VP later when the panel hydrates from disk.
+        groupId: groupId || null,
+        vpId: queryVpId || null,
+        threadId: threadId || null,
+        // Persist the user prompt EXPLICITLY rather than reconstruct it
+        // post-hoc from `messages_json` — every tool-loop iteration
+        // writes the *cumulative* messages array, so deriving the prompt
+        // from `messages.find(role==='user')` would always return turn
+        // 1's prompt and mislabel every subsequent Turn header.
+        userPrompt: userQuestionPreview,
       });
 
       const startTime = Date.now();
@@ -1677,6 +1689,20 @@ export class Engine {
           stopReason: 'error',
           latencyMs,
           responseText,
+          // fix-vp-multi-thread (bug 4): persist the snapshot on the
+          // error path too — failure traces are the most valuable for
+          // hydration.
+          systemPrompt,
+          messages: conversationMessages.map(mapDebugMessage),
+          toolCalls: toolCalls.map(tc => ({ id: tc.id, name: tc.name, input: tc.input })),
+          usage: {
+            inputTokens: totalUsage.inputTokens || 0,
+            outputTokens: totalUsage.outputTokens || 0,
+            totalTokens: (totalUsage.inputTokens || 0) + (totalUsage.outputTokens || 0),
+          },
+          ttfbMs,
+          rawRequest,
+          rawResponse,
         });
 
         // Emit `loop` event for error path too (was `debug_turn`).
@@ -1759,6 +1785,21 @@ export class Engine {
         stopReason,
         latencyMs,
         responseText,
+        // fix-vp-multi-thread (bug 4): persist the full per-loop
+        // snapshot. The frontend debug panel only renders what it has
+        // in-memory — without these columns the user can never see
+        // history from before the panel was opened.
+        systemPrompt,
+        messages: conversationMessages.map(mapDebugMessage),
+        toolCalls: toolCalls.map(tc => ({ id: tc.id, name: tc.name, input: tc.input })),
+        usage: {
+          inputTokens: totalUsage.inputTokens || 0,
+          outputTokens: totalUsage.outputTokens || 0,
+          totalTokens: (totalUsage.inputTokens || 0) + (totalUsage.outputTokens || 0),
+        },
+        ttfbMs,
+        rawRequest,
+        rawResponse,
       });
 
       // Emit `loop` event for the debug panel.

package/unify/web-bridge.js

@@ -52,6 +52,7 @@ import {
 } from './history-compact.js';
 import { persistUnifyAttachments, attachmentsForPersistence } from './attachments.js';
 import { parseSeqFromId } from './conversation/persist.js';
+import { sliceLastNTurns } from './turn-utils.js';
 import { createVpStatusBroker } from './vp-status-broker.js';
 import { classifyThread as defaultClassifyThread, fallbackTitle } from './vp/thread-classifier.js';
 
@@ -523,6 +524,54 @@ function projectPersistedToHistoryEntry(m) {
   return entry;
 }
 
+function projectPersistedToVisibleHistoryEntry(m) {
+  const entry = projectPersistedToHistoryEntry(m);
+  return entry && (entry.role === 'user' || entry.role === 'assistant') ? entry : null;
+}
+
+function loadVisibleGroupHistoryPage(store, groupId, limit, beforeSeq = null) {
+  if (!store || !groupId || !(limit > 0)) return { messages: [], oldestSeq: null, hasMore: false };
+
+  let rows = [];
+  try {
+    if (typeof store.loadOlderByGroup === 'function') {
+      // Use an unbounded raw prefix, then project/slice visible rows below.
+      // This preserves loadOlderByGroup's hot+cold scan without letting raw
+      // reflection/internal rows consume the UI-visible page window.
+      rows = store.loadOlderByGroup(groupId, beforeSeq, Infinity).messages || [];
+    } else if (Number.isFinite(beforeSeq)) {
+      const all = typeof store.loadAllByGroup === 'function'
+        ? store.loadAllByGroup(groupId)
+        : store.loadRecentByGroup(groupId, Infinity);
+      rows = all.filter(m => parseSeqFromId(m?.id) < beforeSeq);
+    } else if (typeof store.loadAllByGroup === 'function') {
+      rows = store.loadAllByGroup(groupId);
+    } else {
+      rows = store.loadRecentByGroup(groupId, Infinity);
+    }
+  } catch (err) {
+    console.error('[Unify] visible history page load failed:', err?.message || err);
+    return { messages: [], oldestSeq: null, hasMore: false };
+  }
+
+  const visible = rows
+    .map(projectPersistedToVisibleHistoryEntry)
+    .filter(Boolean);
+  const messages = sliceLastNTurns(visible, limit);
+  const oldestSeq = messages.length ? parseSeqFromId(messages[0].id) : null;
+  const firstVisibleSeq = visible.length ? parseSeqFromId(visible[0].id) : null;
+  const hasMore = messages.length > 0
+    && Number.isFinite(oldestSeq)
+    && Number.isFinite(firstVisibleSeq)
+    && oldestSeq > firstVisibleSeq;
+
+  return {
+    messages,
+    oldestSeq: Number.isFinite(oldestSeq) ? oldestSeq : null,
+    hasMore,
+  };
+}
+
 /**
  * Hydrate a freshly-created GroupContext's history from the on-disk
  * conversation store. Returns an empty array if the session isn't
@@ -837,7 +886,7 @@ async function routeEnvelopeToVpThread(groupId, vpId, envelope) {
 
   if (related) {
     const content = promptParts || prompt;
-    thread.pendingQueries.push({ content, preview: prompt });
+    thread.pendingQueries.push({ content, preview: prompt, originalText: text, originalParts: Array.isArray(envelope?._promptParts) ? envelope._promptParts : null });
     persistInboundMessageOnceByMsgId({
       msgId: envelope?.msg?.id,
       text,
@@ -979,6 +1028,72 @@ function ensureDriverRunning(groupId, vpId, threadId = 'main') {
           }, { groupId, vpId, threadId: thread.threadId, turnId });
         }
       } catch { /* never crash WS pipeline */ }
+
+      // fix-vp-multi-thread (bug 1 + 3): rescue any orphaned related-
+      // appends. If a user (or a VP via route_forward) added queries
+      // to this thread's `pendingQueries` AFTER the engine had already
+      // decided to end_turn (so the inner drain at engine.js:1850 no
+      // longer fires), those queries would be silently lost. Convert
+      // each leftover into a synthetic inbox envelope so the driver
+      // re-enters and runs a fresh turn on the same thread.
+      if (thread && Array.isArray(thread.pendingQueries) && thread.pendingQueries.length > 0) {
+        const leftovers = thread.pendingQueries.splice(0);
+        for (const leftover of leftovers) {
+          // `originalText` / `originalParts` capture the inbound payload
+          // BEFORE `buildVpPromptPayload` prepended `@vp-<id> ` and added
+          // any suffix. Replaying through `buildVpPromptPayload` (via the
+          // driver) re-applies the prefix, so we must NOT pass the
+          // already-decorated `preview` here or the prompt would carry
+          // a double `@vp-<id> @vp-<id> ...` mention.
+          const replayText = typeof leftover?.originalText === 'string'
+            ? leftover.originalText
+            : '';
+          const replayParts = Array.isArray(leftover?.originalParts) && leftover.originalParts.length > 0
+            ? leftover.originalParts
+            : null;
+          if (!replayText && !replayParts) continue;
+          const followUpId = `followup_${Date.now().toString(36)}_${randomUUID().slice(0, 8)}`;
+          const followUpEnvelope = {
+            groupId,
+            taskId: envelope?.taskId || null,
+            trigger: 'pending_rescue',
+            msg: {
+              id: followUpId,
+              from: 'user',
+              text: replayText,
+              meta: { rescuedFrom: 'pendingQueries', threadId: thread.threadId },
+            },
+            ...(replayParts ? { _promptParts: replayParts } : {}),
+          };
+          const followUpTurnId = `${randomUUID().slice(0, 8)}:${vpId}`;
+          inbox.push({ envelope: followUpEnvelope, turnId: followUpTurnId, thread });
+          try {
+            thread.status = 'typing';
+            thread.updatedAt = Date.now();
+            getVpStatusBroker().transition({
+              groupId,
+              vpId,
+              threadId: thread.threadId,
+              title: thread.title || '',
+              state: 'typing',
+              turnId: followUpTurnId,
+              messageCount: thread.messageIds.length,
+            });
+          } catch (err) {
+            console.warn('[Unify] vp-status typing transition (rescue) failed:', err?.message || err);
+          }
+          try {
+            sendUnifyEvent({
+              type: 'vp_typing_start',
+              groupId,
+              vpId,
+              threadId: thread.threadId,
+              turnId: followUpTurnId,
+              ts: Date.now(),
+            }, { groupId, vpId, threadId: thread.threadId, turnId: followUpTurnId });
+          } catch { /* never crash WS pipeline */ }
+        }
+      }
     }
     vpDrivers.delete(key);
     const tail = vpInboxes.get(key);
@@ -2518,6 +2633,20 @@ async function runVpTurn({ prompt, promptParts = null, groupId, vpId, threadId =
     } catch (err) {
       console.warn('[Unify] vp-status settleIdle failed:', err?.message || err);
     }
+    // fix-vp-multi-thread (bug 2): the bridge tracks per-thread status
+    // on `thread.status` separately from the broker. Multiple sites
+    // (`maybeTransitionVpStatus`, `routeEnvelopeToVpThread`'s typing
+    // transition) write to it but no site cleared it on turn end, so
+    // every finished thread was stuck reporting `thinking|streaming|tool`
+    // forever. `getRunningThreads` filters on this field, so the
+    // classifier next time the user spoke would treat the zombie as
+    // a live thread and route the new query as "related" — orphaning
+    // the message in `pendingQueries` because no engine was running
+    // to drain it. Always settle to 'idle' here.
+    if (thread) {
+      thread.status = 'idle';
+      thread.updatedAt = Date.now();
+    }
   }
 }
 
@@ -3059,6 +3188,55 @@ export async function handleUnifyFetchToolStats(_msg = {}) {
   });
 }
 
+/**
+ * Hydrate the UnifyDebugPanel from the persistent SQLite trace. The
+ * panel state (`unifyDebugLoops` / `unifyDebugTurnsById`) is otherwise
+ * built ONLY from in-flight `loop` / `turn_open` events on the wire,
+ * so a panel opened after a turn has finished sees nothing for that
+ * turn. This handler ships back a frontend-shaped snapshot the store
+ * splices into place.
+ *
+ * Inputs (all optional):
+ *   - `limit`     — max number of loops to return (1..500, default 100)
+ *   - `groupId`   — narrow by group
+ *   - `threadId`  — narrow by thread
+ *
+ * Sends:
+ *   { type: 'unify_debug_history', loops: [...], turns: [...] }
+ *
+ * Best-effort: if the session / trace isn't ready, sends an empty
+ * snapshot so the panel renders a placeholder instead of spinning.
+ */
+export async function handleUnifyFetchDebugHistory(msg = {}) {
+  const limit = Number.isFinite(msg?.limit) ? Number(msg.limit) : 100;
+  const groupId = typeof msg?.groupId === 'string' && msg.groupId ? msg.groupId : null;
+  const threadId = typeof msg?.threadId === 'string' && msg.threadId ? msg.threadId : null;
+  let loops = [];
+  let turns = [];
+  try {
+    if (session?.trace && typeof session.trace.fetchRecentDebugHistory === 'function') {
+      const out = session.trace.fetchRecentDebugHistory({ limit, groupId, threadId });
+      loops = Array.isArray(out?.loops) ? out.loops : [];
+      turns = Array.isArray(out?.turns) ? out.turns : [];
+    }
+  } catch (err) {
+    sendToServer({
+      type: 'unify_debug_history',
+      loops: [],
+      turns: [],
+      error: err && err.message ? err.message : String(err),
+    });
+    return;
+  }
+  sendToServer({
+    type: 'unify_debug_history',
+    loops,
+    turns,
+    groupId,
+    threadId,
+  });
+}
+
 /** Deprecated mode switch — Unify is single-mode. */
 export function handleUnifyModeSwitch(_msg) {
   console.warn('[Unify] unify_mode_switch is deprecated and ignored — Unify now runs in a single unified mode.');
@@ -3154,12 +3332,17 @@ export async function handleUnifyLoadHistory(msg) {
   // ~20–25 turns; in the turn-count world 50 turns of UI scrollback is
   // still cheap and matches what the frontend already passes through.
   const limit = (typeof msg.limit === 'number') ? msg.limit : 50;
-  const messages = limit > 0 ? pickRecent(session.conversationStore, limit) : [];
+  const visiblePage = groupId
+    ? loadVisibleGroupHistoryPage(session.conversationStore, groupId, limit)
+    : { messages: limit > 0 ? pickRecent(session.conversationStore, limit) : [], oldestSeq: null, hasMore: false };
   const compactSummary = session.conversationStore.readCompactSummary();
+  const replayEntries = groupId
+    ? visiblePage.messages
+    : visiblePage.messages
+      .map(projectPersistedToVisibleHistoryEntry)
+      .filter(Boolean);
 
-  for (const m of messages) {
-    const entry = projectPersistedToHistoryEntry(m);
-    if (!entry) continue;
+  for (const entry of replayEntries) {
     if (entry.role === 'user') {
       sendUnifyOutput({ type: 'user', message: { content: entry.content, id: entry.id || null } }, { groupId: entry.groupId || null });
     } else if (entry.role === 'assistant') {
@@ -3181,33 +3364,19 @@ export async function handleUnifyLoadHistory(msg) {
 
   // Compute the pagination cursor for the bootstrap load so the frontend
   // knows whether a "Load older messages" hint should be shown and where
-  // to start the next page. The cursor is the seq of the oldest replayed
-  // message; `hasMore` is true iff there's an earlier message in the
-  // group that we did NOT replay.
+  // to start the next page. For group history, this is computed from the
+  // visible projected page, not raw persisted rows, so reflection/internal
+  // tail rows cannot consume the bootstrap window or create false hasMore.
   let hasMore = false;
   let oldestSeq = null;
-  if (groupId && messages.length > 0) {
-    const firstId = messages[0].id;
-    const seq = parseSeqFromId(firstId);
-    // Defend against malformed ids: a NaN cursor would round-trip back as
-    // a poison `beforeSeq` and degrade subsequent paginations to "give me
-    // the newest page again". Surface as null instead.
-    oldestSeq = Number.isFinite(seq) ? seq : null;
-    if (oldestSeq != null) {
-      // Consult the store for whether anything older exists in the same
-      // group. Cheap: a single extra `loadOlderByGroup` with turns=1.
-      try {
-        const probe = session.conversationStore.loadOlderByGroup(groupId, oldestSeq, 1);
-        hasMore = probe.messages.length > 0;
-      } catch (err) {
-        console.error('[Unify] history-load probe failed:', err.message);
-      }
-    }
+  if (groupId) {
+    hasMore = visiblePage.hasMore;
+    oldestSeq = visiblePage.oldestSeq;
   }
 
   sendUnifyEvent({
     type: 'history_loaded',
-    count: messages.length,
+    count: replayEntries.length,
     hasCompactSummary: !!compactSummary,
     totalHot: session.conversationStore.countHot(),
     totalCold: session.conversationStore.countCold(),
@@ -3249,7 +3418,7 @@ export async function handleUnifyLoadMoreHistory(msg) {
 
   let result;
   try {
-    result = session.conversationStore.loadOlderByGroup(groupId, beforeSeq, turns);
+    result = loadVisibleGroupHistoryPage(session.conversationStore, groupId, turns, beforeSeq);
   } catch (err) {
     console.error('[Unify] loadOlderByGroup failed:', err.message);
     result = { messages: [], oldestSeq: null, hasMore: false };
@@ -3260,8 +3429,6 @@ export async function handleUnifyLoadMoreHistory(msg) {
   // server-side, and stable ids + speaker attribution ride with each row
   // so older-history prepend renders exactly like refresh replay.
   const projected = (result.messages || [])
-    .map(projectPersistedToHistoryEntry)
-    .filter(m => m && (m.role === 'user' || m.role === 'assistant'))
     .map(m => ({
       ...(m.id ? { id: m.id } : {}),
       role: m.role,