@runuai/host 0.9.86 → 0.9.88

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/lib/orchestrator.ts

@@ -1549,6 +1549,7 @@ export class Orchestrator {
     // can consume/reorder prompt state while the earlier error still owns it.
     let eventTail: Promise<void> = Promise.resolve();
     session.onEvent((event) => {
+      this.markChannelActivity(channel.taskId);
       // Recycle/teardown deletes the old session before calling close().
       // Adapters deliberately emit a final exit event; without this identity
       // guard it can delete a replacement or consume its respawn budget.
@@ -3001,6 +3002,20 @@ export class Orchestrator {
    * reconciles it to `stopped` (worktree present) and it can be resumed. Since
    * `stopped` is not an ACTIVE status, host recovery won't restart it.
    */
+  /** Last observed sign of life per channel: any session event (agent
+   * output, turn boundaries) or an inbound delivery. The idle-stop veto
+   * (ADR-125) reads this — the cloud decides idleness from what it can see,
+   * but only the host can see a turn that is mid-flight RIGHT NOW. */
+  readonly #channelActivity = new Map<string, number>();
+
+  markChannelActivity(taskId: string): void {
+    this.#channelActivity.set(taskId, Date.now());
+  }
+
+  lastChannelActivity(taskId: string): number | null {
+    return this.#channelActivity.get(taskId) ?? null;
+  }
+
   async stopTask(taskId: string): Promise<{ ok: boolean; error?: string }> {
     return this.runTaskLifecycle(taskId, () =>
       this.stopTaskWithinLifecycle(taskId),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@runuai/host",
-  "version": "0.9.86",
+  "version": "0.9.88",
   "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);
         }
@@ -1034,6 +1029,28 @@ export const hostCommands: HostCommands = {
     });
   },
 
+  async taskStop(ctx, taskId, input) {
+    logCommand(ctx, "taskStop", taskId, input.reason);
+    // ADR-125: idle stops are the cloud's judgment from what it can see;
+    // only the host can see a turn that is mid-flight RIGHT NOW. Manual
+    // pause carries no veto — a human's explicit gesture wins.
+    if (input.reason === "idle") {
+      const activeAt = getOrchestrator().lastChannelActivity(taskId);
+      if (activeAt !== null && Date.now() - activeAt < IDLE_STOP_VETO_MS) {
+        return { ok: true, value: { vetoed: "active" as const } };
+      }
+    }
+    const result = await getOrchestrator().stopTask(taskId);
+    if (!result.ok) {
+      return {
+        ok: false,
+        code: HostErrorCode.Internal,
+        message: result.error ?? "stop failed",
+        retryable: true,
+      };
+    }
+    return { ok: true, value: {} };
+  },
   async taskStatus(ctx, taskId) {
     logCommand(ctx, "taskStatus", taskId);
     const runtimeFailure = runtimeUnavailable();
@@ -1117,6 +1134,9 @@ export const hostCommands: HostCommands = {
     const runtimeFailure = runtimeUnavailable();
     if (runtimeFailure) return runtimeFailure;
     try {
+      // An inbound turn is activity: the idle veto must cover the gap between
+      // this delivery landing and the agent's first output event.
+      getOrchestrator().markChannelActivity(taskId);
       const result = await getOrchestrator().deliver(taskId, agentId, text);
       if (!result.ok) {
         return {
@@ -1537,6 +1557,10 @@ function teardownRuntimeUnavailable(): HostCommandResult<never> | null {
   };
 }
 
+/** ADR-125: an idle stop is vetoed when the channel showed any activity
+ * this recently — a delivery landing or any session event. */
+const IDLE_STOP_VETO_MS = 120_000;
+
 const RUNTIME_TASK_ADMISSION_WAIT_MS = 3_000;
 
 /**

package/src/main.ts

@@ -173,6 +173,7 @@ import {
   HOST_MAINTENANCE_READINESS_PROTOCOL_FEATURE,
   HOST_CONFIG_PROTOCOL_FEATURE,
   HOST_REMOTE_LIFECYCLE_PROTOCOL_FEATURE,
+  HOST_TASK_STOP_PROTOCOL_FEATURE,
   HOST_ENGINE_ACCOUNTS_PROTOCOL_FEATURE,
   HOST_ENGINE_CONNECT_PROTOCOL_FEATURE,
   HOST_ENGINE_LOGIN_PROTOCOL_FEATURE,
@@ -584,6 +585,7 @@ function buildCapabilities(): HostCapabilities {
       HOST_ENGINE_LOGIN_PROTOCOL_FEATURE,
       HOST_CONFIG_PROTOCOL_FEATURE,
       HOST_REMOTE_LIFECYCLE_PROTOCOL_FEATURE,
+      HOST_TASK_STOP_PROTOCOL_FEATURE,
       HOST_ENGINE_ACCOUNTS_PROTOCOL_FEATURE,
       HOST_ENGINE_CONNECT_PROTOCOL_FEATURE,
       // The echo adapter cannot execute the in-task CLI. Advertising typed
@@ -2279,6 +2281,12 @@ async function dispatchCommand(
       const downInput = expectTaskDownInput(args, 0);
       return hostCommands.taskDown(ctx, downInput);
     }
+    case "taskStop":
+      return hostCommands.taskStop(
+        ctx,
+        typeof args[0] === "string" ? args[0] : "",
+        (args[1] ?? { reason: "manual" }) as { reason: "idle" | "manual" },
+      );
     case "taskStatus":
       return hostCommands.taskStatus(ctx, expectString(args, 0));
     case "channelEnsure":

package/src/protocol.ts

@@ -89,6 +89,10 @@ export const HOST_CONFIG_PROTOCOL_FEATURE = "host-config-v1";
 /** Remote update/restart over the bridge (owner-gated cloud routes). */
 export const HOST_REMOTE_LIFECYCLE_PROTOCOL_FEATURE =
   "host-remote-lifecycle-v1";
+/** ADR-125: cloud-initiated resumable task stop (idle auto-stop + manual
+ * pause). Idle stops carry reason "idle" and the host may VETO them when a
+ * turn is active right now — the veto is an ok result, not an error. */
+export const HOST_TASK_STOP_PROTOCOL_FEATURE = "host-task-stop-v1";
 /** ADR-116: labeled engine accounts on the cloud host page — account list in
  * capabilities, account-targeted login (`label` on engine.login.start), and
  * the engineAccountRemove command. */
@@ -1111,6 +1115,19 @@ export interface TaskLaunchInput {
   ownerName?: string;
 }
 
+/** ADR-125 resumable stop. "idle" = the cloud's sweep decided nobody is
+ * using the task; the host may veto if a turn is live. "manual" = a human
+ * pressed pause; no veto. */
+export interface TaskStopInput {
+  reason: "idle" | "manual";
+}
+
+export interface TaskStopResult {
+  /** Present when the host declined an idle stop because the channel showed
+   * activity within its veto window. The cloud retries on a later sweep. */
+  vetoed?: "active";
+}
+
 export interface TaskDownInput {
   taskId: string;
   task: TaskCommandTask;
@@ -1296,6 +1313,11 @@ export interface HostCommands {
     ctx: CommandContext,
     taskId: string,
   ): Promise<HostCommandResult<TaskStatusResult>>;
+  taskStop(
+    ctx: CommandContext,
+    taskId: string,
+    input: TaskStopInput,
+  ): Promise<HostCommandResult<TaskStopResult>>;
   channelEnsure(
     ctx: CommandContext,
     input: ChannelEnsureInput,