chainlesschain 0.47.6 → 0.47.7

package/src/lib/interaction-adapter.js

@@ -14,6 +14,21 @@ import {
   LEGACY_TO_UNIFIED_TYPE,
 } from "../runtime/runtime-events.js";
 import { createAbortError } from "./abort-utils.js";
+import { createEnvelope } from "@chainlesschain/session-core";
+
+// Phase 5: parallel service-envelope emission. Map WS agent-handler event
+// types onto the canonical `run.*` run-loop envelope types. Events not in
+// this map are skipped (legacy coding-agent envelope still flows).
+const AGENT_EVENT_TO_ENVELOPE_TYPE = Object.freeze({
+  "tool-executing": "run.tool_call",
+  "tool-result": "run.tool_result",
+  "response-complete": "run.message",
+  error: "run.error",
+  // Phase 5 bookends — emitted by agentLoop at entry / termination so
+  // envelope subscribers can correlate a full run by runId.
+  "run-started": "run.started",
+  "run-ended": "run.ended",
+});
 
 // Whitelist of event types the CLI runtime should emit as unified envelopes
 // (with source: "cli-runtime"). Anything not in this set keeps the legacy
@@ -101,7 +116,7 @@ export class WebSocketInteractionAdapter extends InteractionAdapter {
    * @param {import("ws").WebSocket} ws
    * @param {string} sessionId
    */
-  constructor(ws, sessionId) {
+  constructor(ws, sessionId, options = {}) {
     super();
     this.ws = ws;
     this.sessionId = sessionId;
@@ -111,6 +126,11 @@ export class WebSocketInteractionAdapter extends InteractionAdapter {
     // this WS session instead of leaking across sessions via the process-
     // global default tracker.
     this._sequenceTracker = new CodingAgentSequenceTracker();
+    // Phase 5: parallel service-envelope emission. Opt-in (default off) so
+    // legacy callers that count ws.send invocations stay green.
+    this.enablePhase5Envelopes = options.enablePhase5Envelopes === true;
+    // Optional fan-out bus for hosted HTTP SSE subscribers.
+    this.envelopeBus = options.envelopeBus || null;
   }
 
   /** Generate a unique request id */
@@ -230,6 +250,8 @@ export class WebSocketInteractionAdapter extends InteractionAdapter {
         tracker: this._sequenceTracker,
       });
       this._sendWs(envelope);
+      // Phase 5: parallel service-envelope emission for unified subscribers.
+      this._sendPhase5Envelope(eventType, payload, { sessionId, requestId });
       return;
     }
 
@@ -240,6 +262,42 @@ export class WebSocketInteractionAdapter extends InteractionAdapter {
       sessionId: this.sessionId,
       ...data,
     });
+
+    // Phase 5: even for non-coding-agent events, forward if the type maps to
+    // a canonical envelope (run-started / run-ended bookends flow here).
+    if (AGENT_EVENT_TO_ENVELOPE_TYPE[eventType]) {
+      const payload = data && typeof data === "object" ? { ...data } : {};
+      const requestId = payload.requestId || null;
+      const sessionId = payload.sessionId || this.sessionId || null;
+      delete payload.requestId;
+      delete payload.sessionId;
+      this._sendPhase5Envelope(eventType, payload, { sessionId, requestId });
+    }
+  }
+
+  _sendPhase5Envelope(eventType, payload, { sessionId, requestId }) {
+    if (!this.enablePhase5Envelopes) return;
+    const envType = AGENT_EVENT_TO_ENVELOPE_TYPE[eventType];
+    if (!envType) return;
+    try {
+      const env = createEnvelope({
+        type: envType,
+        sessionId: sessionId || null,
+        runId: payload?.runId || null,
+        requestId: requestId || null,
+        payload: { ...(payload || {}) },
+      });
+      this._sendWs(env);
+      if (this.envelopeBus && env.sessionId) {
+        try {
+          this.envelopeBus.publish(env.sessionId, env);
+        } catch (_e) {
+          // Bus fan-out must never break the WS path.
+        }
+      }
+    } catch (_e) {
+      // Phase 5 is additive — never break the legacy path on envelope failure.
+    }
   }
 
   _sendWs(data) {

package/src/lib/jsonl-session-store.js

@@ -29,4 +29,6 @@ export {
   validateJsonlSession,
   validateAllJsonlSessions,
   sampleMigratedSessionsValidation,
+  sessionPath,
+  appendTokenUsage,
 } from "../harness/jsonl-session-store.js";

package/src/lib/memory-injection.js

@@ -0,0 +1,90 @@
+/**
+ * memory-injection — recall top-K session-core memories and format them as a
+ * system-prompt block for agent-repl / chat-repl startup.
+ *
+ * Managed Agents parity Phase G item #5: new sessions automatically surface
+ * relevant global/agent-scoped memory so the assistant has continuity across
+ * runs.
+ *
+ * Design:
+ * - Pull from global scope + (optionally) the session's agent scope.
+ * - Deduplicate by memory id, sort by relevance/score, cap at `limit`.
+ * - Return `null` when nothing useful was found so callers can skip the
+ *   extra system message entirely.
+ * - Pure formatting — caller decides where to splice it into `messages`.
+ */
+
+import { getMemoryStore } from "./session-core-singletons.js";
+
+const DEFAULT_LIMIT = 8;
+const DEFAULT_CONTENT_CHARS = 280;
+
+export function recallStartupMemories({
+  agentId = null,
+  query = "",
+  limit = DEFAULT_LIMIT,
+  memoryStore = null,
+} = {}) {
+  const store = memoryStore || getMemoryStore();
+  if (!store || typeof store.recall !== "function") return [];
+
+  const pools = [];
+  try {
+    pools.push(store.recall({ scope: "global", query, limit }) || []);
+  } catch (_e) {
+    /* ignore — missing scope is not fatal */
+  }
+  if (agentId) {
+    try {
+      pools.push(
+        store.recall({ scope: "agent", scopeId: agentId, query, limit }) || [],
+      );
+    } catch (_e) {
+      /* ignore */
+    }
+  }
+
+  const seen = new Set();
+  const merged = [];
+  for (const pool of pools) {
+    for (const m of pool) {
+      if (!m || !m.id || seen.has(m.id)) continue;
+      seen.add(m.id);
+      merged.push(m);
+    }
+  }
+
+  merged.sort((a, b) => {
+    const ra = Number(a.relevance ?? a.score ?? 0);
+    const rb = Number(b.relevance ?? b.score ?? 0);
+    return rb - ra;
+  });
+
+  return merged.slice(0, limit);
+}
+
+export function formatMemoriesAsSystemPrompt(memories, { headline } = {}) {
+  if (!Array.isArray(memories) || memories.length === 0) return null;
+
+  const title =
+    headline || "Relevant memory from prior sessions (recall — do not echo):";
+  const lines = [title];
+  for (const m of memories) {
+    const scope = m.scope || "global";
+    const scopeTag = m.scopeId
+      ? `${scope}:${String(m.scopeId).slice(0, 12)}`
+      : scope;
+    const cat = m.category ? `[${m.category}] ` : "";
+    const body = String(m.content || "").slice(0, DEFAULT_CONTENT_CHARS);
+    lines.push(`- (${scopeTag}) ${cat}${body}`);
+  }
+  return lines.join("\n");
+}
+
+export function buildMemoryInjection(options = {}) {
+  const memories = recallStartupMemories(options);
+  const content = formatMemoriesAsSystemPrompt(memories, {
+    headline: options.headline,
+  });
+  return content ? { role: "system", content, count: memories.length } : null;
+}

package/src/lib/provider-stream.js

@@ -0,0 +1,120 @@
+/**
+ * Provider streaming adapters — shared by `cc stream` and the Hosted Session
+ * API `stream.run` WS route. Each builder returns an AsyncIterable<string>
+ * of token deltas suitable for piping through session-core StreamRouter.
+ */
+
+import { BUILT_IN_PROVIDERS } from "./llm-providers.js";
+
+export async function* ollamaTokenStream({ baseUrl, model, prompt, signal }) {
+  const res = await fetch(`${baseUrl}/api/generate`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ model, prompt, stream: true }),
+    signal,
+  });
+  if (!res.ok || !res.body) {
+    throw new Error(`Ollama ${res.status} ${res.statusText}`);
+  }
+  const reader = res.body.getReader();
+  const decoder = new TextDecoder();
+  let buf = "";
+  while (true) {
+    const { value, done } = await reader.read();
+    if (done) break;
+    buf += decoder.decode(value, { stream: true });
+    let nl;
+    while ((nl = buf.indexOf("\n")) >= 0) {
+      const line = buf.slice(0, nl).trim();
+      buf = buf.slice(nl + 1);
+      if (!line) continue;
+      try {
+        const obj = JSON.parse(line);
+        if (obj.response) yield obj.response;
+        if (obj.done) return;
+      } catch {
+        /* skip malformed */
+      }
+    }
+  }
+}
+
+export async function* openAIStream({
+  baseUrl,
+  apiKey,
+  model,
+  prompt,
+  signal,
+}) {
+  const res = await fetch(`${baseUrl}/chat/completions`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${apiKey}`,
+    },
+    body: JSON.stringify({
+      model,
+      messages: [{ role: "user", content: prompt }],
+      stream: true,
+    }),
+    signal,
+  });
+  if (!res.ok || !res.body) {
+    throw new Error(`${res.status} ${res.statusText}`);
+  }
+  const reader = res.body.getReader();
+  const decoder = new TextDecoder();
+  let buf = "";
+  while (true) {
+    const { value, done } = await reader.read();
+    if (done) break;
+    buf += decoder.decode(value, { stream: true });
+    const lines = buf.split("\n");
+    buf = lines.pop() || "";
+    for (const raw of lines) {
+      const line = raw.trim();
+      if (!line || !line.startsWith("data:")) continue;
+      const payload = line.slice(5).trim();
+      if (payload === "[DONE]") return;
+      try {
+        const obj = JSON.parse(payload);
+        const delta = obj?.choices?.[0]?.delta?.content;
+        if (delta) yield delta;
+      } catch {
+        /* skip */
+      }
+    }
+  }
+}
+
+/**
+ * Build an AsyncIterable<string> token stream for the given provider.
+ * Throws on unsupported provider / missing API key.
+ */
+export function buildProviderSource(provider, opts = {}) {
+  const { model, baseUrl, apiKey, prompt, signal } = opts;
+  if (provider === "ollama") {
+    return ollamaTokenStream({
+      baseUrl: baseUrl || "http://localhost:11434",
+      model: model || "qwen2:7b",
+      prompt,
+      signal,
+    });
+  }
+  const def = BUILT_IN_PROVIDERS[provider];
+  if (!def) throw new Error(`Unsupported provider: ${provider}`);
+  const finalKey =
+    apiKey || (def.apiKeyEnv ? process.env[def.apiKeyEnv] : null);
+  if (!finalKey) {
+    throw new Error(
+      `API key required for ${provider} (--api-key or ${def.apiKeyEnv})`,
+    );
+  }
+  return openAIStream({
+    baseUrl: baseUrl || def.baseUrl,
+    apiKey: finalKey,
+    model: model || def.models[0],
+    prompt,
+    signal,
+  });
+}

package/src/lib/sandbox-v2.js

@@ -4,6 +4,36 @@
  */
 
 import crypto from "crypto";
+import { createRequire } from "module";
+
+const _require = createRequire(import.meta.url);
+
+// Phase 4: shared sandbox-policy from session-core (lazy, fallback stubs).
+let _sandboxPolicy = null;
+function getSandboxPolicy() {
+  if (_sandboxPolicy) return _sandboxPolicy;
+  try {
+    _sandboxPolicy = _require("@chainlesschain/session-core/sandbox-policy");
+  } catch (_e) {
+    _sandboxPolicy = {
+      mergeSandboxPolicy: (_b, o) => ({ scope: "thread", ...(o || {}) }),
+      resolveBundleSandboxPolicy: () => ({ scope: "thread" }),
+      shouldReuseSandbox: () => false,
+      isSandboxExpired: () => false,
+      isSandboxIdleExpired: () => false,
+    };
+  }
+  return _sandboxPolicy;
+}
+
+function resolvePolicy(options = {}) {
+  const { mergeSandboxPolicy, resolveBundleSandboxPolicy } = getSandboxPolicy();
+  if (options.bundle) {
+    const base = resolveBundleSandboxPolicy(options.bundle);
+    return mergeSandboxPolicy(base, options.policy || {});
+  }
+  return mergeSandboxPolicy({}, options.policy || {});
+}
 
 // ─── Constants ────────────────────────────────────────────────
 
@@ -36,6 +66,22 @@ export const DEFAULT_PERMISSIONS = {
 const activeSandboxes = new Map();
 const auditLog = [];
 
+// Phase 4: sync persisted rows for sandboxes this process hasn't seen yet so
+// reuse/prune decisions honor createdAt/lastUsedAt across CLI restarts.
+// Idempotent and cheap — a single indexed SELECT per call.
+function _syncFromDb(db) {
+  if (!db) return;
+  try {
+    const rows = db
+      .prepare(`SELECT id FROM sandbox_instances WHERE status = 'active'`)
+      .all();
+    const missing = rows.some((r) => !activeSandboxes.has(r.id));
+    if (missing) restoreFromDb(db);
+  } catch (_e) {
+    // best-effort — callers continue with fresh in-memory state
+  }
+}
+
 // ─── Database helpers ─────────────────────────────────────────
 
 /**
@@ -50,10 +96,26 @@ export function ensureSandboxTables(db) {
       permissions TEXT,
       quota TEXT,
       resource_usage TEXT,
+      policy TEXT,
+      created_at_ms INTEGER,
+      last_used_at_ms INTEGER,
       created_at TEXT DEFAULT (datetime('now')),
       updated_at TEXT DEFAULT (datetime('now'))
     )
   `);
+  // Phase 4: in-place migration for legacy CLI DBs. ALTER is a no-op if the
+  // column already exists, so swallow "duplicate column" errors.
+  for (const ddl of [
+    "ALTER TABLE sandbox_instances ADD COLUMN policy TEXT",
+    "ALTER TABLE sandbox_instances ADD COLUMN created_at_ms INTEGER",
+    "ALTER TABLE sandbox_instances ADD COLUMN last_used_at_ms INTEGER",
+  ]) {
+    try {
+      db.exec(ddl);
+    } catch (_e) {
+      // column already present
+    }
+  }
   db.exec(`
     CREATE TABLE IF NOT EXISTS sandbox_audit (
       id TEXT PRIMARY KEY,
@@ -123,6 +185,7 @@ export function createSandbox(db, agentId, options = {}) {
   const quota = options.quota || { ...DEFAULT_QUOTA };
   const resourceUsage = { cpu: 0, memory: 0, storage: 0, network: 0 };
 
+  const now = Date.now();
   const sandbox = {
     id,
     agentId,
@@ -130,12 +193,16 @@ export function createSandbox(db, agentId, options = {}) {
     permissions,
     quota,
     resourceUsage,
-    createdAt: new Date().toISOString(),
+    createdAt: new Date(now).toISOString(),
+    // Phase 4: lifecycle policy + timestamps (ms) for ttl / idleTtl math.
+    policy: resolvePolicy(options),
+    createdAtMs: now,
+    lastUsedAtMs: now,
   };
 
   db.prepare(
-    `INSERT INTO sandbox_instances (id, agent_id, status, permissions, quota, resource_usage)
-     VALUES (?, ?, ?, ?, ?, ?)`,
+    `INSERT INTO sandbox_instances (id, agent_id, status, permissions, quota, resource_usage, policy, created_at_ms, last_used_at_ms)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
   ).run(
     id,
     agentId,
@@ -143,6 +210,9 @@ export function createSandbox(db, agentId, options = {}) {
     JSON.stringify(permissions),
     JSON.stringify(quota),
     JSON.stringify(resourceUsage),
+    JSON.stringify(sandbox.policy || null),
+    sandbox.createdAtMs,
+    sandbox.lastUsedAtMs,
   );
 
   activeSandboxes.set(id, sandbox);
@@ -494,6 +564,131 @@ function logBehavior(db, sandboxId, eventType, eventData) {
   ).run(id, sandboxId, eventType, JSON.stringify(eventData));
 }
 
+/**
+ * Phase 4: refresh lastUsedAt so idle TTL doesn't expire the sandbox.
+ */
+export function touchSandbox(sandboxId, db = null) {
+  const sandbox = activeSandboxes.get(sandboxId);
+  if (!sandbox) return false;
+  sandbox.lastUsedAtMs = Date.now();
+  if (db) {
+    try {
+      db.prepare(
+        `UPDATE sandbox_instances SET last_used_at_ms = ?, updated_at = datetime('now') WHERE id = ?`,
+      ).run(sandbox.lastUsedAtMs, sandboxId);
+    } catch (_e) {
+      // persistence best-effort — in-memory touch already applied
+    }
+  }
+  return true;
+}
+
+/**
+ * Phase 4: rehydrate live sandbox rows from DB into the in-memory map so
+ * idle/ttl math and reuse decisions survive a CLI process restart.
+ * Returns the number of restored sandboxes.
+ */
+export function restoreFromDb(db) {
+  ensureSandboxTables(db);
+  let restored = 0;
+  const rows = db
+    .prepare(
+      `SELECT id, agent_id, status, permissions, quota, resource_usage, policy, created_at_ms, last_used_at_ms, created_at
+       FROM sandbox_instances WHERE status = 'active'`,
+    )
+    .all();
+  const now = Date.now();
+  for (const row of rows) {
+    let policy = null;
+    try {
+      policy = row.policy ? JSON.parse(row.policy) : null;
+    } catch (_e) {
+      policy = null;
+    }
+    activeSandboxes.set(row.id, {
+      id: row.id,
+      agentId: row.agent_id,
+      status: row.status || "active",
+      permissions: JSON.parse(row.permissions || "{}"),
+      quota: JSON.parse(row.quota || "{}"),
+      resourceUsage: JSON.parse(row.resource_usage || "{}"),
+      createdAt: row.created_at || new Date(now).toISOString(),
+      policy,
+      createdAtMs: row.created_at_ms || now,
+      lastUsedAtMs: row.last_used_at_ms || now,
+    });
+    restored += 1;
+  }
+  return restored;
+}
+
+/**
+ * Phase 4: acquire a sandbox for an agent — reuse an existing one if the
+ * policy permits, else create fresh. Returns `{ id, reused, scope, ... }`.
+ */
+export function acquireSandbox(db, agentId, options = {}) {
+  const { shouldReuseSandbox } = getSandboxPolicy();
+  _syncFromDb(db);
+  const policy = resolvePolicy(options);
+  const now = Date.now();
+
+  if (policy.reuseAcrossRuns) {
+    for (const sandbox of activeSandboxes.values()) {
+      if (sandbox.agentId !== agentId) continue;
+      if (sandbox.status !== "active") continue;
+      if (
+        shouldReuseSandbox(
+          sandbox.policy || policy,
+          { createdAt: sandbox.createdAtMs, lastUsedAt: sandbox.lastUsedAtMs },
+          now,
+        )
+      ) {
+        sandbox.lastUsedAtMs = now;
+        return {
+          id: sandbox.id,
+          reused: true,
+          scope: sandbox.policy?.scope || policy.scope,
+          status: sandbox.status,
+          permissions: sandbox.permissions,
+          quota: sandbox.quota,
+        };
+      }
+    }
+  }
+
+  const created = createSandbox(db, agentId, { ...options, policy });
+  return { ...created, reused: false, scope: policy.scope };
+}
+
+/**
+ * Phase 4: sweep sandboxes whose ttl / idle ttl expired, mark them destroyed,
+ * and return `[{ id, reason }]`. Safe to call from a timer.
+ */
+export function pruneExpired(db, now = Date.now()) {
+  const { isSandboxExpired, isSandboxIdleExpired } = getSandboxPolicy();
+  _syncFromDb(db);
+  const destroyed = [];
+  for (const sandbox of Array.from(activeSandboxes.values())) {
+    const policy = sandbox.policy;
+    if (!policy) continue;
+    if (sandbox.status !== "active") continue;
+    const ttlExpired = isSandboxExpired(policy, sandbox.createdAtMs, now);
+    const idleExpired = isSandboxIdleExpired(policy, sandbox.lastUsedAtMs, now);
+    if (ttlExpired || idleExpired) {
+      try {
+        destroySandbox(db, sandbox.id);
+        destroyed.push({
+          id: sandbox.id,
+          reason: ttlExpired ? "ttl" : "idle",
+        });
+      } catch (_e) {
+        // skip — destroySandbox may throw if already gone
+      }
+    }
+  }
+  return destroyed;
+}
+
 /**
  * Clear in-memory state (for testing).
  */

package/src/lib/session-consolidator.js

@@ -0,0 +1,125 @@
+/**
+ * session-consolidator — bridges CLI JSONL sessions into session-core
+ * MemoryConsolidator.
+ *
+ * Managed Agents parity Phase G: `chainlesschain memory consolidate --session <id>`
+ * reads the session's append-only JSONL log, projects the events into
+ * `TRACE_TYPES.{MESSAGE,TOOL_CALL,TOOL_RESULT}` payloads, and runs the shared
+ * MemoryConsolidator against the CLI MemoryStore singleton.
+ *
+ * The JSONL store holds `session_start / user_message / assistant_message /
+ * tool_call / tool_result / compact` events. Only the user/assistant messages
+ * and tool call/result events are carried through — `session_start` and
+ * `compact` don't contribute to memory extraction.
+ */
+
+import {
+  TraceStore,
+  TRACE_TYPES,
+  MemoryConsolidator,
+} from "@chainlesschain/session-core";
+import { readEvents, sessionExists } from "../harness/jsonl-session-store.js";
+import { getMemoryStore } from "./session-core-singletons.js";
+
+/**
+ * Build an in-memory TraceStore populated with events from a JSONL session.
+ * Used so MemoryConsolidator can run against sessions that were never live
+ * in this CLI process.
+ */
+export function buildTraceStoreFromJsonl(sessionId, events) {
+  const trace = new TraceStore();
+  const source = events || readEvents(sessionId);
+
+  for (const ev of source) {
+    if (!ev || !ev.type) continue;
+    const ts = ev.timestamp || Date.now();
+    const d = ev.data || {};
+
+    switch (ev.type) {
+      case "user_message":
+        trace.record({
+          sessionId,
+          type: TRACE_TYPES.MESSAGE,
+          ts,
+          payload: { role: "user", content: d.content || "" },
+        });
+        break;
+      case "assistant_message":
+        trace.record({
+          sessionId,
+          type: TRACE_TYPES.MESSAGE,
+          ts,
+          payload: { role: "assistant", content: d.content || "" },
+        });
+        break;
+      case "tool_call":
+        trace.record({
+          sessionId,
+          type: TRACE_TYPES.TOOL_CALL,
+          ts,
+          payload: { tool: d.tool, args: d.args },
+        });
+        break;
+      case "tool_result": {
+        const raw = d.result;
+        const ok = !(raw && typeof raw === "object" && raw.error);
+        const summary =
+          typeof raw === "string"
+            ? raw
+            : raw && typeof raw === "object"
+              ? raw.summary || raw.message || null
+              : null;
+        trace.record({
+          sessionId,
+          type: TRACE_TYPES.TOOL_RESULT,
+          ts,
+          payload: { tool: d.tool, ok, summary, result: raw },
+        });
+        break;
+      }
+      default:
+        // session_start / compact / other — not memory-relevant
+        break;
+    }
+  }
+
+  return trace;
+}
+
+/**
+ * Consolidate a JSONL session into the CLI MemoryStore.
+ *
+ * @param {string} sessionId
+ * @param {object} options
+ * @param {"session"|"agent"|"global"} [options.scope="agent"]
+ * @param {string|null} [options.scopeId]
+ * @param {string|null} [options.agentId] — used as SessionHandle.agentId when
+ *   scope=agent and no scopeId given
+ * @param {object} [options.memoryStore] — override (tests)
+ * @param {Array}  [options.events] — override (tests)
+ * @returns {Promise<object>} MemoryConsolidator result
+ */
+export async function consolidateJsonlSession(sessionId, options = {}) {
+  if (!sessionId) throw new Error("sessionId required");
+  if (!options.events && !sessionExists(sessionId)) {
+    const err = new Error(`Session not found: ${sessionId}`);
+    err.code = "SESSION_NOT_FOUND";
+    throw err;
+  }
+
+  const trace = buildTraceStoreFromJsonl(sessionId, options.events);
+  const memoryStore = options.memoryStore || getMemoryStore();
+  const consolidator = new MemoryConsolidator({
+    memoryStore,
+    traceStore: trace,
+    scope: options.scope || "agent",
+  });
+
+  return consolidator.consolidate(
+    { sessionId, agentId: options.agentId || sessionId },
+    {
+      scope: options.scope,
+      scopeId: options.scopeId,
+    },
+  );
+}