@yeaft/webchat-agent 1.0.629 → 1.0.632

package/yeaft/person/service.js

@@ -2,6 +2,9 @@ import { SqlitePersonRepository } from './sqlite-repository.js';
 import { LocalPersonMemory } from './local-memory.js';
 import { ensurePersonStorage } from './sqlite-storage.js';
 import { PersonRuntime } from './runtime.js';
+import { PersonCapabilities } from './capabilities.js';
+import { EXECUTION_INSTRUCTIONS } from './execution-protocol.js';
+import { personMinimumRequestBytes } from './request-budget.js';
 import { allowedNativeToolIds } from './native-tools.js';
 import { loadConfig } from '../config.js';
 import { validateFiles } from './attachments.js';
@@ -41,7 +44,13 @@ export function createPersonService(options = {}) {
   if (memory) repository.recall = (ownerId, args = {}, { signal } = {}) => args.query?.trim()
     ? memory.recall(ownerId, args, { signal }) : literalRecall(ownerId, args);
   // Config/adapter are loaded per explicit episode, not a permanent stale cache.
-  const getProvider = (modelCandidates = [], defaultModel = null) => createPersonProvider({ yeaftDir, config, adapter, allowedModels, modelCandidates, defaultModel, effortEnabled: options.effortEnabled });
+  const getProvider = (modelCandidates = [], defaultModel = null) => {
+    const nativeConfig = config ?? loadConfig({ dir: yeaftDir });
+    const capabilities = new PersonCapabilities(null, null, { toolHost: { allowedToolIds: () => allowedNativeToolIds(nativeConfig) } });
+    const minimumRequestBytes = personMinimumRequestBytes(capabilities.executionTools(), EXECUTION_INSTRUCTIONS);
+    return createPersonProvider({ yeaftDir, config: nativeConfig, adapter, allowedModels, modelCandidates, defaultModel,
+      effortEnabled: options.effortEnabled, minimumRequestBytes });
+  };
   const runtime = new PersonRuntime({ repository, getProvider, budget: { calls: null }, workDir, yeaftDir, config, namespace });
   let closed = false;
   const requests = new Set();
@@ -68,18 +77,19 @@ export function createPersonService(options = {}) {
       } catch (error) { if (error.code !== 'NOT_OPEN') throw error; }
       try {
         const provider = await getProvider();
+        let modelReason = null;
         try {
-          const selected = selectPersonModels({ availableModels: provider.availableModels,
+          const selected = selectPersonModels({ availableModels: provider.availableModels, unavailableModels: provider.unavailableModels,
             modelCandidates: status.modelCandidates, defaultModel: status.defaultModel });
           status.modelReady = true;
           status.effectiveModelCandidates = selected.catalog.map(model => model.id);
           status.effectiveDefaultModel = selected.defaultSelection.model;
-        } catch { /* Stale settings remain visible, but do not grant fallback candidates. */ }
+        } catch (error) { modelReason = safeError(error, 'MODEL_SELECTION').message; /* No fallback candidates for stale settings. */ }
         return { ...status, agentDefaultModel: provider.agentDefaultModel,
-          reason: status.modelReady ? null : 'Saved model settings are unavailable; choose models or reset to Agent defaults.',
+          reason: status.modelReady ? null : `${modelReason} Choose models or reset to Agent defaults.`,
           storageReady: true, models: provider.availableModels, availableModels: provider.availableModels,
           availableModelsTruncated: provider.availableModelsTruncated, autonomySupported: false };
-      } catch { return { ...status, reason: 'No permitted native model is configured for digital person.', storageReady: true, models: [], availableModels: [] }; }
+      } catch (error) { return { ...status, reason: safeError(error, 'MODEL_UNAVAILABLE').message, storageReady: true, models: [], availableModels: [] }; }
     }
     if (!configured) fail('NOT_CONFIGURED');
     switch (op) {
@@ -188,7 +198,8 @@ export function createPersonService(options = {}) {
           // An automatic reset must also work when no model is currently available.
           if (merged.modelCandidates.length || merged.defaultModel !== null) {
             const provider = await getProvider();
-            selectPersonModels({ availableModels: provider.availableModels, modelCandidates: merged.modelCandidates, defaultModel: merged.defaultModel });
+            selectPersonModels({ availableModels: provider.availableModels, unavailableModels: provider.unavailableModels,
+              modelCandidates: merged.modelCandidates, defaultModel: merged.defaultModel });
           }
           // Fence the merge base across concurrent services; retry from fresh settings.
           expectedControlVersion = prior.controlVersion;

package/yeaft/person/sqlite-repository.js

@@ -95,6 +95,9 @@ export class SqlitePersonRepository {
   async append(episode, kind, data) { return this.request('append', [episode, kind, data]); }
   async startCall(episode, data) { return this.request('startCall', [episode, data]); }
   async finalizeCall(episode, data) { return this.request('finalizeCall', [episode, data]); }
+  /** Native tools have an independent trace callId, with modelCallId/toolUseId/
+   * toolIndex bound by storage to the complete public provider batch. Legacy
+   * scalar invocations keep their original shared callId. */
   async startCapability(episode, data) { return this.request('startCapability', [episode, data]); }
   async finalizeCapability(episode, data) { return this.request('finalizeCapability', [episode, data]); }
   async executionRead(episode, args, { signal } = {}) {

package/yeaft/person/sqlite-store.js

@@ -3,6 +3,7 @@ import { mkdirSync } from 'node:fs';
 import { dirname } from 'node:path';
 import { randomUUID } from 'node:crypto';
 import { isMainThread } from 'node:worker_threads';
+import { isDeepStrictEqual } from 'node:util';
 import { admissionReceipt, bytes, digest, fail, FEEDBACK, identifier, LIMITS, PersonError, text } from './contracts.js';
 import { CREATED_CAPABILITY_LIMITS, createdCapabilityRecord, validateCreatedCapability } from './created-capability-contract.js';
 import { SCHEMA, TABLES } from './sqlite-schema.js';
@@ -12,7 +13,7 @@ import { chronologicalCursor, conceptView, inspectionCursor, inspectionPage, ins
 import { TOKEN_FIELDS, turnsPage, turnView } from './turn-diagnostics.js';
 import { personPresentation } from './presentation.js';
 import { inspectCapabilities } from './capabilities.js';
-import { executionEvidencePage, executionReadRequest } from './execution-evidence.js';
+import { executionEvidencePage, executionReadRequest, nativeInvocationMatches } from './execution-evidence.js';
 import { OUTPUT_LIMITS, outputArgs, outputMime, outputReadRequest, outputsPage, outputUrl, outputView } from './outputs.js';
 
 const SCOPE = 'namespace = ? AND ownerId = ? AND personId = ?';
@@ -42,7 +43,30 @@ const unavailableOutput = () => ({ text: '', retainedBytes: 0, observedBytes: nu
 const publicOutput = (output, failed) => {
   if (!output) return unavailableOutput();
   if (typeof output.text !== 'string' || bytes(output.text) > LIMITS.outputBytes) fail('OUTPUT_LIMIT');
-  const retainedBytes = bytes(output.text), observedBytes = output.observedBytes ?? output.bytes ?? retainedBytes;
+  if (output.protocol !== undefined && !['native-tools', 'cognition'].includes(output.protocol)) fail('INVALID_REQUEST');
+  // A native batch cannot be relabeled as an unmarked legacy scalar proof.
+  if (output.toolCalls?.length && output.protocol !== 'native-tools') fail('INVALID_REQUEST');
+  const toolCalls = [];
+  let retainedBytes = bytes(output.text), toolCallsTruncated = false;
+  if (output.toolCalls !== undefined) {
+    if (!Array.isArray(output.toolCalls)) fail('INVALID_REQUEST');
+    const ids = new Set();
+    for (const item of output.toolCalls) {
+      if (!item || typeof item.id !== 'string' || !item.id || bytes(item.id) > 1024 ||
+          typeof item.name !== 'string' || !item.name || bytes(item.name) > 512 || ids.has(item.id) ||
+          !item.input || typeof item.input !== 'object' || Array.isArray(item.input)) fail('INVALID_REQUEST');
+      ids.add(item.id);
+      const input = JSON.parse(JSON.stringify(item.input));
+      if (!isDeepStrictEqual(input, item.input)) fail('INVALID_REQUEST');
+      const call = { id: item.id, name: item.name, input, ...(item.malformed === true ? { malformed: true } : {}) };
+      if (retainedBytes + bytes(call) > LIMITS.outputBytes) {
+        if (!failed) fail('OUTPUT_LIMIT');
+        toolCallsTruncated = true; break;
+      }
+      retainedBytes += bytes(call); toolCalls.push(call);
+    }
+  }
+  const observedBytes = output.observedBytes ?? output.bytes ?? retainedBytes;
   if (!Number.isSafeInteger(observedBytes) || observedBytes < retainedBytes) fail('INVALID_REQUEST');
   const usage = output.usage ? {} : null;
   if (usage) for (const key of ['inputTokens', 'outputTokens', 'reasoningTokens', 'cacheReadTokens', 'cacheWriteTokens']) {
@@ -52,8 +76,10 @@ const publicOutput = (output, failed) => {
   if (usage && output.usage.accountingIncomplete === true) usage.accountingIncomplete = true;
   if (usage && typeof output.usage.cacheTokensAreIncludedInInput === 'boolean') usage.cacheTokensAreIncludedInInput = output.usage.cacheTokensAreIncludedInInput;
   const stopReason = typeof output.stopReason === 'string' && bytes(output.stopReason) <= 128 ? output.stopReason : null;
-  return failed ? { text: output.text, retainedBytes, observedBytes, complete: false, accepted: false, availability: 'captured', usage, stopReason }
-    : { text: output.text, bytes: retainedBytes, complete: true, usage, stopReason };
+  const publicFields = { ...(output.protocol === 'native-tools' || output.protocol === 'cognition' ? { protocol: output.protocol } : {}),
+    ...(output.toolCalls !== undefined ? { toolCalls } : {}), ...(toolCallsTruncated ? { toolCallsTruncated: true } : {}) };
+  return failed ? { text: output.text, retainedBytes, observedBytes, complete: false, accepted: false, availability: 'captured', usage, stopReason, ...publicFields }
+    : { text: output.text, bytes: retainedBytes, complete: true, usage, stopReason, ...publicFields };
 };
 const objectOutput = (record, data) => {
   if (!record || !['file', 'link'].includes(record.kind)) fail('INVALID_REQUEST');
@@ -304,9 +330,11 @@ export class SqlitePersonStore {
     return this.trace(episode.ownerId, episode.id, kind, data);
   }
   startCall(episode, data) {
+    identifier(data.callId);
     const p = this.own(episode), scope = this.episodeScope(episode);
     const record = this.one('episodes', scope, ' AND id = ?', [episode.id]);
-    if (!record || record.status !== 'running' || record.openCall || record.openCapability) fail('STALE');
+    if (!record || record.status !== 'running' || record.openCall || record.openCapability ||
+        this.one('traces', scope, " AND json_extract(record, '$.episodeId') = ? AND json_extract(record, '$.callId') = ? AND json_extract(record, '$.kind') IN ('call_started', 'capability_started')", [episode.id, data.callId])) fail('STALE');
     p.writeSerial++; this.put('persons', p);
     record.openCall = { callId: data.callId, requested: data.requested, effective: data.effective, ...(data.manifest ? { manifest: data.manifest } : {}) };
     this.put('episodes', record);
@@ -318,7 +346,8 @@ export class SqlitePersonStore {
     const live = record.status === 'running' && Boolean(this.fenced(episode));
     const draining = record.status === 'cancelled' && record.callFinalizeUntil > this.now;
     if (!live && !draining) return false;
-    const failed = Boolean(code || !live || !output), terminalCode = !live ? 'CANCELLED' : code || 'INTERRUPTED';
+    const failed = Boolean(code || !live || !output || output.complete === false || output.accepted === false || output.toolCallsTruncated === true),
+      terminalCode = !live ? 'CANCELLED' : code || 'INTERRUPTED';
     const call = record.openCall;
     const safeEffective = { model: call.requested.model, effort: typeof effective?.effort === 'string' && effective.effort.length <= 128 ? effective.effort : null,
       effortObserved: effective?.effortObserved === true };
@@ -332,17 +361,42 @@ export class SqlitePersonStore {
     });
     return live;
   }
+  callProof(scope, episodeId, callId) {
+    return 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", [episodeId, callId]);
+  }
+  /** Recheck the original transactional slot and its request proof at publication.
+   * Legacy scalar APIs remain supported only for legacy complete call outputs. */
+  capabilityProof(scope, episodeId, started) {
+    if (!started || started.invocationHash !== digest(started.capability)) return null;
+    const proof = this.callProof(scope, episodeId, started.modelCallId ?? started.callId);
+    if (!proof) return null;
+    const original = this.one('traces', scope, " AND json_extract(record, '$.episodeId') = ? AND json_extract(record, '$.kind') = 'capability_started' AND json_extract(record, '$.callId') = ? ORDER BY seq ASC", [episodeId, started.callId]);
+    if (!original || !isDeepStrictEqual(original.capability, started.capability) ||
+        ['modelCallId', 'toolUseId', 'toolIndex'].some(key => original[key] !== started[key])) return null;
+    if (proof.output.protocol === 'native-tools') return nativeInvocationMatches(proof.output, started, { executable: true }) ? proof : null;
+    return started.modelCallId === undefined && started.toolUseId === undefined && started.toolIndex === undefined && !proof.output.protocol ? proof : null;
+  }
   startCapability(episode, data) {
+    identifier(data.callId);
+    if (data.modelCallId !== undefined) identifier(data.modelCallId);
+    if (!data.capability || typeof data.capability.id !== 'string' || !data.capability.args || typeof data.capability.args !== 'object') fail('INVALID_REQUEST');
     const p = this.own(episode), scope = this.episodeScope(episode);
     const record = this.one('episodes', scope, ' AND id = ?', [episode.id]);
-    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, data.callId]);
+    const proof = this.callProof(scope, episode.id, data.modelCallId ?? data.callId);
     if (!record || record.status !== 'running' || record.openCall || record.openCapability || !proof) fail('STALE');
-    const prior = this.one('traces', scope, " AND json_extract(record, '$.episodeId') = ? AND json_extract(record, '$.kind') = 'capability_started' AND json_extract(record, '$.callId') = ?", [episode.id, data.callId]);
-    if (prior) fail('STALE');
-    record.openCapability = { ...data, invocationHash: digest(data.capability) };
+    const native = proof.output.protocol === 'native-tools';
+    if (native ? !data.modelCallId || data.callId === data.modelCallId || !nativeInvocationMatches(proof.output, data)
+      : proof.output.protocol || data.modelCallId !== undefined || data.toolUseId !== undefined || data.toolIndex !== undefined) fail('STALE');
+    const prior = this.one('traces', scope, " AND json_extract(record, '$.episodeId') = ? AND json_extract(record, '$.kind') = 'capability_started' AND (json_extract(record, '$.callId') = ? OR (? = 1 AND json_extract(record, '$.modelCallId') = ? AND (json_extract(record, '$.toolUseId') = ? OR json_extract(record, '$.toolIndex') = ?)))",
+      [episode.id, data.callId, Number(native), data.modelCallId ?? null, data.toolUseId ?? null, data.toolIndex ?? null]);
+    if (prior || (native && this.one('traces', scope, " AND json_extract(record, '$.episodeId') = ? AND json_extract(record, '$.kind') = 'call_started' AND json_extract(record, '$.callId') = ?", [episode.id, data.callId]))) fail('STALE');
+    const started = { callId: data.callId, capability: data.capability,
+      ...(native ? { modelCallId: data.modelCallId, toolUseId: data.toolUseId, toolIndex: data.toolIndex } : {}),
+      ...(data.capabilityManifest ? { capabilityManifest: data.capabilityManifest } : {}), ...(data.access ? { access: data.access } : {}) };
+    record.openCapability = { ...started, invocationHash: digest(started.capability) };
     this.put('episodes', record);
     p.writeSerial++; this.put('persons', p);
-    return this.trace(episode.ownerId, episode.id, 'capability_started', data);
+    return this.trace(episode.ownerId, episode.id, 'capability_started', started);
   }
   /** Original started invocation only; consuming this slot never restores cognitive authority. */
   finalizeCapability(episode, { callId, capability, result, code = null, terminalCode = null }) {
@@ -356,7 +410,7 @@ export class SqlitePersonStore {
     const started = record.openCapability;
     const failed = Boolean(code || result?.ok === false);
     const outcome = failed ? 'capability_failed' : 'capability_result';
-    const data = { callId, ...(started.capabilityManifest ? { capabilityManifest: started.capabilityManifest } : {}),
+    const data = { callId, ...(started.modelCallId !== undefined ? { modelCallId: started.modelCallId, toolUseId: started.toolUseId, toolIndex: started.toolIndex } : {}), ...(started.capabilityManifest ? { capabilityManifest: started.capabilityManifest } : {}),
       ...(failed ? { capabilityId: started.capability.id, code: code || result.code } : { capability: started.capability }),
       ...(result !== undefined ? { result } : {}) };
     delete record.openCapability; this.put('episodes', record);
@@ -395,8 +449,10 @@ export class SqlitePersonStore {
     this.own(episode);
     const scope = this.episodeScope(episode), active = this.one('episodes', scope, ' AND id = ?', [episode.id]);
     if (!active || active.status !== 'running' || active.epoch !== episode.epoch || active.workerId !== episode.workerId) fail('STALE');
-    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 (!proof || active.openCall?.callId === callId) fail('INVALID_REQUEST');
+    const started = active.openCapability;
+    const proof = started?.callId === callId ? this.capabilityProof(scope, episode.id, started) : this.callProof(scope, episode.id, callId);
+    if (!proof || active.openCall || (started ? started.callId !== callId || started.capability.id !== 'Capability.create' ||
+        !isDeepStrictEqual(started.capability.args, definition) : proof.output.protocol)) fail('INVALID_REQUEST');
     const current = this.one('created_capabilities', scope, ' AND id = ?', [definition.id]);
     if ((current?.version ?? 0) !== definition.expectedVersion) fail('STALE');
     if (definition.expectedVersion >= CREATED_CAPABILITY_LIMITS.versions || (!current &&
@@ -437,8 +493,7 @@ export class SqlitePersonStore {
       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]);
+    const proof = this.capabilityProof(scope, episode.id, record?.openCapability);
     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.
@@ -463,25 +518,35 @@ export class SqlitePersonStore {
   }
   /** 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 }) {
+  publishProgress(episode, { callId, reply, final = false }) {
     const p = this.own(episode), scope = this.episodeScope(episode);
     identifier(callId); text(reply, LIMITS.outputBytes);
+    if (typeof final !== 'boolean') fail('INVALID_REQUEST');
     const record = this.one('episodes', scope, ' AND id = ?', [episode.id]);
     if (!record || record.status !== 'running' || record.openCall || record.openCapability) fail('STALE');
-    const prior = this.rows('messages', scope, " AND json_extract(record, '$.episodeId') = ? AND json_extract(record, '$.replyKind') = 'progress'", [episode.id]);
+    const prior = this.rows('messages', scope, " AND json_extract(record, '$.episodeId') = ? AND json_extract(record, '$.replyKind') IN ('progress', 'execution-final')", [episode.id]);
     const duplicate = prior.find(m => m.callId === callId);
     if (duplicate) { if (duplicate.text !== reply) fail('INVALID_REQUEST'); return messageView(duplicate); }
     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]);
-    const accepted = this.one('traces', scope, " AND json_extract(record, '$.episodeId') = ? AND json_extract(record, '$.kind') = 'activity' AND json_extract(record, '$.callId') = ? AND json_extract(record, '$.disposition') = 'candidate'", [episode.id, callId]);
-    let proposal;
-    try { proposal = JSON.parse(proof?.output?.text); } catch { fail('INVALID_REQUEST'); }
-    if (!accepted || !proposal.next || proposal.reply !== reply) fail('INVALID_REQUEST');
+    if (proof?.output?.protocol === 'native-tools') {
+      if (proof.output.text !== reply || (final && (proof.output.stopReason !== 'end_turn' || proof.output.toolCalls?.length))) fail('INVALID_REQUEST');
+    } else {
+      if (final) fail('INVALID_REQUEST');
+      const accepted = this.one('traces', scope, " AND json_extract(record, '$.episodeId') = ? AND json_extract(record, '$.kind') = 'activity' AND json_extract(record, '$.callId') = ? AND json_extract(record, '$.disposition') = 'candidate'", [episode.id, callId]);
+      let proposal;
+      try { proposal = JSON.parse(proof?.output?.text); } catch { fail('INVALID_REQUEST'); }
+      if (!accepted || !proposal.next || proposal.reply !== reply) fail('INVALID_REQUEST');
+    }
+    // A final duplicate is already delivered. Preserve its identity so final
+    // cognition does not interpret dedupe as a missing public result.
+    const sameReply = prior.find(m => m.text.trim() === reply.trim());
+    if (final && sameReply) return messageView(sameReply);
     // 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()) || this.repeatsPresentation(scope, episode.id, reply)) return null;
+    if ((!final && this.now.getTime() - new Date(record.lastReplyAt ?? record.createdAt).getTime() < FEEDBACK.minMs) ||
+        sameReply || 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 });
+      callId, replyKind: final ? 'execution-final' : 'progress', role: 'assistant', text: reply, 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, 'progress_reply', { callId, messageId: message.id });
@@ -490,7 +555,10 @@ 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');
-    const publishReply = proposal.reply && !this.repeatsPresentation(scope, episode.id, proposal.reply);
+    const repeatsExecutionReply = proposal.reply && this.rows('messages', scope,
+      " AND json_extract(record, '$.episodeId') = ? AND json_extract(record, '$.replyKind') IN ('progress', 'execution-final')", [episode.id])
+      .some(message => message.text.trim() === proposal.reply.trim());
+    const publishReply = proposal.reply && !repeatsExecutionReply && !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);
@@ -593,7 +661,8 @@ export class SqlitePersonStore {
     const episodes = this.sql(`SELECT ${project({ id: 'id', seq: 'inputWatermark', kind: 'kind', status: 'status', createdAt: 'createdAt', endedAt: 'endedAt', terminalCode: 'terminalCode', controlStatus: 'executionControl.status', calls: 'budget.calls', timeoutMs: 'budget.timeoutMs' })} AS metadata
       FROM episodes WHERE ${SCOPE} AND (? IS NULL OR inputWatermark < ?) ORDER BY inputWatermark DESC LIMIT ?`)
       .all(...scopeValues(scope), cursor, cursor, limit + 1).map(row => JSON.parse(row.metadata));
-    const fields = { kind: 'kind', callId: 'callId', callIndex: 'callIndex', createdAt: 'createdAt',
+    const fields = { kind: 'kind', callId: 'callId', modelCallId: 'modelCallId', toolUseId: 'toolUseId', toolIndex: 'toolIndex',
+      protocol: 'output.protocol', callIndex: 'callIndex', createdAt: 'createdAt',
       requestedModel: 'requested.model', requestedEffort: 'requested.effort', effectiveEffort: 'effective.effort', effortObserved: 'effective.effortObserved',
       selectionOrigin: 'selectionOrigin', reason: 'reason', code: 'code', terminalCode: 'terminalCode', outcome: 'outcome',
       contextBytes: 'manifest.contextBytes', contextBudgetBytes: 'manifest.contextBudgetBytes', outputTokensReserved: 'manifest.outputTokensReserved' };
@@ -618,16 +687,21 @@ export class SqlitePersonStore {
         AND json_extract(record, '$.kind') = 'call_started' ORDER BY seq DESC LIMIT 33`)
         .all(...scopeValues(scope), episode.id);
       const oldest = starts[Math.min(starts.length, 32) - 1]?.seq ?? 0;
-      const events = this.sql(`SELECT ${metadata} AS metadata FROM traces WHERE ${SCOPE} AND seq >= ?
-        AND json_extract(record, '$.episodeId') = ? AND json_extract(record, '$.kind') IN
-        ('call_started', 'call_output', 'call_failed', 'proposal_rejected', 'capability_started', 'capability_result', 'capability_failed', 'capability_finalized') ORDER BY seq DESC LIMIT 257`)
-        .all(...scopeValues(scope), oldest, episode.id).map(row => {
-          const event = JSON.parse(row.metadata); event.effortObserved = event.effortObserved === 1; return event;
-        });
-      return { ...turnView(episode, events.slice(0, 256).reverse()),
+      // Tool fan-out must not evict the parent model lifecycle/usage. Both
+      // projections remain bounded, and a shortened detail window is explicit.
+      const eventWindow = kinds => this.sql(`SELECT seq, ${metadata} AS metadata FROM traces WHERE ${SCOPE} AND seq >= ?
+        AND json_extract(record, '$.episodeId') = ? AND json_extract(record, '$.kind') IN (${kinds}) ORDER BY seq DESC LIMIT 257`)
+        .all(...scopeValues(scope), oldest, episode.id);
+      const modelEvents = eventWindow("'call_started', 'call_output', 'call_failed', 'proposal_rejected'");
+      const toolEvents = eventWindow("'capability_started', 'capability_result', 'capability_failed', 'capability_finalized'");
+      const events = [...modelEvents.slice(0, 256), ...toolEvents.slice(0, 256)].sort((a, b) => a.seq - b.seq).map(row => {
+        const event = JSON.parse(row.metadata); event.effortObserved = event.effortObserved === 1; return event;
+      });
+      const callsTruncated = starts.length > 32 || modelEvents.length > 256;
+      return { ...turnView(episode, events),
         loopCount: starts[0]?.callIndex != null ? starts[0].callIndex + 1 : starts.length > 32 ? null : starts.length,
-        callsTruncated: starts.length > 32 || events.length > 256, callWindowLimit: 32,
-        usageScope: starts.length > 32 || events.length > 256 ? 'latest-call-window' : 'episode' };
+        callsTruncated, callWindowLimit: 32, detailsTruncated: toolEvents.length > 256 || modelEvents.length > 256, detailWindowLimit: 256,
+        usageScope: callsTruncated ? 'latest-call-window' : 'episode' };
     });
     return { items, nextCursor: episodes.length > limit ? items.at(-1).seq : null };
   }
@@ -655,8 +729,9 @@ export class SqlitePersonStore {
   checkOutputPublication(episode, { callId, args }) {
     outputArgs(args); this.own(episode);
     const scope = this.episodeScope(episode), active = this.one('episodes', scope, ' AND id = ?', [episode.id]);
-    if (!active || active.status !== 'running' || active.openCapability?.callId !== callId ||
-        active.openCapability.invocationHash !== digest({ id: 'Output.publish', args })) fail('STALE');
+    if (!active || active.status !== 'running' || active.openCall || active.openCapability?.callId !== callId ||
+        active.openCapability.invocationHash !== digest({ id: 'Output.publish', args }) ||
+        !this.capabilityProof(scope, episode.id, active.openCapability)) fail('STALE');
     return true;
   }
   saveOutput(episode, { callId, args, record, data }) {

package/yeaft/person/tool-arguments.js

@@ -0,0 +1,76 @@
+import { fail, identifier, object, page, PersonError, text } from './contracts.js';
+import { validateCreatedDefinition } from './created-capability-contract.js';
+import { executionReadRequest } from './execution-evidence.js';
+import { outputArgs } from './outputs.js';
+import { personPresentation } from './presentation.js';
+import { scriptInput } from './script-executor.js';
+
+/** Pre-dispatch schema check, deliberately separate from execution: rejection
+ * here proves that no host effect has begun and can safely become tool feedback.
+ * Runtime/IO exceptions after this boundary must never be classified as args. */
+export function validateToolArguments(value, schema) {
+  const matches = (input, rule) => {
+    if (rule === false) return false;
+    if (!rule || typeof rule !== 'object') return true;
+    if (rule.allOf && !rule.allOf.every(item => matches(input, item))) return false;
+    if (rule.not && matches(input, rule.not)) return false;
+    if (rule.anyOf && !rule.anyOf.some(item => matches(input, item))) return false;
+    if (rule.oneOf && rule.oneOf.filter(item => matches(input, item)).length !== 1) return false;
+    if (rule.enum && !rule.enum.some(item => JSON.stringify(item) === JSON.stringify(input))) return false;
+    if (Object.hasOwn(rule, 'const') && JSON.stringify(rule.const) !== JSON.stringify(input)) return false;
+    const type = input === null ? 'null' : Array.isArray(input) ? 'array' : typeof input;
+    if (rule.type && !(Array.isArray(rule.type) ? rule.type : [rule.type]).some(wanted => wanted === type || (wanted === 'integer' && Number.isInteger(input)))) return false;
+    if (typeof input === 'string') {
+      if (rule.minLength != null && [...input].length < rule.minLength) return false;
+      if (rule.maxLength != null && [...input].length > rule.maxLength) return false;
+      if (rule.pattern && !new RegExp(rule.pattern, 'u').test(input)) return false;
+    }
+    if (typeof input === 'number' && (!Number.isFinite(input) || (rule.minimum != null && input < rule.minimum) || (rule.maximum != null && input > rule.maximum))) return false;
+    if (Array.isArray(input)) {
+      if (rule.minItems != null && input.length < rule.minItems) return false;
+      if (rule.maxItems != null && input.length > rule.maxItems) return false;
+      if (rule.items && !input.every(item => matches(item, rule.items))) return false;
+    } else if (input && typeof input === 'object') {
+      if ((rule.required ?? []).some(key => !Object.hasOwn(input, key))) return false;
+      for (const [key, item] of Object.entries(input)) {
+        const known = Object.hasOwn(rule.properties ?? {}, key);
+        if (!known && rule.additionalProperties === false) return false;
+        if (known && !matches(item, rule.properties[key])) return false;
+        if (!known && typeof rule.additionalProperties === 'object' && !matches(item, rule.additionalProperties)) return false;
+      }
+    }
+    return true;
+  };
+  if (!matches(value, schema)) fail('INVALID_TOOL_INPUT');
+}
+
+/** Pure argument checks that JSON Schema cannot fully describe (UTF-8 budgets,
+ * URLs and dependent fields). No repository, host dispatch or guest execution.
+ * Only this boundary translates known validation errors to retry-safe feedback;
+ * callers must not wrap capability execution in the same catch. */
+export function validateCapabilityArguments({ id, args }) {
+  try {
+    if (id === 'Capability.create') validateCreatedDefinition(args);
+    else if (id === 'Execution.read') executionReadRequest(args);
+    else if (id === 'Output.publish') outputArgs(args);
+    else if (id === 'PresentResponse') personPresentation(args);
+    else if (id.startsWith('Script.')) {
+      object(args, ['input']); scriptInput(args.input);
+    } else if (id === 'catalog.view') {
+      object(args, ['id']); identifier(args.id);
+    } else if (id === 'catalog.search' || id === 'Recall') {
+      object(args, id === 'Recall' ? ['kind', 'query', 'cursor', 'limit'] : ['query', 'cursor', 'limit'], id === 'Recall' ? ['kind'] : []);
+      text(args.query ?? '', 200, true);
+      const limit = args.limit ?? 3;
+      if (!Number.isInteger(limit) || limit < 1 || limit > 5) fail('INVALID_REQUEST');
+      if (id === 'Recall' && !['messages', 'concepts'].includes(args.kind)) fail('INVALID_REQUEST');
+      if (args.cursor != null) {
+        if (id === 'Recall' && args.kind === 'messages' && !/^lm:[a-f0-9]{32}:\d{1,6}$/.test(args.cursor)) page({ cursor: args.cursor, limit });
+        else identifier(args.cursor);
+      }
+    }
+  } catch (error) {
+    if (error instanceof PersonError && error.code === 'INVALID_REQUEST') fail('INVALID_TOOL_INPUT');
+    throw error;
+  }
+}

package/yeaft/person/turn-diagnostics.js

@@ -77,14 +77,15 @@ export function turnView(episode, events) {
         contextBytes: token(event.contextBytes), contextBudgetBytes: token(event.contextBudgetBytes), contextWindowTokens: token(event.contextWindowTokens),
         outputTokensReserved: token(event.outputTokensReserved), imageTokensReserved: token(event.imageTokensReserved), envelopeTokensReserved: token(event.envelopeTokensReserved),
         contextSources: contextSources(event),
-        usage: callUsage(null, false) });
+        usage: callUsage(null, false), capabilities: [] });
       continue;
     }
-    const call = calls.get(event.callId);
+    const call = calls.get(event.modelCallId ?? event.callId);
     if (!call) continue;
     if (event.kind === 'call_output' || event.kind === 'call_failed') {
       call.status = event.kind === 'call_output' ? 'completed' : ['CANCELLED', 'INTERRUPTED'].includes(event.code) ? event.code.toLowerCase() : 'failed';
       call.endedAt = event.createdAt;
+      if (['native-tools', 'cognition'].includes(event.protocol)) call.protocol = event.protocol;
       // Legacy call lifecycle timestamps include queue/pause time. Do not label
       // them as provider duration when no actual dispatch measurement was stored.
       call.elapsedMs = token(event.requestElapsedMs);
@@ -93,11 +94,26 @@ export function turnView(episode, events) {
       call.usage = callUsage(event.usage, event.kind === 'call_output');
     } else if (event.kind === 'proposal_rejected') {
       call.status = 'rejected'; call.code = string(event.code);
-    } else if (event.kind === 'capability_started') {
-      call.capability = { id: string(event.capabilityId), status: 'running', code: null };
-    } else if (['capability_result', 'capability_failed', 'capability_finalized'].includes(event.kind)) {
-      call.capability = { id: string(event.capabilityId) ?? call.capability?.id ?? null,
-        status: (event.outcome ?? event.kind) === 'capability_failed' ? 'failed' : 'completed', code: string(event.code) ?? string(event.terminalCode) };
+    } else if (['capability_started', 'capability_result', 'capability_failed', 'capability_finalized'].includes(event.kind)) {
+      let capability = call.capabilities.find(item => item.callId === event.callId);
+      if (!capability) {
+        capability = { callId: event.callId, ...(event.modelCallId ? { modelCallId: event.modelCallId,
+          toolUseId: string(event.toolUseId), toolIndex: token(event.toolIndex) } : {}), id: string(event.capabilityId),
+          status: 'running', code: null, createdAt: event.kind === 'capability_started' ? event.createdAt : null, endedAt: null };
+        call.capabilities.push(capability);
+      }
+      if (event.kind !== 'capability_started') {
+        capability.id = string(event.capabilityId) ?? capability.id;
+        capability.status = (event.outcome ?? event.kind) === 'capability_failed' ? 'failed' : 'completed';
+        capability.code = string(event.code) ?? string(event.terminalCode);
+        capability.endedAt = event.createdAt;
+        if (event.kind === 'capability_finalized') Object.assign(capability, { afterTerminal: true, accepted: false,
+          terminalCode: string(event.terminalCode) });
+      }
+      // Compatibility for scalar readers. Native one-to-many consumers use the
+      // complete array; never silently select one member of a multi-tool call.
+      if (call.capabilities.length === 1) call.capability = { id: capability.id, status: capability.status, code: capability.code };
+      else delete call.capability;
     }
   }
   const items = [...calls.values()].sort((a, b) => a.index - b.index);

package/yeaft/tools/bash.js

@@ -238,42 +238,45 @@ Guidelines:
       if (result.stderr) parts.push(`STDERR:\n${result.stderr}`);
       if (result.truncated) parts.push('[Captured output truncated; command exit/timeout status is reported separately. Use a background task for a durable log.]');
       if (result.timedOut) parts.push(`\n(Command timed out after ${timeout}ms)`);
-      if (result.terminationError) {
+      // runProcess resolves after close/owned cleanup, or reports an explicit
+      // terminationError. A missing exit code is not confirmed exit evidence.
+      const terminationConfirmed = !result.terminationError && Number.isInteger(result.exitCode);
+      if (!terminationConfirmed) {
         parts.push([
-          `WARNING: ${result.terminationError}`,
-          'The command timed out, but process-tree termination could not be confirmed. The command may still be running.',
-          'Decide whether to inspect or stop it, retry, or use background=true.',
+          `WARNING: ${result.terminationError || 'No confirmed process exit code was captured.'}`,
+          'Process-tree termination could not be confirmed. The command may still be running.',
+          'Inspect or stop it before retrying or launching another command; use background=true only after resolving its lifecycle.',
         ].join('\n'));
       }
-      if (result.timedOut) {
+      if (result.timedOut || !terminationConfirmed) {
         ctx?.requestToolBatchBarrier?.({
-          kind: 'owned_timeout',
+          kind: result.timedOut ? 'owned_timeout' : 'exit_unconfirmed',
           message: [
-            result.terminationError
-              ? 'The foreground Bash command timed out and process-tree termination could not be confirmed.'
-              : 'The foreground Bash command timed out.',
+            result.timedOut ? 'The foreground Bash command timed out.' : 'The foreground Bash command did not report a confirmed exit.',
+            ...(!terminationConfirmed ? ['Process-tree termination could not be confirmed.'] : []),
             'Return this result to the model before executing another tool call from the same batch.',
           ].join(' '),
         });
       }
 
       const output = parts.join('\n');
-      if (result.exitCode !== 0 || result.timedOut || result.terminationError) {
+      if (result.exitCode !== 0 || result.timedOut || !terminationConfirmed) {
         const failureType = result.timedOut
-          ? (result.terminationError ? 'timeout_unconfirmed' : 'timeout_confirmed')
-          : result.terminationError || result.exitCode === null ? 'exit_unconfirmed' : 'exit_nonzero';
+          ? (terminationConfirmed ? 'timeout_confirmed' : 'timeout_unconfirmed')
+          : terminationConfirmed ? 'exit_nonzero' : 'exit_unconfirmed';
+        const exitCode = Number.isInteger(result.exitCode) ? result.exitCode : null;
         return JSON.stringify({
           error: result.timedOut
-            ? `Command timed out after ${timeout}ms${result.terminationError ? '; process-tree termination was not confirmed' : ''}.`
-            : `Command exited with code ${result.exitCode}.`,
+            ? `Command timed out after ${timeout}ms${terminationConfirmed ? '' : '; process-tree termination was not confirmed'}.`
+            : terminationConfirmed ? `Command exited with code ${exitCode}.` : 'Command termination was not confirmed; the command may still be running.',
           code: `bash_${failureType}`,
           errorEffect: 'unknown',
           failureType,
-          exitCode: Number.isInteger(result.exitCode) ? result.exitCode : null,
-          status: `Exit code: ${result.exitCode}`,
+          exitCode,
+          status: `Exit code: ${exitCode}${result.timedOut ? '; timed out' : ''}; termination ${terminationConfirmed ? 'confirmed' : 'unconfirmed'}`,
           workingDirectory: `Working directory: ${cwd}`,
           timedOut: result.timedOut === true,
-          terminationConfirmed: result.timedOut ? !result.terminationError : null,
+          terminationConfirmed,
           terminationError: result.terminationError || null,
           cwd,
           output: output || '(no output)',

package/yeaft/tools/file-edit.js

@@ -48,6 +48,7 @@ Guidelines:
       },
       old_string: {
         type: 'string',
+        minLength: 1,
         description: {
           en: 'The exact text to find and replace',
           zh: '要查找并替换的精确文本',
@@ -76,7 +77,9 @@ Guidelines:
   async execute(input, ctx) {
     const { file_path, old_string, new_string, replace_all = false } = input;
     if (!file_path) return JSON.stringify({ errorEffect: 'none', error: 'file_path is required' });
-    if (old_string === undefined) return JSON.stringify({ errorEffect: 'none', error: 'old_string is required' });
+    // Guard even callers that bypass schema validation, before any filesystem IO.
+    // An empty needle never advances the synchronous occurrence-counting loop.
+    if (typeof old_string !== 'string' || old_string.length === 0) return JSON.stringify({ errorEffect: 'none', error: 'old_string must be non-empty text' });
     if (new_string === undefined) return JSON.stringify({ errorEffect: 'none', error: 'new_string is required' });
     if (old_string === new_string) return JSON.stringify({ errorEffect: 'none', error: 'old_string and new_string are identical' });