@volter/supercode-teams 0.3.154 → 0.3.156

package/README.md

@@ -27,7 +27,10 @@ verified caller at its local origin. `harness.v1.sessions.close_remote` accepts
 that forwarded caller at the target's Teams door only, under pane control. It
 retains native live-work checks, then calls the existing pane-close door to
 recheck its grant, recorded starter and host entry. It adds no caller identity
-or origin-attestation protocol. A nonstarter needs explicit
+or origin-attestation protocol. Native activity coverage on this path currently
+includes Claude Code and Codex. Other recognized harness panes refuse without
+`foreign: true` when their activity cannot be read; plain command panes are
+handled separately. A nonstarter needs explicit
 `foreign: true` for that one pane. These are node-door methods, not additions to
 the native harness service. [Scope and qualification](../../docs/evidence/remote-pane-close-2026-10-08.md).
 
@@ -49,6 +52,12 @@ Settled read bodies expire after 30 days, with explicit placeholders and retaine
 its originals. Expired read headers are capped at 1,000,000 and carrier/terminal event log tables at 10,000 rows each. Read the
 [dated qualification scope](../../docs/evidence/sqlite-mail-store-2026-10-08.md) before inferring platform support.
 
+Native mail-history reads process the opened file's initial extent in 64 KiB blocks,
+holding one unfinished record instead of the whole transcript and line array. Returned
+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.
+
 `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/bin/workspace.mjs

@@ -1160,6 +1160,11 @@ async function connectorCommand(verb, { flags, rest, output, client, context, te
     // on the machine credential and the daemon keeps the agent's reader context for it; a pane session's agent is the
     // one its launch recorded.
     connector.recordAgentSession=binding=>machine.bindAgentSession(binding,{delegator:context.machine_only?null:contextName});
+    machine.agentDelegator=context.machine_only?null:contextName;
+    machine.agentSessionIntent=session=>{
+      const item=connector.state.agent_sessions?.[session];
+      return item&&['pending','bound'].includes(item.state)?{agent:item.agent,org:item.org,context:item.context,assignments:item.assignments}:null;
+    };
     machine.onLaunchAgent=(session,environment)=>connector.queueAgentSession(session,environment);
     connector.flushAgentIdentity=()=>machine.flushAgentIdentity({delegator:context.machine_only?null:contextName});
     connector.agentClosureReceipt=async id=>{
@@ -1411,6 +1416,7 @@ function humanOutput(value) {
   const data = value?.data ?? value;
   if (data === null) return `${context}Done.\n`;
   if (typeof data === 'string') return `${context}${data}\n`;
+  if(typeof data?.session==='string'&&data.agent)return `${context}Session: ${data.session}\nAgent: ${data.agent.path??data.agent.name??data.agent.id} (${data.agent.id})\n${data.main?'Main session':'Concurrent session'}${data.source?`\nSource: ${data.source}`:''}\n`;
   const row = humanRow(data);
   return `${context}${Object.entries(row).map(([key, item]) => `${key}: ${item}`).join('\n')}\n`;
 }
@@ -1423,7 +1429,7 @@ function humanTranscript(descriptor, messages) {
   const lines = messages.map(message => { const value = message.value ?? message; const body = [text(value.content ?? value.text).trim(), calls(value)].filter(Boolean).join('\n'); return `\n${value.role ?? 'message'}:\n${body || '(no text)'}\n`; });
   return head + coverage + (lines.length ? lines.join('') : '\n(no messages in this window)\n');
 }
-function humanRow(value) { if (!value || typeof value !== 'object') return { value }; const descriptor = value.session ?? value; return Object.fromEntries(Object.entries(descriptor).filter(([, item]) => item === null || ['string', 'number', 'boolean'].includes(typeof item)).slice(0, 8)); }
+function humanRow(value) { if (!value || typeof value !== 'object') return { value }; const descriptor = value.session&&typeof value.session==='object'?value.session:value; return Object.fromEntries(Object.entries(descriptor).filter(([, item]) => item === null || ['string', 'number', 'boolean'].includes(typeof item)).slice(0, 8)); }
 async function stream(iterator, json) { for await (const event of iterator) process.stdout.write(json ? `${JSON.stringify(event)}\n` : humanOutput(event)); }
 function unsupported(message) { throw Object.assign(new Error(message), { code: 'unsupported', exitCode: 5 }); }
 function notFound(message) { throw Object.assign(new Error(message), { code: 'not_found', exitCode: 4 }); }

package/connector/index.mjs

@@ -1256,12 +1256,15 @@ export class TeamsConnector {
     for(const [session,item] of Object.entries(sessions)){
       if(item.state!=='pending'||item.next_at>now)continue;
       try{
+        // Reading as the launch's agent needs its delegation, not a transcript already captured in Teams. Keep the
+        // reader first, so a slow initial capture cannot strand the session's whoami/sessions commands.
+        const binding=await this.recordAgentSession?.({session,agent:item.agent,org:item.org,context:item.context,assignments:item.assignments});
+        if(binding)item.context=binding.context;
         if(!item.declared){
           await this.request('POST',`/machines/${this.machineId}/agent-sessions`,{session,agent:item.agent,main:item.main});item.declared=true;
           // its lineage exists now: a session held for want of it is sent again in this pass
           if(this.state.profile_holds?.[session])delete this.state.profile_holds[session];
         }
-        await this.recordAgentSession?.({session,agent:item.agent,org:item.org,context:item.context,assignments:item.assignments});
         item.state='bound';item.bound_at=now;delete item.error;
       }catch(error){
         item.attempts+=1;item.error=errorSummary(error,now);

package/machine.mjs

@@ -365,6 +365,7 @@ export class TeamsMachine extends MachineCore {
   /** Typed lines by key → the answer their first attempt gives (see #serveTurn). */
   #turnKeys = new Map();
   #sessionBindings = new Map();
+  #agentReaders = new Map();
 
   /** Native process evidence, published by the connector; a missing transport never reports an end. */
   async sessionBindings(machineId,incarnationId) {
@@ -402,10 +403,10 @@ export class TeamsMachine extends MachineCore {
 
   /** An agent's delegated reader credential installed as a context of this machine's supercode home: what its
    * sessions' Teams verbs run under. */
-  async #installAgentContext({origin,team,agent,credential}){
+  async #installAgentContext({origin,team,agent,credential},signal=AbortSignal.timeout(15000)){
     if(typeof origin!=='string'||typeof team!=='string'||typeof agent!=='string'||typeof credential?.token!=='string')throw Object.assign(new Error('agent context requires server, Org, identity and delegated credential'),{code:400});
     const client=new TeamsClient({server:origin,credential:credential.token});
-    const me=await client.me({signal:AbortSignal.timeout(15000)});
+    const me=await client.me({signal});
     if(me.principal.id!==agent||me.principal.kind!=='agent'||!me.teams.some(item=>item.team.id===team))throw Object.assign(new Error('delegated credential does not belong to this agent and Org'),{code:403});
     const key=createHash('sha256').update(`${client.server}/${team}/${agent}`).digest('hex');
     const name=`agent-${key.slice(0,32)}`,ref=`cred_${key}`,contexts=new WorkspaceContexts(supercodeHome(this.env));
@@ -414,23 +415,49 @@ export class TeamsMachine extends MachineCore {
     return {context:name,agent,org:team,expires_at:credential.expires_at};
   }
 
+  /** A reader is reused only while it belongs to this agent and Org and has not expired. Concurrent sessions of
+   * one agent share a renewal. The connected person's authority is used only to delegate; no command runs as them. */
+  async #agentReader({agent,org,context},delegator){
+    const contexts=new WorkspaceContexts(supercodeHome(this.env)),document=contexts.read();
+    let selected=context?document.contexts[context]:null;
+    if(selected&&(selected.principal_id!==agent||(org&&selected.team_id!==org)))
+      throw Object.assign(new Error('agent reader context belongs to another agent or Org'),{code:403});
+    if(!selected){
+      const existing=Object.entries(document.contexts).find(([,item])=>item.principal_id===agent&&item.team_id===org);
+      if(existing)[context,selected]=existing;
+    }
+    org??=selected?.team_id;
+    const credential=selected?contexts.credential(selected.credential_ref):null;
+    if(credential?.token&&credential.server_id===selected.server_id&&credential.origin===selected.origin
+      &&Number.isSafeInteger(credential.expires_at)&&credential.expires_at>Date.now())return {context,org};
+    if(!delegator)return {context:null,org};
+    const key=`${org??''}/${agent}`;
+    if(this.#agentReaders.has(key))return this.#agentReaders.get(key);
+    const renewal=(async()=>{
+      const source=fromContext({supercodeHome:supercodeHome(this.env),name:delegator}),signal=AbortSignal.timeout(20000);
+      if(org&&source.context.team_id!==org)throw Object.assign(new Error('agent reader renewal belongs to another Org'),{code:403});
+      const team=source.client.team(source.context.team_id),identity=(await team.agents.get(agent,{signal})).data;
+      if(identity.state!=='active')throw Object.assign(new Error('only an active agent receives a reader context'),{code:403});
+      const reader=await team.agents.delegateReader(identity.id,{expires_in_ms:86400000},{signal,ifMatch:identity.revision});
+      return this.#installAgentContext({origin:source.context.origin,team:source.context.team_id,agent:identity.id,credential:reader.data},signal);
+    })();
+    this.#agentReaders.set(key,renewal);
+    try{return await renewal;}finally{this.#agentReaders.delete(key);}
+  }
+
   /**
    * A session this machine's connector declared its agent's (D138 step 5): the agent's reader context, as its launch
    * named it, is kept for the session (agent-session-contexts.json, read by `harness.v1.agents.session`), so its Teams
-   * verbs run as that agent. A launch that named none gets one delegated here through `delegator`, the context of the
-   * person this machine is connected as, who manages the agent; a machine connected on its machine credential alone
-   * keeps the session without one.
+   * verbs run as that agent. Missing or expired readers are delegated through the connected person's context, which
+   * manages the agent. A machine connected on its machine credential alone keeps the session without one.
    */
   async bindAgentSession({session,agent,org,context=null,assignments=[]},{delegator=null}={}){
-    if(!context&&delegator){
-      const selected=fromContext({supercodeHome:supercodeHome(this.env),name:delegator}),signal=AbortSignal.timeout(20000);
-      const team=selected.client.team(selected.context.team_id),identity=(await team.agents.get(agent,{signal})).data;
-      if(identity.state!=='ended'){
-        const reader=await team.agents.delegateReader(identity.id,{expires_in_ms:86400000},{signal,ifMatch:identity.revision});
-        context=(await this.#installAgentContext({origin:selected.context.origin,team:selected.context.team_id,agent:identity.id,credential:reader.data})).context;
-      }
-      org??=selected.context.team_id;
-    }
+    const previous=readJson(join(this.home,'agent-session-contexts.json'),{sessions:{}}).sessions[session];
+    if(previous&&(previous.agent!==agent||(org&&previous.org!==org)))
+      throw Object.assign(new Error('a recorded session cannot change agent or Org'),{code:403});
+    context??=previous?.context;
+    org??=previous?.org;
+    ({context,org}=await this.#agentReader({agent,org,context},delegator));
     const file=join(this.home,'agent-session-contexts.json'),record=readJson(file,{version:1,sessions:{}});
     record.sessions[session]={context,agent,org,assignments};
     const temporary=`${file}.${randomBytes(12).toString('hex')}.tmp`;
@@ -3390,7 +3417,10 @@ export class TeamsMachine extends MachineCore {
       case 'harness.v1.agents.session': {
         if(!operator)throw Object.assign(new Error('local agent session lookup requires operator authority'),{code:403});
         if(typeof params.session!=='string')throw Object.assign(new Error('name a native session'),{code:400});
-        return readJson(join(this.home,'agent-session-contexts.json'),{sessions:{}}).sessions[params.session]??null;
+        const binding=readJson(join(this.home,'agent-session-contexts.json'),{sessions:{}}).sessions[params.session]
+          ??this.agentSessionIntent?.(params.session);
+        if(!binding)return null;
+        return this.bindAgentSession({session:params.session,...binding},{delegator:this.agentDelegator??null});
       }
       case 'harness.v1.agents.closureReceipt': {
         if(!operator)throw Object.assign(new Error('native closure receipts require operator authority'),{code:403});

package/mail/transcript.mjs

@@ -1,17 +1,48 @@
 // What a session's transcript says about its mail (crates/harness/src/mail_transcript.rs, ported line for line): the
 // lines its own user typed, the lines it took from its harness's own channels, its answers, and when each filed message
-// first reached the model. The mailbox records a message as sent; only the transcript records it delivered. A transcript
-// is read only when a call names the message or the session it is about (one named read, never a sweep).
+// first reached the model. The mailbox records a message as sent; only the transcript records it delivered. Named mail
+// reads use this reader; agent upkeep also reads changed Claude transcripts to copy the person's typed lines.
 import { readdirSync, statSync } from 'node:fs';
-import { readFile } from 'node:fs/promises';
+import { open } from 'node:fs/promises';
 import { join } from 'node:path';
 import { blake3Hex } from './envelope.mjs';
 
-// A transcript is read off the daemon's event loop (its file read awaited) and parsed in turns of YIELD_LINES lines: one
-// large session's history never holds every other door while it is read.
+// Read one native record at a time. Reading the whole file and splitting it before the first yield retained every
+// tool result while parsing unrelated mail. The read buffer is bounded; one record and the returned mail remain.
+const READ_BYTES = 64 * 1024;
 const YIELD_LINES = 2000;
 const yieldTurn = () => new Promise((resolve) => setImmediate(resolve));
 
+async function* transcriptLines(path) {
+  const file = await open(path, 'r');
+  try {
+    // This pass reads the opened file's initial extent; an appended turn belongs to the next pass.
+    const { size } = await file.stat();
+    let position = 0, fragments = [];
+    while (position < size) {
+      const buffer = Buffer.allocUnsafe(Math.min(READ_BYTES, size - position));
+      const { bytesRead } = await file.read(buffer, 0, buffer.length, position);
+      if (!bytesRead) break;
+      position += bytesRead;
+      const chunk = buffer.subarray(0, bytesRead);
+      let start = 0;
+      for (let end = chunk.indexOf(10); end !== -1; end = chunk.indexOf(10, start)) {
+        const line = fragments.length
+          ? Buffer.concat([...fragments, chunk.subarray(start, end)]).toString('utf8')
+          : chunk.toString('utf8', start, end);
+        fragments = [];
+        start = end + 1;
+        yield line;
+      }
+      if (start < bytesRead) fragments.push(chunk.subarray(start));
+      // Yield even across a long record or many ignored lines, before another read/parse block.
+      await yieldTurn();
+    }
+    // Preserve the former split's final non-newline record, including its JSON-parse refusal if incomplete.
+    if (fragments.length) yield Buffer.concat(fragments).toString('utf8');
+  } finally { await file.close(); }
+}
+
 export const TYPED_ID_PREFIX = 'u-';
 const CHANNEL_ID_PREFIX = 'c-';
 const ANSWER_ID_PREFIX = 'a-';
@@ -88,10 +119,9 @@ export async function readClaude(path) {
   const takenIn = new Map(); // words → [times]
   const early = []; // [words, ids, index, at]
   const deliver = (id, at) => { if (!mail.delivered.has(id)) mail.delivered.set(id, at); };
-  const lines = (await readFile(path, 'utf8')).split('\n');
-  for (let index = 0; index < lines.length; index++) {
-    if (index && index % YIELD_LINES === 0) await yieldTurn();
-    const line = lines[index];
+  let lineIndex = 0;
+  for await (const line of transcriptLines(path)) {
+    if (++lineIndex % YIELD_LINES === 0) await yieldTurn();
     const prompt = line.includes('"promptSource"') || line.includes('"type":"user"');
     const queue = line.includes('"queue-operation"');
     const attachment = line.includes('"queued_command"');
@@ -214,10 +244,9 @@ function codexRenderedMailIds(line) {
 /** Final answers and delivered mail from a Codex session's own transcript (`read_codex_answers`). */
 export async function readCodex(path) {
   const mail = { typed: [], answers: [], channel: [], delivered: new Map() };
-  const lines = (await readFile(path, 'utf8')).split('\n');
-  for (let index = 0; index < lines.length; index++) {
-    if (index && index % YIELD_LINES === 0) await yieldTurn();
-    const line = lines[index];
+  let lineIndex = 0;
+  for await (const line of transcriptLines(path)) {
+    if (++lineIndex % YIELD_LINES === 0) await yieldTurn();
     const rendered = line.includes('cross-session-message id=');
     if (!rendered && !line.includes('"final_answer"')) continue;
     let record; try { record = JSON.parse(line); } catch { continue; }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@volter/supercode-teams",
-  "version": "0.3.154",
+  "version": "0.3.156",
   "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",