@yeaft/webchat-agent 0.1.497 → 0.1.499

package/crew/routing.js

@@ -235,7 +235,7 @@ export function resolveRoleName(to, session, fromRole) {
  * @param {Array<{mimeType, data}>} [turnImages] - auto-attached images from the turn (max 3)
  */
 export async function executeRoute(session, fromRole, route, turnImages = []) {
-  const { to, summary, taskId, taskTitle } = route;
+  let { to, summary, taskId, taskTitle } = route;
 
   // Auto-resume: paused/stopped → running (route execution means work should continue)
   if (session.status === 'paused' || session.status === 'stopped') {
@@ -244,14 +244,51 @@ export async function executeRoute(session, fromRole, route, turnImages = []) {
     sendStatusUpdate(session);
   }
 
+  // ─── task-321: taskId fallback chain ─────────────────────────────
+  // When a ROUTE omits `task:` (shorthand, bare dispatch, human messages,
+  // PM forgetting the field), fall back to:
+  //   (a) the sender's currentTask.taskId
+  //   (b) the most recent non-system entry in session.messageHistory
+  // This keeps prev-* / designer / architect / shorthand messages from
+  // becoming taskId=null orphans that never appear on any feature card.
+  if (!taskId) {
+    const fromRoleState = session.roleStates?.get(fromRole);
+    if (fromRoleState?.currentTask?.taskId) {
+      taskId = fromRoleState.currentTask.taskId;
+      taskTitle = taskTitle || fromRoleState.currentTask.taskTitle || null;
+    } else if (Array.isArray(session.messageHistory) && session.messageHistory.length > 0) {
+      for (let i = session.messageHistory.length - 1; i >= 0; i--) {
+        const h = session.messageHistory[i];
+        if (h && h.from !== 'system' && h.taskId) {
+          taskId = h.taskId;
+          break;
+        }
+      }
+    }
+    // Mirror the fallback back into the route object so downstream
+    // consumers (dispatchToRole / sendCrewOutput) see the inferred id.
+    if (taskId) {
+      route.taskId = taskId;
+      if (taskTitle) route.taskTitle = taskTitle;
+    }
+  }
+
   // Task 文件自动管理（fire-and-forget）
   if (taskId && summary) {
     const fromRoleConfig = session.roles.get(fromRole);
-    if (fromRoleConfig?.isDecisionMaker && taskTitle && to !== 'human') {
-      ensureTaskFile(session, taskId, taskTitle, to, summary)
+    // task-321: Auto-create feature file even when a non-PM role is the
+    // first to mention the taskId. Any role carrying a taskId (PM, devs,
+    // reviewers, designer, architect) now triggers creation — not just PM
+    // with explicit taskTitle. appendTaskRecord itself also creates the
+    // file if missing, so this is a best-effort fast path.
+    const effectiveTitle = taskTitle
+      || session.features?.get(taskId)?.taskTitle
+      || null;
+    if (effectiveTitle && to !== 'human') {
+      ensureTaskFile(session, taskId, effectiveTitle, fromRoleConfig?.isDecisionMaker ? to : fromRole, summary)
         .catch(e => console.warn(`[Crew] Failed to create task file ${taskId}:`, e.message));
     }
-    appendTaskRecord(session, taskId, fromRole, summary)
+    appendTaskRecord(session, taskId, fromRole, summary, { taskTitle: effectiveTitle })
       .catch(e => console.warn(`[Crew] Failed to append task record ${taskId}:`, e.message));
 
     // 更新工作看板：推断状态
@@ -375,8 +412,13 @@ export async function dispatchToRole(session, roleName, content, fromSource, tas
   }
 
   // 设置 task
+  // task-321: keep currentTask sticky. A new taskId updates it; a dispatch
+  // without taskId preserves the previous currentTask so subsequent
+  // sendCrewOutput calls (which read roleState.currentTask.taskId) keep
+  // attaching to the right feature card — instead of falling back to null
+  // the moment the sender omits the `task:` field.
   if (taskId) {
-    roleState.currentTask = { taskId, taskTitle };
+    roleState.currentTask = { taskId, taskTitle: taskTitle || roleState.currentTask?.taskTitle || null };
   }
 
   // Task 上下文注入

package/crew/task-files.js

@@ -59,15 +59,41 @@ ${m.workRecord}
 
 /**
  * 追加工作记录到 task 文件
+ *
+ * task-321: auto-create the feature file if it doesn't exist yet. Previously
+ * a missing file silently dropped the record, which meant that whenever a
+ * non-PM role was first to mention a taskId, the file was never created and
+ * every subsequent record — including from PM — would also be dropped. We
+ * now recover a title from opts.taskTitle → session.features cache → taskId
+ * itself, and create the file on the fly.
+ *
+ * @param {object} session
+ * @param {string} taskId
+ * @param {string} roleName
+ * @param {string} summary
+ * @param {{ taskTitle?: string|null, assignee?: string|null }} [opts]
  */
-export async function appendTaskRecord(session, taskId, roleName, summary) {
+export async function appendTaskRecord(session, taskId, roleName, summary, opts = {}) {
   const filePath = join(session.sharedDir, 'context', 'features', `${taskId}.md`);
 
+  let exists = true;
   try {
     await fs.access(filePath);
   } catch {
-    // 文件不存在，跳过
-    return;
+    exists = false;
+  }
+
+  if (!exists) {
+    const recoveredTitle = opts.taskTitle
+      || session.features?.get(taskId)?.taskTitle
+      || taskId;
+    const assignee = opts.assignee || roleName;
+    try {
+      await ensureTaskFile(session, taskId, recoveredTitle, assignee, summary);
+    } catch (e) {
+      console.warn(`[Crew] Failed to auto-create task file ${taskId} on append:`, e.message);
+      return;
+    }
   }
 
   const role = session.roles.get(roleName);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "0.1.497",
+  "version": "0.1.499",
   "description": "Remote agent for Yeaft WebChat — connects worker machines to the central server",
   "main": "index.js",
   "type": "module",

package/unify/web-bridge.js

@@ -16,13 +16,22 @@
 import { loadSession } from './session.js';
 import { sendToServer } from '../connection/buffer.js';
 import ctx from '../context.js';
-import { getThreadStore } from './threads/store.js';
+import { getThreadStore, MAIN_THREAD_ID } from './threads/store.js';
 
 /** @type {import('./session.js').Session | null} */
 let session = null;
 
-/** @type {AbortController | null} */
-let currentAbort = null;
+/**
+ * task-320: per-thread in-flight AbortController registry.
+ *
+ * A new message only cancels the prior round on the SAME thread; a message
+ * routed to a different thread runs concurrently without aliasing. Keyed by
+ * the resolved `targetThreadId` from the dispatcher's `routing_decision`
+ * event (we don't know the thread until the router has classified).
+ *
+ * @type {Map<string, AbortController>}
+ */
+const abortByThread = new Map();
 
 /** Query timeout in ms — abort if LLM doesn't respond within this window */
 const QUERY_TIMEOUT_MS = 120_000;
@@ -30,10 +39,22 @@ const QUERY_TIMEOUT_MS = 120_000;
 /** Virtual conversationId for the Unify session */
 let unifyConversationId = null;
 
-/** Accumulated conversation messages for context continuity across queries.
- *  Each entry is { role: 'user'|'assistant', content: string|Array }.
- *  Cleared on session reset or consolidation. */
-let conversationMessages = [];
+/**
+ * task-320: per-thread accumulated conversation messages for context
+ * continuity. Previously a single flat array — which cross-contaminated
+ * history across threads. Keyed by threadId. Cleared on session reset or
+ * by a `consolidate` event for that thread only.
+ *
+ * @type {Map<string, Array<{role: 'user'|'assistant', content: string|Array}>>}
+ */
+const messagesByThread = new Map();
+
+function getThreadMessages(threadId) {
+  if (!threadId) return [];
+  let arr = messagesByThread.get(threadId);
+  if (!arr) { arr = []; messagesByThread.set(threadId, arr); }
+  return arr;
+}
 
 /** Whether we've already sent a permission warning to the UI */
 let _permissionDiagnosticSent = false;
@@ -395,8 +416,13 @@ function handleEngineEvent(event, threadId, hctx) {
       break;
 
     case 'consolidate':
-      // Engine compressed the context — clear our accumulated history.
-      conversationMessages = [];
+      // Engine compressed the context — clear our accumulated history for
+      // THIS thread only (task-320: per-thread history map).
+      if (threadId) {
+        messagesByThread.set(threadId, []);
+      } else {
+        messagesByThread.clear();
+      }
       sendUnifyEvent({
         type: 'consolidate',
         archivedCount: event.archivedCount,
@@ -512,11 +538,16 @@ export async function handleUnifyChat(msg) {
       // Create a stable conversationId for the Unify session
       unifyConversationId = `unify-${Date.now()}`;
 
-      // Restore conversationMessages from persisted history for LLM context
+      // Restore per-thread history from persisted conversation store.
+      // task-320: bucket by threadId so each thread keeps its own context.
+      messagesByThread.clear();
       const recent = session.conversationStore.loadRecent(50);
-      conversationMessages = recent
-        .filter(m => m.role === 'user' || m.role === 'assistant')
-        .map(m => ({ role: m.role, content: m.content }));
+      for (const m of recent) {
+        if (m.role !== 'user' && m.role !== 'assistant') continue;
+        const tid = m.threadId || MAIN_THREAD_ID;
+        const bucket = getThreadMessages(tid);
+        bucket.push({ role: m.role, content: m.content });
+      }
 
       // Notify UI: session is ready with model info + conversationId
       sendUnifyEvent({
@@ -533,13 +564,14 @@ export async function handleUnifyChat(msg) {
       sendThreadListUpdate();
     }
 
-    // ─── Cancel any in-flight query ──
-    if (currentAbort) {
-      currentAbort.abort();
-      currentAbort = null;
-    }
-
-    currentAbort = new AbortController();
+    // ─── Per-call AbortController (task-320) ──
+    // Each call owns its own controller. Only once the router resolves the
+    // target thread do we register it into `abortByThread` and abort any
+    // prior controller on THAT same thread. Messages routed to different
+    // threads never alias each other's signals.
+    const abortCtrl = new AbortController();
+    /** @type {string | null} — set on routing_decision */
+    let resolvedThreadId = null;
 
     // ─── Timeout guard: abort query if LLM hangs beyond threshold ──
     // Resets on every event — fires only after prolonged silence.
@@ -547,9 +579,9 @@ export async function handleUnifyChat(msg) {
     const resetQueryTimer = () => {
       if (queryTimer) clearTimeout(queryTimer);
       queryTimer = setTimeout(() => {
-        if (currentAbort) {
+        if (!abortCtrl.signal.aborted) {
           console.error(`[Unify] query timeout after ${QUERY_TIMEOUT_MS / 1000}s of silence — aborting`);
-          currentAbort.abort();
+          abortCtrl.abort();
         }
       }, QUERY_TIMEOUT_MS);
     };
@@ -590,17 +622,31 @@ export async function handleUnifyChat(msg) {
       onError: (err) => { throw err; },
     };
 
-    for await (const pev of session.dispatcher.drain({ signal: currentAbort.signal })) {
+    for await (const pev of session.dispatcher.drain({ signal: abortCtrl.signal })) {
       resetQueryTimer();
+      // task-320: on routing_decision, bind this abort controller to the
+      // resolved target thread and abort any prior in-flight controller
+      // owned by that thread. Different threads don't alias.
+      if (pev && pev.type === 'routing_decision' && pev.targetThreadId && !resolvedThreadId) {
+        resolvedThreadId = pev.targetThreadId;
+        const prior = abortByThread.get(resolvedThreadId);
+        if (prior && prior !== abortCtrl) {
+          prior.abort();
+        }
+        abortByThread.set(resolvedThreadId, abortCtrl);
+      }
       forwardPipelineEvent(pev, pipelineCtx);
     }
 
     // ─── Query complete — accumulate messages for context continuity ──
-    conversationMessages.push({ role: 'user', content: cleanedPrompt });
+    // task-320: per-thread history (no cross-thread contamination).
+    const historyThread = resolvedThreadId || MAIN_THREAD_ID;
+    const threadMessages = getThreadMessages(historyThread);
+    threadMessages.push({ role: 'user', content: cleanedPrompt });
 
     const fullText = assistantTextParts.join('');
     if (fullText) {
-      conversationMessages.push({ role: 'assistant', content: fullText });
+      threadMessages.push({ role: 'assistant', content: fullText });
     }
 
     // ─── Signal turn end to UI ──
@@ -621,17 +667,14 @@ export async function handleUnifyChat(msg) {
     }
 
   } catch (err) {
-    // Don't report abort errors — but still send result to unblock frontend
-    if (err.name === 'AbortError') {
-      sendUnifyOutput({
-        type: 'assistant',
-        message: {
-          content: [{
-            type: 'text',
-            text: '⚠️ Query timed out — no response from LLM. Please try again.',
-          }],
-        },
-      });
+    // task-320: classify both DOM AbortError and LLMAbortError as
+    // "aborted" — LLMAbortError is thrown by the LLM adapters when the
+    // signal trips and must NOT render as a session error bubble.
+    const isAbort = err && (err.name === 'AbortError' || err.name === 'LLMAbortError');
+    if (isAbort) {
+      // Silent abort — the new in-flight round (on the same thread) will
+      // produce its own output. Still send `result` so the frontend's
+      // processing spinner for this exact send clears.
       sendUnifyOutput({
         type: 'result',
         result_text: '',
@@ -672,7 +715,12 @@ export async function handleUnifyChat(msg) {
       result_text: '',
     });
   } finally {
-    currentAbort = null;
+    // task-320: only clear the per-thread slot if THIS controller is still
+    // the registered one. If a newer message already overwrote it, leaving
+    // the newer controller in the map is the correct state.
+    if (resolvedThreadId && abortByThread.get(resolvedThreadId) === abortCtrl) {
+      abortByThread.delete(resolvedThreadId);
+    }
   }
 }
 
@@ -863,11 +911,16 @@ export async function handleUnifyLoadHistory(msg) {
 
     unifyConversationId = `unify-${Date.now()}`;
 
-    // Restore conversationMessages from persisted history for LLM context
+    // Restore per-thread history from persisted conversation store.
+    // task-320: bucket by threadId so each thread keeps its own context.
+    messagesByThread.clear();
     const recent = session.conversationStore.loadRecent(50);
-    conversationMessages = recent
-      .filter(m => m.role === 'user' || m.role === 'assistant')
-      .map(m => ({ role: m.role, content: m.content }));
+    for (const m of recent) {
+      if (m.role !== 'user' && m.role !== 'assistant') continue;
+      const tid = m.threadId || MAIN_THREAD_ID;
+      const bucket = getThreadMessages(tid);
+      bucket.push({ role: m.role, content: m.content });
+    }
 
     sendUnifyEvent({
       type: 'session_ready',
@@ -915,16 +968,19 @@ export async function handleUnifyLoadHistory(msg) {
  * session_ready so the frontend picks up updated models/config.
  */
 export async function resetUnifySession() {
-  if (currentAbort) {
-    currentAbort.abort();
-    currentAbort = null;
+  // task-320: abort ALL in-flight controllers (every thread) before
+  // tearing down the session. Leaves no dangling round still writing
+  // to stdout after shutdown.
+  for (const ctrl of abortByThread.values()) {
+    try { ctrl.abort(); } catch { /* ignore */ }
   }
+  abortByThread.clear();
   if (session) {
     await session.shutdown();
     session = null;
   }
   unifyConversationId = null;
-  conversationMessages = [];
+  messagesByThread.clear();
 
   // Re-initialize session immediately so frontend gets updated config
   try {
@@ -944,11 +1000,13 @@ export async function resetUnifySession() {
 
     unifyConversationId = `unify-${Date.now()}`;
 
-    // Restore conversation history for LLM context
+    // Restore per-thread history for LLM context (task-320).
     const recent = session.conversationStore.loadRecent(50);
-    conversationMessages = recent
-      .filter(m => m.role === 'user' || m.role === 'assistant')
-      .map(m => ({ role: m.role, content: m.content }));
+    for (const m of recent) {
+      if (m.role !== 'user' && m.role !== 'assistant') continue;
+      const tid = m.threadId || MAIN_THREAD_ID;
+      getThreadMessages(tid).push({ role: m.role, content: m.content });
+    }
 
     sendUnifyEvent({
       type: 'session_ready',