@volter/supercode-teams 0.2.39 → 0.2.41

package/connector/index.mjs

@@ -137,6 +137,8 @@ export class TeamsConnector {
           bindings: [...this.nativeEffects.published(), ...await bindings()],
           roots: this.localRoots.map(({id,machine_id,name,harnesses})=>({id,machine_id,name,harnesses})),
           ...(this.hostKeyId ? { host_key_id: this.hostKeyId } : {}),
+          // What each synced session's harness is doing (its turn: working, idle, …), from the last discovery.
+          ...(this.reportedActivity ? { activity: this.reportedActivity } : {}),
         });
         this.save();
       });
@@ -204,7 +206,8 @@ export class TeamsConnector {
     // A rule covers its root folder and every folder under it. Core discovery filters that subtree before it
     // reads any session's tail, so a beat costs one bounded scan per root, not one over every session on the
     // machine; rules over the same root and harnesses share the scan.
-    const discoveries=new Map(),followCandidates=[],discovered=new Set();
+    const discoveries=new Map(),followCandidates=[],discovered=new Set(),activity=[];
+    this.turnStates??=new Map();
     for(const rule of activeRules.values()){
       const root=roots.find(item=>item.id===rule.selector.root_id);
       if(!root)continue;
@@ -225,6 +228,9 @@ export class TeamsConnector {
         const locator=descriptor.locator,nativeSessionId=locator?.session_id,harness=locator?.harness;
         if(!locator||!nativeSessionId||!harness)continue;
         discovered.add(`${harness}:${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 options={locator,descriptor,harness,nativeSessionId,ruleId:rule.id,ruleRevision:rule.revision,backfill:rule.backfill,rootPath:workspace,configuration};
         // A session whose native store has not changed since this rule last captured it is not reloaded.
         // One session that cannot be captured (a transcript that rewrote its history needs an explicit resync)
@@ -243,6 +249,8 @@ export class TeamsConnector {
       }
     }
     this.nativeEffects.endDiscovery();
+    for(const key of this.turnStates.keys())if(!discovered.has(key))this.turnStates.delete(key);
+    this.reportedActivity=activity;
     this.pruneNativeCache(discovered);
     this.rotateFollowers(followCandidates);
   }
@@ -415,10 +423,13 @@ export class TeamsConnector {
     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]&&hash(canonicalJson(message.value))===previous.observed_digests?.[index]);
     if(unchanged&&!retryNative){this.recordStamp(key,ruleId,ruleRevision,backfillPolicy.mode,stamp);return null;}
     let effectivePrevious=previous;const clearBaseline=backfillPolicy.mode==='all';
-    if(!previous&&backfillPolicy.mode==='none'){const toolTail=trailingToolResults(messages);this.state.origins[key]={generation:1,sequence:0,digest:null,baseline:messages.map(x=>x.native_key),baseline_digests:messages.map(x=>hash(canonicalJson(x.value))),...(toolTail?{baseline_tool_tail:toolTail}:{}),observed_keys:messages.map(x=>x.native_key),observed_digests:messages.map(x=>hash(canonicalJson(x.value))),last_rule_revision:ruleRevision,backfill_mode:backfillPolicy.mode};this.recordStamp(key,ruleId,ruleRevision,backfillPolicy.mode,stamp);return null;}
-    if(!previous&&backfillPolicy.mode==='since'){
-      if(!Number.isSafeInteger(backfillPolicy.since))throw Object.assign(new Error('since backfill requires an integer timestamp'),{code:'invalid_request'});
-      const excluded=messages.filter(message=>message.recorded_at==null||message.recorded_at<backfillPolicy.since);
+    // 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.
+    const keptBefore=backfillPolicy.mode==='since'?backfillPolicy.since:backfillPolicy.mode==='none'&&Number.isSafeInteger(rule.capture_after)?rule.capture_after:null;
+    if(!previous&&backfillPolicy.mode==='none'&&keptBefore===null){const toolTail=trailingToolResults(messages);this.state.origins[key]={generation:1,sequence:0,digest:null,baseline:messages.map(x=>x.native_key),baseline_digests:messages.map(x=>hash(canonicalJson(x.value))),...(toolTail?{baseline_tool_tail:toolTail}:{}),observed_keys:messages.map(x=>x.native_key),observed_digests:messages.map(x=>hash(canonicalJson(x.value))),last_rule_revision:ruleRevision,backfill_mode:backfillPolicy.mode};this.recordStamp(key,ruleId,ruleRevision,backfillPolicy.mode,stamp);return null;}
+    if(!previous&&(backfillPolicy.mode==='since'||backfillPolicy.mode==='none')){
+      if(!Number.isSafeInteger(keptBefore))throw Object.assign(new Error('since backfill requires an integer timestamp'),{code:'invalid_request'});
+      const excluded=messages.filter(message=>message.recorded_at==null||message.recorded_at<keptBefore);
       effectivePrevious={generation:1,sequence:0,digest:null,baseline:excluded.map(message=>message.native_key),baseline_digests:excluded.map(message=>hash(canonicalJson(message.value)))};
       this.state.origins[key]=effectivePrevious;
     }
@@ -435,8 +446,8 @@ export class TeamsConnector {
       // A rule that started mid tool call kept back the core's placeholder result; the real result replaces it.
       const settled=baselineMoved&&backfillPolicy.mode==='none'?settledToolTail(effectivePrevious,messages):null;
       if(settled){baselineMoved=false;effectivePrevious={...effectivePrevious,baseline_digests:settled};this.state.origins[key]={...this.state.origins[key],baseline_digests:settled};this.save();}
-      if(baselineMoved&&backfillPolicy.mode==='since'&&Number.isSafeInteger(backfillPolicy.since)){
-        const excluded=messages.filter(message=>message.recorded_at==null||message.recorded_at<backfillPolicy.since);
+      if(baselineMoved&&Number.isSafeInteger(keptBefore)){
+        const excluded=messages.filter(message=>message.recorded_at==null||message.recorded_at<keptBefore);
         effectivePrevious={...effectivePrevious,baseline:excluded.map(message=>message.native_key),baseline_digests:excluded.map(message=>hash(canonicalJson(message.value)))};
         // A tool tail recorded for the old baseline describes positions that no longer hold; it goes with it.
         delete effectivePrevious.baseline_tool_tail;

package/machine.mjs

@@ -419,19 +419,24 @@ export class TeamsMachine extends MachineCore {
       return refuse(`no interact grant for ${target}`);
     }
     accept();
-    const child = spawn(this.supercodeBin, ['message', 'remote-deliver'], { stdio: ['pipe', 'pipe', 'pipe'], env: this.env });
-    let out = '';
-    let err = '';
-    child.stdout.on('data', (chunk) => { out += chunk; });
-    child.stderr.on('data', (chunk) => { err += chunk; });
-    child.on('error', (error) => { err += error.message; });
-    child.on('close', (code) => {
-      this.log.append({ principal, cap: 'interact', target, outcome: code === 0 ? 'turn' : 'failed', detail: err.trim().slice(0, 200) || undefined });
-      if (stream.closed) return;
-      stream.write(out.trim() || JSON.stringify({ code: 1, text: err.trim() || `remote-deliver exited ${code}` }));
-      stream.close('delivered');
+    // The user-turn door every supercode has (harness.v1 sessions.message, as_user): the session's runtime input,
+    // its pane's empty composer, or its mailbox until the composer is free. The sender is named after the member.
+    const answer = (value) => { if (!stream.closed) { stream.write(JSON.stringify(value)); stream.close('delivered'); } };
+    this.#serveRequest('harness.v1.sessions.message', {
+      locator: { harness, session_id: session, storage: { kind: 'file', path: '' } },
+      text: request.text,
+      from_name: entry.name ?? principal ?? 'a Room member',
+      as_user: true,
+    }, 15_000).then((result) => {
+      const delivered = result?.message_id && !result.refusal;
+      this.log.append({ principal, cap: 'interact', target, outcome: delivered ? 'turn' : 'failed', detail: result?.refusal?.message?.slice(0, 200) });
+      answer(delivered
+        ? { code: 0, turn_id: result.message_id, door: result.delivery?.how === 'waiting' ? 'waiting' : (result.delivery?.door ?? 'pane') }
+        : { code: 1, text: result?.refusal?.message ?? 'the session did not take the turn' });
+    }, (error) => {
+      this.log.append({ principal, cap: 'interact', target, outcome: 'failed', detail: error.message.slice(0, 200) });
+      answer({ code: 1, text: error.message });
     });
-    child.stdin.end(JSON.stringify({ op: 'turn', harness, session, text: request.text, from_name: entry.name ?? principal ?? 'a Room member', via: 'room' }));
   }
 
   // ---- terminal ------------------------------------------------------------

package/package.json

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