@yeaft/webchat-agent 0.1.936 → 0.1.938

package/conversation.js

@@ -457,11 +457,19 @@ export async function resumeConversation(msg) {
     if (id === conversationId || (claudeSessionId && conv.claudeSessionId === claudeSessionId)) {
       console.log(`[Resume] Cleaning up old conversation: ${id} (claudeSessionId: ${conv.claudeSessionId})`);
       if (conv.providerOptions && !priorProviderOptions) priorProviderOptions = conv.providerOptions;
-      if (conv.abortController) {
-        conv.abortController.abort();
-      }
-      if (conv.inputStream) {
-        try { conv.inputStream.done(); } catch {}
+      let cleanupDriver = null;
+      try {
+        cleanupDriver = getProvider(conv.providerName || provider || DEFAULT_PROVIDER);
+      } catch { /* fallback to legacy cleanup below */ }
+      if (typeof cleanupDriver?.dispose === 'function') {
+        cleanupDriver.dispose(conv, 'resume cleanup');
+      } else {
+        if (conv.abortController) {
+          conv.abortController.abort();
+        }
+        if (conv.inputStream) {
+          try { conv.inputStream.done(); } catch {}
+        }
       }
       ctx.conversations.delete(id);
     }
@@ -783,17 +791,23 @@ export async function handleUserInput(msg) {
 
     // /clear for capable providers — reset session in-place without spawning new turn
     if (slashCommand.type === 'slash' && slashCommand.command === '/clear') {
+      state.turnActive = true;
+      state.turnCompletedEmitted = false;
+      state.turnErrorEmitted = false;
       if (typeof driver.clear === 'function' && driver.capabilities?.clear) {
         try { await driver.clear(state); } catch (err) {
           console.warn(`[${conversationId}] driver.clear failed:`, err?.message || err);
         }
       }
-      ctx.sendToServer({
-        type: 'turn_completed',
-        conversationId,
-        claudeSessionId: state.sessionId || state.claudeSessionId,
-        workDir: state.workDir
-      });
+      if (!state.turnCompletedEmitted) {
+        ctx.sendToServer({
+          type: 'turn_completed',
+          conversationId,
+          claudeSessionId: state.sessionId || state.claudeSessionId,
+          workDir: state.workDir
+        });
+      }
+      state.turnActive = false;
       return;
     }
 
@@ -812,6 +826,10 @@ export async function handleUserInput(msg) {
       });
     } finally {
       state.turnActive = false;
+      if (state._abortKillTimer) {
+        clearTimeout(state._abortKillTimer);
+        state._abortKillTimer = null;
+      }
       sendConversationList();
     }
     return;
@@ -976,7 +994,7 @@ export function handleAskUserAnswer(msg) {
         if (typeof driver.respondToPermissionRequest === 'function') {
           const ans = msg.answers || {};
           const optionId = typeof ans === 'string' ? ans
-            : ans.optionId || ans.option || Object.values(ans)[0];
+            : ans.optionId || ans.option || ans['Copilot permission'] || Object.values(ans)[0];
           driver.respondToPermissionRequest(state, msg.requestId, optionId);
           return;
         }

package/package.json

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

package/providers/copilot.js

@@ -38,12 +38,7 @@ export async function start(opts) {
   const conversationId = opts.conversationId;
   // Tear down any prior entry so we don't leak children.
   const prior = ctx.conversations.get(conversationId);
-  if (prior?.copilotChild) {
-    try { prior.copilotChild.kill('SIGTERM'); } catch { /* noop */ }
-  }
-  if (prior?.acpClient) {
-    try { prior.acpClient.close('replaced'); } catch { /* noop */ }
-  }
+  dispose(prior, 'replaced');
 
   const providerOptions = opts.providerOptions || prior?.providerOptions || {};
   const model = providerOptions.model || DEFAULT_COPILOT_MODEL;
@@ -116,31 +111,16 @@ async function _bootAcp(state, resumeSessionId, model) {
     }
   });
   child.on('error', (err) => {
-    sendOutput(state.conversationId, {
-      type: 'result',
-      subtype: 'error',
-      session_id: state.sessionId,
-      is_error: true,
-      error: `copilot process error: ${err?.message || err}`,
-    });
+    _sendTurnError(state, `copilot process error: ${err?.message || err}`);
   });
   child.on('close', (code) => {
     if (state.turnActive) {
       const tail = stderrBuf.trim().slice(-2000);
-      sendOutput(state.conversationId, {
-        type: 'result',
-        subtype: 'error',
-        session_id: state.sessionId,
-        is_error: true,
-        error: tail || `copilot exited mid-turn (code ${code})`,
-      });
-      ctx.sendToServer({
-        type: 'turn_completed',
-        conversationId: state.conversationId,
-        claudeSessionId: state.sessionId,
-        workDir: state.workDir,
-      });
-      state.turnActive = false;
+      _sendTurnError(state, tail || `copilot exited mid-turn (code ${code})`);
+      _completeTurn(state);
+    }
+    if (state.acpClient) {
+      try { state.acpClient.close(`copilot exited (code ${code})`); } catch { /* noop */ }
     }
     // Drain any in-flight permission prompts so the frontend dialog unwedges
     // and the Promise GC roots release.
@@ -180,6 +160,7 @@ async function _bootAcp(state, resumeSessionId, model) {
     state.claudeSessionId = resumeSessionId;
     if (Array.isArray(r?.modes?.availableModes)) state.acpModes = r.modes.availableModes;
     if (Array.isArray(r?.models?.availableModels)) cacheCopilotModelsFromAcp(r.models.availableModels);
+    _sendSessionIdUpdate(state);
   } else {
     if (resumeSessionId && !state.acpCapabilities.loadSession) {
       // Surface the downgrade — silently handing back a fresh session would
@@ -198,6 +179,7 @@ async function _bootAcp(state, resumeSessionId, model) {
     state.claudeSessionId = state.sessionId;
     if (Array.isArray(r?.modes?.availableModes)) state.acpModes = r.modes.availableModes;
     if (Array.isArray(r?.models?.availableModels)) cacheCopilotModelsFromAcp(r.models.availableModels);
+    _sendSessionIdUpdate(state);
   }
 
   // 3) Emit a system_init envelope so the UI populates tools / model panels.
@@ -224,14 +206,8 @@ export async function sendInput(state, prompt, opts = {}) {
     try {
       await _bootAcp(state, state.sessionId || null, state.model);
     } catch (err) {
-      sendOutput(conversationId, {
-        type: 'result',
-        subtype: 'error',
-        session_id: state.sessionId,
-        is_error: true,
-        error: `copilot ACP reinit failed: ${err?.message || err}`,
-      });
-      ctx.sendToServer({ type: 'turn_completed', conversationId, claudeSessionId: state.sessionId, workDir: state.workDir });
+      _sendTurnError(state, `copilot ACP reinit failed: ${err?.message || err}`);
+      _completeTurn(state, conversationId);
       return;
     }
   }
@@ -247,6 +223,8 @@ export async function sendInput(state, prompt, opts = {}) {
   const abortController = new AbortController();
   state.abortController = abortController;
   state.turnActive = true;
+  state.turnCompletedEmitted = false;
+  state.turnErrorEmitted = false;
   state.turnResultReceived = false;
 
   // Build prompt content blocks. ACP ContentBlock variants: text, image,
@@ -289,21 +267,9 @@ export async function sendInput(state, prompt, opts = {}) {
       error: isErr ? `copilot stop_reason=${stopReason}` : undefined,
     });
   } catch (err) {
-    sendOutput(conversationId, {
-      type: 'result',
-      subtype: 'error',
-      session_id: state.sessionId,
-      is_error: true,
-      error: err?.message || String(err),
-    });
+    _sendTurnError(state, err?.message || String(err));
   } finally {
-    state.turnActive = false;
-    ctx.sendToServer({
-      type: 'turn_completed',
-      conversationId,
-      claudeSessionId: state.sessionId,
-      workDir: state.workDir,
-    });
+    _completeTurn(state, conversationId);
   }
 }
 
@@ -330,12 +296,44 @@ export function abort(state) {
   }
 }
 
+export function dispose(state, reason = 'disposed') {
+  if (!state) return;
+  if (state.abortController) {
+    try { state.abortController.abort(); } catch { /* noop */ }
+    state.abortController = null;
+  }
+  if (state._abortKillTimer) {
+    clearTimeout(state._abortKillTimer);
+    state._abortKillTimer = null;
+  }
+  _drainPendingPermissions(state, reason);
+  if (state.acpClient) {
+    try { state.acpClient.close(reason); } catch { /* noop */ }
+    state.acpClient = null;
+  }
+  if (state.copilotChild) {
+    try { state.copilotChild.kill('SIGTERM'); } catch { /* noop */ }
+    state.copilotChild = null;
+  }
+  state.initialized = false;
+  state.turnActive = false;
+}
+
 /**
  * /clear support: ask ACP for a brand-new session under the same
  * conversationId. Keeps the child alive — no spawn cost.
  */
 export async function clear(state) {
-  if (!state?.acpClient) return;
+  if (!state) return;
+  if (!state.initialized || !state.acpClient) {
+    try {
+      await _bootAcp(state, null, state.model);
+      return;
+    } catch (err) {
+      _sendTurnError(state, `copilot ACP reinit failed during clear: ${err?.message || err}`);
+      return;
+    }
+  }
   // A fresh session invalidates any in-flight permission prompts.
   _drainPendingPermissions(state, 'session cleared');
   try {
@@ -345,6 +343,7 @@ export async function clear(state) {
     });
     state.sessionId = r?.sessionId || randomUUID();
     state.claudeSessionId = state.sessionId;
+    _sendSessionIdUpdate(state);
     sendOutput(state.conversationId, {
       type: 'system',
       subtype: 'init',
@@ -355,6 +354,7 @@ export async function clear(state) {
       permissionMode: state.allowAllTools ? 'bypassPermissions' : 'default',
     });
   } catch (err) {
+    _sendTurnError(state, `copilot clear failed: ${err?.message || err}`);
     if (ctx?.CONFIG?.debug) console.warn('[copilot] clear failed:', err?.message || err);
   }
 }
@@ -365,6 +365,40 @@ function sendOutput(conversationId, data) {
   ctx.sendToServer({ type: 'claude_output', conversationId, data });
 }
 
+function _sendSessionIdUpdate(state) {
+  if (!state?.conversationId || !state.sessionId) return;
+  ctx.sendToServer({
+    type: 'session_id_update',
+    conversationId: state.conversationId,
+    claudeSessionId: state.sessionId,
+    workDir: state.workDir,
+  });
+}
+
+function _sendTurnError(state, error) {
+  if (!state || state.turnErrorEmitted) return;
+  state.turnErrorEmitted = true;
+  sendOutput(state.conversationId, {
+    type: 'result',
+    subtype: 'error',
+    session_id: state.sessionId,
+    is_error: true,
+    error,
+  });
+}
+
+function _completeTurn(state, conversationId = state?.conversationId) {
+  if (!state || state.turnCompletedEmitted) return;
+  state.turnCompletedEmitted = true;
+  state.turnActive = false;
+  ctx.sendToServer({
+    type: 'turn_completed',
+    conversationId,
+    claudeSessionId: state.sessionId,
+    workDir: state.workDir,
+  });
+}
+
 function _handleAcpNotification(state, method, params) {
   if (method === 'session/update') {
     _handleSessionUpdate(state, params);
@@ -474,19 +508,36 @@ async function _handlePermissionRequest(state, params) {
     const allow = opt.find(o => o.kind === 'allow_always' || o.kind === 'allow_once') || opt[0];
     return { outcome: { outcome: 'selected', optionId: allow.optionId } };
   }
-  // Otherwise route through the existing ask-user wire path. We do it inline
-  // here using a per-state Promise; the frontend responds via the standard
-  // `ask_user_response` message which conversation.js routes back into the
-  // driver via `respondToPermissionRequest(state, requestId, optionId)`.
+  // Otherwise route through the existing AskUserQuestion UI. Emit the same
+  // Claude-style tool_use first, then link it with ask_user_question so the
+  // regular card renders and answer routing can stay provider-agnostic.
   const requestId = `copilot-perm-${randomUUID()}`;
+  const question = _formatPermissionPrompt(params);
+  const questions = [{
+    header: 'Copilot permission',
+    question,
+    options: opt.map(o => ({ label: o.name || o.optionId })),
+    multiSelect: false,
+  }];
+  sendOutput(state.conversationId, {
+    type: 'assistant',
+    message: {
+      role: 'assistant',
+      content: [{
+        type: 'tool_use',
+        id: requestId,
+        name: 'AskUserQuestion',
+        input: { questions },
+      }],
+    },
+  });
   return new Promise((resolve) => {
     state.pendingPermissions.set(requestId, { resolve, options: opt });
     ctx.sendToServer({
       type: 'ask_user_question',
       conversationId: state.conversationId,
       requestId,
-      question: _formatPermissionPrompt(params),
-      options: opt.map(o => ({ id: o.optionId, label: o.name || o.optionId, kind: o.kind })),
+      questions,
     });
   });
 }
@@ -518,7 +569,7 @@ export function respondToPermissionRequest(state, requestId, optionId) {
     return false;
   }
   state.pendingPermissions.delete(requestId);
-  const opt = slot.options.find(o => o.optionId === optionId) || slot.options[0];
+  const opt = slot.options.find(o => o.optionId === optionId || o.name === optionId) || slot.options[0];
   slot.resolve({ outcome: { outcome: 'selected', optionId: opt?.optionId || optionId } });
   return true;
 }

package/yeaft/engine.js

@@ -42,7 +42,7 @@ import { countTurns } from './turn-utils.js';
 import { attachRouterPlan, extractPriorPlan, stripMetaForWire } from './router/continuity.js';
 import { resolveThinking } from './router/thinking.js';
 import { approxTokens } from './memory/budget.js';
-import { truncateToolResultIfNeeded } from './tools/registry.js';
+import { COLLAB_TOOL_POLICY, truncateToolResultIfNeeded } from './tools/registry.js';
 import {
   TOOL_BATCH_SIZE,
   TURN_SUMMARY_THRESHOLD,
@@ -551,9 +551,9 @@ export class Engine {
    *
    * @returns {import('./llm/adapter.js').UnifiedToolDef[]}
    */
-  #getToolDefs() {
+  #getToolDefs(collabToolPolicy = null) {
     if (this.#toolRegistry) {
-      return this.#toolRegistry.getToolDefs(this.#config?.language || 'en');
+      return this.#toolRegistry.getToolDefs(this.#config?.language || 'en', { collabToolPolicy });
     }
     // Legacy path: no mode filtering
     const defs = [];
@@ -1339,7 +1339,7 @@ export class Engine {
    *   string-prompt shape (no regression for existing callers).
    * @yields {EngineEvent}
    */
-  async *query({ prompt, promptParts = null, messages = [], signal, userEffort = null, scenario = 'chat', vpPersona, router, senderVpId, inboundEnvelope, taskId, taskMembers, sessionId, vpPlan, sessionAnnouncement, workDir, userAlreadyPersisted = false, getCurrentTodos = null, setCurrentTodos = null, threadId = MAIN_THREAD_ID, drainPendingUserMessages = null } = {}) {
+  async *query({ prompt, promptParts = null, messages = [], signal, userEffort = null, scenario = 'chat', vpPersona, router, senderVpId, inboundEnvelope, taskId, taskMembers, sessionId, vpPlan, sessionAnnouncement, workDir, userAlreadyPersisted = false, getCurrentTodos = null, setCurrentTodos = null, threadId = MAIN_THREAD_ID, drainPendingUserMessages = null, collabToolPolicy = null } = {}) {
     if (!prompt || typeof prompt !== 'string' || !prompt.trim()) {
       yield {
         type: 'error',
@@ -1365,6 +1365,9 @@ export class Engine {
     const parsed = parseEffortPrefix(prompt);
     const effectivePrompt = parsed.cleanedPrompt;
     const effectiveUserEffort = normalizeEffort(userEffort) || parsed.effort || null;
+    const effectiveCollabToolPolicy = collabToolPolicy === COLLAB_TOOL_POLICY.SINGLE_VP || collabToolPolicy === COLLAB_TOOL_POLICY.MULTI_VP
+      ? collabToolPolicy
+      : null;
 
     // ─── task-325a: engine-owned AbortController ─────────────
     // We create our own controller for this query run so `engine.abort()`
@@ -1399,7 +1402,7 @@ export class Engine {
 
     try {
       this.#currentThreadId = threadId || MAIN_THREAD_ID;
-      yield* this.#runQuery({ prompt: effectivePrompt, promptParts, messages, signal: runSignal, userEffort: effectiveUserEffort, scenario, vpPersona, router, senderVpId, inboundEnvelope, taskId, taskMembers, sessionId, vpPlan, sessionAnnouncement, workDir, userAlreadyPersisted, getCurrentTodos, setCurrentTodos, threadId: this.#currentThreadId, drainPendingUserMessages });
+      yield* this.#runQuery({ prompt: effectivePrompt, promptParts, messages, signal: runSignal, userEffort: effectiveUserEffort, scenario, vpPersona, router, senderVpId, inboundEnvelope, taskId, taskMembers, sessionId, vpPlan, sessionAnnouncement, workDir, userAlreadyPersisted, getCurrentTodos, setCurrentTodos, threadId: this.#currentThreadId, drainPendingUserMessages, collabToolPolicy: effectiveCollabToolPolicy });
     } finally {
       if (signal) {
         try { signal.removeEventListener('abort', onExternalAbort); } catch { /* ignore */ }
@@ -1419,7 +1422,11 @@ export class Engine {
    * in a try/finally without indenting the whole loop.
    * @private
    */
-  async *#runQuery({ prompt, promptParts = null, messages, signal, userEffort = null, scenario = 'chat', vpPersona, router, senderVpId, inboundEnvelope, taskId, taskMembers, sessionId, vpPlan, sessionAnnouncement, workDir, userAlreadyPersisted = false, getCurrentTodos = null, setCurrentTodos = null, threadId = MAIN_THREAD_ID, drainPendingUserMessages = null }) {
+  async *#runQuery({ prompt, promptParts = null, messages, signal, userEffort = null, scenario = 'chat', vpPersona, router, senderVpId, inboundEnvelope, taskId, taskMembers, sessionId, vpPlan, sessionAnnouncement, workDir, userAlreadyPersisted = false, getCurrentTodos = null, setCurrentTodos = null, threadId = MAIN_THREAD_ID, drainPendingUserMessages = null, collabToolPolicy = null }) {
+
+    const effectiveCollabToolPolicy = collabToolPolicy === COLLAB_TOOL_POLICY.SINGLE_VP || collabToolPolicy === COLLAB_TOOL_POLICY.MULTI_VP
+      ? collabToolPolicy
+      : null;
 
     // ─── Pre-query: FTS5 Memory Recall + AMS snapshot ─────
     // Memory has a SINGLE render outlet now (DESIGN-PROMPT §3 ③):
@@ -1685,7 +1692,7 @@ export class Engine {
       };
     }
 
-    const toolDefs = this.#getToolDefs();
+    const toolDefs = this.#getToolDefs(effectiveCollabToolPolicy);
     let turnNumber = 0;
     let continueTurns = 0; // auto-continue counter
     let toolLoopTurns = 0; // task-327b: tool-use turns for long-loop auto-bump
@@ -2408,7 +2415,7 @@ export class Engine {
 
         // Resolve tool: prefer ToolRegistry, fallback to legacy #tools Map
         const hasTool = this.#toolRegistry
-          ? this.#toolRegistry.has(tc.name)
+          ? this.#toolRegistry.isAllowed(tc.name, { collabToolPolicy: effectiveCollabToolPolicy })
           : this.#tools.has(tc.name);
 
         if (!hasTool) {

package/yeaft/tools/registry.js

@@ -11,6 +11,27 @@
 
 import { formatSize } from '../archive/tool-results.js';
 
+/**
+ * Collaboration tools are mutually exclusive per Yeaft group shape:
+ * single-VP groups use sub-agents; multi-VP groups use VP-to-VP forwarding.
+ * Keep the policy names close to the tool registry so LLM exposure and
+ * execution gating use the same source of truth.
+ */
+export const COLLAB_TOOL_POLICY = Object.freeze({
+  SINGLE_VP: 'single-vp',
+  MULTI_VP: 'multi-vp',
+});
+
+export const SUB_AGENT_TOOL_NAMES = Object.freeze([
+  'SpawnAgent',
+  'PromptAgent',
+  'WaitAgent',
+  'CloseAgent',
+  'ListAgents',
+]);
+
+export const FORWARD_TOOL_NAMES = Object.freeze(['RouteForward']);
+
 /**
  * Per-tool-result hard cap.
  *
@@ -208,6 +229,20 @@ function runWithTimeout(promise, timeoutMs, toolName) {
   });
 }
 
+export function normalizeCollabToolPolicy(policy) {
+  if (policy === COLLAB_TOOL_POLICY.SINGLE_VP || policy === COLLAB_TOOL_POLICY.MULTI_VP) {
+    return policy;
+  }
+  return null;
+}
+
+export function isToolHiddenByCollabPolicy(toolName, policy) {
+  const normalized = normalizeCollabToolPolicy(policy);
+  if (!normalized) return false;
+  if (normalized === COLLAB_TOOL_POLICY.SINGLE_VP) return FORWARD_TOOL_NAMES.includes(toolName);
+  return SUB_AGENT_TOOL_NAMES.includes(toolName);
+}
+
 export class ToolRegistry {
   /** @type {Map<string, import('./types.js').ToolDef>} */
   #tools = new Map();
@@ -293,17 +328,36 @@ export class ToolRegistry {
 
   /**
    * Get tool definitions for the LLM adapter.
-   * Returns all registered tools — mode filtering was removed in task-297.
+   * Returns all registered tools unless a collaboration policy hides one of
+   * the mutually-exclusive orchestration tool families.
    * @param {string} [language='en']
+   * @param {{ collabToolPolicy?: string }} [opts]
    * @returns {{ name: string, description: string, parameters: object }[]}
    */
-  getToolDefs(language = 'en') {
+  getToolDefs(language = 'en', opts = {}) {
     const lang = normalizeLanguage(language);
-    return this.getAllTools().map(t => ({
-      name: t.name,
-      description: localizeVisibleText(t.description, lang, t.name),
-      parameters: localizeParameters(t.parameters, lang, t.name),
-    }));
+    const collabToolPolicy = normalizeCollabToolPolicy(opts?.collabToolPolicy);
+    return this.getAllTools()
+      .filter(t => !isToolHiddenByCollabPolicy(t.name, collabToolPolicy))
+      .map(t => ({
+        name: t.name,
+        description: localizeVisibleText(t.description, lang, t.name),
+        parameters: localizeParameters(t.parameters, lang, t.name),
+      }));
+  }
+
+  /**
+   * Check whether a tool may be called under the current collaboration policy.
+   * Unknown / absent policy keeps the historical behavior: all registered
+   * tools remain callable.
+   * @param {string} name
+   * @param {{ collabToolPolicy?: string }} [opts]
+   * @returns {boolean}
+   */
+  isAllowed(name, opts = {}) {
+    const tool = this.#tools.get(name);
+    if (!tool) return false;
+    return !isToolHiddenByCollabPolicy(tool.name, opts?.collabToolPolicy);
   }
 
   /**

package/yeaft/web-bridge.js

@@ -19,6 +19,7 @@
  */
 
 import { join } from 'node:path';
+import { COLLAB_TOOL_POLICY } from './tools/registry.js';
 import { existsSync } from 'node:fs';
 import { randomUUID } from 'node:crypto';
 import { buildDreamOutputSnapshot } from './dream/output-snapshot.js';
@@ -2616,6 +2617,14 @@ async function waitForVpDrivers(_groupId, driverKeys = []) {
  *   `route_forward` can extend `causedBy` chains correctly. Optional only
  *   for pre-707 callers that no longer exist in production.
  */
+function resolveCollabToolPolicy(sessionMeta) {
+  if (!sessionMeta || typeof sessionMeta !== 'object' || !Array.isArray(sessionMeta.roster)) {
+    return null;
+  }
+  const vpCount = new Set(sessionMeta.roster.filter(v => typeof v === 'string' && v.trim())).size;
+  return vpCount > 1 ? COLLAB_TOOL_POLICY.MULTI_VP : COLLAB_TOOL_POLICY.SINGLE_VP;
+}
+
 export function buildVpQueryOpts({ vpId, sessionCoordinator, sessionId, envelope, threadId = 'main' }) {
   // Read the group meta once and reuse for both defaultVpId fallback and
   // announcement injection. Each .getMeta() reload reads + parses the
@@ -2656,6 +2665,8 @@ export function buildVpQueryOpts({ vpId, sessionCoordinator, sessionId, envelope
   if (typeof sessionId === 'string' && sessionId.trim()) {
     out.sessionId = sessionId.trim();
   }
+  const collabToolPolicy = resolveCollabToolPolicy(sessionMeta);
+  if (collabToolPolicy) out.collabToolPolicy = collabToolPolicy;
   // task-334-group-editor: surface the group announcement to the engine so
   // buildWorkerPrompt can inject it as a CLAUDE.md-style shared prefix.
   // Empty/missing reads as '' and prompts.js skips the section.