@yeaft/webchat-agent 1.0.622 → 1.0.624

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "1.0.622",
+  "version": "1.0.624",
   "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/workbench/file-ops.js

@@ -1,5 +1,6 @@
 import { open, readFile, realpath, writeFile, readdir, stat, unlink, rename, mkdir, rm, copyFile, cp } from 'fs/promises';
 import { existsSync } from 'fs';
+import { execFile } from 'node:child_process';
 import { join, basename, dirname, extname, isAbsolute, relative, resolve } from 'path';
 import { platform } from 'os';
 import ctx from '../context.js';
@@ -308,6 +309,37 @@ export async function handleWriteFile(msg) {
   }
 }
 
+let pendingWindowsDrives = null;
+
+function listWindowsFixedDrives() {
+  if (pendingWindowsDrives) return pendingWindowsDrives;
+  // Drive types do not probe root accessibility or wait for disconnected mappings.
+  const command = "$ErrorActionPreference = 'Stop'; [System.IO.DriveInfo]::GetDrives()"
+    + ' | Where-Object { $_.DriveType -eq [System.IO.DriveType]::Fixed }'
+    + ' | ForEach-Object { $_.Name }';
+  pendingWindowsDrives = new Promise((resolve, reject) => {
+    execFile('powershell.exe', ['-NoLogo', '-NoProfile', '-NonInteractive', '-Command', command], {
+      windowsHide: true,
+      timeout: 5000,
+      maxBuffer: 16 * 1024,
+      encoding: 'utf8',
+    }, (error, stdout, stderr) => {
+      if (error) reject(error);
+      else if (stderr.trim()) reject(new Error(stderr.trim()));
+      else resolve(stdout);
+    });
+  }).then(stdout => {
+    const drives = stdout.trim() ? stdout.trim().split(/\r?\n/).map(line => line.trim()) : [];
+    if (drives.some(drive => !/^[A-Za-z]:\\$/.test(drive))) {
+      throw new Error('Invalid Windows drive listing');
+    }
+    return drives.sort().map(drive => ({ name: drive.slice(0, 2), type: 'directory', size: 0 }));
+  }).finally(() => {
+    pendingWindowsDrives = null;
+  });
+  return pendingWindowsDrives;
+}
+
 export async function handleListDirectory(msg) {
   const { conversationId, requestId, _requestUserId, _requestClientId } = msg;
   const dirPath = msg.dirPath || (msg.workbenchRoute?.runtimeProvider === 'work-center' ? msg.workDir : msg.dirPath);
@@ -315,17 +347,11 @@ export async function handleListDirectory(msg) {
   const conv = ctx.conversations.get(conversationId);
   const workDir = msg.workDir || conv?.workDir || ctx.CONFIG.workDir;
 
-  // 空路径：列出驱动器（Windows）或根目录（Unix）
+  // 空路径：列出固定磁盘（Windows）或根目录（Unix）
   if (!dirPath || dirPath === '') {
     try {
       if (platform() === 'win32') {
-        const drives = [];
-        for (const letter of 'CDEFGHIJKLMNOPQRSTUVWXYZ'.split('')) {
-          const drivePath = letter + ':\\';
-          if (existsSync(drivePath)) {
-            drives.push({ name: letter + ':', type: 'directory', size: 0 });
-          }
-        }
+        const drives = await listWindowsFixedDrives();
         sendWorkbenchResult(ctx, msg, {
           type: 'directory_listing',
           conversationId,

package/yeaft/cli-session-runner.js

@@ -277,6 +277,7 @@ export function createCliSessionRunner({
     try {
       for await (const event of engine.query(queryOptions)) {
         if (event.type === 'text_delta') resultText += event.text || '';
+        else if (event.type === 'response_presentation') resultText += event.message?.content || '';
         else if (event.type === 'error' && !failed) {
           failed = event.error instanceof Error
             ? event.error

package/yeaft/cli.js

@@ -721,6 +721,9 @@ async function runREPL(config, args) {
             if (event.type === 'text_delta') {
               responseText += event.text || '';
               process.stdout.write(`\n[${vpId}] ${event.text || ''}`);
+            } else if (event.type === 'response_presentation') {
+              responseText += event.message?.content || '';
+              process.stdout.write(`\n[${vpId}] ${event.message?.content || ''}`);
             } else if (event.type === 'tool_start') {
               process.stderr.write(`\n[${vpId}] ${event.name}...\n`);
             } else if (event.type === 'error') {
@@ -1251,6 +1254,7 @@ async function runOnce(config, args) {
         modelEffort: args.modelEffort || session.config.modelEffort || null,
         onEvent: ({ vpId, event }) => {
           if (event.type === 'text_delta') process.stdout.write(`\n[${vpId}] ${event.text || ''}`);
+          else if (event.type === 'response_presentation') process.stdout.write(`\n[${vpId}] ${event.message?.content || ''}`);
           else if (event.type === 'tool_start') process.stderr.write(`\n[${vpId}] ${event.name}...\n`);
           else if (event.type === 'error') process.stderr.write(`\n[${vpId}] Error: ${event.error?.message || event.error}\n`);
         },

package/yeaft/conversation/persist.js

@@ -377,6 +377,7 @@ function maybeWarnHistoryTruncated(sessionId, storeDir, recentTurnsLimit) {
  */
 let _permissionWarned = false;
 let _historyIndexMutationWarned = false;
+const _segmentIndexWarned = new Set();
 
 /** Rough token estimation: ~4 chars per token. */
 export function estimateTokens(text) {
@@ -885,7 +886,7 @@ class SegmentStore {
       || normalizedSource.streamId !== this.lineage.streamId
       || !Number.isFinite(Number(normalizedSource?.revision))
       || Number(normalizedSource.revision) !== this.lineage.revision;
-    if ((!existsSync(this.indexPath) || indexWasStale || needsMetadataUpgrade) && this.hasData()) this.saveIndex();
+    if ((!existsSync(this.indexPath) || indexWasStale || needsMetadataUpgrade) && this.hasData()) this.#saveRecoverableIndex();
     return this.index;
   }
 
@@ -894,6 +895,19 @@ class SegmentStore {
     writeFileSync(this.indexPath, `${JSON.stringify(this.index || emptySegmentIndex(), null, 2)}\n`, { encoding: 'utf8', mode: 0o644 });
   }
 
+  #saveRecoverableIndex() {
+    try {
+      this.saveIndex();
+    } catch (error) {
+      // JSONL owns the transcript; lineage already owns its identity/fence.
+      // Even a fresh read can rebuild this cache while its target is unwritable.
+      if (!_segmentIndexWarned.has(this.rootDir)) {
+        console.warn(`[Yeaft] Cannot save conversation index ${this.indexPath}: ${error?.message || error} — recoverable from transcript`);
+        _segmentIndexWarned.add(this.rootDir);
+      }
+    }
+  }
+
   metadata() {
     const idx = this.loadIndex();
     return {
@@ -918,6 +932,18 @@ class SegmentStore {
       segment = null;
     }
     const line = `${JSON.stringify(msg)}\n`;
+    const invalidatesEarlierRows = msg._reflection
+      || (Array.isArray(msg.foldedMessageIds) && msg.foldedMessageIds.length > 0);
+    // Prepare durable identity and the mutation fence BEFORE the commit point.
+    // A failed JSONL write can conservatively advance revision, but a committed
+    // fold must never be replayed with an older revision after index recovery.
+    this.#persistCurrentLineage({
+      revision: (Number(idx.revision) || 0) + (invalidatesEarlierRows ? 1 : 0),
+      anchor: establishesAnchor ? this.#lineageAnchorForLine(line) : undefined,
+    });
+    // A complete successful JSONL append is the transcript commit point. Never
+    // report a derived index failure as an uncommitted strict append afterward:
+    // callers would retry/publicize the same response under a second message id.
     appendFileSync(activePath, line, { encoding: 'utf8', mode: 0o644 });
 
     const seq = parseSeqFromId(msg.id);
@@ -933,25 +959,13 @@ class SegmentStore {
     idx.totalMessages = (idx.totalMessages || 0) + 1;
     idx.lastMessageId = msg.id || null;
     idx.nextSeq = Math.max(Number(idx.nextSeq) || 1, seq + 1);
-    const invalidatesEarlierRows = msg._reflection
-      || (Array.isArray(msg.foldedMessageIds) && msg.foldedMessageIds.length > 0);
-    // Ordinary appends are recoverable through afterSeq. Only an append that
-    // invalidates older visible rows (fold reflection/tombstones) advances the
-    // mutation revision and forces the browser to rebuild its snapshot.
-    if (invalidatesEarlierRows) {
-      idx.revision = (Number(idx.revision) || 0) + 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.#persistCurrentLineage({
-      revision: idx.revision,
-      anchor: establishesAnchor ? this.#lineageAnchorForLine(line) : undefined,
-    });
-    this.saveIndex();
+    this.#saveRecoverableIndex();
   }
 
   /**
@@ -1136,7 +1150,9 @@ class SegmentStore {
       revision: idx.revision,
       anchor: updatesAnchor ? this.#lineageAnchorForLine(JSON.stringify(updated)) : undefined,
     });
-    this.saveIndex();
+    // The rewritten transcript and its revision are committed. A cache write
+    // failure must not turn an accepted terminal update into a failed turn.
+    this.#saveRecoverableIndex();
     return updated;
   }
 
@@ -1490,15 +1506,20 @@ export class ConversationStore {
   /**
    * Append a single message to the conversation.
    *
+   * Full JSONL append is the commit point; a derived index failure afterward
+   * returns the committed id and is recoverable on read. Identity/revision
+   * preparation and transcript write failures still reject in strict mode.
+   *
    * @param {object} msg — { role, content, mode?, model?, turnNumber?, toolCalls?, toolCallId?, isError? }
+   * @param {{ strict?: boolean }} [options] — reject rather than return an unpersisted fallback on pre-commit permission errors
    * @returns {object} — the persisted message with id assigned
    */
-  append(msg) {
+  append(msg, { strict = false } = {}) {
     let seq;
     try {
       seq = this.#reserveSeqRange(1);
     } catch (err) {
-      if (!isPermissionError(err)) throw err;
+      if (strict || !isPermissionError(err)) throw err;
       // Live chat remains best-effort when its data root is read-only. The
       // returned row is usable by the current turn but is intentionally not
       // persisted; strict operations such as Session copy bypass this path.
@@ -1525,7 +1546,7 @@ export class ConversationStore {
     try {
       this.#segmentStoreFor(fullMsg, { create: true }).append(fullMsg);
     } catch (err) {
-      if (isPermissionError(err)) {
+      if (!strict && isPermissionError(err)) {
         if (!_permissionWarned) {
           console.warn(`[Yeaft] Cannot write message ${id}: ${err.code} — message not persisted`);
           _permissionWarned = true;

package/yeaft/engine.js

@@ -1095,6 +1095,7 @@ export class Engine {
     }
     const defs = [];
     for (const [, tool] of this.#tools) {
+      if (activeToolNames && !activeToolNames.has(tool.name)) continue;
       defs.push({
         name: tool.name,
         description: tool.description,
@@ -1645,6 +1646,8 @@ export class Engine {
     if (message.responseKind === 'progress' || message.responseKind === 'result') {
       record.responseKind = message.responseKind;
     }
+    if (message.presentation) record.presentation = message.presentation;
+    if (message.presentationCallId) record.presentationCallId = message.presentationCallId;
     if (Array.isArray(message.foldedMessageIds) && message.foldedMessageIds.length > 0) {
       record.foldedMessageIds = [...message.foldedMessageIds];
     }
@@ -1671,7 +1674,7 @@ export class Engine {
     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.providerState && message.role !== 'tool') return null;
-    return this.#conversationStore.append(this.#conversationRecord(message, context));
+    return this.#conversationStore.append(this.#conversationRecord(message, context), { strict: context.strict === true });
   }
 
   #persistFoldedRange(foldedMessages, reflection, context = {}) {
@@ -1885,8 +1888,10 @@ export class Engine {
     let terminalEmitted = false;
     let terminalStopReason = 'error';
     let lastTurnNumber = 0;
+    const publications = [];
     try {
       for await (const event of this.#queryLifecycle(params)) {
+        if (event?.type === 'response_presentation') publications.push(event.message);
         if (Number.isFinite(event?.turnNumber)) lastTurnNumber = event.turnNumber;
         if (event?.type === 'turn_end' && event.terminal === true) {
           terminalEmitted = true;
@@ -1916,6 +1921,16 @@ export class Engine {
         console.warn('[Engine] post-turn maintenance failed:', err?.message || err);
       }
     } finally {
+      // A delivery intent is not a successful terminal state. Persist failures
+      // (including consumers closing the generator) for reconnect/history replay.
+      if (!terminalEmitted || terminalStopReason !== 'end_turn') {
+        for (const message of publications) {
+          try { this.#conversationStore?.update?.(message, {
+            responseKind: 'progress', incomplete: true,
+            stopReason: terminalEmitted ? terminalStopReason : 'aborted',
+          }); } catch (error) { console.warn('[Engine] publication status update failed:', error?.message || error); }
+        }
+      }
       if (queryTraceId && typeof this.#trace?.finalizeQuery === 'function') {
         this.#trace.finalizeQuery(queryTraceId, {
           sessionId: params.sessionId || null,
@@ -2375,12 +2390,15 @@ export class Engine {
       && typeof this.#taskManager.listActiveTasks === 'function'
       ? this.#taskManager.listActiveTasks(runtimeSessionId)
       : [];
-    const registeredToolNames = this.#toolRegistry
+    const canPublishResponse = Boolean(runtimeSessionId) && this.#canPersistConversation()
+      && !isSubAgent && scenario === 'chat' && !vpPersona?.subAgent;
+    const registeredToolNames = (this.#toolRegistry
       ? this.#toolRegistry.getToolNames({
           collabToolPolicy: effectiveCollabToolPolicy,
           plugins: this.#config?.plugins,
         })
-      : Array.from(this.#tools.keys());
+      : Array.from(this.#tools.keys()))
+      .filter(name => name !== 'PresentResponse' || canPublishResponse);
     const registeredToolNameSet = new Set(registeredToolNames);
     const resolveCurrentActiveToolNames = () => this.#toolRegistry
       ? resolveActiveToolNames({
@@ -2398,7 +2416,7 @@ export class Engine {
           imageGenerationConfigured: typeof this.#config?.imageApiUrl === 'string'
             && this.#config.imageApiUrl.trim().length > 0,
         })
-      : null;
+      : new Set(registeredToolNames);
     const discoveredToolNames = new Set();
     const discoveryTraversals = new Map();
     const currentDiscoverableTools = () => this.#toolRegistry
@@ -2615,6 +2633,7 @@ export class Engine {
     let displayImageAnchorMessage = null;
     let lastPersistedAssistantMessage = null;
     let lastPersistedAssistantTextMessage = null;
+    const publishedResponses = new Map();
     let lastSuccessfulModel = null;
     let lastSuccessfulEffort = null;
     // `refreshConfig()` may publish a new Session model while a stream or a
@@ -2982,6 +3001,13 @@ export class Engine {
         let wireMessages = stripMetaForWire(pendingContinuationForRequest
           ? [...requestHistory, pendingContinuationForRequest]
           : requestHistory);
+        // Publication metadata belongs to transcript/UI, including history
+        // supplied on later turns. Only its plain summary enters model input.
+        wireMessages = wireMessages.map(message => {
+          if (!message.presentation && !message.presentationCallId) return message;
+          const { presentation, presentationCallId, ...modelMessage } = message;
+          return modelMessage;
+        });
 
         if (scenario !== 'work-item' && this.#yeaftDir && (this.#config?.archive?.toolResults !== false)) {
           try {
@@ -4089,6 +4115,7 @@ export class Engine {
         }
         if (stopReason === 'end_turn'
             && lastPersistedAssistantTextMessage
+            && (!lastPersistedAssistantTextMessage.presentation || lastPersistedAssistantTextMessage.presentation.phase === 'final')
             && typeof this.#conversationStore?.update === 'function') {
           const resultMessage = this.#conversationStore.update(lastPersistedAssistantTextMessage, {
             responseKind: 'result',
@@ -4181,6 +4208,7 @@ export class Engine {
       /** @type {{ kind?: string, message?: string, sourceToolCallId?: string, sourceToolName?: string } | null} */
       let toolBatchBarrier = null;
       let currentToolCallForAsyncTask = null;
+      const pendingPresentations = new Map();
       // task-707: requestEndTurn is a per-batch closure that lets a tool
       // signal "end this turn after the current batch — no adapter retry".
       // We re-create the closure each iteration because endTurnRequested
@@ -4335,6 +4363,13 @@ export class Engine {
         return {
           ...toolCtx,
           fileReadObservations,
+          publishResponse: canPublishResponse ? presentation => {
+            if (signal?.aborted || this.#currentQueryTurnId !== queryTurnId) {
+              throw new Error('Response publication was cancelled.');
+            }
+            if (!publishedResponses.has(toolCall.id)) pendingPresentations.set(toolCall.id, presentation);
+            return { callId: toolCall.id, sessionId: runtimeSessionId, turnId: queryTurnId, vpId: requestIdentity.vpId };
+          } : null,
           currentToolCall: () => ({ ...stableToolCall }),
           askUser: typeof askUser === 'function'
             ? input => askUser(input, { ...stableToolCall })
@@ -4651,7 +4686,10 @@ export class Engine {
               output = stripDisplayImageData(output, displayImages);
             }
             isError = toolErrorOutput === 'json-error-envelope' && isToolErrorOutput(output);
-            yield { type: 'tool_end', id: tc.id, name: tc.name, output, displayImages, isError, threadId: this.currentThreadId };
+            // Publication acknowledgement waits for its strict durable write below.
+            if (!pendingPresentations.has(tc.id)) {
+              yield { type: 'tool_end', id: tc.id, name: tc.name, output, displayImages, isError, threadId: this.currentThreadId };
+            }
             if (displayImages.some(image => image.deliveryQueued === true)
                 && lastPersistedAssistantMessage
                 && typeof this.#conversationStore?.update === 'function') {
@@ -4837,6 +4875,45 @@ export class Engine {
         if (fatalToolError) throw fatalToolError;
       }
 
+      // Complete the result batch before adding assistant publications so both
+      // persisted history and provider requests retain contiguous tool pairs.
+      for (const [callId, presentation] of pendingPresentations) {
+        if (signal?.aborted || this.#currentQueryTurnId !== queryTurnId) break;
+        if (publishedResponses.has(callId)) continue;
+        const toolMessage = conversationMessages.findLast(row => row.role === 'tool' && row.toolCallId === callId);
+        const message = {
+          role: 'assistant', content: presentation.summary, presentation,
+          presentationCallId: callId, responseKind: 'progress',
+          speakerVpId: requestIdentity.vpId,
+        };
+        let record;
+        try {
+          record = this.#persistConversationMessage(message, {
+            sessionId: runtimeSessionId, turnId: queryTurnId, model: currentModel, executionOrigin, strict: true,
+          });
+          if (!record?.id) throw new Error('Response publication could not be persisted.');
+        } catch (error) {
+          // A storage error is a recoverable tool failure, not a delivery or a
+          // successful final answer. Let the model correct it or use plain text.
+          const output = JSON.stringify({ error: `Response publication failed: ${error.message}` });
+          if (toolMessage) Object.assign(toolMessage, { content: output, isError: true });
+          const toolRecord = this.#persistedToolMessages.get(callId);
+          try { this.#conversationStore?.update?.(toolRecord, { content: output, isError: true }); } catch { /* original storage failure */ }
+          yield { type: 'tool_end', id: callId, name: 'PresentResponse', output, isError: true, threadId: runtimeThreadId };
+          continue;
+        }
+        publishedResponses.set(callId, record);
+        lastPersistedAssistantTextMessage = record;
+        // Metadata is transcript/UI-only. Providers receive the summary as a
+        // regular assistant string, never a generic unknown content block.
+        conversationMessages.push({ role: 'assistant', content: message.content, _persistedMessageId: record.id });
+        fullResponseText += presentation.summary;
+        // Do not yield an acknowledgement between the cancellation fence/write
+        // and the publication: a consumer can abort at every yielded event.
+        yield { type: 'response_presentation', message: record, threadId: runtimeThreadId };
+        yield { type: 'tool_end', id: callId, name: 'PresentResponse', output: toolMessage?.content || '', isError: false, threadId: runtimeThreadId };
+      }
+
       // Preload rules for observed read paths before the next provider input.
       // No tool from the just-completed response can benefit retroactively.
       projectDocSource = this.#getProjectDocBlock(workDir);

package/yeaft/person/capabilities.js

@@ -4,10 +4,13 @@ import { createdCapabilityRecord, validateCreatedDefinition } from './created-ca
 import { runPersonScript, scriptInput, testPersonScript } from './script-executor.js';
 import { chronologicalCursor, createdSkillView, inspectionCursor, inspectionPage, inspectionTime } from './inspection.js';
 import { publishOutput } from './outputs.js';
+import { PRESENTATION_SCHEMA, PRESENT_RESPONSE_DESCRIPTION } from '../response-presentation.js';
+import { publishPresentation } from './presentation.js';
 
 // Intrinsic cognition, bounded pure scripts and supported native host tools.
 // No shell/filesystem/network/VP authority is exposed to generated code.
 const entries = [
+  { id: 'PresentResponse', version: 1, domain: 'delivery', description: 'Publish a structured user-visible answer with a searchable plain-text summary.', keywords: '展示 回答 图表 表格 卡片 时间线 present response chart table cards timeline rich', useWhen: 'Rich structure improves an answer; ordinary reply remains valid for simple text.', avoidWhen: 'Do not expose secrets, fabricate evidence or repeat an already published summary.', instructions: `${PRESENT_RESPONSE_DESCRIPTION} Invoke via next.capability; set reply:null for this delivery. Publication never commits state/concepts or ends the episode, even with phase=final; reserve a later next:null for the cognitive commit.`, args: PRESENTATION_SCHEMA, access: 'publish-owner-message' },
   { id: 'Think', version: 1, domain: 'cognition', description: 'Intrinsic deliberate reflection, reorganization, association and reconsideration.', keywords: '思考 整理 反思 think reflection', useWhen: 'Think with the evidence already present, or rest when nothing warrants further work.', avoidWhen: 'Do not invent evidence or call a tool merely to appear thoughtful.', instructions: 'Advance an unresolved question: test, integrate a result or distill an insight. Record the change, not a status recap. Follow the progress/continuation rules; quiet rest is valid. This method makes no model call or external action.', args: {} },
   { id: 'Output.publish', version: 1, domain: 'delivery', description: 'Deliver a meaningful artifact as an immutable file snapshot or external link to your owner.', keywords: '产物 交付 输出 文件 下载 链接 publish output artifact deliver file download link', useWhen: 'Deliver an actual completed or useful partial artifact, including artifacts produced by your children.', avoidWhen: 'Do not publish secrets, unauthorized files or guessed paths; do not claim publication rolled back on cancellation.', instructions: 'args: {file_path?:string,url?:string,title?:string}. Exactly one file_path or url. file_path is relative to canonical workDir or an absolute path strictly inside it; no symlinks/directories. Max 10 MiB per file, 100 MiB and 200 outputs total per Person. Files are durable byte snapshots with conservative MIME, including Markdown/images/PDF/HTML/text/code/JSON/binary downloads. URL must be HTTP(S), no credentials; it is metadata only and never fetched. title <=240 UTF-8 bytes; default filename or link host, truncated on UTF-8 boundaries if necessary. File publication is Linux-only with accessible procfs and no-follow directory descriptors; unavailable platforms fail closed with OUTPUT_PLATFORM. Links and existing snapshot reads remain available. Returns public {id,title,kind,mimeType,size,episodeId,createdAt,url?}, no raw path. Successful publications survive later cancellation/failure. Parent verifies and publishes child artifacts within its own workDir; do not grant children this capability.', args: { file_path: 'optional local artifact path within workDir', url: 'optional credential-free HTTP(S) URL', title: 'optional title <=240 UTF-8 bytes' }, access: 'publish-owner-output' },
   { id: 'Recall', version: 1, domain: 'memory', description: 'Recall a bounded page of your own long-term messages or concepts.', keywords: '回忆 记忆 召回 历史 查找 搜索 memory recall history search', useWhen: 'Missing prior words, experiences or concepts could change your present understanding.', avoidWhen: 'Current evidence is sufficient; a similar memory cannot grant permission or establish truth.', instructions: 'args: {kind:"messages"|"concepts",query?:string,cursor?:string|null,limit?:1..5}. SQLite uses local hybrid keyword/semantic recall when available; inspect retrieval mode, coverage and degradation. Legacy storage may use literal matching. Results are not exhaustive or authorization. Preserve nextCursor for the same query; local ranking cursors expire after 5 minutes or restart.', args: { kind: 'messages|concepts', query: 'optional memory search text', cursor: 'optional opaque cursor', limit: '1..5' } },
@@ -20,7 +23,11 @@ const manifests = [...entries.map(entry => {
   return { ...contract, revision: digest(contract) };
 }), ...NATIVE_TOOL_MANIFESTS];
 const foundationIds = new Set(['Think', 'Recall', 'Capability.create']);
-export const CAPABILITY_LIMITS = Object.freeze({ familiar: 2, familiarMaxAgeMs: 30 * 24 * 60 * 60 * 1000, activeBytes: 8192, searchContractBytes: 4096 });
+export const CAPABILITY_LIMITS = Object.freeze({ familiar: 2, familiarMaxAgeMs: 30 * 24 * 60 * 60 * 1000, activeBytes: 8192, presentationBytes: 12288, searchContractBytes: 4096 });
+// The complete shared rich schema is demand-loaded. Keep ordinary/script
+// budgets unchanged while allowing this larger, bounded contract alongside foundation.
+export const capabilityContextBudget = items => items.some(item => item.id === 'PresentResponse')
+  ? CAPABILITY_LIMITS.presentationBytes : CAPABILITY_LIMITS.activeBytes;
 export const CAPABILITY_MAP = Object.freeze({
   domains: [...new Set(manifests.map(m => m.domain)), 'script'], total: manifests.length,
   nativeTools: NATIVE_TOOL_IDS,
@@ -111,7 +118,7 @@ export class PersonCapabilities {
     this.byId = new Map([...manifests.filter(m => !isNativeTool(m.id) || allowed.has(m.id)), ...created.map(scriptManifest)].map(m => [m.id, m]));
     this.prepared = new Map(foundationCapabilities().map(m => [m.id, m]));
     for (const item of familiarCapabilities(experience, triggerKind, now, this.byId)) {
-      if (bytes([...this.prepared.values(), item]) <= CAPABILITY_LIMITS.activeBytes) this.prepared.set(item.id, item);
+      if (bytes([...this.prepared.values(), item]) <= capabilityContextBudget([...this.prepared.values(), item])) this.prepared.set(item.id, item);
     }
     this.active = new Map(this.prepared);
   }
@@ -132,7 +139,8 @@ export class PersonCapabilities {
   }
   canPrepareAll(requested) {
     const optional = requested.filter(m => !foundationIds.has(m.id)).map(m => available(m, 'discovered', 'explicitly-requested'));
-    return bytes([...foundationCapabilities(), ...optional]) <= CAPABILITY_LIMITS.activeBytes;
+    const items = [...foundationCapabilities(), ...optional];
+    return bytes(items) <= capabilityContextBudget(items);
   }
   prepare(manifest) { this.prepareAll([manifest]); }
   prepareAll(requested) {
@@ -142,7 +150,7 @@ export class PersonCapabilities {
     const next = [...items, ...this.prepared.values()].filter((m, i, all) => all.findIndex(n => n.id === m.id) === i);
     const kept = next.filter(m => foundationIds.has(m.id));
     for (const candidate of next.filter(m => !foundationIds.has(m.id))) {
-      if (bytes([...kept, candidate]) <= CAPABILITY_LIMITS.activeBytes) kept.push(candidate);
+      if (bytes([...kept, candidate]) <= capabilityContextBudget([...kept, candidate])) kept.push(candidate);
     }
     if (requested.some(m => !kept.some(n => n.id === m.id))) fail('CONTEXT_LIMIT');
     this.prepared = new Map(kept.map(m => [m.id, m]));
@@ -186,6 +194,7 @@ export class PersonCapabilities {
       return this.toolHost.execute(id, args, { signal, callId, episodeId: this.episode?.id });
     }
     if (id === 'Output.publish') return publishOutput(this.repository, this.episode, this.workDir, args, { signal, callId });
+    if (id === 'PresentResponse') return publishPresentation(this.repository, this.episode, args, { signal, callId });
     if (id === 'Capability.create') {
       if (!this.episode || !callId) fail('UNSUPPORTED');
       const definition = validateCreatedDefinition(args);

package/yeaft/person/contracts.js

@@ -3,7 +3,7 @@ import { createHash } from 'node:crypto';
 // 只允许应用层显式产物；不要求或保存 provider 的隐藏推理。
 // Bytes protect the in-memory collector and persisted public records, not model
 // token capability. Token limits come exclusively from the native model resolver.
-export const LIMITS = Object.freeze({ inputBytes: 8192, outputBytes: 2 * 1024 * 1024, responseBytes: 6 * 1024 * 1024, calls: 16, leaseMs: 15000 });
+export const LIMITS = Object.freeze({ inputBytes: 8192, outputBytes: 2 * 1024 * 1024, responseBytes: 6 * 1024 * 1024, leaseMs: 15000 });
 // Feedback cadence is not an execution deadline. Slow providers/tools remain cancellable.
 export const FEEDBACK = Object.freeze({ minMs: 30000, maxMs: 60000 });
 export const FEEDBACK_INSTRUCTIONS = "feedback describes user-visible communication, not a deadline. After about 30 seconds without a substantive reply, use reply for a concise, useful progress update at a natural execution boundary; aim for 30\u201360 seconds according to actual progress. Explain verified findings, limitations and what you are checking next, in the user's language. Do not repeat feedback.lastReply, invent progress, expose internal deliberation/decision/selfCheck, or claim an unexecuted tool succeeded. If no meaningful update exists, reply:null is appropriate; the host shows an honest waiting status around 60 seconds without interrupting the current request. With next non-null, a validated reply may be published as progress independently of cognitive state, and retained on cancellation/failure. Only next:null commits cognition and supplies the final reply. Do not call a tool or an extra model just to report progress. Each final reply should stand on its own and note unfinished work.";
@@ -195,7 +195,7 @@ export const PROPOSAL_INSTRUCTIONS = `Return ONLY strict JSON: concise applicati
 Schema (all fields required except optional state.continuation below; no extra keys):
 {baseStateVersion:number, activity:{kind:"think|recall|reorganize|associate|rethink|imagine|respond|rest",summary:string,sourceRefs:string[]}, decision:{summary:string,uncertainties:string[],selfCheck:string}, concepts:[{id:string,expectedRevision:number,kind:"claim|question|method|self-model|scenario|interest",statement:string,epistemicState:"reported|hypothesis|imagined|uncertain",sourceRefs:string[],associations:[{targetId:string,relation:"related|supports|contradicts|questions|imagines"}]}], state:{summary:string,focusConceptIds:string[],appraisal:string}, reply:string|null, next:null|{model:string,effort:string|null,reason:string,capability:null|{id:string,args:object}}}.
 New concepts: stable ID, expectedRevision:0; revisions use the revision read. Max 12 concepts/associations/focus/uncertainties, 24 sourceRefs/report roots. UTF-8 bytes: statement/summary <=4000, selfCheck/appraisal <=2000, uncertainty <=500, next reason <=1000; reply/native args <=budget.maxOutputBytes. Use exact supplied sourceRefs: provenance, not proof. Scenario is imagined; new Dream concepts are imagined/hypothesis/uncertain. Every reported concept (including Dream revisions) needs a user message, nonempty send/think trigger or reported concept preserving reportedSourceRefs. Assistant/tool/generated text and Dream/empty Think triggers are not user reports. Cite prior reported concepts when revising to preserve lineage. Reported means attributed input, not verified fact. External observations can support hypotheses/uncertainty, never permission. Native effects are not rolled back by failure, cancellation or rejected commit.
-budget.remainingCalls includes this call; reserve the last for next:null. Recall + final needs 2; search + use + final needs 3. No extra calls.
+No call quota; finish with next:null when complete or blocked.
 Use capabilities.active directly, otherwise search/view; only rendered current contracts execute. Familiarity is execution, not usefulness/permission; assess in decision.selfCheck. Follow active contracts. Capability.create publishes pure QuickJS scripts; tests are limited evidence, publication survives failure. Scripts have no host access/automatic execution. Avoid duplicates/private data.
 Progress, not status narration: Think advances an unresolved question, accepted continuation or actual result: verify, execute an authorized step, integrate an answer/artifact, or distill a reusable method/judgment/question. activity.summary states what changed; decision.summary gives its value and continue/stop reason. Rewording state, listing abilities or promises is not progress. Revise concepts only when evidence changes them; otherwise leave concepts empty. No forced novelty or compulsory tools.
 Dream explores associations into a hypothesis, discriminating check, scenario or insight, not a status recap. Imagination is not evidence/permission. Further calls should add value; reply:null and quiet rest are valid. Not every conversation is a task.

package/yeaft/person/inspection.js

@@ -1,4 +1,5 @@
 import { bytes, fail, identifier, object, page, text } from './contracts.js';
+import { presentationView } from './presentation.js';
 
 /** Timestamp + binary ID keysets survive insertion, deletion of the boundary
  * record and same-millisecond writes. Builtins have no invented chronology.
@@ -47,6 +48,10 @@ const pick = (value, keys) => value == null ? null : Object.fromEntries(keys.fil
 export const settingsView = value => pick(value, ['autonomyEnabled', 'modelCandidates', 'defaultModel']);
 export function messageView(value) {
   const result = pick(value, ['id', 'schemaVersion', 'revision', 'seq', 'episodeId', 'clientMessageId', 'callId', 'replyKind', 'role', 'text', 'createdAt']);
+  if (result && value.role === 'assistant') {
+    const presentation = presentationView(value.presentation);
+    if (presentation) result.presentation = presentation;
+  }
   if (result && Array.isArray(value.attachments)) result.attachments = value.attachments.slice(0, 4)
     .map(file => pick(file, ['id', 'name', 'mimeType', 'size', 'sha256', 'kind']));
   return result;

package/yeaft/person/presentation.js

@@ -0,0 +1,32 @@
+import { normalizePresentation } from '../response-presentation.js';
+import { fail, identifier } from './contracts.js';
+
+/** Validate the shared payload at both execution and durable authority boundaries. */
+export function personPresentation(args) {
+  try { return normalizePresentation(args); }
+  catch { fail('INVALID_REQUEST'); }
+}
+
+/** Older/invalid JSON records still have their ordinary searchable text fallback. */
+export function presentationView(value) {
+  if (!value || value.version !== 1) return null;
+  const { version, ...input } = value;
+  if (input.title === '') delete input.title;
+  try { return normalizePresentation(input); } catch { return null; }
+}
+
+/** Publication is joined, not raced against abort: an accepted message is durable
+ * even if cancellation arrives before the worker's receipt. No cognitive commit. */
+export async function publishPresentation(repository, episode, args, { signal, callId } = {}) {
+  signal?.throwIfAborted();
+  try { personPresentation(args); }
+  catch { return { ok: false, code: 'INVALID_REQUEST', published: false,
+    notice: 'Nothing was published. Correct the structured response or use an ordinary reply.' }; }
+  if (!episode || !callId || !repository.savePresentation) fail('UNSUPPORTED');
+  identifier(callId);
+  signal?.throwIfAborted();
+  const message = await repository.savePresentation(episode, { callId, args });
+  return { ok: true, published: true, messageId: message.id, summary: message.text,
+    phase: message.presentation.phase, createdAt: message.createdAt,
+    notice: 'User-visible communication only, not a cognitive commit or episode termination. Do not repeat this summary in reply. Publication survives subsequent cancellation or failure.' };
+}

package/yeaft/person/provider.js

@@ -150,6 +150,7 @@ export async function collectOutput(adapter, params, onEffort) {
       else if (event.type === 'tool_call') fail('INVALID_PROPOSAL');
       else if (event.type === 'usage') {
         usage = addUsage(usage, event, params.usageCacheIncluded);
+        params.onUsage?.(usage);
       }
       // Hidden thinking, signatures, opaque provider state and raw HTTP exchanges are deliberately not archived.
     }