@yeaft/webchat-agent 1.0.610 → 1.0.612

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "1.0.610",
+  "version": "1.0.612",
   "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/contracts.js

@@ -1,7 +1,10 @@
 import { createHash } from 'node:crypto';
 
 // 只允许应用层显式产物；不要求或保存 provider 的隐藏推理。
-export const LIMITS = Object.freeze({ inputBytes: 8192, outputBytes: 65536, contextBytes: 65536, calls: 16, timeoutMs: 120000, leaseMs: 15000 });
+export const LIMITS = Object.freeze({ inputBytes: 8192, outputBytes: 65536, contextBytes: 65536, calls: 16, leaseMs: 15000 });
+// Feedback cadence is not an execution deadline. Slow providers/tools remain cancellable.
+export const FEEDBACK = Object.freeze({ minMs: 30000, maxMs: 60000 });
+export const FEEDBACK_INSTRUCTIONS = "feedback describes user-visible communication, not a deadline. After about 30 seconds without a substantive reply, use reply for a concise, useful progress update at a natural execution boundary; aim for 30\u201360 seconds according to actual progress. Explain verified findings, limitations and what you are checking next, in the user's language. Do not repeat feedback.lastReply, invent progress, expose internal deliberation/decision/selfCheck, or claim an unexecuted tool succeeded. If no meaningful update exists, reply:null is appropriate; the host shows an honest waiting status around 60 seconds without interrupting the current request. With next non-null, a validated reply may be published as progress independently of cognitive state, and retained on cancellation/failure. Only next:null commits cognition and supplies the final reply. Do not call a tool or an extra model just to report progress. Each final reply should stand on its own and note unfinished work.";
 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.',

package/yeaft/person/inspection.js

@@ -20,7 +20,7 @@ export function personName(value) {
 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', 'defaultModel']);
 export function messageView(value) {
-  const result = pick(value, ['id', 'schemaVersion', 'revision', 'seq', 'episodeId', 'clientMessageId', 'role', 'text', 'createdAt']);
+  const result = pick(value, ['id', 'schemaVersion', 'revision', 'seq', 'episodeId', 'clientMessageId', 'callId', 'replyKind', '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;

package/yeaft/person/runtime.js

@@ -1,16 +1,17 @@
 import { createPersonToolHost, createPersonNativeRegistry, isNativeTool, projectNativeResult } from './native-tools.js';
 import { PersonTaskHost } from './task-host.js';
 import { randomUUID } from 'node:crypto';
+import { utf8PrefixWithinBytes } from '../utf8.js';
 import { CAPABILITY_MAP, CAPABILITY_LIMITS, foundationCapabilities, PersonCapabilities, catalogRevision as capabilityCatalogRevision } from './capabilities.js';
 import { attachmentMetadata } from './attachments.js';
 import { abortable, collectOutput } from './provider.js';
-import { bytes, digest, fail, LIMITS, PersonError, PROPOSAL_INSTRUCTIONS, reportedLineage, safeError, validateProposal, validateSelection } from './contracts.js';
+import { bytes, digest, fail, FEEDBACK, FEEDBACK_INSTRUCTIONS, LIMITS, PersonError, PROPOSAL_INSTRUCTIONS, reportedLineage, safeError, validateProposal, validateSelection } from './contracts.js';
 
 const messageRef = m => `message:${m.id}:${m.revision}`;
 const conceptRef = c => `concept:${c.id}:${c.revision}`;
 
 /** Assemble bounded request copies. Omitting a record never deletes or truncates its durable original. */
-export function assembleContext({ snapshot, episode, provider, selection, previous, capabilityResult, remainingCalls, taskEvidence, dependencyRefs = [], activeCapabilities = foundationCapabilities(), capabilityMap = CAPABILITY_MAP, attachments = [], environment }) {
+export function assembleContext({ snapshot, episode, provider, selection, previous, capabilityResult, remainingCalls, taskEvidence, dependencyRefs = [], activeCapabilities = foundationCapabilities(), capabilityMap = CAPABILITY_MAP, attachments = [], environment, feedback }) {
   const model = validateSelection(selection, provider.catalog);
   // UTF-8 bytes is a conservative text-token bound; reserve explicit envelope/output overhead.
   const images = attachments.filter(file => file.kind === 'image');
@@ -74,6 +75,16 @@ export function assembleContext({ snapshot, episode, provider, selection, previo
       omittedCapabilities.push({ id: contract.id, reason: 'context-budget', inspect: 'catalog.view' });
     }
   }
+  // Feedback is a request-only hint, never grounds to fail the next call.
+  // Keep durable replies intact; avoid duplicating up to 8 KiB from previousProposal.
+  if (feedback) {
+    const preview = utf8PrefixWithinBytes(feedback.lastReply ?? '', 512).text;
+    context.feedback = { ...feedback, instructions: FEEDBACK_INSTRUCTIONS, lastReply: preview || null,
+      lastReplyTruncated: bytes(feedback.lastReply ?? '') > bytes(preview) };
+    if (!fits()) { context.feedback.lastReply = null; context.feedback.lastReplyTruncated = Boolean(feedback.lastReply); }
+    if (!fits()) delete context.feedback.instructions;
+    if (!fits()) delete context.feedback;
+  }
   const add = (field, item, ref) => {
     if (renderedRefs.has(ref)) return;
     const inherited = sourceRefs.has(ref);
@@ -189,8 +200,8 @@ export class PersonRuntime {
   isOwnerRunning(ownerId) { return this.pendingCancellations.has(ownerId) || [...this.running.values()].some(job => job.episode.ownerId === ownerId); }
   async run(episode, controller) {
     const { signal } = controller;
-    const timeout = setTimeout(() => controller.abort(new PersonError('TIMEOUT')), episode.budget.timeoutMs);
-    timeout.unref?.();
+    let lastReplyAt = new Date(episode.createdAt).getTime() || Date.now();
+    let lastReply = null;
     let heartbeatRunning = false;
     const heartbeat = setInterval(async () => {
       if (heartbeatRunning || signal.aborted) return;
@@ -198,7 +209,7 @@ export class PersonRuntime {
       try { await this.repository.heartbeat(episode); }
       catch (error) { controller.abort(safeError(error)); }
       finally { heartbeatRunning = false; }
-    }, Math.max(100, Math.floor(this.repository.leaseMs / 3)));
+    }, Math.max(100, Math.min(5000, Math.floor(this.repository.leaseMs / 3))));
     heartbeat.unref?.();
     try {
       const provider = await abortable(this.getProvider(episode.modelCandidates ?? [], episode.defaultModel ?? null), signal);
@@ -232,7 +243,11 @@ export class PersonRuntime {
       for (let index = 0; index < episode.budget.calls; index++) {
         signal.throwIfAborted();
         const callId = randomUUID();
-        const context = assembleContext({ snapshot, episode, provider, selection, previous, capabilityResult, dependencyRefs, remainingCalls: episode.budget.calls - index, taskEvidence: projectTaskEvidence(this.tasks()?.snapshot(episode.ownerId)), attachments, activeCapabilities: capabilities.context(), capabilityMap: capabilities.catalog(), environment: toolHost.environment });
+        const context = assembleContext({ snapshot, episode, provider, selection, previous, capabilityResult, dependencyRefs, remainingCalls: episode.budget.calls - index, taskEvidence: projectTaskEvidence(this.tasks()?.snapshot(episode.ownerId)), attachments, activeCapabilities: capabilities.context(), capabilityMap: capabilities.catalog(), environment: toolHost.environment, feedback: {
+          minIntervalMs: FEEDBACK.minMs, maxIntervalMs: FEEDBACK.maxMs,
+          elapsedSinceReplyMs: Math.max(0, Date.now() - lastReplyAt),
+          due: Date.now() - lastReplyAt >= FEEDBACK.minMs, lastReply,
+        } });
         capabilities.activate(context.activeCapabilities);
         dependencyRefs = context.manifest.inputDependencyRefs;
         for (const [id, concept] of context.concepts) readConcepts.set(id, concept);
@@ -289,6 +304,11 @@ export class PersonRuntime {
           await this.repository.commit(episode, proposal, selection, callId, new Map(proposal.concepts.map(c => [c.id, c.epistemicState === 'reported' ? reportedLineage(c, readSources) : []])));
           return;
         }
+        if (proposal.reply) {
+          signal.throwIfAborted();
+          const published = await this.repository.publishProgress(episode, { callId, reply: proposal.reply });
+          if (published) { lastReply = published.text; lastReplyAt = new Date(published.createdAt).getTime(); }
+        }
         if (index + 1 >= episode.budget.calls) {
           await this.tasks()?.cancel({ ownerId: episode.ownerId, episodeId: episode.id, reason: 'CALL_BUDGET' });
           await this.repository.finish(episode, 'budget_exhausted', 'CALL_BUDGET');
@@ -345,7 +365,7 @@ export class PersonRuntime {
       // On authority failure no alternate memory store is used. Expired leases become durable interrupted records on next access.
       await this.repository.finish(episode, status, safe.code).catch(() => {});
     } finally {
-      clearTimeout(timeout); clearInterval(heartbeat);
+      clearInterval(heartbeat);
       if (!signal.aborted) controller.abort(new PersonError('INTERRUPTED'));
     }
   }

package/yeaft/person/service.js

@@ -22,9 +22,9 @@ export function createPersonService(options = {}) {
   identifier(namespace);
   const configured = typeof yeaftDir === 'string' && Boolean(yeaftDir.trim());
   const calls = options.maxCalls ?? LIMITS.calls;
-  const timeoutMs = options.timeoutMs ?? LIMITS.timeoutMs;
+  // Legacy timeoutMs is intentionally ignored: an episode has no wall-clock deadline.
   const leaseMs = options.leaseMs ?? LIMITS.leaseMs;
-  if (!Number.isInteger(calls) || calls < 1 || calls > 32 || !Number.isInteger(timeoutMs) || timeoutMs < 100 || timeoutMs > 300000 ||
+  if (!Number.isInteger(calls) || calls < 1 || calls > 32 ||
       !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 ? new SqlitePersonRepository({ yeaftDir, namespace, leaseMs }) : null;
@@ -43,7 +43,7 @@ export function createPersonService(options = {}) {
     ? memory.recall(ownerId, args, { signal }) : literalRecall(ownerId, args);
   // Config/adapter are loaded per explicit episode, not a permanent stale cache.
   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 });
+  const runtime = new PersonRuntime({ repository, getProvider, budget: { calls }, workDir, yeaftDir, config, namespace });
   let closed = false;
   const requests = new Set();
   async function handle({ ownerId, op, payload = {} } = {}) {

package/yeaft/person/sqlite-repository.js

@@ -100,6 +100,7 @@ export class SqlitePersonRepository {
   async episodeAttachments(episode) { return this.request('episodeAttachments', [episode]); }
   async context(episode) { return this.request('context', [episode]); }
   async recall(ownerId, options) { return this.request('recall', [ownerId, options]); }
+  async publishProgress(episode, data) { return this.request('publishProgress', [episode, data]); }
   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]); }

package/yeaft/person/sqlite-store.js

@@ -3,7 +3,7 @@ import { mkdirSync } from 'node:fs';
 import { dirname } from 'node:path';
 import { randomUUID } from 'node:crypto';
 import { isMainThread } from 'node:worker_threads';
-import { admissionReceipt, bytes, digest, fail, identifier, LIMITS, PersonError, text } from './contracts.js';
+import { admissionReceipt, bytes, digest, fail, FEEDBACK, identifier, LIMITS, PersonError, text } from './contracts.js';
 import { CREATED_CAPABILITY_LIMITS, createdCapabilityRecord, validateCreatedCapability } from './created-capability-contract.js';
 import { SCHEMA, TABLES } from './sqlite-schema.js';
 import { attachmentMetadata, attachmentRequestHash, validateFiles } from './attachments.js';
@@ -53,7 +53,7 @@ const publicOutput = (output, failed) => {
     : { text: output.text, bytes: retainedBytes, complete: true, usage, stopReason };
 };
 const READS = new Set(['receipt', 'turns', 'inspect', 'search', 'getPerson', 'context', 'recall', 'list', 'searchChanges', 'resolveMemories', 'createdCapabilities', 'episodeAttachments']);
-const WRITES = new Set(['open', 'recover', 'admit', 'heartbeat', 'append', 'startCall', 'finalizeCall', 'startCapability', 'finalizeCapability', 'commit', 'finish', 'cancel', 'settings', 'snapshot', 'saveCreatedCapability']);
+const WRITES = new Set(['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 => {
@@ -257,6 +257,17 @@ export class SqlitePersonStore {
   own(episode) { const p = this.fenced(episode); if (!p) fail('STALE'); return p; }
   heartbeat(episode) {
     const p = this.own(episode); p.leaseUntil = new Date(this.now.getTime() + this.leaseMs); p.writeSerial++; this.put('persons', p);
+    const record = this.one('episodes', this.episodeScope(episode), ' AND id = ?', [episode.id]);
+    if (!record || record.status !== 'running') fail('STALE');
+    const lastAt = new Date(record.feedback?.at ?? record.lastReplyAt ?? record.createdAt).getTime();
+    // Heartbeats are at most 5s apart: publish the fallback between 55–60s.
+    // This updates one snapshot field, never adds messages or schedules cognition.
+    if (this.now.getTime() - lastAt >= FEEDBACK.maxMs - 5000 || record.feedback) {
+      const phase = record.openCall ? 'model' : record.openCapability ? 'capability' : 'preparing';
+      record.feedback = { at: this.now.getTime() - lastAt >= FEEDBACK.maxMs - 5000 ? this.now.toISOString() : record.feedback.at, phase };
+      if (phase === 'capability') record.feedback.capabilityId = record.openCapability.capability?.id;
+      this.put('episodes', record);
+    }
   }
   append(episode, kind, data) {
     // Call proof/publication events are emitted only by their transactional methods.
@@ -366,6 +377,32 @@ export class SqlitePersonStore {
       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()] };
   }
+  /** Publish only a validated, complete call's reply. This is communication, not
+   * a state/Concept commit. Fencing, dedupe and the memory journal share one transaction. */
+  publishProgress(episode, { callId, reply }) {
+    const p = this.own(episode), scope = this.episodeScope(episode);
+    identifier(callId); text(reply, 8192);
+    const record = this.one('episodes', scope, ' AND id = ?', [episode.id]);
+    if (!record || record.status !== 'running' || record.openCall || record.openCapability) fail('STALE');
+    const prior = this.rows('messages', scope, " AND json_extract(record, '$.episodeId') = ? AND json_extract(record, '$.replyKind') = 'progress'", [episode.id]);
+    const duplicate = prior.find(m => m.callId === callId);
+    if (duplicate) { if (duplicate.text !== reply) fail('INVALID_REQUEST'); return messageView(duplicate); }
+    const proof = this.one('traces', scope, " AND json_extract(record, '$.episodeId') = ? AND json_extract(record, '$.kind') = 'call_output' AND json_extract(record, '$.callId') = ? AND json_extract(record, '$.output.complete') = 1", [episode.id, callId]);
+    const accepted = this.one('traces', scope, " AND json_extract(record, '$.episodeId') = ? AND json_extract(record, '$.kind') = 'activity' AND json_extract(record, '$.callId') = ? AND json_extract(record, '$.disposition') = 'candidate'", [episode.id, callId]);
+    let proposal;
+    try { proposal = JSON.parse(proof?.output?.text); } catch { fail('INVALID_REQUEST'); }
+    if (!accepted || !proposal.next || proposal.reply !== reply) fail('INVALID_REQUEST');
+    // Provider latency counts too: a call started before 30s can finish after it.
+    if (this.now.getTime() - new Date(record.lastReplyAt ?? record.createdAt).getTime() < FEEDBACK.minMs ||
+        prior.some(m => m.text.trim() === reply.trim())) 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: 'progress', role: 'assistant', text: reply, createdAt: this.now });
+    this.put('messages', message, true); this.journal(scope, 'messages', message);
+    record.lastReplyAt = this.now.toISOString(); delete record.feedback; this.put('episodes', record);
+    this.trace(episode.ownerId, episode.id, 'progress_reply', { callId, messageId: message.id });
+    return messageView(message);
+  }
   commit(episode, proposal, selection, callId, reportedSources = new Map()) {
     const p = this.own(episode), scope = this.episodeScope(episode);
     if (proposal.baseStateVersion !== episode.baseStateVersion) fail('STALE');
@@ -391,7 +428,7 @@ export class SqlitePersonStore {
     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 (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 });
+      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]);
@@ -504,7 +541,8 @@ export class SqlitePersonStore {
     const scope = this.scope(ownerId), p = this.getPerson(ownerId), state = this.one('states', scope);
     const messages = this.rows('messages', scope, ' ORDER BY seq DESC LIMIT 21');
     const episode = this.one('episodes', scope, ' ORDER BY inputWatermark DESC');
-    const latestEpisode = episode ? { id: episode.id, status: episode.status,
+    const latestEpisode = episode ? { id: episode.id, status: episode.status, createdAt: episode.createdAt,
+      ...(episode.status === 'running' && episode.feedback ? { feedback: episode.feedback } : {}),
       ...(episode.terminalCode ? { terminalCode: episode.terminalCode } : {}), ...(episode.endedAt ? { endedAt: episode.endedAt } : {}) } : 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,