@omnicross/daemon 0.1.7 → 0.1.8

package/dist/cli.js

@@ -1750,15 +1750,15 @@ async function keysRevoke(db, id) {
 
 // src/commands/launch.ts
 import { spawn as spawn2 } from "child_process";
+import { randomUUID as randomUUID6 } from "crypto";
 import { existsSync as existsSync20 } from "fs";
 import { delimiter as delimiter2, join as join12 } from "path";
 import { parseArgs as parseArgs4 } from "util";
 import {
   buildChatCliLaunchConfig as buildChatCliLaunchConfig2,
-  buildClaudeCliLaunchConfig as buildClaudeCliLaunchConfig2,
-  buildCodexLaunchConfig as buildCodexLaunchConfig2,
   buildGeminiCliLaunchConfig as buildGeminiCliLaunchConfig2
 } from "@omnicross/cli-launcher";
+import { ROUTE_LEASE_REQUEST_SCHEMA as ROUTE_LEASE_REQUEST_SCHEMA2 } from "@omnicross/core/provider-proxy";
 
 // src/bootstrap.ts
 import { accessSync, constants as fsConstants, existsSync as existsSync19 } from "fs";
@@ -1774,7 +1774,7 @@ import {
   normalizeServerConfig
 } from "@omnicross/core/outbound-api";
 import { setSubscriptionRegistryForOutbound } from "@omnicross/core/outbound-api/subscriptionRegistryPort";
-import { getSharedAccountHealth as getSharedAccountHealth3 } from "@omnicross/core/pipeline/SubscriptionAccountHealth";
+import { getSharedAccountHealth as getSharedAccountHealth4 } from "@omnicross/core/pipeline/SubscriptionAccountHealth";
 import {
   __resetSharedAccountAllowanceStoreForTests,
   AccountAllowanceStore as AccountAllowanceStore3,
@@ -1782,15 +1782,18 @@ import {
 } from "@omnicross/core/pipeline/AccountAllowanceStore";
 import {
   __resetSharedAccountAllowanceSchedulingForTests,
-  getSharedAccountAllowanceScheduling as getSharedAccountAllowanceScheduling4
+  getSharedAccountAllowanceScheduling as getSharedAccountAllowanceScheduling5
 } from "@omnicross/core/pipeline/AccountAllowanceScheduling";
 import { fetchUpstream as fetchUpstream7, setUpstreamProxyResolver } from "@omnicross/core/pipeline/upstreamFetch";
 import { __resetSharedIdentityStoreForTests } from "@omnicross/core/provider-proxy/identity/SubscriptionIdentityStore";
 import { setGeminiCodeAssistResolver } from "@omnicross/core/ports/gemini-code-assist-resolver";
 import {
   __resetProviderProxyForTests,
-  getProviderProxy
+  getProviderProxy,
+  RouteLeaseManager,
+  RouteLeaseTargetResolver
 } from "@omnicross/core/provider-proxy";
+import { routeLeaseDescriptorPort } from "@omnicross/cli-launcher";
 import { KeySpendTracker } from "@omnicross/core/outbound-api";
 import { PricingEngine, UsageRecorder } from "@omnicross/core/usage";
 import {
@@ -2496,6 +2499,93 @@ async function handleWebhookTest(req, res) {
   res.end(JSON.stringify({ result }));
 }
 
+// src/admin/routeLeaseApi.ts
+import {
+  isLoopbackAddress,
+  normalizeRouteLeaseTtl,
+  ROUTE_LEASE_CAPABILITIES,
+  RouteLeaseError
+} from "@omnicross/core/provider-proxy";
+var MAX_BODY_BYTES = 64 * 1024;
+var SAFE_LEASE_ID = /^[A-Za-z0-9-]{1,128}$/u;
+async function readJson(req) {
+  const chunks = [];
+  let bytes = 0;
+  for await (const chunk of req) {
+    const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+    bytes += buffer.length;
+    if (bytes > MAX_BODY_BYTES) throw new RouteLeaseError("invalid_request", "request body is too large");
+    chunks.push(buffer);
+  }
+  if (chunks.length === 0) return {};
+  try {
+    return JSON.parse(Buffer.concat(chunks).toString("utf8"));
+  } catch {
+    throw new RouteLeaseError("invalid_request", "request body is not valid JSON");
+  }
+}
+function json(res, status, body, noStore = false) {
+  res.statusCode = status;
+  res.setHeader("Content-Type", "application/json");
+  if (noStore) res.setHeader("Cache-Control", "no-store");
+  res.end(JSON.stringify(body));
+}
+function leaseId(value) {
+  if (!value || !SAFE_LEASE_ID.test(value)) throw new RouteLeaseError("invalid_request", "lease id is invalid");
+  return value;
+}
+function header(req, name) {
+  const value = req.headers[name.toLowerCase()];
+  return Array.isArray(value) ? value[0] : value;
+}
+function writeError(res, error, noStore) {
+  const safe = error instanceof RouteLeaseError ? error : new RouteLeaseError("upstream_unavailable", "route lease operation failed safely");
+  if (safe.retryAfterSeconds !== void 0) res.setHeader("Retry-After", String(safe.retryAfterSeconds));
+  json(res, safe.status, safe.toResponse(), noStore);
+}
+async function handleRouteLeaseApi(req, res, path2, deps) {
+  const method = (req.method ?? "GET").toUpperCase();
+  const noStore = method === "POST" && (path2 === "/admin/api/route-leases" || path2.endsWith("/renew"));
+  try {
+    if (!isLoopbackAddress(req.socket.remoteAddress)) {
+      throw new RouteLeaseError("control_unauthorized", "route lease control plane is loopback only");
+    }
+    const manager = deps.routeLeaseManager;
+    if (!manager) throw new RouteLeaseError("daemon_not_ready", "route lease manager is unavailable");
+    const base = "/admin/api/route-leases";
+    const suffix = path2.slice(base.length).replace(/^\/+|\/+$/gu, "");
+    const segments = suffix ? suffix.split("/") : [];
+    if (segments.length === 1 && segments[0] === "capabilities") {
+      if (method !== "GET" && method !== "HEAD") throw new RouteLeaseError("invalid_request", "method is not allowed");
+      return json(res, 200, ROUTE_LEASE_CAPABILITIES);
+    }
+    if (segments.length === 0) {
+      if (method === "GET") return json(res, 200, { leases: manager.list() });
+      if (method === "POST") {
+        const outcome = await manager.createFromRequest(await readJson(req), header(req, "idempotency-key"));
+        return json(res, outcome.created ? 201 : 200, outcome.result, true);
+      }
+      throw new RouteLeaseError("invalid_request", "method is not allowed");
+    }
+    const id = leaseId(segments[0]);
+    if (segments.length === 1) {
+      if (method === "GET") return json(res, 200, manager.get(id));
+      if (method === "DELETE") return json(res, 200, manager.release(id));
+      throw new RouteLeaseError("invalid_request", "method is not allowed");
+    }
+    if (segments.length === 2 && segments[1] === "renew" && method === "POST") {
+      const body = await readJson(req);
+      const ttl = normalizeRouteLeaseTtl(
+        body && typeof body === "object" && !Array.isArray(body) ? body.ttlSeconds : void 0
+      );
+      return json(res, 200, manager.renew(id, ttl), true);
+    }
+    throw new RouteLeaseError("lease_not_found", "route lease endpoint was not found");
+  } catch (error) {
+    writeError(res, error, noStore);
+  }
+}
+
 // src/admin/adminApi.ts
 import http from "http";
 import {
@@ -3054,7 +3144,9 @@ async function exchangeGemini(code, codeVerifier, exchangeFetch) {
 // src/admin/cliLaunch.ts
 import { exec, spawn } from "child_process";
 import { randomUUID as randomUUID2 } from "crypto";
-import { existsSync as existsSync6 } from "fs";
+import { chmodSync as chmodSync3, existsSync as existsSync6, mkdtempSync, rmSync as rmSync2, writeFileSync as writeFileSync6 } from "fs";
+import { createServer } from "net";
+import { tmpdir } from "os";
 import { delimiter, join as join4 } from "path";
 import {
   buildChatCliLaunchConfig,
@@ -3062,6 +3154,33 @@ import {
   buildCodexLaunchConfig,
   buildGeminiCliLaunchConfig
 } from "@omnicross/cli-launcher";
+import {
+  ROUTE_LEASE_REQUEST_SCHEMA,
+  RouteLeaseError as RouteLeaseError2
+} from "@omnicross/core/provider-proxy";
+
+// src/routeLeaseRenewal.ts
+var TERMINAL_LEASE_TTL_SECONDS = 600;
+var TERMINAL_LEASE_RENEW_INTERVAL_MS = 5 * 60 * 1e3;
+var TERMINAL_LEASE_MAX_LIFETIME_MS = 24 * 60 * 60 * 1e3;
+function startTerminalLeaseRenewal(manager, leaseId2) {
+  const stopAt = Date.now() + TERMINAL_LEASE_MAX_LIFETIME_MS;
+  const timer = setInterval(() => {
+    if (Date.now() >= stopAt) {
+      clearInterval(timer);
+      return;
+    }
+    try {
+      manager.renew(leaseId2, TERMINAL_LEASE_TTL_SECONDS);
+    } catch {
+      clearInterval(timer);
+    }
+  }, TERMINAL_LEASE_RENEW_INTERVAL_MS);
+  timer.unref?.();
+  return () => clearInterval(timer);
+}
+
+// src/admin/cliLaunch.ts
 var LAUNCHABLE_CLIS = [
   { id: "claude", displayName: "Claude Code", command: "claude" },
   { id: "codex", displayName: "Codex CLI", command: "codex" },
@@ -3142,34 +3261,183 @@ async function buildLaunchEnv(cli, llmConfig, target) {
 function shq(s) {
   return `'${s.replace(/'/g, `'\\''`)}'`;
 }
-var defaultTerminalOpener = ({ cli, command, extraArgs, env, cwd, platform }) => {
+var MAC_TERMINAL_BOOTSTRAP_SOURCE = `
+'use strict';
+const fs = require('node:fs');
+const net = require('node:net');
+const { spawn } = require('node:child_process');
+const [socketPath, launchDir, cwd, command, ...args] = process.argv.slice(2);
+let payload = '';
+const socket = net.createConnection(socketPath);
+socket.setEncoding('utf8');
+socket.on('data', (chunk) => { payload += chunk; });
+socket.on('end', () => {
+  const descriptor = JSON.parse(payload);
+  if (!descriptor || Array.isArray(descriptor) || Object.values(descriptor).some((value) => typeof value !== 'string')) {
+    throw new Error('invalid terminal launch descriptor');
+  }
+  try { fs.rmSync(launchDir, { recursive: true, force: true }); } catch {}
+  const child = spawn(command, args, {
+    cwd: cwd || undefined,
+    env: { ...process.env, ...descriptor },
+    stdio: 'inherit',
+  });
+  child.on('error', (error) => { console.error(error.message); process.exitCode = 1; });
+  child.on('exit', (code, signal) => {
+    if (signal) process.kill(process.pid, signal);
+    else process.exitCode = code == null ? 1 : code;
+  });
+});
+socket.on('error', (error) => { console.error(error.message); process.exitCode = 1; });
+`;
+var MAC_TERMINAL_IPC_TIMEOUT_MS = 12e4;
+function openTerminal({ cli, command, extraArgs, env, cwd, platform, onFailure }, spawnProcess = spawn, macIpc = {}) {
   const childEnv = { ...process.env, ...env };
   if (platform === "win32") {
     const args = ["/c", "start", `"omnicross ${cli}"`];
     if (cwd) args.push("/D", `"${cwd}"`);
     args.push("cmd", "/k", command, ...extraArgs);
-    spawn(process.env["ComSpec"] || "cmd.exe", args, {
+    spawnProcess(process.env["ComSpec"] || "cmd.exe", args, {
       env: childEnv,
       windowsVerbatimArguments: true,
       detached: true,
       stdio: "ignore"
     }).unref();
-    return;
+    return () => {
+    };
   }
-  const exportLine = Object.entries(env).map(([k, v]) => `export ${k}=${shq(v)}`).join("; ");
   const runLine = [command, ...extraArgs].map(shq).join(" ");
-  const script = `${exportLine}; ${cwd ? `cd ${shq(cwd)}; ` : ""}${runLine}`;
+  const script = `${cwd ? `cd ${shq(cwd)}; ` : ""}${runLine}`;
   if (platform === "darwin") {
-    const osa = `tell application "Terminal" to do script ${JSON.stringify(script)}`;
-    spawn("osascript", ["-e", osa], { detached: true, stdio: "ignore" }).unref();
-    return;
+    const launchDir = mkdtempSync(join4(tmpdir(), "omnicross-terminal-"));
+    const commandFile = join4(launchDir, "launch.command");
+    const bootstrapFile = join4(launchDir, "bootstrap.cjs");
+    const socketPath = macIpc.socketPath ?? join4(launchDir, "descriptor.sock");
+    const openerEnv = { ...process.env };
+    for (const key of Object.keys(env)) delete openerEnv[key];
+    let claimed = false;
+    let cleaned = false;
+    let failureNotified = false;
+    let timer;
+    const notifyFailure = () => {
+      cleanup();
+      if (failureNotified) return;
+      failureNotified = true;
+      try {
+        onFailure?.();
+      } catch {
+      }
+    };
+    const handleLaunchFailure = () => {
+      if (claimed) cleanup();
+      else notifyFailure();
+    };
+    const sockets = /* @__PURE__ */ new Set();
+    const server = createServer((socket) => {
+      socket.unref();
+      sockets.add(socket);
+      socket.once("close", () => sockets.delete(socket));
+      try {
+        macIpc.onAccepted?.(socket);
+      } catch {
+        cleanup();
+        return;
+      }
+      if (claimed || cleaned) {
+        socket.destroy();
+        return;
+      }
+      claimed = true;
+      try {
+        macIpc.onClaimed?.();
+        if (cleaned) return;
+        socket.end(JSON.stringify(env), cleanup);
+      } catch {
+        cleanup();
+      }
+    });
+    const cleanup = () => {
+      if (!cleaned) {
+        cleaned = true;
+        if (timer) clearTimeout(timer);
+        for (const socket of sockets) socket.destroy();
+        sockets.clear();
+        try {
+          server.close();
+        } catch {
+        }
+      }
+      try {
+        if (macIpc.removeArtifacts) {
+          macIpc.removeArtifacts(launchDir);
+        } else {
+          rmSync2(launchDir, {
+            recursive: true,
+            force: true,
+            maxRetries: 3,
+            retryDelay: 20
+          });
+        }
+      } catch {
+      }
+    };
+    try {
+      writeFileSync6(bootstrapFile, MAC_TERMINAL_BOOTSTRAP_SOURCE, { encoding: "utf8", mode: 448 });
+      writeFileSync6(commandFile, `#!/bin/bash
+rm -f -- "$0"
+exec ${shq(process.execPath)} ${shq(bootstrapFile)} ${shq(socketPath)} ${shq(launchDir)} ${shq(cwd ?? "")} ${runLine}
+`, {
+        encoding: "utf8",
+        mode: 448
+      });
+      chmodSync3(commandFile, 448);
+      chmodSync3(bootstrapFile, 448);
+      server.once("error", handleLaunchFailure);
+      server.listen(socketPath, () => {
+        if (cleaned) return;
+        try {
+          macIpc.onListening?.();
+          if (cleaned) return;
+          if (process.platform !== "win32") chmodSync3(socketPath, 384);
+          const opener = spawnProcess("open", ["-n", "-a", "Terminal", commandFile], {
+            env: openerEnv,
+            detached: true,
+            stdio: "ignore"
+          });
+          opener.once("error", handleLaunchFailure);
+          opener.unref();
+          server.unref();
+        } catch {
+          handleLaunchFailure();
+        }
+      });
+      timer = setTimeout(handleLaunchFailure, macIpc.timeoutMs ?? MAC_TERMINAL_IPC_TIMEOUT_MS);
+      timer.unref?.();
+      return cleanup;
+    } catch (error) {
+      cleanup();
+      throw error;
+    }
   }
-  spawn("x-terminal-emulator", ["-e", "bash", "-lc", `${script}; exec bash`], {
+  spawnProcess("x-terminal-emulator", ["-e", "bash", "-lc", `${script}; exec bash`], {
+    env: childEnv,
     detached: true,
     stdio: "ignore"
   }).unref();
-};
+  return () => {
+  };
+}
+var defaultTerminalOpener = (input) => openTerminal(input);
 var sessions = /* @__PURE__ */ new Map();
+function resetCliSessions() {
+  for (const s of sessions.values()) {
+    try {
+      s.onSessionEnd();
+    } catch {
+    }
+  }
+  sessions.clear();
+}
 function errBody(message) {
   return { error: { type: "admin_api_error", message } };
 }
@@ -3224,29 +3492,81 @@ async function handleCliLaunch(cli, body, ctx) {
   } catch (err5) {
     return { status: 400, body: errBody(err5 instanceof Error ? err5.message : "no launch target") };
   }
+  const id = randomUUID2();
+  let leaseId2;
   let launch;
   try {
-    launch = await buildLaunchEnv(cli, ctx.llmConfig, target);
+    if ((cli === "claude" || cli === "codex") && ctx.routeLeaseManager) {
+      const outcome = await ctx.routeLeaseManager.createFromRequest({
+        schemaVersion: ROUTE_LEASE_REQUEST_SCHEMA,
+        consumer: "omnicross-terminal",
+        runtime: cli,
+        upstream: { kind: "provider", providerId: target.providerId },
+        model: target.model,
+        execution: { sessionId: id }
+      }, `omnicross-terminal:${id}`);
+      leaseId2 = outcome.result.leaseId;
+      const stopRenewal = startTerminalLeaseRenewal(ctx.routeLeaseManager, leaseId2);
+      launch = {
+        env: outcome.result.launch.env,
+        extraArgs: outcome.result.launch.extraArgs,
+        onSessionEnd: () => {
+          stopRenewal();
+          ctx.routeLeaseManager?.release(outcome.result.leaseId);
+        }
+      };
+    } else {
+      launch = await buildLaunchEnv(cli, ctx.llmConfig, target);
+    }
   } catch (err5) {
-    return { status: 400, body: errBody(err5 instanceof Error ? err5.message : "failed to build launch env") };
+    const status = err5 instanceof RouteLeaseError2 ? err5.status : 400;
+    return { status, body: errBody(err5 instanceof Error ? err5.message : "failed to build launch env") };
   }
   const cwd = typeof body["cwd"] === "string" && body["cwd"].trim() ? body["cwd"].trim() : void 0;
   const opener = ctx.opener ?? defaultTerminalOpener;
+  let openerCleanup;
+  let ended = false;
+  let published = false;
+  const onSessionEnd = () => {
+    if (ended) return;
+    ended = true;
+    if (published) sessions.delete(id);
+    try {
+      openerCleanup?.();
+    } finally {
+      launch.onSessionEnd();
+    }
+  };
   try {
-    opener({ cli, command: meta.command, extraArgs: launch.extraArgs ?? [], env: launch.env, cwd, platform });
+    const cleanup = opener({
+      cli,
+      command: meta.command,
+      extraArgs: launch.extraArgs ?? [],
+      env: launch.env,
+      cwd,
+      platform,
+      onFailure: onSessionEnd
+    });
+    if (cleanup) openerCleanup = cleanup;
   } catch (err5) {
-    launch.onSessionEnd();
+    onSessionEnd();
     return { status: 500, body: errBody(err5 instanceof Error ? err5.message : "failed to open terminal") };
   }
-  const id = randomUUID2();
+  if (ended) {
+    openerCleanup?.();
+    return { status: 500, body: errBody("failed to open terminal") };
+  }
   sessions.set(id, {
     id,
     cli,
     providerId: target.providerId,
     model: target.model,
+    ...leaseId2 ? { leaseId: leaseId2 } : {},
     startedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    onSessionEnd: launch.onSessionEnd
+    onSessionEnd
   });
+  published = true;
+  if (ended) sessions.delete(id);
   return { status: 200, body: { sessionId: id, providerId: target.providerId, model: target.model } };
 }
 
@@ -4133,7 +4453,7 @@ function sealPack(bundleJson, passphrase) {
   cipher.setAAD(aadFor(PACK_MAGIC, PACK_VERSION, KDF_ALGORITHM));
   const ciphertext = Buffer.concat([cipher.update(bundleJson, "utf8"), cipher.final()]);
   const tag = cipher.getAuthTag();
-  const header = {
+  const header2 = {
     magic: PACK_MAGIC,
     v: PACK_VERSION,
     kdf: KDF_ALGORITHM,
@@ -4144,7 +4464,7 @@ function sealPack(bundleJson, passphrase) {
     iv: iv.toString("base64"),
     tag: tag.toString("base64")
   };
-  return `${PACK_PREFIX}${toB64Url(JSON.stringify(header))}.${ciphertext.toString("base64")}`;
+  return `${PACK_PREFIX}${toB64Url(JSON.stringify(header2))}.${ciphertext.toString("base64")}`;
 }
 function parsePack(packString) {
   if (typeof packString !== "string" || !packString.startsWith(PACK_PREFIX)) {
@@ -4155,28 +4475,28 @@ function parsePack(packString) {
   if (dot < 0) throw new PackAuthError("migration pack is malformed (missing body)");
   const headerB64Url = rest.slice(0, dot);
   const ctB64 = rest.slice(dot + 1);
-  let header;
+  let header2;
   try {
-    header = JSON.parse(fromB64Url(headerB64Url));
+    header2 = JSON.parse(fromB64Url(headerB64Url));
   } catch {
     throw new PackAuthError("migration pack is malformed (unreadable header)");
   }
-  if (!header || header.magic !== PACK_MAGIC || header.v !== PACK_VERSION || header.kdf !== KDF_ALGORITHM || typeof header.salt !== "string" || typeof header.iv !== "string" || typeof header.tag !== "string" || typeof header.N !== "number" || typeof header.r !== "number" || typeof header.p !== "number") {
+  if (!header2 || header2.magic !== PACK_MAGIC || header2.v !== PACK_VERSION || header2.kdf !== KDF_ALGORITHM || typeof header2.salt !== "string" || typeof header2.iv !== "string" || typeof header2.tag !== "string" || typeof header2.N !== "number" || typeof header2.r !== "number" || typeof header2.p !== "number") {
     throw new PackAuthError("migration pack is malformed (unsupported header)");
   }
   const ciphertext = Buffer.from(ctB64, "base64");
-  return { header, ciphertext };
+  return { header: header2, ciphertext };
 }
 function openPack(packString, passphrase) {
   assertPassphraseStrength(passphrase);
-  const { header, ciphertext } = parsePack(packString);
-  const salt = Buffer.from(header.salt, "base64");
-  const iv = Buffer.from(header.iv, "base64");
-  const tag = Buffer.from(header.tag, "base64");
+  const { header: header2, ciphertext } = parsePack(packString);
+  const salt = Buffer.from(header2.salt, "base64");
+  const iv = Buffer.from(header2.iv, "base64");
+  const tag = Buffer.from(header2.tag, "base64");
   if (iv.length !== IV_BYTES2 || tag.length !== TAG_BYTES2) {
     throw new PackAuthError("migration pack is malformed (invalid iv/tag length)");
   }
-  const key = deriveKey(passphrase, salt, header.N, header.r, header.p);
+  const key = deriveKey(passphrase, salt, header2.N, header2.r, header2.p);
   const decipher = createDecipheriv2("aes-256-gcm", key, iv);
   decipher.setAAD(aadFor(PACK_MAGIC, PACK_VERSION, KDF_ALGORITHM));
   decipher.setAuthTag(tag);
@@ -4512,10 +4832,10 @@ function writeJson2(res, status, body) {
   res.writeHead(status, { "Content-Type": "application/json" });
   res.end(JSON.stringify(body));
 }
-function writeError(res, status, message) {
+function writeError2(res, status, message) {
   writeJson2(res, status, { error: { type: "account_allowance_error", message } });
 }
-function readJson(req) {
+function readJson2(req) {
   return new Promise((resolve3, reject) => {
     const chunks = [];
     req.on("data", (chunk) => chunks.push(Buffer.from(chunk)));
@@ -4541,10 +4861,10 @@ function allowanceProvider(value) {
   return value === "claude" || value === "codex" ? value : null;
 }
 async function handleAccountAllowanceApi(req, res, method, rest, service) {
-  if (!service) return writeError(res, 501, "account allowance service is not available");
+  if (!service) return writeError2(res, 501, "account allowance service is not available");
   if (method === "GET" && rest.length === 1 && rest[0] === "scheduling") {
     if (!service.getSchedulingStatus) {
-      return writeError(res, 501, "allowance scheduling diagnostics are not available");
+      return writeError2(res, 501, "allowance scheduling diagnostics are not available");
     }
     return writeJson2(res, 200, { scheduling: service.getSchedulingStatus() });
   }
@@ -4552,27 +4872,27 @@ async function handleAccountAllowanceApi(req, res, method, rest, service) {
     const params = query(req);
     const pathProvider = rest.length >= 2 ? rest[0] : null;
     const providerId = allowanceProvider(pathProvider ?? params.get("providerId") ?? params.get("provider"));
-    if (providerId === null) return writeError(res, 400, "providerId must be claude or codex");
+    if (providerId === null) return writeError2(res, 400, "providerId must be claude or codex");
     const accountId = rest.length >= 2 ? rest[1] : params.get("accountId") ?? void 0;
     const allowances = await service.list({ providerId, accountId });
     return writeJson2(res, 200, { allowances });
   }
   if (method === "POST" && rest[0] === "refresh") {
-    const body = await readJson(req);
+    const body = await readJson2(req);
     const requestedProvider = allowanceProvider(
       typeof body["providerId"] === "string" ? body["providerId"] : "claude"
     );
     if (requestedProvider !== "claude") {
-      return writeError(res, 400, "only Claude allowances support explicit refresh");
+      return writeError2(res, 400, "only Claude allowances support explicit refresh");
     }
     const accountId = typeof body["accountId"] === "string" && body["accountId"].trim() ? body["accountId"].trim() : void 0;
     const allowances = await service.refreshClaude(accountId);
     if (accountId && allowances.length === 0) {
-      return writeError(res, 404, `Claude account '${accountId}' not found`);
+      return writeError2(res, 404, `Claude account '${accountId}' not found`);
     }
     return writeJson2(res, 200, { allowances });
   }
-  return writeError(res, 405, `method ${method} not allowed on account allowances`);
+  return writeError2(res, 405, `method ${method} not allowed on account allowances`);
 }
 
 // src/admin/adminApi.ts
@@ -5807,6 +6127,7 @@ async function handleCli(req, res, method, rest, deps) {
     const result = await handleCliLaunch(cli, body, {
       llmConfig: deps.llmConfig,
       providers,
+      routeLeaseManager: deps.routeLeaseManager,
       opener: deps.cliTerminalOpener,
       probe: deps.cliPathProbe
     });
@@ -6069,7 +6390,7 @@ async function handleUiStatic(req, res, urlPath, uiDist) {
 }
 
 // src/admin/version.ts
-var DAEMON_VERSION = true ? "0.1.7" : "0.0.0-dev";
+var DAEMON_VERSION = true ? "0.1.8" : "0.0.0-dev";
 
 // src/admin/AdminServer.ts
 var LOOPBACK_ADDR = "127.0.0.1";
@@ -6189,6 +6510,10 @@ var AdminServer = class {
       await handleWebhookTest(req, res);
       return;
     }
+    if (path2 === "/admin/api/route-leases" || path2.startsWith("/admin/api/route-leases/")) {
+      await handleRouteLeaseApi(req, res, path2, this.deps);
+      return;
+    }
     if (path2.startsWith("/admin/api/")) {
       await handleAdminApi(req, res, path2, this.deps);
       return;
@@ -6200,8 +6525,8 @@ var AdminServer = class {
   }
   /** Constant-time bearer/header check against the configured token. */
   isAuthorized(req, token) {
-    const header = req.headers["authorization"];
-    const bearer = typeof header === "string" && header.startsWith("Bearer ") ? header.slice("Bearer ".length).trim() : void 0;
+    const header2 = req.headers["authorization"];
+    const bearer = typeof header2 === "string" && header2.startsWith("Bearer ") ? header2.slice("Bearer ".length).trim() : void 0;
     const xToken = req.headers["x-admin-token"];
     const presented = bearer ?? (typeof xToken === "string" ? xToken.trim() : void 0);
     return constantTimeEquals(presented, token);
@@ -6336,7 +6661,7 @@ var OAuthSessionStore = class {
 };
 
 // src/commands/loopbackCallback.ts
-import { createServer } from "http";
+import { createServer as createServer2 } from "http";
 var LOOPBACK_HOST = "127.0.0.1";
 var LOOPBACK_PORT = 1455;
 var CALLBACK_PATH = "/auth/callback";
@@ -6358,7 +6683,7 @@ function awaitLoopbackCode(expectedState, timeoutMs = DEFAULT_TIMEOUT_MS, signal
       fn();
       server2.close();
     };
-    const server = createServer((req, res) => {
+    const server = createServer2((req, res) => {
       const url = new URL(req.url ?? "", `http://${LOOPBACK_HOST}:${LOOPBACK_PORT}`);
       if (url.pathname !== CALLBACK_PATH) {
         res.writeHead(404, HTML_HEADERS);
@@ -6780,7 +7105,7 @@ function safeStringify(value) {
 }
 
 // src/ports/JsonApiServerSettingsStore.ts
-import { readFileSync as readFileSync8, writeFileSync as writeFileSync6 } from "fs";
+import { readFileSync as readFileSync8, writeFileSync as writeFileSync7 } from "fs";
 import { OUTBOUND_API_SERVER_CONFIG_KEY } from "@omnicross/core/outbound-api";
 var JsonApiServerSettingsStore = class {
   /**
@@ -6807,7 +7132,7 @@ var JsonApiServerSettingsStore = class {
     if (key !== OUTBOUND_API_SERVER_CONFIG_KEY) return;
     const file = this.readFile();
     file.server = this.encryptSecrets(value);
-    writeFileSync6(this.configPath, JSON.stringify(file, null, 2) + "\n", "utf8");
+    writeFileSync7(this.configPath, JSON.stringify(file, null, 2) + "\n", "utf8");
   }
   /** Encrypt the proxy passwords + webhook + billing secrets before persisting (no-op without a box). */
   encryptSecrets(config) {
@@ -7161,7 +7486,7 @@ function median(values) {
 }
 
 // src/ports/JsonPricingStore.ts
-import { existsSync as existsSync9, readFileSync as readFileSync10, renameSync as renameSync3, rmSync as rmSync2, writeFileSync as writeFileSync7 } from "fs";
+import { existsSync as existsSync9, readFileSync as readFileSync10, renameSync as renameSync3, rmSync as rmSync3, writeFileSync as writeFileSync8 } from "fs";
 import { randomUUID as randomUUID5 } from "crypto";
 var JsonPricingStore = class {
   constructor(pricingPath) {
@@ -7302,13 +7627,13 @@ var JsonPricingStore = class {
   writeRows(rows) {
     const temporaryPath = `${this.pricingPath}.${process.pid}.${randomUUID5()}.tmp`;
     try {
-      writeFileSync7(temporaryPath, JSON.stringify(rows, null, 2) + "\n", {
+      writeFileSync8(temporaryPath, JSON.stringify(rows, null, 2) + "\n", {
         encoding: "utf8",
         flag: "wx"
       });
       this.replaceFile(temporaryPath);
     } finally {
-      rmSync2(temporaryPath, { force: true });
+      rmSync3(temporaryPath, { force: true });
     }
   }
   /** Isolated for deterministic failure testing; never removes the target. */
@@ -7323,7 +7648,7 @@ function isUsablePricingRow(value) {
 }
 
 // src/pricing/PricingRefreshScheduler.ts
-import { existsSync as existsSync10, readFileSync as readFileSync11, renameSync as renameSync4, writeFileSync as writeFileSync8 } from "fs";
+import { existsSync as existsSync10, readFileSync as readFileSync11, renameSync as renameSync4, writeFileSync as writeFileSync9 } from "fs";
 var EMPTY_STATE2 = {
   lastAttemptAt: null,
   lastSuccessAt: null,
@@ -7416,7 +7741,7 @@ var PricingRefreshScheduler = class {
   }
   writeState(state) {
     const temporaryPath = `${this.statePath}.tmp`;
-    writeFileSync8(temporaryPath, `${JSON.stringify(state, null, 2)}
+    writeFileSync9(temporaryPath, `${JSON.stringify(state, null, 2)}
 `, "utf8");
     renameSync4(temporaryPath, this.statePath);
   }
@@ -7426,7 +7751,7 @@ function finiteOrNull(value) {
 }
 
 // src/ports/JsonVoucherDb.ts
-import { existsSync as existsSync11, readFileSync as readFileSync12, writeFileSync as writeFileSync9 } from "fs";
+import { existsSync as existsSync11, readFileSync as readFileSync12, writeFileSync as writeFileSync10 } from "fs";
 var JsonVoucherDb = class {
   constructor(vouchersPath) {
     this.vouchersPath = vouchersPath;
@@ -7513,12 +7838,12 @@ var JsonVoucherDb = class {
     }
   }
   writeRows(rows) {
-    writeFileSync9(this.vouchersPath, JSON.stringify(rows, null, 2) + "\n", "utf8");
+    writeFileSync10(this.vouchersPath, JSON.stringify(rows, null, 2) + "\n", "utf8");
   }
 };
 
 // src/ports/JsonSubscriptionCredentialStore.ts
-import { existsSync as existsSync13, mkdirSync as mkdirSync4, readFileSync as readFileSync14, writeFileSync as writeFileSync10 } from "fs";
+import { existsSync as existsSync13, mkdirSync as mkdirSync4, readFileSync as readFileSync14, writeFileSync as writeFileSync11 } from "fs";
 import { dirname as dirname6 } from "path";
 import { getSharedAccountHealth as getSharedAccountHealth2 } from "@omnicross/core/pipeline/SubscriptionAccountHealth";
 import { getSharedAccountAllowanceScheduling as getSharedAccountAllowanceScheduling3 } from "@omnicross/core/pipeline/AccountAllowanceScheduling";
@@ -8201,7 +8526,7 @@ var JsonSubscriptionCredentialStore = class {
   persist(config) {
     mkdirSync4(dirname6(this.tokensPath), { recursive: true });
     const encrypted = encryptTokens(config, this.box);
-    writeFileSync10(this.tokensPath, JSON.stringify(encrypted, null, 2) + "\n", "utf8");
+    writeFileSync11(this.tokensPath, JSON.stringify(encrypted, null, 2) + "\n", "utf8");
   }
   /**
    * Read + parse `tokens.json`, tolerating a missing/corrupt file, then DECRYPT
@@ -8770,7 +9095,7 @@ import {
   readFileSync as readFileSync15,
   readdirSync,
   statSync as statSync3,
-  writeFileSync as writeFileSync11
+  writeFileSync as writeFileSync12
 } from "fs";
 import { basename, dirname as dirname7, join as join6 } from "path";
 var SIDECAR_VERSION = 1;
@@ -8812,7 +9137,7 @@ function updateAuditStatsAfterAppend(auditPath, auditBytesBefore, auditBytesAfte
     minTs: previous.minTs === null ? record.ts : Math.min(previous.minTs, record.ts),
     maxTs: previous.maxTs === null ? record.ts : Math.max(previous.maxTs, record.ts)
   };
-  writeFileSync11(statsPath, JSON.stringify(next), "utf8");
+  writeFileSync12(statsPath, JSON.stringify(next), "utf8");
 }
 function queryCovers(stats, from, to) {
   return stats.requestCount === 0 || stats.minTs !== null && stats.maxTs !== null && from <= stats.minTs && to >= stats.maxTs;
@@ -8956,7 +9281,7 @@ async function readAuditStats(auditDir, query2 = {}) {
       total.errorCount += scanned.filtered.errorCount + (resumable?.errorCount ?? 0);
       total.complete = total.complete && scanned.filtered.complete;
       const current = resumable ? mergePersistedStats(resumable, scanned.all) : scanned.all;
-      if (current.complete) writeFileSync11(statsPath, JSON.stringify(current), "utf8");
+      if (current.complete) writeFileSync12(statsPath, JSON.stringify(current), "utf8");
     } catch {
       total.complete = false;
     }
@@ -9518,6 +9843,78 @@ var TokenRefreshScheduler = class {
   }
 };
 
+// src/routeLeaseSubscriptionPreflight.ts
+import {
+  RouteLeaseError as RouteLeaseError3
+} from "@omnicross/core/provider-proxy";
+import { getSharedAccountAllowanceScheduling as getSharedAccountAllowanceScheduling4 } from "@omnicross/core/pipeline/AccountAllowanceScheduling";
+import { getSharedAccountHealth as getSharedAccountHealth3 } from "@omnicross/core/pipeline/SubscriptionAccountHealth";
+import { accountSupportsModel } from "@omnicross/subscriptions/scheduler/accountModelMap";
+var PROVIDERS = /* @__PURE__ */ new Set(["claude", "codex", "gemini", "opencodego"]);
+function accountArray(config, providerId) {
+  const record = config;
+  const key = `${providerId}Accounts`;
+  const accounts = record[key];
+  if (Array.isArray(accounts)) return accounts;
+  const legacy = record[providerId];
+  if (!legacy || typeof legacy !== "object") return [];
+  const activeKey = `active${providerId[0].toUpperCase()}${providerId.slice(1)}AccountId`;
+  return [{ id: String(record[activeKey] ?? "active"), enabled: true, tokens: legacy }];
+}
+function hasCredential(providerId, account) {
+  const tokens = account.tokens;
+  if (providerId === "opencodego") return typeof tokens.apiKey === "string" && tokens.apiKey.length > 0;
+  return typeof tokens.accessToken === "string" && tokens.accessToken.length > 0;
+}
+function safeProviderId(value) {
+  if (!PROVIDERS.has(value)) {
+    throw new RouteLeaseError3("upstream_not_found", "subscription provider was not found");
+  }
+  return value;
+}
+function createRouteLeaseSubscriptionPreflight(credentials) {
+  return {
+    async assertAvailable(upstream, model) {
+      const providerId = safeProviderId(upstream.providerId);
+      const config = await credentials.getFullConfig();
+      const all = accountArray(config, providerId);
+      if (all.length === 0) {
+        throw new RouteLeaseError3("upstream_unavailable", "subscription provider has no configured account");
+      }
+      let bounded = all;
+      if (upstream.kind === "account") {
+        bounded = all.filter((account) => account.id === upstream.accountId);
+      } else if (upstream.kind === "account-group") {
+        bounded = all.filter((account) => account.group?.trim() === upstream.group);
+      }
+      if (bounded.length === 0) {
+        throw new RouteLeaseError3("upstream_not_found", "the selected subscription resource was not found");
+      }
+      const modelEligible = bounded.filter(
+        (account) => accountSupportsModel(account.supportedModels, model)
+      );
+      if (modelEligible.length === 0) {
+        throw new RouteLeaseError3("model_not_configured", "model is not supported by the selected subscription resource");
+      }
+      const credentialEligible = modelEligible.filter(
+        (account) => account.enabled !== false && hasCredential(providerId, account)
+      );
+      const health2 = getSharedAccountHealth3();
+      const allowance = getSharedAccountAllowanceScheduling4();
+      const candidates = credentialEligible.filter(
+        (account) => health2.isSchedulable(providerId, account.id) && allowance.preview(providerId, account.id, account.priority ?? 50).schedulable
+      );
+      if (candidates.length > 0) return;
+      if (upstream.kind === "account") {
+        throw new RouteLeaseError3("upstream_unavailable", "the selected subscription account is unavailable");
+      }
+      throw new RouteLeaseError3("upstream_exhausted", "the selected subscription pool has no eligible account", {
+        retryAfterSeconds: 30
+      });
+    }
+  };
+}
+
 // src/webhook/WebhookDispatcher.ts
 import { createHmac as createHmac2 } from "crypto";
 import { fetchUpstream as fetchUpstream6 } from "@omnicross/core/pipeline/upstreamFetch";
@@ -9700,7 +10097,7 @@ function buildDaemon(config, paths) {
     new JsonAccountAllowancePersistence(defaultAccountAllowancePath(paths.configPath))
   );
   setSharedAccountAllowanceStore(accountAllowanceStore);
-  getSharedAccountAllowanceScheduling4().configure(
+  getSharedAccountAllowanceScheduling5().configure(
     normalizeServerConfig(decryptedConfig.server).allowanceScheduling
   );
   const llmConfig = new ConfigFileProviderConfigSource(decryptedConfig);
@@ -9768,10 +10165,21 @@ function buildDaemon(config, paths) {
     onRecord: (apiKeyId, costUsd, at) => keySpendTracker.add(apiKeyId, costUsd, at)
   });
   const providerProxy = getProviderProxy({ llmConfig, apiKeyPool, usageRecorder });
+  const routeLeaseManager = new RouteLeaseManager(
+    providerProxy,
+    new RouteLeaseTargetResolver(llmConfig, {
+      providerKeys: apiKeyPool,
+      subscriptions: createRouteLeaseSubscriptionPreflight(credentialStore)
+    }),
+    routeLeaseDescriptorPort,
+    { logger }
+  );
+  providerProxy.registerBeforeStop(() => routeLeaseManager.shutdown());
+  providerProxy.registerBeforeStop(() => resetCliSessions());
   llmConfig.setReloadHook(() => apiKeyPool.invalidateCache());
   const accountHealthProbeScheduler = new AccountHealthProbeScheduler(
     credentialStore,
-    getSharedAccountHealth3(),
+    getSharedAccountHealth4(),
     logger,
     DEFAULT_ACCOUNT_PROBE
   );
@@ -9818,6 +10226,7 @@ function buildDaemon(config, paths) {
     keySpendReader: keySpendTracker,
     settingsStore,
     outboundApiServer,
+    routeLeaseManager,
     subscriptionAccounts,
     accountAllowanceService,
     allowanceRefreshScheduler: claudeAllowanceRefreshScheduler,
@@ -9910,7 +10319,7 @@ function buildDaemon(config, paths) {
     logger,
     fetchImpl: (url, init) => fetchUpstream7(url, init)
   });
-  setWebhookRuntime(webhookDispatcher, getSharedAccountHealth3());
+  setWebhookRuntime(webhookDispatcher, getSharedAccountHealth4());
   const auditWriter = new AuditWriter(auditDir, logger);
   const auditPruneSweeper = new AuditPruneSweeper(auditDir, logger, DEFAULT_AUDIT_CONFIG);
   setAuditRuntime(auditWriter, auditPruneSweeper);
@@ -9925,7 +10334,7 @@ function buildDaemon(config, paths) {
   const tokenRefreshScheduler = new TokenRefreshScheduler(credentialStore, logger);
   const accountHealthSweeper = new AccountHealthSweeper(
     credentialStore,
-    getSharedAccountHealth3(),
+    getSharedAccountHealth4(),
     logger
   );
   return {
@@ -9934,6 +10343,7 @@ function buildDaemon(config, paths) {
     keyDb,
     settingsStore,
     providerProxy,
+    routeLeaseManager,
     outboundApiServer,
     apiKeyPool,
     autoDisableStore,
@@ -10049,32 +10459,17 @@ async function runLaunch(argv, deps) {
     await daemon.llmConfig.ready();
     await daemon.providerProxy.start();
   } catch (err5) {
-    daemon.apiKeyPool.dispose();
-    daemon.tokenRefreshScheduler.dispose();
-    daemon.claudeAllowanceRefreshScheduler.dispose();
-    daemon.accountHealthSweeper.dispose();
-    daemon.accountHealthProbeScheduler.dispose();
-    daemon.auditPruneSweeper.dispose();
-    daemon.billingRetrySweeper.dispose();
-    daemon.pricingRefreshScheduler.dispose();
+    await shutdownLaunchDaemon(daemon);
     throw err5;
   }
   let launch;
   try {
-    launch = await buildLaunchConfig(cli, daemon.llmConfig, {
+    launch = await buildLaunchConfig(cli, daemon, {
       providerId: values.provider,
       model: values.model
     });
   } catch (err5) {
-    await daemon.providerProxy.stop();
-    daemon.apiKeyPool.dispose();
-    daemon.tokenRefreshScheduler.dispose();
-    daemon.claudeAllowanceRefreshScheduler.dispose();
-    daemon.accountHealthSweeper.dispose();
-    daemon.accountHealthProbeScheduler.dispose();
-    daemon.auditPruneSweeper.dispose();
-    daemon.billingRetrySweeper.dispose();
-    daemon.pricingRefreshScheduler.dispose();
+    await shutdownLaunchDaemon(daemon);
     throw err5;
   }
   try {
@@ -10093,21 +10488,40 @@ async function runLaunch(argv, deps) {
       cwd: values.cwd
     });
   } finally {
-    launch.onSessionEnd();
-    await daemon.providerProxy.stop();
-    daemon.apiKeyPool.dispose();
-    daemon.tokenRefreshScheduler.dispose();
-    daemon.claudeAllowanceRefreshScheduler.dispose();
-    daemon.accountHealthSweeper.dispose();
-    daemon.accountHealthProbeScheduler.dispose();
-    daemon.auditPruneSweeper.dispose();
-    daemon.billingRetrySweeper.dispose();
-    daemon.pricingRefreshScheduler.dispose();
-  }
-}
-async function buildLaunchConfig(cli, llmConfig, opts) {
+    try {
+      launch.onSessionEnd();
+    } finally {
+      await shutdownLaunchDaemon(daemon);
+    }
+  }
+}
+async function buildLaunchConfig(cli, daemon, opts) {
+  if (cli === "claude" || cli === "codex") {
+    const internalId = randomUUID6();
+    const outcome = await daemon.routeLeaseManager.createFromRequest({
+      schemaVersion: ROUTE_LEASE_REQUEST_SCHEMA2,
+      consumer: "omnicross-terminal",
+      runtime: cli,
+      upstream: { kind: "provider", providerId: opts.providerId },
+      model: opts.model,
+      execution: { sessionId: `launch:${cli}:${internalId}` }
+    }, `omnicross-launch:${internalId}`);
+    const stopRenewal = startTerminalLeaseRenewal(
+      daemon.routeLeaseManager,
+      outcome.result.leaseId
+    );
+    return {
+      baseUrl: daemon.providerProxy.getBaseUrl(),
+      env: outcome.result.launch.env,
+      extraArgs: outcome.result.launch.extraArgs,
+      onSessionEnd: () => {
+        stopRenewal();
+        daemon.routeLeaseManager.release(outcome.result.leaseId);
+      }
+    };
+  }
   const common = {
-    llmConfig,
+    llmConfig: daemon.llmConfig,
     providerId: opts.providerId,
     model: opts.model,
     // Stable, bounded session id — pool failover (poolseam) fires on launch
@@ -10115,10 +10529,6 @@ async function buildLaunchConfig(cli, llmConfig, opts) {
     sessionId: `launch:${cli}`
   };
   switch (cli) {
-    case "claude":
-      return buildClaudeCliLaunchConfig2(common);
-    case "codex":
-      return buildCodexLaunchConfig2(common);
     case "gemini":
       return buildGeminiCliLaunchConfig2(common);
     case "qwen":
@@ -10131,6 +10541,18 @@ async function buildLaunchConfig(cli, llmConfig, opts) {
     }
   }
 }
+async function shutdownLaunchDaemon(daemon) {
+  daemon.routeLeaseManager.shutdown();
+  await daemon.providerProxy.stop();
+  daemon.apiKeyPool.dispose();
+  daemon.tokenRefreshScheduler.dispose();
+  daemon.claudeAllowanceRefreshScheduler.dispose();
+  daemon.accountHealthSweeper.dispose();
+  daemon.accountHealthProbeScheduler.dispose();
+  daemon.auditPruneSweeper.dispose();
+  daemon.billingRetrySweeper.dispose();
+  daemon.pricingRefreshScheduler.dispose();
+}
 function spawnCliInherit(plan) {
   return new Promise((resolve3, reject) => {
     const child = spawn2(plan.command, plan.args, {
@@ -10177,7 +10599,7 @@ import { createInterface } from "readline";
 import { parseArgs as parseArgs5 } from "util";
 import { fetchUpstream as fetchUpstream8, setUpstreamProxyResolver as setUpstreamProxyResolver2 } from "@omnicross/core/pipeline/upstreamFetch";
 import { claudeOAuth as claudeOAuth3, codexOAuth as codexOAuth3, geminiOAuth as geminiOAuth3 } from "@omnicross/subscriptions";
-var PROVIDERS = ["claude", "codex", "gemini"];
+var PROVIDERS2 = ["claude", "codex", "gemini"];
 async function runLogin(argv, deps) {
   const { values, positionals } = parseArgs5({
     args: argv,
@@ -10191,10 +10613,10 @@ async function runLogin(argv, deps) {
   });
   const provider = positionals[0];
   if (!provider) {
-    throw new Error(`login: a <provider> is required (one of ${PROVIDERS.join("|")})`);
+    throw new Error(`login: a <provider> is required (one of ${PROVIDERS2.join("|")})`);
   }
   if (!isLoginProvider(provider)) {
-    throw new Error(`login: unknown provider '${provider}' (expected ${PROVIDERS.join("|")})`);
+    throw new Error(`login: unknown provider '${provider}' (expected ${PROVIDERS2.join("|")})`);
   }
   if (!values.config) {
     throw new Error("login: --config <path> is required");
@@ -10300,7 +10722,7 @@ async function loginGemini(store, deps, exchangeFetch, label) {
   return expiresAt;
 }
 function isLoginProvider(value) {
-  return PROVIDERS.includes(value);
+  return PROVIDERS2.includes(value);
 }
 async function presentUrl(authUrl, deps) {
   console.info("Open this URL in your browser to authorize:");
@@ -10346,7 +10768,7 @@ function promptPaste(prompt) {
 }
 
 // src/commands/providers.ts
-import { randomUUID as randomUUID6 } from "crypto";
+import { randomUUID as randomUUID7 } from "crypto";
 import { parseArgs as parseArgs6 } from "util";
 async function runProviders(argv) {
   const { values, positionals } = parseArgs6({
@@ -10468,7 +10890,7 @@ function providersAddKey(configPath, providerId, opts) {
   const cfg = loadConfig(configPath);
   const row = cfg.providers.find((p) => p.id === providerId);
   if (!row) throw new Error(`providers add-key: unknown provider '${providerId}'`);
-  const entry = { id: randomUUID6(), apiKey: opts.key };
+  const entry = { id: randomUUID7(), apiKey: opts.key };
   if (opts.label) entry.label = opts.label;
   if (opts.weight !== void 0) {
     const w = Number(opts.weight);
@@ -10496,7 +10918,7 @@ function providersRmKey(configPath, providerId, keyId) {
 }
 
 // src/commands/secrets.ts
-import { existsSync as existsSync21, readFileSync as readFileSync18, writeFileSync as writeFileSync12 } from "fs";
+import { existsSync as existsSync21, readFileSync as readFileSync18, writeFileSync as writeFileSync13 } from "fs";
 import { parseArgs as parseArgs7 } from "util";
 async function runSecrets(argv) {
   const { values, positionals } = parseArgs7({
@@ -10670,7 +11092,7 @@ function secretsDecrypt(args) {
   }
   saveConfig(args.config, cfg);
   if (tokensPlain) {
-    writeFileSync12(tokensPath, JSON.stringify(tokensPlain, null, 2) + "\n", "utf8");
+    writeFileSync13(tokensPath, JSON.stringify(tokensPlain, null, 2) + "\n", "utf8");
   }
   console.info(`Decrypted secrets to plaintext in ${args.config}` + tokensSuffix(args.config));
 }
@@ -10714,7 +11136,7 @@ function writeTokensEncrypted(tokensPath, plain, box) {
     { updatedAt: "", ...plain },
     box
   );
-  writeFileSync12(tokensPath, JSON.stringify(encrypted, null, 2) + "\n", "utf8");
+  writeFileSync13(tokensPath, JSON.stringify(encrypted, null, 2) + "\n", "utf8");
 }
 var TOKEN_FIELDS2 = {
   claude: ["accessToken", "refreshToken"],
@@ -10743,8 +11165,8 @@ function tokensSuffix(configPath) {
 // src/commands/start.ts
 import { parseArgs as parseArgs8 } from "util";
 import { loadServerConfig as loadServerConfig3 } from "@omnicross/core/outbound-api";
-import { getSharedAccountHealth as getSharedAccountHealth4 } from "@omnicross/core/pipeline/SubscriptionAccountHealth";
-import { getSharedAccountAllowanceScheduling as getSharedAccountAllowanceScheduling5 } from "@omnicross/core/pipeline/AccountAllowanceScheduling";
+import { getSharedAccountHealth as getSharedAccountHealth5 } from "@omnicross/core/pipeline/SubscriptionAccountHealth";
+import { getSharedAccountAllowanceScheduling as getSharedAccountAllowanceScheduling6 } from "@omnicross/core/pipeline/AccountAllowanceScheduling";
 
 // src/identity/identityRuntime.ts
 import { getSharedIdentityStore as getSharedIdentityStore3 } from "@omnicross/core/provider-proxy/identity/SubscriptionIdentityStore";
@@ -10804,11 +11226,11 @@ async function runStart(argv) {
   await daemon.llmConfig.ready();
   await daemon.providerProxy.start();
   const serverConfig = await loadServerConfig3(daemon.settingsStore);
-  getSharedAccountHealth4().configure({
+  getSharedAccountHealth5().configure({
     overloadEnabled: serverConfig.accountHealth?.overloadCooldownEnabled,
     overloadTtlMs: serverConfig.accountHealth?.overloadCooldownMs
   });
-  getSharedAccountAllowanceScheduling5().configure(serverConfig.allowanceScheduling);
+  getSharedAccountAllowanceScheduling6().configure(serverConfig.allowanceScheduling);
   daemon.claudeAllowanceRefreshScheduler.configure(serverConfig.allowanceScheduling);
   await daemon.outboundApiServer.applyConfig({
     enabled: true,