@runuai/host 0.9.129 → 0.9.131

package/lib/orchestrator.ts

@@ -293,6 +293,12 @@ interface Channel {
   /** Agents with a reconcile-spawn in flight (ADR-049 mid-task adds) — guards
    *  against a concurrent ensure double-spawning the same new agent. */
   spawning: Set<string>;
+  /** Roster agents that have bound at least once on this channel. The launch
+   *  screen's `ready` counts these, not the live `sessions` map: a one-shot
+   *  engine (grok, cursor) exits seconds after its bind, so "every roster
+   *  agent bound at this instant" was never true for a mixed roster after a
+   *  wake — live 2026-09-10, task machine, 4 agents, screen up for good. */
+  everBound: Set<string>;
   /** Factory creates are externally side-effecting before they bind. Teardown
    *  drains them so an old channel cannot resume against a reused container
    *  name and overwrite the replacement generation's durable transport. */
@@ -717,6 +723,7 @@ export class Orchestrator {
       mcpConfigAppliedEpoch: 0,
       configGeneration: 0,
       spawning: new Set(),
+      everBound: new Set(),
       factoryOperations: new Set(),
       eventOperations: new Set(),
       accountByAgent: new Map(),
@@ -1631,19 +1638,30 @@ export class Orchestrator {
 
 
   /** Install a session with an event handler scoped to this exact generation. */
+  /** Every roster agent has bound at least once — the launch screen lifts. */
+  private rosterReady(channel: Channel): boolean {
+    return channel.roster.every(
+      (agent) => channel.sessions.has(agent.id) || channel.everBound.has(agent.id),
+    );
+  }
+
   private bindSession(
     channel: Channel,
     agentId: string,
     session: AgentSession,
   ): void {
     channel.sessions.set(agentId, session);
+    channel.everBound.add(agentId);
     // The launch screen's `ready` rides the bind, not the tail of the start
     // loop: whichever path brings the last roster agent up — the initial
     // start, a reconcile that won the race with it, a respawn after Resume —
     // is the moment the task can take a message. Live 2026-09-09: `agents`
     // was stored, Jonah was up and idle, and no `ready` ever followed, so
     // the page stayed covered for minutes. Idempotent on the cloud side.
-    if (channel.roster.every((agent) => channel.sessions.has(agent.id))) {
+    // Counted on `everBound`, not `sessions`: an agent whose engine exits
+    // after each turn leaves the map seconds after binding and must not hold
+    // the screen up for the rest of the roster (live 2026-09-10).
+    if (this.rosterReady(channel)) {
       this.emitTaskStage(channel.taskId, "ready");
     }
     // Adapters may synchronously emit `error` followed by `turn_complete` (or
@@ -1990,7 +2008,9 @@ export class Orchestrator {
     // this unconditional `agents` then overwrote it — the page stayed
     // covered for good. Only announce the wake-up when there is one to do.
     const allBound = (): boolean =>
-      initialRoster.every((agent) => channel.sessions.has(agent.id));
+      initialRoster.every(
+        (agent) => channel.sessions.has(agent.id) || channel.everBound.has(agent.id),
+      );
     if (!allBound()) this.emitTaskStage(channel.taskId, "agents");
     for (const agent of initialRoster) {
       if (!this.isActiveChannel(channel)) return false;
@@ -2055,7 +2075,11 @@ export class Orchestrator {
     // already bound when this loop began — every bind then predates this
     // pass and could have been overwritten by an `agents` from a start
     // that lost the race.
-    if (allBound()) this.emitTaskStage(channel.taskId, "ready");
+    // Every roster agent was attempted above; if anything is up the task can
+    // take a message, whether or not a one-shot engine has already exited.
+    if (allBound() || channel.sessions.size > 0) {
+      this.emitTaskStage(channel.taskId, "ready");
+    }
     return true;
   }
 

package/lib/task-environment/self.ts

@@ -287,13 +287,22 @@ class SelfTaskEnvironmentHandle implements TaskEnvironmentHandle {
     ) {
       throw new Error("self copy paths must be absolute and NUL-free");
     }
-    // Both sides are this machine. `cp -a` keeps directory trees intact
-    // (engine-account homes), and the result is chowned to the task user so
-    // the agents can read what was copied in for them.
+    // Both sides are this machine. A directory source lands as the
+    // destination's CONTENTS, the way the machine provider's tar stream
+    // does: engine-account provisioning pre-creates the destination, and a
+    // plain `cp -a dir dest` into an existing dest nests `dest/dir/…`, so
+    // CODEX_HOME / GROK_HOME pointed at a dir without auth.json and both
+    // engines ran signed out and silent (live 2026-09-10, first codex + grok
+    // agents on a task machine). A file source copies as before. The result
+    // is chowned to the task user when this process is root, so the agents
+    // can read what was copied in for them.
+    const copy =
+      'if [ -d "$1" ]; then mkdir -p "$2" && cp -a "$1/." "$2/"; ' +
+      'else mkdir -p "$(dirname "$2")" && cp -a "$1" "$2"; fi';
     const script =
-      request.direction === "into"
-        ? 'mkdir -p "$(dirname "$2")" && cp -a "$1" "$2" && chown -R node:node "$2"'
-        : 'mkdir -p "$(dirname "$2")" && cp -a "$1" "$2"';
+      request.direction === "into" && this.#privileged()
+        ? `${copy} && chown -R ${SELF_TASK_USER}:${SELF_TASK_USER} "$2"`
+        : copy;
     const result = await this.exec({
       argv: ["/bin/sh", "-c", script, "copy", request.source, request.destination],
       user: "root",

package/package.json

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