@runuai/host 0.9.43 → 0.9.45

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

@@ -1,6 +1,6 @@
 {
   "name": "@runuai/host",
-  "version": "0.9.43",
+  "version": "0.9.45",
   "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,10 @@ 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,
+  reclaimAbandonedMaintenanceCheck,
+} from "../lib/managed-runtime";
 import { retireTaskSshIdentityEnsures } from "../lib/git-identity";
 import { removeTaskIdentityStrict } from "../lib/ssh";
 import { proveOrphanTaskResourcesAbsent } from "../lib/task-inventory";
@@ -1346,8 +1349,51 @@ function boundedFailureMessage(error: unknown): string {
 }
 
 /** Managed installation, activation, and uninstall drain instead of admitting work. */
+let lastAdmissionRefusalLogAt = 0;
+let lastAdmissionReclaimAt = 0;
+let admissionReclaimInFlight: Promise<"cleared" | "kept" | "none"> | null =
+  null;
 function managedMaintenanceUnavailable(): HostCommandResult<never> | null {
-  if (!managedRuntimeAdmissionPending()) return null;
+  const blocker = managedRuntimeAdmissionBlocker();
+  if (blocker === null) return null;
+  const now = Date.now();
+  // Mid-run self-heal (the abandoned-uninstall marker recurred WHILE the
+  // service was up, 2026-08-19 — boot-time reclaim alone cannot cover a
+  // writer on a schedule). Reclaim only ever touches a provably-untorn
+  // "checking" marker, under the operation lock; rate-limited so the
+  // cloud's retry hammer cannot churn the lock. The command that observed
+  // the marker still refuses — the NEXT retry finds admission open.
+  if (now - lastAdmissionReclaimAt > 30_000 && !admissionReclaimInFlight) {
+    lastAdmissionReclaimAt = now;
+    admissionReclaimInFlight = reclaimAbandonedMaintenanceCheck();
+    void admissionReclaimInFlight
+      .then((verdict) => {
+        if (verdict === "cleared") {
+          console.warn(
+            "[host-agent] cleared an abandoned maintenance marker mid-run (a managed uninstall/update died before any teardown); task admission reopened",
+          );
+        }
+      })
+      .catch((error) => {
+        console.warn(
+          `[host-agent] mid-run maintenance-marker reclaim failed: ${
+            error instanceof Error ? error.message : String(error)
+          }`,
+        );
+      })
+      .finally(() => {
+        admissionReclaimInFlight = 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.
+  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