@yeaft/webchat-agent 1.0.507 → 1.0.509

package/yeaft/history-window.js

@@ -27,6 +27,7 @@ export const DEFAULT_RUNTIME_CACHE_TURN_CAP = 25;
 export const DEFAULT_RUNTIME_CACHE_TOKEN_BUDGET = 32768;
 export const DEFAULT_RUNTIME_CACHE_MESSAGE_CAP = 256;
 
+const MINIMUM_RECENT_PROVIDER_TURNS = 5;
 const IMAGE_PART_TOKEN_COST = 1024;
 const DOCUMENT_PART_TOKEN_COST = 2048;
 const CONTENT_PART_FRAME_TOKENS = 2;
@@ -565,10 +566,11 @@ function truncateToolResultsForModel(messages, options = {}) {
 
 const HISTORY_SOURCE_INDEX = Symbol('historySourceIndex');
 
-function withHistorySourceIndexes(messages) {
+function withHistorySourceIndexes(messages, offset = 0) {
   return messages.map((message, index) => (
     message && typeof message === 'object'
-      ? { ...message, [HISTORY_SOURCE_INDEX]: index }
+      ? { ...message, [HISTORY_SOURCE_INDEX]: Number.isInteger(message[HISTORY_SOURCE_INDEX])
+        ? message[HISTORY_SOURCE_INDEX] : offset + index }
       : message
   ));
 }
@@ -795,12 +797,13 @@ function bucketTextMessages(messages) {
 }
 
 function bucketTurn(messages, index, supplied = {}) {
-  const user = messages.find(bucketUserBoundary);
-  const sourceIds = [...new Set(messages.flatMap(bucketSourceIds))];
-  const keys = [...new Set(messages.filter(bucketUserBoundary).flatMap(bucketUserKeys))];
+  const indexedMessages = withHistorySourceIndexes(messages, index ?? 0);
+  const user = indexedMessages.find(bucketUserBoundary);
+  const sourceIds = [...new Set(indexedMessages.flatMap(bucketSourceIds))];
+  const keys = [...new Set(indexedMessages.filter(bucketUserBoundary).flatMap(bucketUserKeys))];
   if (supplied.id) keys.push(`turn:${supplied.id}`);
   if (keys.length === 0 && index != null) keys.push(`snapshot:${index}`);
-  const text = bucketTextMessages(messages);
+  const text = bucketTextMessages(indexedMessages);
   return {
     ...supplied,
     id: supplied.id || keys[0] || `snapshot:${index}`,
@@ -808,7 +811,7 @@ function bucketTurn(messages, index, supplied = {}) {
     sourceIds,
     userSeq: Number.isFinite(supplied.userSeq) ? supplied.userSeq : bucketSequence(user),
     index,
-    messages,
+    messages: indexedMessages,
     text,
     tokens: estimateMessagesTokens(text),
   };
@@ -893,19 +896,21 @@ function describeBucket(turns, messages = turns.flatMap(turn => turn.text)) {
 
 /**
  * Recompute provider history from untrimmed candidates; never mutate/cache the
- * result in the transcript. Past human turns are atomic text units, including
- * every VP's assistant text. Tools are optional enrichment, newest first.
+ * result in the transcript. Past human turn boundaries are retained when the
+ * configured recent window fits; tools are optional enrichment, newest first.
  *
  * The active turn is outside both buckets and consumes the global budget first.
- * Its opening user row is protected; an oversized active turn alone may be
- * fitted using the legacy protocol-safe transform. Past turns are never fitted.
- * External recall must have comparable userSeq/source identities to establish
+ * Its opening user row is protected. Recent text stays complete: reduce the
+ * oldest end of the suffix down to five turns (or all available for a new
+ * Session); fail closed if that floor cannot fit. Related recall only uses
+ * remaining budget and stays optional and complete. External recall must have
+ * comparable userSeq/source identities to establish
  * that it predates recent/current history; unknown chronology fails closed.
  *
  * @param {Array<object>} snapshot Untrimmed history plus the active execution.
  * @param {{ prompt?: string, relatedTurns?: Array<object>, recentTurnCap?: number,
  * relatedTurnCap?: number, messageTokenBudget?: number, maxMessageCount?: number,
- * language?: string, currentTurnStartIndex?: number,
+ * keepToolTurns?: number, language?: string, currentTurnStartIndex?: number,
  * scoreTurn?: (turn: object, prompt: string) => (number|object) }} [options]
  * @returns {{messages: Array<object>, meta: object}}
  */
@@ -914,7 +919,8 @@ export function buildHistoryBuckets(snapshot, options = {}) {
   const tokenBudget = bucketCap(options.messageTokenBudget, DEFAULT_MESSAGE_TOKEN_BUDGET);
   const messageCap = bucketCap(options.maxMessageCount, DEFAULT_RUNTIME_CACHE_MESSAGE_CAP);
   const recentCap = bucketCap(options.recentTurnCap, 20);
-  const relatedCap = bucketCap(options.relatedTurnCap, 8, 10);
+  const relatedCap = bucketCap(options.relatedTurnCap, 5, 5);
+  const keepToolTurns = bucketCap(options.keepToolTurns, DEFAULT_KEEP_TOOL_TURNS);
   const allTurns = splitBucketTurns(source);
   const currentStart = Number.isInteger(options.currentTurnStartIndex)
     ? Math.max(0, Math.min(source.length, options.currentTurnStartIndex))
@@ -1017,28 +1023,26 @@ export function buildHistoryBuckets(snapshot, options = {}) {
       // past-turn boundary is still a safe fence; never guess from text/time.
       || (turn.index == null && currentIdentity.userSeq == null && past.length > 0
         && bucketBefore(turn, past.at(-1)))));
-  // A candidate inside the initial recent cap can become related after budget
-  // eviction. Reserve before picking the final suffix so it can re-enter.
-  const reservable = relatedCap > 0 ? eligible.filter(turn => turn.tokens <= availableTokens
-    && turn.text.length <= availableRows
-    && (recentCap === 0 || !past.length || bucketBefore(turn, past.at(-1)))) : [];
-  const reserve = reservable.length ? Math.floor(availableTokens * 0.25) : 0;
-  const reservedRows = reservable.length
-    ? Math.max(Math.floor(availableRows * 0.25), Math.min(...reservable.map(turn => turn.text.length))) : 0;
-  function selectRecent(limit, rowLimit = availableRows) {
-    const selected = [];
-    let tokens = 0;
-    let rows = 0;
-    for (let index = past.length - 1; index >= 0 && selected.length < recentCap; index -= 1) {
-      const turn = past[index];
-      if (tokens + turn.tokens > limit || rows + turn.text.length > rowLimit) break;
-      selected.unshift(turn);
-      tokens += turn.tokens;
-      rows += turn.text.length;
-    }
-    return selected;
+  // Recent text has first claim on history budget. Drop whole oldest turns,
+  // never reserve space for recall or truncate text to manufacture turn counts.
+  const recent = [];
+  let recentTokens = 0;
+  let recentRows = 0;
+  const recentCandidates = recentCap > 0 ? past.slice(-recentCap) : [];
+  for (let index = recentCandidates.length - 1; index >= 0; index -= 1) {
+    const turn = recentCandidates[index];
+    if (recentTokens + turn.tokens > availableTokens
+      || recentRows + turn.text.length > availableRows) break;
+    recent.unshift(turn);
+    recentTokens += turn.tokens;
+    recentRows += turn.text.length;
+  }
+  const minimumRecent = Math.min(MINIMUM_RECENT_PROVIDER_TURNS, recentCandidates.length);
+  if (recent.length < minimumRecent) {
+    const error = new Error(`Context budget cannot retain ${minimumRecent} complete recent history turns`);
+    error.code = 'HISTORY_RECENT_BUDGET_EXCEEDED';
+    throw error;
   }
-  let recent = selectRecent(availableTokens - reserve, availableRows - reservedRows);
   let remainingTokens = availableTokens - recent.reduce((total, turn) => total + turn.tokens, 0);
   let remainingRows = availableRows - recent.reduce((total, turn) => total + turn.text.length, 0);
   const related = [];
@@ -1056,29 +1060,19 @@ export function buildHistoryBuckets(snapshot, options = {}) {
     remainingTokens -= turn.tokens;
     remainingRows -= turn.text.length;
   }
-  if (!related.length) recent = selectRecent(availableTokens);
-  else {
-    // Pay the actual related cost, not the provisional reserve. Expand the
-    // recent suffix only while every related turn remains strictly older.
-    const expanded = selectRecent(
-      availableTokens - related.reduce((sum, turn) => sum + turn.tokens, 0),
-      availableRows - related.reduce((sum, turn) => sum + turn.text.length, 0),
-    );
-    while (expanded.length > recent.length && related.some(turn => (
-      !bucketBefore(turn, expanded[0]) || bucketOverlap(turn, expanded[0])
-    ))) expanded.shift();
-    if (expanded.length > recent.length) recent = expanded;
-  }
   related.sort((a, b) => bucketBefore(a, b) ? -1 : bucketBefore(b, a) ? 1 : 0);
 
   const relatedMessages = related.flatMap(turn => turn.text);
-  const recentText = withHistorySourceIndexes(recent.flatMap(turn => turn.messages)
-    .filter(isVisibleConversationRow));
-  const recentBaseline = bucketTextMessages(recentText);
+  const recentBaseline = recent.flatMap(turn => turn.text);
   // Enrich only after both complete-text buckets and the active turn are paid.
+  // Tool protocol is useful only for immediate continuity; unlike visible text,
+  // it never reaches farther back than the configured recent tool window.
+  const recentToolSource = keepToolTurns > 0
+    ? recent.slice(-keepToolTurns).flatMap(turn => turn.messages).filter(isVisibleConversationRow)
+    : [];
   const recentMessages = withoutHistorySourceIndexes(addOptionalRecentToolPairs(
     recentBaseline,
-    truncateToolResultsForModel(recentText, { language: options.language }),
+    truncateToolResultsForModel(recentToolSource, { language: options.language }),
     {
       messageTokenBudget: availableTokens - estimateMessagesTokens(relatedMessages),
       maxMessageCount: availableRows - relatedMessages.length,
@@ -1103,7 +1097,8 @@ export function buildHistoryBuckets(snapshot, options = {}) {
       budget: {
         messageTokenBudget: tokenBudget, maxMessageCount: messageCap,
         recentTurnCap: recentCap, relatedTurnCap: relatedCap,
-        relatedReservedTokens: reserve, availableHistoryTokens: availableTokens,
+        minimumRecentTurns: minimumRecent,
+        relatedReservedTokens: 0, availableHistoryTokens: availableTokens,
         usedTokens: estimateMessagesTokens(messages), usedMessages: messages.length,
       },
       dropped: {

package/yeaft/prompts.js

@@ -532,6 +532,8 @@ function renderVpPersona(vpPersona, lang, effectiveLang = 'en') {
   const name = selectVpPersonaName(vpPersona, effectiveLang);
   if (!name) return '';
   const body = selectVpPersonaBody(vpPersona, effectiveLang);
+  const runtimePreamble = typeof vpPersona.runtimePreamble === 'string'
+    ? vpPersona.runtimePreamble.trim() : '';
 
   // Persona is the IDENTITY layer (not an overlay). Do not prepend a
   // generic assistant identity here: the VP soul body is the source of truth.
@@ -540,6 +542,7 @@ function renderVpPersona(vpPersona, lang, effectiveLang = 'en') {
   const soulHeading = effectiveLang === 'zh' ? '## 灵魂' : '## Soul';
   const lines = [`# ${name}`, '', soulHeading];
   if (body) lines.push('', body);
+  if (runtimePreamble) lines.push('', runtimePreamble);
   return lines.join('\n');
 }
 

package/yeaft/session.js

@@ -49,7 +49,8 @@ import { ensureDefaultSessionIfEmpty, migrateRegisteredWorkDirSessions } from '.
 import { seedDefaultVps } from './vp/seed-defaults.js';
 import { topUpDefaultVps } from './vp/seed-topup.js';
 import { archiveLegacyScopes } from './memory/seed-backfill.js';
-import { createV2DreamScheduler, bootInitEmptyGroups, bootCatchUpStaleDream } from './dream/session-wiring.js';
+// Dream scheduler wiring is intentionally not imported while the runtime path is disabled.
+// import { createV2DreamScheduler, bootInitEmptyGroups, bootCatchUpStaleDream } from './dream/session-wiring.js';
 import { isWorkCenterEnabled } from './work-center/feature.js';
 import { openSegmentIndex } from './memory/index-db.js';
 import { syncAll as syncSegmentIndex } from './memory/segment-sync.js';
@@ -473,50 +474,20 @@ export async function loadSession(options = {}) {
   });
 
 
-  // ─── 9a. Create dream scheduler ────────────
-  // The legacy R6 dream-scheduler was retired alongside recall-r6;
-  // dream is the only active path (the `config.memoryV2` opt-out
-  // flag was retired in task-710 — wiring is unconditional).
-  // partialSession lets the v2 scheduler dereference adapter/config/
-  // engine/trace lazily — safe because callers attach more fields
-  // after this line.
-  const partialSession = {
-    yeaftDir,
-    adapter,
-    config,
-    engine,
-    trace,
-  };
-  const dreamScheduler = createV2DreamScheduler(partialSession);
-
-  // task-710: kick a dream pass at boot for any group that has user
-  // messages but zero memory segments in the FTS index. Without this a
-  // freshly opened agent had to wait an hour (or for the nudge counter
-  // to cross 50) before the first segment landed and recall could find
-  // anything. Fire-and-forget; failure logs at debug only.
-  if (memoryIndex && !config._readOnly) {
-    bootInitEmptyGroups({
-      yeaftDir,
-      memoryIndex,
-      dreamScheduler,
-      config,
-    }).catch(() => { /* best-effort boot init */ });
-  }
-
-  // fix/dream-cadence-and-ui-trigger: stale-cadence catch-up. If the
-  // newest per-group lastDreamAt across all groups is older than
-  // DREAM_INTERVAL_HOURS (or absent and there's user traffic), fire a
-  // single non-manual tick now. Independent of the interval timer —
-  // necessary because production observed 12 days between scheduled
-  // ticks (the unref'd interval did not fire reliably on long-lived
-  // server processes).
-  if (!config._readOnly) {
-    bootCatchUpStaleDream({
-      yeaftDir,
-      dreamScheduler,
-      config,
-    }).catch(() => { /* best-effort catch-up */ });
-  }
+  // ─── 9a. Dream runtime temporarily disabled ────────────
+  // Message history now supplies turn context. Keep the Dream implementation
+  // and persisted data intact, but do not create a scheduler or run boot-time
+  // initialization/catch-up while the replacement is evaluated.
+  //
+  // const partialSession = { yeaftDir, adapter, config, engine, trace };
+  // const dreamScheduler = createV2DreamScheduler(partialSession);
+  // if (memoryIndex && !config._readOnly) {
+  //   bootInitEmptyGroups({ yeaftDir, memoryIndex, dreamScheduler, config }).catch(() => {});
+  // }
+  // if (!config._readOnly) {
+  //   bootCatchUpStaleDream({ yeaftDir, dreamScheduler, config }).catch(() => {});
+  // }
+  const dreamScheduler = null;
 
   // H2.f.5 retired the old session-level thread engine registry, input queue,
   // and dispatcher. The session exposes a default `engine`; PR #797 keeps

package/yeaft/sub-agent/runner.js

@@ -221,10 +221,12 @@ export function startSubAgent(agent, deps = {}) {
       deps.parentVpPersona && typeof deps.parentVpPersona === 'object'
         ? { ...deps.parentVpPersona }
         : {};
-    baseVpPersona.persona =
-      [(baseVpPersona.persona || '').trim(), preamble.trim()]
-        .filter(Boolean)
-        .join('\n\n');
+    // Keep the spawned-agent contract outside the inherited VP soul. Stock
+    // souls can contain bilingual section markers, and persona rendering selects
+    // one language section before provider dispatch; appending the preamble to
+    // that source can therefore discard the child identity and mission. The
+    // prompt renderer appends this runtime-only block after soul selection.
+    baseVpPersona.runtimePreamble = preamble.trim();
     if (!baseVpPersona.displayName || !String(baseVpPersona.displayName).trim()) {
       baseVpPersona.displayName = `${deps.parentName || 'Parent'}/${agent.name || 'sub-agent'}`;
     }

package/yeaft/web-bridge.js

@@ -24,6 +24,7 @@ import { buildDreamOutputSnapshot } from './dream/output-snapshot.js';
 import { Engine } from './engine.js';
 import { loadSession } from './session.js';
 import { loadAgentMCPConfig, loadConfig, loadMCPConfig } from './config.js';
+import { resolveMaxOutputTokens } from './models.js';
 import {
   createManagedProjectSkill,
   createManagedSkill,
@@ -160,7 +161,8 @@ const SKILL_RELOAD_INTERVAL_MS = 2_000;
  * loads the Session.
  * @type {Map<string, {
  *   resolve:Function,
- *   reject?:Function,
+ *   reject:Function,
+ *   conversationId:string|null,
  *   sessionId:string,
  *   vpId:string,
  *   threadId:string,
@@ -176,6 +178,9 @@ const SKILL_RELOAD_INTERVAL_MS = 2_000;
  *   onAbort?:Function,
  * }>} */
 const pendingUserPrompts = new Map();
+// Instance-local retry receipts, never persisted with Session runtime data.
+const terminalUserPrompts = new Map();
+const MAX_TERMINAL_USER_PROMPTS = 256;
 
 /** @type {import('./session.js').Session | null} */
 let session = null;
@@ -2238,7 +2243,9 @@ async function routeEnvelopeToVpThread(sessionId, vpId, envelope) {
     });
   }
 
-  if (related) {
+  // An append shares the running query's request config. A quick send owns
+  // a separate query, so retain its envelope in this thread's normal inbox.
+  if (related && !envelope?._turnConfig) {
     const content = promptParts || prompt;
     const injectedBy = envelope?.msg?.meta?.injectedBy;
     const isInternalAppend = injectedBy === 'route_forward' || injectedBy === 'task_result';
@@ -3036,10 +3043,10 @@ function mergedStatusForProjectRuntime(runtime, ownerSession = session) {
 }
 
 /** Send a Yeaft Session metadata event over the legacy-compatible envelope. */
-function sendSessionEvent(event, { sessionId, chatId, vpId, turnId, threadId, requestId, requestClientId, perfTraceId } = {}) {
+function sendSessionEvent(event, { sessionId, chatId, vpId, turnId, threadId, requestId, requestClientId, perfTraceId, conversationId = yeaftConversationId } = {}) {
   sendToServer({
     type: 'yeaft_output',
-    conversationId: yeaftConversationId,
+    conversationId,
     ...(perfTraceId ? { perfTraceId } : {}),
     ...(requestId ? { requestId } : {}),
     ...(requestClientId ? { _requestClientId: requestClientId } : {}),
@@ -3085,26 +3092,52 @@ function replayPendingUserPrompts(sessionId) {
   }
 }
 
-function settlePendingUserPrompt(requestId, pending, { answers = null, timedOut = false } = {}) {
+function registerPendingUserPrompt(requestId, pending) {
+  pending.onAbort = () => settlePendingUserPrompt(requestId, pending, { aborted: true });
+  pending.timer = setTimeout(() => {
+    settlePendingUserPrompt(requestId, pending, { timedOut: true });
+  }, Math.max(0, pending.expiresAt - Date.now()));
+  pending.timer.unref?.();
+  pendingUserPrompts.set(requestId, pending);
+  if (pending.signal?.aborted) pending.onAbort();
+  else pending.signal?.addEventListener('abort', pending.onAbort, { once: true });
+}
+
+function settlePendingUserPrompt(requestId, pending, { answers = null, timedOut = false, aborted = false } = {}) {
   if (pendingUserPrompts.get(requestId) !== pending) return false;
   pendingUserPrompts.delete(requestId);
   if (pending.timer) clearTimeout(pending.timer);
   if (pending.signal && pending.onAbort) {
     try { pending.signal.removeEventListener('abort', pending.onAbort); } catch { /* ignore */ }
   }
-  try { pending.resumeQueryTimer?.(); } catch { /* best-effort */ }
-  sendSessionEvent({
-    type: timedOut ? 'ask_user_expired' : 'ask_user_answered',
+  if (!aborted) {
+    try { pending.resumeQueryTimer?.(); } catch { /* best-effort */ }
+  }
+  const expired = timedOut || aborted;
+  const event = {
+    type: expired ? 'ask_user_expired' : 'ask_user_answered',
     requestId,
     toolCallId: pending.toolCallId || null,
-    ...(timedOut ? { expiredAt: Date.now() } : { answers: answers || {} }),
-  }, {
+    ...(expired ? { expiredAt: Date.now() } : { answers: answers || {} }),
+  };
+  const identity = {
+    requestId,
+    toolCallId: pending.toolCallId,
+    conversationId: pending.conversationId,
     sessionId: pending.sessionId,
     vpId: pending.vpId,
     threadId: pending.threadId,
     turnId: pending.turnId,
-  });
-  pending.resolve(timedOut ? { __yeaftTimedOut: true } : (answers || {}));
+  };
+  terminalUserPrompts.set(requestId, { identity, event });
+  while (terminalUserPrompts.size > MAX_TERMINAL_USER_PROMPTS) {
+    terminalUserPrompts.delete(terminalUserPrompts.keys().next().value);
+  }
+  // Like prompt replay, live settlement belongs to the current projection,
+  // not the conversation generation captured when the question was created.
+  sendSessionEvent(event, { ...identity, conversationId: yeaftConversationId || pending.conversationId });
+  if (aborted) pending.reject(new Error('aborted'));
+  else pending.resolve(timedOut ? { __yeaftTimedOut: true } : (answers || {}));
   return true;
 }
 
@@ -4744,6 +4777,27 @@ function handleEngineEvent(event, hctx) {
  *   - No legacy "no-session" fallback paths — they were the source of the
  *     router_unavailable bug fixed in v0.1.671.
  */
+/** Validate a one-message override against the loaded Agent catalog, never Session config. */
+export function validateQuickSend(value, config) {
+  if (value === undefined) return null;
+  if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    throw new Error('quickSend must be an object');
+  }
+  const { model, effort, maxOutputTokens } = value;
+  const entry = typeof model === 'string' && model.includes('/')
+    ? config?.availableModels?.find(candidate => candidate.ref === model)
+    : null;
+  if (!entry) throw new Error('quickSend.model must name an available provider/model');
+  if (effort !== null && (typeof effort !== 'string' || !entry.effortOptions?.includes(effort))) {
+    throw new Error('quickSend.effort is not supported by the selected model');
+  }
+  if (maxOutputTokens !== null && (!Number.isSafeInteger(maxOutputTokens) || maxOutputTokens < 1
+      || maxOutputTokens > resolveMaxOutputTokens(entry.id, { modelInfo: entry }))) {
+    throw new Error('quickSend.maxOutputTokens must be null or a positive integer within the model output limit');
+  }
+  return { model, effort, maxOutputTokens };
+}
+
 async function runYeaftSessionSend(msg) {
   if (!msg || typeof msg !== 'object') return;
   const { text } = msg;
@@ -4800,6 +4854,20 @@ async function runYeaftSessionSend(msg) {
     return;
   }
 
+  // Reject malformed overrides before boot, roster changes, attachment writes,
+  // or coordinator persistence. The error includes the client id for retry.
+  let turnConfig = null;
+  try {
+    if (msg.quickSend !== undefined) {
+      turnConfig = validateQuickSend(msg.quickSend, loadConfig({ dir: yeaftDir }));
+    }
+  } catch (err) {
+    sendSessionOutputFrame({ type: 'error', code: 'invalid_quick_send',
+      message: err.message, clientMessageId: msg.id || null }, { sessionId });
+    sendSessionOutputFrame({ type: 'result', result_text: '', is_error: true }, { sessionId });
+    return;
+  }
+
   // Open the user-level session metadata first so project runtime loading can
   // use the stored workDir without blocking the user-message hot path. If
   // metadata is missing we still boot the agent runtime for a useful error
@@ -4981,6 +5049,7 @@ async function runYeaftSessionSend(msg) {
       // Live form — adapters need the base64 image blocks; runVpTurn
       // reads `_promptParts` off the envelope rather than going
       // back to disk on every fan-out target. NOT persisted.
+      _turnConfig: turnConfig,
       _promptParts: attachmentBundle.promptParts,
       _promptSuffix: attachmentBundle.promptSuffix,
       _perfTraceId: perfTraceId,
@@ -5166,6 +5235,12 @@ export function buildVpQueryOpts({ vpId, sessionCoordinator, sessionId, envelope
   // envelope inside router.forward.
   if (envelope && typeof envelope === 'object') {
     out.inboundEnvelope = envelope;
+    // Only direct delivery of this user message inherits quick-send settings.
+    // RouteForward and background reentry keep the recipient's own defaults.
+    if (envelope._turnConfig && !envelope.msg?.meta?.injectedBy
+        && (envelope.msg?.role === 'user' || envelope.msg?.from === 'user')) {
+      out.turnConfig = { ...envelope._turnConfig };
+    }
   }
   // TodoWrite per-thread isolation. Bind closures that read/write a slot
   // keyed by `${sessionId}::${vpId}::${threadId}` so concurrent threads for
@@ -5720,6 +5795,7 @@ async function runVpTurn({ prompt, promptParts = null, sessionId, vpId, threadId
           const pending = {
             resolve,
             reject,
+            conversationId: yeaftConversationId,
             sessionId,
             vpId,
             threadId,
@@ -5734,20 +5810,8 @@ async function runVpTurn({ prompt, promptParts = null, sessionId, vpId, threadId
             signal,
             onAbort: null,
           };
-          const onAbort = () => {
-            if (pendingUserPrompts.get(requestId) !== pending) return;
-            pendingUserPrompts.delete(requestId);
-            if (pending.timer) clearTimeout(pending.timer);
-            reject(new Error('aborted'));
-          };
-          pending.onAbort = onAbort;
-          pending.timer = setTimeout(() => {
-            settlePendingUserPrompt(requestId, pending, { timedOut: true });
-          }, ASK_USER_TIMEOUT_MS);
-          if (typeof pending.timer.unref === 'function') pending.timer.unref();
-          pendingUserPrompts.set(requestId, pending);
-          signal.addEventListener('abort', onAbort, { once: true });
-          sendPendingUserPrompt(requestId, pending);
+          registerPendingUserPrompt(requestId, pending);
+          if (pendingUserPrompts.has(requestId)) sendPendingUserPrompt(requestId, pending);
         }),
         threadId,
         vpTurnId: turnId,
@@ -6829,16 +6893,42 @@ export async function handleYeaftFetchDebugHistory(msg = {}) {
 }
 
 /** Resolve a pending Yeaft AskUser prompt from the web UI. */
-export function handleYeaftAskUserAnswer(msg) {
+export function handleYeaftAskUserAnswer(msg = {}) {
   const requestId = typeof msg?.requestId === 'string' ? msg.requestId : '';
+  const rejectAnswer = reason => {
+    // Echo only submitted identity: never expose the actual pending scope.
+    sendSessionEvent({
+      type: 'ask_user_answer_rejected', requestId,
+      toolCallId: msg?.toolCallId || null, reason,
+    }, {
+      requestId, requestClientId: msg?._requestClientId,
+      conversationId: msg?.conversationId ?? null,
+      sessionId: msg?.sessionId, vpId: msg?.vpId,
+      turnId: msg?.turnId, threadId: msg?.threadId,
+    });
+    return false;
+  };
   const pending = pendingUserPrompts.get(requestId);
-  if (!pending) return false;
-  if (msg.sessionId && msg.sessionId !== pending.sessionId) return false;
-  if (msg.vpId && msg.vpId !== pending.vpId) return false;
-  if (msg.turnId && msg.turnId !== pending.turnId) return false;
-  if (msg.threadId && msg.threadId !== pending.threadId) return false;
-  if (msg.toolCallId && msg.toolCallId !== pending.toolCallId) return false;
-
+  const terminal = terminalUserPrompts.get(requestId);
+  const identity = pending || terminal?.identity;
+  if (!identity) return rejectAnswer('unavailable');
+  // Retain legacy optional identity matching. conversationId is a projection
+  // generation, not Session ownership; it can change after a reconnect.
+  for (const field of ['sessionId', 'vpId', 'turnId', 'threadId', 'toolCallId']) {
+    if (msg[field] && msg[field] !== identity[field]) return rejectAnswer('identity_mismatch');
+  }
+  if (!pending) {
+    sendSessionEvent(terminal.event, {
+      ...terminal.identity,
+      conversationId: msg.conversationId ?? terminal.identity.conversationId,
+      requestClientId: msg._requestClientId,
+    });
+    return terminal.event.type === 'ask_user_answered' ? true : rejectAnswer('unavailable');
+  }
+  if (pending.expiresAt <= Date.now()) {
+    settlePendingUserPrompt(requestId, pending, { timedOut: true });
+    return rejectAnswer('unavailable');
+  }
   return settlePendingUserPrompt(requestId, pending, { answers: msg.answers || {} });
 }
 
@@ -8211,11 +8301,10 @@ export const __testHooks = {
     vpAborts.clear();
     vpInboxes.clear();
   },
-  seedPendingUserPrompt({ requestId = 'ask-test', sessionId = 'session-test', vpId = 'vp-test', threadId = 'main', turnId = 'turn-test', toolCallId = 'call-test', question = 'Continue?', options = [], createdAt = Date.now(), expiresAt = Date.now() + ASK_USER_TIMEOUT_MS } = {}) {
-    let resolved;
-    const promise = new Promise(resolve => { resolved = resolve; });
-    pendingUserPrompts.set(requestId, { resolve: resolved, sessionId, vpId, threadId, turnId, toolCallId, question, options, createdAt, expiresAt, timer: null });
-    return promise;
+  seedPendingUserPrompt({ requestId = 'ask-test', sessionId = 'session-test', vpId = 'vp-test', threadId = 'main', turnId = 'turn-test', toolCallId = 'call-test', conversationId = yeaftConversationId, question = 'Continue?', options = [], createdAt = Date.now(), expiresAt = Date.now() + ASK_USER_TIMEOUT_MS, signal = null } = {}) {
+    return new Promise((resolve, reject) => {
+      registerPendingUserPrompt(requestId, { resolve, reject, conversationId, sessionId, vpId, threadId, turnId, toolCallId, question, options, createdAt, expiresAt, signal });
+    });
   },
   replayPendingUserPrompts,
   settlePendingUserPromptForTest(requestId, opts = {}) {
@@ -8225,8 +8314,10 @@ export const __testHooks = {
   resetPendingUserPrompts() {
     for (const pending of pendingUserPrompts.values()) {
       if (pending.timer) clearTimeout(pending.timer);
+      if (pending.onAbort) pending.signal?.removeEventListener('abort', pending.onAbort);
     }
     pendingUserPrompts.clear();
+    terminalUserPrompts.clear();
   },
   resetVpStatusBroker() {
     if (vpStatusBroker) vpStatusBroker.reset();