@yeaft/webchat-agent 1.0.587 → 1.0.589

package/local-runtime/web/index.html

@@ -17,6 +17,6 @@
 </head>
 <body>
   <div id="app"></div>
-  <script type="module" src="app.bundle.js?v=8e6f87a6"></script>
+  <script type="module" src="app.bundle.js?v=0afa7538"></script>
 </body>
 </html>

package/local-runtime/web/installers/install.ps1

@@ -166,8 +166,19 @@ try {
   $env:PATH = "$NodeDir;$Prefix;$LocalBin;$OriginalPath"
   & $Node $NpmCli --version *> $null
   if ($LASTEXITCODE -ne 0) { Stop-Install 'the selected Node.js does not provide a working npm' }
-  & $Node $NpmCli --prefix $Prefix --global=false install $Package pm2 --registry=$Registry --no-audit --no-fund --loglevel=error
-  if ($LASTEXITCODE -ne 0) { Stop-Install 'npm could not install the Yeaft Agent' }
+  # Default to CPU native dependencies without changing the caller or service environment.
+  $OriginalCuda = Get-Item -LiteralPath 'Env:ONNXRUNTIME_NODE_INSTALL_CUDA' -ErrorAction SilentlyContinue
+  try {
+    if (-not $env:ONNXRUNTIME_NODE_INSTALL_CUDA) { $env:ONNXRUNTIME_NODE_INSTALL_CUDA = 'skip' }
+    & $Node $NpmCli --prefix $Prefix --global=false install $Package pm2 --registry=$Registry --no-audit --no-fund --loglevel=error
+    if ($LASTEXITCODE -ne 0) { Stop-Install 'npm could not install the Yeaft Agent' }
+  } finally {
+    if ($null -ne $OriginalCuda) {
+      Set-Item -LiteralPath 'Env:ONNXRUNTIME_NODE_INSTALL_CUDA' -Value $OriginalCuda.Value
+    } else {
+      Remove-Item -LiteralPath 'Env:ONNXRUNTIME_NODE_INSTALL_CUDA' -ErrorAction SilentlyContinue
+    }
+  }
 
   $Cli = Join-Path $Prefix 'node_modules\@yeaft\webchat-agent\cli.js'
   $Pm2 = Join-Path $Prefix 'node_modules\pm2\bin\pm2'

package/local-runtime/web/installers/install.sh

@@ -124,7 +124,9 @@ fi
 YEAFT_INSTALL_SERVER="$SERVER" "$NODE" -e 'try {const u=new URL(process.env.YEAFT_INSTALL_SERVER);if(!["ws:","wss:"].includes(u.protocol)||!u.hostname||u.username||u.password)process.exit(1)}catch{process.exit(1)}' >/dev/null 2>&1 || fail 'invalid server URL'
 NODE_DIR=$(dirname "$NODE")
 printf 'Installing the Yeaft Agent in %s...\n' "$PREFIX"
-PATH="$NODE_DIR:$PREFIX/bin:$PATH" "$NPM" --prefix "$PREFIX" --global install "$PACKAGE" \
+# Default to CPU native dependencies; scope the policy to npm, not the Agent service.
+ONNXRUNTIME_NODE_INSTALL_CUDA="${ONNXRUNTIME_NODE_INSTALL_CUDA:-skip}" \
+  PATH="$NODE_DIR:$PREFIX/bin:$PATH" "$NPM" --prefix "$PREFIX" --global install "$PACKAGE" \
   --registry="$REGISTRY" --no-audit --no-fund --loglevel=error || fail 'npm could not install the Yeaft Agent'
 CLI_JS=$PREFIX/lib/node_modules/@yeaft/webchat-agent/cli.js
 [ -f "$CLI_JS" ] || fail 'the installed package did not provide yeaft-agent'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "1.0.587",
+  "version": "1.0.589",
   "description": "Remote worker agent for Yeaft Web Code Agent — connects the native Yeaft engine, CLI providers, and workbench tools",
   "main": "index.js",
   "type": "module",
@@ -82,5 +82,8 @@
     "tweetnacl-util": "^0.15.1",
     "uuid": "^11.1.1",
     "ws": "^8.21.0"
+  },
+  "optionalDependencies": {
+    "@huggingface/transformers": "3.8.1"
   }
 }

package/yeaft/person/bridge.js

@@ -3,7 +3,7 @@ import ctx from '../../context.js';
 import { sendToServer } from '../../connection/buffer.js';
 
 /** Lazy Person transport. Only deployment-local environment supplies database credentials.
- * MongoDB is never contacted at ordinary Agent startup, nor configured by browser messages.
+ * Storage is lazy and instance-local by default; browser messages cannot choose a backend.
  */
 export function createPersonBridge({
   context = ctx, send = sendToServer, env = process.env,
@@ -33,14 +33,6 @@ export function createPersonBridge({
         return true;
       }
       const uri = env.YEAFT_PERSON_MONGODB_URI;
-      if (!uri) {
-        if (response.op === 'status') {
-          await send({ ...response, ok: true, data: { configured: false, reason: 'mongodb_not_configured' } });
-        } else {
-          await send({ ...response, ok: false, errorCode: 'not_configured', error: 'Configure YEAFT_PERSON_MONGODB_URI on the Agent to enable the digital person' });
-        }
-        return true;
-      }
       const agentId = context.agentId || context.AGENT_ID;
       if (!agentId || !context.CONFIG?.yeaftDir) throw new Error('identity');
       // Server+Agent is a storage boundary; a re-registration must not reuse the old runtime.
@@ -54,6 +46,8 @@ export function createPersonBridge({
       if (!servicePromise) {
         servicePromise = Promise.resolve().then(() => createService({
           uri,
+          storage: env.YEAFT_PERSON_STORAGE,
+          embedding: { enabled: env.YEAFT_PERSON_EMBEDDING !== 'off', allowDownload: env.YEAFT_PERSON_EMBEDDING_DOWNLOAD !== '0' },
           dbName: env.YEAFT_PERSON_MONGODB_DB || 'yeaft_person',
           namespace,
           yeaftDir: context.CONFIG.yeaftDir,
@@ -74,10 +68,11 @@ export function createPersonBridge({
         NOT_OPEN: 'Open the digital person first',
         STALE: 'Digital person state changed; refresh and try again',
         IDEMPOTENCY_CONFLICT: 'This message identifier already belongs to a different request',
+        STORAGE_MISMATCH: 'The configured storage differs from the existing Person authority; do not switch without a verified migration',
         UNSUPPORTED: 'This capability is not available in this digital person version',
       };
       const known = Object.hasOwn(safeErrors, error?.code);
-      // A lost Mongo commit acknowledgement or response-send failure is not a
+      // A lost database commit acknowledgement or response-send failure is not a
       // definitive rejection. Preserve the command ID so an explicit retry deduplicates.
       await send({ ...response, ok: false, errorCode: known ? error.code.toLowerCase() : 'outcome_unknown',
         error: known ? safeErrors[error.code] : 'Digital person outcome is unknown; refresh and check Agent database/model configuration' });

package/yeaft/person/capabilities.js

@@ -1,53 +1,128 @@
 import { bytes, digest, fail, identifier, object, page, text } from './contracts.js';
 
-// Versioned read-only methods, not the Agent's full registry. No shell/filesystem/VP side effects.
+// Trusted versioned read-only methods, not the Agent's full registry. No shell/filesystem/VP side effects.
 const entries = [
-  { id: 'Think', version: 1, domain: 'cognition', description: 'Intrinsic deliberate reflection, reorganization, association and reconsideration.', instructions: 'Revisit supplied experiences and current judgments; separate report from hypothesis, propose new concepts or associations, test a counterexample, and record the explicit finding with uncertainty. It is fine to rest. This is a method, not another model call or external action.', args: {} },
-  { id: 'Recall', version: 1, domain: 'memory', description: 'Read a bounded page of your own MongoDB messages or concepts.', instructions: 'args: {kind:"messages"|"concepts",query?:string,cursor?:string|null,limit?:1..5}. Literal text search, not a semantic or exhaustive search. Preserve nextCursor to reach older/lower-ranked records.', args: { kind: 'messages|concepts', query: 'optional literal search text', cursor: 'optional opaque cursor', limit: '1..5' } },
-  { id: 'Skill.reconsider', version: 1, domain: 'method', description: 'Read-only method for revising a previous judgment.', instructions: 'Identify one prior claim, list a concrete counterexample or missing evidence, and decide whether to retain, qualify or revise it. Mark what remains unresolved. Do not present the counterexample as an observed event without evidence.', args: {} },
-  { id: 'Skill.associate', version: 1, domain: 'method', description: 'Read-only method for new conceptual associations.', instructions: 'Compare two recalled concepts or experiences. Propose a typed relation and a new question or hypothetical scenario. Co-occurrence is not causation; imagination is not an experience. Keep useful disagreement instead of forcing agreement.', args: {} },
+  { 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: 'Revisit supplied experiences and current judgments; separate report from hypothesis, propose new concepts or associations, test a counterexample, and record the explicit finding with uncertainty. It is fine to rest. This is a method, not another model call or external action.', args: {} },
+  { 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' } },
+  { id: 'Skill.reconsider', version: 1, domain: 'method', description: 'Read-only method for revising a previous judgment.', keywords: '反思 复核 反例 修正 重新审视 reconsider revise counterexample', useWhen: 'A prior judgment meets conflicting evidence or may have overlooked an alternative.', avoidWhen: 'Do not force a revision or treat a hypothetical counterexample as observed evidence.', instructions: 'Identify one prior claim, list a concrete counterexample or missing evidence, and decide whether to retain, qualify or revise it. Mark what remains unresolved. Do not present the counterexample as an observed event without evidence.', args: {} },
+  { id: 'Skill.associate', version: 1, domain: 'method', description: 'Read-only method for new conceptual associations.', keywords: '联想 关联 遐想 想象 associate association imagine dream', useWhen: 'Explore a possible relation between experiences or concepts and preserve it as a question or hypothesis.', avoidWhen: 'Do not equate similarity or co-occurrence with causation or verified experience.', instructions: 'Compare two recalled concepts or experiences. Propose a typed relation and a new question or hypothetical scenario. Co-occurrence is not causation; imagination is not an experience. Keep useful disagreement instead of forcing agreement.', args: {} },
 ];
+const manifests = entries.map(entry => {
+  const contract = { ...entry, access: 'read-only', dependencies: [] };
+  return { ...contract, revision: digest(contract) };
+});
+const byId = new Map(manifests.map(manifest => [manifest.id, manifest]));
+const foundationIds = new Set(['Think', 'Recall']);
+export const CAPABILITY_LIMITS = Object.freeze({ familiar: 2, familiarMaxAgeMs: 30 * 24 * 60 * 60 * 1000, activeBytes: 8192, searchContractBytes: 4096 });
 export const CAPABILITY_MAP = Object.freeze({
   domains: ['cognition', 'memory', 'method'], total: entries.length,
-  discover: { id: 'catalog.search', args: '{query?:string,cursor?:string|null,limit?:1..5}', description: 'Browse/search bounded capability summaries. All entries are reachable by pagination.' },
-  inspect: { id: 'catalog.view', args: '{id:string}', description: 'Load a selected versioned manifest; only then use that read-only capability.' },
+  discover: { id: 'catalog.search', args: '{query?:string,cursor?:string|null,limit?:1..5}', description: 'Browse/search summaries with budgeted complete contracts. Returned contracts are prepared for the next call; omitted contracts require catalog.view. All entries remain reachable by pagination.' },
+  inspect: { id: 'catalog.view', args: '{id:string}', description: 'Load a known ID directly, or a contract omitted by search. No search is required first.' },
   intrinsic: 'Think is always available as a cognitive activity; no tool call is required.',
 });
-export const catalogRevision = digest(entries);
+export const catalogRevision = digest(manifests);
+const copy = value => structuredClone(value);
+const available = (manifest, layer, reason, experience) => ({ ...copy(manifest), availability: { layer, reason, ...(experience ? { experience } : {}) } });
+export const foundationCapabilities = () => manifests.filter(m => foundationIds.has(m.id)).map(m => available(m, 'foundation', 'general-cognitive-ability'));
+
+/** A bounded procedural familiarity projection, never a stored contract or authorization.
+ * Only execution observations for this Person arrive from the fenced repository snapshot.
+ * Trigger kind is a coarse preference, not a semantic classifier or a compulsory workflow. */
+function familiarCapabilities(experience, triggerKind, now) {
+  const candidates = [];
+  for (const item of Array.isArray(experience) ? experience.slice(0, 16) : []) {
+    const manifest = byId.get(item?.id);
+    if (!manifest || foundationIds.has(item.id) || item.version !== manifest.version || item.revision !== manifest.revision) continue;
+    const observations = (Array.isArray(item.observations) ? item.observations.slice(0, 8) : [])
+      .filter(o => ['succeeded', 'failed'].includes(o?.outcome) && ['send', 'think', 'dream'].includes(o.triggerKind) && Number.isFinite(Date.parse(o.usedAt)))
+      .sort((a, b) => Date.parse(b.usedAt) - Date.parse(a.usedAt));
+    const latest = observations[0], age = now - Date.parse(latest?.usedAt);
+    if (!latest || latest.outcome !== 'succeeded' || age < 0 || age > CAPABILITY_LIMITS.familiarMaxAgeMs) continue;
+    const matching = observations.filter(o => o.triggerKind === triggerKind && now - Date.parse(o.usedAt) >= 0 && now - Date.parse(o.usedAt) <= CAPABILITY_LIMITS.familiarMaxAgeMs);
+    candidates.push({ manifest, latest, matching: matching.length, experience: {
+      lastUsedAt: latest.usedAt, lastOutcome: latest.outcome,
+      observedSuccesses: observations.filter(o => o.outcome === 'succeeded').length,
+      observedFailures: observations.filter(o => o.outcome === 'failed').length,
+      sameTriggerObservations: matching.length, usefulness: 'not-evaluated',
+    } });
+  }
+  return candidates.sort((a, b) => b.matching - a.matching || Date.parse(b.latest.usedAt) - Date.parse(a.latest.usedAt) || a.manifest.id.localeCompare(b.manifest.id, 'en'))
+    .slice(0, CAPABILITY_LIMITS.familiar).map(c => available(c.manifest, 'familiar', c.matching ? 'used-in-same-trigger-kind' : 'recently-used', c.experience));
+}
+
 export class PersonCapabilities {
-  constructor(repository, ownerId) { this.repository = repository; this.ownerId = ownerId; this.loaded = new Set(['Think']); }
-  async execute({ id, args }) {
+  constructor(repository, ownerId, { experience = [], triggerKind = 'think', now = Date.now() } = {}) {
+    this.repository = repository; this.ownerId = ownerId;
+    this.prepared = new Map([...foundationCapabilities(), ...familiarCapabilities(experience, triggerKind, now)].map(m => [m.id, m]));
+    this.active = new Map(this.prepared);
+  }
+  context() { return copy([...this.prepared.values()]); }
+  /** Freeze execution eligibility to the complete contracts actually rendered in this call. */
+  activate(rendered) {
+    this.active = new Map();
+    for (const item of rendered) {
+      const current = byId.get(item.id);
+      if (current && current.revision === item.revision && this.prepared.has(item.id)) this.active.set(item.id, current);
+    }
+  }
+  executionManifest(id) {
+    const manifest = this.active.get(id), current = byId.get(id);
+    if (!manifest || manifest.revision !== current?.revision) return null;
+    return { id: current.id, version: current.version, revision: current.revision };
+  }
+  prepare(manifest) {
+    // A bounded working set. Explicitly requested contracts precede older optional ones.
+    const item = available(manifest, foundationIds.has(manifest.id) ? 'foundation' : 'discovered', 'explicitly-requested');
+    const next = [item, ...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);
+    }
+    this.prepared = new Map(kept.map(m => [m.id, m]));
+    // Runtime replaces this with its rendered manifest before every cognitive dispatch.
+    this.activate(kept);
+  }
+  async execute({ id, args }, { signal } = {}) {
+    signal?.throwIfAborted();
     if (id === 'catalog.search') {
       object(args, ['query', 'cursor', 'limit'], []);
-      const query = text(args.query ?? '', 200, true).toLowerCase();
+      const query = text(args.query ?? '', 200, true).toLowerCase().trim();
       const limit = args.limit ?? 3;
       if (!Number.isInteger(limit) || limit < 1 || limit > 5) fail('INVALID_REQUEST');
       if (args.cursor != null) identifier(args.cursor);
-      const matches = entries.filter(e => `${e.id} ${e.domain} ${e.description}`.toLowerCase().includes(query)).sort((a, b) => a.id.localeCompare(b.id, 'en'));
+      const terms = query.split(/\s+/u).filter(Boolean);
+      const matches = manifests.filter(e => terms.every(term => `${e.id} ${e.domain} ${e.description} ${e.keywords} ${e.useWhen}`.toLowerCase().includes(term))).sort((a, b) => a.id.localeCompare(b.id, 'en'));
       const start = args.cursor == null ? 0 : matches.findIndex(e => e.id === args.cursor) + 1;
       if (args.cursor != null && start === 0) fail('INVALID_REQUEST');
-      const items = matches.slice(start, start + limit).map(({ instructions, args: schema, ...entry }) => entry);
-      return { items, nextCursor: start + limit < matches.length ? items.at(-1).id : null, catalogRevision };
+      const contracts = [], omittedContracts = [];
+      const items = matches.slice(start, start + limit).map(manifest => {
+        if (bytes([...contracts, manifest]) <= CAPABILITY_LIMITS.searchContractBytes) { contracts.push(copy(manifest)); this.prepare(manifest); }
+        else omittedContracts.push({ id: manifest.id, reason: 'contract-budget', inspect: 'catalog.view' });
+        const { instructions, args: schema, dependencies, keywords, ...summary } = manifest;
+        return summary;
+      });
+      return { items, contracts, omittedContracts, nextCursor: start + limit < matches.length ? items.at(-1).id : null, catalogRevision };
     }
     if (id === 'catalog.view') {
       object(args, ['id']); identifier(args.id);
-      const entry = entries.find(e => e.id === args.id);
+      const entry = byId.get(args.id);
       if (!entry) fail('UNSUPPORTED');
-      this.loaded.add(entry.id);
-      return { ...entry, catalogRevision, access: 'read-only', dependencies: [] };
+      this.prepare(entry);
+      return { ...copy(entry), catalogRevision };
     }
-    const entry = entries.find(e => e.id === id);
-    if (!entry || !this.loaded.has(id)) fail('UNSUPPORTED');
+    const entry = byId.get(id);
+    if (!entry || !this.executionManifest(id)) fail('UNSUPPORTED');
     if (id === 'Recall') {
       object(args, ['kind', 'query', 'cursor', 'limit'], ['kind']);
       if (!['messages', 'concepts'].includes(args.kind)) fail('INVALID_REQUEST');
       text(args.query ?? '', 200, true);
       const limit = args.limit ?? 3;
       if (!Number.isInteger(limit) || limit < 1 || limit > 5) fail('INVALID_REQUEST');
-      const cursor = args.kind === 'messages' ? page({ cursor: args.cursor, limit }).cursor : args.cursor;
-      if (args.kind === 'concepts' && cursor != null) identifier(cursor);
-      const result = await this.repository.recall(this.ownerId, { ...args, cursor, limit });
-      // Pages contain complete accepted records; context assembly may omit whole records later.
+      const localCursor = typeof args.cursor === 'string' && /^lm:[a-f0-9]{32}:\d{1,6}$/.test(args.cursor);
+      const cursor = args.kind === 'messages' && !localCursor ? page({ cursor: args.cursor, limit }).cursor : args.cursor;
+      if (cursor != null && (localCursor || args.kind === 'concepts')) identifier(cursor);
+      const result = await this.repository.recall(this.ownerId, { ...args, cursor, limit }, { signal });
+      signal?.throwIfAborted();
       if (bytes(result) > 60000) fail('CONTEXT_LIMIT');
       return { ...result, kind: args.kind, version: entry.version };
     }

package/yeaft/person/capability-experience.js

@@ -0,0 +1,60 @@
+import { fail, identifier, object } from './contracts.js';
+
+export const CAPABILITY_EXPERIENCE_LIMITS = Object.freeze({ entries: 16, observations: 8 });
+const excluded = new Set(['catalog.search', 'catalog.view', 'Think']);
+const manifestFields = ['id', 'version', 'revision'];
+const observationFields = ['episodeId', 'callId', 'triggerKind', 'outcome', 'code', 'usedAt'];
+const recentFirst = (a, b) => b.usedAt.localeCompare(a.usedAt);
+
+function manifest(value) {
+  object(value, manifestFields);
+  identifier(value.id);
+  if (!Number.isSafeInteger(value.version) || value.version < 1 || typeof value.revision !== 'string' || !/^[a-f0-9]{64}$/.test(value.revision)) fail('INVALID_REQUEST');
+  return { id: value.id, version: value.version, revision: value.revision };
+}
+function observation(value) {
+  object(value, observationFields);
+  identifier(value.episodeId); identifier(value.callId);
+  if (!['send', 'think', 'dream'].includes(value.triggerKind) || !['succeeded', 'failed'].includes(value.outcome)) fail('INVALID_REQUEST');
+  if (value.outcome === 'failed') identifier(value.code);
+  else if (value.code !== null) fail('INVALID_REQUEST');
+  if (typeof value.usedAt !== 'string' || !/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/.test(value.usedAt) ||
+      !Number.isFinite(Date.parse(value.usedAt)) || new Date(value.usedAt).toISOString() !== value.usedAt) fail('INVALID_REQUEST');
+  return { episodeId: value.episodeId, callId: value.callId, triggerKind: value.triggerKind, outcome: value.outcome, code: value.code, usedAt: value.usedAt };
+}
+
+/** Bounded metadata only. No instructions, permissions, arguments or results are
+ * retained or made authoritative. Technical success is not semantic usefulness. */
+export function capabilityExperienceView(value = []) {
+  if (!Array.isArray(value)) fail('INVALID_REQUEST');
+  return value.map(entry => {
+    object(entry, [...manifestFields, 'observations']);
+    const metadata = manifest({ id: entry.id, version: entry.version, revision: entry.revision });
+    if (!Array.isArray(entry.observations)) fail('INVALID_REQUEST');
+    const observations = entry.observations.map(observation).sort(recentFirst).slice(0, CAPABILITY_EXPERIENCE_LIMITS.observations);
+    return { ...metadata, observations };
+  }).filter(entry => !excluded.has(entry.id) && entry.observations.length)
+    .sort((a, b) => recentFirst(a.observations[0], b.observations[0])).slice(0, CAPABILITY_EXPERIENCE_LIMITS.entries);
+}
+
+/** Called ONLY inside a fenced append transaction, with the stored episode and
+ * repository clock. Missing manifest means no observed execution (legacy trace
+ * or pre-execution rejection), not permission to infer one from trace content.
+ * Returns null when no mutation is needed; never mutates either input. */
+export function recordCapabilityExperience(previous, episode, kind, data, usedAt) {
+  if (!['capability_result', 'capability_failed'].includes(kind) || !data || !Object.hasOwn(data, 'capabilityManifest')) return null;
+  const id = kind === 'capability_result' ? data.capability?.id : data.capabilityId;
+  if (excluded.has(id)) return null;
+  const metadata = manifest(data.capabilityManifest);
+  if (metadata.id !== id) fail('INVALID_REQUEST');
+  const next = observation({ episodeId: episode.id, callId: data.callId, triggerKind: episode.kind,
+    outcome: kind === 'capability_result' ? 'succeeded' : 'failed', code: kind === 'capability_result' ? null : data.code, usedAt });
+  const entries = capabilityExperienceView(previous);
+  // Event identity is per episode/call, including across capability entries.
+  if (entries.some(entry => entry.observations.some(o => o.episodeId === next.episodeId && o.callId === next.callId))) return null;
+  const existing = entries.find(entry => entry.id === id);
+  const retained = existing?.version === metadata.version && existing.revision === metadata.revision ? existing.observations : [];
+  const updated = { ...metadata, observations: [next, ...retained].sort(recentFirst).slice(0, CAPABILITY_EXPERIENCE_LIMITS.observations) };
+  return [updated, ...entries.filter(entry => entry.id !== id)]
+    .sort((a, b) => recentFirst(a.observations[0], b.observations[0])).slice(0, CAPABILITY_EXPERIENCE_LIMITS.entries);
+}

package/yeaft/person/contracts.js

@@ -3,8 +3,9 @@ import { createHash } from 'node:crypto';
 // 只允许应用层显式产物；不要求或保存 provider 的隐藏推理。
 export const LIMITS = Object.freeze({ inputBytes: 8192, outputBytes: 65536, contextBytes: 65536, calls: 4, timeoutMs: 120000, leaseMs: 15000 });
 const ERRORS = {
-  INVALID_REQUEST: 'Invalid digital person request.', NOT_CONFIGURED: 'MongoDB is not configured for digital person.',
-  STORAGE_UNAVAILABLE: 'Digital person storage is unavailable; a transaction-capable MongoDB replica set is required.',
+  INVALID_REQUEST: 'Invalid digital person request.', NOT_CONFIGURED: 'Digital person storage configuration is missing.',
+  STORAGE_UNAVAILABLE: 'Digital person storage is unavailable. Check instance storage and database configuration.',
+  STORAGE_MISMATCH: 'Person storage is already bound to another backend; a verified migration is required.',
   NOT_OPEN: 'Open your digital person first.', BUSY: 'The digital person is already active.',
   IDEMPOTENCY_CONFLICT: 'This clientMessageId was already used for a different request.',
   STALE: 'The activity no longer owns the current person revision.', INVALID_PROPOSAL: 'The model returned an invalid cognitive proposal.',
@@ -113,5 +114,6 @@ export const PROPOSAL_INSTRUCTIONS = `Return ONLY one strict JSON object, no mar
 Schema (all fields required, 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}}}.
 Use the actual numeric baseStateVersion. New concept IDs use simple stable identifiers with expectedRevision 0; revisions of existing concepts require the revision you actually read. At most 12 concepts/associations/focus/uncertainties, 24 sourceRefs. Statements/summaries <=4000 UTF-8 bytes, selfCheck/appraisal <=2000, uncertainty <=500, reply <=8192, next reason <=1000. SourceRefs must exactly match supplied sourceRefs; references are provenance, not proof. Scenario is always imagined; new Dream concepts are imagined/hypothesis/uncertain. Every reported concept, including revisions during Dream, must cite a user message, a nonempty send/think input trigger, or a reported concept with preserved reportedSourceRefs. Assistant messages, imagined/hypothetical/uncertain concepts and Dream/empty Think triggers are not independent reports. Cite the earlier reported concept to preserve its lineage when revising it; retain at most 24 independent report roots. Reported means attributed input, not verified objective truth. No objective-fact epistemic label is available.
-budget.remainingCalls includes this call. Reserve the final call for a proposal with next:null; catalog.search, catalog.view and Recall followed by a final proposal require four calls total. If evidence remains insufficient at the final call, record the uncertainty or rest instead of inventing a result. No additional call is granted after the budget ends.
+budget.remainingCalls includes this call. Reserve the final call for a proposal with next:null; An active Recall followed by a final proposal needs two calls total; search (with a returned contract), capability use and final proposal need three. Do not search or inspect an already active capability merely to follow stages. If evidence remains insufficient at the final call, record the uncertainty or rest instead of inventing a result. No additional call is granted after the budget ends.
+capabilities.active contains complete, current contracts prepared in three layers: foundation abilities, familiar abilities from actual execution observations, and explicitly discovered abilities. You may directly request any active capability; availability does not require use. Familiarity is a hint, not a goal, permission, semantic usefulness or evidence of truth. Evaluate whether the result actually helps in decision.selfCheck; ignore an unhelpful habit, seek another method, or rest. If no prepared ability fits, search the catalog or view a known ID. Search can prepare budgeted contracts without a separate view step; omitted contracts still need inspection. Only runtime-validated active contracts may execute. No separate selector model or hidden cognition is involved.
 Think is intrinsic: recall experience, reorganize it, form concepts and associations, reconsider old judgments, or rest. Each call records one explicit activity. You are the same enduring Person, not a task coordinator. Form your own conclusions, preserve uncertainty, and self-check. You may finish in one call, or choose the next model/effort from the provided catalog with a brief reason and one read-only capability. No mandatory stages or fixed upgrade ladder. Intermediate proposals are NOT accepted state. Only the final proposal (next:null) is committed; include the desired complete state and all final concept changes. Do not claim that a proposal was already committed. Dream is unhurried idle imagination, not a disguised user message or a requirement to produce useful work; reply may be null.`;

package/yeaft/person/local-memory-cache.js

@@ -0,0 +1,82 @@
+import { createHash, randomUUID } from 'node:crypto';
+import { createReadStream } from 'node:fs';
+import { mkdir, open, rename, stat, unlink } from 'node:fs/promises';
+import path from 'node:path';
+
+async function isComplete(file, { size, sha256 }) {
+  try {
+    if ((await stat(file)).size !== size) return false;
+    const hash = createHash('sha256');
+    for await (const chunk of createReadStream(file)) hash.update(chunk);
+    return hash.digest('hex') === sha256;
+  } catch (error) {
+    if (error.code === 'ENOENT') return false;
+    throw error;
+  }
+}
+
+async function syncDirectory(dir) {
+  // Windows does not support opening directories for fsync. A lost directory
+  // entry after power failure is still a cache miss, never an accepted partial file.
+  if (process.platform === 'win32') return;
+  const handle = await open(dir, 'r');
+  try { await handle.sync(); } finally { await handle.close(); }
+}
+
+async function publish(file, url, expected) {
+  const dir = path.dirname(file);
+  await mkdir(dir, { recursive: true, mode: 0o700 });
+  const temporary = `${file}.${process.pid}.${randomUUID()}.partial`;
+  let handle;
+  try {
+    const response = await fetch(url);
+    if (response.status !== 200 || !response.body) throw new Error('model_download_failed');
+    handle = await open(temporary, 'wx', 0o600);
+    const hash = createHash('sha256');
+    let size = 0;
+    // Backpressure keeps memory bounded to stream chunks, including the ONNX file.
+    for await (const chunk of response.body) {
+      size += chunk.byteLength;
+      if (size > expected.size) throw new Error('model_integrity_failed');
+      hash.update(chunk);
+      await handle.writeFile(chunk);
+    }
+    if (size !== expected.size || hash.digest('hex') !== expected.sha256) throw new Error('model_integrity_failed');
+    await handle.sync();
+    await handle.close();
+    handle = null;
+    // Concurrent publishers have the same pinned digest. Never unlink the final
+    // path: an invalid reader or failed writer must not remove another one's repair.
+    await rename(temporary, file);
+    await syncDirectory(dir);
+  } finally {
+    await handle?.close();
+    await unlink(temporary).catch(error => { if (error.code !== 'ENOENT') throw error; });
+  }
+}
+
+/**
+ * Prepare an instance-owned, immutable model snapshot before Transformers sees it.
+ * `artifacts` is a trusted manifest of filename -> { size, sha256 }, pinned with
+ * `model` and its commit `revision`. The hashes are the completion markers: legacy
+ * complete files work offline, partial/corrupt files are misses, and SIGKILL leaves
+ * only ignored unique .partial files. No lock or mutable sidecar can become stale.
+ * Returns a local directory; inference must use it with remote access disabled.
+ */
+export async function prepareModelCache({ yeaftDir, model, revision, artifacts, allowDownload = true }) {
+  if (!/^[\w.-]+\/[\w.-]+$/.test(model) || model.split('/').some(p => p === '.' || p === '..') || !/^[a-f0-9]{40}$/.test(revision)) {
+    throw new Error('invalid_model_identity');
+  }
+  const dir = path.resolve(yeaftDir, 'person', 'models', model, revision);
+  for (const [name, expected] of Object.entries(artifacts)) {
+    if (!name.split('/').every(p => /^[\w.-]+$/.test(p) && p !== '.' && p !== '..') ||
+        !Number.isSafeInteger(expected.size) || expected.size <= 0 || !/^[a-f0-9]{64}$/.test(expected.sha256)) {
+      throw new Error('invalid_model_artifact');
+    }
+    const file = path.join(dir, name);
+    if (await isComplete(file, expected)) continue;
+    if (!allowDownload) throw new Error('model_cache_incomplete');
+    await publish(file, `https://huggingface.co/${model}/resolve/${revision}/${name}`, expected);
+  }
+  return dir;
+}

package/yeaft/person/local-memory-embedding.js

@@ -0,0 +1,54 @@
+import { prepareModelCache } from './local-memory-cache.js';
+
+export const LOCAL_MODEL = 'Xenova/multilingual-e5-small';
+export const LOCAL_REVISION = '761b726dd34fb83930e26aab4e9ac3899aa1fa78';
+// SHA-256 of the exact revision's files (LFS oid for tokenizer/ONNX). Update this
+// manifest with LOCAL_REVISION, never from mutable download response metadata.
+export const LOCAL_ARTIFACTS = Object.freeze({
+  'config.json': Object.freeze({ size: 658, sha256: 'cb99455288675345e1a4f411438d5d0adbba5fbd3a67ea4fb03c015433b996c1' }),
+  'tokenizer_config.json': Object.freeze({ size: 443, sha256: 'a1d6bc8734a6f635dc158508bef000f8e2e5a759c7d92f984b2c86e5ff53425b' }),
+  'tokenizer.json': Object.freeze({ size: 17082730, sha256: '0b44a9d7b51c3c62626640cda0e2c2f70fdacdc25bbbd68038369d14ebdf4c39' }),
+  'onnx/model_quantized.onnx': Object.freeze({ size: 118308185, sha256: 'f80102d3f2a1229f387d3c81909990d8945513e347b0eab049f7de3c6f98c193' }),
+});
+export const VECTOR_DIMENSION = 384;
+export const CHUNK_SIZE = 320;
+export const CHUNK_OVERLAP = 64;
+// Version the complete space, not just the model name. A change invalidates derived chunks.
+export const MODEL_FINGERPRINT = `${LOCAL_MODEL}@${LOCAL_REVISION}:q8:mean:l2:384:e5-prefix:codepoints-${CHUNK_SIZE}-${CHUNK_OVERLAP}:segmenter-v1`;
+
+/** Worker-only lazy adapter. Only model artifacts use the network; text goes to local ONNX. */
+export function createEmbedding({ yeaftDir, allowDownload = true, threads = 2 } = {}) {
+  let extractor;
+  async function load() {
+    if (extractor) return extractor;
+    const modelDir = await prepareModelCache({ yeaftDir, model: LOCAL_MODEL, revision: LOCAL_REVISION, artifacts: LOCAL_ARTIFACTS, allowDownload });
+    const { pipeline, env } = await import('@huggingface/transformers');
+    // Never let Transformers' non-atomic FileCache write model artifacts. The
+    // validated local snapshot is complete, including when restarting offline.
+    env.allowRemoteModels = false;
+    env.allowLocalModels = true;
+    env.localModelPath = '';
+    env.useBrowserCache = false;
+    env.useCustomCache = true;
+    env.customCache = { async match() {}, async put() { throw new Error('unexpected_model_cache_write'); } };
+    // 3.8.1 also uses this flag to pass the ONNX *path* to the native runtime.
+    // The custom cache above prevents its unsafe FileCache from being instantiated.
+    env.useFSCache = true;
+    extractor = await pipeline('feature-extraction', modelDir, {
+      revision: LOCAL_REVISION, dtype: 'q8', device: 'cpu',
+      local_files_only: true,
+      session_options: { intraOpNumThreads: Math.max(1, Math.min(4, threads)), interOpNumThreads: 1 },
+    });
+    return extractor;
+  }
+  return {
+    async embed(texts, type) {
+      const model = await load();
+      const output = await model(texts.map(text => `${type === 'query' ? 'query' : 'passage'}: ${text}`), {
+        pooling: 'mean', normalize: true, truncation: true, max_length: 512,
+      });
+      return output.tolist();
+    },
+    async close() { if (extractor) await extractor.dispose(); extractor = null; },
+  };
+}

package/yeaft/person/local-memory-host.js

@@ -0,0 +1,40 @@
+import { Worker } from 'node:worker_threads';
+import { createEmbedding } from './local-memory-embedding.js';
+
+// ONNX's native addon is not reliably reloadable in replacement Node threads.
+// Keep it in this disposable process; SQLite/tokenization/ranking use a worker
+// thread. The Agent supervises the whole process, including blocked native work.
+let worker;
+let embedder;
+let closing = false;
+process.on('message', message => {
+  if (message.init) {
+    if (worker) return;
+    const options = message.init;
+    worker = new Worker(new URL('./local-memory-worker.js', import.meta.url), { workerData: options });
+    worker.on('message', async response => {
+      if (response.embeddingRequest) {
+        const { id, texts, type } = response.embeddingRequest;
+        try {
+          embedder ??= createEmbedding({ ...options.embedding, yeaftDir: options.yeaftDir });
+          const value = await embedder.embed(texts, type);
+          worker.postMessage({ embeddingResult: { id, value } });
+        } catch {
+          worker.postMessage({ embeddingResult: { id, error: true } });
+        }
+      } else if (response.closed) {
+        closing = true;
+        try { await embedder?.close(); }
+        finally { process.disconnect(); }
+      } else {
+        process.send?.(response);
+      }
+    });
+    worker.on('error', () => process.exit(1));
+    worker.on('exit', code => { if (!closing || code) process.exit(1); });
+    return;
+  }
+  worker?.postMessage(message);
+});
+// Agent crash/IPC teardown must not leave the model process or its thread alive.
+process.on('disconnect', () => process.exit(0));