@yeaft/webchat-agent 1.0.587 → 1.0.589

package/yeaft/person/runtime.js

@@ -1,13 +1,13 @@
 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';
 
 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 MongoDB original. */
-export function assembleContext({ snapshot, episode, provider, selection, previous, capabilityResult, remainingCalls, dependencyRefs = [] }) {
+/** 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 = [], 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,11 +17,11 @@ 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,
-    contextNotice: 'This is bounded short-term context, not all memory. Omitted records remain in MongoDB. Recall pages are scoped to this Person. A previous proposal is not committed state. Inherited source refs were read by an earlier call of this episode, not necessarily rendered here; recall again to check their content.',
+    contextNotice: 'This is bounded short-term context, not all memory. Omitted records remain in long-term storage. Recall pages are scoped to this Person. A previous proposal is not committed state. Inherited source refs were read by an earlier call of this episode, not necessarily rendered here; recall again to check their content.',
   };
   const sourceRefs = new Set([triggerRef, ...dependencyRefs]);
   const renderedRefs = new Set([triggerRef]);
@@ -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);
-            await this.repository.append(episode, 'capability_result', { callId, capability: invocation, result: capabilityResult });
+            capabilityResult = await abortable(capabilities.execute(invocation, { signal }), signal);
+            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;
           }
         }
@@ -170,7 +183,7 @@ export class PersonRuntime {
     } catch (error) {
       const safe = safeError(signal.aborted ? signal.reason : error, 'PROVIDER_FAILED');
       const status = safe.code === 'CANCELLED' ? 'cancelled' : safe.code === 'INTERRUPTED' || safe.code === 'STALE' ? 'interrupted' : 'failed';
-      // On database outage no local fallback is possible. Expired leases become durable interrupted records on next access.
+      // On authority failure no alternate memory store is used. Expired leases become durable interrupted records on next access.
       await this.repository.finish(episode, status, safe.code).catch(() => {});
     } finally {
       clearTimeout(timeout); clearInterval(heartbeat);

package/yeaft/person/service.js

@@ -1,28 +1,46 @@
 import { MongoPersonRepository } from './repository.js';
+import { SqlitePersonRepository } from './sqlite-repository.js';
+import { LocalPersonMemory } from './local-memory.js';
+import { selectPersonStorage, bindPersonStorage } from './storage.js';
 import { PersonRuntime } from './runtime.js';
 import { createPersonProvider } from './provider.js';
 import { fail, identifier, LIMITS, object, page, safeError, text } from './contracts.js';
 
 /**
- * One Mongo-backed Person per (namespace, authenticated ownerId). The transport MUST
+ * One durable Person per (namespace, authenticated ownerId). The transport MUST
  * supply authenticated ownerId, never accept it from a browser payload. URI/provider
  * secrets stay inside this Agent. Constructor and status never initiate model calls.
  * Native provider configuration is read from yeaftDir only (no Session initialization).
- * Inject MongoClient/config/adapter for isolated integration tests; no persistence fallback.
+ * SQLite is the local default; an existing Mongo URI retains Mongo. No authority fallback.
  */
 export function createPersonService(options = {}) {
   const { uri, dbName = 'yeaft_person', namespace = 'default', yeaftDir, MongoClient, config, adapter, allowedModels } = options;
   identifier(namespace);
   if (typeof dbName !== 'string' || !/^[a-zA-Z0-9_-]{1,63}$/.test(dbName)) fail('INVALID_REQUEST');
   if (uri != null && typeof uri !== 'string') fail('INVALID_REQUEST');
-  const configured = Boolean(uri?.trim());
+  const { storage, configured } = selectPersonStorage({ ...options, yeaftDir });
   const calls = options.maxCalls ?? LIMITS.calls;
   const timeoutMs = options.timeoutMs ?? LIMITS.timeoutMs;
   const leaseMs = options.leaseMs ?? LIMITS.leaseMs;
   if (!Number.isInteger(calls) || calls < 1 || calls > 8 || !Number.isInteger(timeoutMs) || timeoutMs < 100 || timeoutMs > 300000 ||
       !Number.isInteger(leaseMs) || leaseMs < 300 || leaseMs > 60000) fail('INVALID_REQUEST');
   if (allowedModels != null && (!Array.isArray(allowedModels) || !allowedModels.length || allowedModels.length > 8 || allowedModels.some(m => typeof m !== 'string'))) fail('INVALID_REQUEST');
-  const repository = new MongoPersonRepository({ uri, dbName, namespace, MongoClient, leaseMs });
+  const repository = !configured ? null : storage === 'mongodb'
+    ? new MongoPersonRepository({ uri, dbName, namespace, MongoClient, leaseMs })
+    : new SqlitePersonRepository({ yeaftDir, namespace, leaseMs });
+  const initialize = repository?.init.bind(repository);
+  let binding;
+  if (repository) repository.init = async () => {
+    if (!binding) binding = bindPersonStorage(yeaftDir, namespace, storage).catch(error => { binding = null; throw error; });
+    await binding;
+    return initialize();
+  };
+  const literalRecall = repository?.recall.bind(repository);
+  const memory = repository && storage === 'sqlite' ? new LocalPersonMemory({
+    repository, literalRecall, yeaftDir, namespace, embedding: options.embedding,
+  }) : null;
+  if (memory) repository.recall = (ownerId, args = {}, { signal } = {}) => args.query?.trim()
+    ? memory.recall(ownerId, args, { signal }) : literalRecall(ownerId, args);
   // Config/adapter are loaded per explicit episode, not a permanent stale cache.
   const getProvider = () => createPersonProvider({ yeaftDir, config, adapter, allowedModels, effortEnabled: options.effortEnabled });
   const runtime = new PersonRuntime({ repository, getProvider, budget: { calls, timeoutMs } });
@@ -34,13 +52,13 @@ export function createPersonService(options = {}) {
     if (typeof op !== 'string') fail('INVALID_REQUEST');
     if (op === 'status') {
       object(payload, []);
-      if (!configured) return { configured: false, reason: 'MongoDB is not configured for digital person.', storageReady: false, modelReady: false };
+      if (!configured) return { configured: false, storage, reason: 'Digital person storage configuration is missing.', storageReady: false, modelReady: false };
       try { await repository.init(); }
-      catch { return { configured: true, reason: 'Digital person storage is unavailable; a transaction-capable MongoDB replica set is required.', storageReady: false, modelReady: false }; }
+      catch (error) { return { configured: true, storage, reason: safeError(error).message, storageReady: false, modelReady: false }; }
       try {
         const provider = await getProvider();
-        return { configured: true, reason: null, storageReady: true, modelReady: true, models: provider.catalog, autonomySupported: false };
-      } catch { return { configured: true, reason: 'No permitted native model is configured for digital person.', storageReady: true, modelReady: false }; }
+        return { configured: true, storage, reason: null, storageReady: true, modelReady: true, models: provider.catalog, autonomySupported: false };
+      } catch { return { configured: true, storage, reason: 'No permitted native model is configured for digital person.', storageReady: true, modelReady: false }; }
     }
     if (!configured) fail('NOT_CONFIGURED');
     switch (op) {
@@ -93,7 +111,8 @@ export function createPersonService(options = {}) {
       closed = true;
       await Promise.allSettled([...requests]);
       await runtime.close();
-      await repository.close().catch(() => {});
+      await memory?.close();
+      await repository?.close().catch(() => {});
     },
   };
 }

package/yeaft/person/sqlite-repository.js

@@ -0,0 +1,123 @@
+import { Worker } from 'node:worker_threads';
+import { join, resolve } from 'node:path';
+import { digest, fail, identifier, PersonError, text } from './contracts.js';
+
+const storageError = code => {
+  const error = new PersonError(code);
+  // Keep transport errors independent of backend topology, SQL and local paths.
+  if (error.code === 'STORAGE_UNAVAILABLE') error.message = 'Digital person storage is unavailable.';
+  return error;
+};
+
+/** One worker/connection per repository, shared WAL authority across processes.
+ * ownerId must come from the authenticated transport, never a request payload.
+ * A worker crash/timeout fails this instance closed: pending outcomes may have
+ * committed, so callers reconcile with a NEW instance and the same idempotency key.
+ * No automatic retry, takeover, model dispatch or local-memory fallback occurs.
+ */
+export class SqlitePersonRepository {
+  constructor({ yeaftDir, namespace = 'default', leaseMs = 15000, busyTimeoutMs = 1000, requestTimeoutMs = 30000, maxPending = 256 } = {}) {
+    text(yeaftDir, 4096); identifier(namespace);
+    if (!Number.isInteger(leaseMs) || leaseMs < 1 || leaseMs > 60000 || !Number.isInteger(busyTimeoutMs) || busyTimeoutMs < 0 || busyTimeoutMs > 5000 ||
+        !Number.isInteger(requestTimeoutMs) || requestTimeoutMs < busyTimeoutMs + 100 || requestTimeoutMs > 120000 ||
+        !Number.isInteger(maxPending) || maxPending < 1 || maxPending > 4096) fail('INVALID_REQUEST');
+    this.namespace = namespace; this.leaseMs = leaseMs;
+    this.dbPath = join(resolve(yeaftDir), 'person', 'person.db');
+    this.options = { dbPath: this.dbPath, namespace, leaseMs, busyTimeoutMs };
+    this.requestTimeoutMs = requestTimeoutMs; this.maxPending = maxPending;
+    this.pending = new Map(); this.requests = new Set(); this.nextId = 0; this.closed = false; this.failed = false;
+  }
+  scope(ownerId) {
+    text(ownerId, 256);
+    return { ownerId, namespace: this.namespace, personId: `person-${digest([this.namespace, ownerId]).slice(0, 32)}` };
+  }
+  async init() {
+    if (this.closed) fail('CLOSED');
+    if (this.failed) throw storageError('STORAGE_UNAVAILABLE');
+    if (!this.initializing) this.initializing = new Promise((resolveReady, rejectReady) => {
+      const timer = setTimeout(() => this.breakWorker(), this.requestTimeoutMs); timer.unref();
+      this.rejectReady = error => { clearTimeout(timer); rejectReady(error); };
+      try {
+        this.worker = new Worker(new URL('./sqlite-worker.js', import.meta.url), { workerData: this.options });
+        this.worker.on('message', message => {
+          if (message.ready) { clearTimeout(timer); this.rejectReady = null; this.worker.unref(); resolveReady(); return; }
+          if (message.startupError) { this.breakWorker(); return; }
+          const pending = this.pending.get(message.id);
+          if (!pending) return;
+          this.pending.delete(message.id); clearTimeout(pending.timer);
+          if (!this.pending.size) this.worker.unref();
+          if (message.error) pending.reject(storageError(message.error)); else pending.resolve(message.result);
+        });
+        this.worker.on('error', () => this.breakWorker());
+        this.worker.on('exit', () => {
+          if (!this.closingWorker || this.pending.size) this.breakWorker();
+        });
+      } catch { this.breakWorker(); }
+    });
+    return this.initializing;
+  }
+  breakWorker() {
+    if (this.failed) return;
+    this.failed = true;
+    const error = storageError('STORAGE_UNAVAILABLE');
+    this.rejectReady?.(error); this.rejectReady = null;
+    for (const pending of this.pending.values()) { clearTimeout(pending.timer); pending.reject(error); }
+    this.pending.clear();
+    this.terminating = this.worker?.terminate().catch(() => {});
+  }
+  send(method, args) {
+    if (this.failed) return Promise.reject(storageError('STORAGE_UNAVAILABLE'));
+    return new Promise((resolveResult, reject) => {
+      const id = ++this.nextId;
+      const timer = setTimeout(() => this.breakWorker(), this.requestTimeoutMs); timer.unref();
+      this.pending.set(id, { resolve: resolveResult, reject, timer });
+      this.worker.ref();
+      try { this.worker.postMessage({ id, method, args }); }
+      catch { this.breakWorker(); }
+    });
+  }
+  async request(method, args) {
+    if (this.closed) fail('CLOSED');
+    if (this.requests.size >= this.maxPending) fail('BUSY');
+    const promise = (async () => { await this.init(); return this.send(method, args); })();
+    this.requests.add(promise);
+    try { return await promise; } finally { this.requests.delete(promise); }
+  }
+  async open(ownerId, name) { return this.request('open', [ownerId, name]); }
+  async getPerson(ownerId) { return this.request('getPerson', [ownerId]); }
+  async recover(ownerId) { return this.request('recover', [ownerId]); }
+  async admit(ownerId, input) { return this.request('admit', [ownerId, input]); }
+  async heartbeat(episode) { return this.request('heartbeat', [episode]); }
+  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 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]); }
+  async finish(episode, status, code) { return this.request('finish', [episode, status, code]); }
+  async cancel(ownerId, episodeId) { return this.request('cancel', [ownerId, episodeId]); }
+  async settings(ownerId, settings) { return this.request('settings', [ownerId, settings]); }
+  async list(ownerId, collection, options, filter) { return this.request('list', [ownerId, collection, options, filter]); }
+  async snapshot(ownerId) { return this.request('snapshot', [ownerId]); }
+  /** Ascending durable journal, scoped before paging. Empty pages retain after. */
+  async searchChanges(ownerId, options) { return this.request('searchChanges', [ownerId, options]); }
+  /** kind is 'messages'|'concepts'; returns a deduplicated array of current public records. */
+  async resolveMemories(ownerId, kind, refs) { return this.request('resolveMemories', [ownerId, kind, refs]); }
+  async close() {
+    if (!this.closing) {
+      this.closed = true;
+      this.closing = (async () => {
+        await Promise.allSettled([...this.requests]);
+        await this.initializing?.catch(() => {});
+        if (this.worker && !this.failed) {
+          this.closingWorker = true;
+          await this.send('close', []).catch(() => {});
+          // terminate also joins the worker if it already completed its normal exit.
+          await this.worker.terminate().catch(() => {});
+        }
+        await this.terminating;
+      })();
+    }
+    return this.closing;
+  }
+}

package/yeaft/person/sqlite-schema.js

@@ -0,0 +1,80 @@
+// Identifiers below are static application schema, never request-controlled SQL.
+export const TABLES = Object.freeze({
+  persons: { keys: [], columns: [] },
+  states: { keys: [], columns: ['version'] },
+  episodes: { keys: ['id'], columns: ['clientMessageId', 'inputWatermark', 'status', 'callFinalizeUntil'] },
+  messages: { keys: ['id'], columns: ['seq', 'revision', 'text'] },
+  concepts: { keys: ['id'], columns: ['revision', 'updatedAt', 'statement'] },
+  concept_revisions: { keys: ['id', 'revision'], columns: [] },
+  state_commits: { keys: ['version'], columns: ['id'] },
+  traces: { keys: ['id'], columns: ['seq'] },
+});
+
+export const SCHEMA = `
+CREATE TABLE IF NOT EXISTS persons (
+  namespace TEXT NOT NULL, ownerId TEXT NOT NULL, personId TEXT NOT NULL,
+  record TEXT NOT NULL CHECK(json_valid(record)), PRIMARY KEY(namespace, ownerId, personId)
+) STRICT;
+CREATE TABLE IF NOT EXISTS states (
+  namespace TEXT NOT NULL, ownerId TEXT NOT NULL, personId TEXT NOT NULL,
+  version INTEGER NOT NULL, record TEXT NOT NULL CHECK(json_valid(record)),
+  PRIMARY KEY(namespace, ownerId, personId),
+  FOREIGN KEY(namespace, ownerId, personId) REFERENCES persons(namespace, ownerId, personId)
+) STRICT;
+CREATE TABLE IF NOT EXISTS episodes (
+  namespace TEXT NOT NULL, ownerId TEXT NOT NULL, personId TEXT NOT NULL,
+  id TEXT NOT NULL, clientMessageId TEXT NOT NULL, inputWatermark INTEGER NOT NULL,
+  status TEXT NOT NULL, callFinalizeUntil INTEGER,
+  record TEXT NOT NULL CHECK(json_valid(record)), PRIMARY KEY(namespace, ownerId, personId, id),
+  UNIQUE(namespace, ownerId, personId, clientMessageId),
+  FOREIGN KEY(namespace, ownerId, personId) REFERENCES persons(namespace, ownerId, personId)
+) STRICT;
+CREATE INDEX IF NOT EXISTS episodes_watermark ON episodes(namespace, ownerId, personId, inputWatermark DESC);
+CREATE INDEX IF NOT EXISTS episodes_drain ON episodes(namespace, ownerId, personId, status, callFinalizeUntil)
+  WHERE json_type(record, '$.openCall') IS NOT NULL;
+CREATE TABLE IF NOT EXISTS messages (
+  namespace TEXT NOT NULL, ownerId TEXT NOT NULL, personId TEXT NOT NULL,
+  id TEXT NOT NULL, seq INTEGER NOT NULL, revision INTEGER NOT NULL, text TEXT NOT NULL,
+  record TEXT NOT NULL CHECK(json_valid(record)), PRIMARY KEY(namespace, ownerId, personId, id),
+  UNIQUE(namespace, ownerId, personId, seq),
+  FOREIGN KEY(namespace, ownerId, personId) REFERENCES persons(namespace, ownerId, personId)
+) STRICT;
+CREATE UNIQUE INDEX IF NOT EXISTS messages_revision ON messages(namespace, ownerId, personId, id, revision);
+CREATE TABLE IF NOT EXISTS concepts (
+  namespace TEXT NOT NULL, ownerId TEXT NOT NULL, personId TEXT NOT NULL,
+  id TEXT NOT NULL, revision INTEGER NOT NULL, updatedAt INTEGER NOT NULL, statement TEXT NOT NULL,
+  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 UNIQUE INDEX IF NOT EXISTS concepts_revision ON concepts(namespace, ownerId, personId, id, revision);
+CREATE INDEX IF NOT EXISTS concepts_recent ON concepts(namespace, ownerId, personId, updatedAt DESC, id);
+CREATE TABLE IF NOT EXISTS concept_revisions (
+  namespace TEXT NOT NULL, ownerId TEXT NOT NULL, personId TEXT NOT NULL,
+  id TEXT NOT NULL, revision INTEGER NOT NULL, record TEXT NOT NULL CHECK(json_valid(record)),
+  PRIMARY KEY(namespace, ownerId, personId, id, revision),
+  FOREIGN KEY(namespace, ownerId, personId) REFERENCES persons(namespace, ownerId, personId)
+) STRICT;
+CREATE TABLE IF NOT EXISTS state_commits (
+  namespace TEXT NOT NULL, ownerId TEXT NOT NULL, personId TEXT NOT NULL,
+  version INTEGER NOT NULL, id TEXT NOT NULL, record TEXT NOT NULL CHECK(json_valid(record)),
+  PRIMARY KEY(namespace, ownerId, personId, version),
+  FOREIGN KEY(namespace, ownerId, personId) REFERENCES persons(namespace, ownerId, personId)
+) STRICT;
+CREATE TABLE IF NOT EXISTS traces (
+  namespace TEXT NOT NULL, ownerId TEXT NOT NULL, personId TEXT NOT NULL,
+  id TEXT NOT NULL, seq INTEGER NOT NULL, record TEXT NOT NULL CHECK(json_valid(record)),
+  PRIMARY KEY(namespace, ownerId, personId, id), UNIQUE(namespace, ownerId, personId, seq),
+  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 (
+  seq INTEGER PRIMARY KEY AUTOINCREMENT,
+  namespace TEXT NOT NULL, ownerId TEXT NOT NULL, personId TEXT NOT NULL,
+  kind TEXT NOT NULL CHECK(kind IN ('messages', 'concepts')), id TEXT NOT NULL,
+  revision INTEGER NOT NULL, record TEXT NOT NULL CHECK(json_valid(record)),
+  UNIQUE(namespace, ownerId, personId, kind, id, revision),
+  FOREIGN KEY(namespace, ownerId, personId) REFERENCES persons(namespace, ownerId, personId)
+) STRICT;
+CREATE INDEX IF NOT EXISTS memory_changes_scope ON memory_changes(namespace, ownerId, personId, seq);
+`;