@yeaft/webchat-agent 1.0.595 → 1.0.597

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "1.0.595",
+  "version": "1.0.597",
   "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,6 +1,7 @@
 import { bytes, digest, fail, identifier, object, page, text } from './contracts.js';
 import { createdCapabilityRecord, validateCreatedDefinition } from './created-capability-contract.js';
 import { runPersonScript, scriptInput, testPersonScript } from './script-executor.js';
+import { createdSkillView, inspectionPage } from './inspection.js';
 
 // Built-in cognition plus bounded pure-script creation, not the Agent's full registry.
 // No shell/filesystem/network/VP authority is exposed to generated code.
@@ -65,6 +66,24 @@ function scriptManifest(record) {
     origin: 'person-created', evidence: record.evidence };
 }
 
+/** Read the real catalog without preparing or executing any capability. No host
+ * registry, file lookup, model configuration or script VM participates. */
+export function inspectCapabilities(created, { cursor, limit }) {
+  const entries = manifests.map(contract => ({ id: contract.id, domain: contract.domain, description: contract.description,
+    version: contract.version, revision: contract.revision, contract: copy(contract), source: { kind: 'builtin' } }));
+  for (const record of created) {
+    const contract = scriptManifest(record);
+    // Evidence is a fixed public shape even when reading older raw records.
+    const item = createdSkillView(record, contract);
+    contract.evidence = item.evidence;
+    entries.push(item);
+  }
+  // IDs are ASCII identifiers. Binary ordering matches SQLite and Mongo simple collation.
+  const matches = entries.filter(entry => cursor === null || entry.id > cursor)
+    .sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
+  return inspectionPage(matches, limit, 'id');
+}
+
 export class PersonCapabilities {
   constructor(repository, ownerId, { experience = [], triggerKind = 'think', now = Date.now(), created = [], episode } = {}) {
     this.repository = repository; this.ownerId = ownerId; this.episode = episode;

package/yeaft/person/inspection.js

@@ -0,0 +1,60 @@
+import { bytes, fail, identifier, object, page, text } from './contracts.js';
+
+/** Public read APIs use keyset cursors, never offsets or model-ranked recall. */
+export function inspectRequest(payload = {}) {
+  object(payload, ['section', 'cursor', 'limit'], ['section']);
+  if (!['memory', 'skills'].includes(payload.section)) fail('INVALID_REQUEST');
+  const { limit } = page({ limit: payload.limit });
+  const cursor = payload.cursor ?? null;
+  if (cursor !== null) identifier(cursor);
+  return { section: payload.section, cursor, limit };
+}
+export function searchRequest(payload = {}) {
+  object(payload, ['query', 'cursor', 'limit'], ['query']);
+  return { query: text(payload.query, 512), ...page({ cursor: payload.cursor, limit: payload.limit }) };
+}
+export function personName(value) {
+  if (typeof value !== 'string') fail('INVALID_REQUEST');
+  return text(value.trim(), 160);
+}
+const pick = (value, keys) => value == null ? null : Object.fromEntries(keys.filter(key => Object.hasOwn(value, key)).map(key => [key, value[key]]));
+export const settingsView = value => pick(value, ['autonomyEnabled', 'modelCandidates']);
+export function messageView(value) {
+  const result = pick(value, ['id', 'schemaVersion', 'revision', 'seq', 'episodeId', 'clientMessageId', 'role', 'text', 'createdAt']);
+  if (result && Array.isArray(value.attachments)) result.attachments = value.attachments.slice(0, 4)
+    .map(file => pick(file, ['id', 'name', 'mimeType', 'size', 'sha256', 'kind']));
+  return result;
+}
+export function conceptView(value) {
+  const result = pick(value, ['id', 'schemaVersion', 'kind', 'statement', 'epistemicState', 'sourceRefs', 'reportedSourceRefs', 'revision', 'episodeId', 'callId', 'stateVersion', 'updatedAt']);
+  if (result && Array.isArray(value.associations)) result.associations = value.associations.map(a => pick(a, ['targetId', 'relation']));
+  return result;
+}
+export function stateView(value) {
+  const result = pick(value, ['schemaVersion', 'version', 'summary', 'appraisal', 'focusConceptIds', 'updatedAt', 'episodeId']);
+  if (!result) return null;
+  if (Array.isArray(value.conceptRefs)) result.conceptRefs = value.conceptRefs.map(ref => pick(ref, ['id', 'revision']));
+  if (Object.hasOwn(value, 'decision')) result.decision = pick(value.decision, ['summary', 'uncertainties', 'selfCheck']);
+  if (Object.hasOwn(value, 'lastSelection')) result.lastSelection = pick(value.lastSelection, ['model', 'effort']);
+  return result;
+}
+export function createdSkillView(record, contract) {
+  return { ...pick(record, ['id', 'description', 'version', 'revision', 'code', 'inputDescription', 'outputDescription', 'createdAt', 'updatedAt']),
+    tests: Array.isArray(record.tests) ? record.tests.map(test => pick(test, ['input', 'expected'])) : [],
+    domain: 'script', contract,
+    evidence: pick(record.evidence, ['engine', 'testsPassed', 'testedAt']),
+    source: { kind: 'person-created', episodeId: record.createdEpisodeId, callId: record.createdCallId } };
+}
+/** Complete records only. Continuation follows the last returned key even when the
+ * byte budget, rather than the requested count, ends a page. No attachment bytes. */
+export function inspectionPage(records, limit, key, view = value => value) {
+  const items = []; let size = 0;
+  for (const record of records) {
+    if (items.length === limit) break;
+    const item = view(record), cost = bytes(item);
+    if (cost > 256 * 1024) fail('OUTPUT_LIMIT');
+    if (items.length && size + cost > 256 * 1024) break;
+    items.push(item); size += cost;
+  }
+  return { items, nextCursor: records.length > items.length ? String(items.at(-1)[key]) : null };
+}

package/yeaft/person/repository.js

@@ -3,6 +3,8 @@ import { admissionReceipt, bytes, digest, fail, identifier, LIMITS, PersonError,
 import { CREATED_CAPABILITY_LIMITS, createdCapabilityRecord, validateCreatedCapability } from './created-capability-contract.js';
 import { attachmentMetadata, attachmentRequestHash, validateFiles } from './attachments.js';
 import { capabilityExperienceView, recordCapabilityExperience } from './capability-experience.js';
+import { conceptView, inspectionPage, inspectRequest, messageView, personName, searchRequest, settingsView, stateView } from './inspection.js';
+import { inspectCapabilities } from './capabilities.js';
 
 const COLLECTIONS = ['persons', 'attachments', 'messages', 'episodes', 'states', 'concepts', 'concept_revisions', 'state_commits', 'traces', 'created_capabilities', 'created_capability_revisions'];
 const txOptions = { readConcern: { level: 'snapshot' }, writeConcern: { w: 'majority' }, readPreference: 'primary', maxCommitTimeMS: 5000, timeoutMS: 10000 };
@@ -97,7 +99,7 @@ export class MongoPersonRepository {
     finally { await session.endSession(); }
   }
   personView(p) {
-    return { id: p.personId, name: p.name, soul: p.soul, soulRevision: p.soulRevision, createdAt: iso(p.createdAt), settings: p.settings };
+    return { id: p.personId, name: p.name, soul: p.soul, soulRevision: p.soulRevision, createdAt: iso(p.createdAt), settings: settingsView(p.settings) };
   }
   async open(ownerId, name = 'Digital Person') {
     const scope = this.scope(ownerId);
@@ -334,9 +336,9 @@ export class MongoPersonRepository {
       this.collections.states.findOne(scope).then(s => this.collections.concepts.find({ ...scope, id: { $in: s.focusConceptIds } }).limit(12).toArray()),
       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()];
+    const concepts = [...new Map([...focused, ...recent].map(c => [c.id, conceptView(c)])).values()];
     return { person: this.personView(p), capabilityExperience: capabilityExperienceView(p.capabilityExperience),
-      state: publicDoc(state), messages: messages.reverse().map(publicDoc), concepts };
+      state: stateView(state), messages: messages.reverse().map(messageView), concepts };
   }
   async recall(ownerId, { kind = 'messages', query = '', cursor = null, limit = 5 }) {
     const scope = this.scope(ownerId);
@@ -345,7 +347,7 @@ export class MongoPersonRepository {
     await this.init();
     const filter = { ...scope, ...(query ? { statement: { $regex: escaped, $options: 'i' } } : {}), ...(cursor ? { id: { $gt: cursor } } : {}) };
     const docs = await this.collections.concepts.find(filter).sort({ id: 1 }).limit(limit + 1).maxTimeMS(2000).toArray();
-    return { items: docs.slice(0, limit).map(publicDoc), nextCursor: docs.length > limit ? docs[limit - 1].id : null };
+    return { items: docs.slice(0, limit).map(conceptView), nextCursor: docs.length > limit ? docs[limit - 1].id : null };
   }
   async commit(episode, proposal, selection, callId, reportedSources = new Map()) {
     return this.transaction(async session => {
@@ -376,12 +378,12 @@ export class MongoPersonRepository {
       const updated = await this.collections.states.replaceOne({ ...scope, version: episode.baseStateVersion }, state, { session });
       if (updated.matchedCount !== 1) fail('STALE');
       await this.collections.state_commits.insertOne(this.doc(scope, { id: randomUUID(), version: p.stateVersion, parentVersion: episode.baseStateVersion,
-        episodeId: episode.id, callId, conceptRevisions: revisions, state: publicDoc(state), createdAt: new Date() }), { session });
+        episodeId: episode.id, callId, conceptRevisions: revisions, state: stateView(state), createdAt: new Date() }), { session });
       if (proposal.reply) await this.collections.messages.insertOne(this.doc(scope, { id: randomUUID(), revision: 1, seq: p.messageSeq, episodeId: episode.id,
         role: 'assistant', text: proposal.reply, createdAt: new Date() }), { session });
       await this.collections.episodes.updateOne({ ...scope, id: episode.id, status: 'running' }, { $set: { status: 'completed', endedAt: new Date(), stateVersion: p.stateVersion } }, { session });
       await this.trace(session, p, episode.id, 'committed', { callId, parentVersion: episode.baseStateVersion, stateVersion: p.stateVersion, conceptRevisions: revisions, decision: proposal.decision });
-      return { state: publicDoc(state) };
+      return { state: stateView(state) };
     });
   }
   async finish(episode, status, code) {
@@ -416,16 +418,39 @@ export class MongoPersonRepository {
       const p = await this.collections.persons.findOne(scope, { session });
       if (!p) fail('NOT_OPEN');
       if (p.activeEpisodeId) fail('BUSY'); // No implicit background API or deferred control effects.
-      const next = { ...p.settings, ...settings };
-      await this.collections.persons.updateOne(scope, { $set: { settings: next }, $inc: { controlVersion: 1, writeSerial: 1 } }, { session });
-      if (Object.keys(settings).length) await this.trace(session, p, null, 'settings', { settings: next });
-      return { settings: next };
+      const { name, ...patch } = settings;
+      if (Object.hasOwn(settings, 'name')) p.name = personName(name);
+      const next = { ...settingsView(p.settings), ...patch };
+      await this.collections.persons.updateOne(scope, { $set: { settings: next, name: p.name }, $inc: { controlVersion: 1, writeSerial: 1 } }, { session });
+      if (Object.keys(settings).length) await this.trace(session, p, null, 'settings', { settings: next, ...(name !== undefined ? { name: p.name } : {}) });
+      return { settings: next, person: this.personView({ ...p, settings: next }) };
     });
   }
+  async inspect(ownerId, options) {
+    const { section, cursor, limit } = inspectRequest(options);
+    await this.getPerson(ownerId);
+    const scope = this.scope(ownerId);
+    if (section === 'skills') {
+      const docs = await this.collections.created_capabilities.find(scope).sort({ id: 1 }).limit(32).maxTimeMS(2000).toArray();
+      return inspectCapabilities(docs.map(doc => JSON.parse(doc.record)), { cursor, limit });
+    }
+    const records = await this.collections.concepts.find({ ...scope, ...(cursor !== null ? { id: { $gt: cursor } } : {}) })
+      .collation({ locale: 'simple' }).sort({ id: 1 }).limit(limit + 1).maxTimeMS(2000).toArray();
+    return inspectionPage(records, limit, 'id', conceptView);
+  }
+  async search(ownerId, options) {
+    const { query, cursor, limit } = searchRequest(options);
+    await this.getPerson(ownerId);
+    const records = await this.collections.messages.find({ ...this.scope(ownerId),
+      text: { $regex: query.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), $options: 'i' }, ...(cursor !== null ? { seq: { $lt: cursor } } : {}) })
+      .sort({ seq: -1 }).limit(limit + 1).maxTimeMS(2000).toArray();
+    return inspectionPage(records, limit, 'seq', messageView);
+  }
   async list(ownerId, collection, { cursor = null, limit = 20 }, filter = {}) {
+    if (!['messages', 'traces'].includes(collection)) fail('INVALID_REQUEST');
     await this.getPerson(ownerId);
     const docs = await this.collections[collection].find({ ...this.scope(ownerId), ...filter, ...(cursor ? { seq: { $lt: cursor } } : {}) }).sort({ seq: -1 }).limit(limit + 1).maxTimeMS(2000).toArray();
-    return { items: docs.slice(0, limit).map(collection === 'traces' ? publicTrace : publicDoc), nextCursor: docs.length > limit ? String(docs[limit - 1].seq) : null };
+    return { items: docs.slice(0, limit).map(collection === 'traces' ? publicTrace : messageView), nextCursor: docs.length > limit ? String(docs[limit - 1].seq) : null };
   }
   async snapshot(ownerId) {
     await this.recover(ownerId);
@@ -438,7 +463,7 @@ export class MongoPersonRepository {
       const concepts = await this.collections.concepts.find({ ...scope, id: { $in: state.focusConceptIds } }, { session }).limit(12).toArray();
       const episode = await this.collections.episodes.findOne(scope, { session, sort: { inputWatermark: -1 },
         projection: { _id: 0, id: 1, status: 1, terminalCode: 1, endedAt: 1 } });
-      return { latestEpisode: episode, person: this.personView(p), state: publicDoc(state), concepts: concepts.map(publicDoc), messages: messages.slice(0, 20).reverse().map(publicDoc),
+      return { latestEpisode: episode, person: this.personView(p), state: stateView(state), concepts: concepts.map(conceptView), messages: messages.slice(0, 20).reverse().map(messageView),
         nextMessagesCursor: messages.length > 20 ? String(messages[19].seq) : null, busy: Boolean(p.activeEpisodeId), episodeId: p.activeEpisodeId };
     });
   }

package/yeaft/person/service.js

@@ -6,6 +6,7 @@ import { PersonRuntime } from './runtime.js';
 import { validateFiles } from './attachments.js';
 import { createPersonProvider, validateModelCandidates } from './provider.js';
 import { fail, identifier, LIMITS, object, page, safeError, text } from './contracts.js';
+import { inspectRequest, personName, searchRequest } from './inspection.js';
 
 /**
  * One durable Person per (namespace, authenticated ownerId). The transport MUST
@@ -102,6 +103,12 @@ export function createPersonService(options = {}) {
       }
       case 'traces': await repository.recover(ownerId); return repository.list(ownerId, 'traces', page(payload));
       case 'messages': return repository.list(ownerId, 'messages', page(payload));
+      // These reads deliberately bypass recover(), Recall and the runtime/provider.
+      case 'inspect': return repository.inspect(ownerId, inspectRequest(payload));
+      case 'search': {
+        searchRequest(payload);
+        return repository.search(ownerId, payload);
+      }
       case 'cancel': {
         object(payload, ['episodeId'], []);
         if (payload.episodeId != null) identifier(payload.episodeId);
@@ -110,7 +117,9 @@ export function createPersonService(options = {}) {
         return result;
       }
       case 'settings': {
-        object(payload, ['autonomyEnabled', 'modelCandidates'], []);
+        object(payload, ['name', 'autonomyEnabled', 'modelCandidates'], []);
+        const patch = { ...payload };
+        if (Object.hasOwn(patch, 'name')) patch.name = personName(patch.name);
         if (Object.hasOwn(payload, 'autonomyEnabled') && typeof payload.autonomyEnabled !== 'boolean') fail('INVALID_REQUEST');
         if (Object.hasOwn(payload, 'modelCandidates')) {
           const refs = payload.modelCandidates;
@@ -122,7 +131,7 @@ export function createPersonService(options = {}) {
         }
         // Timer-driven autonomy is deliberately not claimed or silently enabled.
         if (payload.autonomyEnabled === true) fail('UNSUPPORTED');
-        return repository.settings(ownerId, payload);
+        return repository.settings(ownerId, patch);
       }
       default: fail('INVALID_REQUEST');
     }

package/yeaft/person/sqlite-repository.js

@@ -104,6 +104,8 @@ export class SqlitePersonRepository {
   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]); }
+  async inspect(ownerId, options) { return this.request('inspect', [ownerId, options]); }
+  async search(ownerId, options) { return this.request('search', [ownerId, options]); }
   /** 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. */

package/yeaft/person/sqlite-store.js

@@ -8,6 +8,8 @@ import { CREATED_CAPABILITY_LIMITS, createdCapabilityRecord, validateCreatedCapa
 import { SCHEMA, TABLES } from './sqlite-schema.js';
 import { attachmentMetadata, attachmentRequestHash, validateFiles } from './attachments.js';
 import { capabilityExperienceView, recordCapabilityExperience } from './capability-experience.js';
+import { conceptView, inspectionPage, inspectRequest, messageView, personName, searchRequest, settingsView, stateView } from './inspection.js';
+import { inspectCapabilities } from './capabilities.js';
 
 const SCOPE = 'namespace = ? AND ownerId = ? AND personId = ?';
 const scopeValues = s => [s.namespace, s.ownerId, s.personId];
@@ -46,7 +48,7 @@ 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(['receipt', 'getPerson', 'context', 'recall', 'list', 'searchChanges', 'resolveMemories', 'createdCapabilities', 'episodeAttachments']);
+const READS = new Set(['receipt', 'inspect', 'search', 'getPerson', 'context', 'recall', 'list', 'searchChanges', 'resolveMemories', 'createdCapabilities', 'episodeAttachments']);
 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; };
@@ -135,7 +137,7 @@ export class SqlitePersonStore {
       .run(...scopeValues(scope), kind, record.id, record.revision, JSON.stringify(publicDoc(record)));
   }
   personView(p) {
-    return { id: p.personId, name: p.name, soul: p.soul, soulRevision: p.soulRevision, createdAt: p.createdAt.toISOString(), settings: p.settings };
+    return { id: p.personId, name: p.name, soul: p.soul, soulRevision: p.soulRevision, createdAt: p.createdAt.toISOString(), settings: settingsView(p.settings) };
   }
   getPerson(ownerId) {
     const p = this.one('persons', this.scope(ownerId));
@@ -320,8 +322,8 @@ export class SqlitePersonStore {
     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), 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()] };
+      state: stateView(state), messages: this.rows('messages', scope, ' ORDER BY seq DESC LIMIT 12').reverse().map(messageView),
+      concepts: [...new Map([...focused, ...recent].map(c => [c.id, conceptView(c)])).values()] };
   }
   commit(episode, proposal, selection, callId, reportedSources = new Map()) {
     const p = this.own(episode), scope = this.episodeScope(episode);
@@ -346,7 +348,7 @@ export class SqlitePersonStore {
     if (this.one('states', scope)?.version !== episode.baseStateVersion) fail('STALE');
     this.put('states', state);
     this.put('state_commits', this.doc(scope, { id: randomUUID(), version: p.stateVersion, parentVersion: episode.baseStateVersion,
-      episodeId: episode.id, callId, conceptRevisions: revisions, state: publicDoc(state), createdAt: this.now }), true);
+      episodeId: episode.id, callId, conceptRevisions: revisions, state: stateView(state), createdAt: this.now }), true);
     if (proposal.reply) {
       const message = this.doc(scope, { id: randomUUID(), revision: 1, seq: p.messageSeq, episodeId: episode.id, role: 'assistant', text: proposal.reply, createdAt: this.now });
       this.put('messages', message, true); this.journal(scope, 'messages', message);
@@ -355,7 +357,7 @@ export class SqlitePersonStore {
     if (!record || record.status !== 'running') fail('STALE');
     Object.assign(record, { status: 'completed', endedAt: this.now, stateVersion: p.stateVersion }); this.put('episodes', record);
     this.trace(episode.ownerId, episode.id, 'committed', { callId, parentVersion: episode.baseStateVersion, stateVersion: p.stateVersion, conceptRevisions: revisions, decision: proposal.decision });
-    return { state: publicDoc(state) };
+    return { state: stateView(state) };
   }
   finish(episode, status, code) {
     const p = this.fenced(episode, false);
@@ -383,9 +385,26 @@ export class SqlitePersonStore {
   settings(ownerId, settings) {
     const p = this.getPerson(ownerId);
     if (p.activeEpisodeId) fail('BUSY');
-    p.settings = { ...p.settings, ...settings }; p.controlVersion++; p.writeSerial++; this.put('persons', p);
-    if (Object.keys(settings).length) this.trace(ownerId, null, 'settings', { settings: p.settings });
-    return { settings: p.settings };
+    const { name, ...patch } = settings;
+    if (Object.hasOwn(settings, 'name')) p.name = personName(name);
+    p.settings = { ...settingsView(p.settings), ...patch }; p.controlVersion++; p.writeSerial++; this.put('persons', p);
+    if (Object.keys(settings).length) this.trace(ownerId, null, 'settings', { settings: p.settings, ...(name !== undefined ? { name: p.name } : {}) });
+    return { settings: settingsView(p.settings), person: this.personView(p) };
+  }
+  inspect(ownerId, options) {
+    const { section, cursor, limit } = inspectRequest(options);
+    this.getPerson(ownerId);
+    const scope = this.scope(ownerId);
+    if (section === 'skills') return inspectCapabilities(this.rows('created_capabilities', scope, ' ORDER BY id ASC LIMIT 32'), { cursor, limit });
+    const records = this.rows('concepts', scope, ' AND (? IS NULL OR id > ?) ORDER BY id ASC LIMIT ?', [cursor, cursor, limit + 1]);
+    return inspectionPage(records, limit, 'id', conceptView);
+  }
+  search(ownerId, options) {
+    const { query, cursor, limit } = searchRequest(options);
+    this.getPerson(ownerId);
+    const records = this.rows('messages', this.scope(ownerId),
+      ' AND (? IS NULL OR seq < ?) AND instr(text, ?) > 0 ORDER BY seq DESC LIMIT ?', [cursor, cursor, query.toLowerCase(), limit + 1]);
+    return inspectionPage(records, limit, 'seq', messageView);
   }
   list(ownerId, collection, { cursor = null, limit = 20 } = {}, filter = {}) {
     if (!['messages', 'traces'].includes(collection)) fail('INVALID_REQUEST');
@@ -398,7 +417,7 @@ export class SqlitePersonStore {
     if (cursor != null) { clause += ' AND seq < ?'; params.push(sequence(cursor)); }
     if (query) { clause += ' AND instr(text, ?) > 0'; params.push(query.toLowerCase()); }
     const docs = this.rows(collection, this.scope(ownerId), `${clause} ORDER BY seq DESC LIMIT ?`, [...params, limit + 1]);
-    return { items: docs.slice(0, limit).map(publicDoc), nextCursor: docs.length > limit ? String(docs[limit - 1].seq) : null };
+    return { items: docs.slice(0, limit).map(collection === 'messages' ? messageView : publicDoc), nextCursor: docs.length > limit ? String(docs[limit - 1].seq) : null };
   }
   recall(ownerId, { kind = 'messages', query = '', cursor = null, limit = 5 } = {}) {
     memoryKind(kind); text(query, LIMITS.inputBytes, true); boundedLimit(limit);
@@ -406,7 +425,7 @@ export class SqlitePersonStore {
     this.getPerson(ownerId);
     if (cursor != null) text(cursor, 128);
     const docs = this.rows('concepts', this.scope(ownerId), ' AND (? IS NULL OR id > ?) AND instr(statement, ?) > 0 ORDER BY id ASC LIMIT ?', [cursor, cursor, query.toLowerCase(), limit + 1]);
-    return { items: docs.slice(0, limit).map(publicDoc), nextCursor: docs.length > limit ? docs[limit - 1].id : null };
+    return { items: docs.slice(0, limit).map(conceptView), nextCursor: docs.length > limit ? docs[limit - 1].id : null };
   }
   snapshot(ownerId) {
     this.recover(ownerId);
@@ -415,15 +434,16 @@ export class SqlitePersonStore {
     const episode = this.one('episodes', scope, ' ORDER BY inputWatermark DESC');
     const latestEpisode = episode ? { id: episode.id, status: episode.status,
       ...(episode.terminalCode ? { terminalCode: episode.terminalCode } : {}), ...(episode.endedAt ? { endedAt: episode.endedAt } : {}) } : null;
-    return { latestEpisode, person: this.personView(p), state: publicDoc(state), concepts: this.focused(scope, state.focusConceptIds).slice(0, 12).map(publicDoc),
-      messages: messages.slice(0, 20).reverse().map(publicDoc), nextMessagesCursor: messages.length > 20 ? String(messages[19].seq) : null,
+    return { latestEpisode, person: this.personView(p), state: stateView(state), concepts: this.focused(scope, state.focusConceptIds).slice(0, 12).map(conceptView),
+      messages: messages.slice(0, 20).reverse().map(messageView), nextMessagesCursor: messages.length > 20 ? String(messages[19].seq) : null,
       busy: Boolean(p.activeEpisodeId), episodeId: p.activeEpisodeId };
   }
   searchChanges(ownerId, { after = 0, limit = 100 } = {}) {
     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, row.kind) }));
+    const items = rows.slice(0, limit).map(row => ({ ...row,
+      record: (row.kind === 'messages' ? messageView : conceptView)(decode(row, row.kind)) }));
     return { items, lastSeq: items.at(-1)?.seq ?? after, hasMore: rows.length > limit };
   }
   resolveMemories(ownerId, kind, refs) {
@@ -433,7 +453,7 @@ export class SqlitePersonStore {
     for (const ref of refs) {
       if (!ref || typeof ref.id !== 'string' || !Number.isSafeInteger(ref.revision) || ref.revision < 1) fail('INVALID_REQUEST');
       const record = this.one(kind, scope, ' AND id = ? AND revision = ?', [ref.id, ref.revision]);
-      if (record && !seen.has(record.id)) { seen.add(record.id); records.push(publicDoc(record)); }
+      if (record && !seen.has(record.id)) { seen.add(record.id); records.push((kind === 'messages' ? messageView : conceptView)(record)); }
     }
     return records;
   }