@yeaft/webchat-agent 1.0.606 → 1.0.608

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "1.0.606",
+  "version": "1.0.608",
   "description": "Remote worker agent for Yeaft Web Code Agent — connects the native Yeaft engine, CLI providers, and workbench tools",
   "main": "index.js",
   "type": "module",
@@ -72,7 +72,6 @@
     "dotenv": "^16.3.1",
     "express": "^4.22.2",
     "jsonwebtoken": "^9.0.2",
-    "mongodb": "^6.21.0",
     "multer": "^2.2.0",
     "nodemailer": "^9.0.3",
     "puppeteer-core": "24.41.0",

package/yeaft/person/bridge.js

@@ -2,8 +2,8 @@ import { createHash } from 'node:crypto';
 import ctx from '../../context.js';
 import { sendToServer } from '../../connection/buffer.js';
 
-/** Lazy Person transport. Only deployment-local environment supplies database credentials.
- * Storage is lazy and instance-local by default; browser messages cannot choose a backend.
+/** Lazy Person transport. SQLite storage belongs to this Agent instance;
+ * browser messages cannot choose a storage authority or instance directory.
  */
 export function createPersonBridge({
   context = ctx, send = sendToServer, env = process.env,
@@ -32,7 +32,6 @@ export function createPersonBridge({
         await send({ ...response, ok: false, errorCode: 'invalid_request', error: 'Digital person request requires authenticated ownership' });
         return true;
       }
-      const uri = env.YEAFT_PERSON_MONGODB_URI;
       const agentId = context.agentId || context.AGENT_ID;
       if (!agentId || !context.CONFIG?.yeaftDir) throw new Error('identity');
       // Server+Agent is a storage boundary; a re-registration must not reuse the old runtime.
@@ -45,10 +44,7 @@ export function createPersonBridge({
       identity = namespace;
       if (!servicePromise) {
         servicePromise = Promise.resolve().then(() => createService({
-          uri,
-          storage: env.YEAFT_PERSON_STORAGE,
           embedding: { enabled: env.YEAFT_PERSON_EMBEDDING !== 'off', allowDownload: env.YEAFT_PERSON_EMBEDDING_DOWNLOAD !== '0' },
-          dbName: env.YEAFT_PERSON_MONGODB_DB || 'yeaft_person',
           namespace,
           yeaftDir: context.CONFIG.yeaftDir,
           workDir: context.CONFIG.workDir,
@@ -78,7 +74,7 @@ export function createPersonBridge({
         TASK_CONTROL_UNAVAILABLE: 'Task control could not be confirmed; refresh before retrying',
         STALE: 'Digital person state changed; refresh and try again',
         IDEMPOTENCY_CONFLICT: 'This message identifier already belongs to a different request',
-        STORAGE_MISMATCH: 'The configured storage differs from the existing Person authority; do not switch without a verified migration',
+        STORAGE_MISMATCH: 'Existing digital person storage is not a valid SQLite binding; check instance storage before retrying',
         UNSUPPORTED: 'This capability is not available in this digital person version',
       };
       const known = Object.hasOwn(safeErrors, error?.code);

package/yeaft/person/capabilities.js

@@ -83,7 +83,7 @@ export function inspectCapabilities(created, { cursor, limit }, nativeToolIds =
     contract.evidence = item.evidence;
     entries.push(item);
   }
-  // IDs are ASCII identifiers. Binary ordering matches SQLite and Mongo simple collation.
+  // IDs are ASCII identifiers. Binary ordering matches SQLite.
   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');

package/yeaft/person/contracts.js

@@ -5,7 +5,7 @@ export const LIMITS = Object.freeze({ inputBytes: 8192, outputBytes: 65536, cont
 const ERRORS = {
   INVALID_REQUEST: 'Invalid digital person request.', NOT_CONFIGURED: 'Digital person storage configuration is missing.',
   STORAGE_UNAVAILABLE: 'Digital person storage is unavailable. Check instance storage and database configuration.',
-  STORAGE_MISMATCH: 'Person storage is already bound to another backend; a verified migration is required.',
+  STORAGE_MISMATCH: 'Existing digital person storage is not a valid SQLite binding.',
   NOT_OPEN: 'Open your digital person first.', BUSY: 'The digital person is already active.',
   IDEMPOTENCY_CONFLICT: 'This clientMessageId was already used for a different request.',
   STALE: 'The activity no longer owns the current person revision.', INVALID_PROPOSAL: 'The model returned an invalid cognitive proposal.',

package/yeaft/person/inspection.js

@@ -18,7 +18,7 @@ export function personName(value) {
   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 const settingsView = value => pick(value, ['autonomyEnabled', 'modelCandidates', 'defaultModel']);
 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)

package/yeaft/person/provider.js

@@ -14,6 +14,29 @@ export function validateModelCandidates(refs) {
       new Set(refs).size !== refs.length) fail('MODEL_SELECTION');
 }
 
+export function validateDefaultModel(ref) {
+  if (ref !== null) validateModelCandidates([ref]);
+}
+
+/** Resolve router ownership before allowlisting or bounding the Person catalog. */
+export function resolveAgentDefaultModel(config) {
+  const models = config.availableModels || [], requested = config.primaryModel || config.model;
+  const model = models.find(m => (m.ref || m.id) === requested) || models.find(m => m.id === requested);
+  return model?.ref || (model?.id?.includes('/') ? model.id : null);
+}
+
+/** Shared validation for settings, status and runtime; never broaden an explicit subset. */
+export function selectPersonModels({ availableModels, modelCandidates = [], defaultModel = null }) {
+  validateModelCandidates(modelCandidates);
+  validateDefaultModel(defaultModel);
+  if (modelCandidates.some(ref => !availableModels.some(model => model.id === ref))) fail('MODEL_SELECTION');
+  const catalog = modelCandidates.length ? availableModels.filter(model => modelCandidates.includes(model.id))
+    : availableModels.slice(0, MODEL_LIMITS.candidates);
+  if (defaultModel !== null && !catalog.some(model => model.id === defaultModel)) fail('MODEL_SELECTION');
+  if (!catalog.length) fail('MODEL_UNAVAILABLE');
+  return { catalog, defaultSelection: { model: defaultModel ?? catalog[0].id, effort: null } };
+}
+
 // Bounds apply to the actual wire protocol, not a vision flag or compressed file size.
 // OpenAI tile models (including 2833 base tokens for gpt-4o-mini) have a fixed
 // cost only at explicit low detail. Known patch models below fit <=6144 patches
@@ -38,17 +61,13 @@ function imageInputBudget(modelId, protocol) {
 }
 
 /** Only configured native API models; no Session initialization or implicit credential fallback. */
-export async function createPersonProvider({ yeaftDir, config: suppliedConfig, adapter: suppliedAdapter, allowedModels, effortEnabled = process.env.YEAFT_THINKING_V1 === '1', modelCandidates = [] }) {
+export async function createPersonProvider({ yeaftDir, config: suppliedConfig, adapter: suppliedAdapter, allowedModels, effortEnabled = process.env.YEAFT_THINKING_V1 === '1', modelCandidates = [], defaultModel = null }) {
   const config = structuredClone(suppliedConfig || loadConfig({ dir: yeaftDir }));
   if (!config.providers?.length && !suppliedAdapter) fail('MODEL_UNAVAILABLE');
   const models = config.availableModels || [];
-  const requestedDefault = config.primaryModel || config.model;
-  // Match router ownership: exact qualified ref first; bare IDs use the first
-  // configured provider. Resolve before allowlisting, sorting or truncating.
-  const defaultModel = models.find(m => (m.ref || m.id) === requestedDefault)
-    || models.find(m => m.id === requestedDefault);
-  const defaultRef = defaultModel?.ref || defaultModel?.id;
+  const agentDefaultModel = resolveAgentDefaultModel(config);
   validateModelCandidates(modelCandidates);
+  validateDefaultModel(defaultModel);
   const available = models.filter(m => !allowedModels || allowedModels.includes(m.ref || m.id));
   const routingProviders = (config.providers || []).map(normalizeKnownProviderForRuntime);
   const safeModels = available.map(m => {
@@ -76,19 +95,16 @@ export async function createPersonProvider({ yeaftDir, config: suppliedConfig, a
     return { id: m.ref || m.id, efforts, maxOutput, supportsImages: imageBudget !== null, imageBudget,
       contextWindow: Math.floor(resolveContextWindow(m.id, { ...config, modelInfo: m })) };
   }).filter(m => typeof m.id === 'string' && m.id.length <= 256 && m.contextWindow > m.maxOutput + 1024 && m.maxOutput >= 256);
-  safeModels.sort((a, b) => Number(b.id === defaultRef) - Number(a.id === defaultRef));
+  safeModels.sort((a, b) => Number(b.id === agentDefaultModel) - Number(a.id === agentDefaultModel));
   const seen = new Set();
   const uniqueModels = safeModels.filter(model => !seen.has(model.id) && seen.add(model.id));
   const availableModels = uniqueModels.slice(0, MODEL_LIMITS.available);
   // A UI catalog must not be the bounded episode choice set: model 9+ remains selectable.
   // Explicit lists are validated, never silently truncated or broadened on stale config.
-  if (modelCandidates.some(ref => !availableModels.some(model => model.id === ref))) fail('MODEL_SELECTION');
-  const catalog = modelCandidates.length ? availableModels.filter(model => modelCandidates.includes(model.id))
-    : availableModels.slice(0, MODEL_LIMITS.candidates);
-  if (!catalog.length) fail('MODEL_UNAVAILABLE');
+  const { catalog, defaultSelection } = selectPersonModels({ availableModels, modelCandidates, defaultModel });
   const adapter = suppliedAdapter || await createLLMAdapter(config);
   return { adapter, catalog, availableModels, availableModelsTruncated: uniqueModels.length > MODEL_LIMITS.available,
-    catalogRevision: digest(catalog), defaultSelection: { model: catalog[0].id, effort: null }, effortEnabled };
+    catalogRevision: digest(catalog), defaultSelection, agentDefaultModel, effortEnabled };
 }
 
 export function abortable(promise, signal) {

package/yeaft/person/runtime.js

@@ -147,8 +147,8 @@ export class PersonRuntime {
     this.running = new Map(); this.pendingCancellations = new Map(); this.workerId = randomUUID(); this.closed = false;
   }
   tasks() {
-    // Construction/status/open do not touch task storage. Legacy direct Mongo
-    // embeddings without an instance root retain foreground-only host support.
+    // Construction/status/open do not touch task storage. An instance root is
+    // required before creating the durable task host.
     if (!this.toolOptions.yeaftDir) return null;
     return this.taskHost ??= new PersonTaskHost({ ...this.toolOptions, namespace: this.namespace });
   }
@@ -201,7 +201,7 @@ export class PersonRuntime {
     }, Math.max(100, Math.floor(this.repository.leaseMs / 3)));
     heartbeat.unref?.();
     try {
-      const provider = await abortable(this.getProvider(episode.modelCandidates ?? []), signal);
+      const provider = await abortable(this.getProvider(episode.modelCandidates ?? [], episode.defaultModel ?? null), signal);
       const snapshot = await abortable(this.repository.context(episode), signal);
       const attachments = episode.attachments?.length ? await abortable(this.repository.episodeAttachments(episode), signal) : [];
       // Bind recovered evidence using the repository's authoritative Person ID,
@@ -209,7 +209,7 @@ export class PersonRuntime {
       await this.tasks()?.context({ episode, parentToolRegistry: this.parentToolRegistry });
       signal.throwIfAborted();
       let selection = { ...provider.defaultSelection, reason: 'configured-default', origin: 'bootstrap' };
-      if (snapshot.state.lastSelection) {
+      if (episode.defaultModel == null && snapshot.state.lastSelection) {
         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' }); }
       }

package/yeaft/person/service.js

@@ -1,52 +1,47 @@
-import { MongoPersonRepository } from './repository.js';
 import { SqlitePersonRepository } from './sqlite-repository.js';
 import { LocalPersonMemory } from './local-memory.js';
-import { selectPersonStorage, bindPersonStorage } from './storage.js';
+import { ensurePersonStorage } from './sqlite-storage.js';
 import { PersonRuntime } from './runtime.js';
 import { allowedNativeToolIds } from './native-tools.js';
 import { loadConfig } from '../config.js';
 import { validateFiles } from './attachments.js';
-import { createPersonProvider, validateModelCandidates } from './provider.js';
+import { createPersonProvider, resolveAgentDefaultModel, selectPersonModels, validateDefaultModel, validateModelCandidates } from './provider.js';
 import { fail, identifier, LIMITS, object, page, personTaskRequest, safeError, text } from './contracts.js';
 import { inspectRequest, personName, searchRequest } from './inspection.js';
 
 /**
  * One durable Person per (namespace, authenticated ownerId). The transport MUST
- * supply authenticated ownerId, never accept it from a browser payload. URI/provider
+ * supply authenticated ownerId, never accept it from a browser payload. Provider
  * secrets stay inside this Agent. Constructor and status never initiate model calls.
- * Native provider configuration is read from yeaftDir only (no Session initialization).
- * SQLite is the local default; an existing Mongo URI retains Mongo. No authority fallback.
+ * SQLite storage and native provider configuration belong to yeaftDir only
+ * (no Session initialization or alternate storage authority).
  */
 export function createPersonService(options = {}) {
-  const { uri, dbName = 'yeaft_person', namespace = 'default', yeaftDir, workDir, MongoClient, config, adapter, allowedModels } = options;
+  const { namespace = 'default', yeaftDir, workDir, 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 { storage, configured } = selectPersonStorage({ ...options, yeaftDir });
+  const configured = typeof yeaftDir === 'string' && Boolean(yeaftDir.trim());
   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 > 32 || !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.some(m => typeof m !== 'string'))) fail('INVALID_REQUEST');
-  const repository = !configured ? null : storage === 'mongodb'
-    ? new MongoPersonRepository({ uri, dbName, namespace, MongoClient, leaseMs })
-    : new SqlitePersonRepository({ yeaftDir, namespace, leaseMs });
+  const repository = configured ? new SqlitePersonRepository({ yeaftDir, namespace, leaseMs }) : null;
   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; });
+    if (!binding) binding = ensurePersonStorage(yeaftDir, namespace).catch(error => { binding = null; throw error; });
     await binding;
     return initialize();
   };
   const literalRecall = repository?.recall.bind(repository);
-  const memory = repository && storage === 'sqlite' ? new LocalPersonMemory({
+  const memory = repository ? 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 = (modelCandidates = []) => createPersonProvider({ yeaftDir, config, adapter, allowedModels, modelCandidates, effortEnabled: options.effortEnabled });
+  const getProvider = (modelCandidates = [], defaultModel = null) => createPersonProvider({ yeaftDir, config, adapter, allowedModels, modelCandidates, defaultModel, effortEnabled: options.effortEnabled });
   const runtime = new PersonRuntime({ repository, getProvider, budget: { calls, timeoutMs }, workDir, yeaftDir, config, namespace });
   let closed = false;
   const requests = new Set();
@@ -56,23 +51,32 @@ export function createPersonService(options = {}) {
     if (typeof op !== 'string') fail('INVALID_REQUEST');
     if (op === 'status') {
       object(payload, []);
-      if (!configured) return { renameSupported: true, configured: false, storage, reason: 'Digital person storage configuration is missing.', storageReady: false, modelReady: false };
+      let agentDefaultModel = null;
+      try { agentDefaultModel = resolveAgentDefaultModel(config ?? loadConfig({ dir: yeaftDir })); } catch { /* Invalid/missing native config. */ }
+      const status = { renameSupported: true, defaultModelSupported: true, configured, storage: 'sqlite', modelReady: false,
+        defaultModel: null, agentDefaultModel, modelCandidates: [], effectiveModelCandidates: [], effectiveDefaultModel: null };
+      if (!configured) return { ...status, reason: 'Digital person storage configuration is missing.', storageReady: false };
       try { await repository.init(); }
-      catch (error) { return { renameSupported: true, configured: true, storage, reason: safeError(error).message, storageReady: false, modelReady: false }; }
-      let modelCandidates = [];
-      try { modelCandidates = (await repository.getPerson(ownerId)).settings.modelCandidates ?? []; }
-      catch (error) { if (error.code !== 'NOT_OPEN') throw error; }
+      catch (error) { return { ...status, reason: safeError(error).message, storageReady: false }; }
+      try {
+        const settings = (await repository.getPerson(ownerId)).settings;
+        status.modelCandidates = settings.modelCandidates ?? [];
+        status.defaultModel = settings.defaultModel ?? null;
+      } catch (error) { if (error.code !== 'NOT_OPEN') throw error; }
       try {
         const provider = await getProvider();
-        let modelReady = true;
         try {
-          validateModelCandidates(modelCandidates);
-          if (modelCandidates.some(ref => !provider.availableModels.some(model => model.id === ref))) modelReady = false;
-        } catch { modelReady = false; }
-        return { renameSupported: true, configured: true, storage, reason: modelReady ? null : 'Saved model candidates are unavailable; choose models or reset to Agent defaults.',
-          storageReady: true, modelReady, models: provider.availableModels, availableModels: provider.availableModels,
-          availableModelsTruncated: provider.availableModelsTruncated, modelCandidates, autonomySupported: false };
-      } catch { return { renameSupported: true, configured: true, storage, reason: 'No permitted native model is configured for digital person.', storageReady: true, modelReady: false, models: [], availableModels: [], modelCandidates }; }
+          const selected = selectPersonModels({ availableModels: provider.availableModels,
+            modelCandidates: status.modelCandidates, defaultModel: status.defaultModel });
+          status.modelReady = true;
+          status.effectiveModelCandidates = selected.catalog.map(model => model.id);
+          status.effectiveDefaultModel = selected.defaultSelection.model;
+        } catch { /* Stale settings remain visible, but do not grant fallback candidates. */ }
+        return { ...status, agentDefaultModel: provider.agentDefaultModel,
+          reason: status.modelReady ? null : 'Saved model settings are unavailable; choose models or reset to Agent defaults.',
+          storageReady: true, models: provider.availableModels, availableModels: provider.availableModels,
+          availableModelsTruncated: provider.availableModelsTruncated, autonomySupported: false };
+      } catch { return { ...status, reason: 'No permitted native model is configured for digital person.', storageReady: true, models: [], availableModels: [] }; }
     }
     if (!configured) fail('NOT_CONFIGURED');
     switch (op) {
@@ -143,21 +147,30 @@ export function createPersonService(options = {}) {
         } finally { release(); }
       }
       case 'settings': {
-        object(payload, ['name', 'autonomyEnabled', 'modelCandidates'], []);
+        object(payload, ['name', 'autonomyEnabled', 'modelCandidates', 'defaultModel'], []);
         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;
-          validateModelCandidates(refs);
-          if (refs.length) {
+        if (Object.hasOwn(payload, 'modelCandidates')) validateModelCandidates(payload.modelCandidates);
+        if (Object.hasOwn(payload, 'defaultModel')) validateDefaultModel(payload.defaultModel);
+        // Timer-driven autonomy is deliberately not claimed or silently enabled.
+        if (payload.autonomyEnabled === true) fail('UNSUPPORTED');
+        let expectedControlVersion;
+        if (Object.hasOwn(payload, 'modelCandidates') || Object.hasOwn(payload, 'defaultModel')) {
+          const prior = await repository.getPerson(ownerId);
+          if (prior.activeEpisodeId) fail('BUSY');
+          const merged = { modelCandidates: [], defaultModel: null, ...prior.settings, ...patch };
+          validateModelCandidates(merged.modelCandidates);
+          validateDefaultModel(merged.defaultModel);
+          // An automatic reset must also work when no model is currently available.
+          if (merged.modelCandidates.length || merged.defaultModel !== null) {
             const provider = await getProvider();
-            if (refs.some(ref => !provider.availableModels.some(model => model.id === ref))) fail('MODEL_SELECTION');
+            selectPersonModels({ availableModels: provider.availableModels, modelCandidates: merged.modelCandidates, defaultModel: merged.defaultModel });
           }
+          // Fence the merge base across concurrent services; retry from fresh settings.
+          expectedControlVersion = prior.controlVersion;
         }
-        // Timer-driven autonomy is deliberately not claimed or silently enabled.
-        if (payload.autonomyEnabled === true) fail('UNSUPPORTED');
-        return repository.settings(ownerId, patch);
+        return repository.settings(ownerId, patch, expectedControlVersion);
       }
       default: fail('INVALID_REQUEST');
     }

package/yeaft/person/sqlite-repository.js

@@ -103,7 +103,7 @@ export class SqlitePersonRepository {
   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 settings(ownerId, settings, expectedControlVersion) { return this.request('settings', [ownerId, settings, expectedControlVersion]); }
   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, nativeToolIds) { return this.request('inspect', [ownerId, options, nativeToolIds]); }

package/yeaft/person/sqlite-storage.js

@@ -0,0 +1,24 @@
+import { mkdir, readFile, writeFile, link, unlink } from 'node:fs/promises';
+import { join } from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { digest, fail } from './contracts.js';
+
+/** Preserve existing instance bindings without silently creating a new authority.
+ * SQLite is the only supported storage; this marker is not a backend selector.
+ */
+export async function ensurePersonStorage(yeaftDir, namespace) {
+  const directory = join(yeaftDir, 'person');
+  await mkdir(directory, { recursive: true, mode: 0o700 });
+  const path = join(directory, `storage-${digest(namespace)}.json`);
+  const temporary = `${path}.${randomUUID()}.tmp`;
+  await writeFile(temporary, JSON.stringify({ version: 1, storage: 'sqlite' }), { flag: 'wx', mode: 0o600 });
+  try {
+    // A fully written inode is linked atomically; competing openers never read partial JSON.
+    await link(temporary, path);
+  } catch (error) {
+    if (error.code !== 'EEXIST') throw error;
+    let binding;
+    try { binding = JSON.parse(await readFile(path, 'utf8')); } catch { fail('STORAGE_MISMATCH'); }
+    if (!binding || binding.version !== 1 || binding.storage !== 'sqlite') fail('STORAGE_MISMATCH');
+  } finally { await unlink(temporary).catch(() => {}); }
+}

package/yeaft/person/sqlite-store.js

@@ -151,7 +151,7 @@ export class SqlitePersonStore {
     if (!p) {
       p = this.doc(scope, {
         name, soul: 'A continuous, curious and honest digital person. Preserve uncertainty, reconsider your judgments, distinguish imagination from experience, and respect permissions. You may disagree without acting without authority.',
-        soulRevision: 1, createdAt: this.now, settings: { autonomyEnabled: false },
+        soulRevision: 1, createdAt: this.now, settings: { autonomyEnabled: false, defaultModel: null },
         epoch: 0, writeSerial: 0, inputWatermark: 0, controlVersion: 0, stateVersion: 0,
         traceSeq: 0, messageSeq: 0, activeEpisodeId: null, leaseOwner: null, leaseUntil: new Date(0),
       });
@@ -223,7 +223,7 @@ export class SqlitePersonStore {
       const message = this.doc(scope, { id: messageId, revision: 1, seq: p.messageSeq, episodeId: id, role: 'user', text: input, attachments, createdAt: this.now, clientMessageId });
       this.put('messages', message, true); this.journal(scope, 'messages', message);
     }
-    const episode = this.doc(scope, { id, clientMessageId, requestHash, kind, text: input, messageId, attachments, modelCandidates: [...(p.settings.modelCandidates ?? [])], status: 'running', workerId, epoch: p.epoch,
+    const episode = this.doc(scope, { id, clientMessageId, requestHash, kind, text: input, messageId, attachments, modelCandidates: [...(p.settings.modelCandidates ?? [])], defaultModel: p.settings.defaultModel ?? null, status: 'running', workerId, epoch: p.epoch,
       baseStateVersion: p.stateVersion, inputWatermark: p.inputWatermark, controlVersion: p.controlVersion, budget, createdAt: this.now });
     this.put('episodes', episode, true);
     this.trace(ownerId, id, 'accepted', { trigger: { kind, text: input, messageId, attachments }, baseStateVersion: p.stateVersion, budget });
@@ -419,9 +419,10 @@ export class SqlitePersonStore {
     this.trace(ownerId, id, 'cancelled', { code: 'CANCELLED' });
     return { cancelled: true, episodeId: id };
   }
-  settings(ownerId, settings) {
+  settings(ownerId, settings, expectedControlVersion) {
     const p = this.getPerson(ownerId);
     if (p.activeEpisodeId) fail('BUSY');
+    if (expectedControlVersion !== undefined && p.controlVersion !== expectedControlVersion) fail('STALE');
     const { name, ...patch } = settings;
     if (Object.hasOwn(settings, 'name')) p.name = personName(name);
     // A partial update must preserve durable fields omitted from the public view.
@@ -447,9 +448,9 @@ export class SqlitePersonStore {
   list(ownerId, collection, { cursor = null, limit = 20 } = {}, filter = {}) {
     if (!['messages', 'traces'].includes(collection)) fail('INVALID_REQUEST');
     this.getPerson(ownerId); boundedLimit(limit);
-    if (Object.keys(filter).some(k => k !== 'text') || (filter.text && (typeof filter.text.$regex !== 'string' || filter.text.$options !== 'i'))) fail('INVALID_REQUEST');
-    // Compatibility for Mongo's literal recall filter only; arbitrary selectors are forbidden.
-    const query = filter.text?.$regex?.replace(/\\([.*+?^${}()|[\]\\])/g, '$1') ?? '';
+    if (Object.keys(filter).some(k => k !== 'query')) fail('INVALID_REQUEST');
+    const query = filter.query ?? '';
+    text(query, LIMITS.inputBytes, true);
     if (query && collection !== 'messages') fail('INVALID_REQUEST');
     let clause = '', params = [];
     if (cursor != null) { clause += ' AND seq < ?'; params.push(sequence(cursor)); }
@@ -459,7 +460,7 @@ export class SqlitePersonStore {
   }
   recall(ownerId, { kind = 'messages', query = '', cursor = null, limit = 5 } = {}) {
     memoryKind(kind); text(query, LIMITS.inputBytes, true); boundedLimit(limit);
-    if (kind === 'messages') return this.list(ownerId, kind, { cursor, limit }, query ? { text: { $regex: query.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), $options: 'i' } } : {});
+    if (kind === 'messages') return this.list(ownerId, kind, { cursor, limit }, { query });
     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]);

package/yeaft/person/task-host.js

@@ -61,7 +61,7 @@ function privatePath(root, path) {
 // expose native command fallbacks; redact common sensitive forms before capping.
 function summary(value, maxBytes = 512) {
   const clean = String(value ?? '')
-    .replace(/https?:\/\/\S+|mongodb(?:\+srv)?:\/\/\S+/gi, '[url]')
+    .replace(/\b[a-z][a-z\d+.-]*:\/\/\S+/gi, '[url]')
     .replace(/(?:bearer\s+|(?:api[_-]?key|password|secret|token)\s*[:=]\s*)\S+/gi, '[redacted]')
     .replace(/\b(?:sk-[\w-]+|gh[pousr]_[\w]+|github_pat_[\w]+)\b/g, '[redacted]')
     .replace(/(?:\/[\w.@~+-]+)+(?:\/[^\s]*)?|(?:~|\.\.?|[A-Za-z]:)[\\/][^\s]+/g, '[path]')