@xmanrui/dsh-im 4.9.0 → 4.10.0

package/plugin-src/host/harness-session-coordinator.mjs

@@ -22,7 +22,9 @@ function agentsFromContext(ctx) {
 
 function currentOwnedTurn(agent, expectedTurn, promptRpcId) {
   if (agent?.status !== 'running') return false;
-  const events = agent?.session?.events;
+  const events = typeof agent?.session?.snapshotEvents === 'function'
+    ? agent.session.snapshotEvents()
+    : agent?.session?.events;
   if (!Array.isArray(events)) return false;
 
   let openTurn = null;
@@ -113,7 +115,7 @@ function createSessionMaintenanceExecutor(agents) {
   };
 }
 
-function createFileIngressExecutor(agents) {
+function createFileIngressExecutor(agents, { inboundTtlService } = {}) {
   return ({ sessionId, workspace, files, signal }) => {
     const agent = agents.get(sessionId);
     const attachedWorkspace = agent?.session?.header?.cwd;
@@ -126,7 +128,19 @@ function createFileIngressExecutor(agents) {
         'The Harness Session workspace is unavailable for inbound files.',
       );
     }
-    return stageInboundFiles({ files }, { workspace: exactWorkspace, signal });
+    const staged = stageInboundFiles({ files }, {
+      workspace: exactWorkspace,
+      signal,
+      ...(inboundTtlService ? { retention: inboundTtlService.stagingRetention() } : {}),
+      // Registration at creation time closes the mid-staging sweep window;
+      // trackStaged later re-registers idempotently and owns the release.
+      ...(typeof inboundTtlService?.trackDirectory === 'function'
+        ? { onStagedDirectory: (directory) => inboundTtlService.trackDirectory(directory) }
+        : {}),
+    });
+    return inboundTtlService
+      ? staged.then((result) => (result ? inboundTtlService.trackStaged(result) : result))
+      : staged;
   };
 }
 
@@ -136,7 +150,9 @@ function createFileIngressExecutor(agents) {
  * when an Agent is attached, its live Session header remains authoritative.
  */
 export function createHarnessSessionExecutors(ctx, provided = {}) {
-  const { controlExecutor, sessionMaintenanceExecutor, fileIngressExecutor } = provided;
+  const {
+    controlExecutor, sessionMaintenanceExecutor, fileIngressExecutor, inboundTtlService,
+  } = provided;
   if (controlExecutor !== undefined && typeof controlExecutor !== 'function') {
     throw new TypeError('controlExecutor must be a function');
   }
@@ -147,6 +163,11 @@ export function createHarnessSessionExecutors(ctx, provided = {}) {
   if (fileIngressExecutor !== undefined && typeof fileIngressExecutor !== 'function') {
     throw new TypeError('fileIngressExecutor must be a function');
   }
+  if (inboundTtlService !== undefined
+    && (typeof inboundTtlService?.stagingRetention !== 'function'
+      || typeof inboundTtlService?.trackStaged !== 'function')) {
+    throw new TypeError('inboundTtlService must expose stagingRetention() and trackStaged()');
+  }
 
   const agents = controlExecutor && sessionMaintenanceExecutor && fileIngressExecutor
     ? undefined
@@ -156,6 +177,6 @@ export function createHarnessSessionExecutors(ctx, provided = {}) {
     sessionMaintenanceExecutor: sessionMaintenanceExecutor
       ?? (agents ? createSessionMaintenanceExecutor(agents) : undefined),
     fileIngressExecutor: fileIngressExecutor
-      ?? createFileIngressExecutor(agents ?? { get: () => undefined }),
+      ?? createFileIngressExecutor(agents ?? { get: () => undefined }, { inboundTtlService }),
   };
 }

package/plugin-src/host/inbound-ttl-rpc.mjs

@@ -0,0 +1,83 @@
+import { normalizeInboundTtlHours } from '../../src/channels/shared/inbound-ttl.mjs';
+import { getInboundTtlRuntime } from './inbound-ttl-runtime.mjs';
+
+export const INBOUND_TTL_RPC_CHANNEL = '/dsh-im-settings';
+export const INBOUND_TTL_ENDPOINTS = Object.freeze({
+  get: 'settings.inbound-ttl.get',
+  set: 'settings.inbound-ttl.set',
+  sweep: 'settings.inbound-ttl.sweep',
+});
+
+const ENDPOINTS = new Set(Object.values(INBOUND_TTL_ENDPOINTS));
+
+export function validInboundTtlPayload(endpoint, payload) {
+  if (!ENDPOINTS.has(endpoint)) return false;
+  if (payload === null || typeof payload !== 'object' || Array.isArray(payload)) return false;
+  const keys = Object.keys(payload);
+  if (endpoint === INBOUND_TTL_ENDPOINTS.set) {
+    return keys.length === 1 && keys[0] === 'ttlHours'
+      && normalizeInboundTtlHours(payload.ttlHours) !== null;
+  }
+  return keys.length === 0;
+}
+
+export function createInboundTtlRpcHandler({ store, service, logger = null } = {}) {
+  if (!store || typeof store.getTtlHours !== 'function'
+    || typeof store.setTtlHours !== 'function'
+    || !service || typeof service.sweepNow !== 'function') {
+    throw new TypeError('createInboundTtlRpcHandler requires an inbound TTL store and service');
+  }
+  return async (endpoint, payload, signal) => {
+    if (!validInboundTtlPayload(endpoint, payload)) {
+      return { ok: false, error: { code: 'bad-request', message: 'Invalid inbound TTL request.' } };
+    }
+    if (signal?.aborted) {
+      return { ok: false, error: { code: 'cancelled', message: 'Request cancelled.' } };
+    }
+    try {
+      if (endpoint === INBOUND_TTL_ENDPOINTS.get) {
+        return { ok: true, value: { ttlHours: store.getTtlHours() } };
+      }
+      if (endpoint === INBOUND_TTL_ENDPOINTS.set) {
+        const ttlHours = await store.setTtlHours(payload.ttlHours);
+        // Re-arm the sweep interval so the saved value gets a full window
+        // before its first scheduled enforcement.
+        service.resetSweepSchedule?.();
+        return { ok: true, value: { ttlHours } };
+      }
+      const summary = await service.sweepNow();
+      // The UI shows no result text, so the host log is the only place a
+      // manual sweep can be diagnosed (TTL applied, coverage, deletions).
+      logger?.info?.(
+        `[dsh-im] manual inbound attachment sweep: ${summary.deletedDirectories} deleted`
+        + ` across ${summary.sweptWorkspaces} workspaces (ttl ${store.getTtlHours()}h)`,
+      );
+      return { ok: true, value: summary };
+    } catch (error) {
+      if (error?.code === 'inbound-ttl-invalid') {
+        return {
+          ok: false,
+          error: {
+            code: 'inbound-ttl-invalid',
+            message: '附件保留时长无效：请输入 -1、0 或 1-8760 之间的整数小时数。',
+          },
+        };
+      }
+      return { ok: false, error: { code: 'inbound-ttl-unavailable', message: 'inbound-ttl-unavailable' } };
+    }
+  };
+}
+
+export function installInboundTtlRpc(ctx, options = {}) {
+  if (!ctx?.connection?.rpc || typeof ctx.connection.rpc.handle !== 'function') {
+    throw new TypeError('DSH Host Connection RPC is required');
+  }
+  const runtime = options.runtime ?? getInboundTtlRuntime(ctx, options.config);
+  const logger = typeof ctx?.logger === 'function'
+    ? ctx.logger('dsh-im:inbound-ttl') : (ctx?.logger ?? null);
+  return ctx.connection.rpc.handle(
+    INBOUND_TTL_RPC_CHANNEL,
+    createInboundTtlRpcHandler({ ...runtime, logger }),
+    { authority: 'loopback' },
+  );
+}

package/plugin-src/host/inbound-ttl-runtime.mjs

@@ -0,0 +1,85 @@
+import { homedir } from 'node:os';
+import { join, resolve } from 'node:path';
+
+import { InboundTtlStore } from '../../src/channels/shared/inbound-ttl-store.mjs';
+import { createInboundTtlService } from './inbound-ttl-service.mjs';
+
+const runtimes = new Map();
+
+/**
+ * Resolve the global settings file shared by every channel. The dshHome
+ * resolution mirrors pluginPaths: config.dshHome, then DSH_HOME, then the
+ * user's home directory. Channel-specific dataDir values never apply.
+ */
+export function inboundTtlSettingsPath(config = {}) {
+  const dshHome = resolve(config.dshHome ?? process.env.DSH_HOME ?? join(homedir(), '.dsh'));
+  return resolve(dshHome, 'integrations', 'dsh-im', 'settings.json');
+}
+
+/**
+ * Per-process inbound TTL runtime, cached by resolved settings path so every
+ * channel shares one store, one staged registry, and one sweep timer. The
+ * entry is dropped (and the sweeper stopped) when the owning context is
+ * disposed, letting a later activation rebuild from disk.
+ */
+export function getInboundTtlRuntime(ctx, config = {}) {
+  const settingsPath = inboundTtlSettingsPath(config);
+  const existing = runtimes.get(settingsPath);
+  if (existing) return existing.runtime;
+  const logger = typeof ctx?.logger === 'function'
+    ? ctx.logger('dsh-im:inbound-ttl') : (ctx?.logger ?? console);
+  const store = new InboundTtlStore(settingsPath);
+  const service = createInboundTtlService({ store, logger });
+  const runtime = Object.freeze({ store, service });
+  const entry = { runtime };
+  runtimes.set(settingsPath, entry);
+  // Load persisted settings before the first sweep so a keep-forever TTL can
+  // never be overtaken by the in-memory default. An unreadable store keeps
+  // sweeping disabled rather than deleting files of unknown intent.
+  void store.load().then(
+    () => service.start(),
+    (error) => logger.error?.('[dsh-im] unable to load inbound attachment settings; sweeping stays disabled', error),
+  );
+  if (typeof ctx?.effect === 'function') {
+    ctx.effect(() => () => {
+      if (runtimes.get(settingsPath) !== entry) return;
+      runtimes.delete(settingsPath);
+      service.stop();
+    }, 'dsh-im: stop inbound attachment TTL sweeper');
+  }
+  return runtime;
+}
+
+/**
+ * Advertise one channel's bot workspaces to the global sweeper. The provider
+ * is consulted at sweep time, so bots added or removed later are always
+ * current. The default workspace is always included.
+ */
+export function registerInboundTtlWorkspaces(ctx, service, {
+  workspaces,
+  configStore,
+  defaultWorkspace,
+  botIdFrom = (bot) => bot?.botId,
+} = {}) {
+  if (!service || typeof service.registerWorkspaceProvider !== 'function') return undefined;
+  if (!workspaces || typeof workspaces.workspaceFor !== 'function'
+    || typeof defaultWorkspace !== 'string' || !defaultWorkspace) {
+    return undefined;
+  }
+  const unregister = service.registerWorkspaceProvider(() => {
+    const bots = typeof configStore?.list === 'function' ? configStore.list() : [];
+    const paths = [defaultWorkspace];
+    for (const bot of Array.isArray(bots) ? bots : []) {
+      try {
+        paths.push(workspaces.workspaceFor(botIdFrom(bot)));
+      } catch {
+        // A malformed config entry must not hide the remaining workspaces.
+      }
+    }
+    return paths;
+  });
+  if (typeof ctx?.effect === 'function') {
+    ctx.effect(() => unregister, 'dsh-im: unregister inbound TTL workspaces');
+  }
+  return unregister;
+}

package/plugin-src/host/inbound-ttl-service.mjs

@@ -0,0 +1,179 @@
+import { realpathSync } from 'node:fs';
+import { resolve } from 'node:path';
+
+import { sweepInboundAttachments } from '../../src/channels/shared/inbound-file.mjs';
+
+const DEFAULT_SWEEP_INTERVAL_MS = 30 * 60_000;
+
+// A tracked directory is shielded from sweeps while its turn may still be
+// running. Aborted or stalled turns never call cleanup(), so protection has
+// an upper bound — far above the default reply timeout — after which the
+// directory falls back under TTL control instead of leaking forever.
+const TRACKED_PROTECTION_MS = 24 * 60 * 60_000;
+
+/**
+ * Host-process coordinator for the global inbound attachment TTL. The staged
+ * registry marks directories owned by in-flight turns so a slow turn can
+ * outlive any TTL window without the sweeper deleting its files.
+ */
+export function createInboundTtlService({
+  store,
+  logger = console,
+  intervalMs = DEFAULT_SWEEP_INTERVAL_MS,
+} = {}) {
+  if (!store || typeof store.getTtlHours !== 'function') {
+    throw new TypeError('createInboundTtlService requires a store exposing getTtlHours()');
+  }
+  const tracked = new Map();
+  const providers = new Set();
+  let timer = null;
+
+  const runSweep = () => {
+    sweepNow().catch((error) => {
+      logger.error?.('[dsh-im] inbound attachment sweep failed', error);
+    });
+  };
+
+  function registerWorkspaceProvider(provider) {
+    if (typeof provider !== 'function') {
+      throw new TypeError('inbound TTL workspace provider must be a function');
+    }
+    const wasEmpty = providers.size === 0;
+    providers.add(provider);
+    // The startup sweep races channel activation and usually runs before any
+    // provider exists; re-sweep on the first registration so crash leftovers
+    // do not wait a full interval.
+    if (wasEmpty && timer) runSweep();
+    return () => {
+      providers.delete(provider);
+    };
+  }
+
+  function stagingRetention() {
+    // TTL 0 deletes at turn end; every other mode keeps files for the sweeper.
+    return store.getTtlHours() === 0 ? 'turn' : 'persistent';
+  }
+
+  function canonicalPath(directory) {
+    try {
+      return realpathSync(directory);
+    } catch {
+      return null;
+    }
+  }
+
+  function trackDirectory(directory, { now = () => Date.now() } = {}) {
+    if (typeof directory !== 'string' || !directory) return;
+    const trackedAt = now();
+    tracked.set(directory, trackedAt);
+    // The harness-reported cwd and workspaceFor() may normalize symlinks
+    // differently; track both spellings so either side finds the entry.
+    const canonical = canonicalPath(directory);
+    if (canonical && canonical !== directory) tracked.set(canonical, trackedAt);
+  }
+
+  function releaseDirectory(directory) {
+    tracked.delete(directory);
+    const canonical = canonicalPath(directory);
+    if (canonical && canonical !== directory) tracked.delete(canonical);
+  }
+
+  function isTrackedNow(directory) {
+    const trackedAt = tracked.get(directory);
+    if (trackedAt === undefined) return false;
+    if (Date.now() - trackedAt >= TRACKED_PROTECTION_MS) {
+      tracked.delete(directory);
+      return false;
+    }
+    return true;
+  }
+
+  function trackStaged(staged) {
+    if (!staged || typeof staged !== 'object') return staged;
+    const { directory } = staged;
+    if (typeof directory !== 'string' || !directory) return staged;
+    trackDirectory(directory);
+    const cleanup = typeof staged.cleanup === 'function' ? staged.cleanup : null;
+    return Object.freeze({
+      ...staged,
+      async cleanup() {
+        try {
+          await cleanup?.call(staged);
+        } finally {
+          releaseDirectory(directory);
+        }
+      },
+    });
+  }
+
+  async function sweepNow() {
+    const ttlHours = store.getTtlHours();
+    // Keep-forever never deletes, so no workspace is even inspected.
+    if (ttlHours === -1) return { deletedDirectories: 0, sweptWorkspaces: 0 };
+    const workspaces = new Set();
+    for (const provider of providers) {
+      try {
+        const provided = await provider();
+        for (const workspace of Array.isArray(provided) ? provided : []) {
+          if (typeof workspace === 'string' && workspace) workspaces.add(resolve(workspace));
+        }
+      } catch (error) {
+        logger.warn?.('[dsh-im] inbound TTL workspace provider failed', error);
+      }
+    }
+    const isTracked = (directory) => isTrackedNow(directory)
+      || (canonicalPath(directory) !== null && isTrackedNow(canonicalPath(directory)));
+    let deletedDirectories = 0;
+    let sweptWorkspaces = 0;
+    for (const workspace of workspaces) {
+      try {
+        const result = await sweepInboundAttachments(workspace, ttlHours, { isTracked });
+        deletedDirectories += result.deleted;
+        sweptWorkspaces += 1;
+      } catch (error) {
+        logger.warn?.(`[dsh-im] inbound attachment sweep failed under ${workspace}`, error);
+      }
+    }
+    if (deletedDirectories > 0) {
+      logger.info?.(
+        `[dsh-im] inbound attachment sweep deleted ${deletedDirectories} directories`
+        + ` across ${sweptWorkspaces} workspaces (ttl ${ttlHours}h)`,
+      );
+    }
+    return { deletedDirectories, sweptWorkspaces };
+  }
+
+  function start() {
+    if (timer) return;
+    runSweep();
+    timer = setInterval(runSweep, intervalMs);
+    timer.unref?.();
+  }
+
+  // A freshly saved TTL postpones the next scheduled sweep by a full
+  // interval so the new value is never enforced by a sweep firing moments
+  // after the change, and is not starved of one either.
+  function resetSweepSchedule() {
+    if (!timer) return;
+    clearInterval(timer);
+    timer = setInterval(runSweep, intervalMs);
+    timer.unref?.();
+  }
+
+  function stop() {
+    if (!timer) return;
+    clearInterval(timer);
+    timer = null;
+  }
+
+  return Object.freeze({
+    registerWorkspaceProvider,
+    stagingRetention,
+    trackDirectory,
+    trackStaged,
+    sweepNow,
+    start,
+    resetSweepSchedule,
+    stop,
+  });
+}

package/plugin-src/host/index.mjs

@@ -13,6 +13,7 @@ import { setImHostLanguage } from '../../src/channels/shared/i18n.mjs';
 import { installDeliveryRpc } from './delivery-rpc.mjs';
 import { installDeliveryHttp } from './delivery-http.mjs';
 import { createDeliveryService } from './delivery-service.mjs';
+import { installInboundTtlRpc } from './inbound-ttl-rpc.mjs';
 import { installUpdateRpc } from './update-rpc.mjs';
 
 export const name = 'dsh-im-host';
@@ -32,6 +33,7 @@ function channelConfig(config, name, deliveryService) {
 
 export function createImHostPlugin(internals = {}) {
   const startUpdate = internals.installUpdateRpc ?? installUpdateRpc;
+  const startInboundTtl = internals.installInboundTtlRpc ?? installInboundTtlRpc;
   const startDelivery = internals.installDeliveryRpc ?? installDeliveryRpc;
   const startDeliveryHttp = internals.installDeliveryHttp ?? installDeliveryHttp;
   const makeDeliveryService = internals.createDeliveryService ?? createDeliveryService;
@@ -68,6 +70,7 @@ export function createImHostPlugin(internals = {}) {
             deliveryService.send(botId, targetId, text, options)
           ),
           listTargets: async (botId) => (await deliveryService.listTargets(botId)).targets,
+          listBots: () => deliveryService.listBots(),
         }));
       }
       const activate = async (readyCtx) => {
@@ -109,6 +112,11 @@ export function createImHostPlugin(internals = {}) {
       } catch (error) {
         logger.error?.('[dsh-im] failed to activate update management; continuing with channels', error);
       }
+      try {
+        startInboundTtl(ctx, { config });
+      } catch (error) {
+        logger.error?.('[dsh-im] failed to activate inbound TTL settings; continuing with channels', error);
+      }
       try {
         startDelivery(ctx, deliveryService, { authority: config.rpcAuthority });
       } catch (error) {

package/plugin-src/host/modern-harness-api.mjs

@@ -52,6 +52,15 @@ function questionError(message, code) {
   return error;
 }
 
+function sessionEvents(session) {
+  if (typeof session?.snapshotEvents === 'function') {
+    const events = session.snapshotEvents();
+    if (Array.isArray(events)) return events;
+  }
+  const events = session?.events;
+  return Array.isArray(events) ? events : null;
+}
+
 function matchesQuestions(value, pending) {
   if (!value || typeof value !== 'object'
     || value.sessionId !== pending.sessionId
@@ -191,6 +200,7 @@ class ModernHarnessApi {
   #pendingQuestions = new Map();
   #pendingApprovals = new Map();
   #sessionCursors = new Map();
+  #assistantStreams = new Map();
   #disposers = [];
   #disposed = false;
 
@@ -252,6 +262,13 @@ class ModernHarnessApi {
         if (Number.isSafeInteger(event.seq)) this.#rememberCursor(sessionId, event.seq);
         this.#broadcast({ type: 'session/event', sessionId, event });
       }, { global: true }));
+      this.#disposers.push(ctx.on('agent/assistant-stream', ({ agent, frame }) => {
+        this.#acceptAssistantStream(agent, frame);
+      }, { global: true }));
+      this.#disposers.push(ctx.on('agent/disposed', ({ agent }) => {
+        const sessionId = agent?.session?.id;
+        if (typeof sessionId === 'string') this.#assistantStreams.delete(sessionId);
+      }, { global: true }));
       this.#disposers.push(ctx.on(
         'approval/request',
         (request, next) => this.#requestApproval(request, next),
@@ -319,7 +336,7 @@ class ModernHarnessApi {
       cursor = this.#sessionCursors.get(sessionId) ?? snapshot.cursor;
       if (beforeSeq === undefined && cursor === snapshot.cursor) {
         return {
-          events: historyEntries(snapshot.records),
+          events: this.#withAssistantStream(sessionId, historyEntries(snapshot.records)),
           hasMore: snapshot.hasMore === true,
           ...(snapshot.projections === undefined ? {} : { projections: snapshot.projections }),
         };
@@ -333,7 +350,54 @@ class ModernHarnessApi {
         ...(beforeSeq === undefined ? {} : { beforeSeq }),
       },
     }, signal);
-    return { events: historyEntries(page.records), hasMore: page.hasMore === true };
+    return {
+      events: beforeSeq === undefined
+        ? this.#withAssistantStream(sessionId, historyEntries(page.records))
+        : historyEntries(page.records),
+      hasMore: page.hasMore === true,
+    };
+  }
+
+  #acceptAssistantStream(agent, frame) {
+    const sessionId = agent?.session?.id;
+    if (typeof sessionId !== 'string' || !frame || typeof frame !== 'object') return;
+    if (frame.type === 'start') {
+      const nextSeq = agent?.session?.seq;
+      const startedAfterSeq = Number.isSafeInteger(nextSeq) && nextSeq >= 0
+        ? nextSeq - 1
+        : this.#sessionCursors.get(sessionId) ?? -1;
+      this.#assistantStreams.set(sessionId, {
+        attemptId: frame.attemptId,
+        turn: frame.turn,
+        step: frame.step,
+        startedAfterSeq,
+        entries: [],
+      });
+      return;
+    }
+    const stream = this.#assistantStreams.get(sessionId);
+    if (!stream || stream.attemptId !== frame.attemptId) return;
+    if (frame.type === 'end') {
+      this.#assistantStreams.delete(sessionId);
+      return;
+    }
+    if (frame.type !== 'chunk' || frame.index !== stream.entries.length) return;
+    stream.entries.push({
+      type: 'transient',
+      event: {
+        type: 'assistant/chunk',
+        // Match DSH's Web client ordering: live chunks sit in the numeric gap
+        // before the durable assistant/message that replaces them.
+        seq: stream.startedAfterSeq + 1 - 1 / (frame.index + 2),
+        time: frame.time,
+        data: { turn: stream.turn, step: stream.step, chunk: frame.chunk },
+      },
+    });
+  }
+
+  #withAssistantStream(sessionId, entries) {
+    const transient = this.#assistantStreams.get(sessionId)?.entries ?? [];
+    return transient.length === 0 ? entries : [...entries, ...transient];
   }
 
   #rememberCursor(sessionId, cursor) {
@@ -385,15 +449,15 @@ class ModernHarnessApi {
   }
 
   #claimableAgent(agent) {
-    const sessionId = agent?.session?.id ?? agent?.id;
-    if (typeof sessionId !== 'string' || !agent?.session || !Array.isArray(agent.session.events)) {
-      return null;
-    }
+    const session = agent?.session;
+    const sessionId = session?.id ?? agent?.id;
+    const events = sessionEvents(session);
+    if (typeof sessionId !== 'string' || !events) return null;
     return hasActiveHarnessInteractionOwner(
       this.#scope,
       sessionId,
-      agent.session.events,
-    ) ? { sessionId, session: agent.session } : null;
+      events,
+    ) ? { sessionId, events } : null;
   }
 
   #questionFrame(pending) {
@@ -464,8 +528,8 @@ class ModernHarnessApi {
     const claimed = new Set([...this.#pendingApprovals.values()].map((entry) => entry.approvalId));
     const decided = new Set();
     let approvalId;
-    for (let index = owner.session.events.length - 1; index >= 0; index -= 1) {
-      const event = owner.session.events[index];
+    for (let index = owner.events.length - 1; index >= 0; index -= 1) {
+      const event = owner.events[index];
       if (event.type === 'approval/decided') {
         decided.add(event.data?.id);
       } else if (event.type === 'approval/asked') {
@@ -547,6 +611,7 @@ class ModernHarnessApi {
     if (this.#disposed) return;
     this.#disposed = true;
     for (const subscription of [...this.#mux]) subscription.close();
+    this.#assistantStreams.clear();
     for (const pending of [...this.#pendingApprovals.values()]) pending.settle('cancelled');
     for (const pending of [...this.#pendingQuestions.values()]) pending.settle(
       'cancelled',