@yeaft/webchat-agent 1.0.172 → 1.0.174

package/package.json

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

@@ -524,6 +524,9 @@ export class Engine {
   /** @type {Array<{content:string|Array, preview:string}>} */
   #pendingUserMessages = [];
 
+  /** True after the bridge queued input in its external per-thread buffer. */
+  #externalUserWakePending = false;
+
   /**
    * Tasks (background bash, sub-agent spawns) that were launched DURING
    * the currently-running query() and have NOT terminated yet. The query
@@ -1654,6 +1657,7 @@ export class Engine {
 
   #drainPendingUserMessages(drainPendingUserMessages) {
     const pending = [];
+    this.#externalUserWakePending = false;
     if (typeof drainPendingUserMessages === 'function') {
       try {
         const drained = drainPendingUserMessages();
@@ -1809,6 +1813,7 @@ export class Engine {
       this.#abortReason = null;
       this.#currentThreadId = MAIN_THREAD_ID;
       this.#pendingUserMessages.length = 0;
+      this.#externalUserWakePending = false;
       this.#asyncTaskToolMeta.clear();
       this.#pendingTaskResultMessages.length = 0;
       this.#pendingTaskResultUpdates.length = 0;
@@ -2955,7 +2960,8 @@ export class Engine {
         while (!signal?.aborted
                && this.#pendingTaskResultMessages.length === 0
                && this.#pendingTaskResultUpdates.length === 0
-               && this.#pendingUserMessages.length === 0) {
+               && this.#pendingUserMessages.length === 0
+               && !this.#externalUserWakePending) {
           if (this.#pendingAsyncTaskIds.size === 0) break;
           await this.#waitForAsyncWake(signal);
         }
@@ -3680,6 +3686,20 @@ export class Engine {
     return true;
   }
 
+  /**
+   * Wake a query whose external pending-message hook has received input.
+   * The bridge keeps the full message (attachments and provenance included)
+   * in its thread queue; this method only releases an async-task wait so the
+   * normal drain callback can consume it at the next safe adapter boundary.
+   * @returns {boolean}
+   */
+  wakeForPendingUserMessage() {
+    if (!this.isRunning) return false;
+    this.#externalUserWakePending = true;
+    this.#wakeAsyncTaskWaiters();
+    return true;
+  }
+
   /**
    * Install the coordinator that lets an external dispatcher (web-bridge)
    * route a background task's terminal event back to THIS engine while
@@ -3851,6 +3871,7 @@ export class Engine {
       if (this.#pendingTaskResultMessages.length > 0) return resolve();
       if (this.#pendingTaskResultUpdates.length > 0) return resolve();
       if (this.#pendingUserMessages.length > 0) return resolve();
+      if (this.#externalUserWakePending) return resolve();
       if (signal?.aborted) return resolve();
       this.#asyncTaskWaiters.push(resolve);
       if (signal && typeof signal.addEventListener === 'function') {

package/yeaft/tools/ask-user.js

@@ -66,6 +66,13 @@ Guidelines:
     }
 
     const answers = await ctx.askUser({ question, options });
+    if (answers?.__yeaftTimedOut) {
+      return JSON.stringify({
+        question,
+        timedOut: true,
+        message: 'The user did not answer before the request expired. Continue without this input.',
+      });
+    }
     return JSON.stringify({ question, answers });
   },
 });

package/yeaft/web-bridge.js

@@ -80,7 +80,27 @@ const YEAFT_SKILL_COMMAND_PREFIX = 'yeaft-skills:';
 const PROJECT_SKILL_TIERS = new Set(['project', 'project-claude', 'project-codex']);
 const BASE_RUNTIME_KEY = '__base__';
 
-/** @type {Map<string, {resolve:Function, sessionId:string, vpId:string, threadId:string, turnId:string, signal?:AbortSignal, onAbort?:Function}>} */
+/**
+ * Live AskUser requests. They are Session-scoped runtime state rather than a
+ * turn lock: every connected client may answer the same request, while the
+ * first valid answer wins. Pending requests are replayed when another device
+ * loads the Session.
+ * @type {Map<string, {
+ *   resolve:Function,
+ *   reject?:Function,
+ *   sessionId:string,
+ *   vpId:string,
+ *   threadId:string,
+ *   turnId:string,
+ *   question:string,
+ *   options:Array<string>,
+ *   createdAt:number,
+ *   expiresAt:number,
+ *   timer?:NodeJS.Timeout|null,
+ *   resumeQueryTimer?:Function,
+ *   signal?:AbortSignal,
+ *   onAbort?:Function,
+ * }>} */
 const pendingUserPrompts = new Map();
 
 /** @type {import('./session.js').Session | null} */
@@ -212,6 +232,7 @@ function scheduleYeaftLoadHistoryMetadataReplay(sessionId) {
         yeaftDir: ctx.CONFIG?.yeaftDir || null,
         tasks: replaySession.taskManager ? replaySession.taskManager.listActiveTasks() : [],
       }, { sessionId });
+      if (sessionId) replayPendingUserPrompts(sessionId);
       sendSessionSnapshotBroadcast();
       if (sessionId && session === replaySession) {
         sendDreamSnapshotForSession(sessionId, { trigger: 'load_history' }).catch(() => null);
@@ -796,6 +817,8 @@ export function broadcastLanguageChange(language) {
 /** Query timeout in ms — abort if LLM doesn't respond within this window */
 const QUERY_TIMEOUT_MS = 120_000;
 const HIGH_REASONING_QUERY_TIMEOUT_MS = 300_000;
+/** AskUser is human-paced but must never pin a VP turn forever. */
+const ASK_USER_TIMEOUT_MS = 10 * 60_000;
 
 function isHighReasoningEffort(effort) {
   const value = typeof effort === 'string' ? effort.trim().toLowerCase() : '';
@@ -1378,6 +1401,12 @@ export function __testGetVpThreads(sessionId, vpId) {
   }));
 }
 
+/** Test-only: attach an Engine-like wake target to a seeded VP thread. */
+export function __testSetVpThreadEngine({ sessionId, vpId, threadId, engine }) {
+  const thread = getOrCreateVpThread({ sessionId, vpId, threadId });
+  thread.engine = engine || null;
+}
+
 /** Test-only: seed a VP thread without starting its engine driver. */
 export function __testSeedVpThread({ sessionId, vpId, threadId, title = 'test thread', status = 'queued' }) {
   const thread = getOrCreateVpThread({ sessionId, vpId, threadId, title });
@@ -1725,31 +1754,43 @@ async function routeEnvelopeToVpThread(sessionId, vpId, envelope) {
       senderVpId: isInternalAppend ? (envelope?.msg?.meta?.senderVpId || envelope?.msg?.from || null) : null,
       sourceThreadId: isInternalAppend ? visibleInboundThreadId(envelope, thread.threadId) : null,
     });
-    persistInboundMessageOnceByMsgId({
-      msgId: envelope?.msg?.id,
-      text,
-      sessionId,
-      threadId: visibleInboundThreadId(envelope, thread.threadId),
-      role: isInternalAppend ? 'assistant' : 'user',
-      speakerVpId: envelope?.msg?.meta?.senderVpId || envelope?.msg?.from || null,
-      attachments: Array.isArray(envelope?.msg?.meta?.attachments) ? envelope.msg.meta.attachments : [],
-      internal: isInternalAppend,
-      ts: envelope?.msg?.ts || null,
-      clientMessageId: envelope?.msg?.meta?.clientMessageId || null,
-    });
-    thread.updatedAt = Date.now();
-    try {
-      sendSessionEvent({
-        type: 'vp_thread_user_appended',
+    // A thread parked on a background task has no adapter activity to poll this
+    // queue. Wake its Engine explicitly so the new user message is consumed
+    // immediately while the task remains tracked in TaskManager. If the Engine
+    // is not actually running, this was a stale classifier hit; remove the
+    // append and fall through to a normal queued turn instead of orphaning it.
+    let appendedToRunningThread = false;
+    try { appendedToRunningThread = thread.engine?.wakeForPendingUserMessage?.() === true; } catch { /* best-effort wake */ }
+    if (!appendedToRunningThread) {
+      thread.pendingQueries.pop();
+      related = false;
+    } else {
+      persistInboundMessageOnceByMsgId({
+        msgId: envelope?.msg?.id,
+        text,
         sessionId,
-        vpId,
-        threadId: thread.threadId,
-        title: thread.title,
-        turnId,
-        ts: Date.now(),
-      }, { sessionId, vpId, threadId: thread.threadId, turnId });
-    } catch { /* never crash WS pipeline */ }
-    return thread.threadId;
+        threadId: visibleInboundThreadId(envelope, thread.threadId),
+        role: isInternalAppend ? 'assistant' : 'user',
+        speakerVpId: envelope?.msg?.meta?.senderVpId || envelope?.msg?.from || null,
+        attachments: Array.isArray(envelope?.msg?.meta?.attachments) ? envelope.msg.meta.attachments : [],
+        internal: isInternalAppend,
+        ts: envelope?.msg?.ts || null,
+        clientMessageId: envelope?.msg?.meta?.clientMessageId || null,
+      });
+      thread.updatedAt = Date.now();
+      try {
+        sendSessionEvent({
+          type: 'vp_thread_user_appended',
+          sessionId,
+          vpId,
+          threadId: thread.threadId,
+          title: thread.title,
+          turnId,
+          ts: Date.now(),
+        }, { sessionId, vpId, threadId: thread.threadId, turnId });
+      } catch { /* never crash WS pipeline */ }
+      return thread.threadId;
+    }
   }
 
   const key = threadKey(sessionId, vpId, thread.threadId);
@@ -2335,6 +2376,60 @@ function sendSessionEvent(event, { sessionId, chatId, vpId, turnId, threadId, pe
   });
 }
 
+function pendingUserPromptEvent(requestId, pending, extra = {}) {
+  return {
+    type: 'ask_user_question',
+    requestId,
+    questions: [{
+      question: pending.question,
+      options: pending.options.map(label => ({ label, description: '' })),
+      multiSelect: false,
+    }],
+    createdAt: pending.createdAt,
+    expiresAt: pending.expiresAt,
+    ...extra,
+  };
+}
+
+function sendPendingUserPrompt(requestId, pending, extra = {}) {
+  sendSessionEvent(pendingUserPromptEvent(requestId, pending, extra), {
+    sessionId: pending.sessionId,
+    vpId: pending.vpId,
+    threadId: pending.threadId,
+    turnId: pending.turnId,
+  });
+}
+
+function replayPendingUserPrompts(sessionId) {
+  const now = Date.now();
+  for (const [requestId, pending] of pendingUserPrompts) {
+    if (pending.sessionId !== sessionId || pending.expiresAt <= now) continue;
+    sendPendingUserPrompt(requestId, pending, { replay: true });
+  }
+}
+
+function settlePendingUserPrompt(requestId, pending, { answers = null, timedOut = false } = {}) {
+  if (pendingUserPrompts.get(requestId) !== pending) return false;
+  pendingUserPrompts.delete(requestId);
+  if (pending.timer) clearTimeout(pending.timer);
+  if (pending.signal && pending.onAbort) {
+    try { pending.signal.removeEventListener('abort', pending.onAbort); } catch { /* ignore */ }
+  }
+  try { pending.resumeQueryTimer?.(); } catch { /* best-effort */ }
+  sendSessionEvent({
+    type: timedOut ? 'ask_user_expired' : 'ask_user_answered',
+    requestId,
+    ...(timedOut ? { expiredAt: Date.now() } : { answers: answers || {} }),
+  }, {
+    sessionId: pending.sessionId,
+    vpId: pending.vpId,
+    threadId: pending.threadId,
+    turnId: pending.turnId,
+  });
+  pending.resolve(timedOut ? { __yeaftTimedOut: true } : (answers || {}));
+  return true;
+}
+
 function configuredVpPaths() {
   const yeaftDir = ctx.CONFIG?.yeaftDir;
   if (typeof yeaftDir !== 'string' || !yeaftDir.trim()) return {};
@@ -4560,40 +4655,44 @@ async function runVpTurn({ prompt, promptParts = null, sessionId, vpId, threadId
         askUser: ({ question, options }) => new Promise((resolve, reject) => {
           const requestId = `ask_${randomUUID()}`;
           const signal = vpAbort.signal;
-          // User think time is not engine silence. Pause the query watchdog until
-          // the card is answered; the normal tool/LLM budget resumes afterward.
+          const createdAt = Date.now();
+          // Human think time is not engine silence. Pause the query watchdog,
+          // but keep a separate bounded AskUser lifetime so an abandoned card
+          // cannot pin the VP forever.
           if (queryTimer) {
             clearTimeout(queryTimer);
             queryTimer = null;
           }
-          const onAbort = () => {
-            pendingUserPrompts.delete(requestId);
-            reject(new Error('aborted'));
-          };
-          pendingUserPrompts.set(requestId, {
-            resolve: answers => {
-              resetQueryTimer();
-              resolve(answers);
-            },
+          const pending = {
+            resolve,
+            reject,
             sessionId,
             vpId,
             threadId,
             turnId,
+            question,
+            options: Array.isArray(options) ? options.filter(label => typeof label === 'string') : [],
+            createdAt,
+            expiresAt: createdAt + ASK_USER_TIMEOUT_MS,
+            timer: null,
+            resumeQueryTimer: resetQueryTimer,
             signal,
-            onAbort,
-          });
+            onAbort: null,
+          };
+          const onAbort = () => {
+            if (pendingUserPrompts.get(requestId) !== pending) return;
+            pendingUserPrompts.delete(requestId);
+            if (pending.timer) clearTimeout(pending.timer);
+            reject(new Error('aborted'));
+          };
+          pending.onAbort = onAbort;
+          pending.timer = setTimeout(() => {
+            settlePendingUserPrompt(requestId, pending, { timedOut: true });
+          }, ASK_USER_TIMEOUT_MS);
+          if (typeof pending.timer.unref === 'function') pending.timer.unref();
+          pendingUserPrompts.set(requestId, pending);
           signal.addEventListener('abort', onAbort, { once: true });
-          sendSessionEvent({
-            type: 'ask_user_question',
-            requestId,
-            questions: [{
-              question,
-              options: Array.isArray(options)
-                ? options.map(label => ({ label, description: '' }))
-                : [],
-              multiSelect: false,
-            }],
-          }, envelope);
+          sendPendingUserPrompt(requestId, pending);
         }),
         threadId,
         vpTurnId: turnId,
@@ -5639,12 +5738,7 @@ export function handleYeaftAskUserAnswer(msg) {
   if (msg.turnId && msg.turnId !== pending.turnId) return false;
   if (msg.threadId && msg.threadId !== pending.threadId) return false;
 
-  pendingUserPrompts.delete(requestId);
-  if (pending.signal && pending.onAbort) {
-    try { pending.signal.removeEventListener('abort', pending.onAbort); } catch { /* ignore */ }
-  }
-  pending.resolve(msg.answers || {});
-  return true;
+  return settlePendingUserPrompt(requestId, pending, { answers: msg.answers || {} });
 }
 
 export async function handleYeaftSessionSend(msg) {
@@ -6543,13 +6637,21 @@ export const __testHooks = {
     vpAborts.clear();
     vpInboxes.clear();
   },
-  seedPendingUserPrompt({ requestId = 'ask-test', sessionId = 'session-test', vpId = 'vp-test', threadId = 'main', turnId = 'turn-test' } = {}) {
+  seedPendingUserPrompt({ requestId = 'ask-test', sessionId = 'session-test', vpId = 'vp-test', threadId = 'main', turnId = 'turn-test', question = 'Continue?', options = [], createdAt = Date.now(), expiresAt = Date.now() + ASK_USER_TIMEOUT_MS } = {}) {
     let resolved;
     const promise = new Promise(resolve => { resolved = resolve; });
-    pendingUserPrompts.set(requestId, { resolve: resolved, sessionId, vpId, threadId, turnId });
+    pendingUserPrompts.set(requestId, { resolve: resolved, sessionId, vpId, threadId, turnId, question, options, createdAt, expiresAt, timer: null });
     return promise;
   },
+  replayPendingUserPrompts,
+  settlePendingUserPromptForTest(requestId, opts = {}) {
+    const pending = pendingUserPrompts.get(requestId);
+    return pending ? settlePendingUserPrompt(requestId, pending, opts) : false;
+  },
   resetPendingUserPrompts() {
+    for (const pending of pendingUserPrompts.values()) {
+      if (pending.timer) clearTimeout(pending.timer);
+    }
     pendingUserPrompts.clear();
   },
   resetVpStatusBroker() {

package/yeaft/work-center/bridge.js

@@ -18,14 +18,19 @@ let shuttingDown = false;
 let shutdownPromise = null;
 let serviceFactory = null;
 
-const BROWSER_DETAIL_OPS = new Set(['get', 'create', 'update', 'start', 'cancel', 'guide', 'retry']);
+const BROWSER_DETAIL_OPS = new Set(['get', 'create', 'update', 'start', 'cancel', 'action_input', 'guide', 'retry']);
+const BROWSER_ACTION_DEBUG_OPS = new Set(['get_action_messages', 'get_action_requests', 'get_action_request']);
 // `files` is an internal server-to-Agent field. The browser relay rejects any
 // client-supplied value and only emits files resolved from owned upload ids.
 const BROWSER_FILE_FIELDS = Object.freeze({
   create: [
     'title', 'goal', 'acceptanceCriteria', 'workItemType', 'workDir', 'reuseMemory', 'files', 'start',
   ],
+  action_input: ['id', 'text', 'actionId', 'revision', 'files'],
   guide: ['id', 'guidance', 'actionId', 'revision', 'files'],
+  get_action_messages: ['id', 'actionId', 'cursor', 'limit'],
+  get_action_requests: ['id', 'actionId'],
+  get_action_request: ['id', 'actionId', 'runId', 'requestId'],
 });
 
 function browserFilePayload(op, value) {
@@ -100,6 +105,7 @@ async function createDefaultService() {
     },
     policyProvider: async () => readWorkCenterSettings(yeaftDir),
     attachmentRoot: join(yeaftDir, 'work-center', 'attachments'),
+    yeaftDir,
     actionWorktreeRoot: join(yeaftDir, 'work-center', 'worktrees'),
     registry: defaultRegistry,
     store: null,
@@ -184,7 +190,7 @@ export async function handleWorkCenterRequest(msg) {
       const workCenter = await ensureWorkCenter();
       const payload = Object.hasOwn(BROWSER_FILE_FIELDS, op)
         ? browserFilePayload(op, msg.payload)
-        : (msg.payload || {});
+        : (BROWSER_ACTION_DEBUG_OPS.has(op) ? browserFilePayload(op, msg.payload) : (msg.payload || {}));
       data = await workCenter.handle(op, payload);
     }
     if (BROWSER_DETAIL_OPS.has(op)) data = projectWorkItemDetail(data);

package/yeaft/work-center/controller.js

@@ -210,16 +210,54 @@ export class WorkflowController {
         instruction: actionInstruction(step, workItem, context, renderSessionContextSnapshot(workItem.sessionContext)),
         maxAttempts: previous.maxAttempts || 2,
       };
-    }, input.attachments);
+    }, input.attachments, input.addedAttachments);
     if (!detail) throw new Error(`WorkItem not found: ${id}`);
     return detail;
   }
 
+  input(id, input = {}) {
+    const text = typeof input.text === 'string' ? input.text.trim().slice(0, 8_000) : '';
+    const addedAttachmentCount = Math.max(0, Number(input.addedAttachmentCount) || 0);
+    if (!text && addedAttachmentCount === 0) throw new Error('Action input or attachments are required');
+    const workItem = this.store.getWorkItem(id);
+    if (!workItem) throw new Error(`WorkItem not found: ${id}`);
+    if (['ready', 'running'].includes(workItem.status)) {
+      if (workItem.currentActionId !== input.actionId || workItem.revision !== input.revision) {
+        throw new Error('Action changed before input was applied; refresh and try again');
+      }
+      return this.guide(id, {
+        guidance: text,
+        actionId: input.actionId,
+        revision: input.revision,
+        addedAttachmentCount,
+        addedAttachments: input.addedAttachments,
+        attachments: input.attachments,
+      });
+    }
+    if (!['waiting', 'needs_attention'].includes(workItem.status)) {
+      throw new Error(`WorkItem in ${workItem.status} cannot accept Action input`);
+    }
+    if (workItem.currentActionId !== input.actionId || workItem.revision !== input.revision) {
+      throw new Error('Action changed before input was applied; refresh and try again');
+    }
+    return this.retry(id, {
+      answer: text,
+      addedAttachmentCount,
+      expected: { actionId: input.actionId, revision: input.revision },
+      attachments: input.attachments,
+      inputEvent: {
+        text: text || `The user added ${addedAttachmentCount} attachment(s) as additional context for this Action.`,
+        attachments: input.addedAttachments,
+      },
+    });
+  }
+
   retry(id, input = {}) {
     const answer = typeof input.answer === 'string' ? input.answer.trim().slice(0, 8_000) : '';
+    const addedAttachmentCount = Math.max(0, Number(input.addedAttachmentCount) || 0);
     const detail = this.store.retryWorkItemAtomic(id, (workItem, previous, previousRun) => {
-      if (workItem.status === 'waiting' && !answer) {
-        throw new Error('answer is required to resume a waiting WorkItem');
+      if (workItem.status === 'waiting' && !answer && addedAttachmentCount === 0) {
+        throw new Error('answer or attachments are required to resume a waiting WorkItem');
       }
       const step = previous
         ? {
@@ -244,7 +282,9 @@ export class WorkflowController {
           summary: previousRun.summary || '',
           evidence: normalizeEvidence(previousRun.evidence),
           waitingReason: previousRun.waitingReason || null,
-          answer: answer || null,
+          answer: answer || (addedAttachmentCount > 0
+            ? `The user added ${addedAttachmentCount} attachment(s) as additional context for this Action.`
+            : null),
         });
       }
       return {
@@ -253,6 +293,10 @@ export class WorkflowController {
         instruction: actionInstruction(step, workItem, context, renderSessionContextSnapshot(workItem.sessionContext)),
         maxAttempts: previous?.maxAttempts || 2,
       };
+    }, {
+      expected: input.expected || null,
+      attachments: input.attachments,
+      inputEvent: input.inputEvent || null,
     });
     if (!detail) throw new Error(`WorkItem not found: ${id}`);
     return detail;