@volter/supercode-teams 0.3.154 → 0.3.155

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).
 

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/package.json

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