@runuai/host 0.8.18 → 0.8.20

package/lib/orchestrator.ts

@@ -1463,7 +1463,12 @@ async function dockerListContainersByLabel(
     { timeoutMs: 60_000 },
   );
   if (res.status === null) return null; // docker state UNKNOWN — don't act on it
-  if (res.status !== 0) return [];
+  // Non-zero is ALSO unknown, not "no containers": after a machine reboot the
+  // host service races the Docker daemon, and `docker ps` fails fast with
+  // "cannot connect". Treating that as [] downgraded every active task to
+  // stopped on boot (live user report 2026-07-21) — the exited-container
+  // restart branch below never got a chance to run.
+  if (res.status !== 0) return null;
   return res.stdout
     .split("\n")
     .map((l) => l.trim())
@@ -1518,7 +1523,40 @@ async function dockerExec(
 }
 
 /** Exported for tests; production entry is the getOrchestrator() boot guard. */
-export async function recoverRunningTasks(): Promise<void> {
+export async function recoverRunningTasks(opts?: {
+  /** Delay between passes while docker is unreachable (tests shrink it). */
+  retryMs?: number;
+  /** Bound on passes; ~15 min at the default cadence covers slow boots. */
+  maxPasses?: number;
+}): Promise<void> {
+  const retryMs = opts?.retryMs ?? 20_000;
+  const maxPasses = opts?.maxPasses ?? 45;
+  // After a machine reboot the host service and the Docker daemon start
+  // concurrently; a pass that finds docker unreachable resolves nothing and
+  // must retry once the daemon is up — the whole point of recovery is to
+  // restart the exited containers that reboot left behind.
+  for (let pass = 1; ; pass++) {
+    const deferred = await recoveryPass();
+    if (deferred === 0) return;
+    if (pass >= maxPasses) {
+      console.warn(
+        `[orchestrator] recovery: docker still unreachable after ${pass} passes — giving up (${deferred} task(s) unresolved)`,
+      );
+      return;
+    }
+    if (pass === 1) {
+      console.log(
+        `[orchestrator] recovery: docker not ready — retrying every ${Math.round(retryMs / 1000)}s for ${deferred} task(s)`,
+      );
+    }
+    await new Promise((resolve) => setTimeout(resolve, retryMs));
+  }
+}
+
+/** One recovery sweep. Returns how many tasks were deferred on an
+ *  unreachable docker (0 = everything resolved one way or another). */
+async function recoveryPass(): Promise<number> {
+  let deferred = 0;
   try {
     const db = getDb();
     const rows = db
@@ -1526,13 +1564,13 @@ export async function recoverRunningTasks(): Promise<void> {
       .from(schema.hostTasks)
       .where(inArray(schema.hostTasks.statusMirror, [...ACTIVE_STATUSES]))
       .all();
-    if (rows.length === 0) return;
+    if (rows.length === 0) return 0;
     console.log(
       `[orchestrator] recovery: scanning ${rows.length} active task row(s)`,
     );
     for (const task of rows) {
       try {
-        await recoverOneTask(task);
+        if (!(await recoverOneTask(task))) deferred += 1;
       } catch (err) {
         console.error(
           `[orchestrator] recovery: ${task.taskId} failed:`,
@@ -1546,17 +1584,19 @@ export async function recoverRunningTasks(): Promise<void> {
       err instanceof Error ? err.message : err,
     );
   }
+  return deferred;
 }
 
+/** Returns false when docker was unreachable (caller retries the pass). */
 async function recoverOneTask(
   task: typeof schema.hostTasks.$inferSelect,
-): Promise<void> {
+): Promise<boolean> {
   const composeProject = task.composeProject;
   if (!composeProject) {
     // We never wrote a compose project name for this row — must be
     // a row stuck in `queued`/`starting` from before task-up got past
     // step 2. Leave it; the user can recreate.
-    return;
+    return true;
   }
   const containerName = `${composeProject}-app-1`;
   const containers = await dockerListContainersByLabel(
@@ -1564,11 +1604,11 @@ async function recoverOneTask(
   );
   if (containers === null) {
     // Docker unreachable / timed out — actual state unknown. Leave the row
-    // alone; the next recovery pass (or the next ensure) will see the truth.
+    // alone; the retrying caller re-scans once docker answers.
     console.warn(
-      `[orchestrator] recovery: ${task.taskId} skipped — docker did not answer`,
+      `[orchestrator] recovery: ${task.taskId} deferred — docker did not answer`,
     );
-    return;
+    return false;
   }
 
   if (containers.length === 0) {
@@ -1585,7 +1625,7 @@ async function recoverOneTask(
       `[orchestrator] recovery: ${task.taskId} -> ${next} (container gone, ` +
         `worktree ${workspaceOnDisk ? "present" : "gone"})`,
     );
-    return;
+    return true;
   }
 
   const running = containers.some((c) => c.State === "running");
@@ -1607,7 +1647,7 @@ async function recoverOneTask(
     if (task.ownerUserId) {
       void setupTaskGithub(task.taskId, task.ownerUserId);
     }
-    return;
+    return true;
   }
 
   // Container exists but exited. Bring it back up + re-launch the
@@ -1620,7 +1660,7 @@ async function recoverOneTask(
       codeServerPort: null,
       previewPorts: "[]",
     });
-    return;
+    return true;
   }
   // Correctly-owned Codex creds BEFORE uai-init / any agent respawn: the boot
   // reinject sweep only targets containers already running, so a container
@@ -1649,6 +1689,7 @@ async function recoverOneTask(
   console.log(
     `[orchestrator] recovery: ${task.taskId} resumed (port ${port ?? "?"})`,
   );
+  return true;
 }
 
 function db_setStatus(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@runuai/host",
-  "version": "0.8.18",
+  "version": "0.8.20",
   "description": "Uai host — runs ephemeral AI coding tasks in Docker on a machine you control.",
   "license": "MIT",
   "author": "Diogo Perillo <diogo.perillo@gmail.com>",

package/scripts/agent/task-up.sh

@@ -198,7 +198,15 @@ while IFS= read -r project_obj; do
   [ -n "$project_default" ] || project_default="main"
 
   mkdir -p "$(dirname "$worktree_target")"
-  if git -C "$mirror_dir" rev-parse --verify --quiet \
+  if [ -e "$worktree_target/.git" ]; then
+    # Resume (ADR-028): the task worktree survived the stop — reuse it as-is
+    # (a linked worktree's .git is a FILE, hence -e). Re-running `git
+    # worktree add` would refuse ("already exists" / branch exists) and
+    # errored EVERY resume of a worktree-preserving stop within seconds
+    # (found live 2026-07-21). The task branch and any uncommitted work are
+    # exactly what the user expects back.
+    log "worktree for $project_slug already present — resuming with it"
+  elif git -C "$mirror_dir" rev-parse --verify --quiet \
        "refs/remotes/origin/$project_default" >/dev/null 2>&1; then
     # Normal case: branch the task worktree off origin/<defaultBranch>.
     step "WORKTREE_FAILED" "git worktree add ($project_id)"