@yeaft/webchat-agent 1.0.623 → 1.0.624

package/yeaft/person/sqlite-store.js

@@ -10,6 +10,7 @@ import { attachmentMetadata, attachmentRequestHash, validateFiles } from './atta
 import { capabilityExperienceView, recordCapabilityExperience } from './capability-experience.js';
 import { chronologicalCursor, conceptView, inspectionCursor, inspectionPage, inspectRequest, messageView, personName, searchRequest, settingsView, stateView } from './inspection.js';
 import { TOKEN_FIELDS, turnsPage, turnView } from './turn-diagnostics.js';
+import { personPresentation } from './presentation.js';
 import { inspectCapabilities } from './capabilities.js';
 import { OUTPUT_LIMITS, outputArgs, outputMime, outputReadRequest, outputsPage, outputUrl, outputView } from './outputs.js';
 
@@ -65,7 +66,7 @@ const objectOutput = (record, data) => {
   }
 };
 const READS = new Set(['outputs', 'outputRead', 'checkOutputPublication', 'receipt', 'turns', 'inspect', 'search', 'getPerson', 'context', 'recall', 'list', 'searchChanges', 'resolveMemories', 'createdCapabilities', 'episodeAttachments']);
-const WRITES = new Set(['executionControl', 'saveOutput', 'open', 'recover', 'admit', 'heartbeat', 'append', 'startCall', 'finalizeCall', 'startCapability', 'finalizeCapability', 'commit', 'publishProgress', 'finish', 'cancel', 'settings', 'snapshot', 'saveCreatedCapability']);
+const WRITES = new Set(['executionControl', 'savePresentation', 'saveOutput', 'open', 'recover', 'admit', 'heartbeat', 'append', 'startCall', 'finalizeCall', 'startCapability', 'finalizeCapability', 'commit', 'publishProgress', 'finish', 'cancel', 'settings', 'snapshot', 'saveCreatedCapability']);
 const memoryKind = kind => { if (!['messages', 'concepts'].includes(kind)) fail('INVALID_REQUEST'); return kind; };
 const boundedLimit = (limit, max = 100) => { if (!Number.isSafeInteger(limit) || limit < 1 || limit > max) fail('INVALID_REQUEST'); return limit; };
 const sequence = value => {
@@ -292,7 +293,7 @@ export class SqlitePersonStore {
   }
   append(episode, kind, data) {
     // Call proof/publication events are emitted only by their transactional methods.
-    if (['call_started', 'call_output', 'call_failed', 'capability_created', 'capability_finalized', 'output_published'].includes(kind)) fail('INVALID_REQUEST');
+    if (['call_started', 'call_output', 'call_failed', 'capability_created', 'capability_finalized', 'output_published', 'presentation_published'].includes(kind)) fail('INVALID_REQUEST');
     const p = this.own(episode);
     const record = this.one('episodes', this.episodeScope(episode), ' AND id = ?', [episode.id]);
     if (!record || record.status !== 'running') fail('STALE');
@@ -400,6 +401,48 @@ export class SqlitePersonStore {
       state: stateView(state), messages: this.rows('messages', scope, ' ORDER BY seq DESC LIMIT 12').reverse().map(messageView),
       concepts: [...new Map([...focused, ...recent].map(c => [c.id, conceptView(c)])).values()] };
   }
+  /** Atomic capability publication: exact started invocation + live lease, never
+   * publishProgress's no-open-capability path. JSON carries the canonical payload;
+   * text remains the searchable/model/legacy fallback. phase is delivery intent. */
+  savePresentation(episode, { callId, args }) {
+    identifier(callId);
+    const presentation = personPresentation(args);
+    const p = this.own(episode), scope = this.episodeScope(episode);
+    const record = this.one('episodes', scope, ' AND id = ?', [episode.id]);
+    const invocationHash = digest({ id: 'PresentResponse', args });
+    const prior = this.rows('messages', scope, " AND json_extract(record, '$.episodeId') = ? AND json_type(record, '$.presentation') = 'object'", [episode.id]);
+    const receipt = this.one('traces', scope,
+      " AND json_extract(record, '$.episodeId') = ? AND json_extract(record, '$.kind') = 'presentation_published' AND json_extract(record, '$.callId') = ?", [episode.id, callId]);
+    if (receipt) {
+      if (receipt.invocationHash !== invocationHash) fail('INVALID_REQUEST');
+      const message = prior.find(m => m.id === receipt.messageId);
+      if (!message) fail('STORAGE_UNAVAILABLE');
+      return messageView(message);
+    }
+    const proof = this.one('traces', scope,
+      " AND json_extract(record, '$.episodeId') = ? AND json_extract(record, '$.kind') = 'call_output' AND json_extract(record, '$.callId') = ? AND json_extract(record, '$.output.complete') = 1", [episode.id, callId]);
+    if (!record || record.status !== 'running' || record.openCall || !proof || record.openCapability?.callId !== callId ||
+        record.openCapability.invocationHash !== invocationHash) fail('STALE');
+    // Repeating an identical delivery in this episode adds no new visible answer.
+    const repeated = prior.find(m => digest(m.presentation) === digest(presentation));
+    if (repeated) {
+      this.trace(episode.ownerId, episode.id, 'presentation_published', { callId, invocationHash, messageId: repeated.id, phase: presentation.phase, duplicate: true });
+      return messageView(repeated);
+    }
+    p.messageSeq++; p.writeSerial++; this.put('persons', p);
+    const message = this.doc(scope, { id: randomUUID(), revision: 1, seq: p.messageSeq, episodeId: episode.id,
+      callId, publicationHash: invocationHash, replyKind: 'presentation', role: 'assistant',
+      text: presentation.summary, presentation, createdAt: this.now });
+    this.put('messages', message, true); this.journal(scope, 'messages', message);
+    record.lastReplyAt = this.now.toISOString(); delete record.feedback; this.put('episodes', record);
+    this.trace(episode.ownerId, episode.id, 'presentation_published', { callId, invocationHash, messageId: message.id, phase: presentation.phase });
+    return messageView(message);
+  }
+  repeatsPresentation(scope, episodeId, reply) {
+    return typeof reply === 'string' && this.rows('messages', scope,
+      " AND json_extract(record, '$.episodeId') = ? AND json_type(record, '$.presentation') = 'object'", [episodeId])
+      .some(message => message.text.trim() === reply.trim());
+  }
   /** Publish only a validated, complete call's reply. This is communication, not
    * a state/Concept commit. Fencing, dedupe and the memory journal share one transaction. */
   publishProgress(episode, { callId, reply }) {
@@ -417,7 +460,7 @@ export class SqlitePersonStore {
     if (!accepted || !proposal.next || proposal.reply !== reply) fail('INVALID_REQUEST');
     // Provider latency counts too: a call started before 30s can finish after it.
     if (this.now.getTime() - new Date(record.lastReplyAt ?? record.createdAt).getTime() < FEEDBACK.minMs ||
-        prior.some(m => m.text.trim() === reply.trim())) return null;
+        prior.some(m => m.text.trim() === reply.trim()) || this.repeatsPresentation(scope, episode.id, reply)) return null;
     p.messageSeq++; p.writeSerial++; this.put('persons', p);
     const message = this.doc(scope, { id: randomUUID(), revision: 1, seq: p.messageSeq, episodeId: episode.id,
       callId, replyKind: 'progress', role: 'assistant', text: reply, createdAt: this.now });
@@ -429,7 +472,8 @@ export class SqlitePersonStore {
   commit(episode, proposal, selection, callId, reportedSources = new Map()) {
     const p = this.own(episode), scope = this.episodeScope(episode);
     if (proposal.baseStateVersion !== episode.baseStateVersion) fail('STALE');
-    p.stateVersion++; p.writeSerial++; if (proposal.reply) p.messageSeq++;
+    const publishReply = proposal.reply && !this.repeatsPresentation(scope, episode.id, proposal.reply);
+    p.stateVersion++; p.writeSerial++; if (publishReply) p.messageSeq++;
     p.activeEpisodeId = null; p.leaseOwner = null; p.leaseUntil = new Date(0);
     this.put('persons', p);
     const revisions = [];
@@ -452,7 +496,7 @@ export class SqlitePersonStore {
     this.put('states', state);
     this.put('state_commits', this.doc(scope, { id: randomUUID(), version: p.stateVersion, parentVersion: episode.baseStateVersion,
       episodeId: episode.id, callId, conceptRevisions: revisions, state: stateView(state), createdAt: this.now }), true);
-    if (proposal.reply) {
+    if (publishReply) {
       const message = this.doc(scope, { id: randomUUID(), revision: 1, seq: p.messageSeq, episodeId: episode.id, callId, replyKind: 'final', role: 'assistant', text: proposal.reply, createdAt: this.now });
       this.put('messages', message, true); this.journal(scope, 'messages', message);
     }

package/yeaft/response-presentation.js

@@ -0,0 +1,81 @@
+/** Shared, bounded user-visible response contract for native Sessions and Persons.
+ * Contains no executable markup, filesystem access or network requests. Runtime
+ * owns identity/phase; summary remains useful without the rich client.
+ */
+const str = (maxLength = 2000) => ({ type: 'string', maxLength });
+const arr = (items, maxItems, minItems = 1) => ({ type: 'array', items, minItems, maxItems });
+const obj = (properties, required) => ({ type: 'object', properties, required, additionalProperties: false });
+const block = (type, properties, required) => obj({ type: { type: 'string', enum: [type] }, title: str(160), ...properties }, ['type', ...required]);
+export const PRESENTATION_SCHEMA = obj({
+  title: str(160),
+  summary: str(8000),
+  phase: { type: 'string', enum: ['progress', 'final'] },
+  blocks: arr({ anyOf: [
+    block('markdown', { text: str(12000) }, ['text']),
+    block('cards', { items: arr(obj({ title: str(160), text: str(2000), label: str(80) }, ['title', 'text']), 8) }, ['items']),
+    block('metrics', { items: arr(obj({ label: str(120), value: str(120), detail: str(240) }, ['label', 'value']), 8) }, ['items']),
+    block('table', { columns: arr(str(120), 8), rows: arr(arr(str(1000), 8, 1), 50) }, ['columns', 'rows']),
+    block('chart', { style: { type: 'string', enum: ['bar', 'line'] }, unit: str(60), series: arr(obj({ label: str(120), values: arr({ type: 'number' }, 40) }, ['label', 'values']), 4), labels: arr(str(120), 40) }, ['style', 'series', 'labels']),
+    block('timeline', { items: arr(obj({ label: str(120), title: str(160), text: str(2000) }, ['label', 'title', 'text']), 16) }, ['items']),
+    block('diagram', { nodes: arr(obj({ id: str(40), label: str(160) }, ['id', 'label']), 12), edges: arr(obj({ from: str(40), to: str(40), label: str(120) }, ['from', 'to']), 24, 0) }, ['nodes', 'edges']),
+    block('image', { url: str(2000), alt: str(240), caption: str(1000) }, ['url', 'alt']),
+    block('link', { url: str(2000), text: str(1000) }, ['url', 'text']),
+    block('map', { points: arr(obj({ label: str(160), latitude: { type: 'number', minimum: -90, maximum: 90 }, longitude: { type: 'number', minimum: -180, maximum: 180 }, detail: str(1000) }, ['label', 'latitude', 'longitude']), 20) }, ['points']),
+  ] }, 12),
+}, ['summary', 'blocks']);
+
+export const PRESENT_RESPONSE_DESCRIPTION = `Publish a rich user-visible response inside this turn: cards, metrics, comparison tables, bar/line charts, timelines, relationship diagrams, images, artifact links or coordinate maps. Optional: use normal text for simple answers. Supply a self-contained summary for copying, search, model history and older clients; do not repeat the whole rich answer afterwards. Use only verified data, mark uncertainty, and never fabricate chart values or coordinates. No HTML/JavaScript, arbitrary SVG, styling or executable content. Image/link URLs must be credential-free HTTP(S); images require the reader to load external content. Maps are coordinate sketches, not navigation maps, and do not fetch tiles. phase=progress continues work; phase=final is a delivery intent, not proof of task success. Runtime still owns persistence, cancellation and turn termination. Validation failure publishes nothing; correct the payload or answer in text.`;
+
+function check(value, schema, path) {
+  if (schema.anyOf) {
+    const candidate = schema.anyOf.find(s => value?.type === s.properties.type.enum[0]);
+    if (!candidate) throw new Error(`${path}: unsupported block type`);
+    return check(value, candidate, path);
+  }
+  if (schema.type === 'object') {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) throw new Error(`${path}: expected object`);
+    for (const key of Object.keys(value)) if (!Object.hasOwn(schema.properties, key)) throw new Error(`${path}.${key}: unknown field`);
+    for (const key of schema.required) if (!Object.hasOwn(value, key)) throw new Error(`${path}.${key}: required`);
+    for (const [key, item] of Object.entries(value)) check(item, schema.properties[key], `${path}.${key}`);
+  } else if (schema.type === 'array') {
+    if (!Array.isArray(value) || value.length < schema.minItems || value.length > schema.maxItems) throw new Error(`${path}: invalid item count`);
+    value.forEach((item, i) => check(item, schema.items, `${path}[${i}]`));
+  } else if (schema.type === 'string') {
+    if (typeof value !== 'string' || !value.trim() || value.length > schema.maxLength) throw new Error(`${path}: expected non-empty bounded text`);
+    if (schema.enum && !schema.enum.includes(value)) throw new Error(`${path}: unsupported value`);
+  } else if (schema.type === 'number') {
+    if (typeof value !== 'number' || !Number.isFinite(value) || Math.abs(value) > 1e12 || (schema.minimum !== undefined && value < schema.minimum) || (schema.maximum !== undefined && value > schema.maximum)) throw new Error(`${path}: invalid finite number`);
+  }
+}
+
+/** Return a canonical JSON-only snapshot; rejects rather than partially publishing. */
+export function normalizePresentation(input) {
+  check(input, PRESENTATION_SCHEMA, 'response');
+  const encoded = JSON.stringify(input);
+  if (new TextEncoder().encode(encoded).length > 49152) throw new Error('response: exceeds 48 KiB');
+  const value = JSON.parse(encoded);
+  for (const b of value.blocks) {
+    if (b.type === 'table' && b.rows.some(row => row.length !== b.columns.length)) throw new Error('table: every row must match the columns');
+    if (b.type === 'chart' && b.series.some(series => series.values.length !== b.labels.length)) throw new Error('chart: values must match labels');
+    if (b.type === 'diagram') {
+      const ids = new Set(b.nodes.map(n => n.id));
+      if (ids.size !== b.nodes.length || b.edges.some(e => !ids.has(e.from) || !ids.has(e.to))) throw new Error('diagram: unique nodes and existing edge endpoints required');
+    }
+    if (b.type === 'image' || b.type === 'link') b.url = safePresentationUrl(b.url);
+  }
+  const canonical = { version: 1, title: value.title || '', summary: value.summary, phase: value.phase || 'final', blocks: value.blocks };
+  if (new TextEncoder().encode(JSON.stringify(canonical)).length > 49152) throw new Error('response: exceeds 48 KiB');
+  return canonical;
+}
+
+/** External URLs are metadata only. Never fetch server-side or accept credentials. */
+export function safePresentationUrl(value) {
+  if (typeof value !== 'string' || /[\u0000-\u0020\u007f]/.test(value)) throw new Error('response: invalid URL');
+  let url;
+  try { url = new URL(value); } catch { throw new Error('response: invalid absolute URL'); }
+  if (!['https:', 'http:'].includes(url.protocol) || url.username || url.password) throw new Error('response: unsafe URL');
+  // Canonical URLs are encoded, so input length alone is not a safe bound.
+  // Persisted snapshots must pass exactly the same limits on replay.
+  if (url.href.length > 2000) throw new Error('response: URL exceeds 2000 characters');
+  return url.href;
+}

package/yeaft/stdio-protocol.js

@@ -319,6 +319,12 @@ export function createStreamProjector({
         state.resultText += event.text || '';
         write({ ...base, type: 'assistant', subtype: 'text_delta', delta: { type: 'text_delta', text: event.text || '' } });
         break;
+      case 'response_presentation':
+        state.resultText += event.message?.content || '';
+        write({ ...base, type: 'assistant', subtype: 'response_presentation',
+          message: event.message, content: [{ type: 'text', text: event.message?.content || '' }],
+          presentation: event.message?.presentation });
+        break;
       case 'thinking_delta':
         write({ ...base, type: 'assistant', subtype: 'thinking_delta', delta: { type: 'thinking_delta', thinking: event.text || '' } });
         break;

package/yeaft/tools/activation.js

@@ -10,6 +10,7 @@ export const ALWAYS_VISIBLE_TOOL_NAMES = Object.freeze([
   'EnterWorktree',
   'ExitWorktree',
   'AskUser',
+  'PresentResponse',
   'DiscoverTools',
   'WebSearch',
   'WebFetch',

package/yeaft/tools/index.js

@@ -25,6 +25,7 @@ import exitWorktree from './exit-worktree.js';
 
 // --- P0 Core tools ---
 import askUser from './ask-user.js';
+import presentResponse from './present-response.js';
 import webSearch from './web-search.js';
 import webFetch from './web-fetch.js';
 import historySearch from './history-search.js';
@@ -92,6 +93,7 @@ export const allTools = [
 
   // P0 Core
   askUser,
+  presentResponse,
   webSearch,
   webFetch,
   historySearch,

package/yeaft/tools/present-response.js

@@ -0,0 +1,27 @@
+import { defineTool } from './types.js';
+import { PRESENTATION_SCHEMA, normalizePresentation, PRESENT_RESPONSE_DESCRIPTION } from '../response-presentation.js';
+
+export default defineTool({
+  name: 'PresentResponse',
+  description: PRESENT_RESPONSE_DESCRIPTION,
+  parameters: PRESENTATION_SCHEMA,
+  isReadOnly: () => false,
+  isConcurrencySafe: () => false,
+  cacheWithinQuery: false,
+  duplicateCallPolicy: () => 'allow',
+  errorOutput: 'json-error-envelope',
+  async execute(input, ctx) {
+    try {
+      // Validate the entire snapshot before invoking any host-side publication.
+      const presentation = normalizePresentation(input);
+      if (ctx?.signal?.aborted) throw new Error('Response publication was cancelled.');
+      if (typeof ctx?.publishResponse !== 'function') {
+        throw new Error('Response publication is unavailable in this runtime. Use normal text.');
+      }
+      const identity = await ctx.publishResponse(presentation);
+      return JSON.stringify({ accepted: true, ...identity, message: 'Response accepted for delivery. Continue work if needed; do not repeat the summary. The normal turn boundary still applies.' });
+    } catch (error) {
+      return JSON.stringify({ error: error.message });
+    }
+  },
+});

package/yeaft/web-bridge.js

@@ -1396,6 +1396,8 @@ function projectPersistedToHistoryEntry(m, { includeReflections = false } = {})
   entry.threadId = m.threadId || m.turnId || 'main';
   if (m.turnId) entry.turnId = m.turnId;
   if (m.imageAssetAnchor) entry.imageAssetAnchor = true;
+  if (m.presentation) entry.presentation = m.presentation;
+  if (m.presentationCallId) entry.presentationCallId = m.presentationCallId;
   if (m.responseKind === 'progress' || m.responseKind === 'result') entry.responseKind = m.responseKind;
   if (Number.isInteger(m.llmCallCount) && m.llmCallCount > 0) entry.llmCallCount = m.llmCallCount;
   for (const key of ['inputTokens', 'outputTokens', 'totalTokens', 'totalMs']) {
@@ -1541,6 +1543,8 @@ function projectVisibleHistoryChunkMessages(messages = []) {
       threadId: m.threadId || m.turnId || 'main',
       ...(m.turnId ? { turnId: m.turnId } : {}),
       ...(m.imageAssetAnchor === true ? { imageAssetAnchor: true } : {}),
+      ...(m.presentation ? { presentation: m.presentation } : {}),
+      ...(m.presentationCallId ? { presentationCallId: m.presentationCallId } : {}),
       ...(Array.isArray(m.attachments) && m.attachments.length > 0 ? { attachments: hydrateHistoryAttachmentPreviews(m.attachments, m.sessionId) } : {}),
       ...(m.quote ? { quote: m.quote } : {}),
       ...(Array.isArray(m.images) && m.images.length > 0 ? { images: m.images } : {}),
@@ -1615,6 +1619,7 @@ function emitLegacyHistoryOutputFrames(replayEntries) {
         type: 'assistant',
         message: {
           id: entry.id || null,
+          ...(entry.presentation ? { presentation: entry.presentation, presentationCallId: entry.presentationCallId, responseKind: entry.responseKind } : {}),
           content: [
             ...(entry.content ? [{ type: 'text', text: entry.content }] : []),
             ...((entry.toolCalls || []).map(toolCall => ({ type: 'tool_use', ...toolCall, history: true }))),
@@ -4156,6 +4161,14 @@ function handleEngineEvent(event, hctx) {
   }
   if ((event.type === 'text_delta' || event.type === 'thinking_delta')
       && (typeof event.text !== 'string' || event.text.length === 0)) return;
+  // Reject stale publications before touching timers, queued text or history.
+  if (event.type === 'response_presentation') {
+    const message = event.message;
+    if (hctx.signal?.aborted || !message?.id || !message.presentation
+        || message.sessionId !== hctx.sessionId || message.turnId !== hctx.turnId
+        || message.speakerVpId !== hctx.vpId || message.threadId !== (hctx.threadId || 'main')
+        || hctx.presentations?.some(row => row.id === message.id)) return;
+  }
   const terminalTurnEnd = event.type === 'turn_end' && event.terminal === true;
   const managesQueryTimer = terminalTurnEnd
     || event.type === 'aborted'
@@ -4190,6 +4203,27 @@ function handleEngineEvent(event, hctx) {
       maybeTransitionVpStatus(hctx, 'streaming');
       break;
 
+    case 'response_presentation': {
+      const message = event.message;
+      if (!hctx.presentations) hctx.presentations = [];
+      hctx.presentations.push({ ...message, _textPartsCount: (hctx.assistantTextParts || []).length });
+      hctx.presentationTextPartsCount = (hctx.assistantTextParts || []).length;
+      if (!hctx.skipPartialHistory) {
+        const prompts = hctx.includeInitialPrompt ? [hctx.prompt, ...(hctx.appendedUserPrompts || [])] : (hctx.appendedUserPrompts || []);
+        appendTurnToSessionHistory(hctx.sessionId, hctx.threadId || 'main', hctx.vpId,
+          prompts, hctx.assistantTextParts || [], hctx.toolCallsAccum || [],
+          hctx.toolResultsAccum || [], hctx.thinkingBlocksAccum || [],
+          { turnId: hctx.turnId, partial: true, presentations: hctx.presentations });
+      }
+      sendSessionOutputFrame({
+        type: 'assistant',
+        message: { id: message.id, content: message.content, presentation: message.presentation,
+          presentationCallId: message.presentationCallId, responseKind: 'progress' },
+        ts: message.time || null,
+      }, envelope);
+      break;
+    }
+
     case 'thinking_delta':
       sendSessionEvent({ type: 'thinking_delta', text: event.text }, envelope);
       break;
@@ -4308,7 +4342,7 @@ function handleEngineEvent(event, hctx) {
           hctx.toolCallsAccum || [],
           hctx.toolResultsAccum || [],
           hctx.thinkingBlocksAccum || [],
-          { turnId: hctx.turnId, partial: true },
+          { turnId: hctx.turnId, partial: true, presentations: hctx.presentations },
         );
       }
       sendSessionOutputFrame({
@@ -4376,6 +4410,22 @@ function handleEngineEvent(event, hctx) {
       // stop the user-query silence watchdog before that best-effort work.
       if (event.terminal) {
         (hctx.stopQueryTimer || hctx.pauseQueryTimer)?.();
+        const publications = hctx.presentations || [];
+        for (const row of publications) {
+          row.responseKind = 'progress';
+          row.stopReason = event.stopReason;
+          if (event.stopReason !== 'end_turn') row.incomplete = true;
+        }
+        const last = publications.at(-1);
+        if (event.stopReason === 'end_turn' && last?.presentation.phase === 'final'
+            && hctx.presentationTextPartsCount === (hctx.assistantTextParts || []).length) last.responseKind = 'result';
+        if (publications.length && !hctx.skipPartialHistory) {
+          const prompts = hctx.includeInitialPrompt ? [hctx.prompt, ...(hctx.appendedUserPrompts || [])] : (hctx.appendedUserPrompts || []);
+          appendTurnToSessionHistory(hctx.sessionId, hctx.threadId || 'main', hctx.vpId,
+            prompts, hctx.assistantTextParts || [], hctx.toolCallsAccum || [],
+            hctx.toolResultsAccum || [], hctx.thinkingBlocksAccum || [],
+            { turnId: hctx.turnId, partial: true, presentations: publications });
+        }
       }
       // A normal tool_use stop means "run tools, then call the adapter again",
       // so it must NOT end the VP's visible turn. An aborted turn is terminal
@@ -5668,6 +5718,7 @@ async function runVpTurn({ prompt, promptParts = null, sessionId, vpId, threadId
         pauseQueryTimer,
         touchQueryTimer: watchdog.touch,
         stopQueryTimer: watchdog.stop,
+        signal: vpAbort.signal,
         sessionId,
         vpId,
         turnId,
@@ -5810,7 +5861,7 @@ async function runVpTurn({ prompt, promptParts = null, sessionId, vpId, threadId
       // block after the target response.
       const visiblePrompts = inboundIsInternal ? appendedUserPrompts : [prompt, ...appendedUserPrompts];
       const appendHistoryStart = perfNowMs();
-      appendTurnToSessionHistory(sessionId, threadId, vpId, visiblePrompts, assistantTextParts, toolCallsAccum, toolResultsAccum, thinkingBlocksAccum, { turnId });
+      appendTurnToSessionHistory(sessionId, threadId, vpId, visiblePrompts, assistantTextParts, toolCallsAccum, toolResultsAccum, thinkingBlocksAccum, { turnId, presentations: handlerCtx.presentations });
       if (perfTraceId) {
         recordAgentPerfTrace(ctx.CONFIG, {
           traceId: perfTraceId,
@@ -5993,7 +6044,11 @@ function buildTurnHistoryEntries(threadId, vpId, prompts, assistantTextParts, to
     }
   }
 
-  const fullText = assistantTextParts.join('');
+  const presentations = opts.presentations || [];
+  const firstPublicationOffset = presentations[0]?._textPartsCount;
+  const fullText = Number.isInteger(firstPublicationOffset)
+    ? assistantTextParts.slice(0, firstPublicationOffset).join('')
+    : assistantTextParts.join('');
   if (fullText || toolCallsAccum.length > 0) {
     // Stamp speakerVpId on assistant + tool rows so the in-memory
     // baseSnapshot filter (filterSnapshotForVp) can mirror the disk
@@ -6037,6 +6092,19 @@ function buildTurnHistoryEntries(threadId, vpId, prompts, assistantTextParts, to
       entries.push(markEntry(toolMsg));
     }
   }
+  for (let index = 0; index < presentations.length; index += 1) {
+    const record = presentations[index];
+    const entry = projectPersistedToHistoryEntry(record);
+    if (entry) entries.push(markEntry(entry));
+    // Keep later prose after its publication in the runtime cache as well as
+    // on disk. The internal offset is never projected into public history.
+    if (Number.isInteger(record._textPartsCount)) {
+      const end = presentations[index + 1]?._textPartsCount ?? assistantTextParts.length;
+      const text = assistantTextParts.slice(record._textPartsCount, end).join('');
+      if (text) entries.push(markEntry({ role: 'assistant', content: text,
+        threadId: threadId || 'main', ...(vpId ? { speakerVpId: vpId } : {}) }));
+    }
+  }
   return entries;
 }