@yeaft/webchat-agent 1.0.633 → 1.0.634

package/yeaft/person/service.js

@@ -2,6 +2,7 @@ import { SqlitePersonRepository } from './sqlite-repository.js';
 import { LocalPersonMemory } from './local-memory.js';
 import { ensurePersonStorage } from './sqlite-storage.js';
 import { PersonRuntime } from './runtime.js';
+import { PersonAutonomy } from './autonomy.js';
 import { PersonCapabilities } from './capabilities.js';
 import { EXECUTION_INSTRUCTIONS } from './execution-protocol.js';
 import { personMinimumRequestBytes } from './request-budget.js';
@@ -52,8 +53,11 @@ export function createPersonService(options = {}) {
       effortEnabled: options.effortEnabled, minimumRequestBytes });
   };
   const runtime = new PersonRuntime({ repository, getProvider, budget: { calls: null }, workDir, yeaftDir, config, namespace });
+  const autonomy = repository ? new PersonAutonomy({ repository, runtime }) : null;
+  runtime.toolOptions.onCompletion = completion => autonomy?.observe(completion);
   let closed = false;
   const requests = new Set();
+  const autonomyStops = new Map();
   async function handle({ ownerId, op, payload = {} } = {}) {
     if (closed) fail('CLOSED');
     text(ownerId, 256); // Owners are opaque authenticated IDs, not database selectors.
@@ -64,16 +68,18 @@ export function createPersonService(options = {}) {
       try { agentDefaultModel = resolveAgentDefaultModel(config ?? loadConfig({ dir: yeaftDir })); } catch { /* Invalid/missing native config. */ }
       const filePublication = outputFilePublicationSupport();
       const status = { outputsSupported: true, outputsFileSupported: filePublication.supported, outputsFileReason: filePublication.reason,
-        renameSupported: true, defaultModelSupported: true, configured, storage: 'sqlite', modelReady: false,
+        renameSupported: true, defaultModelSupported: true, autonomySupported: true, autonomyEnabled: false, configured, storage: 'sqlite', modelReady: false,
         executionsSupported: true, pauseSupported: true, main: runtime.execution(ownerId),
         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 { ...status, reason: safeError(error).message, storageReady: false }; }
       try {
-        const settings = (await repository.getPerson(ownerId)).settings;
+        const person = await repository.getPerson(ownerId);
+        const settings = person.settings;
         status.modelCandidates = settings.modelCandidates ?? [];
         status.defaultModel = settings.defaultModel ?? null;
+        status.autonomyEnabled = settings.autonomyEnabled === true && person.autonomy?.version === 1;
       } catch (error) { if (error.code !== 'NOT_OPEN') throw error; }
       try {
         const provider = await getProvider();
@@ -88,7 +94,7 @@ export function createPersonService(options = {}) {
         return { ...status, agentDefaultModel: provider.agentDefaultModel,
           reason: status.modelReady ? null : `${modelReason} Choose models or reset to Agent defaults.`,
           storageReady: true, models: provider.availableModels, availableModels: provider.availableModels,
-          availableModelsTruncated: provider.availableModelsTruncated, autonomySupported: false };
+          availableModelsTruncated: provider.availableModelsTruncated };
       } catch (error) { return { ...status, reason: safeError(error, 'MODEL_UNAVAILABLE').message, storageReady: true, models: [], availableModels: [] }; }
     }
     if (!configured) fail('NOT_CONFIGURED');
@@ -170,25 +176,33 @@ export function createPersonService(options = {}) {
       case 'cancel': {
         object(payload, ['episodeId'], []);
         if (payload.episodeId != null) identifier(payload.episodeId);
+        autonomyStops.set(ownerId, (autonomyStops.get(ownerId) ?? 0) + 1);
         const release = runtime.beginCancellation(ownerId);
         try {
           const result = await repository.cancel(ownerId, payload.episodeId);
           // Even a repeated cancel must join an already-fenced local execution.
           // A durable cancelled status alone does not prove host effects stopped.
-          await runtime.cancel(payload.episodeId, 'CANCELLED', ownerId);
+          await Promise.all([runtime.cancel(payload.episodeId, 'CANCELLED', ownerId),
+            ...(result.cancelled && payload.episodeId && result.episodeId !== payload.episodeId
+              ? [runtime.cancel(result.episodeId, 'CANCELLED', ownerId)] : [])]);
           return result;
         } finally { release(); }
       }
       case 'settings': {
+        const stopGeneration = autonomyStops.get(ownerId) ?? 0;
         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')) 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 (runtime.pendingCancellations.has(ownerId)) fail('BUSY');
+        let expectedControlVersion, expectedAutonomyGeneration;
+        if (Object.hasOwn(payload, 'autonomyEnabled')) {
+          const prior = await repository.getPerson(ownerId);
+          expectedAutonomyGeneration = prior.autonomy?.generation ?? null;
+          if (runtime.pendingCancellations.has(ownerId)) fail('BUSY');
+        }
         if (Object.hasOwn(payload, 'modelCandidates') || Object.hasOwn(payload, 'defaultModel')) {
           const prior = await repository.getPerson(ownerId);
           if (prior.activeEpisodeId) fail('BUSY');
@@ -204,7 +218,8 @@ export function createPersonService(options = {}) {
           // Fence the merge base across concurrent services; retry from fresh settings.
           expectedControlVersion = prior.controlVersion;
         }
-        return repository.settings(ownerId, patch, expectedControlVersion);
+        if (Object.hasOwn(payload, 'autonomyEnabled') && (autonomyStops.get(ownerId) ?? 0) !== stopGeneration) fail('STALE');
+        return repository.settings(ownerId, patch, expectedControlVersion, expectedAutonomyGeneration);
       }
       default: fail('INVALID_REQUEST');
     }
@@ -217,7 +232,9 @@ export function createPersonService(options = {}) {
     },
     async close() {
       closed = true;
+      const stoppingAutonomy = autonomy?.close();
       await Promise.allSettled([...requests]);
+      await stoppingAutonomy;
       await runtime.close();
       await memory?.close();
       await repository?.close().catch(() => {});

package/yeaft/person/sqlite-repository.js

@@ -88,6 +88,9 @@ export class SqlitePersonRepository {
   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 autonomyOwners(options) { return this.request('autonomyOwners', [options]); }
+  async autonomyObserve(ownerId, event) { return this.request('autonomyObserve', [ownerId, event]); }
+  async autonomyAdmit(ownerId, input) { return this.request('autonomyAdmit', [ownerId, input]); }
   async admit(ownerId, input) { return this.request('admit', [ownerId, input]); }
   async receipt(ownerId, clientMessageId, requestHash) { return this.request('receipt', [ownerId, clientMessageId, requestHash]); }
   async executionControl(episode, control) { return this.request('executionControl', [episode, control]); }
@@ -117,7 +120,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, expectedControlVersion) { return this.request('settings', [ownerId, settings, expectedControlVersion]); }
+  async settings(ownerId, settings, expectedControlVersion, expectedAutonomyGeneration) { return this.request('settings', [ownerId, settings, expectedControlVersion, expectedAutonomyGeneration]); }
   async list(ownerId, collection, options, filter) { return this.request('list', [ownerId, collection, options, filter]); }
   async turns(ownerId, options) { return this.request('turns', [ownerId, options]); }
   async checkOutputPublication(episode, input) { return this.request('checkOutputPublication', [episode, input]); }

package/yeaft/person/sqlite-store.js

@@ -12,6 +12,7 @@ import { capabilityExperienceView, recordCapabilityExperience } from './capabili
 import { chronologicalCursor, conceptView, inspectionCursor, inspectionPage, inspectRequest, messageView, personName, searchRequest, settingsView, stateView } from './inspection.js';
 import { TOKEN_FIELDS, turnsPage, turnView } from './turn-diagnostics.js';
 import { personPresentation } from './presentation.js';
+import { executionOrientation } from './behavior.js';
 import { inspectCapabilities } from './capabilities.js';
 import { executionEvidencePage, executionReadRequest, nativeInvocationMatches } from './execution-evidence.js';
 import { OUTPUT_LIMITS, outputArgs, outputMime, outputReadRequest, outputsPage, outputUrl, outputView } from './outputs.js';
@@ -92,8 +93,8 @@ const objectOutput = (record, data) => {
     if (!mimes.includes(record.mimeType) || !(data instanceof Uint8Array) || data.length !== record.size) fail('INVALID_REQUEST');
   }
 };
-const READS = new Set(['checkExecutionRead', 'executionRead', 'outputs', 'outputRead', 'checkOutputPublication', 'receipt', 'turns', 'inspect', 'search', 'getPerson', 'context', 'recall', 'list', 'searchChanges', 'resolveMemories', 'createdCapabilities', 'episodeAttachments']);
-const WRITES = new Set(['executionControl', 'savePresentation', 'saveOutput', 'open', 'recover', 'admit', 'heartbeat', 'append', 'startCall', 'finalizeCall', 'startCapability', 'finalizeCapability', 'commit', 'publishProgress', 'finish', 'cancel', 'settings', 'snapshot', 'saveCreatedCapability']);
+const READS = new Set(['autonomyOwners', 'checkExecutionRead', 'executionRead', 'outputs', 'outputRead', 'checkOutputPublication', 'receipt', 'turns', 'inspect', 'search', 'getPerson', 'context', 'recall', 'list', 'searchChanges', 'resolveMemories', 'createdCapabilities', 'episodeAttachments']);
+const WRITES = new Set(['autonomyObserve', 'autonomyAdmit', 'executionControl', 'savePresentation', 'saveOutput', 'open', 'recover', 'admit', 'heartbeat', 'append', 'startCall', 'finalizeCall', 'startCapability', 'finalizeCapability', 'commit', 'publishProgress', '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 => {
@@ -181,7 +182,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: settingsView(p.settings) };
+    return { id: p.personId, name: p.name, soul: p.soul, soulRevision: p.soulRevision, createdAt: p.createdAt.toISOString(), settings: settingsView({ ...p.settings, autonomyEnabled: p.settings.autonomyEnabled === true && p.autonomy?.version === 1 }) };
   }
   getPerson(ownerId) {
     const p = this.one('persons', this.scope(ownerId));
@@ -224,6 +225,10 @@ export class SqlitePersonStore {
     if (expired) {
       const id = p.activeEpisodeId;
       p.epoch++; p.writeSerial++; p.activeEpisodeId = null; p.leaseOwner = null; p.leaseUntil = new Date(0);
+      if (p.settings.autonomyEnabled === true && p.autonomy?.version === 1) {
+        p.settings.autonomyEnabled = false;
+        p.autonomy = { ...p.autonomy, generation: randomUUID(), pending: [], nextAt: null };
+      }
       this.put('persons', p);
       const episode = this.one('episodes', scope, ' AND id = ?', [id]);
       if (episode?.status === 'running') {
@@ -243,8 +248,82 @@ export class SqlitePersonStore {
     const episode = this.one('episodes', this.scope(ownerId), ' AND clientMessageId = ?', [clientMessageId]);
     return admissionReceipt(episode, clientMessageId, requestHash);
   }
+  /** Only explicit v1 opt-in is schedulable. Legacy settings never acquire consent. */
+  autonomyOwners({ after = '', limit = 50 } = {}) {
+    boundedLimit(limit, 100);
+    const rows = this.sql(`SELECT record FROM persons WHERE namespace = ? AND ownerId > ?
+      AND json_extract(record, '$.settings.autonomyEnabled') = 1
+      AND json_extract(record, '$.autonomy.version') = 1 ORDER BY ownerId LIMIT ?`)
+      .all(this.namespace, after, limit).map(row => JSON.parse(row.record));
+    return { owners: rows.map(p => p.ownerId), next: rows.length === limit ? rows.at(-1).ownerId : null };
+  }
+  autonomyObserve(ownerId, event) {
+    const p = this.getPerson(ownerId), a = p.autonomy;
+    // No raw task text enters scheduling metadata. Events are untrusted observations,
+    // and only tasks from the current consent generation may wake this Person.
+    if (p.settings.autonomyEnabled !== true || a?.version !== 1 || !event ||
+        !['succeeded', 'failed'].includes(event.status)) return false;
+    identifier(event.taskId); identifier(event.episodeId); text(event.sourceRef, 512);
+    const source = this.one('episodes', this.scope(ownerId), ' AND id = ?', [event.episodeId]);
+    if (source?.autonomyGeneration !== a.generation) return false;
+    const key = digest([event.taskId, event.status]);
+    if ((a.seen ?? []).includes(key) || (a.integratedSourceRefs ?? []).includes(event.sourceRef)) return false;
+    a.seen = [...(a.seen ?? []), key].slice(-64);
+    a.pending = [...(a.pending ?? []), { taskId: event.taskId, status: event.status, sourceRef: event.sourceRef }].slice(-8);
+    a.nextAt = this.now.getTime() + 5000; a.backoffMs = 60000;
+    p.writeSerial++; this.put('persons', p);
+    return true;
+  }
+  autonomyAdmit(ownerId, { workerId, budget }) {
+    let p = this.getPerson(ownerId), a = p.autonomy;
+    if (p.settings.autonomyEnabled !== true || a?.version !== 1) return null;
+    if (p.activeEpisodeId) {
+      if (p.leaseUntil <= this.now) {
+        // Lost execution control is not permission to replay host effects. Reconcile
+        // the episode, then require explicit re-enable before further cognition.
+        this.recover(ownerId); p = this.getPerson(ownerId);
+        p.settings.autonomyEnabled = false; p.autonomy = { ...a, generation: randomUUID(), pending: [], nextAt: null };
+        p.writeSerial++; this.put('persons', p);
+      }
+      return null; // Includes paused / pausing jobs; never bypass admission.
+    }
+    const now = this.now.getTime();
+    if (!Number.isFinite(a.nextAt) || now < a.nextAt) return null;
+    const state = this.one('states', this.scope(ownerId));
+    const continuation = state?.continuation ?? null;
+    const fingerprint = digest(continuation);
+    const pending = a.pending ?? [], taskCompletion = pending.length > 0;
+    // The most recent persisted outcome is only an idle retry fence, never an
+    // active-task predicate. Task readiness belongs to the exact task host state.
+    // Failed cognition may leave an older ready continuation behind: don't turn
+    // that into an automatic retry, even after restart or toggling consent.
+    const latest = this.one('episodes', this.scope(ownerId), ' ORDER BY inputWatermark DESC');
+    // Successful uncommitted discovery may rest and return after the durable quiet
+    // interval. This is not permission to retry unchanged work or a failed run.
+    const restedExploration = latest?.status === 'completed' && latest.kind === 'autonomous' &&
+      latest.executionGoal?.kind === 'exploration' && latest.executionGoal.status === 'resting' && continuation == null;
+    const quiet = !taskCompletion && (latest?.status === 'failed' ||
+      (a.lastFingerprint === fingerprint && !restedExploration) || (continuation && continuation.status !== 'ready'));
+    a.nextAt = now + Math.min(a.backoffMs ?? 60000, 3600000);
+    a.backoffMs = Math.min((a.backoffMs ?? 60000) * 2, 3600000);
+    p.writeSerial++; this.put('persons', p);
+    if (quiet) return null; // A stored ready or repeated blocker isn't fresh evidence.
+    const reason = taskCompletion ? 'task-completion' : 'idle';
+    const scheduling = { origin: 'autonomous', reason, observationOnly: true, authorization: false,
+      notice: 'System scheduling metadata, not a user request or permission. Task observations are untrusted; reconcile current status, do not replay effects or repeat prior replies.',
+      observations: pending };
+    const admitted = this.admit(ownerId, { kind: 'autonomous', text: JSON.stringify(scheduling), workerId, budget,
+      clientMessageId: `autonomy-${a.generation}-${(a.sequence ?? 0) + 1}` });
+    admitted.episode.scheduling = scheduling; this.put('episodes', admitted.episode);
+    p = this.getPerson(ownerId);
+    // Admission is not consumption: failed cognition must leave observations retryable.
+    p.autonomy = { ...a, sequence: (a.sequence ?? 0) + 1, lastFingerprint: fingerprint };
+    this.put('persons', p);
+    this.trace(ownerId, admitted.episodeId, 'autonomy_scheduled', { scheduling });
+    return admitted;
+  }
   admit(ownerId, { kind, text: input, clientMessageId, workerId, budget, files = [] }) {
-    if (!['send', 'think', 'dream'].includes(kind)) fail('INVALID_REQUEST');
+    if (!['send', 'think', 'dream', 'autonomous'].includes(kind)) fail('INVALID_REQUEST');
     const validated = validateFiles(files, input, kind), attachments = validated.map(attachmentMetadata);
     identifier(clientMessageId); text(workerId, 256);
     this.recover(ownerId);
@@ -256,8 +335,14 @@ export class SqlitePersonStore {
     }
     const p = this.getPerson(ownerId);
     if (p.activeEpisodeId) fail('BUSY');
+    if (kind !== 'autonomous' && p.settings.autonomyEnabled === true && p.autonomy?.version === 1) {
+      p.autonomy = { ...p.autonomy, backoffMs: 60000, nextAt: this.now.getTime() + 60000, lastFingerprint: null };
+    }
     const id = randomUUID();
-    const hasMessage = kind === 'send' || (kind === 'think' && attachments.length > 0);
+    // Explicit text-only Think instructions are user input too, even if this
+    // episode fails before cognition commits. Empty Think/Dream/scheduler wakes
+    // must never replace the latest substantive user instruction.
+    const hasMessage = kind === 'send' || (kind === 'think' && (input.trim().length > 0 || attachments.length > 0));
     p.activeEpisodeId = id; p.leaseOwner = workerId; p.leaseUntil = new Date(this.now.getTime() + this.leaseMs);
     p.epoch++; p.writeSerial++; p.inputWatermark++; if (hasMessage) p.messageSeq++;
     this.put('persons', p);
@@ -269,7 +354,7 @@ export class SqlitePersonStore {
       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 ?? [])], defaultModel: p.settings.defaultModel ?? null, status: 'running', workerId, epoch: p.epoch,
-      baseStateVersion: p.stateVersion, inputWatermark: p.inputWatermark, controlVersion: p.controlVersion, budget, createdAt: this.now });
+      baseStateVersion: p.stateVersion, inputWatermark: p.inputWatermark, controlVersion: p.controlVersion, autonomyGeneration: p.settings.autonomyEnabled === true ? p.autonomy?.generation ?? null : null, budget, createdAt: this.now });
     this.put('episodes', episode, true);
     this.trace(ownerId, id, 'accepted', { trigger: { kind, text: input, messageId, attachments }, baseStateVersion: p.stateVersion, budget });
     return { episodeId: id, duplicate: false, status: 'running', episode };
@@ -326,6 +411,7 @@ export class SqlitePersonStore {
     if (!record || record.status !== 'running') fail('STALE');
     const experience = recordCapabilityExperience(p.capabilityExperience, record, kind, data, this.now.toISOString());
     if (experience) p.capabilityExperience = experience;
+    if (kind === 'execution_goal') { record.executionGoal = data.goal; this.put('episodes', record); }
     p.writeSerial++; this.put('persons', p);
     return this.trace(episode.ownerId, episode.id, kind, data);
   }
@@ -352,6 +438,10 @@ export class SqlitePersonStore {
     const safeEffective = { model: call.requested.model, effort: typeof effective?.effort === 'string' && effective.effort.length <= 128 ? effective.effort : null,
       effortObserved: effective?.effortObserved === true };
     if (typeof effective?.wireMode === 'string' && effective.wireMode.length <= 128) safeEffective.wireMode = effective.wireMode;
+    // Only evidence actually rendered to a successful model call can be
+    // acknowledged at commit. Scheduling metadata and inherited refs are not reads.
+    if (!failed) record.integratedTaskSourceRefs = [...new Set([...(record.integratedTaskSourceRefs ?? []),
+      ...(call.manifest?.renderedSourceRefs ?? []).filter(ref => typeof ref === 'string' && ref.startsWith('person-task:'))])].slice(-64);
     delete record.openCall; delete record.callFinalizeUntil; this.put('episodes', record);
     this.trace(episode.ownerId, episode.id, failed ? 'call_failed' : 'call_output', {
       callId, requested: call.requested, effective: safeEffective, output: publicOutput(output, failed),
@@ -413,6 +503,7 @@ export class SqlitePersonStore {
     const data = { callId, ...(started.modelCallId !== undefined ? { modelCallId: started.modelCallId, toolUseId: started.toolUseId, toolIndex: started.toolIndex } : {}), ...(started.capabilityManifest ? { capabilityManifest: started.capabilityManifest } : {}),
       ...(failed ? { capabilityId: started.capability.id, code: code || result.code } : { capability: started.capability }),
       ...(result !== undefined ? { result } : {}) };
+    if (live && started.capability.id === 'Execution.goal' && result?.ok === true) record.executionGoal = result.goal;
     delete record.openCapability; this.put('episodes', record);
     if (live) {
       const experience = recordCapabilityExperience(p.capabilityExperience, record, outcome, data, this.now.toISOString());
@@ -473,11 +564,54 @@ export class SqlitePersonStore {
   }
   context(episode) {
     const p = this.own(episode), scope = this.episodeScope(episode), state = this.one('states', scope);
-    const focused = this.focused(scope, state.focusConceptIds).slice(0, 12);
-    const recent = this.rows('concepts', scope, ' ORDER BY updatedAt DESC, id ASC LIMIT 12');
+    const focused = this.focused(scope, state.focusConceptIds.slice(0, 12));
+    const latestUser = this.one('messages', scope, " AND json_extract(record, '$.role') = 'user' ORDER BY seq DESC");
+    const dream = executionOrientation(episode.kind, episode.scheduling) === 'dream', recentLimit = dream ? 6 : 12;
+    const recent = this.rows('concepts', scope, ` ORDER BY updatedAt DESC, id ASC LIMIT ${recentLimit}`);
+    let messages = dream ? [] : this.rows('messages', scope, ' ORDER BY seq DESC LIMIT 12');
+    let older = [], olderMessages = [];
+    if (dream) {
+      // Rotate complete records, not LLM summaries or random full-database loads.
+      // SQL counts/offsets may scan indexes; only the small selected pages are decoded.
+      // inputWatermark advances on admission, including episodes that never commit.
+      const rotation = Math.max(0, episode.inputWatermark - 1);
+      const recentUsers = this.rows('messages', scope, " AND json_extract(record, '$.role') = 'user' ORDER BY seq DESC LIMIT 6");
+      const boundary = recentUsers.at(-1)?.seq ?? 0;
+      const userClause = " AND json_extract(record, '$.role') = 'user' AND seq < ?";
+      const count = this.sql(`SELECT count(*) AS n FROM messages WHERE ${SCOPE}${userClause}`).get(...scopeValues(scope), boundary).n;
+      if (count) {
+        const offset = rotation * 4 % count;
+        olderMessages = this.rows('messages', scope, `${userClause} ORDER BY seq ASC LIMIT 4 OFFSET ?`, [boundary, offset]);
+        if (olderMessages.length < Math.min(4, count)) olderMessages.push(...this.rows('messages', scope,
+          `${userClause} ORDER BY seq ASC LIMIT ?`, [boundary, Math.min(4, count) - olderMessages.length]));
+      }
+      // Assistant progress is not evidence of user interests. Keep at most two
+      // substantive replies for conversational grounding, independent of progress volume.
+      const replies = this.rows('messages', scope,
+        " AND json_extract(record, '$.role') = 'assistant' AND coalesce(json_extract(record, '$.replyKind'), '') != 'progress' ORDER BY seq DESC LIMIT 2");
+      messages = [...recentUsers, ...olderMessages, ...replies];
+      const excluded = [...new Set([...focused, ...recent].map(c => c.id))];
+      const exclusion = excluded.length ? ` AND id NOT IN (${excluded.map(() => '?').join(',')})` : '';
+      for (const kind of ['claim', 'question', 'method', 'self-model', 'scenario', 'interest']) {
+        const clause = ` AND json_extract(record, '$.kind') = ?${exclusion}`;
+        const params = [kind, ...excluded];
+        const total = this.sql(`SELECT count(*) AS n FROM concepts WHERE ${SCOPE}${clause}`).get(...scopeValues(scope), ...params).n;
+        if (total) older.push(...this.rows('concepts', scope, `${clause} ORDER BY updatedAt ASC, id ASC LIMIT 1 OFFSET ?`, [...params, rotation % total]));
+      }
+    }
+    // A long assistant progress stream must never erase the newest user stop or
+    // prohibition. Runtime also receives it separately for mandatory admission.
+    if (latestUser && !messages.some(m => m.id === latestUser.id)) messages = [...messages.slice(0, 11), latestUser];
+    messages.sort((a, b) => a.seq - b.seq);
     return { person: this.personView(p), capabilityExperience: capabilityExperienceView(p.capabilityExperience),
-      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()] };
+      state: stateView(state), latestUserInstruction: messageView(latestUser), messages: messages.map(messageView),
+      concepts: [...new Map([...focused, ...recent, ...older].map(c => [c.id, conceptView(c)])).values()],
+      contextSelection: { strategy: dream ? 'dream-diverse' : 'recent', rotation: dream ? episode.inputWatermark - 1 : null,
+        limits: { messages: 12, focusedConcepts: 12, recentConcepts: recentLimit, olderConcepts: dream ? 6 : 0 },
+        recentUserMessageRefs: dream ? messages.filter(m => m.role === 'user' && !olderMessages.some(old => old.id === m.id)).map(m => `message:${m.id}:${m.revision}`) : [],
+        olderUserMessageRefs: olderMessages.map(m => `message:${m.id}:${m.revision}`),
+        focusedConceptRefs: focused.map(c => `concept:${c.id}:${c.revision}`), recentConceptRefs: recent.map(c => `concept:${c.id}:${c.revision}`),
+        olderConceptRefs: older.map(c => `concept:${c.id}:${c.revision}`) } };
   }
   /** Atomic capability publication: exact started invocation + live lease, never
    * publishProgress's no-open-capability path. JSON carries the canonical payload;
@@ -501,7 +635,10 @@ export class SqlitePersonStore {
     if (!record || record.status !== 'running' || record.openCall || !proof || record.openCapability?.callId !== callId ||
         record.openCapability.invocationHash !== invocationHash) fail('STALE');
     // Repeating an identical delivery in this episode adds no new visible answer.
-    const repeated = prior.find(m => digest(m.presentation) === digest(presentation));
+    const repeated = prior.find(m => digest(m.presentation) === digest(presentation)) ??
+      (episode.kind === 'autonomous' ? this.rows('messages', scope,
+        " AND json_type(record, '$.presentation') = 'object' ORDER BY seq DESC LIMIT 32")
+        .find(m => digest(m.presentation) === digest(presentation)) : null);
     if (repeated) {
       this.trace(episode.ownerId, episode.id, 'presentation_published', { callId, invocationHash, messageId: repeated.id, phase: presentation.phase, duplicate: true });
       return messageView(repeated);
@@ -515,6 +652,11 @@ export class SqlitePersonStore {
     this.trace(episode.ownerId, episode.id, 'presentation_published', { callId, invocationHash, messageId: message.id, phase: presentation.phase });
     return messageView(message);
   }
+  repeatsAutonomousReply(scope, episode, reply) {
+    return episode.kind === 'autonomous' && typeof reply === 'string' &&
+      this.rows('messages', scope, " AND json_extract(record, '$.role') = 'assistant' ORDER BY seq DESC LIMIT 32")
+        .some(message => message.text.trim() === reply.trim());
+  }
   repeatsPresentation(scope, episodeId, reply) {
     return typeof reply === 'string' && this.rows('messages', scope,
       " AND json_extract(record, '$.episodeId') = ? AND json_type(record, '$.presentation') = 'object'", [episodeId])
@@ -545,9 +687,12 @@ export class SqlitePersonStore {
     // cognition does not interpret dedupe as a missing public result.
     const sameReply = prior.find(m => m.text.trim() === reply.trim());
     if (final && sameReply) return messageView(sameReply);
+    if (final && this.repeatsAutonomousReply(scope, episode, reply)) {
+      return messageView(this.rows('messages', scope, " AND json_extract(record, '$.role') = 'assistant' ORDER BY seq DESC LIMIT 32").find(message => message.text.trim() === reply.trim()));
+    }
     // Provider latency counts too: a call started before 30s can finish after it.
     if ((!final && this.now.getTime() - new Date(record.lastReplyAt ?? record.createdAt).getTime() < FEEDBACK.minMs) ||
-        sameReply || this.repeatsPresentation(scope, episode.id, reply)) return null;
+        sameReply || this.repeatsAutonomousReply(scope, episode, reply) || this.repeatsPresentation(scope, episode.id, reply)) return null;
     p.messageSeq++; p.writeSerial++; this.put('persons', p);
     const message = this.doc(scope, { id: randomUUID(), revision: 1, seq: p.messageSeq, episodeId: episode.id,
       callId, replyKind: final ? 'execution-final' : 'progress', role: 'assistant', text: reply, createdAt: this.now });
@@ -558,11 +703,12 @@ export class SqlitePersonStore {
   }
   commit(episode, proposal, selection, callId, reportedSources = new Map()) {
     const p = this.own(episode), scope = this.episodeScope(episode);
-    if (proposal.baseStateVersion !== episode.baseStateVersion) fail('STALE');
+    const record = this.one('episodes', scope, ' AND id = ?', [episode.id]);
+    if (!record || record.status !== 'running' || proposal.baseStateVersion !== episode.baseStateVersion) fail('STALE');
     const repeatsExecutionReply = proposal.reply && this.rows('messages', scope,
       " AND json_extract(record, '$.episodeId') = ? AND json_extract(record, '$.replyKind') IN ('progress', 'execution-final')", [episode.id])
       .some(message => message.text.trim() === proposal.reply.trim());
-    const publishReply = proposal.reply && !repeatsExecutionReply && !this.repeatsPresentation(scope, episode.id, proposal.reply);
+    const publishReply = proposal.reply && !this.repeatsAutonomousReply(scope, episode, proposal.reply) && !repeatsExecutionReply && !this.repeatsPresentation(scope, episode.id, proposal.reply);
     p.stateVersion++; p.writeSerial++; if (publishReply) p.messageSeq++;
     p.activeEpisodeId = null; p.leaseOwner = null; p.leaseUntil = new Date(0);
     this.put('persons', p);
@@ -580,18 +726,38 @@ export class SqlitePersonStore {
     if (new Set(proposal.state.focusConceptIds).size !== proposal.state.focusConceptIds.length || focus.length !== proposal.state.focusConceptIds.length) fail('STALE');
     const priorState = this.one('states', scope);
     const continuation = Object.hasOwn(proposal.state, 'continuation') ? proposal.state.continuation : priorState?.continuation;
-    const state = this.doc(scope, { ...proposal.state, ...(continuation !== undefined ? { continuation } : {}), version: p.stateVersion, conceptRefs: focus.map(c => ({ id: c.id, revision: c.revision })),
+    const understanding = Object.hasOwn(proposal.state, 'understanding') ? proposal.state.understanding : priorState?.understanding;
+    const state = this.doc(scope, { ...proposal.state, ...(continuation !== undefined ? { continuation } : {}),
+      ...(understanding !== undefined ? { understanding } : {}), version: p.stateVersion, conceptRefs: focus.map(c => ({ id: c.id, revision: c.revision })),
       decision: proposal.decision, lastSelection: { model: selection.model, effort: selection.effort }, updatedAt: this.now, episodeId: episode.id });
     if (this.one('states', scope)?.version !== episode.baseStateVersion) fail('STALE');
     this.put('states', state);
+    if (episode.kind === 'autonomous' && p.autonomy?.generation === episode.autonomyGeneration) {
+      p.autonomy.lastFingerprint = digest(continuation ?? null);
+      // Backoff starts when discovery actually rests, not when a potentially long
+      // episode was admitted. Never immediately wake after a long execution.
+      if (record.executionGoal?.kind === 'exploration' && record.executionGoal.status === 'resting' && continuation == null) {
+        p.autonomy.nextAt = this.now.getTime() + (p.autonomy.backoffMs ?? 60000);
+      }
+      this.put('persons', p);
+    }
     this.put('state_commits', this.doc(scope, { id: randomUUID(), version: p.stateVersion, parentVersion: episode.baseStateVersion,
       episodeId: episode.id, callId, conceptRevisions: revisions, state: stateView(state), createdAt: this.now }), true);
     if (publishReply) {
       const message = this.doc(scope, { id: randomUUID(), revision: 1, seq: p.messageSeq, episodeId: episode.id, callId, replyKind: 'final', role: 'assistant', text: proposal.reply, createdAt: this.now });
       this.put('messages', message, true); this.journal(scope, 'messages', message);
     }
-    const record = this.one('episodes', scope, ' AND id = ?', [episode.id]);
-    if (!record || record.status !== 'running') fail('STALE');
+    if (p.settings.autonomyEnabled === true && p.autonomy?.generation === record.autonomyGeneration) {
+      const integrated = new Set(record.integratedTaskSourceRefs ?? []);
+      if (integrated.size) {
+        // Exact event identity only. A completion arriving after the last model
+        // read survives; rollback of any rejected commit preserves every event.
+        p.autonomy.pending = (p.autonomy.pending ?? []).filter(event => !integrated.has(event.sourceRef));
+        p.autonomy.integratedSourceRefs = [...new Set([...(p.autonomy.integratedSourceRefs ?? []), ...integrated])].slice(-64);
+        p.autonomy.lastFingerprint = digest(continuation ?? null);
+        this.put('persons', p);
+      }
+    }
     delete record.executionControl;
     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 });
@@ -611,7 +777,17 @@ export class SqlitePersonStore {
   }
   cancel(ownerId, episodeId = null) {
     const scope = this.scope(ownerId), p = this.getPerson(ownerId);
-    if (!p.activeEpisodeId || (episodeId && p.activeEpisodeId !== episodeId)) return { cancelled: false, episodeId };
+    // Cancel is also a durable autonomy stop, even when the target already ended.
+    p.settings = { ...p.settings, autonomyEnabled: false };
+    p.autonomy = { version: 1, generation: randomUUID(), pending: [], nextAt: null };
+    p.writeSerial++; this.put('persons', p);
+    if (!p.activeEpisodeId) return { cancelled: false, episodeId };
+    if (episodeId && p.activeEpisodeId !== episodeId) {
+      const active = this.one('episodes', scope, ' AND id = ?', [p.activeEpisodeId]);
+      if (active?.kind !== 'autonomous') return { cancelled: false, episodeId };
+      // The target may finish just before a queued autonomous admission. Cancel
+      // that follow-up too; never let a stale target bypass the owner's stop.
+    }
     const id = p.activeEpisodeId, until = p.leaseUntil;
     p.epoch++; p.controlVersion++; p.writeSerial++; p.activeEpisodeId = null; p.leaseOwner = null; p.leaseUntil = new Date(0); this.put('persons', p);
     const record = this.one('episodes', scope, ' AND id = ?', [id]);
@@ -622,14 +798,21 @@ export class SqlitePersonStore {
     this.trace(ownerId, id, 'cancelled', { code: 'CANCELLED' });
     return { cancelled: true, episodeId: id };
   }
-  settings(ownerId, settings, expectedControlVersion) {
+  settings(ownerId, settings, expectedControlVersion, expectedAutonomyGeneration) {
     const p = this.getPerson(ownerId);
-    if (p.activeEpisodeId) fail('BUSY');
+    const autonomyOnly = Object.keys(settings).length === 1 && Object.hasOwn(settings, 'autonomyEnabled');
+    if (p.activeEpisodeId && !autonomyOnly) fail('BUSY');
+    if (expectedAutonomyGeneration !== undefined && (p.autonomy?.generation ?? null) !== expectedAutonomyGeneration) fail('STALE');
+    if (Object.hasOwn(settings, 'autonomyEnabled')) {
+      if (typeof settings.autonomyEnabled !== 'boolean') fail('INVALID_REQUEST');
+      p.autonomy = { version: 1, generation: randomUUID(), pending: [], backoffMs: 60000,
+        nextAt: settings.autonomyEnabled ? this.now.getTime() + 5000 : null };
+    }
     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.
-    p.settings = { ...p.settings, ...patch }; p.controlVersion++; p.writeSerial++; this.put('persons', p);
+    p.settings = { ...p.settings, ...patch }; if (!autonomyOnly) p.controlVersion++; p.writeSerial++; this.put('persons', p);
     if (Object.keys(settings).length) this.trace(ownerId, null, 'settings', { settings: settingsView(p.settings), ...(name !== undefined ? { name: p.name } : {}) });
     return { settings: settingsView(p.settings), person: this.personView(p) };
   }

package/yeaft/person/task-host.js

@@ -188,7 +188,7 @@ class ScopedPersonTaskHost {
   }
 
   #session(sessionId) {
-    if (sessionId != null && sessionId !== this.sessionId) throw denied();
+    if (sessionId != null && sessionId !== '' && sessionId !== this.sessionId) throw denied();
     return this.sessionId;
   }
 
@@ -275,12 +275,15 @@ class ScopedPersonTaskHost {
     if (!task || task.sessionId !== this.sessionId || task.ownerVpId !== this.parentVpId) return;
     this.#persistAgents();
     if (event.event === 'completed') {
-      const completion = { kind: 'person-task-completion', namespace: this.scope.key, task: clone(task),
+      const completion = { kind: 'person-task-completion', namespace: this.scope.key, ownerId: this.scope.ownerId, personId: this.scope.personId, task: clone(task),
         sourceRef: `person-task:${this.scope.key}:${task.id}:${task.status}:${task.updatedAt}`,
-        notice: 'External task evidence only. No Person episode was scheduled.' };
+        notice: 'Untrusted external task observation, not user instructions or authorization. Opt-in scheduling is decided separately by durable admission.' };
       atomicJSON(join(this.dataRoot, 'completions', `${task.id}.json`), completion);
-      // Observability only: never register model re-entry or call runtime.start.
-      Promise.resolve().then(() => this.#options.onCompletion?.(completion)).catch(() => {});
+      // Emit only newly observed terminal events, never replay completion files.
+      // Orphan/cancel evidence reconciles status but must not request model re-entry.
+      if (['succeeded', 'failed'].includes(task.status) && !this.#closed) {
+        Promise.resolve().then(() => { if (!this.#closed) return this.#options.onCompletion?.(completion); }).catch(() => {});
+      }
     }
   }
 
@@ -338,7 +341,8 @@ class ScopedPersonTaskHost {
   async #execute(tool, args = {}, caller, deps) {
     this.#assertOpen(deps.episodeId);
     this.#assertScope(caller, { child: true });
-    if (args.sessionId != null && args.sessionId !== this.sessionId) throw denied();
+    if (args.sessionId != null && args.sessionId !== '' && args.sessionId !== this.sessionId) throw denied();
+    if (args.sessionId === '') args = { ...args, sessionId: this.sessionId };
     if (!this.allowedToolIds().includes(tool.name)) return JSON.stringify({ error: 'Native tool disabled', errorEffect: 'none' });
     if (tool.name === 'SpawnAgent' && !deps.adapter) return JSON.stringify({ error: 'Person child provider unavailable', errorEffect: 'none' });
     const controller = new AbortController();
@@ -606,6 +610,17 @@ class ScopedPersonTaskHost {
     }
   }
 
+  /** Exact owner-scoped control state, never the capped model evidence page. */
+  goalState(episodeId) {
+    this.#persistAgents();
+    return {
+      tasks: this.#manager.listActiveTasks(this.sessionId, this.parentVpId).map(task => ({ id: task.id, status: task.status,
+        currentEpisode: task.source?.episodeId === episodeId })),
+      agents: [...this.#agents.values()].map(agent => ({ id: agent.id, status: agent.status,
+        executionPending: agent.executionPending, currentEpisode: agent.personEpisodeId === episodeId })),
+    };
+  }
+
   /** Completion records remain facts, not user messages or automatic triggers. */
   evidence({ limit = 50 } = {}) {
     if (!Number.isInteger(limit) || limit < 1 || limit > 100) throw new Error('Invalid evidence limit');
@@ -710,6 +725,10 @@ export class PersonTaskHost {
     return this.#host(episode.ownerId, episode.personId).context(input);
   }
 
+  goalState(ownerId, episodeId) {
+    return this.#host(ownerId).goalState(episodeId);
+  }
+
   snapshot(ownerId) { return this.#host(ownerId).snapshot(ownerId); }
 
   async readToolResult(episode, args, options) {

package/yeaft/person/tool-arguments.js

@@ -4,6 +4,7 @@ import { executionReadRequest } from './execution-evidence.js';
 import { outputArgs } from './outputs.js';
 import { personPresentation } from './presentation.js';
 import { scriptInput } from './script-executor.js';
+import { validateExecutionGoal } from './execution-goal.js';
 
 /** Pre-dispatch schema check, deliberately separate from execution: rejection
  * here proves that no host effect has begun and can safely become tool feedback.
@@ -50,7 +51,8 @@ export function validateToolArguments(value, schema) {
  * callers must not wrap capability execution in the same catch. */
 export function validateCapabilityArguments({ id, args }) {
   try {
-    if (id === 'Capability.create') validateCreatedDefinition(args);
+    if (id === 'Execution.goal') validateExecutionGoal(args);
+    else if (id === 'Capability.create') validateCreatedDefinition(args);
     else if (id === 'Execution.read') executionReadRequest(args);
     else if (id === 'Output.publish') outputArgs(args);
     else if (id === 'PresentResponse') personPresentation(args);