@volter/supercode-teams 0.3.157 → 0.3.158

package/README.md

@@ -61,11 +61,19 @@ the source boundary and the remaining runtime qualification.
 The connector's redaction memo keeps serialized redacted JSON, with at most
 200,000 entries and 32 MiB of accounted string payload (two bytes per code unit,
 including keys and digests). An entry over 1 MiB is not retained. Oldest entries
-are evicted to fit; cache misses still go through the redaction worker. These are
+are evicted to fit; cache misses use a held digest observed under the same checked
+redaction basis, or go through the redaction worker. These are
 memo bounds, not total connector memory limits. The
 [source investigation](../../docs/evidence/connector-redaction-memo-2026-10-08.md)
 does not attribute the observed process peak or claim a measured runtime improvement.
 
+Memo entries are discarded when the observed custody/rules basis changes. A
+capture and its worker use one matching custody snapshot; a basis mismatch
+rejects the capture before queueing and leaves it owed for retry. Older basis
+labels cannot authorize held-digest reuse. Custody still refreshes on its existing
+30-second interval; queued and published captures are not retroactively redacted.
+[Source boundary and qualification](../../docs/evidence/connector-redaction-basis-2026-10-08.md).
+
 `supercode teams rpc mail.statistics` reads local storage counts and import/retention receipts. It is refused remotely
 and through the app door. Writer groups count stored envelope copies, not call attempts or quotas; database page
 counts exclude physical WAL size. Successful imports record their actual source reads, bytes, batch sizes and time.

package/connector/index.mjs

@@ -46,6 +46,7 @@ const covers=(root,cwd)=>{
 };
 // An error of the connection itself (the outbox, authentication, the server), not of one session.
 const connectionError=error=>Boolean(error?.outbox||error?.status===401||error?.status===403||error?.status>=500);
+const retryCapture=error=>connectionError(error)||error?.code==='redaction_basis_changed';
 const sameError=(a,b)=>a!=null&&b!=null&&a.code===b.code&&a.message===b.message;
 const errorSummary=(error,at)=>error==null?null:{code:typeof error.code==='string'?error.code:null,message:String(error.message??error).slice(0,500),at};
 /** The sync status a connector keeps in its state directory (see TeamsConnector#syncStatus); null when it has none. */
@@ -105,12 +106,21 @@ export function foldConnectorState(stateDir){
 // observed, a baseline, the carried prefix) is of that form: a digest of the local text named a prefix the server never
 // held, every carry was refused, and each session holding a secret went whole on every pass. A message is redacted
 // in the connector's redaction worker, with a bounded digest memo: no body for one without a secret (most), serialized
-// redacted JSON for one with. Evicted or oversized values are redacted again. Each loaded message's digest (of the form
+// redacted JSON for one with. A miss uses the same-basis held-digest proof or redacts again. Each loaded message's digest (of the form
 // sent) is taken once and read where needed. The byte budget counts two bytes per retained string code unit, including
 // keys and digests; the entry bound separately limits Map/record overhead. Neither is a total-process heap bound.
 const REDACTED_MEMO=200000,REDACTED_MEMO_BYTES=32*1024*1024,REDACTED_MEMO_ENTRY_BYTES=1024*1024;
 const redactions=new Map();
-let redactionBytes=0;
+let redactionBytes=0,redactionMemoBasis=null;
+function useRedactionMemo(basis){
+  if(redactionMemoBasis!==basis){redactions.clear();redactionBytes=0;redactionMemoBasis=basis;}
+}
+function requireRedactionBasis(basis){
+  if(redactionBasis()!==basis)throw Object.assign(new Error('redaction basis changed; capture needs fresh redaction'),{code:'redaction_basis_changed'});
+}
+// Older queued/committed captures could label a result with the basis read after its worker returned. They do not
+// establish the checked observation needed for held-digest reuse, even when that old label equals today's basis.
+const checkedRedactionBasis=basis=>`checked-v1:${basis}`;
 const sentDigests=new WeakMap();
 const digestOf=message=>{let digest=sentDigests.get(message);if(digest===undefined){digest=hash(canonicalJson(message.value));sentDigests.set(message,digest);}return digest;};
 function remember(digest,redacted){
@@ -660,9 +670,8 @@ export class TeamsConnector {
     if(this.unreadable?.has(key))captured=false;
     else if(changed&&!this.predatesWindow(options))try{await this.capture({...options,live:Boolean(this.watched?.has(key))});}catch(error){
       if(this.abort.signal.aborted)return;
-      // An error of the connection itself (the outbox, authentication, the server): the outbox's own retry takes it, and
-      // this session's capture stays owed until a flush passes (it may have failed before it was queued)
-      if(connectionError(error)){this.oweCapture(options,error);return;}
+      // A connection failure or a changed redaction basis keeps this session owed; the existing retry wake re-reads it.
+      if(retryCapture(error)){this.oweCapture(options,error);return;}
       captured=false;this.noteSessionProblem(options,error);
       if(!this.noteUnreadable(options,error))process.stderr.write(`supercode teams: ${harness} session ${nativeSessionId} not synced: ${error.message}\n`);
     }
@@ -892,8 +901,9 @@ export class TeamsConnector {
   // Each loaded message in the form sent: the memo's; the loaded one itself when the server holds it unchanged under
   // this redaction basis (its digest is among those last observed); else what the redaction worker makes of it, all of
   // a capture's new messages in one request. A digest is taken once per message, of the form sent.
-  async sentMessages(raw,previous){
-    const basis=redactionBasis(),held=previous?.redaction_basis===basis&&previous?.observed_digests?.length?new Set(previous.observed_digests):null;
+  async sentMessages(raw,previous,basis=redactionBasis()){
+    requireRedactionBasis(basis);useRedactionMemo(basis);
+    const held=previous?.redaction_basis===checkedRedactionBasis(basis)&&previous?.observed_digests?.length?new Set(previous.observed_digests):null;
     const out=new Array(raw.length),missing=[];
     raw.forEach((message,index)=>{
       const text=canonicalJson(message.value),digest=hash(text);
@@ -905,8 +915,10 @@ export class TeamsConnector {
       this.redactor??=new Redactor();
       if(!this.redactionCounted){this.redactionCounted=true;this.syncStatus().redaction={since:new Date(this.clock.nowMs()).toISOString(),batches:0,messages:0,bytes:0,worker_ms:0,main_ms:0,max_main_ms:0};}
       // The worker is sent each new message's canonical JSON and answers only those redaction changed.
-      let started=performance.now();const texts=missing.map(([,,text])=>text),pending=this.redactor.run('canonical',texts);let mainMs=performance.now()-started;
+      let started=performance.now();const texts=missing.map(([,,text])=>text),pending=this.redactor.run('canonical',texts,{basis});let mainMs=performance.now()-started;
       const changed=await pending;started=performance.now();
+      // Another connector/capture can run while this worker answers. Never store its result under a later basis.
+      requireRedactionBasis(basis);useRedactionMemo(basis);
       for(const [index,digest] of missing){remember(digest,null);out[index]=raw[index];sentDigests.set(raw[index],digest);}
       for(const {index:at,value,digest:sent} of changed){
         const [index,digest]=missing[at];
@@ -920,13 +932,14 @@ export class TeamsConnector {
       cost.batches+=1;cost.messages+=missing.length;cost.bytes+=texts.reduce((n,text)=>n+text.length,0);
       cost.worker_ms=Math.round(this.redactor.workerMs);cost.main_ms=Math.round((cost.main_ms+mainMs)*10)/10;cost.max_main_ms=Math.max(cost.max_main_ms,Math.round(mainMs*10)/10);
     }
-    return out;
+    requireRedactionBasis(basis);return out;
   }
-  async spillTranslated(translated,defaultName){
+  async spillTranslated(translated,defaultName,basis){
     const files=translated.files?.length?translated.files:[{path:translated.suggested_filename??defaultName,content:translated.content,role:'primary'}];
     if(files.filter(file=>file.role==='primary').length!==1)throw Object.assign(new Error('native codec bundle must contain exactly one primary file'),{code:'fidelity_unavailable'});
     let total=0;const spilled=[];
-    this.redactor??=new Redactor();const texts=await this.redactor.run('texts',files.map(file=>file.content));
+    this.redactor??=new Redactor();const texts=await this.redactor.run('texts',files.map(file=>file.content),{basis});
+    if(basis!==undefined)requireRedactionBasis(basis);
     for(const [index,file] of files.entries()){const bytes=Buffer.from(texts[index],'utf8');total+=bytes.length;if(total>256*1024*1024)throw Object.assign(new Error('native artifact bundle exceeds 256 MiB'),{code:'request_too_large'});spilled.push({path:file.path,role:file.role,...this.spill(bytes)});}
     return {fidelity:translated.fidelity,residue:translated.residue??[],files:spilled};
   }
@@ -956,7 +969,7 @@ export class TeamsConnector {
       const wait=this.watched?.has(key)||options.paced?0:CAPTURE_FLOOR_MS-(now-(this.lastCaptures.get(key)??0));
       // one retry wake per session, holding each rule's latest obligation: a newer generation of a rule replaces that
       // rule's options, never another rule's; the wake runs every rule held, paced as one
-      if(wait>0){this.holdObligation(this.retryOptions??=new Map(),key,options);if(!this.captureRetry.has(key))this.captureRetry.set(key,setTimeout(()=>{this.captureRetry.delete(key);for(const latest of this.takeObligations(this.retryOptions,key))this.capture({...latest,paced:true}).catch(error=>{if(connectionError(error))this.oweCapture(latest,error);else this.lastError=error;});},wait).unref?.());return null;}
+      if(wait>0){this.holdObligation(this.retryOptions??=new Map(),key,options);if(!this.captureRetry.has(key))this.captureRetry.set(key,setTimeout(()=>{this.captureRetry.delete(key);for(const latest of this.takeObligations(this.retryOptions,key))this.capture({...latest,paced:true}).catch(error=>{if(retryCapture(error))this.oweCapture(latest,error);else this.lastError=error;});},wait).unref?.());return null;}
       this.lastCaptures.set(key,now);
       const {locator}=options,path=locator?.storage?.kind==='file'&&existsSync(locator.storage.path)?realpathSync(locator.storage.path):null;
       const artifactBefore=path?statSync(path):null,anchor=this.codexAnchor(key,artifactBefore);
@@ -1080,7 +1093,7 @@ export class TeamsConnector {
         if(this.abort.signal.aborted)return;
         // A load that failed or timed out waits like a slow one, so it does not hold its lane on every pass.
         if(started!==null)this.largeCaptures.set(key,{at:started,ms:this.clock.nowMs()-started});
-        if(connectionError(error)){this.oweCapture(options,error);continue;}
+        if(retryCapture(error)){this.oweCapture(options,error);continue;}
         this.noteSessionProblem(options,error);
         if(!this.noteUnreadable(options,error))process.stderr.write(`supercode teams: ${options.harness} session ${options.nativeSessionId} not synced: ${error.message}\n`);
       }
@@ -1127,13 +1140,13 @@ export class TeamsConnector {
     }
     // The turns typed through a door here are labelled before redaction, which then reads them as sent.
     const raw=(loaded.messages??loaded.turns??[]).map((entry,index)=>{const value=entry.value??Object.fromEntries(Object.entries(entry).filter(([key])=>!['id','native_key','recorded_at','timestamp'].includes(key)));return{native_key:entry.id??entry.native_key??String(index),recorded_at:recordedAt(entry),value};});this.labelTurns(key,loaded.messages??loaded.turns??[],raw);
-    let messages=await this.sentMessages(raw,previous);const loadedMessages=messages,basis=redactionBasis();
+    const basis=redactionBasis();let messages=await this.sentMessages(raw,previous,basis);const loadedMessages=messages;
     if (harness === 'codex' && loaded.total_message_count > messages.length) coverage = { ...coverage, completeness: 'partial', reasons: [...new Set([...coverage.reasons, 'prefix_not_captured'])] };
     // A session published without its native bundle is captured again, with the same messages, once the bundle can be built.
     const nativeWanted=configuration.native_capture!==false&&backfillPolicy.mode==='all'&&typeof this.core.translateSession==='function'&&!((artifactBefore?.size??0)>NATIVE_MAX_BYTES);
     const retryNative=Boolean(previous?.native_deferred&&nativeWanted&&artifactBefore?.isFile()&&!previous?.baseline&&this.nativeReady(key,artifactBefore));
     const unchanged=previous?.last_rule_revision===ruleRevision&&previous?.backfill_mode===backfillPolicy.mode&&previous?.observed_keys?.length===messages.length&&messages.every((message,index)=>message.native_key===previous.observed_keys[index]&&digestOf(message)===previous.observed_digests?.[index]);
-    if(unchanged&&!retryNative){this.recordStamp(key,ruleId,ruleRevision,backfillPolicy.mode,stamp);await this.publishSessionProfile(key);return null;}
+    if(unchanged&&!retryNative){requireRedactionBasis(basis);this.origins[key]={...previous,redaction_basis:checkedRedactionBasis(basis)};this.recordStamp(key,ruleId,ruleRevision,backfillPolicy.mode,stamp);await this.publishSessionProfile(key);return null;}
     let effectivePrevious=previous;const clearBaseline=backfillPolicy.mode==='all';
     // A `none` rule keeps back the history recorded before it became active (the server's capture_after), not
     // whatever a session holds when first seen: a session begun after the rule is published from its first message.
@@ -1199,9 +1212,9 @@ export class TeamsConnector {
         // translated for this capture alone: its spilled files live while the capture is queued (outbox-only)
         try{
           const translated=(await this.core.translateSession({locator,target_harness:harness},{timeoutMs:translateTimeoutMs})).artifact;
-          if(fileStamp(statSync(artifactSource))===onDisk)bundle={stamp:onDisk,...await this.spillTranslated(translated,basename(artifactSource))};
+          if(fileStamp(statSync(artifactSource))===onDisk)bundle={stamp:onDisk,...await this.spillTranslated(translated,basename(artifactSource),basis)};
         }catch(error){
-          if(this.abort.signal.aborted)throw error;
+          if(this.abort.signal.aborted||error?.code==='redaction_basis_changed')throw error;
           this.lastError=error;process.stderr.write(`supercode teams: ${harness} session ${nativeSessionId} published without its native bundle: ${error.message}\n`);
           // The same file is not translated again; a write to it clears this.
           if(this.sessionLive(key,ruleId,epoch)){this.state.native_failed[key]=onDisk;this.save();}
@@ -1211,17 +1224,18 @@ export class TeamsConnector {
       if(bundle&&fileStamp(statSync(artifactSource))!==onDisk)bundle=null;
       if(bundle)({artifacts,nativeBundle}=this.bundleArtifacts(bundle,harness));else nativeDeferred=true;
       // A retry that still has no bundle would republish the same messages for nothing.
-      if(unchanged&&!nativeBundle){this.recordStamp(key,ruleId,ruleRevision,backfillPolicy.mode,stamp);this.armNativeIdle(key);return null;}
+      if(unchanged&&!nativeBundle){requireRedactionBasis(basis);this.origins[key]={...previous,redaction_basis:checkedRedactionBasis(basis)};this.recordStamp(key,ruleId,ruleRevision,backfillPolicy.mode,stamp);this.armNativeIdle(key);return null;}
     }else if(sqliteSource&&nativeWanted&&!effectivePrevious?.baseline){
       const translated=(await this.core.translateSession({locator,target_harness:harness},{timeoutMs:translateTimeoutMs})).artifact;
       const digest=entries=>hash(canonicalJson((entries.messages??entries.turns??[]).map(entry=>entry.value??entry)));if(digest(await this.core.session(locator).load())!==digest(loaded))throw Object.assign(new Error('native session changed while it was being captured'),{code:'resync_required'});
-      ({artifacts,nativeBundle}=this.bundleArtifacts(await this.spillTranslated(translated,`${nativeSessionId}.json`),harness));
+      ({artifacts,nativeBundle}=this.bundleArtifacts(await this.spillTranslated(translated,`${nativeSessionId}.json`,basis),harness));
     }
     const recordedTimes=messages.map(message=>message.recorded_at).filter(Number.isSafeInteger),commit={capture_id:captureId,parts:parts.length,digest:'',title:descriptor?.title??null,repository:null,reported_user:null,recorded_activity_at:recordedTimes.length?Math.max(...recordedTimes):null,parent_native_id:descriptor?.parent_session_id??null,coverage:effectivePrevious?.baseline&&!clearBaseline?{...coverage,completeness:'partial',reasons:[...new Set([...coverage.reasons,'prefix_not_captured'])]}:coverage,artifacts:artifacts.map(item=>item.manifest),...(nativeBundle?{native_bundle:nativeBundle}:{})};
     const digestCommit={...commit};delete digestCommit.digest;commit.digest=hash(canonicalJson({begin,parts,commit:digestCommit}));
     // A session gone or no longer covered while it loaded queues nothing (its spilled bundle, held by nothing, goes at the next start).
     if(!this.sessionLive(key,ruleId,epoch))return null;
-    this.queue({begin,parts,commit,artifacts,windowStart:anchor,clearBaseline,backfillMode:backfillPolicy.mode,stamp,nativeDeferred,observed:{keys:loadedMessages.map(message=>message.native_key),digests:loadedMessages.map(digestOf)},redactionBasis:basis});this.save();const receipt=await this.flushSerial();await this.publishSessionProfile(key);return receipt;
+    requireRedactionBasis(basis);
+    this.queue({begin,parts,commit,artifacts,windowStart:anchor,clearBaseline,backfillMode:backfillPolicy.mode,stamp,nativeDeferred,observed:{keys:loadedMessages.map(message=>message.native_key),digests:loadedMessages.map(digestOf)},redactionBasis:checkedRedactionBasis(basis)});this.save();const receipt=await this.flushSerial();await this.publishSessionProfile(key);return receipt;
   }
   /**
    * One session's oldest observation published. A session Teams refused (lineage not declared yet, or any error) is
@@ -1318,13 +1332,13 @@ export class TeamsConnector {
    */
   scheduleFlush(error){
     if(this.flushTimer||this.abort.signal.aborted||(!this.outbox.length&&!this.owed?.size))return;
-    if(this.flushBackoff==null)process.stderr.write(`supercode teams: ${this.outbox.length} queued capture(s) and ${this.owed?.size??0} session capture(s) wait for the server (${error?.message??'not sent'}); tried again with backoff\n`);
+    if(this.flushBackoff==null)process.stderr.write(`supercode teams: ${this.outbox.length} queued capture(s) and ${this.owed?.size??0} session capture(s) wait to retry (${error?.message??'not sent'}); tried again with backoff\n`);
     this.flushBackoff=Math.min(300000,(this.flushBackoff??2500)*2);
     this.flushTimer=setTimeout(()=>{this.flushTimer=null;void this.flush().catch(failure=>{this.lastError=failure;this.scheduleFlush(failure);});},this.flushBackoff);this.flushTimer.unref?.();
   }
   /**
-   * A capture that failed on the connection, wherever it ran (a pass, a floor's wake, a large lane): its session's
-   * capture is owed until a flush passes (it may have failed before it was queued), and the outbox's wake is armed
+   * A capture that failed on the connection or a changed redaction basis, wherever it ran (a pass, a floor's wake,
+   * a large lane): its session's capture is owed until a flush passes (it may have failed before it was queued), and the wake is armed
    * for it even when nothing is queued.
    */
   oweCapture(options,error){
@@ -1341,7 +1355,7 @@ export class TeamsConnector {
   async flushSerial(){
     let receipt;
     try{receipt=await this.flushOutbox();}catch(error){throw Object.assign(error,{outbox:true});}
-    // the connection answers again: every session whose capture failed on it is captured now
+    // Every owed session is re-read, including one whose redaction basis changed before queueing.
     if(this.owed?.size){const owed=[...this.owed];this.owed.clear();for(const key of owed)this.resee(key);}
     return receipt;
   }

package/connector/redactor.mjs

@@ -4,26 +4,34 @@
 import { Worker, isMainThread, parentPort } from 'node:worker_threads';
 
 if (!isMainThread && parentPort) {
-  const { redactText, redactValue } = await import('@volter/teams/redact');
+  const { redactText, redactValue, redactionBasis, redactionSnapshot } = await import('@volter/teams/redact');
   const { canonicalJson } = await import('../contracts/index.mjs');
   const { createHash } = await import('node:crypto');
   // 'canonical': each item is a message value's canonical JSON (the connector has it already, for its digest), a string
   // copied to this thread for little more than its bytes, where a value's object graph costs the connector's thread a
   // walk each way. Only what redaction changed comes back, with its new digest.
-  const changedOf = (items) => {
+  const changedOf = (items, custody) => {
     const changed = [];
     items.forEach((text, index) => {
-      const value = redactValue(JSON.parse(text)), sent = canonicalJson(value);
+      const value = redactValue(JSON.parse(text), undefined, custody), sent = canonicalJson(value);
       if (sent !== text) changed.push({ index, value, digest: createHash('sha256').update(sent).digest('hex') });
     });
     return changed;
   };
   const { performance } = await import('node:perf_hooks');
-  parentPort.on('message', ({ id, kind, items }) => {
+  parentPort.on('message', ({ id, kind, items, basis }) => {
     // Its own busy time rides back with each answer: what redaction costs, apart from the connector's other work.
     const started = performance.now();
-    try { const answer = kind === 'canonical' ? changedOf(items) : items.map((item) => (kind === 'texts' ? redactText(item) : redactValue(item))); parentPort.postMessage({ id, items: answer, busy: performance.now() - started }); }
-    catch (error) { parentPort.postMessage({ id, error: String(error?.message ?? error) }); }
+    const requireBasis=()=>{if(basis!==undefined&&redactionBasis()!==basis)throw Object.assign(new Error('redaction worker basis differs from the capture; capture needs fresh redaction'),{code:'redaction_basis_changed'});};
+    try {
+      // All strings in this checked batch use the same custody observation, even if a batch crosses its refresh interval.
+      const snapshot=basis===undefined?null:redactionSnapshot();
+      if(snapshot&&snapshot.basis!==basis)throw Object.assign(new Error('redaction worker basis differs from the capture; capture needs fresh redaction'),{code:'redaction_basis_changed'});
+      requireBasis();
+      const answer = kind === 'canonical' ? changedOf(items,snapshot?.values) : items.map((item) => (kind === 'texts' ? redactText(item,undefined,snapshot?.values) : redactValue(item,undefined,snapshot?.values)));
+      requireBasis();
+      parentPort.postMessage({ id, items: answer, busy: performance.now() - started });
+    } catch (error) { parentPort.postMessage({ id, error: String(error?.message ?? error), code: error?.code }); }
   });
 }
 
@@ -33,11 +41,11 @@ export class Redactor {
   start() {
     // The connector's own node flags are not the worker's (one meant for the entry script refuses to start it).
     const worker = new Worker(new URL(import.meta.url), { execArgv: [] });
-    worker.on('message', ({ id, items, error, busy }) => {
+    worker.on('message', ({ id, items, error, code, busy }) => {
       const waiter = this.waiting.get(id); if (!waiter) return;
       this.waiting.delete(id);
       this.workerMs += busy ?? 0;
-      if (error) waiter.reject(Object.assign(new Error(`redaction failed: ${error}`), { code: 'redaction_failed' }));
+      if (error) waiter.reject(Object.assign(new Error(`redaction failed: ${error}`), { code: code === 'redaction_basis_changed' ? code : 'redaction_failed' }));
       else waiter.resolve(items);
       if (!this.waiting.size) worker.unref();
     });
@@ -54,13 +62,14 @@ export class Redactor {
   }
 
   /** `items` redacted, in order: `kind` 'values' (JSON values, every string in them) or 'texts'; for 'canonical' (canonical
-   *  JSON texts) only the changed ones, as `{ index, value, digest }`. */
-  run(kind, items) {
+   *  JSON texts) only the changed ones, as `{ index, value, digest }`. An optional basis must match the worker before
+   *  and after redaction; a mismatch rejects the request rather than returning stale decisions. */
+  run(kind, items, { basis } = {}) {
     if (!items.length) return Promise.resolve([]);
     if (!this.worker) this.start();
     const id = this.next++;
     this.worker.ref();
-    return new Promise((resolve, reject) => { this.waiting.set(id, { resolve, reject }); this.worker.postMessage({ id, kind, items }); });
+    return new Promise((resolve, reject) => { this.waiting.set(id, { resolve, reject }); this.worker.postMessage({ id, kind, items, basis }); });
   }
 
   close() { const worker = this.worker; this.worker = null; return worker ? worker.terminate().then(() => {}) : Promise.resolve(); }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@volter/supercode-teams",
-  "version": "0.3.157",
+  "version": "0.3.158",
   "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",
@@ -75,7 +75,7 @@
     "@volter/supercode-health": "^0.1.0",
     "@volter/supercode-terminal": "^0.2.54",
     "@volter/supercode-trace": "^0.1.0",
-    "@volter/teams": "0.2.42",
+    "@volter/teams": "0.2.43",
     "@xterm/addon-serialize": "^0.14.0",
     "@xterm/headless": "^6.0.0",
     "protobufjs": "8.8.0",