@yeaft/webchat-agent 1.0.634 → 1.0.636

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "1.0.634",
+  "version": "1.0.636",
   "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/conversation/search.js

@@ -38,8 +38,14 @@ function searchableContent(msg) {
   return '';
 }
 
-function matchesMessage(msg, terms) {
+function matchesMessage(msg, terms, source, boundary) {
   if (!msg || msg.role === 'tool' || !isVisibleConversationRow(msg)) return false;
+  // Sequence numbers belong to the source Session, not to a sibling transcript
+  // (or a row's optional sessionId). Filter before counting toward any limit.
+  if (boundary && source.sessionId === boundary.sessionId) {
+    const seq = Number.isFinite(msg.seq) ? msg.seq : parseSeqFromId(msg.id);
+    if (Number.isFinite(seq) && seq >= boundary.beforeSeq) return false;
+  }
   const content = searchableContent(msg).toLocaleLowerCase();
   return content.length > 0 && terms.every(term => content.includes(term));
 }
@@ -59,7 +65,7 @@ function withSource(msg, source) {
   return {
     ...publicMessage,
     content: searchableContent(msg),
-    sessionId: msg.sessionId || source.sessionId || null,
+    sessionId: source.sessionId || msg.sessionId || null,
     historySource: source.kind,
   };
 }
@@ -67,7 +73,7 @@ function withSource(msg, source) {
 /**
  * Search Markdown messages in one directory, newest first.
  */
-function searchMarkdownDir(dir, terms, limit, source, telemetry) {
+function searchMarkdownDir(dir, terms, limit, source, telemetry, boundary) {
   if (!existsSync(dir)) return [];
 
   const files = readdirSync(dir)
@@ -84,12 +90,12 @@ function searchMarkdownDir(dir, terms, limit, source, telemetry) {
     const lowerRaw = raw.toLocaleLowerCase();
     if (!terms.every(term => lowerRaw.includes(term))) continue;
     const msg = parseMessage(raw);
-    if (matchesMessage(msg, terms)) results.push(withSource(msg, source));
+    if (matchesMessage(msg, terms, source, boundary)) results.push(withSource(msg, source));
   }
   return results;
 }
 
-function searchSegmentDir(dir, terms, limit, source, telemetry) {
+function searchSegmentDir(dir, terms, limit, source, telemetry, boundary) {
   if (!existsSync(dir)) return [];
   const files = readdirSync(dir)
     .filter(f => f.endsWith('.jsonl'))
@@ -109,7 +115,7 @@ function searchSegmentDir(dir, terms, limit, source, telemetry) {
       if (!lines[i]?.trim()) continue;
       recordMessageScan(telemetry);
       const msg = parseJsonLine(lines[i]);
-      if (matchesMessage(msg, terms)) results.push(withSource(msg, source));
+      if (matchesMessage(msg, terms, source, boundary)) results.push(withSource(msg, source));
     }
   }
   return results;
@@ -154,7 +160,10 @@ function sessionConversationDirs(dir) {
  * @param {string} dir — Yeaft root directory (e.g. ~/.yeaft)
  * @param {string} keyword — search terms
  * @param {number} [limit=10] — max results
- * @param {{telemetry?: {scannedFiles?: number, scannedBytes?: number, scannedMessages?: number}, sessionIds?: string[]}} [options]
+ * @param {{telemetry?: {scannedFiles?: number, scannedBytes?: number, scannedMessages?: number}, sessionIds?: string[], boundarySessionId?: string, beforeSeq?: number, beforeMessageId?: string}} [options]
+ *   A trusted exclusive boundary applies only to boundarySessionId's transcript.
+ *   Finite beforeSeq takes precedence over a monotonic beforeMessageId. Without
+ *   a valid boundary, legacy search behavior is preserved.
  * @returns {object[]} — matching messages, newest first
  */
 export function searchMessages(dir, keyword, limit = 10, options = {}) {
@@ -169,6 +178,13 @@ export function searchMessages(dir, keyword, limit = 10, options = {}) {
     telemetry.scannedMessages = 0;
   }
 
+  const beforeSeq = Number.isFinite(options.beforeSeq)
+    ? options.beforeSeq
+    : parseSeqFromId(options.beforeMessageId);
+  const boundary = typeof options.boundarySessionId === 'string' && options.boundarySessionId && Number.isFinite(beforeSeq)
+    ? { sessionId: options.boundarySessionId, beforeSeq }
+    : null;
+
   const requestedSessionIds = Array.isArray(options.sessionIds)
     ? new Set(options.sessionIds.filter(id => typeof id === 'string' && id.trim()).map(id => id.trim()))
     : null;
@@ -191,8 +207,8 @@ export function searchMessages(dir, keyword, limit = 10, options = {}) {
   const segmentDirs = conversationDirs.map(source => ({ ...source, dir: join(source.dir, 'segments') }));
 
   const results = [
-    ...segmentDirs.flatMap(source => searchSegmentDir(source.dir, terms, resultLimit, source, telemetry)),
-    ...markdownDirs.flatMap(source => searchMarkdownDir(source.dir, terms, resultLimit, source, telemetry)),
+    ...segmentDirs.flatMap(source => searchSegmentDir(source.dir, terms, resultLimit, source, telemetry, boundary)),
+    ...markdownDirs.flatMap(source => searchMarkdownDir(source.dir, terms, resultLimit, source, telemetry, boundary)),
   ]
     .sort(compareNewest)
     .slice(0, resultLimit);

package/yeaft/engine.js

@@ -18,6 +18,7 @@
  */
 
 import { randomUUID, createHash } from 'crypto';
+import { QueryProgress, progressReminder } from './query-progress.js';
 import { promises as fsp } from 'fs';
 import { join, resolve as resolvePath } from 'path';
 import { buildSystemPrompt, buildWorkerPrompt } from './prompts.js';
@@ -1442,6 +1443,8 @@ export class Engine {
       signal,
       effortDecision: snapshotEffortDecision(vpCtx?.effortDecision),
       requestIdentity: vpCtx?.requestIdentity,
+      queryTurnId: vpCtx?.queryTurnId,
+      historyBeforeSeq: vpCtx?.historyBeforeSeq,
       yeaftDir: this.#yeaftDir,
       managedCliReady: this.#managedCliReady,
       runtimePlatform: getRuntimePlatformInfo(),
@@ -2122,6 +2125,16 @@ export class Engine {
     const effortConstraint = isSubAgent || scenario === 'sub_agent' || vpPersona?.subAgent
       ? Object.freeze({ parentDecision: snapshotEffortDecision(parentEffortDecision) }) : null;
     const queryStartedAt = Date.now();
+    const queryProgress = new QueryProgress();
+    const progressIdentity = { turnId: queryTurnId, threadId: runtimeThreadId, sessionId: runtimeSessionId, vpId: requestIdentity.vpId };
+    let progressReportPending = false;
+    const resetProgressEvidence = () => {
+      queryProgress.resetEvidence();
+      progressReportPending = false;
+    };
+    const syncProgressInput = (items) => {
+      if (items.some(item => !item.internal || item.taskId)) resetProgressEvidence();
+    };
     const userQuestionPreview = String(prompt || '').slice(0, 200);
     const queryVpId = vpPersona && typeof vpPersona === 'object'
       && typeof vpPersona.vpId === 'string'
@@ -2152,7 +2165,10 @@ export class Engine {
     const readOnlyToolReuseOwner = this.#currentAbortCtrl;
     this.#activeReadOnlyToolReuse = {
       owner: readOnlyToolReuseOwner,
-      invalidate: invalidateReadOnlyToolReuse,
+      invalidate: () => {
+        invalidateReadOnlyToolReuse();
+        resetProgressEvidence();
+      },
     };
 
     // Durability boundary: a valid user turn must exist on disk before any
@@ -2833,6 +2849,7 @@ export class Engine {
       const currentContextWindow = resolveContextWindow(currentModel, requestConfig);
 
       const appendedBeforeStream = this.#drainPendingUserMessages(drainPendingUserMessages);
+      syncProgressInput(appendedBeforeStream);
       if (appendedBeforeStream.length > 0) {
         for (const item of appendedBeforeStream) {
           this.#persistAppendedUserMessage(item, runtimeSessionId);
@@ -2853,6 +2870,7 @@ export class Engine {
         // this query was parked. Its task-result update is the authoritative
         // synchronization point before the next provider loop.
         invalidateReadOnlyToolReuse();
+        resetProgressEvidence();
       }
       if (taskResultUpdatesBeforeStream.length > 0) {
         for (const update of taskResultUpdatesBeforeStream) {
@@ -2887,7 +2905,8 @@ export class Engine {
       // tool-free response for a useful handoff, under the existing signal.
       const executionPolicy = isSubAgent
         ? this.#toolRegistry?.prepareProviderRequest?.() : null;
-      if (executionPolicy?.finalize) toolDefs = [];
+      const progressReporting = progressReportPending;
+      if (executionPolicy?.finalize || progressReporting) toolDefs = [];
       ({ resolvedSkillContent, resolvedSkills, skillResolutionError } = resolveSkillPromptState({
         skillManager: this.#skillManager,
         prompt,
@@ -2906,6 +2925,7 @@ export class Engine {
       reportedSkillError = skillResolutionError;
       systemPrompt = buildCurrentSystemPrompt();
       if (executionPolicy?.prompt) systemPrompt += `\n\n${executionPolicy.prompt}`;
+      if (progressReporting) systemPrompt += `\n\n${progressReminder('report', queryProgress.snapshot().reason)}`;
       let requestDebugMessages = [];
       let requestInputBreakdown = null;
 
@@ -3140,7 +3160,12 @@ export class Engine {
           continuationCommitted = true;
         };
         let childDispatchReserved = false;
+        let progressRequestCounted = false;
         const commitDispatch = () => {
+          if (!progressRequestCounted) {
+            queryProgress.requestStarted();
+            progressRequestCounted = true;
+          }
           if (isSubAgent && !childDispatchReserved) {
             this.#toolRegistry?.reserveProviderRequest?.({ reporting: !!executionPolicy?.finalize });
             childDispatchReserved = true;
@@ -3260,7 +3285,7 @@ export class Engine {
             case 'tool_call':
               // No dispatch or orphan protocol rows during the reserved report,
               // even if an adapter ignores the absence of tool definitions.
-              if (executionPolicy?.finalize) break;
+              if (executionPolicy?.finalize || progressReporting) break;
               if (toolCalls.length === 0) {
                 traceRequest('llm.first_tool_call', {
                   durationMs: perfNowMs() - requestPerfStart,
@@ -3505,7 +3530,7 @@ export class Engine {
         // the caller. Replaying that request would publish a duplicate call and
         // leave ambiguous execution ownership, so only pre-tool failures are
         // eligible for transparent retry or model fallback.
-        const canReplayProviderRequest = toolCalls.length === 0 && !executionPolicy?.finalize;
+        const canReplayProviderRequest = toolCalls.length === 0 && !executionPolicy?.finalize && !progressReporting;
         if (earlyIsContextOverflow && canReplayProviderRequest
           && contextOverflowRecoveryAttempts < 3) {
           contextOverflowRecoveryAttempts += 1;
@@ -3914,8 +3939,54 @@ export class Engine {
       // The reporting allowance is exactly one provider response, not another
       // investigation loop. Ignore unsolicited calls even from a noncompliant
       // adapter, and never auto-continue a truncated reporting response.
-      if (executionPolicy?.finalize) {
-        yield { type: 'turn_end', turnNumber, stopReason: 'budget_report', threadId, terminal: true };
+      yield queryProgress.snapshot(progressIdentity);
+      // Normal tool calls have already been persisted. On abort let that batch
+      // reach the skipped-result path so every call remains durably paired.
+      if (signal?.aborted && (toolCalls.length === 0 || executionPolicy?.finalize || progressReporting)) {
+        yield { type: 'aborted', reason: this.#abortReason || 'external', turnNumber, threadId };
+        yield { type: 'turn_end', turnNumber, stopReason: 'aborted', threadId, terminal: true };
+        break;
+      }
+      if (executionPolicy?.finalize || progressReporting) {
+        if (progressReporting) {
+          // An owned completion accepted during this tool-free stream resets
+          // progress. Resume at the normal pre-stream drains so both updated
+          // tool rows and folded/message deliveries reach the next request.
+          if (!progressReportPending) {
+            yield { type: 'turn_end', turnNumber, stopReason: 'async_task_continue', threadId };
+            continue;
+          }
+          // The reporting allowance cannot discard input accepted during its
+          // stream. Honor the same atomic input-close fence as normal endings.
+          let appended = this.#drainPendingUserMessages(drainPendingUserMessages);
+          if (appended.length === 0 && typeof closePendingUserInput === 'function' && !closePendingUserInput()) {
+            appended = this.#drainPendingUserMessages(drainPendingUserMessages);
+            if (appended.length === 0) throw new Error('Could not close pending user input for progress report');
+          }
+          if (appended.length > 0) {
+            syncProgressInput(appended);
+            for (const item of appended) {
+              this.#persistAppendedUserMessage(item, runtimeSessionId);
+              conversationMessages.push({ role: 'user', content: item.content });
+              yield { type: 'user_append', turnId: queryTurnId, loopNumber: turnNumber, threadId,
+                preview: String(item.preview || '').slice(0, 200), internal: Boolean(item.internal) };
+            }
+            yield { type: 'turn_end', turnNumber, stopReason: 'user_append_continue', threadId };
+            continue;
+          }
+          // No more same-turn deliveries after this decision. Later task
+          // completions must use the coordinator rescue path, not be accepted
+          // between the final report/error yields and terminal turn_end.
+          this.retireAsyncTasks('no_progress');
+          if (!responseText.trim()) {
+            const report = 'Execution paused after repeated tool results or failures without observed progress. The requested task is not confirmed complete. Review the preceding tool results and resolve the blocker before resuming.';
+            this.#persistConversationMessage({ role: 'assistant', content: report, responseKind: 'progress' }, { sessionId: runtimeSessionId, turnId: queryTurnId, model: currentModel, stopReason: 'no_progress', executionOrigin });
+            yield { type: 'text_delta', text: report, threadId };
+          }
+          if (!signal?.aborted) yield { type: 'error', error: 'Execution paused after repeated non-progress batches; task completion was not verified.', code: 'no_progress', retryable: false };
+        }
+        if (signal?.aborted) yield { type: 'aborted', reason: this.#abortReason || 'external', turnNumber, threadId };
+        yield { type: 'turn_end', turnNumber, stopReason: signal?.aborted ? 'aborted' : progressReporting ? 'no_progress' : 'budget_report', threadId, terminal: true };
         break;
       }
 
@@ -3958,6 +4029,7 @@ export class Engine {
       if (toolCalls.length === 0) {
         const appendedAfterAssistant = this.#drainPendingUserMessages(drainPendingUserMessages);
         if (appendedAfterAssistant.length > 0) {
+          syncProgressInput(appendedAfterAssistant);
           for (const item of appendedAfterAssistant) {
             this.#persistAppendedUserMessage(item, runtimeSessionId);
             conversationMessages.push({ role: 'user', content: item.content });
@@ -3987,7 +4059,8 @@ export class Engine {
       // tell the user the outcome or continue the work. Do not wait
       // for another user turn."
       if ((stopReason !== 'tool_use' || toolCalls.length === 0)
-          && this.#pendingAsyncTaskIds.size > 0
+          && (this.#pendingAsyncTaskIds.size > 0
+            || this.#pendingTaskResultUpdates.length > 0 || this.#pendingTaskResultMessages.length > 0)
           && !signal?.aborted) {
         const asyncTaskWaitTimeoutMs = this.#asyncTaskWaitTimeoutMs();
         const deferredTaskIds = [];
@@ -4047,6 +4120,7 @@ export class Engine {
             // that completed while we waited may have changed the workspace,
             // so it is the same cache synchronization boundary.
             invalidateReadOnlyToolReuse();
+            resetProgressEvidence();
             for (const update of taskResultUpdatesAfterAsyncWait) {
               yield {
                 type: 'tool_result_update',
@@ -4064,6 +4138,7 @@ export class Engine {
           }
           const appendedAfterAsyncWait = this.#drainPendingUserMessages(drainPendingUserMessages);
           if (appendedAfterAsyncWait.length > 0) {
+            syncProgressInput(appendedAfterAsyncWait);
             for (const item of appendedAfterAsyncWait) {
               this.#persistAppendedUserMessage(item, runtimeSessionId);
               conversationMessages.push({ role: 'user', content: item.content });
@@ -4095,6 +4170,7 @@ export class Engine {
           if (appendedBeforeClose.length === 0) {
             throw new Error('Could not close pending user input for terminal completion');
           }
+          syncProgressInput(appendedBeforeClose);
           for (const item of appendedBeforeClose) {
             this.#persistAppendedUserMessage(item, runtimeSessionId);
             conversationMessages.push({ role: 'user', content: item.content });
@@ -4216,6 +4292,8 @@ export class Engine {
       const toolCtx = this.#buildToolContext(signal, {
         effortDecision: snapshotEffortDecision(requestEffortDecision),
         requestIdentity,
+        queryTurnId,
+        historyBeforeSeq: Number.isFinite(persistedQueryUser?.seq) ? persistedQueryUser.seq : parseSeqFromId(persistedQueryUser?.id),
         router,
         senderVpId,
         sessionId: runtimeSessionId,
@@ -4401,6 +4479,7 @@ export class Engine {
         if (signal?.aborted) abortedDuringTools = true;
 
         if (!preparedParallelExecution && !toolBatchBarrier && !signal?.aborted
+            && !queryProgress.blocked(tc)
             && toolAllowedForRequest(tc) && isConcurrencySafeTool(this, tc.name, tc.input)
             && duplicatePolicyForCall(tc) !== 'suppress'
             && !mayMutateWorkspaceAfterReturn(this, tc.name, tc.input)) {
@@ -4409,7 +4488,7 @@ export class Engine {
             candidateIndex < toolCalls.length;
             candidateIndex += 1) {
             const candidate = toolCalls[candidateIndex];
-            if (!toolAllowedForRequest(candidate)
+            if (queryProgress.blocked(candidate) || !toolAllowedForRequest(candidate)
                 || !isConcurrencySafeTool(this, candidate.name, candidate.input)
                 || duplicatePolicyForCall(candidate) === 'suppress'
                 || mayMutateWorkspaceAfterReturn(this, candidate.name, candidate.input)) break;
@@ -4491,6 +4570,7 @@ export class Engine {
           && duplicateCallPolicy === 'suppress'
           && successfulDuplicateCount >= DUP_TOOL_THRESHOLD - 1;
         let suppressionCount = queryDuplicateSuppressions.get(duplicateCallKey) || 0;
+        const failureBlock = !readyParallelExecution && !skipped ? queryProgress.blocked(tc) : null;
 
         let output;
         let displayImages = [];
@@ -4570,6 +4650,11 @@ export class Engine {
             : `Error: unknown tool "${tc.name}"`;
           isError = true;
           yield { type: 'tool_end', id: tc.id, name: tc.name, output, isError: true, threadId: this.currentThreadId };
+        } else if (failureBlock) {
+          output = failureBlock;
+          isError = true;
+          yield { type: 'tool_start', id: tc.id, name: tc.name, input: tc.input, threadId: this.currentThreadId };
+          yield { type: 'tool_end', id: tc.id, name: tc.name, output, isError: true, suppressed: true, threadId: this.currentThreadId };
         } else if (needsProjectDocReload) {
           projectDocSource = freshProjectDocSource;
           projectDocLoadedPathHints = [...new Set([
@@ -4738,7 +4823,7 @@ export class Engine {
           ])].slice(-128);
         }
 
-        if (!skipped && !duplicateCallSuppressed && !isError && !reusedReadOnlyResult
+        if (!skipped && !duplicateCallSuppressed && !failureBlock && !isError && !reusedReadOnlyResult
             && duplicateCallPolicy !== 'allow') {
           const nextDuplicateCount = successfulDuplicateCount + 1;
           queryDuplicateCounts.set(duplicateCallKey, nextDuplicateCount);
@@ -4765,6 +4850,13 @@ export class Engine {
             `[system note] ${tc.name} rejected the same arguments twice before execution: ${validationError.slice(0, 300)}. Correct the arguments using its schema/error hint or choose a different tool. No operation was performed; repeating unchanged arguments will not help.`,
           );
         }
+        const repeatedResultCallId = queryProgress.observe({
+          call: tc, output, isError, readOnly: readOnlyTool,
+          executed: !skipped && !duplicateCallSuppressed && !failureBlock && !reusedReadOnlyResult && !readyParallelExecution?.shared && hasTool && !needsProjectDocReload,
+          reused: reusedReadOnlyResult || Boolean(readyParallelExecution?.shared),
+          skipped: skipped || needsProjectDocReload,
+          policy: duplicateCallPolicy,
+        });
         const toolDurationMs = readyParallelExecution?.durationMs ?? (Date.now() - toolStartTime);
 
         // feat-6af5f9f1 PR B: emit a structured `tool_exec` event for the
@@ -4779,7 +4871,7 @@ export class Engine {
           name: tc.name,
           durationMs: toolDurationMs,
           isError,
-          suppressed: duplicateCallSuppressed,
+          suppressed: duplicateCallSuppressed || Boolean(failureBlock),
           toolOutput: output,
           ...(reusedReadOnlyResult ? { reused: true, reusedCallId: reusedReadOnlyCallId } : {}),
           ...(skipped ? { skipped: true } : {}),
@@ -4789,7 +4881,7 @@ export class Engine {
         // 2026-05-13: feed the per-tool counters. Stays best-effort — a
         // stats sink that throws shouldn't crash the engine. `record`
         // already swallows internal write errors.
-        if (!skipped && !duplicateCallSuppressed
+        if (!skipped && !duplicateCallSuppressed && !failureBlock && !reusedReadOnlyResult && !readyParallelExecution?.shared
             && this.#toolStats && typeof this.#toolStats.record === 'function') {
           try {
             this.#toolStats.record({
@@ -4815,7 +4907,7 @@ export class Engine {
           reusedCallId: reusedReadOnlyCallId,
         });
 
-        if (!skipped && !duplicateCallSuppressed && !reusedReadOnlyResult
+        if (!skipped && !duplicateCallSuppressed && !failureBlock && !reusedReadOnlyResult && !isError
             && !readOnlyToolReuseDisabled && cacheableTool) {
           readOnlyToolResults.set(duplicateKey, {
             output,
@@ -4828,7 +4920,10 @@ export class Engine {
         // Append only the bounded copy to the model message history. Raw
         // `output` is still used for debug traces, UI events, exec-log, and
         // persistence so large tool results are not lost outside context.
-        const contextOutput = truncateToolResultIfNeeded(output, {
+        const modelOutput = repeatedResultCallId && !isError && modelImages.length === 0
+          ? `[Unchanged read result: already returned by call ${repeatedResultCallId}; reuse it instead of reading again.]\n${output}`
+          : output;
+        const contextOutput = truncateToolResultIfNeeded(modelOutput, {
           toolName: tc.name,
           language: this.#config?.language,
         });
@@ -4862,7 +4957,7 @@ export class Engine {
         // user-conversation turn), not the inner loop's turnNumber.
         // Aligns exec-log layout with dup detection lookback and the
         // T2 fallback-stub readTurn() call below.
-        if (!skipped && !duplicateCallSuppressed) {
+        if (!skipped && !duplicateCallSuppressed && !failureBlock && !reusedReadOnlyResult && !readyParallelExecution?.shared) {
           this.#execLog.append(queryNumber, buildExecLogEntry({
             loopIdx: queryToolCount,
             toolName: tc.name,
@@ -4935,6 +5030,13 @@ export class Engine {
         conversationMessages.push({ role: 'user', content: reminder });
       }
       if (pendingDupReminders.length > 0) duplicateReminderAwaitingResponse = true;
+      const progressAction = queryProgress.finishBatch();
+      yield queryProgress.snapshot(progressIdentity);
+      if (progressAction && !signal?.aborted && !endTurnRequested) {
+        const reason = queryProgress.snapshot().reason;
+        conversationMessages.push({ role: 'user', content: progressReminder(progressAction, reason) });
+        if (progressAction === 'report') progressReportPending = true;
+      }
       if (terminateAfterDuplicateBatch) {
         yield {
           type: 'error',

package/yeaft/query-progress.js

@@ -0,0 +1,201 @@
+/**
+ * Query-local loop evidence. Activity is not completion: only changed observations
+ * (including new negative reads) count as evidence. No transcript, arguments or
+ * result bodies escape this object. Polling/waiting is neutral, not stagnation or progress.
+ */
+import { createHash } from 'node:crypto';
+import { argsHashOf } from './tool-folding/exec-log.js';
+
+const MAX_ENTRIES = 1024;
+const WARNING_BATCHES = 4;
+const RECOVERY_BATCHES = 8;
+const REPORT_BATCHES = 12;
+const FAILURE_LIMIT = 3;
+const NEUTRAL_TOOLS = new Set([
+  'AskUser', 'WaitAgent', 'ListAgents', 'WaitTask', 'ListTasks', 'ReadTaskLog',
+  'PromptAgent', 'UpdateAgent', 'CloseAgent', 'PresentResponse',
+]);
+
+function boundedSet(map, key, value) {
+  map.delete(key);
+  map.set(key, value);
+  if (map.size > MAX_ENTRIES) map.delete(map.keys().next().value);
+}
+function resultHash(output) {
+  return createHash('sha256').update(typeof output === 'string' ? output : JSON.stringify(output) || '').digest('hex');
+}
+
+function failureKind(output, call, readOnly) {
+  const text = typeof output === 'string' ? output : JSON.stringify(output) || '';
+  const errorText = text.replace(/^Error:\s*/, '');
+  let contract;
+  // MCP and legacy tools throw JSON envelopes; Engine prefixes their messages
+  // with "Error: ". Preserve that contract for classification without changing
+  // the raw persisted/UI tool output.
+  try { contract = typeof output === 'string' ? JSON.parse(errorText) : output; } catch { /* legacy text errors */ }
+  // Confirmed nonzero exit is not rollback evidence. It is, however, a finished
+  // command that can be revalidated after an edit or new input, unlike a timeout
+  // or an operation whose lifecycle is still unknown.
+  if (call.name === 'Bash' && contract?.code === 'bash_exit_nonzero'
+      && contract.failureType === 'exit_nonzero' && contract.terminationConfirmed === true
+      && contract.timedOut === false && Number.isInteger(contract.exitCode)) return 'terminated_command';
+  if (contract?.errorEffect === 'unknown' || contract?.replaySafe === false) return 'uncertain';
+  // Match the registry's explicit pre-execution validation contract, not words
+  // in arbitrary messages or file paths such as /schema/validation/*.json.
+  if (contract?.code === 'invalid_arguments' && contract.errorEffect === 'none') return 'validation';
+  // A dispatched mutation without an explicit no-effect contract is unsafe to
+  // replay regardless of whether its message happens to mention a timeout.
+  if (!readOnly && contract?.errorEffect !== 'none') return 'uncertain';
+  const message = typeof contract?.error === 'string' ? contract.error : errorText;
+  if (['EPERM', 'EACCES'].includes(contract?.code)
+      || /^(?:Failed to read file:\s*)?(?:EPERM\b|EACCES\b|permission denied\b|access denied\b|forbidden\b)/i.test(message)) return 'permission';
+  // Known negative filesystem observations contain paths, not lifecycle data.
+  // Names such as /timeout/schema/ are domain evidence, never timeout signals.
+  if (readOnly && (/^(?:File not found:|ENOENT\b|Path is a directory:|Cannot read binary file:|File too large:)/i.test(message)
+      || contract?.code === 'ENOENT')) return resultHash(output);
+  if (/timed?\s*out|timeout|ECONNRESET|disconnect|socket hang up|connection closed/i.test(message)) return 'uncertain';
+  return resultHash(output);
+}
+
+export class QueryProgress {
+  #results = new Map();
+  #mutations = new Map();
+  #failures = new Map();
+  #batch = { evidence: false, repeated: false, failed: false };
+  #revision = 0;
+  #state = {
+    modelRequests: 0, toolExecutions: 0, reusedCalls: 0, repeatedCalls: 0,
+    failedCalls: 0, stage: 'running', reason: null, lastEvidenceAt: null, stagnantBatches: 0,
+  };
+
+  requestStarted() { this.#state.modelRequests += 1; }
+
+  /** Caller feedback/new owned task results may invalidate prior observations. */
+  resetEvidence() {
+    this.#results.clear();
+    this.#mutations.clear();
+    // New instructions/results do not prove a timed-out mutation was rolled back.
+    for (const [key, failure] of this.#failures) {
+      if (failure.readOnly || failure.kind !== 'uncertain') this.#failures.delete(key);
+    }
+    this.#state.stagnantBatches = 0;
+    this.#state.stage = 'running';
+    this.#state.reason = null;
+    this.#batch = { evidence: false, repeated: false, failed: false };
+  }
+
+  /** Limit unchanged failures; never automatically replay an uncertain mutation. */
+  blocked(call) {
+    const failure = this.#failures.get(`${call.name}:${argsHashOf(call.input)}`);
+    // A possibly committed mutation must be verified before even the first replay.
+    if (!failure || (failure.count < FAILURE_LIMIT
+        && !(['uncertain', 'terminated_command'].includes(failure.kind) && !failure.readOnly))) return null;
+    return `Blocked unchanged failed call to ${call.name} after ${failure.count} equivalent failures. This call was NOT executed. Use the earlier error to correct the arguments or choose a different supported path. If an earlier operation timed out or disconnected, its side effects may already have happened: verify the target state before retrying. Otherwise report the concrete blocker. Previous failed call: ${failure.callId}.`;
+  }
+
+  observe({ call, output, isError = false, readOnly = false, executed = true, reused = false, skipped = false, policy = 'warn' }) {
+    if (skipped) return;
+    if (executed) this.#state.toolExecutions += 1;
+    if (reused) this.#state.reusedCalls += 1;
+    if (isError) this.#state.failedCalls += 1;
+    const key = `${call.name}:${argsHashOf(call.input)}`;
+    const hash = resultHash(output);
+    if (isError) {
+      const prior = this.#failures.get(key);
+      const kind = failureKind(output, call, readOnly);
+      if (executed && !readOnly) {
+        // A partial mutation may have changed even a previously unreadable
+        // resource. Permit verification, never a replay of the mutation itself.
+        this.#results.clear();
+        for (const [failedKey, failure] of this.#failures) {
+          if (failure.readOnly) this.#failures.delete(failedKey);
+        }
+      }
+      // A blocked result is synthetic; do not replace the original failure.
+      if (executed) boundedSet(this.#failures, key, {
+        kind, readOnly, count: prior?.kind === kind ? prior.count + 1 : 1, callId: call.id,
+      });
+      const repeated = !executed || prior?.kind === kind;
+      // A first negative observation for a distinct read narrows the search.
+      // Validation/permission failures are blockers, not domain evidence.
+      if (readOnly && !repeated && !['validation', 'permission', 'uncertain'].includes(kind)) {
+        this.#batch.evidence = true;
+        this.#state.lastEvidenceAt = Date.now();
+      } else {
+        this.#batch.failed = true;
+      }
+      if (repeated) {
+        this.#batch.repeated = true;
+        this.#state.repeatedCalls += 1;
+      }
+      return;
+    }
+    this.#failures.delete(key);
+    if (NEUTRAL_TOOLS.has(call.name) || policy === 'allow') return;
+    if (!readOnly && executed && !reused) {
+      // New mutations invalidate read observations, so edit/verify loops remain
+      // useful. An identical mutation/acknowledgement is not itself evidence
+      // of another change; never cache or replay it, merely count repetition.
+      if (this.#mutations.get(key) === hash) {
+        this.#batch.repeated = true;
+        this.#state.repeatedCalls += 1;
+      } else {
+        boundedSet(this.#mutations, key, hash);
+        this.#results.clear();
+        // Reads and confirmed, finished commands may now succeed after an
+        // edit. Unknown/timeout side effects still require explicit verification.
+        for (const [failedKey, failure] of this.#failures) {
+          if (failure.readOnly || failure.kind === 'terminated_command') this.#failures.delete(failedKey);
+        }
+        this.#batch.evidence = true;
+        this.#state.lastEvidenceAt = Date.now();
+      }
+      return;
+    }
+    // Different ranges/pages are independent observations. A changed result for
+    // the same call is fresh evidence even when it returns to an older value.
+    const prior = this.#results.get(key);
+    if (prior?.hash === hash || reused || !executed) {
+      this.#state.repeatedCalls += 1;
+      this.#batch.repeated = true;
+      return readOnly && prior?.hash === hash ? prior.callId : null;
+    } else {
+      boundedSet(this.#results, key, { hash, callId: call.id });
+      this.#batch.evidence = true;
+      this.#state.lastEvidenceAt = Date.now();
+    }
+  }
+
+  /** Called only AFTER every tool result is paired and persisted. */
+  finishBatch() {
+    const previousStage = this.#state.stage;
+    if (this.#batch.evidence) {
+      this.#state.stagnantBatches = 0;
+      this.#state.stage = 'running';
+      this.#state.reason = null;
+    } else if (this.#batch.repeated || this.#batch.failed) {
+      this.#state.stagnantBatches += 1;
+      this.#state.reason = this.#batch.failed ? 'repeated_failure' : 'repeated_results';
+      const count = this.#state.stagnantBatches;
+      this.#state.stage = count >= REPORT_BATCHES ? 'stopped'
+        : count >= RECOVERY_BATCHES ? 'recovering'
+          : count >= WARNING_BATCHES ? 'warning' : 'running';
+    }
+    this.#batch = { evidence: false, repeated: false, failed: false };
+    if (previousStage === this.#state.stage || this.#state.stage === 'running') return null;
+    if (this.#state.stage === 'stopped') return 'report';
+    return this.#state.stage;
+  }
+
+  snapshot(identity = {}) {
+    return { type: 'query_progress', ...identity, revision: ++this.#revision, ...this.#state };
+  }
+}
+
+export function progressReminder(action, reason) {
+  const failureHint = reason === 'repeated_failure'
+    ? 'The same execution paths are failing. A timeout does not prove an operation did not happen; verify state before retrying any side effect.'
+    : 'Recent tool batches repeat results already available; re-reading or restating a plan is not new evidence.';
+  if (action === 'report') return `[system note] Investigation stopped after repeated non-progress batches despite recovery guidance. ${failureHint} Do not claim the user task is complete. Using only existing evidence, give a concise handoff: completed artifacts, unfinished requirements, concrete blocker, and a safe next step. No further tools are available for this one reporting response.`;
+  return `[system note] Query progress ${action === 'recovering' ? 'recovery required' : 'warning'}: ${failureHint} Reuse prior results. Execute a concrete next step toward the requested deliverable, obtain genuinely missing evidence, or explain the blocker. Do not spawn another review of the same baseline or search for your own promises. Long-running useful work and legitimate waits remain allowed.`;
+}

package/yeaft/sub-agent/prompt-queue.js

@@ -11,6 +11,9 @@ import { snapshotEffortDecision } from '../effort.js';
  * @param {{ projectSessionIds?: string[], projectLabel?: string, projectInstruction?: string }} projectContext
  */
 export function enqueueSubAgentPrompt(agent, prompt, projectContext = {}) {
+  // Reserve the original delegation identity, but stop reusing its mutable
+  // evidence as soon as follow-up work is accepted (even before it runs).
+  agent.delegationSuperseded = true;
   if (!Array.isArray(agent.pendingPrompts)) agent.pendingPrompts = [];
   agent.pendingPrompts.push({
     prompt,