@yeaft/webchat-agent 1.0.588 → 1.0.590

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(), capabilityMap = CAPABILITY_MAP }) {
   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: { ...capabilityMap, active: [] }, capabilityCatalogRevision: capabilityMap.revision ?? 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: capabilityMap.revision ?? capabilityCatalogRevision,
+      activeCapabilities: context.capabilities.active.map(({ id, version, revision, availability }) => ({ id, version, revision, ...availability })), omittedCapabilities }, maxTokens: model.maxOutput,
   };
 }
 
@@ -95,7 +105,8 @@ 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 created = await abortable(this.repository.createdCapabilities(episode), signal);
+      const capabilities = new PersonCapabilities(this.repository, episode.ownerId, { experience: snapshot.capabilityExperience, triggerKind: episode.kind, created, episode });
       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 +114,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(), capabilityMap: capabilities.catalog() });
+        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 +167,24 @@ 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: capabilities.active.get(invocation.id)?.access ?? 'catalog-read' });
           try {
             signal.throwIfAborted();
-            capabilityResult = await abortable(capabilities.execute(invocation, { signal }), signal);
-            await this.repository.append(episode, 'capability_result', { callId, capability: invocation, result: capabilityResult });
+            // Script cancellation joins its worker before runtime.close can finish.
+            const executionPromise = capabilities.execute(invocation, { signal, callId });
+            capabilityResult = invocation.id === 'Capability.create' || invocation.id.startsWith('Script.')
+              ? await executionPromise : await abortable(executionPromise, signal);
+            signal.throwIfAborted();
+            if (capabilityResult?.ok === false) {
+              await this.repository.append(episode, 'capability_failed', { callId, capabilityId: invocation.id, ...execution, code: capabilityResult.code, result: capabilityResult });
+            } else {
+              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/script-executor.js

@@ -0,0 +1,88 @@
+import { Worker } from 'node:worker_threads';
+import { isDeepStrictEqual } from 'node:util';
+import { bytes, fail } from './contracts.js';
+
+const MAX_WORKERS = 4;
+let active = 0;
+
+/** JSON-only values, bounded before crossing the guest boundary. */
+export function scriptInput(value) {
+  let remaining = 8192;
+  const ancestors = new Set();
+  const spend = n => { remaining -= n; if (remaining < 0) fail('INVALID_REQUEST'); };
+  function visit(v, depth) {
+    if (depth > 32) fail('INVALID_REQUEST');
+    if (v === null || typeof v === 'string' || typeof v === 'boolean' || (typeof v === 'number' && Number.isFinite(v))) { spend(bytes(JSON.stringify(v))); return; }
+    if (!v || typeof v !== 'object' || ancestors.has(v) || (!Array.isArray(v) && Object.getPrototypeOf(v) !== Object.prototype && Object.getPrototypeOf(v) !== null)) fail('INVALID_REQUEST');
+    const array = Array.isArray(v), keys = Object.keys(v);
+    if (Reflect.ownKeys(v).length !== keys.length + (array ? 1 : 0) || (array && keys.length !== v.length)) fail('INVALID_REQUEST');
+    spend(2 + Math.max(0, keys.length - 1)); ancestors.add(v);
+    for (let i = 0; i < keys.length; i++) {
+      const key = keys[i], d = Object.getOwnPropertyDescriptor(v, key);
+      if (!Object.hasOwn(d, 'value') || (array && key !== String(i))) fail('INVALID_REQUEST');
+      if (!array) spend(bytes(JSON.stringify(key)) + 1);
+      visit(d.value, depth + 1);
+    }
+    ancestors.delete(v);
+  }
+  visit(value, 0);
+  return value;
+}
+
+/** Pure JSON -> JSON computation. No permissions can be requested by guest code.
+ * Worker is joined on success, failure and cancellation; no user script lives on.
+ * This does not claim arbitrary native-code isolation or semantic correctness. */
+export async function runPersonScript(code, input, { signal } = {}) {
+  signal?.throwIfAborted();
+  if (typeof code !== 'string' || !code.trim() || bytes(code) > 8192) fail('INVALID_REQUEST');
+  scriptInput(input);
+  if (active >= MAX_WORKERS) return { ok: false, code: 'SCRIPT_BUSY' };
+  active++;
+  let worker, timer, onAbort;
+  try {
+    return await new Promise((resolve, reject) => {
+      let finished = false;
+      const finish = async (result, cancelled = false) => {
+        if (finished) return;
+        finished = true;
+        clearTimeout(timer); signal?.removeEventListener('abort', onAbort);
+        await worker?.terminate().catch(() => {});
+        if (cancelled) reject(signal.reason); else resolve(result);
+      };
+      onAbort = () => finish(null, true);
+      try {
+        worker = new Worker(new URL('./script-worker.js', import.meta.url), {
+          workerData: { code, input }, resourceLimits: { maxOldGenerationSizeMb: 64, maxYoungGenerationSizeMb: 16, stackSizeMb: 2 },
+        });
+        worker.on('message', result => {
+          try {
+            if (result?.ok === true) scriptInput(result.output);
+            else if (result?.ok !== false) throw new Error('Invalid worker result');
+            void finish(result);
+          } catch { void finish({ ok: false, code: 'SCRIPT_OUTPUT' }); }
+        });
+        worker.on('error', () => { void finish({ ok: false, code: 'SCRIPT_EXECUTION' }); });
+        worker.on('exit', () => { void finish({ ok: false, code: 'SCRIPT_EXECUTION' }); });
+        timer = setTimeout(() => { void finish({ ok: false, code: 'SCRIPT_TIMEOUT' }); }, 3000);
+        signal?.addEventListener('abort', onAbort, { once: true });
+        if (signal?.aborted) onAbort();
+      } catch { void finish({ ok: false, code: 'SCRIPT_EXECUTION' }); }
+    });
+  } finally {
+    clearTimeout(timer); signal?.removeEventListener('abort', onAbort);
+    active--;
+  }
+}
+
+/** Every case gets a fresh VM; test output is evidence only for the supplied cases. */
+export async function testPersonScript(definition, { signal } = {}) {
+  let testsPassed = 0;
+  for (const [index, test] of definition.tests.entries()) {
+    const result = await runPersonScript(definition.code, test.input, { signal });
+    signal?.throwIfAborted();
+    if (!result.ok) return { ...result, testsPassed, failedTest: index };
+    if (!isDeepStrictEqual(result.output, test.expected)) return { ok: false, code: 'SCRIPT_TEST_FAILED', testsPassed, failedTest: index, actual: result.output };
+    testsPassed++;
+  }
+  return { ok: true, evidence: { engine: 'quickjs', testsPassed, testedAt: new Date().toISOString() } };
+}

package/yeaft/person/script-worker.js

@@ -0,0 +1,77 @@
+import { parentPort, workerData } from 'node:worker_threads';
+import { getQuickJS } from 'quickjs-emscripten';
+
+// Separate WASM interpreter, NOT node:vm. No host functions/modules are bound.
+// Parent termination bounds startup, computation, output extraction and cleanup.
+let runtime, context;
+try {
+  const engine = await getQuickJS();
+  runtime = engine.newRuntime();
+  runtime.setMemoryLimit(16 * 1024 * 1024);
+  runtime.setMaxStackSize(256 * 1024);
+  const deadline = Date.now() + 200;
+  runtime.setInterruptHandler(() => Date.now() > deadline);
+  context = runtime.newContext();
+  const { code, input } = workerData;
+  // Capture intrinsics before executing generated code; Function compiles ONLY a
+  // function body and has no access to this validation closure. Neither raw code
+  // interpolation nor mutable guest serializers can redefine the output boundary.
+  const source = `(() => {
+    'use strict';
+    const compile = Function, parse = JSON.parse, stringify = JSON.stringify;
+    const isArray = Array.isArray, finite = Number.isFinite;
+    const proto = Object.getPrototypeOf, objectProto = Object.prototype;
+    const descriptor = Object.getOwnPropertyDescriptor, keys = Reflect.ownKeys;
+    const create = Object.create, setProto = Object.setPrototypeOf, ErrorType = Error;
+    const input = parse(${JSON.stringify(JSON.stringify(input))});
+    const fn = compile('input', ${JSON.stringify(`'use strict';\n${code}`)});
+    const ancestors = create(null);
+    let nodes = 0;
+    function snapshot(v, depth) {
+      if (++nodes > 8192 || depth > 32) throw new ErrorType('JSON limit');
+      if (v === null || typeof v === 'string' || typeof v === 'boolean') return v;
+      if (typeof v === 'number' && finite(v)) return v;
+      if (typeof v !== 'object') throw new ErrorType('JSON only');
+      for (let i = 0; i < depth; i++) if (ancestors[i] === v) throw new ErrorType('JSON cycle');
+      const array = isArray(v), p = proto(v);
+      if (!array && p !== objectProto && p !== null) throw new ErrorType('JSON object only');
+      const names = keys(v);
+      const length = array ? descriptor(v, 'length').value : names.length;
+      if (length > 8192 || names.length !== length + (array ? 1 : 0)) throw new ErrorType('JSON keys');
+      const out = array ? setProto([], null) : create(null);
+      ancestors[depth] = v;
+      for (let i = 0; i < length; i++) {
+        const key = array ? '' + i : names[i];
+        if (typeof key !== 'string') throw new ErrorType('JSON key');
+        const d = descriptor(v, key);
+        if (!d || !d.enumerable || !descriptor(d, 'value')) throw new ErrorType('JSON data only');
+        out[key] = snapshot(d.value, depth + 1);
+      }
+      delete ancestors[depth];
+      return out;
+    }
+    const value = snapshot(fn(input), 0);
+    // Snapshot has null prototypes and data properties only: no guest getters or
+    // inherited toJSON are run during serialization, even after global mutation.
+    const json = stringify(value);
+    if (typeof json !== 'string' || json.length > 8192) throw new ErrorType('JSON output limit');
+    return json;
+  })()`;
+  const result = context.evalCode(source, 'created-capability.js');
+  if (result.error) {
+    result.error.dispose();
+    parentPort.postMessage({ ok: false, code: 'SCRIPT_EXECUTION' });
+  } else {
+    const json = context.getString(result.value);
+    result.value.dispose();
+    if (Buffer.byteLength(json, 'utf8') > 8192) parentPort.postMessage({ ok: false, code: 'SCRIPT_OUTPUT' });
+    else parentPort.postMessage({ ok: true, output: JSON.parse(json) });
+  }
+} catch {
+  // Guest error strings may contain arbitrary input; fixed codes only cross out.
+  parentPort.postMessage({ ok: false, code: 'SCRIPT_EXECUTION' });
+} finally {
+  context?.dispose();
+  runtime?.dispose();
+  parentPort.close();
+}

package/yeaft/person/sqlite-repository.js

@@ -1,6 +1,7 @@
 import { Worker } from 'node:worker_threads';
 import { join, resolve } from 'node:path';
 import { digest, fail, identifier, PersonError, text } from './contracts.js';
+import { validateCreatedCapability } from './created-capability-contract.js';
 
 const storageError = code => {
   const error = new PersonError(code);
@@ -91,6 +92,8 @@ 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]); }
+  async createdCapabilities(episode) { return this.request('createdCapabilities', [episode]); }
+  async saveCreatedCapability(episode, input) { return this.request('saveCreatedCapability', [episode, validateCreatedCapability(input)]); }
   async context(episode) { return this.request('context', [episode]); }
   async recall(ownerId, options) { return this.request('recall', [ownerId, options]); }
   async commit(episode, proposal, selection, callId, reportedSources = new Map()) { return this.request('commit', [episode, proposal, selection, callId, reportedSources]); }

package/yeaft/person/sqlite-schema.js

@@ -8,6 +8,8 @@ export const TABLES = Object.freeze({
   concept_revisions: { keys: ['id', 'revision'], columns: [] },
   state_commits: { keys: ['version'], columns: ['id'] },
   traces: { keys: ['id'], columns: ['seq'] },
+  created_capabilities: { keys: ['id'], columns: ['version'] },
+  created_capability_revisions: { keys: ['id', 'version'], columns: [] },
 });
 
 export const SCHEMA = `
@@ -66,6 +68,21 @@ CREATE TABLE IF NOT EXISTS traces (
   PRIMARY KEY(namespace, ownerId, personId, id), UNIQUE(namespace, ownerId, personId, seq),
   FOREIGN KEY(namespace, ownerId, personId) REFERENCES persons(namespace, ownerId, personId)
 ) STRICT;
+CREATE INDEX IF NOT EXISTS traces_call_output ON traces(namespace, ownerId, personId,
+  json_extract(record, '$.episodeId'), json_extract(record, '$.callId'))
+  WHERE json_extract(record, '$.kind') = 'call_output';
+CREATE TABLE IF NOT EXISTS created_capabilities (
+  namespace TEXT NOT NULL, ownerId TEXT NOT NULL, personId TEXT NOT NULL,
+  id TEXT NOT NULL, version INTEGER NOT NULL CHECK(version BETWEEN 1 AND 32),
+  record TEXT NOT NULL CHECK(json_valid(record)), PRIMARY KEY(namespace, ownerId, personId, id),
+  FOREIGN KEY(namespace, ownerId, personId) REFERENCES persons(namespace, ownerId, personId)
+) STRICT;
+CREATE TABLE IF NOT EXISTS created_capability_revisions (
+  namespace TEXT NOT NULL, ownerId TEXT NOT NULL, personId TEXT NOT NULL,
+  id TEXT NOT NULL, version INTEGER NOT NULL CHECK(version BETWEEN 1 AND 32),
+  record TEXT NOT NULL CHECK(json_valid(record)), PRIMARY KEY(namespace, ownerId, personId, id, version),
+  FOREIGN KEY(namespace, ownerId, personId) REFERENCES persons(namespace, ownerId, personId)
+) STRICT;
 -- This journal is authority data, not a disposable search index. A committed seq is
 -- never reused, including after reopening; gaps between owners are intentional.
 CREATE TABLE IF NOT EXISTS memory_changes (

package/yeaft/person/sqlite-store.js

@@ -4,14 +4,28 @@ import { dirname } from 'node:path';
 import { randomUUID } from 'node:crypto';
 import { isMainThread } from 'node:worker_threads';
 import { bytes, digest, fail, 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';
+import { capabilityExperienceView, recordCapabilityExperience } from './capability-experience.js';
 
 const SCOPE = 'namespace = ? AND ownerId = ? AND personId = ?';
 const scopeValues = s => [s.namespace, s.ownerId, s.personId];
 // Query-only projections; record retains the original public Unicode text.
 const SEARCH_COLUMNS = Object.freeze({ messages: 'text', concepts: 'statement' });
-const dates = new Set(['createdAt', 'updatedAt', 'endedAt', 'leaseUntil', 'callFinalizeUntil']);
-const decode = row => row ? JSON.parse(row.record, (key, value) => dates.has(key) && typeof value === 'string' ? new Date(value) : value) : null;
+const metadataDates = Object.freeze({
+  persons: ['createdAt', 'leaseUntil'], episodes: ['createdAt', 'endedAt', 'callFinalizeUntil'],
+  messages: ['createdAt'], states: ['updatedAt'], concepts: ['updatedAt'], concept_revisions: ['updatedAt'],
+  state_commits: ['createdAt'], traces: ['createdAt'],
+});
+const decode = (row, table) => {
+  if (!row) return null;
+  const record = JSON.parse(row.record);
+  // Only known storage metadata is a Date. Trace payloads and created-definition
+  // JSON may use these names at any depth without changing their string values.
+  for (const key of metadataDates[table] ?? []) if (typeof record[key] === 'string') record[key] = new Date(record[key]);
+  if (table === 'state_commits' && typeof record.state?.updatedAt === 'string') record.state.updatedAt = new Date(record.state.updatedAt);
+  return record;
+};
 const publicDoc = doc => {
   if (!doc) return null;
   const { _id, ownerId, namespace, personId, ...rest } = doc;
@@ -31,8 +45,8 @@ const publicOutput = (output, failed) => {
   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 READS = new Set(['getPerson', 'context', 'recall', 'list', 'searchChanges', 'resolveMemories']);
-const WRITES = new Set(['open', 'recover', 'admit', 'heartbeat', 'append', 'startCall', 'finalizeCall', 'commit', 'finish', 'cancel', 'settings', 'snapshot']);
+const READS = new Set(['getPerson', 'context', 'recall', 'list', 'searchChanges', 'resolveMemories', 'createdCapabilities']);
+const WRITES = new Set(['open', 'recover', 'admit', 'heartbeat', 'append', 'startCall', 'finalizeCall', 'commit', 'finish', 'cancel', 'settings', 'snapshot', 'saveCreatedCapability']);
 const memoryKind = kind => { if (!['messages', 'concepts'].includes(kind)) fail('INVALID_REQUEST'); return kind; };
 const boundedLimit = (limit, max = 100) => { if (!Number.isSafeInteger(limit) || limit < 1 || limit > max) fail('INVALID_REQUEST'); return limit; };
 const sequence = value => {
@@ -100,7 +114,8 @@ export class SqlitePersonStore {
   // All clauses at call sites below are fixed application strings; values are bound.
   rows(table, scope, clause = '', params = []) {
     this.table(table);
-    return this.sql(`SELECT record FROM ${table} WHERE ${SCOPE}${clause}`).all(...scopeValues(scope), ...params).map(decode);
+    return this.sql(`SELECT record FROM ${table} WHERE ${SCOPE}${clause}`).all(...scopeValues(scope), ...params)
+      .map(row => decode(row, table));
   }
   one(table, scope, clause = '', params = []) { return this.rows(table, scope, `${clause} LIMIT 1`, params)[0] ?? null; }
   put(table, record, insert = false) {
@@ -219,7 +234,14 @@ 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);
+    // Call proof/publication events are emitted only by their transactional methods.
+    if (['call_started', 'call_output', 'call_failed', 'capability_created'].includes(kind)) fail('INVALID_REQUEST');
+    const p = this.own(episode);
+    const record = this.one('episodes', this.episodeScope(episode), ' AND id = ?', [episode.id]);
+    if (!record || record.status !== 'running') fail('STALE');
+    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) {
@@ -249,6 +271,28 @@ export class SqlitePersonStore {
     });
     return live;
   }
+  createdCapabilities(episode) {
+    this.own(episode);
+    return this.rows('created_capabilities', this.episodeScope(episode), ' ORDER BY id ASC LIMIT 32').map(publicDoc);
+  }
+  saveCreatedCapability(episode, input) {
+    const { definition, evidence, callId } = validateCreatedCapability(input);
+    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 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 &&
+        this.sql(`SELECT count(*) AS n FROM created_capabilities WHERE ${SCOPE}`).get(...scopeValues(scope)).n >= CREATED_CAPABILITY_LIMITS.ids)) fail('CONTEXT_LIMIT');
+    const record = this.doc(scope, createdCapabilityRecord(definition, evidence, { episode, callId, now: this.now }));
+    this.put('created_capability_revisions', record, true);
+    this.put('created_capabilities', record);
+    this.trace(episode.ownerId, episode.id, 'capability_created', { callId, capabilityId: record.id,
+      capabilityManifest: { id: record.id, version: record.version, revision: record.revision }, evidence: record.evidence });
+    return publicDoc(record);
+  }
   focused(scope, ids) {
     return ids.map(id => this.one('concepts', scope, ' AND id = ?', [id])).filter(Boolean);
   }
@@ -256,7 +300,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()) {
@@ -359,7 +404,7 @@ export class SqlitePersonStore {
     this.getPerson(ownerId); after = sequence(after); boundedLimit(limit, 1000);
     const rows = this.sql(`SELECT seq, kind, id, revision, record FROM memory_changes WHERE ${SCOPE} AND seq > ? ORDER BY seq ASC LIMIT ?`)
       .all(...scopeValues(this.scope(ownerId)), after, limit + 1);
-    const items = rows.slice(0, limit).map(row => ({ ...row, record: decode(row) }));
+    const items = rows.slice(0, limit).map(row => ({ ...row, record: decode(row, row.kind) }));
     return { items, lastSeq: items.at(-1)?.seq ?? after, hasMore: rows.length > limit };
   }
   resolveMemories(ownerId, kind, refs) {