@volter/supercode-teams 0.3.12 → 0.3.14

package/bin/teams.mjs

@@ -72,7 +72,9 @@ const [verb, sub, ...rest] = positional;
 // Each command is timed (the slow log, @volter/supercode-harness-sdk/slow-log); a service, a watch or a forward runs
 // until stopped and is timed one door at a time instead.
 const LONG_RUNNING = new Set(['connect', 'watch', 'port', 'stream', 'attach', 'serve']);
-if (!LONG_RUNNING.has(verb) && !(verb === 'machine' && sub === 'start') && !(verb === 'message' && sub === 'watch')) timeCommand(`teams ${[verb, sub].filter(Boolean).join(' ')}`, argv);
+// A service runs this entry as `teams.mjs teams connect`: the leading `teams` is the entry's own name, not a verb.
+const [timedVerb, timedSub] = verb === 'teams' ? [sub, rest[0]] : [verb, sub];
+if (!LONG_RUNNING.has(timedVerb) && !(timedVerb === 'machine' && timedSub === 'start') && !(timedVerb === 'message' && timedSub === 'watch')) timeCommand(`teams ${[timedVerb, timedSub].filter(Boolean).join(' ')}`, argv);
 
 const MACHINE_HELP = 'machine verbs: machine start|status|restart, slow [--since 1h], describe, panes, input, suspend, resume, files, ports, port, stream, jobs, workspace, title, attention, watch, rpc, launches, log, health, browser (add --machine NAME for an enrolled machine)';
 

package/connector/index.mjs

@@ -6,6 +6,10 @@ import { EffectConsumer } from './effects.mjs';
 import { NativeEffects } from './native-effects.mjs';
 import { consumeAgentClosures } from './agent-closures.mjs';
 
+/** How often a sync pass reads a root's whole session catalog; between, it reads only what changed. */
+const FULL_DISCOVERY_MS = 120_000;
+/** How far back a changed-only read reaches past the last read: clock skew and writes landing out of order. */
+const CATALOG_MARGIN_MS = 30_000;
 const SYNC_PROBLEM_LIMIT=20;
 // Live follows are bounded. The harness SDK lets at most 64 subscription opens await replies at once (sdk/typescript
 // core.mjs MAX_PENDING_RUNTIME_OPENS; more reject with SUBSCRIPTION_OPEN_CAPACITY) and every live follow is a follower
@@ -194,7 +198,7 @@ export class TeamsConnector {
     this.activityBindings=new Map();
     this.activityEvent=event=>{
       if(event.subscription!==this.activitySubscription)return;
-      for(const activity of event.activities??[])this.recordActivityBinding(activity);
+      for(const activity of event.activities??[]){this.recordActivityBinding(activity);this.recordTurn(activity);}
       this.publishActivityHeartbeat();
     };
     this.core.on?.('sessionActivityEvent',this.activityEvent);
@@ -270,27 +274,20 @@ export class TeamsConnector {
       const root=roots.find(item=>item.id===rule.selector.root_id);
       if(!root)continue;
       const workspace=root.path??root.workspace,subtree=!root.exact_only,discoveryKey=JSON.stringify([workspace,subtree,[...(rule.selector.harnesses??[])].sort(),root.homes??null]);
-      if(!discoveries.has(discoveryKey))discoveries.set(discoveryKey,(async()=>{
-        const descriptors=[];
-        let cursor;
-        do {
-          // A broad root enrolled before rules covered subfolders keeps its exact-folder discovery.
-          const page=await this.core.discover({workspace,...(subtree?{workspace_subtree:true}:{}),harnesses:rule.selector.harnesses,homes:root.homes,limit:2048,...(cursor?{cursor}:{})});
-          descriptors.push(...(page.sessions??page.entries??[]));
-          cursor=page.next_cursor??page.nextCursor??null;
-        } while(cursor);
-        return descriptors;
-      })());
-      const descriptors=await discoveries.get(discoveryKey);
+      if(!discoveries.has(discoveryKey))discoveries.set(discoveryKey,this.catalogOf(discoveryKey,{workspace,...(subtree?{workspace_subtree:true}:{}),harnesses:rule.selector.harnesses,homes:root.homes}));
+      const {descriptors,fresh}=await discoveries.get(discoveryKey);
       for(const descriptor of descriptors){
         const locator=descriptor.locator,nativeSessionId=locator?.session_id,harness=locator?.harness;
         if(!locator||!nativeSessionId||!harness)continue;
         discovered.add(`${harness}:${nativeSessionId}`);
         activityLocators.set(`${harness}:${nativeSessionId}`,locator);
-        if(descriptor.activity)this.recordActivityBinding({...descriptor.activity,harness,session_id:nativeSessionId});
+        // A descriptor this pass did not read again carries the activity of the pass that did: the activity
+        // subscription keeps the bindings current, and only a fresh read may change them here.
+        const key=`${harness}:${nativeSessionId}`,isFresh=fresh.has(key);
+        if(descriptor.activity&&isFresh)this.recordActivityBinding({...descriptor.activity,harness,session_id:nativeSessionId});
         // A session's turn state as its harness reports it, and since when this connector has seen it so.
-        const turn=descriptor.activity?.turn;
-        if(typeof turn==='string'&&turn&&activity.length<4096){const key=`${harness}:${nativeSessionId}`,held=this.turnStates.get(key),since=held?.turn===turn?held.since:this.clock.nowMs();this.turnStates.set(key,{turn,since});activity.push({harness,native_id:nativeSessionId,turn,since});}
+        const held=this.turnStates.get(key),turn=isFresh?descriptor.activity?.turn:held?.turn;
+        if(typeof turn==='string'&&turn&&activity.length<4096){const since=held?.turn===turn?held.since:this.clock.nowMs();this.turnStates.set(key,{turn,since});activity.push({harness,native_id:nativeSessionId,turn,since});}
         const options={locator,descriptor,harness,nativeSessionId,ruleId:rule.id,ruleRevision:rule.revision,backfill:rule.backfill,rootPath:workspace,configuration};
         if(locator.storage?.kind==='file')this.liveFiles.set(`${harness}:${nativeSessionId}`,options);
         // A session whose native store has not changed since this rule last captured it is not reloaded.
@@ -322,6 +319,50 @@ export class TeamsConnector {
     this.pruneNativeCache(discovered);
     this.rotateFollowers(followCandidates);
   }
+  /**
+   * A root's session catalog for this pass. Every FULL_DISCOVERY_MS the whole catalog is read again (what catches a
+   * session that went away); between, only sessions updated since the last read (with a margin for clock and write
+   * order) are read and merged into the held catalog. A full read every 15 s was two to three 2,048-row pages, each a
+   * full scan in the harness and 8 MB parsed on this daemon's thread, and it kept every door waiting (t_23e47b73).
+   * Answers { descriptors, fresh }: the catalog, and the keys this pass read.
+   */
+  async catalogOf(discoveryKey,query){
+    // Between full reads a held session's turn comes from the activity subscription (recordTurn), not from this read.
+    this.catalogs??=new Map();
+    const now=this.clock.nowMs(),held=this.catalogs.get(discoveryKey),full=!held||now-held.fullAt>=FULL_DISCOVERY_MS;
+    const read=[];
+    let cursor;
+    do {
+      // A broad root enrolled before rules covered subfolders keeps its exact-folder discovery.
+      const page=await this.core.discover({...query,limit:2048,...(full?{}:{updated_after_ms:Math.max(0,held.readAt-CATALOG_MARGIN_MS)}),...(cursor?{cursor}:{})});
+      read.push(...(page.sessions??page.entries??[]));
+      cursor=page.next_cursor??page.nextCursor??null;
+    } while(cursor);
+    const keyOf=descriptor=>descriptor.locator?`${descriptor.locator.harness}:${descriptor.locator.session_id}`:null;
+    const catalog=full?new Map():held.catalog;
+    const fresh=new Set();
+    for(const descriptor of read){const key=keyOf(descriptor);if(!key)continue;catalog.set(key,descriptor);fresh.add(key);}
+    this.catalogs.set(discoveryKey,{catalog,readAt:now,fullAt:full?now:held.fullAt});
+    // The held catalog keeps discovery's order: the most recently updated first.
+    const descriptors=[...catalog.values()].sort((a,b)=>(b.updated_at_ms??0)-(a.updated_at_ms??0));
+    return {descriptors,fresh};
+  }
+  /**
+   * A session's turn as its activity subscription reports a change: what keeps the turn current between full reads,
+   * for the changes a session's transcript never shows (an approval prompt, the process exiting). The report the
+   * heartbeat publishes follows it at once.
+   */
+  recordTurn(activity){
+    const turn=activity?.turn;
+    if(!activity?.harness||!activity.session_id||typeof turn!=='string'||!turn)return;
+    this.turnStates??=new Map();
+    const key=`${activity.harness}:${activity.session_id}`,held=this.turnStates.get(key);
+    if(held?.turn===turn)return;
+    const since=this.clock.nowMs();
+    this.turnStates.set(key,{turn,since});
+    const reported=this.reportedActivity?.find(row=>row.harness===activity.harness&&row.native_id===activity.session_id);
+    if(reported){reported.turn=turn;reported.since=since;}
+  }
   recordActivityBinding(activity){
     if(!activity?.harness||!activity.session_id)return;
     const key=`${activity.harness}:${activity.session_id}`,id=`activity_${hash(`${this.machineId}:${this.state.incarnation_id}:${key}`).slice(0,32)}`;
@@ -338,7 +379,7 @@ export class TeamsConnector {
     if(fingerprint===this.activityFingerprint)return;
     const opened=await this.core.subscribeSessionActivity(locators),previous=this.activitySubscription;
     this.activitySubscription=opened.subscription;this.activityFingerprint=fingerprint;
-    for(const activity of opened.initial??[])this.recordActivityBinding(activity);
+    for(const activity of opened.initial??[]){this.recordActivityBinding(activity);this.recordTurn(activity);}
     if(previous)await this.core.unsubscribeSessionActivity(previous);
   }
   captureViewedFiles(){

package/package.json

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