@yeaft/webchat-agent 1.0.588 → 1.0.589

package/local-runtime/version.json

@@ -1 +1 @@
-{"version":"1.0.588"}
+{"version":"1.0.589"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "1.0.588",
+  "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",

package/yeaft/person/capabilities.js

@@ -1,44 +1,117 @@
 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: 'Recall a bounded page of your own long-term messages or concepts.', 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.', 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']); }
+  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');
@@ -49,7 +122,7 @@ export class PersonCapabilities {
       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 });
-      // Pages contain complete accepted records; context assembly may omit whole records later.
+      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

@@ -114,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/repository.js

@@ -1,5 +1,6 @@
 import { randomUUID } from 'node:crypto';
 import { bytes, digest, fail, LIMITS, PersonError, safeError } from './contracts.js';
+import { capabilityExperienceView, recordCapabilityExperience } from './capability-experience.js';
 
 const COLLECTIONS = ['persons', 'messages', 'episodes', 'states', 'concepts', 'concept_revisions', 'state_commits', 'traces'];
 const txOptions = { readConcern: { level: 'snapshot' }, writeConcern: { w: 'majority' }, readPreference: 'primary', maxCommitTimeMS: 5000, timeoutMS: 10000 };
@@ -172,7 +173,9 @@ export class MongoPersonRepository {
     });
   }
   fence(episode, withLease = true) {
-    return { ...this.scope(episode.ownerId), activeEpisodeId: episode.id, epoch: episode.epoch, leaseOwner: episode.workerId,
+    const scope = this.scope(episode.ownerId);
+    if (episode.namespace !== scope.namespace || episode.personId !== scope.personId) fail('STALE');
+    return { ...scope, activeEpisodeId: episode.id, epoch: episode.epoch, leaseOwner: episode.workerId,
       stateVersion: episode.baseStateVersion, controlVersion: episode.controlVersion, inputWatermark: episode.inputWatermark, ...(withLease ? fresh() : {}) };
   }
   async heartbeat(episode) {
@@ -186,6 +189,11 @@ export class MongoPersonRepository {
     return this.transaction(async session => {
       const p = await this.collections.persons.findOneAndUpdate(this.fence(episode), { $inc: { writeSerial: 1 } }, { session, returnDocument: 'after' });
       if (!p) fail('STALE');
+      const scope = this.scope(episode.ownerId);
+      const record = await this.collections.episodes.findOne({ ...scope, id: episode.id, status: 'running' }, { session });
+      if (!record) fail('STALE');
+      const experience = recordCapabilityExperience(p.capabilityExperience, record, kind, data, new Date().toISOString());
+      if (experience) await this.collections.persons.updateOne(scope, { $set: { capabilityExperience: experience } }, { session });
       return this.trace(session, p, episode.id, kind, data);
     });
   }
@@ -242,7 +250,8 @@ export class MongoPersonRepository {
       this.collections.concepts.find(scope).sort({ updatedAt: -1, id: 1 }).limit(12).toArray(),
     ]);
     const concepts = [...new Map([...focused, ...recent].map(c => [c.id, publicDoc(c)])).values()];
-    return { person: this.personView(p), state: publicDoc(state), messages: messages.reverse().map(publicDoc), concepts };
+    return { person: this.personView(p), capabilityExperience: capabilityExperienceView(p.capabilityExperience),
+      state: publicDoc(state), messages: messages.reverse().map(publicDoc), concepts };
   }
   async recall(ownerId, { kind = 'messages', query = '', cursor = null, limit = 5 }) {
     const scope = this.scope(ownerId);

package/yeaft/person/runtime.js

@@ -1,5 +1,5 @@
 import { randomUUID } from 'node:crypto';
-import { CAPABILITY_MAP, PersonCapabilities, catalogRevision as capabilityCatalogRevision } from './capabilities.js';
+import { CAPABILITY_MAP, CAPABILITY_LIMITS, foundationCapabilities, PersonCapabilities, catalogRevision as capabilityCatalogRevision } from './capabilities.js';
 import { abortable, collectOutput } from './provider.js';
 import { bytes, fail, LIMITS, PersonError, PROPOSAL_INSTRUCTIONS, reportedLineage, safeError, validateProposal, validateSelection } from './contracts.js';
 
@@ -7,7 +7,7 @@ const messageRef = m => `message:${m.id}:${m.revision}`;
 const conceptRef = c => `concept:${c.id}:${c.revision}`;
 
 /** Assemble bounded request copies. Omitting a record never deletes or truncates its durable original. */
-export function assembleContext({ snapshot, episode, provider, selection, previous, capabilityResult, remainingCalls, dependencyRefs = [] }) {
+export function assembleContext({ snapshot, episode, provider, selection, previous, capabilityResult, remainingCalls, dependencyRefs = [], activeCapabilities = foundationCapabilities() }) {
   const model = validateSelection(selection, provider.catalog);
   // UTF-8 bytes is a conservative text-token bound; reserve explicit envelope/output overhead.
   const contextCap = Math.min(LIMITS.contextBytes, model.contextWindow - model.maxOutput - 1024);
@@ -17,7 +17,7 @@ export function assembleContext({ snapshot, episode, provider, selection, previo
     person: { id: snapshot.person.id, name: snapshot.person.name, soulRevision: snapshot.person.soulRevision },
     state: snapshot.state, trigger: { kind: episode.kind, text: episode.text, ref: triggerRef },
     models: provider.catalog, modelCatalogRevision: provider.catalogRevision,
-    capabilities: CAPABILITY_MAP, capabilityCatalogRevision,
+    capabilities: { ...CAPABILITY_MAP, active: [] }, capabilityCatalogRevision,
     budget: { remainingCalls, maxOutputBytes: LIMITS.outputBytes },
     previousProposal: previous ?? null, capabilityResult: capabilityResult ?? null,
     messages: [], concepts: [], sourceRefs: [triggerRef], inheritedSourceRefs: dependencyRefs,
@@ -41,6 +41,15 @@ export function assembleContext({ snapshot, episode, provider, selection, previo
   context.sourceRefs = [...sourceRefs];
   const fits = () => bytes(system) + bytes(context) <= contextCap;
   if (!fits()) fail('CONTEXT_LIMIT');
+  const omittedCapabilities = [];
+  for (const contract of activeCapabilities) {
+    context.capabilities.active.push(contract);
+    if (bytes(context.capabilities.active) > CAPABILITY_LIMITS.activeBytes || !fits()) {
+      context.capabilities.active.pop();
+      if (contract.availability.layer === 'foundation') fail('CONTEXT_LIMIT');
+      omittedCapabilities.push({ id: contract.id, reason: 'context-budget', inspect: 'catalog.view' });
+    }
+  }
   const add = (field, item, ref) => {
     if (renderedRefs.has(ref)) return;
     const inherited = sourceRefs.has(ref);
@@ -52,11 +61,12 @@ export function assembleContext({ snapshot, episode, provider, selection, previo
   context.messages.reverse();
   for (const c of snapshot.concepts) add('concepts', c, conceptRef(c));
   return {
-    system, messages: [{ role: 'user', content: JSON.stringify(context) }], sourceRefs, concepts: conceptMap, sources,
+    activeCapabilities: context.capabilities.active, system, messages: [{ role: 'user', content: JSON.stringify(context) }], sourceRefs, concepts: conceptMap, sources,
     manifest: { stateVersion: snapshot.state.version, sourceRefs: [...sourceRefs], renderedSourceRefs: [...renderedRefs], inputDependencyRefs: [...sourceRefs], omitted,
       boundedRecentWindow: { messages: 12, recentConcepts: 12, focusedConcepts: 12 },
       contextBytes: bytes(system) + bytes(context), contextBudgetBytes: contextCap, outputTokensReserved: model.maxOutput,
-      modelCatalogRevision: provider.catalogRevision, capabilityCatalogRevision }, maxTokens: model.maxOutput,
+      modelCatalogRevision: provider.catalogRevision, capabilityCatalogRevision,
+      activeCapabilities: context.capabilities.active.map(({ id, version, revision, availability }) => ({ id, version, revision, ...availability })), omittedCapabilities }, maxTokens: model.maxOutput,
   };
 }
 
@@ -95,7 +105,7 @@ export class PersonRuntime {
         try { validateSelection(snapshot.state.lastSelection, provider.catalog); selection = { ...snapshot.state.lastSelection, reason: 'last-accepted-choice', origin: 'persisted' }; }
         catch { await this.repository.append(episode, 'selection_rejected', { requested: snapshot.state.lastSelection, code: 'MODEL_SELECTION', fallback: 'configured-default' }); }
       }
-      const capabilities = new PersonCapabilities(this.repository, episode.ownerId);
+      const capabilities = new PersonCapabilities(this.repository, episode.ownerId, { experience: snapshot.capabilityExperience, triggerKind: episode.kind });
       let previous = null, capabilityResult = null, dependencyRefs = [];
       // Validation retains actual reads across calls, independently of the bounded rendered request.
       // Candidate proposals never enter this read-set or establish new provenance.
@@ -103,7 +113,8 @@ export class PersonRuntime {
       for (let index = 0; index < episode.budget.calls; index++) {
         signal.throwIfAborted();
         const callId = randomUUID();
-        const context = assembleContext({ snapshot, episode, provider, selection, previous, capabilityResult, dependencyRefs, remainingCalls: episode.budget.calls - index });
+        const context = assembleContext({ snapshot, episode, provider, selection, previous, capabilityResult, dependencyRefs, remainingCalls: episode.budget.calls - index, activeCapabilities: capabilities.context() });
+        capabilities.activate(context.activeCapabilities);
         dependencyRefs = context.manifest.inputDependencyRefs;
         for (const [id, concept] of context.concepts) readConcepts.set(id, concept);
         for (const [ref, source] of context.sources) readSources.set(ref, source);
@@ -155,14 +166,16 @@ export class PersonRuntime {
         capabilityResult = null;
         if (proposal.next.capability) {
           const invocation = proposal.next.capability;
-          await this.repository.append(episode, 'capability_started', { callId, capability: invocation, access: 'read-only' });
+          const manifest = capabilities.executionManifest(invocation.id);
+          const execution = manifest ? { capabilityManifest: manifest } : {};
+          await this.repository.append(episode, 'capability_started', { callId, capability: invocation, ...execution, access: 'read-only' });
           try {
             signal.throwIfAborted();
             capabilityResult = await abortable(capabilities.execute(invocation, { signal }), signal);
-            await this.repository.append(episode, 'capability_result', { callId, capability: invocation, result: capabilityResult });
+            await this.repository.append(episode, 'capability_result', { callId, capability: invocation, ...execution, result: capabilityResult });
           } catch (error) {
             const safe = safeError(error, 'UNSUPPORTED');
-            await this.repository.append(episode, 'capability_failed', { callId, capabilityId: invocation.id, code: safe.code }).catch(() => {});
+            await this.repository.append(episode, 'capability_failed', { callId, capabilityId: invocation.id, ...execution, code: safe.code }).catch(() => {});
             throw safe;
           }
         }

package/yeaft/person/sqlite-store.js

@@ -5,6 +5,7 @@ import { randomUUID } from 'node:crypto';
 import { isMainThread } from 'node:worker_threads';
 import { bytes, digest, fail, identifier, LIMITS, PersonError, text } from './contracts.js';
 import { SCHEMA, TABLES } from './sqlite-schema.js';
+import { capabilityExperienceView, recordCapabilityExperience } from './capability-experience.js';
 
 const SCOPE = 'namespace = ? AND ownerId = ? AND personId = ?';
 const scopeValues = s => [s.namespace, s.ownerId, s.personId];
@@ -219,7 +220,12 @@ export class SqlitePersonStore {
     const p = this.own(episode); p.leaseUntil = new Date(this.now.getTime() + this.leaseMs); p.writeSerial++; this.put('persons', p);
   }
   append(episode, kind, data) {
-    const p = this.own(episode); p.writeSerial++; this.put('persons', p);
+    const p = this.own(episode);
+    const record = this.one('episodes', this.episodeScope(episode), ' AND id = ?', [episode.id]);
+    if (!record || record.status !== 'running') fail('STALE');
+    const experience = recordCapabilityExperience(p.capabilityExperience, record, kind, data, this.now.toISOString());
+    if (experience) p.capabilityExperience = experience;
+    p.writeSerial++; this.put('persons', p);
     return this.trace(episode.ownerId, episode.id, kind, data);
   }
   startCall(episode, data) {
@@ -256,7 +262,8 @@ export class SqlitePersonStore {
     const p = this.own(episode), scope = this.episodeScope(episode), state = this.one('states', scope);
     const focused = this.focused(scope, state.focusConceptIds).slice(0, 12);
     const recent = this.rows('concepts', scope, ' ORDER BY updatedAt DESC, id ASC LIMIT 12');
-    return { person: this.personView(p), state: publicDoc(state), messages: this.rows('messages', scope, ' ORDER BY seq DESC LIMIT 12').reverse().map(publicDoc),
+    return { person: this.personView(p), capabilityExperience: capabilityExperienceView(p.capabilityExperience),
+      state: publicDoc(state), messages: this.rows('messages', scope, ' ORDER BY seq DESC LIMIT 12').reverse().map(publicDoc),
       concepts: [...new Map([...focused, ...recent].map(c => [c.id, publicDoc(c)])).values()] };
   }
   commit(episode, proposal, selection, callId, reportedSources = new Map()) {