@volter/supercode-teams 0.3.87 → 0.3.88

package/live-sessions.mjs

@@ -453,7 +453,13 @@ export class LiveSessions extends EventEmitter {
   }
 
   /** The session a client runs in, from its claim: its parent's current session, else its environment's id through the map. */
-  #sessionOfClaim({ pid, ppid, session }) {
+  #sessionOfClaim({ pid, ppid, session, runtime }) {
+    // a runtime supercode hosts (the native agent) says so in its claim: it is named by its own process first, never by
+    // the session whose shell started it; one with no receipt is named by the rest of its claim, as any client is
+    if (runtime === true) {
+      const own = this.#runtimeOfPid(Number(pid));
+      if (own) return own;
+    }
     const parent = this.claude.get(Number(ppid));
     if (parent && alive(parent.pid)) return this.#address('claude-code', parent.sessionId);
     if (typeof session === 'string' && session) {
@@ -465,14 +471,20 @@ export class LiveSessions extends EventEmitter {
     // only when exactly one live runtime's receipt names that process. A process several receipts name (harness serve
     // records its own pid on each runtime it hosts with no child of its own) is no one runtime, and is refused.
     for (const candidate of [Number(pid), Number(ppid)]) {
-      if (!Number.isInteger(candidate) || candidate <= 0) continue;
-      const held = [...this.runtimes.values()].filter((runtime) => runtime.pid === candidate && alive(runtime.pid));
-      if (held.length === 1) return this.#address(held[0].harness, held[0].sessionId);
-      if (held.length > 1) throw new CallerRefused(`process ${candidate} hosts ${held.length} runtimes, so which one is calling is not known; nothing was done`);
+      const found = this.#runtimeOfPid(candidate);
+      if (found) return found;
     }
     return null;
   }
 
+  /** The runtime whose live receipt alone names process `pid`, or null; several receipts naming it are no one runtime, refused. */
+  #runtimeOfPid(pid) {
+    if (!Number.isInteger(pid) || pid <= 0) return null;
+    const held = [...this.runtimes.values()].filter((runtime) => runtime.pid === pid && alive(runtime.pid));
+    if (held.length > 1) throw new CallerRefused(`process ${pid} hosts ${held.length} runtimes, so which one is calling is not known; nothing was done`);
+    return held.length === 1 ? this.#address(held[0].harness, held[0].sessionId) : null;
+  }
+
   /**
    * Who a local client is, from its claim `{pid, ppid, session, named}` (docs/architecture/overview.md, "Who is
    * calling"): a session's address, a board's address, or null for a person. Throws CallerRefused when the claim names

package/machine.mjs

@@ -649,7 +649,9 @@ export class TeamsMachine extends MachineCore {
       deliverRuntime: deliverToRuntime, codexAnswer: (request) => codexQuestions(request) });
     // an agent's verbs (3b-2): its threads, a delegation, its record
     this.agentVerbs = new AgentVerbs({ machine, store: this.mailStore, agents: this.agents, live, supercodeBin: this.supercodeBin, env: this.env,
-      paneOf: (session) => this.mail.paneOf(session), mailRoot });
+      paneOf: (session) => this.mail.paneOf(session), mailRoot,
+      // a delegation's pane that never became its holder is closed, as `panes.close` closes one
+      closePane: async (pane) => { const session = await this.#paneByContext(pane); if (session) { await this.host.closeSession(session.id); this.#panesChanged(); } } });
     // the names sessions ran under (`<mail>/names.json`): a name an agent was given reaches the same session after it
     // runs under another, kept from the map's changes (at most once a second)
     let naming = null;

package/mail/agents.mjs

@@ -12,6 +12,8 @@ import { cameThroughLink, parseAddress, threadOf } from './compose.mjs';
 
 /** The pseudo-harness of an agent address. */
 export const AGENT_HARNESS = 'agent';
+/** How recent a folder time is not trusted to say its folder is unchanged (a coarse clock's tick, a 1 s filesystem). */
+const RACY_MS = 2000;
 /** How long a send waits for a resumed session to be reachable again. */
 export const RESUME_WAIT_MS = 45_000;
 
@@ -63,34 +65,47 @@ export class Agents {
   thread(id) { return validName(id) ? readJson(join(this.threadsDir, `${id}.json`)) : null; }
 
   /** Every thread, oldest first. */
-  threads() {
-    // Read once and kept while the folder is unchanged: every writer (this daemon, and mail_agent.rs's in the native
-    // watch until step 4) renames a whole record into it, which moves the folder's time. One stat a call, not a read of
-    // every record: a send's plan asks this on every send, and an agent's threads grow with its history.
+  threads() { return this.#records().list.map((thread) => structuredClone(thread)); }
+
+  /**
+   * The thread records, read once and kept while their folder is unchanged, with an index of them by holder and by
+   * channel marker. Every writer (this daemon, and mail_agent.rs's in the native watch until step 4) renames a whole
+   * record into the folder, which moves its time: one stat a call, never a read of every record, though a send's plan
+   * asks on every send and an agent's threads grow with its history. A folder time within RACY_MS of now is not trusted
+   * (a write in the same tick of a coarse clock leaves it unmoved): read again, and not kept, until it is older.
+   */
+  #records() {
     let changed;
-    try { changed = statSync(this.threadsDir).mtimeMs; } catch { return []; }
-    if (this.threadsCache?.changed === changed) return this.threadsCache.list.map((thread) => structuredClone(thread));
+    try { changed = statSync(this.threadsDir).mtimeMs; } catch { return { list: [], byHolder: new Map(), byMarker: new Map() }; }
+    if (this.threadsCache?.changed === changed && Date.now() - changed > RACY_MS) return this.threadsCache;
     let names = [];
-    try { names = readdirSync(this.threadsDir); } catch { return []; }
+    try { names = readdirSync(this.threadsDir); } catch { return { list: [], byHolder: new Map(), byMarker: new Map() }; }
     const list = names.filter((name) => name.endsWith('.json')).map((name) => readJson(join(this.threadsDir, name))).filter((thread) => thread?.id)
       .sort((a, b) => (a.created_at_ms - b.created_at_ms) || (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
-    this.threadsCache = { changed, list };
-    return list.map((thread) => structuredClone(thread));
+    const byHolder = new Map(), byMarker = new Map();
+    for (const thread of list) {
+      byHolder.set(thread.holder, [...(byHolder.get(thread.holder) ?? []), thread]);
+      for (const [marker, id] of Object.entries(thread.markers ?? {})) if (!byMarker.has(marker)) byMarker.set(marker, { thread, id });
+    }
+    const records = { changed, list, byHolder, byMarker };
+    if (Date.now() - changed > RACY_MS) this.threadsCache = records;
+    return records;
   }
 
   /** The thread `address` holds for an agent other than as its main session (mail_agent.rs `thread_held_by`). */
   heldBy(address) {
-    return this.threads().reverse().find((thread) => {
-      if (thread.holder !== address || thread.parent != null) return false;
+    const held = [...(this.#records().byHolder.get(address) ?? [])].reverse().find((thread) => {
+      if (thread.parent != null) return false;
       const agent = this.load(thread.agent);
       return agent != null && agent.main_session !== address;
-    }) ?? null;
+    });
+    return held ? structuredClone(held) : null;
   }
 
   /** The thread whose channel message has the platform id `marker`, with that message's id. */
   ofMarker(marker) {
-    for (const thread of this.threads()) if (thread.markers?.[marker]) return { thread, id: thread.markers[marker] };
-    return null;
+    const found = this.#records().byMarker.get(marker);
+    return found ? { thread: structuredClone(found.thread), id: found.id } : null;
   }
 
   /** The agent `address` is a session of: its main, or a thread's holder. */
@@ -163,7 +178,7 @@ export class Agents {
   }
 
   /** The threads of the agent `name`, oldest first. */
-  threadsOf(name) { return this.threads().filter((thread) => thread.agent === name); }
+  threadsOf(name) { return this.#records().list.filter((thread) => thread.agent === name).map((thread) => structuredClone(thread)); }
 
   /**
    * A line that reached an agent's main session through its own input (its terminal, its DM) is a root of the agent:

package/mail/store.mjs

@@ -124,7 +124,9 @@ export class MailStore extends EventEmitter {
     if (!envelope || typeof envelope.id !== 'string') { box.skipped.add(`${part}/${file}`); return; }
     // its body's first line is kept beside the header (never in it): a listing of threads names each root by it with no
     // body read
-    const firstLine = typeof envelope.body === 'string' ? envelope.body.slice(0, 400).split('\n')[0] : '';
+    // the line whole, then capped by characters (a surrogate pair is never split), never a slice of the body first
+    const end = typeof envelope.body === 'string' ? envelope.body.indexOf('\n') : -1;
+    const firstLine = typeof envelope.body === 'string' ? Array.from(end < 0 ? envelope.body : envelope.body.slice(0, end)).slice(0, 400).join('') : '';
     box.files.set(`${part}/${file}`, { header: headerOf(envelope), state: STATES[part], path, part, firstLine });
   }
 

package/mail/verbs.mjs

@@ -19,8 +19,8 @@ export class AgentVerbs {
   /** `machine` this machine's name; `store` the mail store; `agents` an agent's records; `live` the live-session map;
    *  `supercodeBin` the native binary (`supercode open` starts a session in a pane); `paneOf(session)` the daemon pane a
    *  live session runs in; `mailRoot` the mail folder. */
-  constructor({ machine, store, agents, live, supercodeBin, env = process.env, paneOf, mailRoot }) {
-    Object.assign(this, { machine, store, agents, live, supercodeBin, env, paneOf, mailRoot });
+  constructor({ machine, store, agents, live, supercodeBin, env = process.env, paneOf, mailRoot, closePane = async () => {} }) {
+    Object.assign(this, { machine, store, agents, live, supercodeBin, env, paneOf, mailRoot, closePane });
   }
 
   #whole(stored) { const envelope = this.store.body(stored); return envelope ? { ...stored, envelope } : null; }
@@ -126,17 +126,24 @@ export class AgentVerbs {
       child.on('close', (code) => resolve({ code, out, err }));
     });
     if (run.code !== 0) throw new Error(`the session did not start: ${run.err.trim()}`);
-    if (known) return known;
     let pane = null;
     try { pane = JSON.parse(run.out).pane; } catch { /* not reported */ }
+    if (known) return known;
     if (typeof pane !== 'string') throw new Error('the new pane was not reported');
-    const started = Date.now();
-    while (Date.now() - started < 60_000) {
-      const session = this.live.sessions().find((row) => this.paneOf(row) === pane);
-      if (session) { await ready(session.address); return session.address; }
-      await sleep(500);
+    // a launch that fails once its pane is open closes that pane: nothing it started is left running, holding what was
+    // copied to it, after its thread goes back
+    try {
+      const started = Date.now();
+      while (Date.now() - started < 60_000) {
+        const session = this.live.sessions().find((row) => this.paneOf(row) === pane);
+        if (session) { await ready(session.address); return session.address; }
+        await sleep(500);
+      }
+      throw new Error(`${program} started in pane ${pane}, but no session appeared there within a minute; its pane is closed`);
+    } catch (error) {
+      try { await this.closePane(pane); } catch (closing) { error.message += ` (its pane ${pane} could not be closed: ${closing.message})`; }
+      throw error;
     }
-    throw new Error(`${program} started in pane ${pane}, but no session appeared there within a minute`);
   }
 
   /**

package/package.json

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