@runuai/host 0.9.115 → 0.9.116

package/lib/env.ts

@@ -57,6 +57,10 @@ const schema = z.object({
   // ADR-135: the broker Lambda a Uai-operated host invokes for a reactive
   // refresh (name or ARN). Unset = scheduled refreshes only.
   UAI_TOKEN_BROKER_FUNCTION: z.string().min(1).optional(),
+  // Who keeps the standard image and agent CLIs current. `host` (owned hosts):
+  // this process, hourly. `external` (Uai-operated hosts): a cloud job keeps
+  // the payload AMI fresh and this host only reconciles once at start.
+  UAI_IMAGE_MAINTENANCE: z.enum(["host", "external"]).default("host"),
   NODE_ENV: z
     .enum(["development", "production", "test"])
     .default("development"),

package/lib/standard-image.ts

@@ -1128,21 +1128,54 @@ function markAgentClisReady(): void {
  * `{ ok, error? }` so the caller decides (boot: fire-and-forget; taskUp:
  * surface the reason). Resolves `agentClisReady` on every exit path.
  */
-export function ensureStandardImage(): Promise<StandardImageResult> {
+export function ensureStandardImage(
+  opts: { maxAgeMs?: number } = {},
+): Promise<StandardImageResult> {
+  // A task-up passes maxAgeMs: a pass that succeeded recently for the same
+  // engine configuration is reused instead of spending ~15 s spinning a
+  // maintenance container per task (live 2026-09-09: 16 s of every task
+  // start). The hourly schedule (main.ts) and the boot pass keep it fresh.
+  const engines = configuredOptionalEngines();
+  const key = optionalEngineConfigurationKey(engines);
+  const recent = lastOkByKey.get(key);
+  if (
+    opts.maxAgeMs !== undefined &&
+    recent !== undefined &&
+    Date.now() - recent.at <= opts.maxAgeMs
+  ) {
+    markAgentClisReady();
+    return Promise.resolve(recent.result);
+  }
   // Startup, runtime recovery, and a newly-arrived task can all discover the
   // same daemon transition. One shared volume repair/build must own that
   // window; concurrent maintenance containers can otherwise replace the same
   // CLI shims underneath each other and defeat agentClisReady's fence.
-  const engines = configuredOptionalEngines();
-  return ensureQueue.run(optionalEngineConfigurationKey(engines), () =>
-    ensureStandardImageInner(engines).finally(() => {
-      // Always signal — even a docker-down bail — so agent spawns never hang
-      // waiting on a reconcile that will not happen this boot.
-      markAgentClisReady();
-    }),
+  return ensureQueue.run(key, () =>
+    ensureStandardImageInner(engines)
+      .then((result) => {
+        if (result.ok) lastOkByKey.set(key, { at: Date.now(), result });
+        else lastOkByKey.delete(key);
+        return result;
+      })
+      .finally(() => {
+        // Always signal — even a docker-down bail — so agent spawns never hang
+        // waiting on a reconcile that will not happen this boot.
+        markAgentClisReady();
+      }),
   );
 }
 
+/** Last successful pass per engine configuration (in-process). */
+const lastOkByKey = new Map<string, { at: number; result: StandardImageResult }>();
+
+/** Tests: forget every remembered pass. */
+export function resetStandardImageMemo(): void {
+  lastOkByKey.clear();
+}
+
+/** The owned-host schedule (docs/agent-notes.md, "image maintenance"). */
+export const MAINTENANCE_INTERVAL_MS = 60 * 60_000;
+
 async function ensureStandardImageInner(
   engines: OptionalEngineConfiguration,
 ): Promise<StandardImageResult> {

package/package.json

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

package/src/index.ts

@@ -792,7 +792,10 @@ export const hostCommands: HostCommands = {
         // a real build only when missing/stale (Docker is definitely up now, a
         // task just arrived). On a build FAILURE, surface WHY to the cloud (not
         // just the host log — the operator can't read a remote user's machine).
-        const img = await ensureStandardImage();
+        // A pass that succeeded within the hour is reused (2026-09-09: the
+        // re-check cost 16 s of every task start); the hourly schedule in
+        // main.ts and the boot pass keep it fresh.
+        const img = await ensureStandardImage({ maxAgeMs: 60 * 60_000 });
         if (!img.ok) {
           throw new AgentError(
             "STANDARD_IMAGE_UNAVAILABLE",

package/src/main.ts

@@ -179,6 +179,7 @@ import {
 import "../lib/agents/factory";
 import {
   areAgentClisReady,
+  MAINTENANCE_INTERVAL_MS,
   configuredOptionalEngines,
   ensureStandardImage,
   onAgentClisReady,
@@ -468,6 +469,17 @@ void reconcileEngineAccountsFromStore({ hostId })
       `[engine-accounts] credential store reconcile failed: ${error instanceof Error ? error.message : String(error)}`,
     );
   });
+// Image + agent-CLI maintenance runs where the compute is owned: an owned
+// host keeps its own image current on an hourly schedule (a task-up reuses
+// the last pass instead of blocking on one); a Uai-operated host sets
+// UAI_IMAGE_MAINTENANCE=external — a cloud job keeps the payload AMI fresh —
+// and reconciles only once, at start.
+if (env.UAI_IMAGE_MAINTENANCE === "host") {
+  const maintenanceTimer = setInterval(() => {
+    void ensureStandardImage().catch(() => undefined);
+  }, MAINTENANCE_INTERVAL_MS);
+  maintenanceTimer.unref?.();
+}
 // ADR-135: one refresher per rotating credential. Owned host → the in-process
 // loop refreshes and re-pushes; Uai-operated host → the broker Lambda
 // refreshes and this host picks up changed parameter versions.