@yeaft/webchat-agent 1.0.384 → 1.0.385

package/local-runtime/version.json

@@ -1 +1 @@
-{"version":"1.0.384"}
+{"version":"1.0.385"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "1.0.384",
+  "version": "1.0.385",
   "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/cli-session-runner.js

@@ -3,6 +3,7 @@ import { join } from 'node:path';
 import { Engine } from './engine.js';
 import { createRouter } from './routing/router.js';
 import { createCoordinator } from './sessions/coordinator.js';
+import { resolveMemberId } from './sessions/roster.js';
 import { sessionsRoot } from './sessions/session-crud.js';
 import { openSession, loadSessionMeta } from './sessions/session-store.js';
 import { loadSessionConfig, resolveSessionConfig } from './sessions/session-config.js';
@@ -61,6 +62,7 @@ export function createCliSessionRunner({
   workDir = process.cwd(),
   engineFactory = createCliVpEngine,
   personaFactory = buildVpPersona,
+  configureEngine = null,
 } = {}) {
   if (!loaded || !sessionId) return null;
   const sessionDir = join(sessionsRoot(loaded.yeaftDir), sessionId);
@@ -70,12 +72,21 @@ export function createCliSessionRunner({
   const engines = new Map();
   const tails = new Map();
   const pending = new Set();
+  // Root turns are accepted synchronously but execute on per-VP promise tails.
+  // Durable rows therefore cannot use append order as their causal boundary: a
+  // later root user row may be written before an earlier VP starts, while the
+  // earlier VP's assistant rows may be written after that later user row. Every
+  // new row carries one durable causalRootId; the legacy ids remain fallbacks
+  // for rows produced before that field existed.
+  const rootOrderByIdentity = new Map();
+  let nextRootOrder = 0;
   let closed = false;
 
   const engineFor = (vpId) => {
     let engine = engines.get(vpId);
     if (!engine) {
       engine = engineFactory(loaded, sessionId, vpId);
+      if (typeof configureEngine === 'function') configureEngine(engine, vpId);
       engines.set(vpId, engine);
     }
     return engine;
@@ -86,16 +97,56 @@ export function createCliSessionRunner({
   const runEnvelope = async (vpId, envelope, options) => {
     const meta = handle.getMeta();
     const engine = engineFor(vpId);
-    const promptText = envelope?.msg?.text || '';
-    const prompt = `@vp-${vpId} ${promptText}`;
-    const messages = loaded.conversationStore.loadSessionHistoryForVp(sessionId, vpId);
+    const prompt = envelope?.msg?.text || '';
+    const persistedUserClientMessageId = typeof envelope?._persistedUserClientMessageId === 'string'
+      ? envelope._persistedUserClientMessageId
+      : null;
+    const causalRootId = typeof envelope?._cliCausalRootId === 'string' && envelope._cliCausalRootId
+      ? envelope._cliCausalRootId
+      : null;
+    const rootOrder = Number.isInteger(envelope?._cliRootOrder)
+      ? envelope._cliRootOrder
+      : null;
+    // Engine.query() appends `prompt` itself. Exclude this root's durable user
+    // row and every later root turn, regardless of where their assistant/tool
+    // rows landed in the globally sequenced transcript. This preserves rows
+    // completed by earlier accepted roots while preventing future prompts from
+    // entering an earlier provider request.
+    const messages = loaded.conversationStore
+      .loadSessionHistoryForVp(sessionId, vpId)
+      .filter((message) => {
+        if (persistedUserClientMessageId
+            && message?.role === 'user'
+            && message.clientMessageId === persistedUserClientMessageId) return false;
+        if (rootOrder === null) return true;
+        let messageRootOrder = null;
+        if (typeof message?.causalRootId === 'string' && message.causalRootId) {
+          // A durable causal root is authoritative. Do not reinterpret a row by
+          // its role-specific legacy ids when this field is present.
+          messageRootOrder = rootOrderByIdentity.get(message.causalRootId);
+        } else if (message?.role === 'user' && typeof message.clientMessageId === 'string') {
+          messageRootOrder = rootOrderByIdentity.get(message.clientMessageId);
+        } else if (typeof message?.turnId === 'string') {
+          messageRootOrder = rootOrderByIdentity.get(message.turnId);
+        }
+        return !Number.isInteger(messageRootOrder) || messageRootOrder < rootOrder;
+      });
     const todos = [];
     let resultText = '';
     let failed = null;
     const scopedCoordinator = {
       group: coordinator.group,
       ingest(input, opts) {
-        return coordinator.ingest({ ...input, _cliTurnContext: envelope._cliTurnContext }, opts);
+        const report = coordinator.ingest({
+          ...input,
+          _cliRootOrder: envelope._cliRootOrder,
+          _cliCausalRootId: envelope._cliCausalRootId,
+          _cliTurnContext: envelope._cliTurnContext,
+        }, opts);
+        if (rootOrder !== null && typeof report?.message?.id === 'string') {
+          rootOrderByIdentity.set(report.message.id, rootOrder);
+        }
+        return report;
       },
     };
     const queryOptions = {
@@ -110,6 +161,7 @@ export function createCliSessionRunner({
       router: createRouter({ coordinator: scopedCoordinator }),
       inboundEnvelope: envelope,
       userAlreadyPersisted: true,
+      causalRootId,
       threadId: 'main',
       vpTurnId: envelope?.msg?.id || randomUUID(),
       collabToolPolicy: meta.roster.length > 1
@@ -120,7 +172,7 @@ export function createCliSessionRunner({
         todos.splice(0, todos.length, ...(Array.isArray(next) ? next : []));
       },
       askUser: options.askUser
-        ? request => options.askUser(request, vpId, queryOptions.vpTurnId)
+        ? request => options.askUser(request, vpId, queryOptions.vpTurnId, queryOptions.threadId)
         : null,
       userEffort: options.modelEffort || null,
     };
@@ -151,14 +203,17 @@ export function createCliSessionRunner({
     if (closed) throw new Error('CLI Session runner is closed');
     const turnContext = envelope?._cliTurnContext;
     if (!turnContext) throw new Error('CLI Session envelope is missing its turn context');
+    if (turnContext.claimedVpIds.has(vpId)) {
+      return { ok: false, error: 'target_already_claimed' };
+    }
+    turnContext.claimedVpIds.add(vpId);
     const previous = tails.get(vpId) || Promise.resolve();
     const task = previous.catch(() => {}).then(() => runEnvelope(vpId, envelope, turnContext.options));
     tails.set(vpId, task);
     pending.add(task);
-    turnContext.pending.add(task);
+    turnContext.tasks.push(task);
     task.finally(() => {
       pending.delete(task);
-      turnContext.pending.delete(task);
       if (tails.get(vpId) === task) tails.delete(vpId);
     }).catch(() => {});
     return task;
@@ -181,26 +236,87 @@ export function createCliSessionRunner({
     get meta() { return handle.getMeta(); },
     async run(prompt, options = {}) {
       if (closed) throw new Error('CLI Session runner is closed');
-      const turnContext = Object.freeze({ options: Object.freeze({ ...options }), pending: new Set() });
-      const messageId = randomUUID();
-      // The shared user row is the durability boundary. Every VP Engine skips
-      // its own user append, preventing @all from duplicating the prompt N times.
-      loaded.conversationStore.append({
-        role: 'user',
-        content: prompt,
-        sessionId,
-        threadId: 'main',
-        clientMessageId: messageId,
-        userAuthored: true,
+      let routingIntent = options.routingIntent && typeof options.routingIntent === 'object'
+        ? options.routingIntent
+        : null;
+      if (routingIntent) {
+        const meta = handle.getMeta();
+        const rawTargets = Array.isArray(routingIntent.targetVpIds)
+          ? routingIntent.targetVpIds
+          : [];
+        const targetVpIds = [];
+        for (const rawTarget of rawTargets) {
+          const target = typeof rawTarget === 'string' ? rawTarget.trim() : '';
+          const resolved = resolveMemberId(meta, target);
+          if (!resolved) throw new Error(`Unknown stream-json target VP ${target || String(rawTarget)}: not in roster`);
+          if (!targetVpIds.includes(resolved)) targetVpIds.push(resolved);
+        }
+        if (routingIntent.broadcast === true) {
+          for (const vpId of meta.roster) {
+            if (!targetVpIds.includes(vpId)) targetVpIds.push(vpId);
+          }
+        }
+        if (targetVpIds.length === 0) throw new Error('stream-json routing intent requires at least one target VP');
+        routingIntent = Object.freeze({
+          targetVpIds: Object.freeze(targetVpIds),
+          broadcast: routingIntent.broadcast === true,
+          explicit: routingIntent.explicit === true,
+        });
+      }
+      const turnContext = Object.freeze({
+        options: Object.freeze({ ...options }),
+        tasks: [],
+        claimedVpIds: new Set(),
       });
+      const messageId = randomUUID();
+      const rootOrder = nextRootOrder++;
+      rootOrderByIdentity.set(messageId, rootOrder);
+      // The shared user row is the durability boundary. Validate structured
+      // routing above before this append so malformed machine selectors never
+      // enter the transcript or reach a provider.
+      let persistedUserClientMessageId = null;
+      if (!options.internal) {
+        const persistedUser = loaded.conversationStore.append({
+          role: 'user',
+          content: prompt,
+          sessionId,
+          threadId: 'main',
+          clientMessageId: messageId,
+          causalRootId: messageId,
+          userAuthored: true,
+        });
+        persistedUserClientMessageId = persistedUser?.clientMessageId || messageId;
+      }
       const report = coordinator.ingest({
         id: messageId,
-        from: 'user',
-        role: 'user',
+        from: options.internal ? 'tool' : 'user',
+        role: options.internal ? 'assistant' : 'user',
         text: prompt,
+        ...(options.internal ? {
+          internal: true,
+          taskId: options.taskId || null,
+          meta: {
+            ...(options.meta || {}),
+            injectedBy: 'task_result',
+            ...(routingIntent?.targetVpIds?.[0]
+              ? { routeTargetVpId: routingIntent.targetVpIds[0] }
+              : {}),
+          },
+        } : {}),
+        ...(routingIntent ? { _routingIntent: routingIntent } : {}),
+        ...(persistedUserClientMessageId ? { _persistedUserClientMessageId: persistedUserClientMessageId } : {}),
+        _cliRootOrder: rootOrder,
+        _cliCausalRootId: messageId,
         _cliTurnContext: turnContext,
       });
-      const results = await drain(turnContext.pending);
+      const results = [];
+      let cursor = 0;
+      while (cursor < turnContext.tasks.length) {
+        const batch = turnContext.tasks.slice(cursor);
+        cursor += batch.length;
+        results.push(...await Promise.all(batch));
+        await Promise.resolve();
+      }
       return { report, results };
     },
     abort(reason = 'user') {

package/yeaft/cli.js

@@ -38,8 +38,17 @@ import { ConversationStore } from './conversation/persist.js';
 import { snapshotSessions } from './sessions/session-crud.js';
 import { loadSessionConfig, resolveSessionConfig } from './sessions/session-config.js';
 import { validateSessionId } from './sessions/ids.js';
-import { createJsonlWriter, JsonlInput, runStreamTurn, runStreamSessionTurn } from './stdio-protocol.js';
+import {
+  createJsonlWriter,
+  JsonlInput,
+  normalizeStreamRoutingIntent,
+  runStreamTurn,
+  runStreamSessionTurn,
+} from './stdio-protocol.js';
 import { createCliSessionRunner } from './cli-session-runner.js';
+import { emitStreamTaskEvent, taskResultReentryContext } from './tasks/result-delivery.js';
+import { TASK_RESULT_DELIVERY, taskResultDeliveryFor } from './tasks/store.js';
+import { buildStreamSubAgentFrame } from './sub-agent/public-event.js';
 import {
   cleanupManagedCliRuntimePaths,
   ensureManagedCliTools,
@@ -816,6 +825,34 @@ async function runREPL(config, args) {
 
 // ─── Structured stdio handler ──────────────────────────────────
 
+function writeStreamProtocolError({ write, sessionId, error }) {
+  const turnId = randomUUID();
+  const normalized = error instanceof Error ? error : new Error(String(error || 'Unknown error'));
+  write({
+    type: 'error',
+    session_id: sessionId,
+    turn_id: turnId,
+    thread_id: 'main',
+    threadId: 'main',
+    error: { name: normalized.name || 'Error', message: normalized.message || String(normalized) },
+    retryable: false,
+  });
+  const result = {
+    type: 'result',
+    subtype: 'error',
+    session_id: sessionId,
+    turn_id: turnId,
+    thread_id: 'main',
+    threadId: 'main',
+    stop_reason: 'error',
+    is_error: true,
+    result: '',
+    error: normalized.message || String(normalized),
+  };
+  write(result);
+  return result;
+}
+
 async function runStreamJson(config, args) {
   const sessionId = args.sessionId || `session_cli_${randomUUID()}`;
   const validation = validateSessionId(sessionId);
@@ -854,8 +891,148 @@ async function runStreamJson(config, args) {
     managedCliReady: args.managedCliReady,
   });
   const { engine, conversationStore, skillManager, toolRegistry } = loaded;
-  const sessionRunner = createCliSessionRunner({ loaded, sessionId, workDir });
   const todoState = { value: [] };
+  const asyncTaskOwners = new Map();
+  const rescuedTaskIds = new Set();
+  const pendingTaskRescues = new Set();
+  const taskLifecycleWaiters = new Set();
+  let sessionRunner = null;
+  let taskEventIntakeOpen = true;
+  let hadError = false;
+  let singleEngineTail = Promise.resolve();
+
+  const loadStreamHistory = () => conversationStore.loadRecentBySession(sessionId, 20).map(message => ({
+    role: message.role,
+    content: message.content,
+    ...(message.toolCallId && { toolCallId: message.toolCallId }),
+    ...(message.toolCalls && { toolCalls: message.toolCalls }),
+  }));
+
+  // An ad-hoc stream-json conversation has exactly one Engine and no VP roster.
+  // Serialize both root turns and late task-result rescues on that same stable
+  // process owner so a completion cannot race another query or invent a VP id.
+  const runSingleEngineTurn = (turnOptions) => {
+    const turn = singleEngineTail.catch(() => {}).then(() => runStreamTurn({
+      engine,
+      ...turnOptions,
+    }));
+    singleEngineTail = turn;
+    return turn;
+  };
+
+  const wakeTaskLifecycleWaiters = () => {
+    if (taskLifecycleWaiters.size === 0) return;
+    const waiters = Array.from(taskLifecycleWaiters);
+    taskLifecycleWaiters.clear();
+    for (const resolveWaiter of waiters) resolveWaiter();
+  };
+
+  const rescueTaskResult = async (context) => {
+    const taskId = context?.task?.id;
+    if (!taskId || !context?.content || rescuedTaskIds.has(taskId)) return false;
+    if (sessionRunner && !context.vpId) return false;
+    rescuedTaskIds.add(taskId);
+    try {
+      const common = {
+        prompt: context.content,
+        sessionId,
+        workDir,
+        model: loaded.config.model,
+        modelEffort: loaded.config.modelEffort || null,
+        input,
+        write,
+        taskId,
+      };
+      const result = sessionRunner
+        ? await runStreamSessionTurn({
+            runner: sessionRunner,
+            ...common,
+            internal: true,
+            meta: {
+              injectedBy: 'task_result',
+              routeTargetVpId: context.vpId,
+              threadId: context.threadId || 'main',
+            },
+            routingIntent: { targetVpIds: [context.vpId], explicit: true },
+          })
+        : await runSingleEngineTurn({
+            ...common,
+            messages: loadStreamHistory(),
+            threadId: context.threadId || 'main',
+            userAlreadyPersisted: true,
+          });
+      hadError ||= result?.is_error === true;
+      return true;
+    } catch (error) {
+      hadError = true;
+      writeStreamProtocolError({ write, sessionId, error });
+      return false;
+    }
+  };
+
+  const queueTaskRescue = (context) => {
+    if (!taskEventIntakeOpen) return null;
+    let rescue;
+    rescue = rescueTaskResult(context).finally(() => {
+      pendingTaskRescues.delete(rescue);
+      wakeTaskLifecycleWaiters();
+    });
+    pendingTaskRescues.add(rescue);
+    wakeTaskLifecycleWaiters();
+    return rescue;
+  };
+
+  const configureStreamEngine = (targetEngine, vpId = null) => {
+    if (!targetEngine) return;
+    if (typeof targetEngine.setAsyncTaskCoordinator === 'function') {
+      const removeOwner = (taskId, ownerEngine) => {
+        const owner = asyncTaskOwners.get(taskId);
+        if (!owner || owner.engine !== ownerEngine) return null;
+        asyncTaskOwners.delete(taskId);
+        return owner;
+      };
+      targetEngine.setAsyncTaskCoordinator({
+        onRegister(taskId, ownerEngine) {
+          if (!taskId) return;
+          asyncTaskOwners.set(taskId, {
+            engine: ownerEngine,
+            sessionId,
+            vpId: vpId || null,
+            threadId: ownerEngine.currentThreadId || 'main',
+          });
+        },
+        onUnregister: removeOwner,
+        onConsumed: removeOwner,
+        onDeferred(taskId, ownerEngine) {
+          const owner = removeOwner(taskId, ownerEngine);
+          const task = loaded.taskManager?.getTask?.(sessionId, taskId);
+          if (!owner || !task || !['succeeded', 'failed', 'cancelled', 'orphaned'].includes(task.status)) return;
+          const context = taskResultReentryContext({ event: 'completed', task }, { sessionId, owner });
+          if (context) queueTaskRescue(context);
+        },
+        onUndelivered(taskId, delivery, ownerEngine) {
+          const owner = removeOwner(taskId, ownerEngine);
+          if (!owner || rescuedTaskIds.has(taskId)) return;
+          queueTaskRescue({
+            task: { id: taskId, kind: delivery?.taskKind, status: delivery?.taskStatus },
+            sessionId: delivery?.sessionId || owner.sessionId,
+            vpId: delivery?.vpId || owner.vpId,
+            threadId: delivery?.threadId || owner.threadId,
+            content: delivery?.content,
+          });
+        },
+      });
+    }
+    if (typeof targetEngine.setSubAgentEventSink === 'function') {
+      targetEngine.setSubAgentEventSink((agentId, event) => {
+        const frame = buildStreamSubAgentFrame({ event, agentId, sessionId, vpId, threadId: targetEngine.currentThreadId });
+        if (frame) write(frame);
+      });
+    }
+  };
+
+  configureStreamEngine(engine, null);
+  sessionRunner = createCliSessionRunner({ loaded, sessionId, workDir, configureEngine: configureStreamEngine });
 
   write({
     type: 'system',
@@ -870,16 +1047,57 @@ async function runStreamJson(config, args) {
     output_format: 'stream-json',
   });
 
-  const runPrompt = async (prompt) => {
-    const priorMessages = conversationStore.loadRecentBySession(sessionId, 20).map(message => ({
-      role: message.role,
-      content: message.content,
-      ...(message.toolCallId && { toolCallId: message.toolCallId }),
-      ...(message.toolCalls && { toolCalls: message.toolCalls }),
-    }));
+  if (loaded.taskManager && typeof loaded.taskManager.setEventSink === 'function') {
+    loaded.taskManager.setEventSink((event) => {
+      if (!taskEventIntakeOpen) return;
+      const hadExactOwner = asyncTaskOwners.has(event?.task?.id);
+      const delivery = emitStreamTaskEvent({ event, asyncTaskOwners, write, sessionId });
+      if (delivery.projected && !delivery.delivered && !hadExactOwner && event?.event === 'completed') {
+        const context = taskResultReentryContext(event, { sessionId });
+        if (context) queueTaskRescue(context);
+      }
+      wakeTaskLifecycleWaiters();
+    });
+  }
+
+  const activeModelReentryTasks = () => {
+    if (!loaded.taskManager || typeof loaded.taskManager.listActiveTasks !== 'function') return [];
+    return loaded.taskManager.listActiveTasks(sessionId).filter(task => (
+      taskResultDeliveryFor(task) === TASK_RESULT_DELIVERY.MODEL_REENTRY
+    ));
+  };
+
+  const drainTaskLifecycle = async () => {
+    if (!loaded.taskManager || typeof loaded.taskManager.setEventSink !== 'function') {
+      taskEventIntakeOpen = false;
+      return;
+    }
+    // EOF is a lifecycle fence, not permission to abandon model-reentry work.
+    // Keep the Session runner and task event sink alive until every owned
+    // result-producing task is terminal and every resulting rescue turn has
+    // settled. `status_only` tasks remain detached and never hold CLI exit.
+    for (;;) {
+      if (activeModelReentryTasks().length === 0 && pendingTaskRescues.size === 0) {
+        // JavaScript runs this check + close synchronously. No TaskManager
+        // completion can interleave between observing the empty sets and
+        // detaching the sink, so no late rescue can target a closed runner.
+        taskEventIntakeOpen = false;
+        loaded.taskManager.setEventSink(null);
+        wakeTaskLifecycleWaiters();
+        return;
+      }
+      await new Promise(resolveWaiter => taskLifecycleWaiters.add(resolveWaiter));
+    }
+  };
+
+  const runPrompt = async (prompt, message = null) => {
+    const routingIntent = normalizeStreamRoutingIntent(message);
+    if (routingIntent && !sessionRunner) {
+      throw new Error('stream-json VP selectors require an existing formal Session with a persisted roster');
+    }
     const turnOptions = {
       prompt,
-      messages: priorMessages,
+      messages: loadStreamHistory(),
       sessionId,
       workDir,
       model: loaded.config.model,
@@ -890,31 +1108,45 @@ async function runStreamJson(config, args) {
       setCurrentTodos: todos => { todoState.value = Array.isArray(todos) ? todos.slice() : []; },
     };
     return sessionRunner
-      ? runStreamSessionTurn({ runner: sessionRunner, ...turnOptions })
-      : runStreamTurn({ engine, ...turnOptions });
+      ? runStreamSessionTurn({ runner: sessionRunner, routingIntent, ...turnOptions })
+      : runSingleEngineTurn(turnOptions);
   };
 
-  let hadError = false;
   const recordResult = (result) => {
     hadError ||= result?.is_error === true;
     return result;
   };
   try {
     if (args.prompt) {
-      recordResult(await runPrompt(args.prompt));
+      try {
+        recordResult(await runPrompt(args.prompt));
+      } catch (error) {
+        recordResult(writeStreamProtocolError({ write, sessionId, error }));
+      }
     } else if (input) {
       for (;;) {
         const item = await input.nextPrompt();
         if (!item) break;
-        recordResult(await runPrompt(item.prompt));
+        try {
+          recordResult(await runPrompt(item.prompt, item.message));
+        } catch (error) {
+          recordResult(writeStreamProtocolError({ write, sessionId, error }));
+        }
       }
     } else {
       let prompt = '';
       for await (const chunk of process.stdin) prompt += chunk;
-      if (prompt.trim()) recordResult(await runPrompt(prompt.trim()));
+      if (prompt.trim()) {
+        try {
+          recordResult(await runPrompt(prompt.trim()));
+        } catch (error) {
+          recordResult(writeStreamProtocolError({ write, sessionId, error }));
+        }
+      }
     }
   } finally {
     input?.close();
+    await drainTaskLifecycle();
     await sessionRunner?.close();
     await loaded.shutdown();
     console.log = originalConsole.log;

package/yeaft/conversation/persist.js

@@ -434,6 +434,7 @@ function serializeMessage(msg) {
   // Defaults to 'main' for legacy messages (see migrate-messages-threadid.js).
   fm.push(`threadId: ${msg.threadId || 'main'}`);
   if (msg.turnId) fm.push(`turnId: ${msg.turnId}`);
+  if (msg.causalRootId) fm.push(`causalRootId: ${msg.causalRootId}`);
   if (msg.executionOrigin === 'route_forward') fm.push('executionOrigin: route_forward');
   if (msg.imageAssetAnchor) fm.push('imageAssetAnchor: true');
   // task-313: when a thread is merged into another, the messages keep
@@ -581,6 +582,7 @@ export function parseMessage(raw) {
       case 'tokens_est': msg.tokens_est = parseInt(value, 10); break;
       case 'threadId': msg.threadId = value; break;
       case 'turnId': msg.turnId = value; break;
+      case 'causalRootId': msg.causalRootId = value; break;
       case 'executionOrigin':
         if (value === 'route_forward') msg.executionOrigin = value;
         break;