@volter/supercode-orchestrator 0.5.181 → 0.5.182

package/board/doors.mjs

@@ -26,8 +26,11 @@ async function opened(machine) {
   }
   const opening = (async () => {
     const channel = await openMachine({ machine: machine || null });
-    const door = { channel, node: null, harness: null };
+    const door = { channel, node: null, harness: null, heardAt: performance.now() };
+    // when the channel last carried anything (an answer, a stream's data, the keep-alive's pong): see retireSilent
+    channel.socket?.on?.('data', () => { door.heardAt = performance.now(); });
     channel.on('close', () => { if (held.get(key) === opening) held.delete(key); });
+    door.opening = opening;
     return door;
   })();
   held.set(key, opening);
@@ -43,13 +46,14 @@ async function opened(machine) {
 export async function machineCall(machine, method, params = {}, { timeoutMs = 60_000 } = {}) {
   if (!method.startsWith('harness.v1.')) throw new Error('a machine door is a harness.v1 method');
   const started = performance.now();
+  let door = null;
   try {
-    const door = await opened(machine);
+    door = await opened(machine);
     if (method.startsWith('harness.v1.sessions.')) {
       // The harness client starts its transport again itself once it ends (a daemon restart there); one that never
       // started is let go, so the next call starts another.
       if (!door.harness) {
-        const starting = (async () => { const client = new SupercodeHarnessClient({ transport: harnessTransport(door.channel) }); await client.start?.(); return client; })();
+        const starting = (async () => { const client = new SupercodeHarnessClient({ transport: channelHarness(door.channel, machine) }); await client.start?.(); return client; })();
         starting.catch(() => { if (door.harness === starting) door.harness = null; });
         door.harness = starting;
       }
@@ -66,11 +70,46 @@ export async function machineCall(machine, method, params = {}, { timeoutMs = 60
       door.node = opening;
     }
     return await (await door.node).call(method, params, { timeoutMs });
+  } catch (error) {
+    if (machine && door && (error?.code === 'REQUEST_TIMEOUT' || error?.code === 504)) retireSilent(machine, door, started);
+    throw error;
   } finally {
     noteStep(`door ${method}${machine ? ' (another machine)' : ''}`, performance.now() - started);
   }
 }
 
+/**
+ * Another machine's channel that carried nothing at all for the whole of a request's bound is closed, so the next call
+ * opens a fresh one. Such a channel's socket to the Teams server can stay open after the server has lost the far side:
+ * every request on it waits out its bound, and nothing ends the channel until the server closes the socket. On
+ * 2026-10-14 the board owner's discoveries on other machines timed out five times running (00:05:16 to 00:06:31), the
+ * server closed their channel at 00:06:37 (two calls failed "connection closed"), and the next channel answered in
+ * 1.4 s. The keep-alive's ping is answered by the far machine's own channel, so a channel that carried anything
+ * meanwhile (another answer, a pong) reaches that machine and is kept: the request was slow there.
+ */
+function retireSilent(machine, door, started) {
+  if (door.heardAt >= started || door.channel.closed) return;
+  if (held.get(machine) === door.opening) held.delete(machine);
+  door.channel.close();
+}
+
+/**
+ * The harness transport over a machine channel, saying what ended when it ends: the channel's stream is no harness
+ * process, and its close (`connection closed`) read as "Volter Harness service exited" sent F81 looking for a child
+ * that never exited.
+ */
+function channelHarness(channel, machine) {
+  const inner = harnessTransport(channel);
+  const where = machine ? `the Teams server channel to ${machine}` : "the socket to this machine's daemon";
+  return {
+    get running() { return inner.running; },
+    start: (handlers) => inner.start({ ...handlers,
+      onExit: (code, reason) => handlers.onExit(code, `${reason ?? 'closed'}: ${where} ended, no harness process exited`) }),
+    write: (line) => inner.write(line),
+    close: () => inner.close(),
+  };
+}
+
 export async function machineRecordStream(params = {}) {
   const door = await opened(null);
   return door.channel.open('machine-record-changes', params);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@volter/supercode-orchestrator",
-  "version": "0.5.181",
+  "version": "0.5.182",
   "type": "module",
   "description": "The orchestrator runtime over the Volter Harness ontology: one typed operational model whose folder is its serialization, read and written through the harness orchestration doors (docs/ORCHESTRATOR-IR.md)",
   "exports": {