@yeaft/webchat-agent 1.0.589 → 1.0.590

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,6 +4,7 @@ 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';
 
@@ -11,8 +12,20 @@ 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;
@@ -32,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 => {
@@ -101,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) {
@@ -220,6 +234,8 @@ 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) {
+    // 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');
@@ -255,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);
   }
@@ -366,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) {