@volter/supercode-teams 0.3.114 → 0.3.116

package/machine.mjs

@@ -126,6 +126,13 @@ export function claudeUsageLimitWait(screen) {
 /** The settle floor for a pane whose kind has no composer pattern: the screen
  *  must have stopped changing for this long before the pane counts as ready. */
 const INITIAL_INPUT_SETTLE_MS = 1_000;
+/** A Windows Codex's typed first input waits, before pasting, for an empty composer on a screen unchanged this long
+ *  (CODEX_PASTE_SETTLE_DEADLINE_MS at most); gives the paste CODEX_PASTE_SHOWN_MS to show, and watches
+ *  CODEX_PASTE_LATE_MS more to clear one shown after that. */
+const CODEX_PASTE_SETTLE_MS = 1_500;
+const CODEX_PASTE_SETTLE_DEADLINE_MS = 30_000;
+const CODEX_PASTE_SHOWN_MS = 5_000;
+const CODEX_PASTE_LATE_MS = 15_000;
 
 /**
  * Claude asks whether to trust a folder it has not opened before, whatever its permission mode, and has no flag that
@@ -500,6 +507,17 @@ export class TeamsMachine extends MachineCore {
     // Set by a service-run connector: how `machine.restart` ends this daemon so its service manager starts it again.
     this.restartHandler = null;
     this.launches = new Launches(this.p.launches);
+    // The release this daemon runs, in its machine record (`supercode teams machine status`): its Teams package and its
+    // native. A daemon an upgrade did not restart runs the release it started with, whatever is installed, and a
+    // client a release behind or ahead of it is refused, so status says which it is (2026-10-06: version skew between
+    // daemons and their installs behind much of the day's trouble).
+    this.once('listening', () => {
+      try {
+        const record = readJson(this.p.machine, null);
+        if (record?.pid !== process.pid) return;
+        writeJson(this.p.machine, { ...record, release: this.#release() });
+      } catch { /* its record says no release */ }
+    });
     // the panes' stable porthole hook and the machine's stable supercode brought up to this release's at start, under
     // every pane already running
     this.#portholeHook();
@@ -1805,6 +1823,17 @@ export class TeamsMachine extends MachineCore {
     return this.stableSupercodePath ?? this.supercodeBin;
   }
 
+  /** This daemon's release: its Teams package's version, and its native's (`--version`), as it started. */
+  #release() {
+    let teams = null, native = null;
+    try { teams = JSON.parse(readFileSync(new URL('./package.json', import.meta.url), 'utf8')).version ?? null; } catch { /* unread */ }
+    try {
+      const answer = spawnSync(this.supercodeBin, ['--version'], { env: this.env, encoding: 'utf8', timeout: 5000, stdio: ['ignore', 'pipe', 'ignore'] });
+      native = answer.status === 0 ? answer.stdout.trim() || null : null;
+    } catch { /* unread */ }
+    return { teams, native };
+  }
+
   #portholeHook() {
     if (this.portholeHookPath) return this.portholeHookPath;
     const stable = join(supercodeHome(this.env), 'porthole-hook.cjs');
@@ -2367,18 +2396,47 @@ export class TeamsMachine extends MachineCore {
       const pause = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
       // Styled, so the composer's dim placeholder ("Ask Codex to do anything") reads as empty.
       const composer = async () => terminal.composerText?.('codex', await this.host.capture(session.id, { preserveEscapes: true })) ?? null;
-      if (await composer() !== '') return { delivered: false, reason: 'composer-not-empty' };
+      // A composer that reads ready can still be mid-layout: a fresh Codex redraws its screen for about a second more
+      // (measured on volter-desktop: ready from the first frame, redrawn at ~1.1 s and ~1.3 s), and a paste sent into
+      // that is shown late or not at all. Paste only into an empty composer on a screen that has stopped changing.
+      let settled = false;
+      for (const until = Date.now() + CODEX_PASTE_SETTLE_DEADLINE_MS; !settled && !signal.aborted && Date.now() < until;) {
+        const capture = await this.host.capture(session.id, { preserveEscapes: true });
+        settled = terminal.composerText?.('codex', capture) === '' &&
+          this.#screenUnchangedMs(session.id, capture, Date.now()) >= CODEX_PASTE_SETTLE_MS;
+        if (!settled) await pause(150);
+      }
+      if (signal.aborted) return { delivered: false, reason: 'aborted' };
+      if (!settled) return { delivered: false, reason: await composer() === '' ? 'screen-unsettled' : 'composer-not-empty' };
       for (const paste of codexWindowsPastes(body)) {
         if (signal.aborted) return { delivered: false, reason: 'aborted' };
         await this.host.sendInput(session.id, paste, { submitMode: 'none' });
         await pause(300);
       }
       let held = false;
-      for (let attempt = 0; attempt < 20 && !held && !signal.aborted; attempt += 1) {
+      for (const until = Date.now() + CODEX_PASTE_SHOWN_MS; !held && !signal.aborted && Date.now() < until;) {
         held = Boolean(await composer());
         if (!held) await pause(150);
       }
-      if (!held) return { delivered: false, reason: 'paste-unconfirmed' };
+      if (!held) {
+        // A paste shown after this gave up would sit in the composer unsent: watch a while longer and clear it, so the
+        // pane is left as it was found (the launch records the input as undelivered either way).
+        for (const until = Date.now() + CODEX_PASTE_LATE_MS; !signal.aborted && Date.now() < until;) {
+          const shown = await composer();
+          if (!shown) { await pause(250); continue; }
+          // Only this launch's paste is cleared: Codex shows a large paste as its placeholder, a small one as its
+          // text. Anything else (a person typing meanwhile) is theirs and stays.
+          // Compared with whitespace removed on both sides: the composer's text joins its screen rows with line breaks,
+          // so a first line wider than one row never matches as it was sent.
+          const squash = (value) => value.replace(/\s+/gu, '');
+          const firstLine = squash(body.split('\n')[0]);
+          if (/^\[Pasted Content \d+ chars\]/u.test(shown) || (firstLine && squash(shown).startsWith(firstLine))) {
+            await this.#clearCodexComposer(session, composer, pause);
+          }
+          break;
+        }
+        return { delivered: false, reason: 'paste-unconfirmed' };
+      }
       await this.host.sendInput(session.id, '\r', { submitMode: 'single' });
       return { delivered: true };
     } catch (error) {
@@ -2388,6 +2446,17 @@ export class TeamsMachine extends MachineCore {
     }
   }
 
+  /** Empty a Windows Codex composer this launch pasted into: line clear, then deletes until it reads empty (a paste
+   *  placeholder goes with one delete). Never Enter, Escape or Ctrl-C. */
+  async #clearCodexComposer(session, composer, pause) {
+    await this.host.sendInput(session.id, '\u0015', { submitMode: 'none' });
+    await pause(300);
+    for (let round = 0; round < 40 && await composer(); round += 1) {
+      await this.host.sendInput(session.id, '\u007f'.repeat(200), { submitMode: 'none' });
+      await pause(200);
+    }
+  }
+
   async #deliverPaneText(session, contextKey, text, options = {}) {
     const kind = this.#paneKind(contextKey, session);
     if (kind === 'codex' && codexUpdatePrompt(await this.host.capture(session.id, { lines: 120 }))) return { delivered: false, reason: 'codex-update-prompt: delivery refused; restart Codex with check_for_update_on_startup=false' };

package/mail/relay.mjs

@@ -283,11 +283,13 @@ export class Relays {
       }
       // why it is not reused, said in the timing line: a relay that should have been warm and was not shows here
       step(`runtime not reused (${stale ? 'it held a stale turn' : !runtime ? 'no live receipt' : !alive(this.#pid(spec, runtime)) ? 'its process ended' : !record.connection ? 'no connection' : 'endpoint moved'})`);
-      // closed through the owner's door even after its receipt went. One whose receipt is gone, or whose process
-      // ended, is only serve's record of it: let go without holding this send (yuerans, 2026-10-06: 2.3-18 s of every
-      // send under load); one still running is closed before its successor starts, as before
+      // closed through the owner's door even after its receipt went. One whose receipt is gone, or whose process is
+      // known and ended, is only serve's record of it: let go without holding this send (yuerans, 2026-10-06: 2.3-18 s
+      // of every send under load). One that may still run, its process unknown (no child pid, a record of another
+      // runtime) or alive, is closed before its successor starts in the same folder, as before.
       const close = this.serve('harness.v1.runtimes.close', { connection: record.connection, runtime_id: record.runtime_id }, CLOSE_MS);
-      if (runtime && alive(this.#pid(spec, runtime))) {
+      const pid = runtime ? this.#pid(spec, runtime) : null;
+      if (runtime && !(Number.isInteger(pid) && !alive(pid))) {
         try { await close; }
         catch (error) { if (this.runtimeOf('claude-code', record.runtime_id)) throw new Error(`could not retire the old relay: ${error.message}`); }
         step('old runtime closed (runtimes.close)');

package/package.json

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