@volter/supercode-teams 0.3.156 → 0.3.158

package/README.md

@@ -58,6 +58,22 @@ mail history and individual records can still be large. The
 [allocation evidence](../../docs/evidence/mail-transcript-stream-2026-10-08.md) names
 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 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. */
@@ -103,14 +104,39 @@ export function foldConnectorState(stateDir){
 }
 // What leaves for the server is redacted (@volter/teams/redact), and every digest this connector keeps or sends (what it
 // 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 once
-// per process, in the connector's redaction worker: by its digest, nothing kept for one without a secret (most), its
-// redacted form for one with. Each loaded message's digest (of the form sent) is taken once and read where needed.
-const REDACTED_MEMO=200000;
+// 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. 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,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;};
-const remember=(digest,redacted)=>{if(redactions.size>=REDACTED_MEMO)redactions.clear();redactions.set(digest,redacted);};
+function remember(digest,redacted){
+  // Remove the earlier unchanged placeholder even if this redacted body is too large to cache: leaving it would
+  // make a later hit reuse the original, unredacted message.
+  const previous=redactions.get(digest);
+  if(previous){redactionBytes-=previous.bytes;redactions.delete(digest);}
+  const kept=redacted?{text:JSON.stringify(redacted.value),digest:redacted.digest}:null;
+  const bytes=2*(digest.length+(kept?.digest.length??0)+(kept?.text.length??0));
+  if(bytes>REDACTED_MEMO_ENTRY_BYTES)return;
+  while(redactions.size>=REDACTED_MEMO||redactionBytes+bytes>REDACTED_MEMO_BYTES){
+    const oldest=redactions.keys().next().value;
+    redactionBytes-=redactions.get(oldest).bytes;redactions.delete(oldest);
+  }
+  redactions.set(digest,{kept,bytes});redactionBytes+=bytes;
+}
 // A capture part is one request, and the server refuses a body over 8 MiB (volter-teams request-json.mjs): a part
 // holds at most PART_MESSAGES messages (the contract's bound) and PART_BYTES of them, so a run of large tool results
 // splits across parts instead of failing the whole session. A single message larger than that goes alone.
@@ -644,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`);
     }
@@ -876,12 +901,13 @@ 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);
-      if(redactions.has(digest)){const kept=redactions.get(digest);out[index]=kept?{...message,value:kept.value}:message;sentDigests.set(out[index],kept?kept.digest:digest);return;}
+      if(redactions.has(digest)){const {kept}=redactions.get(digest);out[index]=kept?{...message,value:JSON.parse(kept.text)}:message;sentDigests.set(out[index],kept?kept.digest:digest);return;}
       if(held?.has(digest)){remember(digest,null);out[index]=message;sentDigests.set(message,digest);return;}
       missing.push([index,digest,text]);
     });
@@ -889,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];
@@ -904,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};
   }
@@ -940,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);
@@ -1064,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`);
       }
@@ -1111,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.
@@ -1183,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();}
@@ -1195,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
@@ -1302,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){
@@ -1325,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.156",
+  "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",