@runuai/host 0.9.78 → 0.9.79

package/images/standard/container/uai-init

@@ -419,9 +419,25 @@ install_folder_deps() {
 
 reject_workspace_runtime_shadow || exit 78
 
-if [ -d "$WORKSPACE" ] && [ -f "$RUNTIME_PROJECTS" ] \
-   && [ ! -L "$RUNTIME_PROJECTS" ]; then
-  seen_runtime_projects="|"
+# ADR-122: dependency installs leave the task-start critical path. The loop
+# below runs in a DETACHED background process so uai-init (and with it
+# task-up) returns as soon as the cheap, provable work is done — the editor
+# and the agents start immediately, warm or cold. Progress is observable in
+# the workspace itself:
+#
+#   $WORKSPACE/.uai/init/deps-status   running | done | failed | authority-violation
+#   $WORKSPACE/.uai/init/deps.log      the full install transcript
+#
+# The runtime-authority posture narrows deliberately: the synchronous
+# workspace-shadow proofs above and below still exit 78 (task-up
+# quarantines), but a shadow that APPEARS MID-INSTALL can no longer stop the
+# task — agents are already running by then, and an agent could author the
+# same shadow a second later anyway. The runner still refuses to run any
+# further dependency command under a shadowed root and records
+# `authority-violation`; the shared asdf volume stays read-only-proven
+# regardless.
+run_workspace_installs() {
+  local seen_runtime_projects="|" project_slug folder git_marker
   while IFS= read -r project_slug || [ -n "$project_slug" ]; do
     if [[ ! "$project_slug" =~ ^[a-z0-9-]{1,64}$ ]]; then
       log "warning: unsafe runtime-project allowlist entry — skipping"
@@ -441,11 +457,67 @@ if [ -d "$WORKSPACE" ] && [ -f "$RUNTIME_PROJECTS" ] \
       log "warning: allowlisted project $project_slug is not a safe Git worktree — skipping"
       continue
     fi
-    reject_workspace_runtime_shadow || exit 78
+    if ! reject_workspace_runtime_shadow; then
+      printf 'authority-violation\n' > "$deps_status_file"
+      return 78
+    fi
     # Run in a subshell so a `cd` (or a failing command under the relaxed
     # error mode) in one folder never leaks into the next.
     ( install_folder_deps "$folder" )
   done < "$RUNTIME_PROJECTS"
+  return 0
+}
+
+if [ -d "$WORKSPACE" ] && [ -f "$RUNTIME_PROJECTS" ] \
+   && [ ! -L "$RUNTIME_PROJECTS" ]; then
+  deps_state_dir="$WORKSPACE/.uai/init"
+  deps_status_file="$deps_state_dir/deps-status"
+  deps_log_file="$deps_state_dir/deps.log"
+  deps_lock_dir="$deps_state_dir/deps.lock.d"
+  mkdir -p "$deps_state_dir"
+
+  # One runner at a time. uai-init is re-runnable (task-up retry, recovery),
+  # and each re-run SHOULD refresh dependencies — but never concurrently.
+  # mkdir is the portable atomic lock; a pid that no longer answers marks a
+  # crashed runner whose lock is stale and may be stolen.
+  deps_spawn=1
+  if mkdir "$deps_lock_dir" 2>/dev/null; then
+    # Hold the lock as ourselves until the runner's pid replaces it, so a
+    # concurrent uai-init never reads an empty pid file as a stale lock.
+    printf '%s\n' "$$" > "$deps_lock_dir/pid"
+  else
+    deps_holder=$(cat "$deps_lock_dir/pid" 2>/dev/null || true)
+    if [ -n "$deps_holder" ] && kill -0 "$deps_holder" 2>/dev/null; then
+      log "dependency install already running (pid $deps_holder) — leaving it be"
+      deps_spawn=0
+    else
+      rm -rf "$deps_lock_dir"
+      if mkdir "$deps_lock_dir" 2>/dev/null; then
+        printf '%s\n' "$$" > "$deps_lock_dir/pid"
+      else
+        log "warning: could not acquire the dependency install lock — skipping installs"
+        deps_spawn=0
+      fi
+    fi
+  fi
+  if [ "$deps_spawn" -eq 1 ]; then
+    printf 'running\n' > "$deps_status_file"
+    log "installing workspace dependencies in the background (status: $deps_status_file, log: $deps_log_file)"
+    (
+      trap 'rm -rf "$deps_lock_dir"' EXIT
+      deps_rc=0
+      run_workspace_installs || deps_rc=$?
+      if [ "$deps_rc" -eq 0 ]; then
+        printf 'done\n' > "$deps_status_file"
+        log "workspace dependency install complete"
+      elif [ "$deps_rc" -ne 78 ]; then
+        printf 'failed\n' > "$deps_status_file"
+        log "workspace dependency install failed (exit $deps_rc)"
+      fi
+    ) >>"$deps_log_file" 2>&1 </dev/null &
+    printf '%s\n' "$!" > "$deps_lock_dir/pid"
+    disown
+  fi
 elif [ ! -d "$WORKSPACE" ]; then
   log "workspace $WORKSPACE missing — scratchpad/no-project task, skipping installs"
 else

package/lib/vnode-pressure.ts

@@ -0,0 +1,103 @@
+/**
+ * ADR-118 follow-up: the macOS vnode-table pressure sensor.
+ *
+ * Apple's Virtualization.framework virtiofs pins one host vnode per distinct
+ * guest-touched file for the life of the task VM (~12k per task after
+ * ADR-118 moved the pnpm store off virtiofs; ~130k+ before it). The table
+ * ceiling (`kern.maxvnodes`) is a boot-time default the host cannot raise
+ * without root, and AT the ceiling unrelated host software starts failing
+ * with ENFILE — the suspected 2026-08-24 kernel-panic precursor.
+ *
+ * Three surfaces ride this module:
+ *  - `readVnodePressure()` — the sensor (cached; null off-macOS).
+ *  - `vnodeAdmissionProblem()` — task-up guard: refuse to start ANOTHER
+ *    apple-container VM above the threshold instead of letting the kernel
+ *    hit the wall. Existing tasks keep running.
+ *  - `logVnodePressure()` — periodic observability, warn-level near the
+ *    ceiling so host logs explain refusals before they happen.
+ *
+ * Raising the ceiling needs root once: `sudo uai-host tune` (see cli.ts)
+ * installs a LaunchDaemon that reasserts the sysctls at every boot —
+ * sysctl writes alone are ephemeral.
+ */
+
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+
+const exec = promisify(execFile);
+
+/** Refuse NEW apple task VMs above this fraction of the vnode ceiling. */
+const ADMISSION_THRESHOLD = 0.9;
+/** Warn-log above this fraction. */
+const WARN_THRESHOLD = 0.8;
+const CACHE_MS = 15_000;
+
+export interface VnodePressure {
+  current: number;
+  max: number;
+  ratio: number;
+}
+
+let cached: { at: number; value: VnodePressure | null } | null = null;
+
+export async function readVnodePressure(): Promise<VnodePressure | null> {
+  if (process.platform !== "darwin") return null;
+  if (cached && Date.now() - cached.at < CACHE_MS) return cached.value;
+  let value: VnodePressure | null = null;
+  try {
+    const { stdout } = await exec(
+      "/usr/sbin/sysctl",
+      ["-n", "kern.num_vnodes", "kern.maxvnodes"],
+      { timeout: 5_000 },
+    );
+    const parts = stdout.trim().split(/\s+/).map(Number);
+    const current = parts[0] ?? Number.NaN;
+    const max = parts[1] ?? Number.NaN;
+    if (Number.isFinite(current) && Number.isFinite(max) && max > 0) {
+      value = { current, max, ratio: current / max };
+    }
+  } catch {
+    // Sensor failure is never a task failure; admission simply has no data.
+  }
+  cached = { at: Date.now(), value };
+  return value;
+}
+
+/** Non-null = refuse to start another apple-container task VM right now. */
+export async function vnodeAdmissionProblem(): Promise<string | null> {
+  const pressure = await readVnodePressure();
+  if (!pressure || pressure.ratio < ADMISSION_THRESHOLD) return null;
+  return (
+    `the macOS vnode table is at ${Math.round(pressure.ratio * 100)}% ` +
+    `(${pressure.current}/${pressure.max}); starting another task VM risks ` +
+    "system-wide file-table exhaustion. Close a running task, or raise the " +
+    "ceiling once with: sudo uai-host tune"
+  );
+}
+
+let lastLoggedBand: "ok" | "warn" | "critical" = "ok";
+
+/** Log on band TRANSITIONS only, so a host sitting near the ceiling does not
+ * spam its own log every interval. */
+export async function logVnodePressure(): Promise<void> {
+  const pressure = await readVnodePressure();
+  if (!pressure) return;
+  const band =
+    pressure.ratio >= ADMISSION_THRESHOLD
+      ? "critical"
+      : pressure.ratio >= WARN_THRESHOLD
+        ? "warn"
+        : "ok";
+  if (band === lastLoggedBand) return;
+  lastLoggedBand = band;
+  const detail = `${pressure.current}/${pressure.max} (${Math.round(pressure.ratio * 100)}%)`;
+  if (band === "critical") {
+    console.warn(
+      `[vnode] table at ${detail} — new apple task VMs will be refused; run: sudo uai-host tune`,
+    );
+  } else if (band === "warn") {
+    console.warn(`[vnode] table filling: ${detail}`);
+  } else {
+    console.log(`[vnode] table pressure back to normal: ${detail}`);
+  }
+}

package/package.json

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

package/src/cli.ts

@@ -22,7 +22,7 @@ import "./load-env";
 
 import { spawn, spawnSync } from "node:child_process";
 import { createHash, randomBytes } from "node:crypto";
-import { existsSync, mkdirSync, readFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { homedir, hostname } from "node:os";
 import { dirname, join, resolve } from "node:path";
 
@@ -137,6 +137,8 @@ async function main(): Promise<void> {
       return cmdLogs(follow);
     case "runtime":
       return cmdRuntime(rest);
+    case "tune":
+      return cmdTune();
     case "update":
       return cmdUpdate(rest);
     case "rollback":
@@ -498,6 +500,139 @@ async function boundedResponseJson(
 
 // --- runtime ---------------------------------------------------------------
 
+// --- tune (ADR-118 follow-up: vnode/file-table ceilings) ---------------------
+
+const TUNE_DAEMON_LABEL = "com.runuai.tune";
+const TUNE_DAEMON_PLIST = `/Library/LaunchDaemons/${TUNE_DAEMON_LABEL}.plist`;
+/** Floors, not targets — an operator-raised ceiling is never lowered. Each
+ * apple-container task VM pins host vnodes for its life (~12k after ADR-118,
+ * far more during dependency churn), and the boot defaults sit low enough
+ * that two heavy tasks have filled the table live (2026-08-25). ~2M vnodes
+ * is roughly half a GB of kernel memory IF fully populated. */
+const TUNE_MAXVNODES_FLOOR = 2_097_152;
+const TUNE_MAXFILES_FLOOR = 2_097_152;
+const TUNE_MAXFILESPERPROC_FLOOR = 1_048_576;
+
+function readSysctlNumber(name: string): number | null {
+  const res = spawnSync("/usr/sbin/sysctl", ["-n", name], {
+    encoding: "utf8",
+  });
+  const value = Number((res.stdout ?? "").trim());
+  return res.status === 0 && Number.isFinite(value) ? value : null;
+}
+
+function tunePlistContent(settings: Array<[string, number]>): string {
+  const args = ["/usr/sbin/sysctl", ...settings.map(([k, v]) => `${k}=${v}`)]
+    .map((a) => `    <string>${a}</string>`)
+    .join("\n");
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${TUNE_DAEMON_LABEL}</string>
+  <key>ProgramArguments</key>
+  <array>
+${args}
+  </array>
+  <key>RunAtLoad</key>
+  <true/>
+</dict>
+</plist>
+`;
+}
+
+async function cmdTune(): Promise<void> {
+  if (process.platform !== "darwin") {
+    console.error(red("tune is macOS-only (apple-container task VMs)"));
+    process.exitCode = 1;
+    return;
+  }
+  const current = {
+    maxvnodes: readSysctlNumber("kern.maxvnodes"),
+    maxfiles: readSysctlNumber("kern.maxfiles"),
+    maxfilesperproc: readSysctlNumber("kern.maxfilesperproc"),
+  };
+  if (
+    current.maxvnodes === null ||
+    current.maxfiles === null ||
+    current.maxfilesperproc === null
+  ) {
+    console.error(red("could not read the current kernel limits via sysctl"));
+    process.exitCode = 1;
+    return;
+  }
+  // Order matters at apply time: maxfilesperproc must stay <= maxfiles.
+  const settings: Array<[string, number]> = [
+    ["kern.maxfiles", Math.max(current.maxfiles, TUNE_MAXFILES_FLOOR)],
+    [
+      "kern.maxfilesperproc",
+      Math.max(current.maxfilesperproc, TUNE_MAXFILESPERPROC_FLOOR),
+    ],
+    ["kern.maxvnodes", Math.max(current.maxvnodes, TUNE_MAXVNODES_FLOOR)],
+  ];
+  const desiredPlist = tunePlistContent(settings);
+  const plistCurrent = existsSync(TUNE_DAEMON_PLIST)
+    ? readFileSync(TUNE_DAEMON_PLIST, "utf8")
+    : null;
+  const changes = settings.filter(
+    ([key, value]) => value !== current[key.slice("kern.".length) as keyof typeof current],
+  );
+  if (changes.length === 0 && plistCurrent === desiredPlist) {
+    const summary = settings.map(([k, v]) => `${k}=${v}`).join(" ");
+    console.log(`already tuned (${summary}); boot persistence in place`);
+    return;
+  }
+
+  if (typeof process.getuid !== "function" || process.getuid() !== 0) {
+    console.log(`${bold("uai-host tune")} will (needs sudo):`);
+    for (const [key, value] of changes) {
+      console.log(
+        `  raise ${key}: ${current[key.slice("kern.".length) as keyof typeof current]} -> ${value}`,
+      );
+    }
+    console.log(
+      `  install ${TUNE_DAEMON_PLIST} so the limits survive reboots`,
+    );
+    console.log(`\nrun: ${cyan("sudo uai-host tune")}`);
+    process.exitCode = 1;
+    return;
+  }
+
+  for (const [key, value] of settings) {
+    const res = spawnSync("/usr/sbin/sysctl", [`${key}=${value}`], {
+      encoding: "utf8",
+    });
+    if (res.status !== 0) {
+      console.error(
+        red(`sysctl ${key}=${value} failed: ${(res.stderr ?? "").trim()}`),
+      );
+      process.exitCode = 1;
+      return;
+    }
+  }
+  writeFileSync(TUNE_DAEMON_PLIST, desiredPlist, { mode: 0o644 });
+  spawnSync("/usr/sbin/chown", ["root:wheel", TUNE_DAEMON_PLIST]);
+  // Re-bootstrap so launchd owns the daemon under its current definition.
+  spawnSync("/bin/launchctl", ["bootout", `system/${TUNE_DAEMON_LABEL}`]);
+  const bootstrap = spawnSync(
+    "/bin/launchctl",
+    ["bootstrap", "system", TUNE_DAEMON_PLIST],
+    { encoding: "utf8" },
+  );
+  if (bootstrap.status !== 0) {
+    console.error(
+      red(
+        `limits applied, but launchctl bootstrap failed (${(bootstrap.stderr ?? "").trim()}) — they will not survive a reboot`,
+      ),
+    );
+    process.exitCode = 1;
+    return;
+  }
+  const summary = settings.map(([k, v]) => `${k}=${v}`).join(" ");
+  console.log(`tuned: ${summary} (persisted via ${TUNE_DAEMON_PLIST})`);
+}
+
 async function cmdRuntime(rest: string[]): Promise<void> {
   if (rest[0] === "begin-install") {
     return cmdBeginRuntimeInstall(rest.slice(1));
@@ -1882,6 +2017,8 @@ function printHelp(): void {
   status               connection, service info, active tasks (same as the UI)
   logs [--follow]      tail the service log
   runtime recheck      probe Docker again and refresh cloud capabilities
+  tune                 (macOS, sudo) raise kernel vnode/file-table ceilings for
+                       apple-container task VMs and persist them across boots
   setup --cloud <wss-url> --enroll <token>
                        claim this machine via an enrollment token from the web
                        app (mints + writes the host credential); on an

package/src/index.ts

@@ -70,10 +70,12 @@ import {
   containerRuntimeTeardownProblem,
   ensureContainerRuntimeForTask,
   initializeContainerRuntime,
+  pinnedContainerRuntimeProvider,
   reprobeContainerRuntimeMachineIdentity,
   suspendContainerRuntime,
   waitForContainerRuntimeOperational,
 } from "../lib/container-runtime";
+import { vnodeAdmissionProblem } from "../lib/vnode-pressure";
 import {
   provisionTaskEnvironment,
   reconstructPersistedTaskEnvironment,
@@ -264,6 +266,21 @@ export const hostCommands: HostCommands = {
     if (readyAdmissionFailure) return readyAdmissionFailure;
     const readyRuntimeFailure = runtimeUnavailable();
     if (readyRuntimeFailure) return readyRuntimeFailure;
+    // ADR-118 follow-up: each apple-container task is its own VM, and each
+    // VM pins host vnodes for its life. Refuse to start ANOTHER one when the
+    // table is nearly full — a clear, retryable refusal now beats ENFILE
+    // storms (and the suspected panic path) for the whole machine later.
+    if (pinnedContainerRuntimeProvider() === "apple-container") {
+      const vnodeProblem = await vnodeAdmissionProblem();
+      if (vnodeProblem) {
+        return {
+          ok: false,
+          code: HostErrorCode.HostUnavailable,
+          message: vnodeProblem,
+          retryable: true,
+        };
+      }
+    }
     const orchestrator = getOrchestrator();
     return orchestrator.runTaskLifecycle(input.task.id, async () => {
       // A direct duplicate teardown may still be draining operations that

package/src/main.ts

@@ -110,6 +110,7 @@ import {
   publishActivationPhase,
 } from "../lib/container-runtime";
 import { reconstructPersistedTaskEnvironment } from "../lib/task-environment";
+import { logVnodePressure } from "../lib/vnode-pressure";
 import { resolveAppleTunnelRoute } from "./apple-tunnel-route";
 import {
   configureBundledContainerRuntime,
@@ -516,6 +517,11 @@ void connect();
 // Local browser UI (ADR-028) — same single process, alongside the WSS client.
 // Best-effort: a UI bind failure must not take the host service down.
 void startLocalUi();
+// ADR-118 follow-up: vnode-pressure observability (macOS/apple-container
+// hosts). Logs only on band transitions; the sensor caches its sysctl read.
+const vnodePressureTimer = setInterval(() => void logVnodePressure(), 60_000);
+vnodePressureTimer.unref?.();
+void logVnodePressure();
 
 async function startLocalUi(): Promise<void> {
   try {