@runuai/host 0.9.146 → 0.9.147

package/lib/agent-cli.ts

@@ -305,7 +305,22 @@ async function main() {
     case "memory search": {
       const q = pos.join(" ") || flags.q || "";
       const author = flags.as ? "&author=" + encodeURIComponent(flags.as) : "";
-      out((await api("GET", "/api/agent/memory?q=" + encodeURIComponent(q) + author)).memories);
+      const limit = flags.limit ? "&limit=" + encodeURIComponent(String(flags.limit)) : "";
+      const res = await api(
+        "GET",
+        "/api/agent/memory?q=" + encodeURIComponent(q) + author + limit,
+      );
+      out(res.memories);
+      // Truncation goes to stderr so it cannot corrupt piped JSON, and it is
+      // stated rather than implied: recalling across tasks means reading the
+      // WHOLE store, and a short page that says nothing reads as all there is.
+      // NOTE: this file is a template literal. No backticks, no \${} in here.
+      if (res.truncated) {
+        console.error(
+          "uai: showing " + res.memories.length + " of " + res.total +
+            " — re-run with --limit all for every row.",
+        );
+      }
       break;
     }
     case "memory save": {
@@ -453,7 +468,7 @@ async function main() {
         "  uai task list",
         "  uai task create --name <n> --prompt <p> [--projects id,id] [--team id] [--agents handle,handle]",
         '  uai task close --status finished|canceled [--reason "final report"]',
-        "  uai memory search <query>",
+        "  uai memory search <query> [--as handle] [--limit N|all]",
         "  uai memory save <text> [--project id] [--tags a,b]",
         "  uai memory delete <id>",
         "  uai todo list",

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@runuai/host",
-  "version": "0.9.146",
+  "version": "0.9.147",
   "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,
@@ -866,7 +869,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);
@@ -1042,15 +1049,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

@@ -1812,9 +1812,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 }