@runuai/host 0.9.42 → 0.9.44

package/lib/engine-login.ts

@@ -1286,7 +1286,13 @@ export function engineLoginContainerArgs(
       ? [
           "/usr/bin/script",
           "-qefc",
-          "exec claude setup-token",
+          // A wide PTY first: `script` allocates 80×24 when stdin is no
+          // terminal, the CLI hard-wraps the OAuth URL at that width, and
+          // the streamed capture then sees only the first fragment — the
+          // operator lands on claude.ai with "Missing redirect_uri" and half
+          // a client id (live 2026-08-18). stty targets the PTY `script`
+          // just allocated.
+          "stty cols 500 rows 50 2>/dev/null; exec claude setup-token",
           "/dev/null",
         ]
       : ["codex", "login"];

package/lib/managed-runtime.ts

@@ -806,12 +806,62 @@ export function managedRuntimeActivationPending(home?: string): boolean {
  * taskUp and must be repaired by a safe uninstall retry.
  */
 export function managedRuntimeAdmissionPending(home?: string): boolean {
+  return managedRuntimeAdmissionBlocker(home) !== null;
+}
+
+/** The exact file closing task admission, or null. Refusals must NAME their
+ * gate: three stacked silent refusals cost a live operator hours
+ * (2026-08-18) because nothing anywhere said which file to look at. */
+export function managedRuntimeAdmissionBlocker(home?: string): string | null {
   const paths = managedRuntimePaths(home);
-  return (
-    pathExistsSync(paths.activationPending) ||
-    pathExistsSync(paths.maintenancePending) ||
-    pathExistsSync(paths.installIntent)
-  );
+  for (const marker of [
+    paths.activationPending,
+    paths.maintenancePending,
+    paths.installIntent,
+  ]) {
+    if (pathExistsSync(marker)) return marker;
+  }
+  return null;
+}
+
+/**
+ * Boot-time self-heal for the recurring silent-gate incident (live
+ * 2026-08-11 and twice on 2026-08-18): an uninstall/update helper that died
+ * at phase "checking" leaves its admission gate behind forever, and every
+ * taskUp / channelEnsure then bounces retryably with no feedback anywhere.
+ *
+ * A "checking" marker is reclaimable by the flow's OWN contract — no
+ * teardown has begun at that phase (removeManagedRuntime reopens admission
+ * itself on an ordinary busy refusal) — and a marker observed while holding
+ * the operation lock cannot belong to a live operation. Later phases
+ * (teardown/cleanup) and unreadable markers stay fail-closed: state may be
+ * half-removed and only an uninstall retry may touch them.
+ */
+export async function reclaimAbandonedMaintenanceCheck(
+  home?: string,
+): Promise<"cleared" | "kept" | "none"> {
+  const paths = managedRuntimePaths(home);
+  if (!pathExistsSync(paths.maintenancePending)) return "none";
+  let release: () => Promise<void>;
+  try {
+    release = await acquireManagedOperationLock(paths);
+  } catch {
+    // A live install/update/uninstall owns the gate; leave it alone.
+    return "kept";
+  }
+  try {
+    let marker: MaintenanceMarker | null;
+    try {
+      marker = await readMaintenanceMarker(paths);
+    } catch {
+      return "kept";
+    }
+    if (!marker || marker.phase !== "checking") return "kept";
+    await removeDurably(paths.maintenancePending);
+    return "cleared";
+  } finally {
+    await release();
+  }
 }
 
 /**
@@ -1448,7 +1498,21 @@ export async function removeManagedRuntime(
     // before inspecting SQLite; taskUp writes `starting` before its final gate
     // check. Whichever arrives second observes the first, so teardown cannot
     // begin while an unrecorded task proceeds into Docker side effects.
-    if (!(await options.canRemove())) {
+    let removable: boolean;
+    try {
+      removable = await options.canRemove();
+    } catch (error) {
+      if (marker.phase === "checking") {
+        // The check itself failed, so no teardown began — leaving the gate
+        // behind here poisoned every taskUp/channelEnsure with a silent
+        // retryable refusal until an operator found the file (live
+        // 2026-08-18, twice). Same safety argument as the busy refusal
+        // below: reopen admission, keep the error.
+        await removeDurably(paths.maintenancePending);
+      }
+      throw error;
+    }
+    if (!removable) {
       if (marker.phase === "checking") {
         // No teardown began, so this ordinary busy refusal may safely reopen
         // admission. A retry of a previously-started teardown stays fail-closed.

package/lib/orchestrator.ts

@@ -111,7 +111,10 @@ import {
   type ResolvedEngineAccount,
 } from "./engine-accounts";
 import { clearTaskGatewayAcl, setupMcpTaskConfig } from "./mcp-gateway";
-import { stopPreviewSidecars } from "./preview-sidecar";
+import {
+  PREVIEW_SIDECAR_TASK_LABEL,
+  stopPreviewSidecars,
+} from "./preview-sidecar";
 import {
   agentClisReady,
   standardImageCorepackVersionPath,
@@ -4110,8 +4113,12 @@ async function dockerStart(containerName: string): Promise<DockerStartResult> {
   return "failed";
 }
 
+// The fourth column is the preview-sidecar marker: a sidecar can wear the
+// task's compose labels, and a row that is neither app-shaped nor a known
+// sidecar reads as AMBIGUOUS here — which fenced maintenance on a healthy
+// host (live 2026-08-18).
 const RUNTIME_WRITER_LIST_FORMAT =
-  '{{json .Names}}\t{{.Label "com.docker.compose.project"}}\t{{.Label "com.docker.compose.service"}}';
+  `{{json .Names}}\t{{.Label "com.docker.compose.project"}}\t{{.Label "com.docker.compose.service"}}\t{{.Label "${PREVIEW_SIDECAR_TASK_LABEL}"}}`;
 const RUNTIME_WRITER_INSPECT_FORMAT = [
   "{{json .Id}}",
   "{{json .Name}}",
@@ -4233,10 +4240,12 @@ async function listRuntimeWriterCandidates(): Promise<
   for (const rawLine of listed.stdout.split(/\r?\n/)) {
     if (!rawLine) continue;
     const fields = rawLine.split("\t");
-    if (fields.length !== 3) {
+    if (fields.length !== 4) {
       ambiguous = true;
       continue;
     }
+    // A preview sidecar is a known non-writer, not an ambiguity.
+    if (fields[3] !== "") continue;
     let name: unknown;
     try {
       name = JSON.parse(fields[0]!);

package/lib/preview-sidecar.ts

@@ -21,7 +21,17 @@ import { inspectTunnelContainer } from "./tunnel-runtime";
 
 /** Port the proxy listens on inside the sidecar (published to a random host port). */
 const INNER_PORT = 9000;
-const LABEL = "com.runuai.preview-sidecar.task";
+/**
+ * Exported for every "which container is the task's APP" scan: sidecars can
+ * legitimately wear the task's compose project/service labels (teardown
+ * finds them by project), so any container carrying THIS label must be
+ * excluded before counting app containers. Live 2026-08-18: one browser
+ * sidecar with compose labels made legacy adoption count two app containers
+ * and fail the whole runtime selection closed — every task on the host read
+ * as "still starting".
+ */
+export const PREVIEW_SIDECAR_TASK_LABEL = "com.runuai.preview-sidecar.task";
+const LABEL = PREVIEW_SIDECAR_TASK_LABEL;
 const TARGET_LABEL = "com.runuai.preview-sidecar.target";
 
 /** (taskId,name,containerPort) -> published 127.0.0.1 host port of a live sidecar. */

package/lib/task-environment/docker.ts

@@ -16,6 +16,7 @@ import {
 } from "../agent";
 import { dockerCli, type DockerResult } from "../docker-exec";
 import { taskDir } from "../env";
+import { PREVIEW_SIDECAR_TASK_LABEL } from "../preview-sidecar";
 import { assertSafeHostTaskId } from "../task-identity";
 import {
   assertTaskEnvironmentProcessRequest,
@@ -868,8 +869,12 @@ function taskStatusToEnvironmentStatus(
   };
 }
 
+// The fourth column is the preview-sidecar marker: a sidecar wearing the
+// task's compose labels must read as "not the app", not as malformed
+// identity data — the latter turned a healthy running task's status into
+// "unknown" (live 2026-08-18).
 const DOCKER_STATUS_FORMAT =
-  '{{.Names}}\t{{.Label "com.docker.compose.project"}}\t{{.State}}';
+  `{{.Names}}\t{{.Label "com.docker.compose.project"}}\t{{.State}}\t{{.Label "${PREVIEW_SIDECAR_TASK_LABEL}"}}`;
 
 async function inspectDockerTaskEnvironmentStatus(
   docker: typeof dockerCli,
@@ -897,14 +902,20 @@ async function inspectDockerTaskEnvironmentStatus(
 
   let state: string | undefined;
   for (const raw of result.stdout.split(/\r?\n/)) {
-    const line = raw.trim();
-    if (!line) continue;
-    const [name, project, candidateState, ...extra] = line.split("\t");
+    // No trim before splitting: the app row's LAST column (the sidecar
+    // marker) is empty, and trimming would eat its tab and shift the shape.
+    if (!raw.trim()) continue;
+    const [name, project, candidateState, sidecar, ...extra] = raw.split("\t");
+    // A preview sidecar wearing the task's compose labels is not the app
+    // container; skipping it keeps a healthy task from reading as unknown.
+    if (sidecar !== undefined && sidecar !== "") continue;
     if (
       state !== undefined ||
       name !== environment.containerName ||
       project !== environment.composeProject ||
       !candidateState ||
+      !candidateState.trim() ||
+      sidecar === undefined ||
       extra.length > 0
     ) {
       return {

package/lib/task-environment/legacy-adoption.ts

@@ -5,6 +5,7 @@ import { eq } from "drizzle-orm";
 import { dockerCli, type DockerResult } from "../docker-exec";
 import { getDb, schema, type HostTask } from "../db";
 import { parsePreviewPortRuntimes } from "../preview-ports";
+import { PREVIEW_SIDECAR_TASK_LABEL } from "../preview-sidecar";
 import { assertSafeHostTaskId } from "../task-identity";
 import {
   APPLE_TASK_ENVIRONMENT_PROVIDER,
@@ -26,7 +27,11 @@ const INSPECT_OUTPUT_LIMIT = 128 * 1024;
 const INVENTORY_OUTPUT_LIMIT = 128 * 1024;
 const LEGACY_INSPECT_FORMAT =
   '{{json .Id}}\t{{json .Name}}\t{{json (index .Config.Labels "com.docker.compose.project")}}\t{{json (index .Config.Labels "com.docker.compose.service")}}\t{{json .State.Status}}\t{{json .Mounts}}';
-const LEGACY_INVENTORY_FORMAT = "{{.ID}}\t{{.Names}}";
+// The third column is the preview-sidecar marker: a sidecar can wear the
+// task's compose project/service labels (teardown finds it by project), so
+// the app-container census must see and skip it — counting one as an app
+// container failed the WHOLE runtime adoption closed (live 2026-08-18).
+const LEGACY_INVENTORY_FORMAT = `{{.ID}}\t{{.Names}}\t{{.Label "${PREVIEW_SIDECAR_TASK_LABEL}"}}`;
 
 type LegacyTaskRow = Pick<
   HostTask,
@@ -317,27 +322,38 @@ async function proveNoConflictingAppContainer(
   ) {
     throw new Error(`task ${candidate.row.taskId} app inventory failed`);
   }
+  if (result.stdout !== "" && !result.stdout.endsWith("\n")) {
+    throw new Error(`task ${candidate.row.taskId} app inventory failed`);
+  }
+  const appRows: string[][] = [];
+  for (const line of result.stdout === ""
+    ? []
+    : result.stdout.slice(0, -1).split("\n")) {
+    const fields = line.split("\t");
+    if (fields.length !== 3) {
+      throw new Error(`task ${candidate.row.taskId} app inventory failed`);
+    }
+    // A preview sidecar wearing the task's compose labels is not an app
+    // container; counting one here failed the whole runtime adoption closed
+    // (live 2026-08-18, six labeled browser sidecars on the Studio).
+    if (fields[2] !== "") continue;
+    appRows.push(fields);
+  }
   if (expected === null) {
     // The exact container is proven absent; adoption is sound only if no
-    // same-project replacement exists either (an empty inventory prints
-    // nothing at all).
-    if (result.stdout !== "") {
+    // same-project replacement exists either.
+    if (appRows.length !== 0) {
       throw new Error(
         `task ${candidate.row.taskId} has conflicting app containers`,
       );
     }
     return;
   }
-  if (!result.stdout.endsWith("\n")) {
-    throw new Error(`task ${candidate.row.taskId} app inventory failed`);
-  }
-  const lines = result.stdout.slice(0, -1).split("\n");
-  if (lines.length !== 1) {
+  if (appRows.length !== 1) {
     throw new Error(`task ${candidate.row.taskId} has conflicting app containers`);
   }
-  const fields = lines[0]!.split("\t");
+  const fields = appRows[0]!;
   if (
-    fields.length !== 2 ||
     fields[0] !== expected.containerId ||
     fields[1] !== expected.containerName
   ) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@runuai/host",
-  "version": "0.9.42",
+  "version": "0.9.44",
   "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/src/index.ts

@@ -75,7 +75,7 @@ import {
 } from "../lib/preview-sidecar";
 import { inspectTunnelContainer } from "../lib/tunnel-runtime";
 import { ContainerRuntimeUnavailableError } from "../lib/runtime-guard";
-import { managedRuntimeAdmissionPending } from "../lib/managed-runtime";
+import { managedRuntimeAdmissionBlocker } from "../lib/managed-runtime";
 import { retireTaskSshIdentityEnsures } from "../lib/git-identity";
 import { removeTaskIdentityStrict } from "../lib/ssh";
 import { proveOrphanTaskResourcesAbsent } from "../lib/task-inventory";
@@ -1346,8 +1346,20 @@ function boundedFailureMessage(error: unknown): string {
 }
 
 /** Managed installation, activation, and uninstall drain instead of admitting work. */
+let lastAdmissionRefusalLogAt = 0;
 function managedMaintenanceUnavailable(): HostCommandResult<never> | null {
-  if (!managedRuntimeAdmissionPending()) return null;
+  const blocker = managedRuntimeAdmissionBlocker();
+  if (blocker === null) return null;
+  // A refusal must NAME its gate somewhere an operator can find it. Three
+  // stacked silent refusals cost hours live (2026-08-18); rate-limited so a
+  // retrying cloud cannot flood the log.
+  const now = Date.now();
+  if (now - lastAdmissionRefusalLogAt > 60_000) {
+    lastAdmissionRefusalLogAt = now;
+    console.warn(
+      `[host-agent] refusing task admission: managed-maintenance marker present at ${blocker}`,
+    );
+  }
   return {
     ok: false,
     code: HostErrorCode.HostUnavailable,

package/src/main.ts

@@ -127,7 +127,11 @@ import {
   onChange as onRegistryChange,
 } from "../lib/agents/registry";
 import { canAdvertiseTypedSecretaryDispatch } from "../lib/agents/mode";
-import { MANAGED_UPDATE_RESTART_EXIT_CODE } from "../lib/managed-runtime";
+import {
+  MANAGED_UPDATE_RESTART_EXIT_CODE,
+  managedRuntimeAdmissionBlocker,
+  reclaimAbandonedMaintenanceCheck,
+} from "../lib/managed-runtime";
 import { ManagedOperationDrain } from "../lib/managed-operation-drain";
 import {
   createHostLogManager,
@@ -371,6 +375,27 @@ interface PausableSource {
 }
 
 console.log(`[host-agent] starting host ${hostId}`);
+// Self-heal the recurring silent admission gate BEFORE anything can refuse
+// work: an uninstall/update helper that died at phase "checking" (live
+// 2026-08-11 + twice 2026-08-18) left every taskUp/channelEnsure bouncing
+// retryably with no feedback. Only a provably-untorn "checking" marker is
+// reclaimed; anything else stays fail-closed and is NAMED in the log.
+try {
+  const reclaim = await reclaimAbandonedMaintenanceCheck();
+  if (reclaim === "cleared") {
+    console.warn(
+      "[host-agent] cleared an abandoned maintenance marker (a managed uninstall/update died before any teardown); task admission reopened",
+    );
+  } else if (reclaim === "kept") {
+    console.warn(
+      `[host-agent] task admission is CLOSED by a managed-maintenance marker: ${managedRuntimeAdmissionBlocker() ?? "(marker path unavailable)"} — retry the pending uninstall/update or remove the marker to reopen`,
+    );
+  }
+} catch (error) {
+  console.warn(
+    `[host-agent] abandoned-maintenance reclaim failed: ${error instanceof Error ? error.message : String(error)}`,
+  );
+}
 migrateHostDb();
 // Reconcile a durable retention-off setting before recovery/connect can make
 // crash-left owner-facing terminal history observable again. Correctness