@runuai/host 0.9.146 → 0.9.148

package/lib/stopped-task-status-queue.ts

@@ -4,8 +4,21 @@
  * mirror remains the authority at flush time so a later Resume wins over an
  * older queued stop.
  */
+/**
+ * Why the host stopped the task, when the host knows.
+ *
+ * `"manual"` is ADR-028's local-UI Stop — a person at the machine pressed it.
+ * Everything else the host reports through this frame is automatic (writable
+ * -container quarantine during a runtime activation or a shared-volume
+ * repair), and carries no reason. The cloud needs the difference because
+ * ADR-144 lets a collaborator resume a task that stopped on its own but not
+ * one a human deliberately paused, and until now both arrived as the same
+ * three fields.
+ */
+export type StoppedTaskReason = "manual";
+
 export class StoppedTaskStatusQueue {
-  private readonly pending = new Set<string>();
+  private readonly pending = new Map<string, StoppedTaskReason | undefined>();
 
   constructor(
     private readonly statusForTask: (
@@ -13,8 +26,13 @@ export class StoppedTaskStatusQueue {
     ) => string | null | undefined,
   ) {}
 
-  enqueue(taskId: string): void {
-    this.pending.add(taskId);
+  enqueue(taskId: string, reason?: StoppedTaskReason): void {
+    // A reason, once known, STICKS across a re-enqueue. The same task can be
+    // queued twice before a flush — an operator Stop, then a quarantine sweep
+    // that finds its container already down — and the automatic pass arriving
+    // second does not make the human's decision retroactively automatic.
+    // Dropping it would silently hand the task back to every collaborator.
+    this.pending.set(taskId, reason ?? this.pending.get(taskId));
   }
 
   /** A failed taskUp may have stopped a legacy runtime before recreation lost
@@ -35,9 +53,9 @@ export class StoppedTaskStatusQueue {
     return true;
   }
 
-  flush(publish: (taskId: string) => void): void {
-    for (const taskId of [...this.pending]) {
-      if (this.statusForTask(taskId) === "stopped") publish(taskId);
+  flush(publish: (taskId: string, reason?: StoppedTaskReason) => void): void {
+    for (const [taskId, reason] of [...this.pending]) {
+      if (this.statusForTask(taskId) === "stopped") publish(taskId, reason);
       this.pending.delete(taskId);
     }
   }

package/lib/ulid.ts

@@ -4,4 +4,13 @@ export function newId(): string {
   return ulid().toLowerCase();
 }
 
-export { ulid as monotonicUlid };
+/**
+ * A ULID with its canonical UPPERCASE base32, unlike `newId()` above.
+ *
+ * Renamed from `monotonicUlid`, which it never was: the plain generator
+ * randomises the suffix, so two ids minted in the same millisecond do not
+ * sort in call order. Nothing in this package imports it — it is kept only to
+ * mirror `lib/ulid.ts`, and it is renamed here too so the false promise is
+ * not sitting in the copy someone reads next.
+ */
+export { ulid as rawUlid };

package/package.json

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

package/src/main.ts

@@ -28,7 +28,10 @@ import {
   getHostTask,
   hasInFlightHostTaskLifecycle,
 } from "../lib/runtime-state";
-import { StoppedTaskStatusQueue } from "../lib/stopped-task-status-queue";
+import {
+  StoppedTaskStatusQueue,
+  type StoppedTaskReason,
+} from "../lib/stopped-task-status-queue";
 import {
   getOrchestrator,
   quarantineWritableRuntimeContainers,
@@ -209,6 +212,7 @@ import {
   HOST_ENGINE_ACCOUNT_SCOPES_PROTOCOL_FEATURE,
   HOST_ENGINE_DISCONNECT_PROTOCOL_FEATURE,
   HOST_ENGINE_LOGIN_PROTOCOL_FEATURE,
+  LIVE_ROSTER_EDIT_PROTOCOL_FEATURE,
   isEngineAccountScope,
   HOST_LOGS_PROTOCOL_FEATURE,
   HOST_TASK_INVENTORY_PROTOCOL_FEATURE,
@@ -866,7 +870,11 @@ async function startLocalUi(): Promise<void> {
         invalidateMachineTunnelRoute(taskId);
         try {
           const result = await getOrchestrator().stopTask(taskId);
-          if (result.ok) queueStoppedTaskStatus(taskId);
+          // A PERSON pressed Stop on this machine's own UI — ADR-028. Labelled
+          // as such because the cloud otherwise cannot tell it apart from the
+          // quarantine sweeps below, which reach the bridge through this same
+          // frame, and ADR-144 turns that difference into who may undo it.
+          if (result.ok) queueStoppedTaskStatus(taskId, "manual");
           return result;
         } finally {
           invalidateMachineTunnelRoute(taskId);
@@ -909,6 +917,7 @@ function buildCapabilities(): HostCapabilities {
       HOST_ENGINE_ACCOUNT_SCOPES_PROTOCOL_FEATURE,
       HOST_ENGINE_ACCOUNT_MANAGE_PROTOCOL_FEATURE,
       HOST_ENGINE_DISCONNECT_PROTOCOL_FEATURE,
+      LIVE_ROSTER_EDIT_PROTOCOL_FEATURE,
       // The echo adapter cannot execute the in-task CLI. Advertising typed
       // dispatch in mock mode would let the composer create a Secretary that
       // has no way to wake crew.
@@ -1042,15 +1051,18 @@ function sendCapabilities(): void {
 
 /** Keep a rolling-isolation/local-UI stop from remaining cloud-ghost-running
  * merely because the bridge was between connections at the transition. */
-function queueStoppedTaskStatus(taskId: string): void {
-  pendingRuntimeIsolationStatuses.enqueue(taskId);
+function queueStoppedTaskStatus(
+  taskId: string,
+  reason?: StoppedTaskReason,
+): void {
+  pendingRuntimeIsolationStatuses.enqueue(taskId, reason);
   flushStoppedTaskStatuses();
 }
 
 function flushStoppedTaskStatuses(socket: WebSocket | null = ws): void {
   if (!socket || socket.readyState !== WebSocket.OPEN) return;
-  pendingRuntimeIsolationStatuses.flush((taskId) => {
-    send(socket, { kind: "task.status", taskId, status: "stopped" });
+  pendingRuntimeIsolationStatuses.flush((taskId, reason) => {
+    send(socket, { kind: "task.status", taskId, status: "stopped", reason });
   });
 }
 

package/src/protocol.ts

@@ -120,6 +120,14 @@ export const HOST_ENGINE_ACCOUNT_MANAGE_PROTOCOL_FEATURE =
   "host-engine-account-manage-v1";
 export const HOST_ENGINE_ACCOUNT_SCOPES_PROTOCOL_FEATURE =
   "host-engine-account-scopes-v1";
+/** ADR-049 addendum: live roster edits. On channel.ensure the host diffs the
+ * live roster against the spec — an agent whose kind, model or effort changed
+ * has its session recycled so the reconciler respawns it on the new settings,
+ * and an agent missing from the spec has its session stopped (its session dir
+ * stays). A host without this keeps a changed agent's old process until some
+ * unrelated respawn and never stops a removed one, so the cloud refuses to
+ * edit or remove a running task's agents on it. */
+export const LIVE_ROSTER_EDIT_PROTOCOL_FEATURE = "live-roster-edit-v1";
 /** The owner-level account scope; every pre-scope account lives here. */
 export const HOST_ACCOUNT_SCOPE = "host";
 const ORG_ACCOUNT_SCOPE_RE = /^org:[A-Za-z0-9_-]{1,128}$/;
@@ -1812,9 +1820,21 @@ export type HostToCloud =
   // ADR-103: `seq` is the outbox sequence number (monotonic within a bootId).
   // Absent from pre-103 hosts; the cloud dedups replay overlap by it.
   | { kind: "event"; event: HostEvent; seq?: number }
-  // Host-pushed task lifecycle (ADR-028 local-UI Stop): the host operator paused
-  // a task's containers, so the cloud mirrors the status (currently "stopped").
-  | { kind: "task.status"; taskId: string; status: string }
+  // Host-pushed task lifecycle: the cloud mirrors the status (currently
+  // "stopped"). TWO different events arrive through this one frame — ADR-028's
+  // local-UI Stop, where the host operator paused the task's containers, and
+  // the automatic writable-container quarantine a runtime activation or
+  // shared-volume repair performs. `reason: "manual"` is the first; its
+  // absence is the second.
+  //
+  // The cloud cannot infer it. ADR-144 lets a collaborator resume a task that
+  // stopped on its own and not one a human deliberately paused, and with both
+  // stops indistinguishable on the wire the deliberate one was reversible by
+  // anyone on the task. OPTIONAL so an older host stays compatible: it sends
+  // no reason, the cloud records none, and that host's operator Stop keeps the
+  // pre-ADR-144 behaviour rather than mislabelling its quarantines as manual
+  // and blocking the recovery path they exist to enable.
+  | { kind: "task.status"; taskId: string; status: string; reason?: string }
   | { kind: "ping"; ts: number }
   // ADR-133: a sidecar asks for (or refreshes) its task-scoped AWS lease.
   | { kind: "lease.request"; opId: string; taskId: string }
@@ -2025,6 +2045,18 @@ export type HostEvent =
       agentId: string;
       reason: string;
     }
+  // A roster change moved an agent's session (LIVE_ROSTER_EDIT_PROTOCOL_FEATURE).
+  // `restarting`: its kind/model/effort changed and the old session was stopped
+  // (at once when idle, otherwise when its turn ended) — the reconciler is
+  // respawning it. `ready`: that replacement session bound. `removed`: the
+  // agent left the roster and its session was stopped. An older cloud ignores
+  // the unknown kind.
+  | {
+      kind: "agent.session";
+      taskId: string;
+      agentId: string;
+      state: "restarting" | "ready" | "removed";
+    }
   // A host-originated system note for the task channel (ADR-027) — e.g. gh
   // auth expired. The cloud renders it as an author:"system" message.
   | {