@yeaft/webchat-agent 0.1.823 → 0.1.826

package/package.json

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

package/unify/debug-trace.js

@@ -125,6 +125,38 @@ function truncate(str, max) {
   return str.slice(0, max) + '... [truncated]';
 }
 
+function truncatedJsonSentinel(originalBytes) {
+  return {
+    __truncated: true,
+    originalBytes,
+    maxBytes: MAX_LOOP_PAYLOAD,
+  };
+}
+
+function truncateJsonValue(value) {
+  if (value == null) return value;
+  if (typeof value === 'string') return truncate(value, MAX_LOOP_PAYLOAD);
+  try {
+    const s = JSON.stringify(value);
+    if (s.length <= MAX_LOOP_PAYLOAD) return value;
+    return truncatedJsonSentinel(s.length);
+  } catch {
+    return null;
+  }
+}
+
+function boundDreamEventData(eventType, eventData) {
+  if (eventType !== 'dream_loop' || !eventData || typeof eventData !== 'object') return eventData;
+  return {
+    ...eventData,
+    systemPrompt: truncateJsonValue(eventData.systemPrompt),
+    messages: truncateJsonValue(eventData.messages),
+    response: truncateJsonValue(eventData.response),
+    rawRequest: truncateJsonValue(eventData.rawRequest),
+    rawResponse: truncateJsonValue(eventData.rawResponse),
+  };
+}
+
 /**
  * DebugTrace — SQLite-backed debug trace.
  */
@@ -229,11 +261,7 @@ export class DebugTrace {
       try {
         const s = JSON.stringify(v);
         if (s.length <= MAX_LOOP_PAYLOAD) return s;
-        return JSON.stringify({
-          __truncated: true,
-          originalBytes: s.length,
-          maxBytes: MAX_LOOP_PAYLOAD,
-        });
+        return JSON.stringify(truncatedJsonSentinel(s.length));
       } catch { return null; }
     };
     // For raw request/response, accept either a pre-stringified blob
@@ -304,7 +332,8 @@ export class DebugTrace {
   logEvent({ traceId, eventType, eventData = null }) {
     const id = randomUUID();
     const now = Date.now();
-    const data = eventData != null ? JSON.stringify(eventData) : null;
+    const boundedData = boundDreamEventData(eventType, eventData);
+    const data = boundedData != null ? JSON.stringify(boundedData) : null;
     this.#prepare('insertEvent', `
       INSERT INTO trace_events (id, trace_id, event_type, event_data, created_at)
       VALUES (?, ?, ?, ?, ?)
@@ -312,6 +341,19 @@ export class DebugTrace {
     return id;
   }
 
+  /**
+   * Compatibility helper used by older engine/dream call sites.
+   * @param {string} eventType
+   * @param {unknown} eventData
+   * @returns {string}
+   */
+  event(eventType, eventData = null) {
+    const traceId = (eventData && typeof eventData === 'object' && (eventData.turnId || eventData.runId))
+      ? String(eventData.turnId || eventData.runId)
+      : String(eventType || 'event');
+    return this.logEvent({ traceId, eventType, eventData });
+  }
+
   // ─── Read API ────────────────────────────────────────────────
 
   /**
@@ -477,7 +519,9 @@ export class DebugTrace {
     const dreamEvents = [];
     if (dreamLim > 0) {
       const eventRows = this.#db.prepare(`
-        SELECT * FROM trace_events WHERE event_type = 'dream_progress' ORDER BY created_at DESC LIMIT ?
+        SELECT * FROM trace_events
+        WHERE event_type IN ('dream_progress', 'dream_loop', 'dream_turn_open', 'dream_turn_close', 'dream_run')
+        ORDER BY created_at DESC, rowid DESC LIMIT ?
       `).all(Math.max(dreamLim * 5, dreamLim));
       for (const er of eventRows) {
         const data = parseJsonSafe(er.event_data) || {};
@@ -488,7 +532,12 @@ export class DebugTrace {
           const isThisGroup = evtGroupId === groupId || target === `group/${groupId}`;
           if (!isBroadcast && !isThisGroup) continue;
         }
-        dreamEvents.push({ type: 'dream_progress', ...data, at: er.created_at, ts: data.ts || er.created_at });
+        dreamEvents.push({
+          type: data.type || (er.event_type === 'dream_progress' ? 'dream_progress' : er.event_type),
+          ...data,
+          at: er.created_at,
+          ts: data.ts || data.at || er.created_at,
+        });
         if (dreamEvents.length >= dreamLim) break;
       }
       dreamEvents.reverse();
@@ -638,6 +687,7 @@ export class NullTrace {
   endTurn() {}
   logTool() { return 'null'; }
   logEvent() { return 'null'; }
+  event() { return 'null'; }
   queryByMessage() { return { turns: [], tools: [], events: [] }; }
   queryByTrace() { return { turns: [], tools: [], events: [] }; }
   queryRecent() { return []; }

package/unify/dream-v2/session-wiring.js

@@ -128,29 +128,128 @@ function makeLlm(session) {
     });
 
     // Emit complete loop event (request + response) to the debug panel.
+    const latencyMs = Date.now() - startedMs;
+    const usage = normalizeDreamUsage(r?.usage || {});
+    if (!session._dreamMetrics) session._dreamMetrics = createDreamMetrics({ turnId });
+    session._dreamMetrics.llmCallCount += 1;
+    session._dreamMetrics.inputTokens += usage.inputTokens;
+    session._dreamMetrics.outputTokens += usage.outputTokens;
+    session._dreamMetrics.totalTokens += usage.totalTokens;
+    session._dreamMetrics.byPass[pass] = session._dreamMetrics.byPass[pass] || createDreamPassMetrics();
+    session._dreamMetrics.byPass[pass].llmCallCount += 1;
+    session._dreamMetrics.byPass[pass].inputTokens += usage.inputTokens;
+    session._dreamMetrics.byPass[pass].outputTokens += usage.outputTokens;
+    session._dreamMetrics.byPass[pass].totalTokens += usage.totalTokens;
+    session._dreamMetrics.byPass[pass].durationMs += latencyMs;
+    const loopEvent = stampDreamScope(session, {
+      type: 'loop',
+      turnId,
+      loopNumber,
+      pass,
+      model: model || 'unknown',
+      systemPrompt: effectiveSystem,
+      messages: [{ role: 'user', content: prompt }],
+      response: typeof r?.text === 'string' ? r.text : '',
+      toolCalls: [],
+      usage,
+      latencyMs,
+      ttfbMs: null,
+      stopReason: 'end_turn',
+      rawRequest: null,
+      rawResponse: null,
+    });
+    persistDreamTrace(session, 'dream_loop', loopEvent);
     if (typeof session._dreamProgressSink === 'function') {
-      session._dreamProgressSink({
-        type: 'loop',
-        turnId,
-        loopNumber,
-        model: model || 'unknown',
-        systemPrompt: effectiveSystem,
-        messages: [{ role: 'user', content: prompt }],
-        response: typeof r?.text === 'string' ? r.text : '',
-        toolCalls: [],
-        usage: r?.usage || { inputTokens: 0, outputTokens: 0, totalTokens: 0 },
-        latencyMs: Date.now() - startedMs,
-        ttfbMs: null,
-        stopReason: 'end_turn',
-        rawRequest: null,
-        rawResponse: null,
-      });
+      session._dreamProgressSink(loopEvent);
     }
 
     return (r && r.text) ? r.text : '';
   };
 }
 
+
+function stampDreamScope(session, evt) {
+  if (!evt || typeof evt !== 'object') return evt;
+  if (evt.groupId || !session?._dreamActiveGroupId) return evt;
+  return { ...evt, groupId: session._dreamActiveGroupId };
+}
+
+function finiteNumber(v) {
+  const n = Number(v);
+  return Number.isFinite(n) && n > 0 ? Math.floor(n) : 0;
+}
+
+function normalizeDreamUsage(usage = {}) {
+  const inputTokens = finiteNumber(
+    usage.inputTokens ?? usage.input_tokens ?? usage.promptTokens ?? usage.prompt_tokens,
+  );
+  const outputTokens = finiteNumber(
+    usage.outputTokens ?? usage.output_tokens ?? usage.completionTokens ?? usage.completion_tokens,
+  );
+  const explicitTotal = finiteNumber(usage.totalTokens ?? usage.total_tokens);
+  return {
+    inputTokens,
+    outputTokens,
+    totalTokens: explicitTotal || inputTokens + outputTokens,
+  };
+}
+
+function createDreamPassMetrics() {
+  return { llmCallCount: 0, inputTokens: 0, outputTokens: 0, totalTokens: 0, durationMs: 0 };
+}
+
+function createDreamMetrics({ turnId, startedAt = Date.now() } = {}) {
+  return {
+    turnId: turnId || 'dream',
+    startedAt,
+    durationMs: 0,
+    llmCallCount: 0,
+    inputTokens: 0,
+    outputTokens: 0,
+    totalTokens: 0,
+    byPass: {},
+  };
+}
+
+function finalizeDreamMetrics(metrics, durationMs) {
+  const m = metrics || createDreamMetrics();
+  return {
+    turnId: m.turnId || 'dream',
+    startedAt: m.startedAt || null,
+    durationMs: finiteNumber(durationMs),
+    llmCallCount: finiteNumber(m.llmCallCount),
+    inputTokens: finiteNumber(m.inputTokens),
+    outputTokens: finiteNumber(m.outputTokens),
+    totalTokens: finiteNumber(m.totalTokens),
+    passBreakdown: Object.fromEntries(Object.entries(m.byPass || {}).map(([pass, rec]) => [pass, {
+      llmCallCount: finiteNumber(rec.llmCallCount),
+      inputTokens: finiteNumber(rec.inputTokens),
+      outputTokens: finiteNumber(rec.outputTokens),
+      totalTokens: finiteNumber(rec.totalTokens),
+      durationMs: finiteNumber(rec.durationMs),
+    }])),
+  };
+}
+
+function summarizeDreamResult(result = {}) {
+  return {
+    groups: Array.isArray(result.groups) ? result.groups.length : 0,
+    targets: Array.isArray(result.targets) ? result.targets.length : 0,
+    error: result.error || null,
+    skipped: !!result.skipped,
+    skippedReason: result.skippedReason || null,
+  };
+}
+
+function persistDreamTrace(session, eventType, eventData) {
+  try {
+    if (typeof session?.trace?.event === 'function') session.trace.event(eventType, eventData);
+    else if (typeof session?.trace?.logEvent === 'function') {
+      session.trace.logEvent({ traceId: String(eventData?.turnId || eventData?.runId || eventType), eventType, eventData });
+    }
+  } catch { /* trace must never break dream */ }
+}
+
 /**
  * Create a v2 dream scheduler bound to a session and wire its progress
  * events into the engine's sub-agent event sink (web-bridge translates
@@ -162,20 +261,21 @@ function makeLlm(session) {
 export function createV2DreamScheduler(session) {
   const onProgress = (evt) => {
     try {
+      const stampedEvt = stampDreamScope(session, evt);
       const sink = session.engine?.subAgentEventSink || null;
       // We don't have a sub-agent id; emit on the engine's standard
       // event channel instead. session.engine exposes setSubAgentEventSink
       // for nested events; for top-level dream, we route through trace.
       if (typeof session.trace?.event === 'function') {
-        session.trace.event('dream_progress', evt);
+        session.trace.event('dream_progress', stampedEvt);
       }
       if (typeof session._dreamProgressSink === 'function') {
-        session._dreamProgressSink(evt);
+        session._dreamProgressSink(stampedEvt);
       }
       // Best-effort console for debug builds.
       if (session.config?.debug) {
         // eslint-disable-next-line no-console
-        console.log('[dream-v2]', evt);
+        console.log('[dream-v2]', stampedEvt);
       }
     } catch { /* never let progress reporting kill the run */ }
   };
@@ -190,16 +290,19 @@ export function createV2DreamScheduler(session) {
     const startedAt = Date.now();
     session._dreamTurnId = turnId;
     session._dreamLoopCounter = 0;
+    session._dreamMetrics = createDreamMetrics({ turnId, startedAt });
 
+    const turnOpen = stampDreamScope(session, {
+      type: 'turn_open',
+      turnId,
+      userPrompt: '[dream] automatic memory consolidation',
+      vpId: null,
+      groupId: null,
+      at: startedAt,
+    });
+    persistDreamTrace(session, 'dream_turn_open', turnOpen);
     if (typeof session._dreamProgressSink === 'function') {
-      session._dreamProgressSink({
-        type: 'turn_open',
-        turnId,
-        userPrompt: '[dream] automatic memory consolidation',
-        vpId: null,
-        groupId: null,
-        at: startedAt,
-      });
+      session._dreamProgressSink(turnOpen);
     }
 
     return runDream({
@@ -208,14 +311,35 @@ export function createV2DreamScheduler(session) {
       scopeFilter: Array.isArray(opts.scopeFilter) ? opts.scopeFilter : undefined,
     }).then((result) => {
       // Bug 2: emit turn_close when the dream pass completes.
+      result.trigger = opts.manual ? 'manual' : 'auto';
+      if (session._dreamActiveGroupId && !result.groupId) result.groupId = session._dreamActiveGroupId;
+      const metrics = finalizeDreamMetrics(session._dreamMetrics, Date.now() - startedAt);
+      result.metrics = metrics;
+      result.durationMs = metrics.durationMs;
+      result.llmCallCount = metrics.llmCallCount;
+      result.inputTokens = metrics.inputTokens;
+      result.outputTokens = metrics.outputTokens;
+      result.totalTokens = metrics.totalTokens;
+      result.passBreakdown = metrics.passBreakdown;
+      const turnClose = stampDreamScope(session, {
+        type: 'turn_close',
+        turnId,
+        totalMs: metrics.durationMs,
+        totalTokens: metrics.totalTokens,
+        loopCount: metrics.llmCallCount,
+        metrics,
+      });
+      persistDreamTrace(session, 'dream_turn_close', turnClose);
+      persistDreamTrace(session, 'dream_run', stampDreamScope(session, {
+        type: 'dream_run',
+        turnId,
+        phase: 'result',
+        status: result?.error ? 'error' : 'done',
+        metrics,
+        resultSummary: summarizeDreamResult(result),
+      }));
       if (typeof session._dreamProgressSink === 'function') {
-        session._dreamProgressSink({
-          type: 'turn_close',
-          turnId,
-          totalMs: Date.now() - startedAt,
-          totalTokens: 0,
-          loopCount: session._dreamLoopCounter || 0,
-        });
+        session._dreamProgressSink(turnClose);
       }
       return result;
     });

package/unify/sub-agent/runner.js

@@ -31,8 +31,10 @@ import { ToolRegistry } from '../tools/registry.js';
 import { buildSpawnedPreamble } from './spawned-prompt.js';
 
 const RESTRICTED_TOOLS = new Set([
-  'Agent',
-  'SendMessage',
+  'SpawnAgent',
+  'Agent',          // legacy alias
+  'PromptAgent',
+  'SendMessage',    // legacy alias
   'WaitAgent',
   'CloseAgent',
   'ListAgents',

package/unify/sub-agent/spawned-prompt.js

@@ -38,7 +38,7 @@ export function buildSpawnedPreamble({ parentName, parentVpId, agentName, missio
       m || '(无具体任务说明)',
       '',
       '## 行为约束',
-      '- 不要再 spawn sub-agent（你已经没有 Agent / SendMessage / WaitAgent / CloseAgent 工具）。',
+      '- 不要再 spawn sub-agent（你已经没有 SpawnAgent / PromptAgent / WaitAgent / CloseAgent 工具）。',
       '- 不要 route_forward 给别的 VP，不要 ask_user。',
       '- 完成时直接以 markdown 自由文本回复（end_turn）。建议结构："## 结果" / "## 关键发现" / "## 遗留问题"。',
       '- 失败/不可行也要明确说出来，不要假装完成。父 VP 会读你的最终消息。',
@@ -55,7 +55,7 @@ export function buildSpawnedPreamble({ parentName, parentVpId, agentName, missio
     m || '(no mission body provided)',
     '',
     '## Constraints',
-    '- Do NOT spawn further sub-agents (Agent / SendMessage / WaitAgent / CloseAgent are not in your toolset).',
+    '- Do NOT spawn further sub-agents (SpawnAgent / PromptAgent / WaitAgent / CloseAgent are not in your toolset).',
     '- Do NOT use route_forward to other VPs. Do NOT ask_user.',
     '- When done, reply in free markdown (end_turn). Suggested structure: "## Result" / "## Key findings" / "## Open questions".',
     '- If the mission is infeasible or you fail, say so plainly. The parent will read your final message.',

package/unify/tools/agent.js

@@ -174,7 +174,8 @@ export function tickAgent(agentId, delta = {}, now = Date.now()) {
 }
 
 export default defineTool({
-  name: 'Agent',
+  name: 'SpawnAgent',
+  aliases: ['Agent'],
   description: `Create a sub-agent to work on an independent task in parallel.
 
 Sub-agents run in their own context and can be given a concrete mission
@@ -189,7 +190,7 @@ Guidelines:
 - Give a clear, focused mission — what "done" looks like
 - Use expected_output to pin the structure you want back
 - Always set a budget for unbounded missions
-- Use SendMessage to communicate, WaitAgent to collect results, CloseAgent to finalize`,
+- Use PromptAgent to communicate, WaitAgent to collect results, CloseAgent to finalize`,
   parameters: {
     type: 'object',
     properties: {
@@ -302,7 +303,7 @@ Guidelines:
       persona: spec.persona || null,
       budget: spec.budget || null,
       status: agent.status,
-      message: `Sub-agent "${name}" spawned (${agentId}). Use WaitAgent to collect its first turn output, SendMessage to give it more work, CloseAgent to finish.`,
+      message: `Sub-agent "${name}" spawned (${agentId}). Use WaitAgent to collect its first turn output, PromptAgent to give it more work, CloseAgent to finish.`,
     });
   },
 });

package/unify/tools/index.js

@@ -18,7 +18,6 @@ import exitWorktree from './exit-worktree.js';
 
 // --- P0 Core tools ---
 import askUser from './ask-user.js';
-import openSourceMessage from './open-source-message.js';
 import webSearch from './web-search.js';
 import webFetch from './web-fetch.js';
 import historySearch from './history-search.js';
@@ -66,7 +65,6 @@ import { jsRepl, jsReplReset } from './js-repl.js';
 import notebookEdit from './notebook-edit.js';
 import imageGeneration from './image-generation.js';
 import viewImage from './view-image.js';
-import requestPermissions from './request-permissions.js';
 
 /**
  * All built-in tools, flattened into a single array.
@@ -82,7 +80,6 @@ export const allTools = [
 
   // P0 Core
   askUser,
-  openSourceMessage,
   webSearch,
   webFetch,
   historySearch,
@@ -117,7 +114,6 @@ export const allTools = [
   notebookEdit,
   imageGeneration,
   viewImage,
-  requestPermissions,
 ];
 
 /**

package/unify/tools/registry.js

@@ -226,6 +226,17 @@ export class ToolRegistry {
   register(tool) {
     if (!tool || !tool.name) throw new Error('Tool must have a name');
     this.#tools.set(tool.name, tool);
+    // Legacy-name aliases: keep historical jsonl tool_calls resolvable
+    // after a rename. The alias entry shares the same tool object so
+    // execute/has lookups succeed, but `getToolDefs()` dedupes by tool
+    // identity so the LLM only sees the canonical name.
+    if (Array.isArray(tool.aliases)) {
+      for (const alias of tool.aliases) {
+        if (typeof alias === 'string' && alias && alias !== tool.name) {
+          this.#tools.set(alias, tool);
+        }
+      }
+    }
     return this;
   }
 
@@ -269,10 +280,21 @@ export class ToolRegistry {
 
   /**
    * Get all registered tools (unfiltered).
+   *
+   * Dedupes alias entries — when a tool is registered with `aliases`,
+   * the same ToolDef object lives at multiple Map keys. We return each
+   * tool object at most once (under its canonical `tool.name`).
    * @returns {import('./types.js').ToolDef[]}
    */
   getAllTools() {
-    return Array.from(this.#tools.values());
+    const seen = new Set();
+    const out = [];
+    for (const tool of this.#tools.values()) {
+      if (seen.has(tool)) continue;
+      seen.add(tool);
+      out.push(tool);
+    }
+    return out;
   }
 
   /**
@@ -291,11 +313,12 @@ export class ToolRegistry {
   }
 
   /**
-   * Get all registered tool names.
+   * Get all registered tool names (canonical only — aliases are excluded
+   * so debug surfaces like the tool-stats panel show one row per tool).
    * @returns {string[]}
    */
   getToolNames() {
-    return Array.from(this.#tools.keys());
+    return this.getAllTools().map(t => t.name);
   }
 
   /**
@@ -337,12 +360,12 @@ export class ToolRegistry {
 
   /** Number of registered tools. */
   get size() {
-    return this.#tools.size;
+    return this.getAllTools().length;
   }
 
-  /** All registered tool names. */
+  /** All registered tool names (canonical only; aliases excluded). */
   get names() {
-    return Array.from(this.#tools.keys());
+    return this.getAllTools().map(t => t.name);
   }
 }
 

package/unify/tools/send-message.js

@@ -1,16 +1,20 @@
 /**
- * send-message.js — Send a message to a sub-agent.
+ * send-message.js — Send a follow-up prompt to a sub-agent.
+ *
+ * Tool name: PromptAgent (canonical) / SendMessage (legacy alias for
+ * historical jsonl replay — see registry alias map).
  */
 
 import { defineTool } from './types.js';
 import { getAgentRegistry } from './agent.js';
 
 export default defineTool({
-  name: 'SendMessage',
-  description: `Send a message to a sub-agent.
+  name: 'PromptAgent',
+  aliases: ['SendMessage'],
+  description: `Send a follow-up prompt to a sub-agent you previously spawned.
 
-Use this to give tasks, provide instructions, or relay information to a sub-agent.
-The message is queued for the agent to process.`,
+Use this to give the sub-agent more work, additional instructions, or relay
+information. The prompt is queued for the agent to process on its next turn.`,
   parameters: {
     type: 'object',
     properties: {

package/unify/tools/types.js

@@ -74,6 +74,7 @@
  */
 export function defineTool({
   name,
+  aliases,
   description,
   parameters,
   execute,
@@ -94,6 +95,12 @@ export function defineTool({
     isReadOnly,
     isDestructive,
   };
+  // Legacy tool-name aliases. Registered as extra lookup keys so old
+  // jsonl tool_calls (e.g. `SendMessage` → `PromptAgent`) keep resolving,
+  // but excluded from the LLM-visible catalogue.
+  if (Array.isArray(aliases) && aliases.length > 0) {
+    def.aliases = aliases.slice();
+  }
   // Only attach `timeoutMs` when the tool author opts in. Leaving it
   // unset means ToolRegistry.execute uses DEFAULT_TOOL_TIMEOUT_MS — set
   // to <= 0 to disable the per-tool timeout entirely.

package/unify/tools/wait-agent.js

@@ -10,7 +10,7 @@ export default defineTool({
   description: `Wait for a sub-agent to complete its task and retrieve the result.
 
 Returns the agent's final result or current status if still running.
-Use after sending a task to an agent via SendMessage.`,
+Use after sending a task to an agent via PromptAgent.`,
   parameters: {
     type: 'object',
     properties: {

package/unify/web-bridge.js

@@ -3222,6 +3222,13 @@ export function normalizeDreamResult(result) {
 
   return {
     success,
+    durationMs: Number.isFinite(Number(result?.durationMs)) ? Number(result.durationMs) : 0,
+    llmCallCount: Number.isFinite(Number(result?.llmCallCount)) ? Number(result.llmCallCount) : 0,
+    inputTokens: Number.isFinite(Number(result?.inputTokens)) ? Number(result.inputTokens) : 0,
+    outputTokens: Number.isFinite(Number(result?.outputTokens)) ? Number(result.outputTokens) : 0,
+    totalTokens: Number.isFinite(Number(result?.totalTokens)) ? Number(result.totalTokens) : 0,
+    metrics: result?.metrics || null,
+    passBreakdown: result?.passBreakdown || result?.metrics?.passBreakdown || null,
     skipped,
     skippedReason,
     groupsProcessed,
@@ -3260,13 +3267,15 @@ export async function handleUnifyDreamTrigger(msg = {}) {
   // group or different) overlapping the same inflight pass used to set
   // the module-level groupId slot, race the sink wrapping, and let the
   // second `finally` restore the original sink while the first run was
-  // still emitting events. We now refuse any second scoped trigger
-  // while ANY scoped pass is inflight — the scheduler already
-  // short-circuits the underlying run for same-group, and a different
-  // group's filter would have been silently dropped anyway (see
-  // dream-v2/schedule.js inflight reuse), so the user-facing semantics
-  // are unchanged ("you already asked").
-  if (groupId && inflightScopedDreamGroups.size > 0) {
+  // still emitting events. We now refuse scoped triggers while ANY dream
+  // pass is already running: a scoped manual click during an unscoped
+  // auto run must not install `_dreamActiveGroupId` or wrap the sink,
+  // otherwise auto-run events can be persisted under the clicked group.
+  // The scheduler also short-circuits the underlying run for same-group,
+  // and a different group's filter would have been silently dropped
+  // anyway (see dream-v2/schedule.js inflight reuse), so the user-facing
+  // semantics are unchanged ("you already asked").
+  if (groupId && (inflightScopedDreamGroups.size > 0 || session.dreamScheduler.isRunning)) {
     const skippedResult = {
       skipped: true,
       skippedReason: 'already-running',
@@ -3289,6 +3298,7 @@ export async function handleUnifyDreamTrigger(msg = {}) {
   // OTHER groupIds chain (last-installed wins) but each restoration
   // unwinds back to its predecessor.
   const originalSink = session?._dreamProgressSink;
+  if (groupId) session._dreamActiveGroupId = groupId;
   if (groupId && typeof originalSink === 'function') {
     inflightScopedDreamGroups.add(groupId);
     session._dreamProgressSink = (evt) => {
@@ -3345,6 +3355,7 @@ export async function handleUnifyDreamTrigger(msg = {}) {
     });
   } finally {
     // Restore the original sink and release the per-group inflight lock.
+    if (groupId && session?._dreamActiveGroupId === groupId) session._dreamActiveGroupId = null;
     if (groupId && typeof originalSink === 'function') {
       session._dreamProgressSink = originalSink;
       inflightScopedDreamGroups.delete(groupId);

package/unify/tools/open-source-message.js

@@ -1,49 +0,0 @@
-/**
- * open-source-message.js — task-334f R6 §Δ24.4.
- *
- * Low-level random access: given a (groupId, msgId), fetch the raw message
- * from the group's jsonl log. Used when a VP has an exact pointer but does
- * not want to run the memory_trace wrapper (5% case: audit / debug).
- */
-
-import { defineTool } from './types.js';
-
-export default defineTool({
-  name: 'open_source_message',
-  description: `Open a single source message by (groupId, msgId).
-
-This is the low-level random-access primitive. Prefer memory_trace if you are
-starting from a memory entry. Returns JSON: { message } or { error }.`,
-  parameters: {
-    type: 'object',
-    properties: {
-      groupId: { type: 'string', description: 'Group id' },
-      msgId:   { type: 'string', description: 'Message id' },
-    },
-    required: ['groupId', 'msgId'],
-  },
-  isConcurrencySafe: () => true,
-  isReadOnly: () => true,
-  async execute(input, ctx) {
-    const { groupId, msgId } = input || {};
-    if (!groupId || !msgId) {
-      return JSON.stringify({ error: 'groupId and msgId required' });
-    }
-    const coordinator = ctx?.coordinator;
-    if (!coordinator || typeof coordinator.openGroup !== 'function') {
-      return JSON.stringify({ error: 'group coordinator not available' });
-    }
-    const group = coordinator.openGroup(groupId);
-    if (!group) return JSON.stringify({ error: `group not found: ${groupId}` });
-
-    const iter = typeof group.readMessageRange === 'function'
-      ? group.readMessageRange(msgId, msgId)
-      : group.streamMessages();
-    for (const msg of iter) {
-      if (msg.id === msgId) {
-        return JSON.stringify({ message: msg });
-      }
-    }
-    return JSON.stringify({ error: `message not found: ${msgId} in ${groupId}` });
-  },
-});

package/unify/tools/request-permissions.js

@@ -1,59 +0,0 @@
-/**
- * request-permissions.js — Request permission for dangerous operations.
- *
- * When an operation is flagged as destructive, this tool requests
- * explicit user permission before proceeding.
- */
-
-import { defineTool } from './types.js';
-
-export default defineTool({
-  name: 'RequestPermissions',
-  description: `Request permission from the user for a potentially dangerous operation.
-
-Use this before executing destructive operations like:
-- Deleting files or directories
-- Running commands that modify system state
-- Force-pushing to git
-- Resetting databases
-
-The user must explicitly approve before you proceed.`,
-  parameters: {
-    type: 'object',
-    properties: {
-      operation: {
-        type: 'string',
-        description: 'Description of the operation that needs permission',
-      },
-      reason: {
-        type: 'string',
-        description: 'Why this operation is necessary',
-      },
-      risk_level: {
-        type: 'string',
-        enum: ['low', 'medium', 'high', 'critical'],
-        description: 'Risk level of the operation',
-      },
-    },
-    required: ['operation'],
-  },
-  isConcurrencySafe: () => false,
-  isReadOnly: () => true,
-  async execute(input, ctx) {
-    const { operation, reason, risk_level = 'medium' } = input;
-    if (!operation) return JSON.stringify({ error: 'operation is required' });
-
-    // In a full integration, this would use the ask_user mechanism
-    // to get explicit permission. For now, return a structured request.
-    return JSON.stringify({
-      type: 'permission_request',
-      operation,
-      reason: reason || 'Operation requires explicit permission',
-      riskLevel: risk_level,
-      message: `⚠️ Permission required for: ${operation}` +
-               (reason ? `\nReason: ${reason}` : '') +
-               `\nRisk level: ${risk_level}`,
-      hint: 'User must explicitly approve this operation before proceeding.',
-    });
-  },
-});