@volter/supercode-teams 0.3.140 → 0.3.142

package/bin/workspace/agent-session.mjs

@@ -1,6 +1,9 @@
 // Native session hints choose the nearest actual harness when terminal servers inherited both variables.
 import { spawnSync } from 'node:child_process';
 import { basename } from 'node:path';
+import { openLocalMachine, nodeRpc } from '../../client.mjs';
+import { teamsHome, paths } from '@volter/teams/home';
+import { ownClaim } from '../../live-sessions.mjs';
 export function agentSessionHint(env=process.env){
   if(env.SUPERCODE_AGENT_SESSION)return env.SUPERCODE_AGENT_SESSION;
   const claude=env.CLAUDE_CODE_SESSION_ID,codex=env.CODEX_THREAD_ID;
@@ -18,3 +21,38 @@ export function agentSessionHint(env=process.env){
   }
   throw new Error('native session hints are ambiguous; name --session SESSION');
 }
+
+/** The daemon's retained binding is authoritative even when a launch has an old or empty context. */
+export async function agentSessionEnvironment(env = process.env, session = agentSessionHint(env)) {
+  if (!session) return env;
+  let channel;
+  try {
+    channel = await openLocalMachine(paths(teamsHome(env)).socket);
+    const rpc = await nodeRpc(channel);
+    const identity = await rpc.call('harness.v1.agents.session', { session, claim: ownClaim(env) });
+    if (!identity) return env;
+    if (env.SUPERCODE_AGENT_ID && env.SUPERCODE_AGENT_ID !== identity.agent)
+      throw Object.assign(new Error('session ownership does not match its launch identity'), { code: 'forbidden' });
+    if (env.SUPERCODE_AGENT_ORG && env.SUPERCODE_AGENT_ORG !== identity.org)
+      throw Object.assign(new Error('session Org does not match its launch identity'), { code: 'forbidden' });
+    return { ...env, SUPERCODE_AGENT_CONTEXT: identity.context ?? '', SUPERCODE_AGENT_ID: identity.agent,
+      SUPERCODE_AGENT_ORG: identity.org, SUPERCODE_AGENT_ASSIGNMENTS: JSON.stringify(identity.assignments) };
+  } catch (error) {
+    // An offline/older daemon does not authorize a fallback to a person's context.
+    // An existing launch reader can still be checked by the server itself.
+    if (!['ENOENT', 'ECONNREFUSED', 'machine_offline', -32601].includes(error.code)) throw error;
+    return env;
+  } finally { channel?.close(); }
+}
+
+/** Choosing a context never changes an agent into the connected person. */
+export function agentContextName(contexts, env = process.env, explicit = null) {
+  if (!env.SUPERCODE_AGENT_ID) return explicit ?? env.SUPERCODE_CONTEXT ?? contexts.read().current;
+  const name = explicit ?? (env.SUPERCODE_AGENT_CONTEXT || null);
+  if (!name) throw Object.assign(new Error('agent delegation is unavailable; no custodian context fallback is permitted'), { code: 'authentication_required' });
+  const selected = contexts.read().contexts[name];
+  if (!selected || selected.principal_id !== env.SUPERCODE_AGENT_ID
+    || (env.SUPERCODE_AGENT_ORG && selected.team_id !== env.SUPERCODE_AGENT_ORG))
+    throw Object.assign(new Error('selected context does not belong to this agent and Org'), { code: 'forbidden' });
+  return name;
+}

package/bin/workspace.mjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { StringDecoder } from 'node:string_decoder';
 import { hostname } from 'node:os';
-import { agentSessionHint } from './workspace/agent-session.mjs';
+import { agentSessionHint, agentSessionEnvironment, agentContextName } from './workspace/agent-session.mjs';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 import { existsSync, readFileSync, realpathSync, rmSync } from 'node:fs';
 import { basename, dirname, join, resolve } from 'node:path';
@@ -60,20 +60,8 @@ export async function workspaceMain(argv = process.argv.slice(2), env = process.
   if (verb === 'login') return loginCommand({ flags, origin: sub, rest, home, output });
   if (verb === 'auth') return authCommand({ flags, sub, rest, home, contexts, output, env, dependencies });
   if (verb === 'connect' && flags.enrollment_stdin) adoptEnrollment(contexts, home, flags);
-  if(['agent','sessions'].includes(verb)){
-    const session=flags.session??agentSessionHint(env);
-    if(session){
-      let channel;
-      try{
-        channel=await openLocalMachine(paths(teamsHome()).socket);const rpc=await nodeRpc(channel);
-        const identity=await rpc.call('harness.v1.agents.session',{session});
-        if(identity&&!flags.context&&!env.SUPERCODE_AGENT_CONTEXT)env={...env,SUPERCODE_AGENT_CONTEXT:identity.context,SUPERCODE_AGENT_ID:identity.agent,SUPERCODE_AGENT_ASSIGNMENTS:JSON.stringify(identity.assignments)};
-      }catch(error){
-        // Only absence of an older/offline daemon permits the ordinary plain-session context.
-        if(!['ENOENT','ECONNREFUSED','machine_offline',-32601].includes(error.code))throw error;
-      }finally{channel?.close();}
-    }
-  }
+  if(env.SUPERCODE_AGENT_ID||['agent','sessions'].includes(verb))
+    env=await agentSessionEnvironment(env,flags.session??agentSessionHint(env));
   // Every door called from an agent starts under its delegated context. A sibling product verb
   // must not silently recover the custodian's ordinary login when an agent's reader is bounded.
   const agentContext = env.SUPERCODE_AGENT_CONTEXT || null;
@@ -87,7 +75,7 @@ export async function workspaceMain(argv = process.argv.slice(2), env = process.
     throw new Error('agent delegation is unavailable; no custodian context fallback is permitted');
   }
   const explicitContext = flags.context ?? agentContext ?? env.SUPERCODE_CONTEXT;
-  let selected = explicitContext ?? contexts.read().current;
+  let selected = agentContextName(contexts,env,flags.context??null);
   const urlReference = verb === 'sessions' ? rest.find(value => /^https?:\/\//.test(value)) : null;
   if (!explicitContext && urlReference) selected = contextForUrl(contexts.read(), urlReference) ?? selected;
   if (!selected) usage('no workspace context selected');
@@ -871,7 +859,7 @@ async function machinesCommand(sub, { flags, rest, output, client, context, team
     }
     if (action === 'grant') {
       for (const key of ['to', 'caps', 'ttl']) if (!flags[key]) usage(`--${key} is required`);
-      const subject = /^(user|service|group):(.+)$/.exec(flags.to)?.[2]; if (!subject) usage('--to must be user:ID, service:ID or group:ID');
+      const subject = /^(user|service|agent|group):(.+)$/.exec(flags.to)?.[2]; if (!subject) usage('--to must be user:ID, service:ID, agent:ID or group:ID');
       const ttl = duration(flags.ttl);
       if (flags.session || flags.binding) {
         // One session binding's native live actions (§5).

package/fleet.mjs

@@ -8,9 +8,14 @@ import { harnessTransport, nodeRpc, openRemoteMachine } from './client.mjs';
 import { openMachine } from './machine-door.mjs';
 import { WorkspaceContexts, fromContext } from './context.mjs';
 import { teamsHome } from '@volter/teams/home';
+import { agentSessionEnvironment, agentContextName } from './bin/workspace/agent-session.mjs';
 
 /** Open the channel to the machine `name` names in `context` (or this box's daemon when name is null). */
-export function openOn(name = null, { context = null, env = process.env } = {}) {
+export async function openOn(name = null, { context = null, env = process.env } = {}) {
+  if (name && env.SUPERCODE_AGENT_ID) {
+    env = await agentSessionEnvironment(env);
+    context = agentContextName(new WorkspaceContexts(env.SUPERCODE_HOME ?? resolve(teamsHome(env), '..')), env, context);
+  }
   return openMachine({ machine: name, context, env });
 }
 
@@ -44,6 +49,7 @@ export async function nodeRequest(channel, method, params = {}) {
  * that refused or is offline carries its reason. Nothing is stored.
  */
 export async function fleetDiscover({ context = null, machines = null, params = {}, env = process.env } = {}) {
+  if (env.SUPERCODE_AGENT_ID) env = await agentSessionEnvironment(env);
   // One page from each machine, never its whole catalog (yuerans' was 5,620 sessions, 20 MB, 13.5 s): the caller's
   // limit, or FLEET_PAGE; each machine answers it from its daemon's held index.
   // `--limit 0` is every session, as it always was
@@ -51,7 +57,7 @@ export async function fleetDiscover({ context = null, machines = null, params =
   const home = teamsHome(env);
   const supercodeHome = env.SUPERCODE_HOME ?? resolve(home, '..');
   const contexts = new WorkspaceContexts(supercodeHome);
-  const name = context ?? env.SUPERCODE_CONTEXT ?? contexts.read().current;
+  const name = agentContextName(contexts, env, context);
   if (!name || name === 'local') throw new Error('--fleet discovers the machines of a Teams context: `supercode teams login …`, then `supercode context use NAME` or --context NAME');
   const { client, context: selected } = fromContext({ supercodeHome, name, fetch: globalThis.fetch });
   const token = contexts.credential(selected.credential_ref).token;
@@ -105,4 +111,3 @@ export async function fleetDiscover({ context = null, machines = null, params =
 
 /** Sessions `discover --fleet` asks each machine for when the caller names no limit. */
 const FLEET_PAGE = 50;
-

package/machine.mjs

@@ -682,13 +682,15 @@ export class TeamsMachine extends MachineCore {
     // one follow at a time: a change while one is in flight is followed again when it ends, never beside it (two in flight
     // would leave the earlier subscription unsubscribed)
     let pending = null, followed = '', backoffMs = 0, running = false, again = false;
+    this.stopLiveFollow = () => { clearTimeout(pending); pending = null; again = false; this.live.stop(); };
     const follow = async () => {
       pending = null;
+      if (this.stopping) return;
       if (running) { again = true; return; }
       running = true;
       try { await followNow(); } finally {
         running = false;
-        if (again) { again = false; if (!pending) { pending = setTimeout(follow, 0); pending.unref?.(); } }
+        if (again && !this.stopping) { again = false; if (!pending) { pending = setTimeout(follow, 0); pending.unref?.(); } }
       }
     };
     const followNow = async () => {
@@ -699,6 +701,7 @@ export class TeamsMachine extends MachineCore {
       try {
         if (locators.length) {
           const opened = await this.#serveRequest('harness.v1.sessions.activity.subscribe', { locators }, 30_000);
+          if (this.stopping) return;
           this.liveActivity = opened?.subscription ?? null;
           this.live.codexActivity(opened?.initial ?? [], { replace: true });
         } else { this.liveActivity = null; this.live.codexActivity([], { replace: true }); }
@@ -706,6 +709,7 @@ export class TeamsMachine extends MachineCore {
         this.live.codexFollowedNow();
         if (previous) void this.#serveRequest('harness.v1.sessions.activity.unsubscribe', { subscription: previous }, 30_000).catch(() => {});
       } catch (error) {
+        if (this.stopping) return;
         backoffMs = Math.min(300_000, Math.max(2000, (backoffMs || 1000) * 2));
         this.emit('records-log', `live sessions: the Codex sessions' activity could not be followed (${error.message}); tried again in ${Math.round(backoffMs / 1000)} s`);
         pending = setTimeout(follow, backoffMs); pending.unref?.();
@@ -713,7 +717,7 @@ export class TeamsMachine extends MachineCore {
     };
     // a change is followed after 2 s (changes come in bursts); the first follow after the index's first answer at once,
     // as sends wait on it (the Codex sessions are not known until it is done)
-    this.live.on('codex-followed', () => { if (!pending) { pending = setTimeout(follow, this.live.codexKnown ? 2000 : 0); pending.unref?.(); } });
+    this.live.on('codex-followed', () => { if (!this.stopping && !pending) { pending = setTimeout(follow, this.live.codexKnown ? 2000 : 0); pending.unref?.(); } });
     this.on('internal-notification', (message) => {
       const params = message.params ?? {};
       if (params.subscription && params.subscription === this.liveActivity) this.live.codexActivity(params.activities);
@@ -1158,6 +1162,8 @@ export class TeamsMachine extends MachineCore {
     this.jobs?.stopAll();
     void this.relayEndpoint?.then((endpoint) => endpoint?.close()).catch(() => {});
     this.carrier?.stop();
+    this.stopLiveFollow?.();
+    this.mailStore?.stop();
     clearInterval(this.hookSpoolTimer);
     this.idleNotices?.stop();
     this.agentUpkeep?.stop();
@@ -1353,17 +1359,30 @@ export class TeamsMachine extends MachineCore {
     accept();
     this.log.append({ principal, cap: 'harness', target: '*', outcome: 'opened' });
     const lines = lineSplitter();
+    let forwarding = Promise.resolve();
     stream.on('data', (chunk) => {
       for (const line of lines(chunk)) {
         if (!line) continue;
-        let message;
-        try { message = JSON.parse(line); } catch { continue; }
-        const asked = message.id !== undefined && message.id !== null ? message.id : null;
-        if (asked !== null) message.id = joinId(index, message.id);
-        // a serve that is not there to take it answers the request at once, on this stream only
-        if (!this.#toServe(JSON.stringify(message) + '\n') && asked !== null && !stream.closed) {
-          try { stream.write(`${JSON.stringify({ jsonrpc: '2.0', id: asked, error: { code: -32000, message: 'harness serve is not running; it is being started again' } })}\n`); } catch { /* the stream went */ }
-        }
+        forwarding = forwarding.then(async () => {
+          if (stream.closed) return;
+          if (entry.verify) {
+            const fresh = await entry.verify();
+            if (fresh?.class !== 'operator') {
+              this.log.append({ principal, cap: 'harness', target: '*', outcome: 'refused', detail: 'no live operator grant' });
+              return stream.close('no live operator grant');
+            }
+            entry.admitted = fresh;
+          }
+          if (stream.closed) return;
+          let message;
+          try { message = JSON.parse(line); } catch { return; }
+          const asked = message.id !== undefined && message.id !== null ? message.id : null;
+          if (asked !== null) message.id = joinId(index, message.id);
+          // a serve that is not there to take it answers the request at once, on this stream only
+          if (!this.#toServe(JSON.stringify(message) + '\n') && asked !== null && !stream.closed) {
+            try { stream.write(`${JSON.stringify({ jsonrpc: '2.0', id: asked, error: { code: -32000, message: 'harness serve is not running; it is being started again' } })}\n`); } catch { /* the stream went */ }
+          }
+        }).catch(() => { if (!stream.closed) stream.close('machine authority could not be verified'); });
       }
     });
     stream.on('close', () => { entry.harness = null; });
@@ -2390,6 +2409,13 @@ export class TeamsMachine extends MachineCore {
    */
   #deliverInitialInput({ key, contextKey, session, kind, by, input, act, nativeInput, executable = {}, resumed = {} }) {
     if (this.pendingInitialInputs.has(key)) return;
+    // Input confirmation can finish after the child. Keep the launch's latest
+    // status and completion; a late input receipt must not make it ready again.
+    const recordInput = facts => {
+      const launch = this.launches.find(key);
+      if (launch?.pane !== contextKey) return;
+      this.launches.record({ ...launch, ...facts, status: launch.status });
+    };
     const abort = new AbortController();
     const task = (async () => {
       let nativeReadyBy = 'native-prompt';
@@ -2399,7 +2425,7 @@ export class TeamsMachine extends MachineCore {
         const result = nativeReadyBy === 'pane-gone' || nativeReadyBy === 'deadline'
           ? { delivered: false, refused: true, reason: nativeReadyBy }
           : await this.#deliverClaudeInitialInput(session, contextKey, nativeInput, abort.signal);
-        this.launches.record({ key, pane: contextKey, kind, by, ...resumed, ...executable, status: 'ready', inputDelivered: result.delivered,
+        recordInput({ key, pane: contextKey, kind, by, ...resumed, ...executable, inputDelivered: result.delivered,
           inputReadyBy: nativeReadyBy, ...(result.delivered ? { inputReceipt: result.receipt } : { inputError: result.reason }),
           inputRefused: result.refused === true, inputPending: result.queued === true,
           ...(result.native_session ? { native_session: result.native_session } : {}) });
@@ -2415,7 +2441,7 @@ export class TeamsMachine extends MachineCore {
         const typed = nativeReadyBy === 'pane-gone' || nativeReadyBy === 'deadline' ? { delivered: false, reason: nativeReadyBy }
           : await this.#typeCodexFirstInput(session, input, abort.signal);
         if (!typed.delivered) {
-          this.launches.record({ key, pane: contextKey, kind, by, ...resumed, ...executable, status: 'ready', inputDelivered: false,
+          recordInput({ key, pane: contextKey, kind, by, ...resumed, ...executable, inputDelivered: false,
             inputReadyBy: nativeReadyBy, inputError: typed.reason });
           act('launch', `pane:${contextKey}`, 'failed', `first input undelivered: ${typed.reason}`);
           return;
@@ -2424,7 +2450,7 @@ export class TeamsMachine extends MachineCore {
       if (nativeInput) {
         const result = await confirmNativeInitialInput(nativeInput, { signal: abort.signal,
           deadlineMs: Date.now() + INITIAL_INPUT_READY_DEADLINE_MS, live: async () => Boolean(await this.#paneByContext(contextKey)) });
-        this.launches.record({ key, pane: contextKey, kind, by, ...resumed, ...executable, status: 'ready', inputDelivered: result.delivered,
+        recordInput({ key, pane: contextKey, kind, by, ...resumed, ...executable, inputDelivered: result.delivered,
           inputReadyBy: nativeReadyBy, ...(result.delivered ? { inputReceipt: result.receipt } : { inputError: result.reason }),
           ...(result.native_session ? { native_session: result.native_session } : {}) });
         act('launch', `pane:${contextKey}`, result.delivered ? 'ok' : result.queued ? 'input-pending' : 'failed',
@@ -2434,19 +2460,19 @@ export class TeamsMachine extends MachineCore {
       const readyBy = await this.#awaitInputReady(session, contextKey, kind, abort.signal);
       if (readyBy === 'aborted') return;
       if (readyBy === 'pane-gone' || readyBy === 'deadline') {
-        this.launches.record({ key, pane: contextKey, kind, by, ...resumed, ...executable, status: 'ready', inputDelivered: false, inputReadyBy: readyBy });
+        recordInput({ key, pane: contextKey, kind, by, ...resumed, ...executable, inputDelivered: false, inputReadyBy: readyBy });
         act('launch', `pane:${contextKey}`, 'failed', `first input undelivered: ${readyBy}`);
         return;
       }
       const result = await this.#deliverPaneText(session, contextKey, input, { signal: abort.signal });
-      this.launches.record({ key, pane: contextKey, kind, by, ...resumed, ...executable, status: 'ready', inputDelivered: result.delivered,
+      recordInput({ key, pane: contextKey, kind, by, ...resumed, ...executable, inputDelivered: result.delivered,
         inputReadyBy: readyBy, ...(!result.delivered ? { inputError: result.reason } : {}) });
       act('launch', `pane:${contextKey}`, result.delivered ? 'ok' : result.queued ? 'input-pending' : 'failed',
         result.delivered ? `first input delivered (${readyBy})` : `first input unconfirmed: ${result.reason}`);
     })().catch((error) => {
       // Nothing above is expected to throw; if something does, the launch record
       // is where it is answerable, not a crashed daemon.
-      this.launches.record({ key, pane: contextKey, kind, by, ...resumed, ...executable, status: 'ready', inputDelivered: false, inputError: error?.message ?? String(error) });
+      recordInput({ key, pane: contextKey, kind, by, ...resumed, ...executable, inputDelivered: false, inputError: error?.message ?? String(error) });
     }).finally(() => {
       if (this.pendingInitialInputs.get(key)?.task === task) this.pendingInitialInputs.delete(key);
     });
@@ -3202,7 +3228,8 @@ export class TeamsMachine extends MachineCore {
       cancelled_at: found.cancelled_at ?? null,
       live: Boolean(session && !session.dead), label: session?.label ?? null, activeCommand: session?.activeCommand ?? null,
       exit_output: found.pane && (!session || session.dead) ? paneExitOutput(found.pane) : null,
-      exit: session?.dead ? deadPaneExit(session) : found.pane && !session ? paneExit(found.pane) : null,
+      exit: found.completion ?? (found.status === 'finished' ? { failed: false, how: 'status 0' }
+        : session?.dead ? deadPaneExit(session) : found.pane && !session ? paneExit(found.pane) : null),
       ...initialInputFacts(found),
     };
   }
@@ -3502,6 +3529,11 @@ export class TeamsMachine extends MachineCore {
         let existing = this.launches.find(key);
         while (existing) {
           if (existing.status === 'cancelled') throw Object.assign(new Error(`launch key ${key} was cancelled before issuance; use a new key`), { code: 409, reason: 'launch_key_cancelled' });
+          // Finished itself records an observed clean exit, including older
+          // journals that did not keep a separate completion field.
+          if (existing.status === 'finished') {
+            return { key, pane: existing.pane, reused: true, status: 'finished', exit: existing.completion?.how ?? 'status 0' };
+          }
           if (existing.status === 'issued') return { key, pane: existing.pane, reused: true, status: existing.status };
           if (existing.status === 'ready') {
             const session = await this.#paneByContext(existing.pane);
@@ -3511,6 +3543,14 @@ export class TeamsMachine extends MachineCore {
               this.#recoverClaudeInitialInputs([session], key);
               return { key, pane: existing.pane, reused: true, status: existing.status };
             }
+            // The child can finish after creation but before the original
+            // caller's settlement read. Retain its observed exit before a
+            // concurrent or restarted caller can issue this key again.
+            const exit = session?.dead ? deadPaneExit(session) : paneExit(existing.pane);
+            if (exit?.failed === false) {
+              this.launches.record({ ...existing, status: 'finished', completion: exit });
+              return { key, pane: existing.pane, reused: true, status: 'finished', exit: exit.how };
+            }
           }
           break;
         }
@@ -3561,7 +3601,13 @@ export class TeamsMachine extends MachineCore {
         // The agent the launch's environment names is kept with the launch: the pane's session is bound to it once the
         // session is seen in the pane (sessionBindings).
         const agent = launchAgent(params.env);
-        this.launches.record({ key, pane: contextKey, kind: params.kind ?? null, by, ...resumed, ...executable, status: 'ready', ...(agent ? { agent } : {}) });
+        // createSession can return a retained exit descriptor with no pane.
+        // Its first journal write must already contain that completion, before
+        // any title/input/settlement await lets another caller see the key.
+        const createdExit = session.dead ? deadPaneExit(session) : null;
+        this.launches.record({ key, pane: contextKey, kind: params.kind ?? null, by, ...resumed, ...executable,
+          status: createdExit ? createdExit.failed ? 'exited' : 'finished' : 'ready',
+          ...(createdExit?.failed === false ? { completion: createdExit } : {}), ...(agent ? { agent } : {}) });
         if (params.kind === 'codex' && (params.arguments ?? []).includes('--dangerously-bypass-hook-trust')) this.#settleCodexStartup(key, contextKey, session, act);
         act('launch', `pane:${contextKey}`, 'ok', params.kind ?? params.program);
         if (typeof params.name === 'string' && params.name.trim()) {
@@ -3585,9 +3631,10 @@ export class TeamsMachine extends MachineCore {
         const settled = await this.#paneByContext(contextKey);
         if (!settled || settled.dead) {
           // Finished (it ran to a clean end) is an answer; exited (it failed at once) is the caller's error.
-          const exit = settled?.dead ? deadPaneExit(settled) : paneExit(contextKey);
+          const exit = settled?.dead ? deadPaneExit(settled) : session.dead ? deadPaneExit(session) : paneExit(contextKey);
           const status = exit && !exit.failed ? 'finished' : 'exited';
-          this.launches.record({ key, pane: contextKey, kind: params.kind ?? null, by, ...resumed, ...executable, status, error: exit?.failed ? exit.how : undefined });
+          this.launches.record({ ...this.launches.find(key), key, pane: contextKey, kind: params.kind ?? null, by, ...resumed, ...executable, status,
+            ...(exit && !exit.failed ? { completion: exit } : {}), error: exit?.failed ? exit.how : undefined });
           this.#panesChanged();
           return { key, pane: contextKey, reused: false, status, exit: exit?.how ?? null };
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@volter/supercode-teams",
-  "version": "0.3.140",
+  "version": "0.3.142",
   "type": "module",
   "description": "A machine daemon serving this machine's doors, and a local or remote Teams server for shared session discovery, OpenTelemetry ingestion and access to enrolled machines.",
   "license": "MIT",
@@ -70,7 +70,7 @@
     "@volter/supercode-health": "^0.1.0",
     "@volter/supercode-terminal": "^0.2.54",
     "@volter/supercode-trace": "^0.1.0",
-    "@volter/teams": "0.2.36",
+    "@volter/teams": "0.2.37",
     "@xterm/addon-serialize": "^0.14.0",
     "@xterm/headless": "^6.0.0",
     "protobufjs": "8.8.0",