@runuai/host 0.9.86 → 0.9.87

package/lib/agents/machine-durable.ts

@@ -143,6 +143,8 @@ export class MachineDurableProcess implements LineTransport {
   #closed = false;
   #detached = false;
   #sawSpawnMeta = false;
+  /** Completed-and-empty direct outbox probes past the spawn grace. */
+  #noMetaStrikes = 0;
   readonly #startedAt = Date.now();
   #tail: TaskEnvironmentProcess | null = null;
   #tailGeneration = 0;
@@ -322,9 +324,40 @@ export class MachineDurableProcess implements LineTransport {
     this.#probing = true;
     try {
       if (!this.#sawSpawnMeta) {
-        if (Date.now() - this.#startedAt > HEARTBEAT_STALE_MS) {
-          this.#finish(null, "no spawn meta within grace");
+        if (Date.now() - this.#startedAt <= HEARTBEAT_STALE_MS) return;
+        // Grace elapsed on OUR clock — but the spawn meta arrives via the
+        // tail, an ssh child of THIS host, and both starve together when the
+        // host CPU is pegged (live 2026-08-29: a 12-task launch burst pushed
+        // load to 16, tails lagged, and healthy runners were declared dead —
+        // then respawned, ORPHANING the originals). Before any verdict, ask
+        // the machine directly: the runner writes its spawn meta as the
+        // outbox's first line.
+        let sawOnMachine = false;
+        try {
+          const probe = await execStep(this.#environment, [
+            "/bin/sh",
+            "-c",
+            'head -n1 "$1/outbox.jsonl" 2>/dev/null | grep -c __uai',
+            "probe",
+            this.#sessionDir,
+          ]);
+          sawOnMachine =
+            probe.exitCode === 0 && Number(probe.stdout.trim()) > 0;
+        } catch {
+          // Unreachable machine: counts as a strike below.
+        }
+        if (this.#closed || this.#detached) return;
+        if (sawOnMachine) {
+          this.#sawSpawnMeta = true;
+          return;
         }
+        // Two COMPLETED empty probes past the grace — not elapsed time — are
+        // the death sentence; probes that never ran prove nothing.
+        this.#noMetaStrikes += 1;
+        if (this.#noMetaStrikes < 2) return;
+        await this.#killRemoteRunner();
+        if (this.#closed || this.#detached) return;
+        this.#finish(null, "no spawn meta within grace");
         return;
       }
       const fresh = await machineHeartbeatFresh(
@@ -333,12 +366,37 @@ export class MachineDurableProcess implements LineTransport {
         HEARTBEAT_STALE_MS,
       );
       if (this.#closed || this.#detached) return;
-      if (!fresh) this.#finish(null, "heartbeat stale");
+      if (!fresh) {
+        // A stale-but-alive runner would be doubled by the respawn; the
+        // single-runner-per-session invariant is enforced here, not hoped for.
+        await this.#killRemoteRunner();
+        if (this.#closed || this.#detached) return;
+        this.#finish(null, "heartbeat stale");
+      }
     } finally {
       this.#probing = false;
     }
   }
 
+  /** Best-effort remote kill of this session's runner before declaring it
+   * dead: a wrong verdict must cost a restart, never an orphaned agent.
+   * `runner[.]mjs` so the kill-shell's own argv (which carries this script
+   * text) can never self-match — the pgrep/pkill self-match class. */
+  async #killRemoteRunner(): Promise<void> {
+    try {
+      await execStep(this.#environment, [
+        "/bin/sh",
+        "-c",
+        'pkill -f "runner[.]mjs $1" >/dev/null 2>&1; true',
+        "kill",
+        this.#sessionDir,
+      ]);
+    } catch {
+      // The finish verdict stands either way; the orphan sweep in recovery
+      // remains the backstop for an unreachable machine.
+    }
+  }
+
   #finish(code: number | null, reason = "unspecified"): void {
     if (this.#closed) return;
     // Session deaths are load-bearing and were undiagnosable without this

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@runuai/host",
-  "version": "0.9.86",
+  "version": "0.9.87",
   "description": "Uai host — runs ephemeral AI tasks in containers on a machine you control.",
   "license": "MIT",
   "author": "Uai Tech <team@runuai.com>",

package/src/index.ts

@@ -976,18 +976,13 @@ export const hostCommands: HostCommands = {
       }
       const result = await wrapAgent(ctx, "taskDown", async () => {
         if (environment === null) return agent.taskDown(input);
-        // ADR-121: an ordinary stop of a machine task must keep the machine's
-        // disk — the workspace lives THERE, not on a host worktree the way
-        // compose teardown preserves it. Stop is the resumable gesture
-        // (provision restarts a stopped machine); only orphan GC terminates.
-        if (
-          !orphanGc &&
-          environment.descriptor.locator.provider === "machine"
-        ) {
-          stopMachineGatewayTunnel(input.taskId);
-          await environment.stop();
-          return taskDownResultForInput(input, { status: "stopped" });
-        }
+        // taskDown is TERMINAL — its only cloud callers are task close and
+        // failed-occurrence/orphan cleanup; pause rides the separate stopTask
+        // command. Machines therefore TERMINATE here: a closed task can never
+        // be resumed, so a stopped-but-kept machine is a per-month disk leak
+        // with no consumer (owner, 2026-08-29 — 16 parked disks after one
+        // evening of testing). The task branch lives on the remote; the
+        // machine's disk is not a preservation surface once the task ends.
         if (environment.descriptor.locator.provider === "machine") {
           stopMachineGatewayTunnel(input.taskId);
         }