@yeaft/webchat-agent 1.0.213 → 1.0.214

package/local-runtime/version.json

@@ -1 +1 @@
-{"version":"1.0.213"}
+{"version":"1.0.214"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "1.0.213",
+  "version": "1.0.214",
   "description": "Remote worker agent for Yeaft Web Code Agent — connects the native Yeaft engine, CLI providers, and workbench tools",
   "main": "index.js",
   "type": "module",

package/yeaft/conversation/persist.js

@@ -20,6 +20,7 @@
 import { existsSync, mkdirSync, writeFileSync, readFileSync, readdirSync, renameSync, unlinkSync, statSync, appendFileSync } from 'fs';
 import { join, basename } from 'path';
 import { isPermissionError } from '../init.js';
+import { writeAtomic } from '../storage/atomic.js';
 import { pairSanitize } from '../pair-sanitize.js';
 import { sliceLastNTurns, stripVpMentionPrefix } from '../turn-utils.js';
 import { isHiddenConversationRow } from './internal-control.js';
@@ -76,6 +77,7 @@ function emptySegmentIndex() {
     lastMessageId: null,
     activeSegment: SEGMENT_FIRST_NAME,
     segments: [],
+    foldedMessageIds: [],
   };
 }
 
@@ -91,6 +93,26 @@ function normalizeSegmentRecord(msg) {
   return out;
 }
 
+function foldedMessageIdsFrom(rows) {
+  const ids = new Set();
+  for (const row of rows || []) {
+    if (!row?._reflection || !Array.isArray(row.foldedMessageIds)) continue;
+    for (const id of row.foldedMessageIds) {
+      if (typeof id === 'string' && id) ids.add(id);
+    }
+  }
+  return ids;
+}
+
+function applyFoldedMessageTombstones(rows, additionalIds = []) {
+  const foldedIds = foldedMessageIdsFrom(rows);
+  for (const id of additionalIds || []) {
+    if (typeof id === 'string' && id) foldedIds.add(id);
+  }
+  if (foldedIds.size === 0) return rows;
+  return rows.filter(row => !foldedIds.has(row?.id));
+}
+
 function segmentNameForNumber(n) {
   return `${String(n).padStart(6, '0')}.jsonl`;
 }
@@ -363,6 +385,8 @@ function serializeMessage(msg) {
   if (msg.sessionId) fm.push(`sessionId: ${msg.sessionId}`);
   if (msg.chatId) fm.push(`chatId: ${msg.chatId}`);
   if (msg.clientMessageId) fm.push(`clientMessageId: ${msg.clientMessageId}`);
+  if (msg.incomplete) fm.push('incomplete: true');
+  if (msg.stopReason) fm.push(`stopReason: ${msg.stopReason}`);
   // Session attribution: when a VP authors an assistant turn (either
   // its own reply or a route_forward injection from another VP), stamp
   // the speaker so the UI can render the message on the correct VP track.
@@ -492,6 +516,8 @@ export function parseMessage(raw) {
       case 'sessionId': msg.sessionId = value; break;
       case 'chatId': msg.chatId = value; break;
       case 'clientMessageId': msg.clientMessageId = value; break;
+      case 'incomplete': msg.incomplete = value === 'true'; break;
+      case 'stopReason': msg.stopReason = value; break;
       case 'speakerVpId': msg.speakerVpId = value; break;
       case 'attachmentsB64':
         try {
@@ -621,8 +647,9 @@ class SegmentStore {
         idx = null;
       }
     }
-    this.index = this.#normalizeIndex(idx || this.#rebuildIndex());
-    if (!existsSync(this.indexPath) && this.hasData()) this.saveIndex();
+    const indexWasStale = idx && !this.#indexMatchesDisk(idx);
+    this.index = this.#normalizeIndex(!idx || indexWasStale ? this.#rebuildIndex() : idx);
+    if ((!existsSync(this.indexPath) || indexWasStale) && this.hasData()) this.saveIndex();
     return this.index;
   }
 
@@ -659,6 +686,12 @@ class SegmentStore {
     idx.totalMessages = (idx.totalMessages || 0) + 1;
     idx.lastMessageId = msg.id || null;
     idx.nextSeq = Math.max(Number(idx.nextSeq) || 1, seq + 1);
+    if (msg._reflection && Array.isArray(msg.foldedMessageIds)) {
+      idx.foldedMessageIds = Array.from(new Set([
+        ...(Array.isArray(idx.foldedMessageIds) ? idx.foldedMessageIds : []),
+        ...msg.foldedMessageIds.filter(id => typeof id === 'string' && id),
+      ]));
+    }
     this.saveIndex();
   }
 
@@ -672,9 +705,11 @@ class SegmentStore {
     const out = [];
     for (const seg of segments) {
       const rows = this.#readSegment(seg.file, { beforeSeq, afterSeq, desc, includeCold });
-      out.push(...rows);
+      out.push(...applyFoldedMessageTombstones(rows, idx.foldedMessageIds));
     }
-    return desc ? out.sort((a, b) => parseSeqFromId(b.id) - parseSeqFromId(a.id)) : out.sort(compareMessagesBySeq);
+    return desc
+      ? out.sort((a, b) => parseSeqFromId(b.id) - parseSeqFromId(a.id))
+      : out.sort(compareMessagesBySeq);
   }
 
   *scan({ beforeSeq = Infinity, afterSeq = -Infinity, desc = false, includeCold = false } = {}) {
@@ -685,7 +720,8 @@ class SegmentStore {
       .slice()
       .sort((a, b) => desc ? (b.lastSeq || 0) - (a.lastSeq || 0) : (a.firstSeq || 0) - (b.firstSeq || 0));
     for (const seg of segments) {
-      for (const row of this.#readSegment(seg.file, { beforeSeq, afterSeq, desc, includeCold })) yield row;
+      const rows = this.#readSegment(seg.file, { beforeSeq, afterSeq, desc, includeCold });
+      yield* applyFoldedMessageTombstones(rows, idx.foldedMessageIds);
     }
   }
 
@@ -705,18 +741,39 @@ class SegmentStore {
     for (const msg of (rows || []).filter(Boolean).sort(compareMessagesBySeq)) this.append(msg);
   }
 
+  updateById(id, updater) {
+    if (!id || typeof updater !== 'function' || !this.hasData()) return null;
+    const targetSeq = parseSeqFromId(id);
+    const idx = this.loadIndex();
+    const segment = (idx.segments || []).find((candidate) => {
+      const first = Number(candidate.firstSeq);
+      const last = Number(candidate.lastSeq);
+      return Number.isFinite(targetSeq)
+        && Number.isFinite(first)
+        && Number.isFinite(last)
+        && targetSeq >= first
+        && targetSeq <= last;
+    });
+    if (!segment?.file) return null;
+
+    const path = join(this.segmentDir, segment.file);
+    const rows = this.#readSegment(segment.file, { includeCold: true });
+    const rowIndex = rows.findIndex(row => row?.id === id);
+    if (rowIndex < 0) return null;
+    const next = updater({ ...rows[rowIndex] });
+    if (!next || typeof next !== 'object') return null;
+    const updated = { ...next, id: rows[rowIndex].id };
+    rows[rowIndex] = updated;
+
+    const body = rows.map(row => JSON.stringify(row)).join('\n') + (rows.length > 0 ? '\n' : '');
+    writeAtomic(path, body);
+    segment.bytes = Buffer.byteLength(body);
+    this.saveIndex();
+    return updated;
+  }
+
   markCold(id) {
-    if (!id || !this.hasData()) return 0;
-    const rows = this.readAll({ includeCold: true });
-    let changed = 0;
-    for (const msg of rows) {
-      if (msg?.id === id && msg.cold !== true) {
-        msg.cold = true;
-        changed += 1;
-      }
-    }
-    if (changed > 0) this.replaceAll(rows);
-    return changed;
+    return this.updateById(id, msg => ({ ...msg, cold: true })) ? 1 : 0;
   }
 
   clear() {
@@ -729,6 +786,19 @@ class SegmentStore {
     this.index = emptySegmentIndex();
   }
 
+  #indexMatchesDisk(idx) {
+    if (!existsSync(this.segmentDir)) return !(idx?.segments?.length > 0);
+    const diskFiles = readdirSync(this.segmentDir).filter(file => file.endsWith('.jsonl')).sort();
+    const indexedSegments = Array.isArray(idx?.segments) ? idx.segments : [];
+    const indexedFiles = indexedSegments.map(segment => segment?.file).filter(Boolean).sort();
+    if (diskFiles.length !== indexedFiles.length
+        || diskFiles.some((file, index) => file !== indexedFiles[index])) return false;
+    return indexedSegments.every(segment => {
+      const path = join(this.segmentDir, segment.file);
+      return existsSync(path) && statSync(path).size === Number(segment.bytes);
+    });
+  }
+
   #normalizeIndex(idx) {
     const out = { ...emptySegmentIndex(), ...(idx || {}) };
     out.segments = Array.isArray(out.segments) ? out.segments.filter(s => s && s.file) : [];
@@ -737,6 +807,9 @@ class SegmentStore {
     out.nextSeq = Math.max(Number(out.nextSeq) || 1, maxSeq + 1);
     out.activeSegment = out.activeSegment || out.segments[out.segments.length - 1]?.file || SEGMENT_FIRST_NAME;
     out.totalMessages = Number(out.totalMessages) || out.segments.reduce((sum, seg) => sum + (Number(seg.count) || 0), 0);
+    out.foldedMessageIds = Array.isArray(out.foldedMessageIds)
+      ? Array.from(new Set(out.foldedMessageIds.filter(id => typeof id === 'string' && id)))
+      : [];
     return out;
   }
 
@@ -758,10 +831,12 @@ class SegmentStore {
       };
       idx.segments.push(seg);
       idx.totalMessages += rows.length;
+      idx.foldedMessageIds.push(...foldedMessageIdsFrom(rows));
       idx.lastMessageId = rows[rows.length - 1]?.id || idx.lastMessageId;
       idx.nextSeq = Math.max(idx.nextSeq, seg.lastSeq + 1);
       idx.activeSegment = file;
     }
+    idx.foldedMessageIds = Array.from(new Set(idx.foldedMessageIds));
     return idx;
   }
 
@@ -931,6 +1006,51 @@ export class ConversationStore {
     return messages.map(m => this.append(m));
   }
 
+  /**
+   * Replace fields on one persisted message while preserving its id/order.
+   * Rewrites only the owning conversation segment set; used for async tool
+   * results that complete after their initial tool row was appended.
+   *
+   * @param {object} message — persisted row returned by append()
+   * @param {object} patch — fields to merge into the row
+   * @returns {object|null}
+   */
+  update(message, patch) {
+    if (!message?.id || !patch || typeof patch !== 'object') return null;
+    try {
+      const store = this.#segmentStoreFor(message, { create: false });
+      return store.updateById(message.id, current => ({ ...current, ...patch }));
+    } catch (err) {
+      if (isPermissionError(err)) {
+        if (!_permissionWarned) {
+          console.warn(`[Yeaft] Cannot update message ${message.id}: ${err.code}`);
+          _permissionWarned = true;
+        }
+        return null;
+      }
+      throw err;
+    }
+  }
+
+  /**
+   * Atomically publish a logical range replacement for tool folding.
+   *
+   * The original rows stay append-only on disk. A single reflection row owns
+   * their ids as tombstones, so readers either observe the complete old arc or
+   * the complete reflection — never a half-rewritten tool pair.
+   *
+   * @param {object[]} messages — persisted rows being folded
+   * @param {object} reflection — synthetic `_reflection` user row
+   * @returns {object|null}
+   */
+  foldMessages(messages, reflection) {
+    const foldedMessageIds = Array.from(new Set(
+      (messages || []).map(message => message?.id).filter(id => typeof id === 'string' && id),
+    ));
+    if (foldedMessageIds.length === 0 || !reflection || reflection._reflection !== true) return null;
+    return this.append({ ...reflection, foldedMessageIds });
+  }
+
   /**
    * Move a message from hot (messages/) to cold (cold/).
    *
@@ -1264,11 +1384,12 @@ export class ConversationStore {
    * @param {number} [turnsLimit=DEFAULT_RECENT_TURNS]
    * @returns {object[]}
    */
-  loadRecentBySession(sessionId, turnsLimit = DEFAULT_RECENT_TURNS) {
+  loadRecentBySession(sessionId, turnsLimit = DEFAULT_RECENT_TURNS, { includeReflections = false } = {}) {
     if (!sessionId) return [];
     if (turnsLimit === Infinity || turnsLimit < 0) {
       const all = this.#loadSessionMessages(sessionId);
-      const filtered = all.filter(m => m && m.sessionId === sessionId && !isHiddenConversationRow(m));
+      const filtered = all.filter(m => m && m.sessionId === sessionId
+        && (!isHiddenConversationRow(m) || (includeReflections && m._reflection === true)));
       return pairSanitize(filtered);
     }
     if (!(turnsLimit > 0)) return [];
@@ -1276,6 +1397,7 @@ export class ConversationStore {
     const { messages, truncated } = this.#loadRecentSessionWindow(sessionId, turnsLimit, {
       roles: null,
       stripAssistantToolCalls: false,
+      includeReflections,
     });
     if (truncated) {
       const hasCompact = this.hasAnyCompactSummaryForSession(sessionId);
@@ -1324,9 +1446,14 @@ export class ConversationStore {
   loadSessionHistoryForVp(sessionId, vpId) {
     if (!sessionId || !vpId) return [];
     const all = this.#loadSessionMessages(sessionId);
+    const foldedIds = foldedMessageIdsFrom(all);
     const out = [];
     for (const m of all) {
-      if (!m || m.sessionId !== sessionId) continue;
+      if (!m || m.sessionId !== sessionId || foldedIds.has(m.id)) continue;
+      if (m._reflection === true) {
+        out.push(m);
+        continue;
+      }
       if (isHiddenConversationRow(m)) continue;
       if (m.role === 'user') {
         out.push(m);
@@ -2320,7 +2447,12 @@ export class ConversationStore {
     return parseMessage(readFileSync(path, 'utf8'));
   }
 
-  #loadRecentSessionWindow(sessionId, turnsLimit, { beforeSeq = Infinity, roles = null, stripAssistantToolCalls = false } = {}) {
+  #loadRecentSessionWindow(sessionId, turnsLimit, {
+    beforeSeq = Infinity,
+    roles = null,
+    stripAssistantToolCalls = false,
+    includeReflections = false,
+  } = {}) {
     const kept = [];
     const pendingBoundaryRows = [];
     let turnsFromEnd = 0;
@@ -2366,7 +2498,7 @@ export class ConversationStore {
       if (!m || m.sessionId !== sessionId) continue;
 
       const boundaryComplete = turnsFromEnd >= turnsLimit;
-      if (isHiddenConversationRow(m)) {
+      if (isHiddenConversationRow(m) && !(includeReflections && m._reflection === true)) {
         if (boundaryComplete) {
           truncated = true;
           break;

package/yeaft/engine.js

@@ -7,7 +7,7 @@
  *   3. Call adapter.stream()
  *   4. Collect text + tool_calls from stream events
  *   5. If tool_calls → execute tools → append results → goto 3
- *   6. If end_turn → persist messages → check consolidation → done
+ *   6. Persist each completed message at its durability boundary; end_turn runs maintenance
  *   7. If max_tokens → auto-continue (up to maxContinueTurns)
  *   8. On LLMContextError → force compact → retry
  *   9. On retryable error with fallbackModel → switch model → retry
@@ -34,7 +34,6 @@ import { readSummary as readScopeSummary } from './memory/store.js';
 import { runAdjust } from './memory/adjust.js';
 import { cleanMemoryPromptText, isMemoryPromptRelevant } from './memory/prompt-cleanup.js';
 import { isVpSeedBackfillStub } from './memory/seed-backfill.js';
-import { runStopHooks } from './stop-hooks.js';
 import { perfNowMs, recordAgentPerfTrace } from './perf-trace.js';
 // Default thread marker for legacy / non-group flows. Group VP runtime may
 // pass a real threadId per (sessionId, vpId, threadId) engine instance.
@@ -512,7 +511,8 @@ export class Engine {
    * LLMAbortError (or a synthetic abort check) and yields exactly one pair
    * of events — `{type:'aborted', reason}` followed by
    * `{type:'turn_end', stopReason:'aborted'}` — then returns without
-   * persisting partial tool calls, consolidation, or stop-hook side-effects.
+   * running consolidation or other terminal maintenance. Any assistant text
+   * already streamed is durably recorded as an incomplete response.
    *
    * @type {AbortController|null}
    */
@@ -586,6 +586,9 @@ export class Engine {
   /** Task results already spliced into conversationMessages for the next request. */
   #pendingAsyncTaskConfirmIds = new Set();
 
+  /** Persisted tool rows that may receive a same-turn background-task update. */
+  #persistedToolMessages = new Map();
+
   /** Reject new same-turn deliveries once the current query starts closing. */
   #asyncTaskDeliveryClosed = true;
 
@@ -1377,57 +1380,57 @@ export class Engine {
     return this.#conversationStore.readCompactSummary();
   }
 
-  /**
-   * Persist user message and assistant response to conversation store.
-   * Skipped in read-only mode (config._readOnly).
-   *
-   * Multi-VP fan-out (Bug 1): when several engines run the same user
-   * prompt in parallel, we must NOT each write our own copy of the user
-   * message — `coord.ingest`/the orchestrator already wrote it once. Pass
-   * `userAlreadyPersisted: true` from the caller to skip the user-row
-   * append while still persisting the assistant + tool rows.
-   *
-   * @param {string} userContent
-   * @param {string} assistantContent
-   * @param {object[]} [toolCalls]
-   * @param {string} [sessionId]
-   * @param {boolean} [userAlreadyPersisted]
-   */
-  #persistMessages(userContent, assistantContent, toolCalls, sessionId, userAlreadyPersisted = false) {
-    if (!this.#conversationStore) return;
-    if (this.#config._readOnly) return;
-
-    // Persist with the active runtime thread. Legacy / non-group flows use
-    // MAIN_THREAD_ID; group VP flows pass their classified threadId.
-    const threadId = this.#currentThreadId || MAIN_THREAD_ID;
-
-    // Persist user message — unless an upstream caller (e.g. the group
-    // coordinator) has already done so for this turn.
-    if (!userAlreadyPersisted) {
-      this.#conversationStore.append({
-        role: 'user',
-        content: userContent,
-        threadId,
-        // Bug 6: stamp sessionId/chatId so history replay can route by container.
-        ...(sessionId ? { sessionId } : {}),
-        ...(this.#chatId ? { chatId: this.#chatId } : {}),
-      });
-    }
+  #canPersistConversation() {
+    return Boolean(this.#conversationStore) && !this.#config._readOnly;
+  }
 
-    // Persist assistant message
-    const assistantMsg = {
-      role: 'assistant',
-      content: assistantContent,
-      model: this.#config.model,
-      threadId,
+  #conversationRecord(message, { sessionId, turnId, model, incomplete = false, stopReason = null } = {}) {
+    const record = {
+      role: message.role,
+      content: typeof message.content === 'string'
+        ? message.content
+        : JSON.stringify(message.content ?? ''),
+      model: model || this.#config.model,
+      threadId: this.#currentThreadId || MAIN_THREAD_ID,
       ...(sessionId ? { sessionId } : {}),
       ...(this.#chatId ? { chatId: this.#chatId } : {}),
-      ...(this.#vpId ? { speakerVpId: this.#vpId } : {}),
     };
-    if (toolCalls && toolCalls.length > 0) {
-      assistantMsg.toolCalls = toolCalls;
+    if (message.toolCallId) record.toolCallId = message.toolCallId;
+    if (Array.isArray(message.toolCalls) && message.toolCalls.length > 0) record.toolCalls = message.toolCalls;
+    if (Array.isArray(message.thinkingBlocks) && message.thinkingBlocks.length > 0) record.thinkingBlocks = message.thinkingBlocks;
+    if (message.isError) record.isError = true;
+    if (message.imageAssetAnchor) record.imageAssetAnchor = true;
+    if (message._reflection) record._reflection = true;
+    if (Array.isArray(message.foldedMessageIds) && message.foldedMessageIds.length > 0) {
+      record.foldedMessageIds = [...message.foldedMessageIds];
     }
-    this.#conversationStore.append(assistantMsg);
+    if (turnId && (message.role === 'assistant' || message.role === 'tool')) record.turnId = turnId;
+    if (this.#vpId && (message.role === 'assistant' || message.role === 'tool')) record.speakerVpId = this.#vpId;
+    if (incomplete) record.incomplete = true;
+    if (stopReason) record.stopReason = stopReason;
+    return record;
+  }
+
+  #persistConversationMessage(message, context = {}) {
+    if (!this.#canPersistConversation() || !message?.role) return null;
+    const hasContent = typeof message.content === 'string'
+      ? message.content.length > 0
+      : message.content != null;
+    const hasToolCalls = Array.isArray(message.toolCalls) && message.toolCalls.length > 0;
+    const hasThinking = Array.isArray(message.thinkingBlocks) && message.thinkingBlocks.length > 0;
+    if (!hasContent && !hasToolCalls && !hasThinking && message.role !== 'tool') return null;
+    return this.#conversationStore.append(this.#conversationRecord(message, context));
+  }
+
+  #persistFoldedRange(messages, startIdx, endIdx, reflection, context = {}) {
+    if (!this.#canPersistConversation() || typeof this.#conversationStore?.foldMessages !== 'function') return null;
+    const persistedRows = (messages || []).slice(startIdx, endIdx + 1)
+      .map(message => message?._persistedMessageId || message?.id)
+      .filter(id => typeof id === 'string' && id)
+      .map(id => ({ id }));
+    if (persistedRows.length === 0) return null;
+    const record = this.#conversationRecord(reflection, context);
+    return this.#conversationStore.foldMessages(persistedRows, record);
   }
 
   /**
@@ -1652,6 +1655,15 @@ export class Engine {
         ? toolMsg.content
         : this.#formatTaskResultUpdateContent(toolMsg.content);
       toolMsg.content = `${prior}\n\n${appendText}`;
+      const persistedTool = this.#persistedToolMessages.get(update.toolCallId);
+      if (persistedTool && typeof this.#conversationStore?.update === 'function') {
+        const durablePrior = typeof persistedTool.content === 'string'
+          ? persistedTool.content
+          : this.#formatTaskResultUpdateContent(persistedTool.content);
+        const durableContent = `${durablePrior}\n\n${appendText}`;
+        const updated = this.#conversationStore.update(persistedTool, { content: durableContent });
+        if (updated) this.#persistedToolMessages.set(update.toolCallId, updated);
+      }
       applied.push(update);
       if (this.#acceptedAsyncTaskResults.has(update.taskId)) {
         this.#pendingAsyncTaskConfirmIds.add(update.taskId);
@@ -1688,6 +1700,12 @@ export class Engine {
     return deliveries.length;
   }
 
+  #persistAppendedUserMessage(item, sessionId) {
+    if (!item || item.persisted || item.internal) return;
+    this.#persistConversationMessage({ role: 'user', content: item.content }, { sessionId });
+    item.persisted = true;
+  }
+
   #drainPendingUserMessages(drainPendingUserMessages) {
     const pending = [];
     this.#externalUserWakePending = false;
@@ -1726,6 +1744,7 @@ export class Engine {
           content,
           preview,
           internal: Boolean(item.internal),
+          persisted: Boolean(item.persisted),
           taskId,
         };
       })
@@ -1850,6 +1869,7 @@ export class Engine {
       this.#asyncTaskToolMeta.clear();
       this.#pendingTaskResultMessages.length = 0;
       this.#pendingTaskResultUpdates.length = 0;
+      this.#persistedToolMessages.clear();
       // Release any parked waiters so they don't pin a microtask after
       // query() returns. The loop has already exited so they're harmless,
       // but cleanup keeps the promise graph tight.
@@ -1879,6 +1899,24 @@ export class Engine {
     const runtimeThreadId = (typeof threadId === 'string' && threadId.trim())
       ? threadId.trim()
       : MAIN_THREAD_ID;
+    const queryTurnId = randomUUID();
+    const queryStartedAt = Date.now();
+    const userQuestionPreview = String(prompt || '').slice(0, 200);
+    const queryVpId = vpPersona && typeof vpPersona === 'object'
+      && typeof vpPersona.vpId === 'string'
+      ? vpPersona.vpId
+      : (typeof senderVpId === 'string' ? senderVpId : null);
+
+    // Durability boundary: a valid user turn must exist on disk before any
+    // memory pre-flow or provider request can fail. The Web Session bridge
+    // already writes one shared user row before multi-VP fan-out, so those
+    // callers set userAlreadyPersisted and every VP skips this append.
+    if (!userAlreadyPersisted) {
+      this.#persistConversationMessage({ role: 'user', content: prompt }, {
+        sessionId: runtimeSessionId,
+      });
+    }
+
     const perfTraceId = typeof inboundEnvelope?._perfTraceId === 'string' && inboundEnvelope._perfTraceId.trim()
       ? inboundEnvelope._perfTraceId.trim()
       : (typeof inboundEnvelope?.perfTraceId === 'string' && inboundEnvelope.perfTraceId.trim() ? inboundEnvelope.perfTraceId.trim() : null);
@@ -2159,7 +2197,10 @@ export class Engine {
     // reflection; only high context pressure (>=80% of model window)
     // enables the carry-forward rewrite.
     if (groupReflectionAllowed) {
-      yield* this.#applyPendingT2Reflections(conversationMessages, prompt);
+      yield* this.#applyPendingT2Reflections(conversationMessages, prompt, {
+        sessionId: runtimeSessionId,
+        model: this.#config.model,
+      });
     }
 
     // PR-L: track this query()'s tool-arc for reflection.
@@ -2194,13 +2235,6 @@ export class Engine {
     // `queryTurnId` is the wire-level turn identifier; every event emitted
     // during this query() carries it as `turnId`. Each LLM call inside
     // the loop is a `loopNumber` (was wire field `turnNumber`).
-    const queryTurnId = randomUUID();
-    const queryStartedAt = Date.now();
-    const userQuestionPreview = String(prompt || '').slice(0, 200);
-    const queryVpId = vpPersona && typeof vpPersona === 'object'
-      && typeof vpPersona.vpId === 'string'
-      ? vpPersona.vpId
-      : (typeof senderVpId === 'string' ? senderVpId : null);
 
     yield {
       type: 'turn_open',
@@ -2250,7 +2284,8 @@ export class Engine {
     let continueTurns = 0; // auto-continue counter
     let toolLoopTurns = 0; // task-327b: tool-use turns for long-loop auto-bump
     let fullResponseText = '';
-    let hasDisplayImageAnchor = false;
+    let displayImageAnchorMessage = null;
+    let lastPersistedAssistantMessage = null;
     let currentModel = this.#config.model;
     let cumulativeInputTokens = 0;
     let cumulativeOutputTokens = 0;
@@ -2323,6 +2358,18 @@ export class Engine {
       });
       let ttfbMs = null;  // Time to first token
       let responseText = '';
+      let incompleteAssistantPersisted = false;
+      const persistIncompleteAssistantOnce = (reason) => {
+        if (incompleteAssistantPersisted || !responseText) return null;
+        incompleteAssistantPersisted = true;
+        return this.#persistConversationMessage({ role: 'assistant', content: responseText }, {
+          sessionId: runtimeSessionId,
+          turnId: vpTurnId || queryTurnId,
+          model: currentModel,
+          incomplete: true,
+          stopReason: reason,
+        });
+      };
       const toolCalls = [];
       const thinkingBlocks = []; // task-327d: collected from adapter for round-trip
       let stopReason = 'end_turn';
@@ -2351,6 +2398,7 @@ export class Engine {
       const appendedBeforeStream = this.#drainPendingUserMessages(drainPendingUserMessages);
       if (appendedBeforeStream.length > 0) {
         for (const item of appendedBeforeStream) {
+          this.#persistAppendedUserMessage(item, runtimeSessionId);
           conversationMessages.push({ role: 'user', content: item.content });
           yield {
             type: 'user_append',
@@ -2671,6 +2719,7 @@ export class Engine {
           || err?.name === 'LLMAbortError'
           || (signal?.aborted && /abort/i.test(err?.message || ''));
         if (earlyIsAbort || signal?.aborted) {
+          persistIncompleteAssistantOnce('aborted');
           traceRequest('llm.request_abort', {
             durationMs: perfNowMs() - requestPerfStart,
             ok: false,
@@ -2741,6 +2790,7 @@ export class Engine {
             };
             const slept = await sleepWithAbort(delayMs, signal);
             if (!slept || signal?.aborted) {
+              persistIncompleteAssistantOnce('aborted');
               yield { type: 'aborted', reason: this.#abortReason || 'external', turnNumber, threadId };
               yield { type: 'turn_end', turnNumber, stopReason: 'aborted', threadId };
               break;
@@ -2761,6 +2811,8 @@ export class Engine {
           continue;
         }
 
+        persistIncompleteAssistantOnce('error');
+
         this.#trace.endTurn(turnId, {
           model: currentModel,
           inputTokens: totalUsage.inputTokens,
@@ -2873,6 +2925,67 @@ export class Engine {
         rawResponse,
       });
 
+      // Build and durably append this completed provider response before
+      // yielding any post-stream diagnostics. A consumer may stop iterating at
+      // any yield; persistence therefore cannot wait for turn_end or even the
+      // debug `loop` event below.
+      const assistantMsg = { role: 'assistant', content: responseText };
+      if (toolCalls.length > 0) {
+        assistantMsg.toolCalls = toolCalls.map(tc => ({
+          id: tc.id,
+          name: tc.name,
+          input: tc.input,
+        }));
+      }
+      if (thinkingBlocks.length > 0) {
+        assistantMsg.thinkingBlocks = thinkingBlocks.map(tb => (
+          tb.redacted
+            ? { redacted: true, data: tb.data, signature: tb.signature }
+            : { thinking: tb.thinking, signature: tb.signature }
+        ));
+      }
+      if (vpPersona && vpPersona.vpId) {
+        const planForThisVp = (vpPlan && typeof vpPlan === 'object'
+          && typeof vpPlan.vpId === 'string' && vpPlan.vpId === vpPersona.vpId)
+          ? vpPlan
+          : null;
+        attachRouterPlan(assistantMsg, {
+          vpId: vpPersona.vpId,
+          forwardQuery: planForThisVp && planForThisVp.forwardQuery
+            ? planForThisVp.forwardQuery
+            : { userOriginal: prompt || '', intent: '' },
+          preselect: planForThisVp && planForThisVp.preselect
+            ? planForThisVp.preselect
+            : undefined,
+          thinking: planForThisVp && (planForThisVp.thinking === 'high' || planForThisVp.thinking === 'max')
+            ? planForThisVp.thinking
+            : null,
+          thinkingReason: planForThisVp && typeof planForThisVp.thinkingReason === 'string'
+            ? planForThisVp.thinkingReason
+            : '',
+        });
+      }
+      const previousImageAnchorMessage = displayImageAnchorMessage;
+      if (previousImageAnchorMessage && typeof this.#conversationStore?.update === 'function') {
+        const cleared = this.#conversationStore.update(previousImageAnchorMessage, { imageAssetAnchor: false });
+        if (cleared) displayImageAnchorMessage = null;
+      }
+      if (previousImageAnchorMessage && displayImageAnchorMessage === null) assistantMsg.imageAssetAnchor = true;
+      const persistedAssistantMessage = this.#persistConversationMessage(assistantMsg, {
+        sessionId: runtimeSessionId,
+        turnId: vpTurnId || queryTurnId,
+        model: currentModel,
+      });
+      if (persistedAssistantMessage) {
+        assistantMsg._persistedMessageId = persistedAssistantMessage.id;
+        if (assistantMsg.imageAssetAnchor) displayImageAnchorMessage = persistedAssistantMessage;
+        lastPersistedAssistantMessage = persistedAssistantMessage;
+      }
+      if (previousImageAnchorMessage && displayImageAnchorMessage === null && !persistedAssistantMessage) {
+        const restored = this.#conversationStore.update(previousImageAnchorMessage, { imageAssetAnchor: true });
+        displayImageAnchorMessage = restored || null;
+      }
+
       // Emit `loop` event for the debug panel.
       // feat-6af5f9f1 PR B: a Loop is one LLM call inside a Turn. The wire
       // event was historically named `debug_turn` and carried `turnNumber`,
@@ -2913,63 +3026,20 @@ export class Engine {
         rawResponse,
       };
 
-      // Append assistant message to conversation
-      const assistantMsg = { role: 'assistant', content: responseText };
-      if (toolCalls.length > 0) {
-        assistantMsg.toolCalls = toolCalls.map(tc => ({
-          id: tc.id,
-          name: tc.name,
-          input: tc.input,
-        }));
-      }
-      // task-327d: persist thinking blocks for the next turn's replay.
-      // Anthropic requires assistant.thinking blocks to be echoed back
-      // verbatim (text + signature) when the previous turn used extended
-      // thinking — see translateMessages in anthropic.js.
-      if (thinkingBlocks.length > 0) {
-        assistantMsg.thinkingBlocks = thinkingBlocks.map(tb => (
-          tb.redacted
-            ? { redacted: true, data: tb.data, signature: tb.signature }
-            : { thinking: tb.thinking, signature: tb.signature }
-        ));
-      }
-      // Phase 8 (DESIGN.md §9.15): carry the router plan back on the
-      // assistant message that produced it. Stripped at the wire by
-      // stripMetaForWire — pure bookkeeping for priorPlan continuity.
-      if (vpPersona && vpPersona.vpId) {
-        // PR-I: when the dispatcher hands us a per-VP plan whose vpId matches
-        // the active persona, persist its `forwardQuery`, `preselect`, and
-        // `thinking` on the assistant message so the next turn's
-        // priorPlan continuity (DESIGN.md §9.15) sees the live router's
-        // decision — not a synthetic stub.
-        const planForThisVp = (vpPlan && typeof vpPlan === 'object'
-          && typeof vpPlan.vpId === 'string' && vpPlan.vpId === vpPersona.vpId)
-          ? vpPlan
-          : null;
-        attachRouterPlan(assistantMsg, {
-          vpId: vpPersona.vpId,
-          forwardQuery: planForThisVp && planForThisVp.forwardQuery
-            ? planForThisVp.forwardQuery
-            : { userOriginal: prompt || '', intent: '' },
-          preselect: planForThisVp && planForThisVp.preselect
-            ? planForThisVp.preselect
-            : undefined,
-          thinking: planForThisVp && (planForThisVp.thinking === 'high' || planForThisVp.thinking === 'max')
-            ? planForThisVp.thinking
-            : null,
-          thinkingReason: planForThisVp && typeof planForThisVp.thinkingReason === 'string'
-            ? planForThisVp.thinkingReason
-            : '',
-        });
-      }
+      // Keep the same durable assistant object in the live model history.
+      // Private router metadata is stripped only at the next wire boundary.
       conversationMessages.push(assistantMsg);
       fullResponseText += responseText;
 
       // ─── Handle max_tokens → auto-continue ────────────
       if (stopReason === 'max_tokens' && continueTurns < MAX_CONTINUE_TURNS) {
         continueTurns++;
-        // Append a "Continue" user message
-        conversationMessages.push({ role: 'user', content: 'Continue' });
+        // This synthetic continuation is part of the model-visible protocol.
+        // Persist it before the next provider request so a crash does not leave
+        // the completed assistant row without its following user boundary.
+        const continueMessage = { role: 'user', content: 'Continue' };
+        this.#persistConversationMessage(continueMessage, { sessionId: runtimeSessionId });
+        conversationMessages.push(continueMessage);
         yield { type: 'turn_end', turnNumber, stopReason: 'max_tokens_continue', threadId };
         continue; // loop back to call adapter again
       }
@@ -2981,6 +3051,7 @@ export class Engine {
       const appendedAfterAssistant = this.#drainPendingUserMessages(drainPendingUserMessages);
       if (appendedAfterAssistant.length > 0) {
         for (const item of appendedAfterAssistant) {
+          this.#persistAppendedUserMessage(item, runtimeSessionId);
           conversationMessages.push({ role: 'user', content: item.content });
           yield {
             type: 'user_append',
@@ -3072,6 +3143,7 @@ export class Engine {
           const appendedAfterAsyncWait = this.#drainPendingUserMessages(drainPendingUserMessages);
           if (appendedAfterAsyncWait.length > 0) {
             for (const item of appendedAfterAsyncWait) {
+              this.#persistAppendedUserMessage(item, runtimeSessionId);
               conversationMessages.push({ role: 'user', content: item.content });
               yield {
                 type: 'user_append',
@@ -3102,6 +3174,7 @@ export class Engine {
             throw new Error('Could not close pending user input for terminal completion');
           }
           for (const item of appendedBeforeClose) {
+            this.#persistAppendedUserMessage(item, runtimeSessionId);
             conversationMessages.push({ role: 'user', content: item.content });
             yield {
               type: 'user_append',
@@ -3120,57 +3193,12 @@ export class Engine {
         }
         yield { type: 'turn_end', turnNumber, stopReason, threadId, terminal: true };
 
-        // ─── Post-query: StopHooks or Legacy ─────────────
-        if (this.#config._readOnly) {
-          // Read-only mode: skip all persistence operations
-        } else if (this.#yeaftDir && this.#conversationStore) {
-          // Full pipeline: persist + consolidate + dream gate
-          // Note: stopHooks uses fastConfig for consolidation/dream (cheaper internal tasks)
-          // but receives both configs — messages are persisted with primary model name
-          const hookResult = await runStopHooks({
-            yeaftDir: this.#yeaftDir,
-            conversationStore: this.#conversationStore,
-            adapter: this.#adapter,
-            config: this.#fastConfig,
-            primaryModel: this.#config.model,
-            messages: conversationMessages,
-            // Reflect-persist fix: tell stop-hooks the EXACT turn boundary
-            // instead of letting it heuristically scan back to the last
-            // role:'user'. With T1/T2 reflection collapse, the last
-            // role:'user' is the synthetic reflection message — not the
-            // original user prompt — so the heuristic was dropping
-            // earlier reflection messages and the original prompt off
-            // the persistence window. `turnStartIdx` is the index of
-            // the original user prompt (set at query() entry); slicing
-            // from there persists the full collapsed turn including all
-            // reflection messages and the trailing assistant response.
-            turnStartIdx,
-            trace: this.#trace,
-            // Bug 6: tag persisted messages with the originating group so
-            // history replay can re-stamp them on reload.
-            sessionId,
-            threadId,
-            turnId: vpTurnId || queryTurnId,
-            vpId: this.#vpId,
-            // Multi-VP fan-out (history-dedup): skip the user-row append
-            // in stop-hooks when the orchestrator already wrote it once
-            // for this turn. The hook still persists assistant + tool
-            // rows for THIS VP's contribution.
-            userAlreadyPersisted,
-            hasDisplayImageAnchor,
-          });
-
-          if (hookResult.consolidated) {
-            yield { type: 'consolidate', archivedCount: 0, extractedCount: 0 };
-          }
-        } else {
-          // Legacy path (no yeaftDir → use old behavior)
-          this.#persistMessages(prompt, fullResponseText, assistantMsg.toolCalls, sessionId, userAlreadyPersisted);
-
-          const consolidated = await this.#maybeConsolidate();
-          if (consolidated && consolidated.archivedCount > 0) {
-            yield { type: 'consolidate', archivedCount: consolidated.archivedCount, extractedCount: consolidated.extractedCount };
-          }
+        // Message durability is handled incrementally before this terminal
+        // branch. End-of-turn owns maintenance only; re-appending the whole
+        // turn here would duplicate rows and reintroduce the crash window.
+        const consolidated = await this.#maybeConsolidate();
+        if (consolidated && consolidated.archivedCount > 0) {
+          yield { type: 'consolidate', archivedCount: consolidated.archivedCount, extractedCount: consolidated.extractedCount };
         }
 
         // ─── Post-turn AMS adjust ────────────────────────────────
@@ -3385,7 +3413,35 @@ export class Engine {
             }
             isError = toolErrorOutput === 'json-error-envelope' && isToolErrorOutput(output);
             yield { type: 'tool_end', id: tc.id, name: tc.name, output, displayImages, isError, threadId: this.currentThreadId };
-            if (displayImages.some(image => image.deliveryQueued === true)) hasDisplayImageAnchor = true;
+            if (displayImages.some(image => image.deliveryQueued === true)
+                && lastPersistedAssistantMessage
+                && typeof this.#conversationStore?.update === 'function') {
+              const priorAnchor = displayImageAnchorMessage;
+              if (priorAnchor && priorAnchor.id !== lastPersistedAssistantMessage.id) {
+                const cleared = this.#conversationStore.update(priorAnchor, { imageAssetAnchor: false });
+                if (cleared) {
+                  const anchored = this.#conversationStore.update(lastPersistedAssistantMessage, {
+                    imageAssetAnchor: true,
+                  });
+                  if (anchored) {
+                    displayImageAnchorMessage = anchored;
+                    lastPersistedAssistantMessage = anchored;
+                  } else {
+                    displayImageAnchorMessage = this.#conversationStore.update(priorAnchor, {
+                      imageAssetAnchor: true,
+                    }) || null;
+                  }
+                }
+              } else if (!priorAnchor) {
+                const anchored = this.#conversationStore.update(lastPersistedAssistantMessage, {
+                  imageAssetAnchor: true,
+                });
+                if (anchored) {
+                  displayImageAnchorMessage = anchored;
+                  lastPersistedAssistantMessage = anchored;
+                }
+              }
+            }
           } catch (err) {
             output = `Error: ${err.message}`;
             isError = true;
@@ -3444,12 +3500,24 @@ export class Engine {
           toolName: tc.name,
           language: this.#config?.language,
         });
-        conversationMessages.push({
+        const toolMessage = {
           role: 'tool',
           toolCallId: tc.id,
           content: contextOutput,
           isError,
+        };
+        conversationMessages.push(toolMessage);
+        // Model context may use a bounded copy, but durable conversation
+        // history keeps the raw normalized tool output for recovery/debug.
+        const persistedToolMessage = this.#persistConversationMessage({ ...toolMessage, content: output }, {
+          sessionId: runtimeSessionId,
+          turnId: vpTurnId || queryTurnId,
+          model: currentModel,
         });
+        if (persistedToolMessage) {
+          toolMessage._persistedMessageId = persistedToolMessage.id;
+          this.#persistedToolMessages.set(tc.id, persistedToolMessage);
+        }
 
         // PR-L: persist this execution to the exec-log for fallback-stub
         // and duplicate-call detection. Best-effort — disk failures are
@@ -3563,6 +3631,20 @@ export class Engine {
           const next = collapseRangeToReflection(
             conversationMessages, batchStart, batchEnd, content,
           );
+          const reflectionMessage = next[batchStart];
+          const durableRowsInRange = conversationMessages
+            .slice(batchStart, batchEnd + 1)
+            .some(message => message?._persistedMessageId || message?.id);
+          const persistedReflection = this.#persistFoldedRange(
+            conversationMessages,
+            batchStart,
+            batchEnd,
+            reflectionMessage,
+            { sessionId: runtimeSessionId, model: currentModel },
+          );
+          if (durableRowsInRange && !persistedReflection) {
+            throw new Error('T1 reflection could not publish its durable range replacement');
+          }
           conversationMessages.length = 0;
           for (const m of next) conversationMessages.push(m);
           // After collapse: the just-inserted reflection lives at
@@ -3696,8 +3778,9 @@ export class Engine {
    *
    * @param {Array} conversationMessages
    * @param {string} originalUserMsg
+   * @param {{sessionId?: string, model?: string}} context
    */
-  async *#applyPendingT2Reflections(conversationMessages, originalUserMsg) {
+  async *#applyPendingT2Reflections(conversationMessages, originalUserMsg, context = {}) {
     if (this.#pendingT2.size === 0) return;
     // Drain in insertion order (Map preserves it). We process all entries
     // because the user could send multiple prompts back-to-back before
@@ -3739,8 +3822,20 @@ export class Engine {
         continue;
       }
 
-      // Rewrite history.
+      // Rewrite history and publish the same logical replacement to disk.
       const next = collapseRangeToReflection(conversationMessages, startIdx, endIdx, content);
+      const reflectionMessage = next[startIdx];
+      const durableRowsInRange = conversationMessages
+        .slice(startIdx, endIdx + 1)
+        .some(message => message?._persistedMessageId || message?.id);
+      const persistedReflection = this.#persistFoldedRange(
+        conversationMessages,
+        startIdx,
+        endIdx,
+        reflectionMessage,
+        context,
+      );
+      if (durableRowsInRange && !persistedReflection) continue;
       // Mutate in place so caller's reference stays valid.
       conversationMessages.length = 0;
       for (const m of next) conversationMessages.push(m);

package/yeaft/router/continuity.js

@@ -98,9 +98,9 @@ export function stripMetaForWire(messages) {
   let mutated = false;
   const out = messages.map(m => {
     if (m && typeof m === 'object'
-        && ('_meta' in m || '_runtimeTurnId' in m || '_partialTurn' in m)) {
+        && ('_meta' in m || '_runtimeTurnId' in m || '_partialTurn' in m || '_persistedMessageId' in m)) {
       mutated = true;
-      const { _meta, _runtimeTurnId, _partialTurn, ...rest } = m;
+      const { _meta, _runtimeTurnId, _partialTurn, _persistedMessageId, ...rest } = m;
       return rest;
     }
     return m;

package/yeaft/web-bridge.js

@@ -1176,12 +1176,15 @@ function isPersistedInternalMessage(m) {
  * @param {object} m — record from conversationStore.loadRecent*()
  * @returns {object|null} history-shape entry, or null to skip
  */
-function projectPersistedToHistoryEntry(m) {
+function projectPersistedToHistoryEntry(m, { includeReflections = false } = {}) {
   if (!m) return null;
   if (m.role !== 'user' && m.role !== 'assistant' && m.role !== 'tool') return null;
-  if (isPersistedInternalMessage(m)) return null;
+  if (isPersistedInternalMessage(m) && !(includeReflections && m._reflection === true)) return null;
   const entry = { role: m.role, content: m.role === 'tool' ? m.content : __testNormalizePersistedVisibleContent(m.content) };
-  if (m.id) entry.id = m.id;
+  if (m.id) {
+    entry.id = m.id;
+    entry._persistedMessageId = m.id;
+  }
   entry.threadId = m.threadId || m.turnId || 'main';
   if (m.turnId) entry.turnId = m.turnId;
   if (m.imageAssetAnchor) entry.imageAssetAnchor = true;
@@ -1441,14 +1444,18 @@ function hydrateGroupHistory(sessionId) {
   if (!session?.conversationStore || !sessionId) return [];
   let recent;
   try {
-    recent = session.conversationStore.loadRecentBySession(sessionId);
+    recent = session.conversationStore.loadRecentBySession(
+      sessionId,
+      undefined,
+      { includeReflections: true },
+    );
   } catch (err) {
     console.warn('[Yeaft] hydrateGroupHistory failed (sessionId=%s):', sessionId, err?.message || err);
     return [];
   }
   const out = [];
   for (const m of recent || []) {
-    const entry = projectPersistedToHistoryEntry(m);
+    const entry = projectPersistedToHistoryEntry(m, { includeReflections: true });
     if (entry) out.push(entry);
   }
   return out;
@@ -5079,7 +5086,7 @@ async function runVpTurn({ prompt, promptParts = null, sessionId, vpId, threadId
         vpTurnId: turnId,
         drainPendingUserMessages: () => {
           if (!thread || !Array.isArray(thread.pendingQueries) || thread.pendingQueries.length === 0) return [];
-          return thread.pendingQueries.splice(0);
+          return thread.pendingQueries.splice(0).map(item => ({ ...item, persisted: true }));
         },
         ...queryOpts,
       })) {