@n1creator/openacp-cli 2026.712.7 → 2026.712.9

package/dist/index.js

@@ -8,6 +8,111 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
+// src/core/security/network-redaction.ts
+function sanitizeProxyDebugNamespaces(value) {
+  if (!value) return value;
+  const entries = value.split(",").map((item) => item.trim()).filter(Boolean);
+  const safeEntries = entries.filter((item) => item.startsWith("-") || !UNSAFE_PROXY_DEBUG.test(item));
+  if (safeEntries.some((item) => !item.startsWith("-") && item.includes("*"))) {
+    for (const exclusion of PROXY_DEBUG_EXCLUSIONS) if (!safeEntries.includes(exclusion)) safeEntries.push(exclusion);
+  }
+  const safe = safeEntries.join(",");
+  return safe || void 0;
+}
+function redactNetworkSecrets(input2) {
+  return input2.replace(/(https?:\/\/api\.telegram\.org\/bot)[^/?#\s]+/gi, "$1<redacted>").replace(/(\/bot)[0-9]+:[A-Za-z0-9_-]+/g, "$1<redacted>").replace(/\b([a-z][a-z0-9+.-]*:\/\/)[^/@\s]+@/gi, "$1<redacted>@").replace(new RegExp(`([?&](?:${SENSITIVE_QUERY_KEYS})=)[^&#\\s]*`, "gi"), "$1<redacted>").replace(/\b(authorization|proxy-authorization)\s*[:=]\s*(?:Bearer|Basic)\s+[^\s,;}"']+/gi, "$1: <redacted>").replace(/\b(x-api-key|api-key|cookie|set-cookie)\s*[:=]\s*[^\r\n,;}]+/gi, "$1: <redacted>");
+}
+function normalizedKey(key) {
+  return key.toLowerCase().replace(/[^a-z0-9]/g, "");
+}
+function isSensitiveObjectKey(key) {
+  const normalized = normalizedKey(key);
+  return SENSITIVE_OBJECT_KEYS.has(normalized) || /(?:token|secret|password|passwd|apikey|authorization|cookie)$/.test(normalized);
+}
+function sanitizeNetworkLogValue(value, seen = /* @__PURE__ */ new WeakMap()) {
+  if (typeof value === "string") return redactNetworkSecrets(value);
+  if (value instanceof Error) {
+    const sanitized = new Error(redactNetworkSecrets(value.message));
+    sanitized.name = value.name;
+    if (value.stack) sanitized.stack = redactNetworkSecrets(value.stack);
+    for (const [key, nested] of Object.entries(value)) {
+      ;
+      sanitized[key] = isSensitiveObjectKey(key) ? "<redacted>" : sanitizeNetworkLogValue(nested, seen);
+    }
+    return sanitized;
+  }
+  if (!value || typeof value !== "object") return value;
+  if (Buffer.isBuffer(value) || value instanceof Uint8Array || value instanceof Date) return value;
+  if (seen.has(value)) return seen.get(value);
+  if (Array.isArray(value)) {
+    const result2 = [];
+    seen.set(value, result2);
+    for (const item of value) result2.push(sanitizeNetworkLogValue(item, seen));
+    return result2;
+  }
+  const result = {};
+  seen.set(value, result);
+  for (const [key, nested] of Object.entries(value)) {
+    result[key] = isSensitiveObjectKey(key) ? "<redacted>" : sanitizeNetworkLogValue(nested, seen);
+  }
+  return result;
+}
+var SENSITIVE_QUERY_KEYS, UNSAFE_PROXY_DEBUG, PROXY_DEBUG_EXCLUSIONS, SENSITIVE_OBJECT_KEYS;
+var init_network_redaction = __esm({
+  "src/core/security/network-redaction.ts"() {
+    "use strict";
+    SENSITIVE_QUERY_KEYS = [
+      "access_token",
+      "access-token",
+      "token",
+      "api_key",
+      "api-key",
+      "apikey",
+      "key",
+      "secret",
+      "password",
+      "passwd",
+      "auth",
+      "authorization",
+      "signature",
+      "sig",
+      "bot_token",
+      "bot-token"
+    ].join("|");
+    UNSAFE_PROXY_DEBUG = /^\*?(?:proxy-agent|proxy|https-proxy-agent|http-proxy-agent|socks-proxy-agent)(?::|\*|$)/i;
+    PROXY_DEBUG_EXCLUSIONS = [
+      "-proxy",
+      "-proxy:*",
+      "-proxy-agent",
+      "-proxy-agent:*",
+      "-https-proxy-agent",
+      "-https-proxy-agent:*",
+      "-http-proxy-agent",
+      "-http-proxy-agent:*",
+      "-socks-proxy-agent",
+      "-socks-proxy-agent:*"
+    ];
+    SENSITIVE_OBJECT_KEYS = /* @__PURE__ */ new Set([
+      "authorization",
+      "proxyauthorization",
+      "xapikey",
+      "apikey",
+      "token",
+      "xgoogapikey",
+      "xauthtoken",
+      "xtelegrambottoken",
+      "authentication",
+      "accesstoken",
+      "password",
+      "passwd",
+      "secret",
+      "bottoken",
+      "cookie",
+      "setcookie"
+    ]);
+  }
+});
+
 // src/core/utils/log.ts
 var log_exports = {};
 __export(log_exports, {
@@ -124,7 +229,7 @@ function initLogger(config) {
     ]
   });
   currentTransport = transports;
-  rootLogger = pino({ level: config.level }, transports);
+  rootLogger = pino({ level: config.level, hooks: networkSecurityHooks }, transports);
   initialized = true;
   Object.assign(log, wrapVariadic(rootLogger));
   return rootLogger;
@@ -135,7 +240,7 @@ function setLogLevel(level) {
 function createChildLogger(context) {
   return new Proxy({}, {
     get(_target, prop, receiver) {
-      const child = rootLogger.child(context);
+      const child = rootLogger.child(sanitizeNetworkLogValue(context));
       const value = Reflect.get(child, prop, receiver);
       return typeof value === "function" ? value.bind(child) : value;
     }
@@ -149,7 +254,7 @@ function createSessionLogger(sessionId, parentLogger) {
   try {
     const sessionLogPath = path.join(sessionLogDir, `${sessionId}.log`);
     const dest = pino.destination(sessionLogPath);
-    const sessionFileLogger = pino({ level: parentLogger.level }, dest).child({ sessionId });
+    const sessionFileLogger = pino({ level: parentLogger.level, hooks: networkSecurityHooks }, dest).child({ sessionId });
     const combinedChild = parentLogger.child({ sessionId });
     const originalInfo = combinedChild.info.bind(combinedChild);
     const originalWarn = combinedChild.warn.bind(combinedChild);
@@ -183,16 +288,34 @@ function createSessionLogger(sessionId, parentLogger) {
     return parentLogger.child({ sessionId });
   }
 }
-function closeSessionLogger(logger) {
+async function closeSessionLogger(logger) {
   const dest = logger.__sessionDest;
-  if (dest && typeof dest.destroy === "function") {
-    dest.destroy();
-  }
+  if (!dest) return;
+  await new Promise((resolve7) => {
+    let settled = false;
+    const done = () => {
+      if (!settled) {
+        settled = true;
+        resolve7();
+      }
+    };
+    const timeout = setTimeout(done, 3e3);
+    dest.once?.("close", () => {
+      clearTimeout(timeout);
+      done();
+    });
+    if (typeof dest.end === "function") dest.end();
+    else {
+      dest.destroy?.();
+      clearTimeout(timeout);
+      done();
+    }
+  });
 }
 async function shutdownLogger() {
   if (!initialized) return;
   const transport = currentTransport;
-  rootLogger = pino({ level: "debug" });
+  rootLogger = pino({ level: "debug", hooks: networkSecurityHooks });
   Object.assign(log, wrapVariadic(rootLogger));
   currentTransport = void 0;
   logDir = void 0;
@@ -229,12 +352,19 @@ async function cleanupOldSessionLogs(retentionDays) {
   } catch {
   }
 }
-var rootLogger, initialized, logDir, currentTransport, log, muteCount, savedLevel;
+var networkSecurityHooks, rootLogger, initialized, logDir, currentTransport, log, muteCount, savedLevel;
 var init_log = __esm({
   "src/core/utils/log.ts"() {
     "use strict";
+    init_network_redaction();
+    networkSecurityHooks = {
+      logMethod(inputArgs, method) {
+        method.apply(this, inputArgs.map((arg) => sanitizeNetworkLogValue(arg)));
+      }
+    };
     rootLogger = pino({
       level: "debug",
+      hooks: networkSecurityHooks,
       transport: { target: "pino-pretty", options: { colorize: true, translateTime: "SYS:standard", destination: 2 } }
     });
     initialized = false;
@@ -328,22 +458,22 @@ __export(config_registry_exports, {
   resolveOptions: () => resolveOptions,
   setFieldValueAsync: () => setFieldValueAsync
 });
-function getFieldDef(path36) {
-  return CONFIG_REGISTRY.find((f) => f.path === path36);
+function getFieldDef(path37) {
+  return CONFIG_REGISTRY.find((f) => f.path === path37);
 }
 function getSafeFields() {
   return CONFIG_REGISTRY.filter((f) => f.scope === "safe");
 }
-function isHotReloadable(path36) {
-  const def = getFieldDef(path36);
+function isHotReloadable(path37) {
+  const def = getFieldDef(path37);
   return def?.hotReload ?? false;
 }
 function resolveOptions(def, config) {
   if (!def.options) return void 0;
   return typeof def.options === "function" ? def.options(config) : def.options;
 }
-function getConfigValue(config, path36) {
-  const parts = path36.split(".");
+function getConfigValue(config, path37) {
+  const parts = path37.split(".");
   let current = config;
   for (const part of parts) {
     if (current && typeof current === "object" && part in current) {
@@ -1376,7 +1506,7 @@ function stripPythonPackageVersion(pkg) {
   const at = pkg.indexOf("@");
   return at === -1 ? pkg : pkg.slice(0, at);
 }
-async function installAgent(agent, store, progress, agentsDir) {
+async function installAgent(agent, store, progress, agentsDir, scopedFetch = globalThis.fetch) {
   const agentKey = getAgentAlias(agent.id);
   await progress?.onStart(agent.id, agent.name);
   const dist = resolveDistribution(agent);
@@ -1396,7 +1526,7 @@ Install it with: pip install uv`;
   let binaryPath;
   if (dist.type === "binary") {
     try {
-      binaryPath = await downloadAndExtract(agent.id, dist.archive, progress, agentsDir);
+      binaryPath = await downloadAndExtract(agent.id, dist.archive, progress, agentsDir, scopedFetch);
     } catch (err) {
       const msg = `Failed to download ${agent.name}. Please try again or install manually.`;
       await progress?.onError(msg);
@@ -1412,12 +1542,12 @@ Install it with: pip install uv`;
   await progress?.onSuccess(agent.name);
   return { ok: true, agentKey, setupSteps: setupSteps.length > 0 ? setupSteps : void 0 };
 }
-async function downloadAndExtract(agentId, archiveUrl, progress, agentsDir) {
+async function downloadAndExtract(agentId, archiveUrl, progress, agentsDir, scopedFetch = globalThis.fetch) {
   const destDir = path10.join(agentsDir ?? DEFAULT_AGENTS_DIR, agentId);
   fs11.mkdirSync(destDir, { recursive: true });
   await progress?.onStep("Downloading...");
   log11.info({ agentId, url: archiveUrl }, "Downloading agent binary");
-  const response = await fetch(archiveUrl);
+  const response = await scopedFetch(archiveUrl);
   if (!response.ok) {
     throw new Error(`Download failed: ${response.status} ${response.statusText}`);
   }
@@ -1437,20 +1567,39 @@ async function readResponseWithProgress(response, contentLength, progress) {
     const arrayBuffer = await response.arrayBuffer();
     return Buffer.from(arrayBuffer);
   }
-  const reader = response.body.getReader();
   const chunks = [];
   let received = 0;
-  while (true) {
-    const { done, value } = await reader.read();
-    if (done) break;
+  const consume = async (value) => {
     chunks.push(value);
     received += value.length;
-    if (received > MAX_DOWNLOAD_SIZE) {
-      throw new Error(`Download exceeds size limit of ${MAX_DOWNLOAD_SIZE} bytes`);
+    if (received > MAX_DOWNLOAD_SIZE) throw new Error(`Download exceeds size limit of ${MAX_DOWNLOAD_SIZE} bytes`);
+    if (contentLength > 0) await progress?.onDownloadProgress(Math.min(100, Math.round(received / contentLength * 100)));
+  };
+  const body = response.body;
+  if (typeof body.getReader === "function") {
+    const reader = body.getReader();
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        await consume(value);
+      }
+    } catch (error) {
+      await reader.cancel?.(error).catch(() => {
+      });
+      throw error;
+    } finally {
+      reader.releaseLock?.();
     }
-    if (contentLength > 0) {
-      await progress?.onDownloadProgress(Math.round(received / contentLength * 100));
+  } else if (body[Symbol.asyncIterator]) {
+    try {
+      for await (const value of body) await consume(new Uint8Array(value));
+    } catch (error) {
+      body.destroy?.(error instanceof Error ? error : void 0);
+      throw error;
     }
+  } else {
+    return Buffer.from(await response.arrayBuffer());
   }
   return Buffer.concat(chunks);
 }
@@ -1551,12 +1700,16 @@ var init_groq = __esm({
     "use strict";
     GROQ_API_URL = "https://api.groq.com/openai/v1/audio/transcriptions";
     GroqSTT = class {
-      constructor(apiKey, defaultModel = "whisper-large-v3-turbo") {
+      constructor(apiKey, defaultModel = "whisper-large-v3-turbo", scopedFetch = globalThis.fetch, getScopedFetch) {
         this.apiKey = apiKey;
         this.defaultModel = defaultModel;
+        this.scopedFetch = scopedFetch;
+        this.getScopedFetch = getScopedFetch;
       }
       apiKey;
       defaultModel;
+      scopedFetch;
+      getScopedFetch;
       name = "groq";
       /**
        * Transcribes audio using the Groq Whisper API.
@@ -1573,7 +1726,7 @@ var init_groq = __esm({
         if (options?.language) {
           form.append("language", options.language);
         }
-        const resp = await fetch(GROQ_API_URL, {
+        const resp = await (this.getScopedFetch?.() ?? this.scopedFetch)(GROQ_API_URL, {
           method: "POST",
           headers: { Authorization: `Bearer ${this.apiKey}` },
           body: form
@@ -1693,8 +1846,1065 @@ var init_native_stt = __esm({
   }
 });
 
+// src/core/network/proxy-types.ts
+var PROXY_PROTOCOLS;
+var init_proxy_types = __esm({
+  "src/core/network/proxy-types.ts"() {
+    "use strict";
+    PROXY_PROTOCOLS = ["http", "https", "socks5", "socks5h"];
+  }
+});
+
+// src/core/network/proxy-store.ts
+import fs15 from "fs";
+import path15 from "path";
+import net from "net";
+function atomicWrite(file, value, mode) {
+  fs15.mkdirSync(path15.dirname(file), { recursive: true, mode: 448 });
+  const tmp = `${file}.${process.pid}.${Date.now()}.tmp`;
+  fs15.writeFileSync(tmp, `${JSON.stringify(value, null, 2)}
+`, { mode, flag: "wx" });
+  fs15.chmodSync(tmp, mode);
+  const fd = fs15.openSync(tmp, "r");
+  fs15.fsyncSync(fd);
+  fs15.closeSync(fd);
+  fs15.renameSync(tmp, file);
+  try {
+    const dir = fs15.openSync(path15.dirname(file), "r");
+    fs15.fsyncSync(dir);
+    fs15.closeSync(dir);
+  } catch {
+  }
+}
+function isRoute(value) {
+  return value === "direct" || value === "inherit" || typeof value === "string" && /^profile:[a-z0-9][a-z0-9._-]{0,63}$/i.test(value);
+}
+function isProxyScope(value) {
+  return typeof value === "string" && /^[a-z0-9][a-z0-9_-]*(?:\.[a-z0-9][a-z0-9_-]*)+$/i.test(value) && value.length <= 160;
+}
+function canonicalStoredHost(value) {
+  if (typeof value !== "string" || !value || /[\u0000-\u001f\u007f\s/@?#]/.test(value)) throw new Error("invalid profile host");
+  if (value.startsWith("[") && value.endsWith("]") && net.isIP(value.slice(1, -1)) === 6) return value.slice(1, -1).toLowerCase();
+  if (net.isIP(value) === 4 || net.isIP(value) === 6) return value.toLowerCase();
+  const host = value.toLowerCase().replace(/\.$/, "");
+  if (host.length > 253 || !host.split(".").every((label) => /^(?!-)[a-z0-9-]{1,63}(?<!-)$/.test(label))) throw new Error("invalid profile host");
+  return host;
+}
+function validateConfig(value) {
+  if (!value || typeof value !== "object") throw new Error("root must be an object");
+  const v = value;
+  if (v.version === 1) {
+    v.version = PROXY_STORE_VERSION;
+    v.revision = 0;
+    v.persistedScopes = Object.keys(v.routing?.routes ?? {});
+  }
+  if (v.version !== PROXY_STORE_VERSION) throw new Error(`unsupported version ${String(v.version)}`);
+  if (!Number.isSafeInteger(v.revision) || v.revision < 0) throw new Error("revision must be a non-negative integer");
+  if (!Array.isArray(v.profiles) || !v.routing || typeof v.routing !== "object" || !isRoute(v.routing.global) || !v.routing.routes || typeof v.routing.routes !== "object" || Array.isArray(v.routing.routes)) throw new Error("invalid profiles/routing shape");
+  const ids = /* @__PURE__ */ new Set();
+  for (const p of v.profiles) {
+    if (!p || typeof p !== "object" || !/^[a-z0-9][a-z0-9._-]{0,63}$/i.test(p.id) || ids.has(p.id) || !["http", "https", "socks5", "socks5h"].includes(p.protocol) || !Number.isInteger(p.port) || p.port < 1 || p.port > 65535) throw new Error("invalid profile");
+    ids.add(p.id);
+    p.host = canonicalStoredHost(p.host);
+    if (typeof p.name !== "string" || !p.name.trim() || p.name.length > 100 || typeof p.failClosed !== "boolean" || typeof p.hasCredentials !== "boolean") throw new Error("invalid profile fields");
+    if (!Array.isArray(p.noProxy) || p.noProxy.length > 256 || p.noProxy.some((item) => typeof item !== "string" || !item.trim() || /[\u0000-\u001f\u007f\s]/.test(item))) throw new Error("invalid noProxy");
+  }
+  for (const [scope, route] of Object.entries(v.routing.routes)) {
+    if (!isProxyScope(scope) || !isRoute(route)) throw new Error(`invalid route for ${scope}`);
+  }
+  for (const route of [v.routing.global, ...Object.values(v.routing.routes)]) {
+    if (route.startsWith("profile:") && !ids.has(route.slice(8))) throw new Error(`route references missing profile ${route.slice(8)}`);
+  }
+  if (!Array.isArray(v.persistedScopes) || v.persistedScopes.some((s) => !isProxyScope(s)) || new Set(v.persistedScopes).size !== v.persistedScopes.length) throw new Error("invalid persisted scopes");
+  return structuredClone(v);
+}
+function validateSecrets(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error("secrets root must be an object");
+  for (const [id, record] of Object.entries(value)) {
+    if (!/^[a-z0-9][a-z0-9._-]{0,63}$/i.test(id)) throw new Error("invalid secret profile id");
+    if (!record || typeof record !== "object") throw new Error("invalid secret record");
+    const r = record;
+    if (r.username !== void 0 && (typeof r.username !== "string" || r.username.length > 4096 || /[\r\n\u0000]/.test(r.username))) throw new Error("invalid secret username");
+    if (r.password !== void 0 && (typeof r.password !== "string" || r.password.length > 4096 || /[\r\n\u0000]/.test(r.password))) throw new Error("invalid secret password");
+  }
+  return structuredClone(value);
+}
+function validateCredentialConsistency(config, secrets) {
+  const profiles = new Map(config.profiles.map((profile) => [profile.id, profile]));
+  for (const id of Object.keys(secrets)) {
+    if (!profiles.has(id)) throw new Error(`credentials reference missing profile ${id}`);
+  }
+  for (const profile of config.profiles) {
+    const secret = secrets[profile.id];
+    const present = Boolean(secret?.username || secret?.password);
+    if (profile.hasCredentials !== present) throw new Error(`hasCredentials mismatch for profile ${profile.id}`);
+  }
+}
+var PROXY_STORE_VERSION, DEFAULT_CONFIG2, ProxyStoreError, ProxyStoreCorruptError, ProxyRevisionConflictError, ProxyStore;
+var init_proxy_store = __esm({
+  "src/core/network/proxy-store.ts"() {
+    "use strict";
+    PROXY_STORE_VERSION = 2;
+    DEFAULT_CONFIG2 = {
+      version: PROXY_STORE_VERSION,
+      revision: 0,
+      profiles: [],
+      routing: { global: "inherit", routes: {} },
+      persistedScopes: []
+    };
+    ProxyStoreError = class extends Error {
+      constructor(code, message, details) {
+        super(message);
+        this.code = code;
+        this.details = details;
+        this.name = "ProxyStoreError";
+      }
+      code;
+      details;
+    };
+    ProxyStoreCorruptError = class extends ProxyStoreError {
+      constructor(file, reason, quarantine, lkgAvailable = false) {
+        super("PROXY_STORE_CORRUPT", `Proxy policy store is invalid (${path15.basename(file)}): ${reason}`, { file, quarantine, lkgAvailable });
+        this.name = "ProxyStoreCorruptError";
+      }
+    };
+    ProxyRevisionConflictError = class extends ProxyStoreError {
+      constructor(expected, actual) {
+        super("PROXY_REVISION_CONFLICT", `Proxy policy changed concurrently (expected revision ${expected}, current ${actual})`, { expected, actual });
+        this.name = "ProxyRevisionConflictError";
+      }
+    };
+    ProxyStore = class {
+      configPath;
+      secretsPath;
+      journalPath;
+      lkgPath;
+      lockPath;
+      constructor(instanceRoot) {
+        this.configPath = path15.join(instanceRoot, "proxy.json");
+        this.secretsPath = path15.join(instanceRoot, "proxy-secrets.json");
+        this.journalPath = path15.join(instanceRoot, "proxy-transaction.json");
+        this.lkgPath = path15.join(instanceRoot, "proxy-lkg.json");
+        this.lockPath = path15.join(instanceRoot, "proxy.lock");
+        const lock = this.acquireLock();
+        try {
+          this.cleanupOrphans(instanceRoot);
+          this.recoverJournal();
+        } finally {
+          this.releaseLock(lock);
+        }
+      }
+      cleanupOrphans(root) {
+        try {
+          const names = fs15.readdirSync(root);
+          for (const name of names) if (/^proxy.*\.tmp$/.test(name)) fs15.rmSync(path15.join(root, name), { force: true });
+          const quarantines = names.filter((n) => n.includes(".corrupt.")).sort().reverse();
+          for (const name of quarantines.slice(3)) fs15.rmSync(path15.join(root, name), { force: true });
+        } catch {
+        }
+      }
+      quarantine(file) {
+        try {
+          const target = `${file}.corrupt.${Date.now()}`;
+          fs15.copyFileSync(file, target, fs15.constants.COPYFILE_EXCL);
+          fs15.chmodSync(target, 384);
+          return target;
+        } catch {
+          return void 0;
+        }
+      }
+      readConfigFile(file = this.configPath) {
+        try {
+          return validateConfig(JSON.parse(fs15.readFileSync(file, "utf8")));
+        } catch (error) {
+          if (error.code === "ENOENT" && file === this.configPath) return structuredClone(DEFAULT_CONFIG2);
+          const q = file === this.configPath ? this.quarantine(file) : void 0;
+          throw new ProxyStoreCorruptError(file, error.message, q, fs15.existsSync(this.lkgPath));
+        }
+      }
+      readSecretsFile() {
+        try {
+          const stat = fs15.statSync(this.secretsPath);
+          if ((stat.mode & 63) !== 0) throw new Error("secret file mode must be 0600");
+          return validateSecrets(JSON.parse(fs15.readFileSync(this.secretsPath, "utf8")));
+        } catch (error) {
+          if (error.code === "ENOENT") return {};
+          const q = this.quarantine(this.secretsPath);
+          throw new ProxyStoreCorruptError(this.secretsPath, error.message, q, fs15.existsSync(this.lkgPath));
+        }
+      }
+      recoverJournal() {
+        if (!fs15.existsSync(this.journalPath)) return;
+        try {
+          const tx = JSON.parse(fs15.readFileSync(this.journalPath, "utf8"));
+          if (tx.version !== 1) throw new Error("unsupported transaction version");
+          const config = validateConfig(tx.config);
+          const secrets = validateSecrets(tx.secrets);
+          validateCredentialConsistency(config, secrets);
+          atomicWrite(this.configPath, config, 384);
+          atomicWrite(this.secretsPath, secrets, 384);
+          atomicWrite(this.lkgPath, tx, 384);
+          fs15.unlinkSync(this.journalPath);
+        } catch (error) {
+          throw new ProxyStoreCorruptError(this.journalPath, error.message, this.quarantine(this.journalPath), fs15.existsSync(this.lkgPath));
+        }
+      }
+      load() {
+        const config = this.readConfigFile();
+        try {
+          validateCredentialConsistency(config, this.readSecretsFile());
+        } catch (error) {
+          if (error instanceof ProxyStoreCorruptError) throw error;
+          throw new ProxyStoreCorruptError(this.secretsPath, error.message, this.quarantine(this.secretsPath), fs15.existsSync(this.lkgPath));
+        }
+        return config;
+      }
+      getSecrets() {
+        const config = this.readConfigFile();
+        const secrets = this.readSecretsFile();
+        try {
+          validateCredentialConsistency(config, secrets);
+        } catch (error) {
+          throw new ProxyStoreCorruptError(this.secretsPath, error.message, this.quarantine(this.secretsPath), fs15.existsSync(this.lkgPath));
+        }
+        return secrets;
+      }
+      getSecret(id) {
+        return this.getSecrets()[id];
+      }
+      commit(config, secrets, expectedRevision) {
+        const lock = this.acquireLock();
+        try {
+          this.recoverJournal();
+          const actual = this.load().revision;
+          if (actual !== expectedRevision) throw new ProxyRevisionConflictError(expectedRevision, actual);
+          const next = validateConfig({ ...config, version: PROXY_STORE_VERSION, revision: actual + 1 });
+          const cleanSecrets = validateSecrets(secrets);
+          validateCredentialConsistency(next, cleanSecrets);
+          const tx = { version: 1, config: next, secrets: cleanSecrets };
+          atomicWrite(this.journalPath, tx, 384);
+          atomicWrite(this.configPath, next, 384);
+          atomicWrite(this.secretsPath, cleanSecrets, 384);
+          atomicWrite(this.lkgPath, tx, 384);
+          fs15.unlinkSync(this.journalPath);
+          return next;
+        } finally {
+          this.releaseLock(lock);
+        }
+      }
+      releaseLock(fd) {
+        try {
+          fs15.closeSync(fd);
+        } catch {
+        }
+        try {
+          fs15.unlinkSync(this.lockPath);
+        } catch {
+        }
+      }
+      acquireLock() {
+        fs15.mkdirSync(path15.dirname(this.lockPath), { recursive: true, mode: 448 });
+        for (let attempt = 0; attempt < 200; attempt++) {
+          try {
+            const fd = fs15.openSync(this.lockPath, "wx", 384);
+            fs15.writeFileSync(fd, JSON.stringify({ pid: process.pid, createdAt: Date.now() }));
+            fs15.fsyncSync(fd);
+            return fd;
+          } catch (error) {
+            if (error.code !== "EEXIST") throw error;
+            if (this.removeStaleLock()) continue;
+            Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 10);
+          }
+        }
+        throw new ProxyStoreError("PROXY_STORE_BUSY", "Proxy policy store is locked by another process");
+      }
+      removeStaleLock() {
+        try {
+          const lock = JSON.parse(fs15.readFileSync(this.lockPath, "utf8"));
+          const old = !Number.isFinite(lock.createdAt) || Date.now() - Number(lock.createdAt) > 3e4;
+          let dead = false;
+          if (Number.isInteger(lock.pid)) {
+            try {
+              process.kill(lock.pid, 0);
+            } catch (error) {
+              dead = error.code === "ESRCH";
+            }
+          }
+          if (dead || old && !Number.isInteger(lock.pid)) {
+            fs15.unlinkSync(this.lockPath);
+            return true;
+          }
+        } catch {
+          try {
+            if (Date.now() - fs15.statSync(this.lockPath).mtimeMs > 3e4) {
+              fs15.unlinkSync(this.lockPath);
+              return true;
+            }
+          } catch {
+          }
+        }
+        return false;
+      }
+      loadLastKnownGood() {
+        try {
+          return validateConfig(JSON.parse(fs15.readFileSync(this.lkgPath, "utf8")).config);
+        } catch {
+          return void 0;
+        }
+      }
+    };
+  }
+});
+
+// src/core/network/proxy-service.ts
+import { ProxyAgent } from "proxy-agent";
+import nodeFetch from "node-fetch";
+import fs16 from "fs";
+import net2 from "net";
+import { Readable } from "stream";
+import debug from "debug";
+function validateId(value, label) {
+  if (!/^[a-z0-9][a-z0-9._-]{0,63}$/i.test(value)) throw new ProxyValidationError(`Invalid ${label}: ${value}`);
+}
+function canonicalHost(input2) {
+  if (!input2 || /[\u0000-\u001f\u007f\s/@?#]/.test(input2)) throw new ProxyValidationError("Proxy host must be a DNS name, IPv4, or bracketed IPv6 without URL components");
+  if (input2.includes(":")) {
+    if (!(input2.startsWith("[") && input2.endsWith("]")) || net2.isIP(input2.slice(1, -1)) !== 6) throw new ProxyValidationError("IPv6 proxy hosts must be bracketed and must not include a port");
+    return input2.slice(1, -1).toLowerCase();
+  }
+  if (net2.isIP(input2) === 4) return input2;
+  const host = input2.toLowerCase().replace(/\.$/, "");
+  if (host.length > 253 || !host.split(".").every((label) => /^(?!-)[a-z0-9-]{1,63}(?<!-)$/.test(label))) throw new ProxyValidationError("Invalid proxy DNS host");
+  return host;
+}
+function categoryDefault(scope) {
+  const dot = scope.indexOf(".");
+  return dot > 0 ? `${scope.slice(0, dot)}.default` : void 0;
+}
+function routeProfileId(route) {
+  return route.startsWith("profile:") ? route.slice("profile:".length) : void 0;
+}
+function proxyUrl(profile, secret) {
+  const host = net2.isIP(profile.host) === 6 ? `[${profile.host}]` : profile.host;
+  const url = new URL(`${profile.protocol}://${host}:${profile.port}`);
+  const username = secret?.username;
+  if (username) url.username = username;
+  if (secret?.password) url.password = secret.password;
+  return url.toString();
+}
+function shouldBypassProxy(target, noProxy) {
+  const url = new URL(target);
+  const host = url.hostname.toLowerCase().replace(/^\[|\]$/g, "");
+  const hostAndPort = `${net2.isIP(host) === 6 ? `[${host}]` : host}:${url.port || (url.protocol === "https:" ? "443" : "80")}`;
+  return noProxy.some((raw) => {
+    const pattern = raw.trim().toLowerCase();
+    if (!pattern) return false;
+    if (pattern === "*") return true;
+    if (pattern.replace(/^\[|\]$/g, "") === host) return true;
+    if (pattern.startsWith("[") && pattern.includes("]:") || pattern.includes(":") && net2.isIP(pattern) !== 6) return hostAndPort === pattern;
+    const normalized = pattern.startsWith("*.") ? pattern.slice(1) : pattern;
+    return host === normalized.replace(/^\./, "") || normalized.startsWith(".") && host.endsWith(normalized);
+  });
+}
+function safeError(error) {
+  const message = error instanceof Error ? error.message : "Proxy request failed";
+  return new Error(redactNetworkSecrets(message));
+}
+function normalizeResponse(response) {
+  if (response instanceof Response) return response;
+  const body = response.body ? Readable.toWeb(response.body) : null;
+  return copyResponse(response, body);
+}
+async function fetchThroughAgent(input2, init, agent) {
+  if (typeof ReadableStream !== "undefined" && init?.body instanceof ReadableStream) {
+    throw new ProxyValidationError("Web ReadableStream request bodies are not supported by scoped fetch; use string, URLSearchParams, Blob, or FormData");
+  }
+  if (typeof Request !== "undefined" && input2 instanceof Request) {
+    const inherited = {
+      method: input2.method,
+      headers: Object.fromEntries(input2.headers.entries()),
+      redirect: input2.redirect,
+      signal: input2.signal
+    };
+    if (!init?.body && input2.method !== "GET" && input2.method !== "HEAD") inherited.body = Buffer.from(await input2.clone().arrayBuffer());
+    return nodeFetch(input2.url, { ...inherited, ...init, agent });
+  }
+  return nodeFetch(input2, { ...init, agent });
+}
+function copyResponse(response, body) {
+  const noBody = response.status === 101 || response.status === 204 || response.status === 205 || response.status === 304;
+  const copy = new Response(noBody ? null : body, { status: response.status, statusText: response.statusText, headers: response.headers });
+  for (const key of ["url", "redirected", "type"]) {
+    try {
+      Object.defineProperty(copy, key, { value: response[key], configurable: true });
+    } catch {
+    }
+  }
+  return copy;
+}
+var enabledDebug, PROXY_ENV_KEYS, ProxyValidationError, ProxyUnknownScopeError, ProxyProfileInUseError, ProxyRouteTestError, ProxyProfileTestError, ProxyService;
+var init_proxy_service = __esm({
+  "src/core/network/proxy-service.ts"() {
+    "use strict";
+    init_proxy_types();
+    init_proxy_store();
+    init_proxy_store();
+    init_network_redaction();
+    enabledDebug = debug.disable();
+    debug.enable(sanitizeProxyDebugNamespaces(enabledDebug) ?? "");
+    PROXY_ENV_KEYS = [
+      "HTTP_PROXY",
+      "HTTPS_PROXY",
+      "ALL_PROXY",
+      "NO_PROXY",
+      "http_proxy",
+      "https_proxy",
+      "all_proxy",
+      "no_proxy",
+      "NODE_USE_ENV_PROXY"
+    ];
+    ProxyValidationError = class extends Error {
+      constructor(message, code = "PROXY_VALIDATION_ERROR") {
+        super(message);
+        this.code = code;
+        this.name = "ProxyValidationError";
+      }
+      code;
+    };
+    ProxyUnknownScopeError = class extends ProxyValidationError {
+      constructor(scope) {
+        super(`Proxy scope "${scope}" is not registered`, "PROXY_UNKNOWN_SCOPE");
+      }
+    };
+    ProxyProfileInUseError = class extends ProxyValidationError {
+      constructor(id) {
+        super(`Proxy profile "${id}" is still used by routing`, "PROXY_PROFILE_IN_USE");
+      }
+    };
+    ProxyRouteTestError = class extends Error {
+      code = "PROXY_ROUTE_TEST_FAILED";
+      constructor(scope, cause) {
+        const reason = safeError(cause).message;
+        super(`Proxy route test failed for ${scope}; route was not changed: ${reason}`);
+        this.name = "ProxyRouteTestError";
+      }
+    };
+    ProxyProfileTestError = class extends Error {
+      code = "PROXY_PROFILE_TEST_FAILED";
+      constructor(profileId, cause) {
+        const reason = safeError(cause).message;
+        super(`Proxy profile test failed for ${profileId}; profile was not changed: ${reason}`);
+        this.name = "ProxyProfileTestError";
+      }
+    };
+    ProxyService = class {
+      constructor(instanceRoot, retiredLeaseTimeoutMs = 5 * 6e4, allowedNodeEnvironmentFlags = process.allowedNodeEnvironmentFlags) {
+        this.retiredLeaseTimeoutMs = retiredLeaseTimeoutMs;
+        this.allowedNodeEnvironmentFlags = allowedNodeEnvironmentFlags;
+        this.store = new ProxyStore(instanceRoot);
+        try {
+          const config = this.store.load();
+          for (const scope of [...config.persistedScopes, ...Object.keys(config.routing.routes)]) this.scopes.add(scope);
+        } catch {
+        }
+      }
+      retiredLeaseTimeoutMs;
+      allowedNodeEnvironmentFlags;
+      store;
+      scopes = /* @__PURE__ */ new Set([
+        "channels.default",
+        "channels.telegram",
+        "agents.default",
+        "agents.codex",
+        "agents.cursor",
+        "services.default",
+        "services.npmUpdate",
+        "services.agentRegistry",
+        "services.pluginInstaller",
+        "services.speechDownloads",
+        "plugins.default"
+      ]);
+      testers = /* @__PURE__ */ new Map();
+      listeners = /* @__PURE__ */ new Set();
+      transports = /* @__PURE__ */ new Map();
+      facades = /* @__PURE__ */ new Map();
+      mutationQueue = Promise.resolve();
+      policyGeneration = 0;
+      maxTransports = 128;
+      serialize(operation) {
+        const next = this.mutationQueue.then(operation, operation);
+        this.mutationQueue = next.then(() => void 0, () => void 0);
+        return next;
+      }
+      getPolicyGeneration() {
+        return this.policyGeneration;
+      }
+      invalidatePolicyBeforeCommit(config, affectedProfile, changedScope) {
+        const agentAffected = changedScope === "global" || changedScope === "agents.default" || Boolean(changedScope?.startsWith("agents.")) || Boolean(affectedProfile && Object.entries(config.routing.routes).some(([scope, route]) => scope.startsWith("agents.") && route === `profile:${affectedProfile}`)) || Boolean(affectedProfile && config.routing.global === `profile:${affectedProfile}`);
+        if (agentAffected) this.policyGeneration++;
+        return agentAffected;
+      }
+      registerScope(scope) {
+        if (!isProxyScope(scope)) throw new ProxyValidationError(`Invalid proxy scope: ${scope}`);
+        this.scopes.add(scope);
+        this.persistScope(scope);
+        return () => this.scopes.delete(scope);
+      }
+      registerRouteTester(scope, tester) {
+        this.registerScope(scope);
+        this.testers.set(scope, tester);
+        return () => this.testers.delete(scope);
+      }
+      /**
+       * Scope discovery is part of the durable policy schema, not only an in-memory
+       * UI concern. Persisting registrations lets an operator configure a plugin or
+       * agent while it is temporarily disabled and keeps the category list stable
+       * across daemon restarts.
+       */
+      persistScope(scope) {
+        const config = this.store.load();
+        if (config.persistedScopes.includes(scope)) return;
+        config.persistedScopes = [...config.persistedScopes, scope].sort();
+        this.store.commit(config, this.store.getSecrets(), config.revision);
+      }
+      onRouteChanged(listener) {
+        this.listeners.add(listener);
+        return () => this.listeners.delete(listener);
+      }
+      listProfiles() {
+        return this.store.load().profiles.map((profile) => ({ ...profile }));
+      }
+      getProfile(id) {
+        return this.listProfiles().find((profile) => profile.id === id);
+      }
+      saveProfile(input2) {
+        const config = this.store.load();
+        const secrets = this.store.getSecrets();
+        const { profile, nextSecrets } = this.buildProfile(input2, config, secrets);
+        const affectedScopes = this.scopesUsingProfile(config, input2.id);
+        this.invalidatePolicyBeforeCommit(config, input2.id);
+        config.profiles = [...config.profiles.filter((p) => p.id !== profile.id), profile];
+        config.persistedScopes = [.../* @__PURE__ */ new Set([...config.persistedScopes, ...Object.keys(config.routing.routes)])];
+        this.store.commit(config, nextSecrets, config.revision);
+        this.retireScopes(affectedScopes);
+        return profile;
+      }
+      buildProfile(input2, config, secrets) {
+        validateId(input2.id, "profile id");
+        if (!PROXY_PROTOCOLS.includes(input2.protocol)) throw new ProxyValidationError(`Unsupported proxy protocol: ${input2.protocol}`);
+        if (!Number.isInteger(input2.port) || input2.port < 1 || input2.port > 65535) throw new ProxyValidationError("Proxy port must be between 1 and 65535");
+        const host = canonicalHost(input2.host);
+        const existing = config.profiles.find((p) => p.id === input2.id);
+        const nextSecrets = structuredClone(secrets);
+        if (input2.username !== void 0 || input2.password !== void 0) nextSecrets[input2.id] = { username: input2.username ?? nextSecrets[input2.id]?.username, password: input2.password ?? nextSecrets[input2.id]?.password };
+        const secret = nextSecrets[input2.id];
+        return { profile: {
+          id: input2.id,
+          name: input2.name ?? existing?.name ?? input2.id,
+          protocol: input2.protocol,
+          host,
+          port: input2.port,
+          noProxy: input2.noProxy ?? existing?.noProxy ?? ["localhost", "127.0.0.1", "::1"],
+          failClosed: input2.failClosed ?? existing?.failClosed ?? true,
+          hasCredentials: Boolean(secret?.username || secret?.password)
+        }, nextSecrets };
+      }
+      async saveProfileSafely(input2, expectedRevision) {
+        return this.serialize(async () => {
+          const config = this.store.load();
+          const secrets = this.store.getSecrets();
+          if (expectedRevision !== void 0 && config.revision !== expectedRevision) throw new ProxyRevisionConflictError(expectedRevision, config.revision);
+          const { profile: candidate, nextSecrets } = this.buildProfile(input2, config, secrets);
+          const affectedScopes = this.scopesUsingProfile(config, input2.id);
+          const candidateSecret = nextSecrets[input2.id];
+          for (const [scope, tester] of this.testers) {
+            if (this.resolve(scope).profile?.id === input2.id) {
+              const fetcher = this.createProfileFetch(candidate, candidateSecret);
+              try {
+                await tester(fetcher);
+              } catch (error) {
+                throw new ProxyProfileTestError(input2.id, error);
+              } finally {
+                fetcher.destroy?.();
+              }
+            }
+          }
+          this.invalidatePolicyBeforeCommit(config, input2.id);
+          config.profiles = [...config.profiles.filter((p) => p.id !== candidate.id), candidate];
+          const saved = this.store.commit(config, nextSecrets, config.revision).profiles.find((p) => p.id === candidate.id);
+          this.retireScopes(affectedScopes);
+          return saved;
+        });
+      }
+      /** Import a conventional proxy env file without ever returning or logging its credential URL. */
+      importEnvFile(id, envFile, name) {
+        return this.saveProfile(this.parseEnvFile(id, envFile, name));
+      }
+      parseEnvFile(id, envFile, name) {
+        const stat = fs16.statSync(envFile);
+        if (!stat.isFile()) throw new Error("Proxy env path is not a file");
+        if ((stat.mode & 63) !== 0) throw new Error("Proxy env file must have mode 0600");
+        const values = {};
+        for (const rawLine of fs16.readFileSync(envFile, "utf8").split(/\r?\n/)) {
+          const line = rawLine.trim();
+          if (!line || line.startsWith("#")) continue;
+          const match = /^(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)=(.*)$/.exec(line);
+          if (!match) continue;
+          let value = match[2].trim();
+          if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) value = value.slice(1, -1);
+          values[match[1]] = value;
+        }
+        const httpUrl = values.HTTP_PROXY ?? values.http_proxy;
+        const httpsUrl = values.HTTPS_PROXY ?? values.https_proxy;
+        if (httpUrl && httpsUrl && httpUrl !== httpsUrl) throw new ProxyValidationError("HTTP_PROXY and HTTPS_PROXY differ; use one canonical proxy URL or create separate profiles");
+        const rawUrl = httpsUrl ?? httpUrl ?? values.ALL_PROXY ?? values.all_proxy;
+        if (!rawUrl) throw new Error("No proxy URL found in env file");
+        let url;
+        try {
+          url = new URL(rawUrl);
+        } catch {
+          throw new ProxyValidationError("Proxy env contains an invalid URL");
+        }
+        const protocol = url.protocol.slice(0, -1);
+        if (!PROXY_PROTOCOLS.includes(protocol)) throw new ProxyValidationError(`Unsupported proxy protocol: ${protocol}`);
+        if (url.pathname && url.pathname !== "/" || url.search || url.hash) throw new ProxyValidationError("Proxy URL must not contain path, query, or fragment");
+        const noProxy = values.NO_PROXY ?? values.no_proxy;
+        return {
+          id,
+          name,
+          protocol,
+          // WHATWG URL keeps IPv6 hostnames bracketed. Preserve that canonical
+          // input form here; buildProfile performs the single host normalization.
+          host: url.hostname,
+          port: Number(url.port || (protocol.startsWith("socks") ? 1080 : protocol === "https" ? 443 : 80)),
+          username: decodeURIComponent(url.username),
+          password: decodeURIComponent(url.password),
+          noProxy: noProxy ? noProxy.split(",").map((item) => item.trim()).filter(Boolean) : void 0
+        };
+      }
+      async importEnvFileSafely(id, envFile, name, expectedRevision) {
+        return this.saveProfileSafely(this.parseEnvFile(id, envFile, name), expectedRevision);
+      }
+      async deleteProfile(id, expectedRevision) {
+        return this.serialize(async () => {
+          const config = this.store.load();
+          const secrets = this.store.getSecrets();
+          if (expectedRevision !== void 0 && config.revision !== expectedRevision) throw new ProxyRevisionConflictError(expectedRevision, config.revision);
+          if (!config.profiles.some((p) => p.id === id)) throw new ProxyValidationError(`Proxy profile "${id}" does not exist`);
+          if (Object.values(config.routing.routes).includes(`profile:${id}`) || config.routing.global === `profile:${id}`) throw new ProxyProfileInUseError(id);
+          config.profiles = config.profiles.filter((p) => p.id !== id);
+          delete secrets[id];
+          this.store.commit(config, secrets, config.revision);
+        });
+      }
+      resolve(scope, routeOverride) {
+        const config = this.store.load();
+        return this.resolveFromConfig(scope, config, routeOverride);
+      }
+      resolveFromConfig(scope, config, routeOverride) {
+        const exact = routeOverride ?? config.routing.routes[scope];
+        const category = categoryDefault(scope);
+        const route = exact ?? (category ? config.routing.routes[category] : void 0) ?? config.routing.global;
+        const resolvedFrom = routeOverride ? "candidate" : exact ? scope : category && config.routing.routes[category] ? category : "global";
+        const id = routeProfileId(route);
+        const profile = id ? config.profiles.find((item) => item.id === id) : void 0;
+        if (id && !profile) throw new Error(`Proxy profile "${id}" does not exist`);
+        return { scope, route, resolvedFrom, profile };
+      }
+      async setRoute(scope, route, expectedRevision) {
+        return this.serialize(async () => {
+          if (scope !== "global" && !this.getKnownScopes().includes(scope)) throw new ProxyUnknownScopeError(scope);
+          this.validateRoute(route);
+          const config = this.store.load();
+          if (expectedRevision !== void 0 && config.revision !== expectedRevision) throw new ProxyRevisionConflictError(expectedRevision, config.revision);
+          const candidate = structuredClone(config);
+          if (scope === "global") candidate.routing.global = route;
+          else candidate.routing.routes[scope] = route;
+          const affectedScopes = this.changedResolutionScopes(config, candidate);
+          try {
+            await this.testCandidateRoutes(config, candidate);
+          } catch (error) {
+            throw new ProxyRouteTestError(scope, error);
+          }
+          const affectsAgents = this.invalidatePolicyBeforeCommit(config, void 0, scope);
+          candidate.persistedScopes = [.../* @__PURE__ */ new Set([...candidate.persistedScopes, ...scope === "global" ? [] : [scope]])];
+          this.store.commit(candidate, this.store.getSecrets(), config.revision);
+          this.retireScopes(affectedScopes);
+          for (const listener of this.listeners) await listener(scope, route);
+          return {
+            scope,
+            route,
+            warmPoolInvalidated: affectsAgents,
+            activeAgentProcessesUnaffected: affectsAgents
+          };
+        });
+      }
+      async clearRoute(scope, expectedRevision) {
+        return this.serialize(async () => {
+          const config = this.store.load();
+          if (expectedRevision !== void 0 && config.revision !== expectedRevision) throw new ProxyRevisionConflictError(expectedRevision, config.revision);
+          const candidate = structuredClone(config);
+          if (scope === "global") candidate.routing.global = "inherit";
+          else {
+            if (!this.getKnownScopes().includes(scope)) throw new ProxyUnknownScopeError(scope);
+            delete candidate.routing.routes[scope];
+          }
+          const affectedScopes = this.changedResolutionScopes(config, candidate);
+          try {
+            await this.testCandidateRoutes(config, candidate);
+          } catch (error) {
+            throw new ProxyRouteTestError(scope, error);
+          }
+          this.invalidatePolicyBeforeCommit(config, void 0, scope);
+          this.store.commit(candidate, this.store.getSecrets(), config.revision);
+          this.retireScopes(affectedScopes);
+          for (const listener of this.listeners) await listener(scope, this.resolve(scope).route);
+        });
+      }
+      getKnownScopes() {
+        const config = this.store.load();
+        return [.../* @__PURE__ */ new Set([...this.scopes, ...config.persistedScopes, ...Object.keys(config.routing.routes)])].sort();
+      }
+      createFetch(scope, routeOverride) {
+        if (routeOverride) return this.createTransport(scope, routeOverride);
+        if (!this.getKnownScopes().includes(scope)) throw new ProxyUnknownScopeError(scope);
+        const existing = this.facades.get(scope);
+        if (existing) return existing;
+        const facade = (async (input2, init) => {
+          const entry = this.acquireTransport(scope);
+          try {
+            const response = await entry.fetcher(input2, init);
+            return this.releaseWithResponse(response, entry);
+          } catch (error) {
+            this.releaseTransport(entry);
+            throw error;
+          }
+        });
+        this.facades.set(scope, facade);
+        return facade;
+      }
+      createTransport(scope, routeOverride) {
+        const resolution = this.resolve(scope, routeOverride);
+        const cacheKey = JSON.stringify({
+          route: resolution.route,
+          profile: resolution.profile,
+          inherited: resolution.route === "inherit" ? [process.env.HTTP_PROXY, process.env.HTTPS_PROXY, process.env.ALL_PROXY, process.env.NO_PROXY] : void 0
+        });
+        if (!routeOverride) {
+          const cached = this.transports.get(scope);
+          if (cached?.key === cacheKey) return cached.fetcher;
+        }
+        if (resolution.route === "direct") {
+          const fetcher2 = this.createDirectFetch();
+          if (!routeOverride) this.cacheTransport(scope, cacheKey, fetcher2);
+          return fetcher2;
+        }
+        let agent;
+        if (resolution.route === "inherit") {
+          const hasInheritedProxy = process.env.HTTPS_PROXY ?? process.env.https_proxy ?? process.env.HTTP_PROXY ?? process.env.http_proxy ?? process.env.ALL_PROXY ?? process.env.all_proxy;
+          if (!hasInheritedProxy) {
+            const fetcher2 = this.createDirectFetch();
+            if (!routeOverride) this.cacheTransport(scope, cacheKey, fetcher2);
+            return fetcher2;
+          }
+          agent = new ProxyAgent();
+        } else if (resolution.profile) {
+          const fetcher2 = this.createProfileFetch(resolution.profile, this.store.getSecret(resolution.profile.id));
+          if (!routeOverride) this.cacheTransport(scope, cacheKey, fetcher2);
+          return fetcher2;
+        } else {
+          return globalThis.fetch.bind(globalThis);
+        }
+        const fetcher = (async (input2, init) => {
+          try {
+            const response = await fetchThroughAgent(input2, init, agent);
+            return normalizeResponse(response);
+          } catch (error) {
+            if (resolution.profile?.failClosed !== false) throw safeError(error);
+            return globalThis.fetch(input2, init);
+          }
+        });
+        fetcher.destroy = () => agent.destroy?.();
+        if (!routeOverride) this.cacheTransport(scope, cacheKey, fetcher);
+        return fetcher;
+      }
+      cacheTransport(scope, key, fetcher) {
+        const old = this.transports.get(scope);
+        if (old && old.fetcher !== fetcher) this.retireTransport(old);
+        this.transports.set(scope, { key, fetcher, active: 0, retired: false, destroyed: false, leases: /* @__PURE__ */ new Set() });
+        while (this.transports.size > this.maxTransports) {
+          const oldest = this.transports.keys().next().value;
+          if (!oldest) break;
+          const entry = this.transports.get(oldest);
+          if (entry) this.retireTransport(entry);
+          this.transports.delete(oldest);
+        }
+      }
+      buildAgentEnv(agentName, inherited) {
+        return this.buildChildEnv(`agents.${agentName}`, inherited);
+      }
+      buildChildEnv(scope, inherited) {
+        const resolution = this.resolve(scope);
+        const env = { ...inherited };
+        if (env.DEBUG) {
+          const safeDebug = sanitizeProxyDebugNamespaces(env.DEBUG);
+          if (safeDebug) env.DEBUG = safeDebug;
+          else delete env.DEBUG;
+        }
+        if (resolution.route === "inherit") return env;
+        for (const key of PROXY_ENV_KEYS) delete env[key];
+        if (env.NODE_OPTIONS) {
+          env.NODE_OPTIONS = env.NODE_OPTIONS.split(/\s+/).filter((flag) => flag !== "--use-env-proxy").join(" ");
+          if (!env.NODE_OPTIONS) delete env.NODE_OPTIONS;
+        }
+        if (resolution.route === "direct") {
+          env.NODE_USE_ENV_PROXY = "0";
+          return env;
+        }
+        const profile = resolution.profile;
+        const url = proxyUrl(profile, this.store.getSecret(profile.id));
+        const noProxy = profile.noProxy.join(",");
+        if (profile.protocol === "http" || profile.protocol === "https") {
+          env.HTTP_PROXY = env.http_proxy = url;
+          env.HTTPS_PROXY = env.https_proxy = url;
+          env.NODE_USE_ENV_PROXY = "1";
+          if (this.allowedNodeEnvironmentFlags.has("--use-env-proxy")) {
+            env.NODE_OPTIONS = [env.NODE_OPTIONS, "--use-env-proxy"].filter(Boolean).join(" ");
+          }
+        } else {
+          env.ALL_PROXY = env.all_proxy = url;
+        }
+        env.NO_PROXY = env.no_proxy = noProxy;
+        return env;
+      }
+      async test(scope, targetUrl = "https://api.ipify.org?format=json") {
+        if (!this.getKnownScopes().includes(scope)) throw new ProxyUnknownScopeError(scope);
+        let response;
+        try {
+          response = await this.createFetch(scope)(targetUrl, { signal: AbortSignal.timeout(1e4) });
+          return { ok: response.ok, status: response.status };
+        } catch (error) {
+          return { ok: false, error: error instanceof Error ? redactNetworkSecrets(error.message) : "Proxy test failed" };
+        } finally {
+          try {
+            await response?.body?.cancel();
+          } catch {
+          }
+        }
+      }
+      async testProfile(id, targetUrl) {
+        if (!this.getProfile(id)) return { ok: false, error: `Proxy profile "${id}" does not exist` };
+        let fetcher;
+        let response;
+        try {
+          fetcher = this.createTransport("services.proxyTest", `profile:${id}`);
+          response = await fetcher(targetUrl ?? "https://api.ipify.org?format=json", {
+            signal: AbortSignal.timeout(1e4)
+          });
+          return { ok: response.ok, status: response.status };
+        } catch (error) {
+          return { ok: false, error: error instanceof Error ? redactNetworkSecrets(error.message) : "Proxy test failed" };
+        } finally {
+          try {
+            await response?.body?.cancel();
+          } catch {
+          }
+          ;
+          fetcher?.destroy?.();
+        }
+      }
+      status() {
+        const config = this.store.load();
+        const scopes = this.getKnownScopes();
+        const daemonVariables = PROXY_ENV_KEYS.filter((key) => {
+          const value = process.env[key];
+          return !["NO_PROXY", "no_proxy", "NODE_USE_ENV_PROXY"].includes(key) && value !== void 0 && value !== "";
+        });
+        return {
+          revision: config.revision,
+          profiles: this.listProfiles(),
+          routing: config.routing,
+          scopes,
+          diagnostics: scopes.map((scope) => {
+            const resolution = this.resolve(scope);
+            const child = scope.startsWith("agents.") || scope.startsWith("services.");
+            const socks = child && Boolean(resolution.profile?.protocol.startsWith("socks"));
+            return {
+              scope,
+              route: resolution.route,
+              resolvedFrom: resolution.resolvedFrom,
+              childProcessSupport: child ? socks ? "best-effort-socks-env" : "native-env" : "not-applicable",
+              warning: socks ? "SOCKS support depends on the child process honoring ALL_PROXY; npm and arbitrary ACP clients may require HTTP/HTTPS profiles." : void 0
+            };
+          }),
+          environment: {
+            daemonWideProxyActive: daemonVariables.length > 0,
+            compatibilityMode: daemonVariables.length > 0,
+            variables: daemonVariables,
+            message: daemonVariables.length > 0 ? "Daemon-wide proxy environment is active. Scoped direct transports remain isolated, but category isolation is in compatibility mode until legacy wrapper/drop-in proxy injection is removed." : "No daemon-wide proxy environment detected; native scoped routing is authoritative."
+          }
+        };
+      }
+      validateRoute(route) {
+        if (route === "direct" || route === "inherit") return;
+        const id = routeProfileId(route);
+        if (!id || !this.getProfile(id)) throw new ProxyValidationError(`Proxy profile "${id ?? route}" does not exist`);
+      }
+      async testCandidateRoutes(current, candidate) {
+        for (const [scope, tester] of this.testers) {
+          const before = this.resolveFromConfig(scope, current);
+          const after = this.resolveFromConfig(scope, candidate);
+          if (before.route !== after.route || before.profile?.id !== after.profile?.id) {
+            const fetcher = this.createTransport(scope, after.route);
+            try {
+              await tester(fetcher);
+            } finally {
+              fetcher.destroy?.();
+            }
+          }
+        }
+      }
+      createProfileFetch(profile, secret) {
+        const url = proxyUrl(profile, secret);
+        const agent = new ProxyAgent({
+          getProxyForUrl: (target) => shouldBypassProxy(target, profile.noProxy) ? "" : url
+        });
+        const directFallback = profile.failClosed === false ? this.createDirectFetch() : void 0;
+        const fetcher = (async (input2, init) => {
+          try {
+            const response = await fetchThroughAgent(input2, init, agent);
+            return normalizeResponse(response);
+          } catch (error) {
+            if (profile.failClosed !== false) throw safeError(error);
+            return directFallback(input2, init);
+          }
+        });
+        fetcher.destroy = () => {
+          agent.destroy?.();
+          directFallback?.destroy?.();
+        };
+        return fetcher;
+      }
+      /** Direct transport that ignores daemon-wide env proxy flags without global mutation. */
+      createDirectFetch() {
+        const agent = new ProxyAgent({ getProxyForUrl: () => "" });
+        const fetcher = (async (input2, init) => {
+          const response = await fetchThroughAgent(input2, init, agent);
+          return normalizeResponse(response);
+        });
+        fetcher.destroy = () => agent.destroy?.();
+        return fetcher;
+      }
+      acquireTransport(scope) {
+        this.createTransport(scope);
+        const entry = this.transports.get(scope);
+        entry.active++;
+        return entry;
+      }
+      releaseTransport(entry) {
+        entry.active = Math.max(0, entry.active - 1);
+        if (entry.retired && entry.active === 0) this.destroyTransport(entry);
+      }
+      retireTransport(entry) {
+        entry.retired = true;
+        if (entry.active === 0) {
+          this.destroyTransport(entry);
+          return;
+        }
+        if (!entry.retirementTimer) {
+          entry.retirementTimer = setTimeout(() => {
+            const reason = new Error("Retired proxy transport response exceeded its maximum lease");
+            for (const abort of [...entry.leases]) abort(reason);
+            this.destroyTransport(entry);
+          }, this.retiredLeaseTimeoutMs);
+          entry.retirementTimer.unref?.();
+        }
+      }
+      destroyTransport(entry) {
+        if (entry.destroyed) return;
+        entry.destroyed = true;
+        if (entry.retirementTimer) clearTimeout(entry.retirementTimer);
+        entry.fetcher.destroy?.();
+      }
+      retireScopes(scopes) {
+        for (const scope of scopes) {
+          const entry = this.transports.get(scope);
+          if (!entry) continue;
+          this.transports.delete(scope);
+          this.retireTransport(entry);
+        }
+      }
+      scopesUsingProfile(config, profileId) {
+        return this.allScopes(config).filter((scope) => this.resolveFromConfig(scope, config).profile?.id === profileId);
+      }
+      changedResolutionScopes(before, after) {
+        return this.allScopes(before, after).filter((scope) => {
+          const a = this.resolveFromConfig(scope, before);
+          const b = this.resolveFromConfig(scope, after);
+          return JSON.stringify([a.route, a.profile]) !== JSON.stringify([b.route, b.profile]);
+        });
+      }
+      allScopes(...configs) {
+        return [.../* @__PURE__ */ new Set([...this.scopes, ...configs.flatMap((config) => [...config.persistedScopes, ...Object.keys(config.routing.routes)])])];
+      }
+      releaseWithResponse(response, entry) {
+        const release = () => this.releaseTransport(entry);
+        if (!response.body) {
+          release();
+          return response;
+        }
+        const reader = response.body.getReader();
+        let released = false;
+        let bodyController;
+        const done = () => {
+          if (!released) {
+            released = true;
+            entry.leases.delete(abort);
+            release();
+          }
+        };
+        const abort = (reason) => {
+          if (released) return;
+          try {
+            bodyController?.error(reason);
+          } catch {
+          }
+          void reader.cancel(reason).then(done, done);
+        };
+        entry.leases.add(abort);
+        if (entry.destroyed) abort(new Error("Retired proxy transport response exceeded its maximum lease"));
+        const body = new ReadableStream({
+          start(controller) {
+            bodyController = controller;
+          },
+          async pull(controller) {
+            try {
+              const chunk = await reader.read();
+              if (chunk.done) {
+                done();
+                controller.close();
+              } else controller.enqueue(chunk.value);
+            } catch (error) {
+              done();
+              controller.error(error);
+            }
+          },
+          async cancel(reason) {
+            try {
+              await reader.cancel(reason);
+            } finally {
+              done();
+            }
+          }
+        });
+        return copyResponse(response, body);
+      }
+    };
+  }
+});
+
 // src/core/doctor/checks/config.ts
-import * as fs15 from "fs";
+import * as fs17 from "fs";
 var configCheck;
 var init_config2 = __esm({
   "src/core/doctor/checks/config.ts"() {
@@ -1706,14 +2916,14 @@ var init_config2 = __esm({
       order: 1,
       async run(ctx) {
         const results = [];
-        if (!fs15.existsSync(ctx.configPath)) {
+        if (!fs17.existsSync(ctx.configPath)) {
           results.push({ status: "fail", message: "Config file not found" });
           return results;
         }
         results.push({ status: "pass", message: "Config file exists" });
         let raw;
         try {
-          raw = JSON.parse(fs15.readFileSync(ctx.configPath, "utf-8"));
+          raw = JSON.parse(fs17.readFileSync(ctx.configPath, "utf-8"));
         } catch (err) {
           results.push({
             status: "fail",
@@ -1732,7 +2942,7 @@ var init_config2 = __esm({
             fixRisk: "safe",
             fix: async () => {
               applyMigrations(raw);
-              fs15.writeFileSync(ctx.configPath, JSON.stringify(raw, null, 2));
+              fs17.writeFileSync(ctx.configPath, JSON.stringify(raw, null, 2));
               return { success: true, message: "applied migrations" };
             }
           });
@@ -1756,8 +2966,8 @@ var init_config2 = __esm({
 
 // src/core/doctor/checks/agents.ts
 import { execFileSync as execFileSync3 } from "child_process";
-import * as fs16 from "fs";
-import * as path16 from "path";
+import * as fs18 from "fs";
+import * as path17 from "path";
 function commandExists2(cmd) {
   try {
     execFileSync3("which", [cmd], { stdio: "pipe" });
@@ -1766,9 +2976,9 @@ function commandExists2(cmd) {
   }
   let dir = process.cwd();
   while (true) {
-    const binPath = path16.join(dir, "node_modules", ".bin", cmd);
-    if (fs16.existsSync(binPath)) return true;
-    const parent = path16.dirname(dir);
+    const binPath = path17.join(dir, "node_modules", ".bin", cmd);
+    if (fs18.existsSync(binPath)) return true;
+    const parent = path17.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -1790,9 +3000,9 @@ var init_agents = __esm({
         const defaultAgent = ctx.config.defaultAgent;
         let agents = {};
         try {
-          const agentsPath = path16.join(ctx.dataDir, "agents.json");
-          if (fs16.existsSync(agentsPath)) {
-            const data = JSON.parse(fs16.readFileSync(agentsPath, "utf-8"));
+          const agentsPath = path17.join(ctx.dataDir, "agents.json");
+          if (fs18.existsSync(agentsPath)) {
+            const data = JSON.parse(fs18.readFileSync(agentsPath, "utf-8"));
             agents = data.installed ?? {};
           }
         } catch {
@@ -1830,8 +3040,8 @@ var settings_manager_exports = {};
 __export(settings_manager_exports, {
   SettingsManager: () => SettingsManager
 });
-import fs17 from "fs";
-import path17 from "path";
+import fs19 from "fs";
+import path18 from "path";
 var SettingsManager, SettingsAPIImpl;
 var init_settings_manager = __esm({
   "src/core/plugin/settings-manager.ts"() {
@@ -1854,7 +3064,7 @@ var init_settings_manager = __esm({
       async loadSettings(pluginName) {
         const settingsPath = this.getSettingsPath(pluginName);
         try {
-          const content = fs17.readFileSync(settingsPath, "utf-8");
+          const content = fs19.readFileSync(settingsPath, "utf-8");
           return JSON.parse(content);
         } catch {
           return {};
@@ -1874,7 +3084,7 @@ var init_settings_manager = __esm({
       }
       /** Resolve the absolute path to a plugin's settings.json file. */
       getSettingsPath(pluginName) {
-        return path17.join(this.basePath, pluginName, "settings.json");
+        return path18.join(this.basePath, pluginName, "settings.json");
       }
       async getPluginSettings(pluginName) {
         return this.loadSettings(pluginName);
@@ -1895,7 +3105,7 @@ var init_settings_manager = __esm({
       readFile() {
         if (this.cache !== null) return this.cache;
         try {
-          const content = fs17.readFileSync(this.settingsPath, "utf-8");
+          const content = fs19.readFileSync(this.settingsPath, "utf-8");
           this.cache = JSON.parse(content);
           return this.cache;
         } catch {
@@ -1904,9 +3114,9 @@ var init_settings_manager = __esm({
         }
       }
       writeFile(data) {
-        const dir = path17.dirname(this.settingsPath);
-        fs17.mkdirSync(dir, { recursive: true });
-        fs17.writeFileSync(this.settingsPath, JSON.stringify(data, null, 2));
+        const dir = path18.dirname(this.settingsPath);
+        fs19.mkdirSync(dir, { recursive: true });
+        fs19.writeFileSync(this.settingsPath, JSON.stringify(data, null, 2));
         this.cache = data;
       }
       async get(key) {
@@ -1941,11 +3151,12 @@ var init_settings_manager = __esm({
 });
 
 // src/core/doctor/checks/telegram.ts
-import * as path18 from "path";
+import * as path19 from "path";
 var BOT_TOKEN_REGEX, telegramCheck;
 var init_telegram = __esm({
   "src/core/doctor/checks/telegram.ts"() {
     "use strict";
+    init_network_redaction();
     BOT_TOKEN_REGEX = /^\d+:[A-Za-z0-9_-]{35,}$/;
     telegramCheck = {
       name: "Telegram",
@@ -1957,7 +3168,7 @@ var init_telegram = __esm({
           return results;
         }
         const { SettingsManager: SettingsManager2 } = await Promise.resolve().then(() => (init_settings_manager(), settings_manager_exports));
-        const sm = new SettingsManager2(path18.join(ctx.pluginsDir, "data"));
+        const sm = new SettingsManager2(path19.join(ctx.pluginsDir, "data"));
         const ps = await sm.loadSettings("@openacp/telegram");
         const botToken = ps.botToken;
         const chatId = ps.chatId;
@@ -1970,9 +3181,17 @@ var init_telegram = __esm({
           return results;
         }
         results.push({ status: "pass", message: "Bot token format valid" });
+        let telegramFetch;
+        try {
+          telegramFetch = ctx.fetchForScope("channels.telegram");
+        } catch (err) {
+          const message = err instanceof Error ? err.message : String(err);
+          results.push({ status: "fail", message: `Cannot initialize Telegram transport: ${redactNetworkSecrets(message)}` });
+          return results;
+        }
         let botId;
         try {
-          const res = await fetch(`https://api.telegram.org/bot${botToken}/getMe`);
+          const res = await telegramFetch(`https://api.telegram.org/bot${botToken}/getMe`);
           const data = await res.json();
           if (data.ok && data.result) {
             botId = data.result.id;
@@ -1982,7 +3201,8 @@ var init_telegram = __esm({
             return results;
           }
         } catch (err) {
-          results.push({ status: "fail", message: `Cannot reach Telegram API: ${err instanceof Error ? err.message : String(err)}` });
+          const message = err instanceof Error ? err.message : String(err);
+          results.push({ status: "fail", message: `Cannot reach Telegram API: ${redactNetworkSecrets(message)}` });
           return results;
         }
         if (!chatId || chatId === 0) {
@@ -1990,7 +3210,7 @@ var init_telegram = __esm({
           return results;
         }
         try {
-          const res = await fetch(`https://api.telegram.org/bot${botToken}/getChat`, {
+          const res = await telegramFetch(`https://api.telegram.org/bot${botToken}/getChat`, {
             method: "POST",
             headers: { "Content-Type": "application/json" },
             body: JSON.stringify({ chat_id: chatId })
@@ -2010,11 +3230,12 @@ var init_telegram = __esm({
             results.push({ status: "pass", message: `Chat is supergroup with topics ("${data.result.title}")` });
           }
         } catch (err) {
-          results.push({ status: "fail", message: `Cannot validate chat: ${err instanceof Error ? err.message : String(err)}` });
+          const message = err instanceof Error ? err.message : String(err);
+          results.push({ status: "fail", message: `Cannot validate chat: ${redactNetworkSecrets(message)}` });
           return results;
         }
         try {
-          const res = await fetch(`https://api.telegram.org/bot${botToken}/getChatMember`, {
+          const res = await telegramFetch(`https://api.telegram.org/bot${botToken}/getChatMember`, {
             method: "POST",
             headers: { "Content-Type": "application/json" },
             body: JSON.stringify({ chat_id: chatId, user_id: botId })
@@ -2031,7 +3252,8 @@ var init_telegram = __esm({
             });
           }
         } catch (err) {
-          results.push({ status: "fail", message: `Admin check failed: ${err instanceof Error ? err.message : String(err)}` });
+          const message = err instanceof Error ? err.message : String(err);
+          results.push({ status: "fail", message: `Admin check failed: ${redactNetworkSecrets(message)}` });
         }
         return results;
       }
@@ -2040,7 +3262,7 @@ var init_telegram = __esm({
 });
 
 // src/core/doctor/checks/storage.ts
-import * as fs18 from "fs";
+import * as fs20 from "fs";
 var storageCheck;
 var init_storage = __esm({
   "src/core/doctor/checks/storage.ts"() {
@@ -2050,28 +3272,28 @@ var init_storage = __esm({
       order: 4,
       async run(ctx) {
         const results = [];
-        if (!fs18.existsSync(ctx.dataDir)) {
+        if (!fs20.existsSync(ctx.dataDir)) {
           results.push({
             status: "fail",
             message: "Data directory ~/.openacp does not exist",
             fixable: true,
             fixRisk: "safe",
             fix: async () => {
-              fs18.mkdirSync(ctx.dataDir, { recursive: true });
+              fs20.mkdirSync(ctx.dataDir, { recursive: true });
               return { success: true, message: "created directory" };
             }
           });
         } else {
           try {
-            fs18.accessSync(ctx.dataDir, fs18.constants.W_OK);
+            fs20.accessSync(ctx.dataDir, fs20.constants.W_OK);
             results.push({ status: "pass", message: "Data directory exists and writable" });
           } catch {
             results.push({ status: "fail", message: "Data directory not writable" });
           }
         }
-        if (fs18.existsSync(ctx.sessionsPath)) {
+        if (fs20.existsSync(ctx.sessionsPath)) {
           try {
-            const content = fs18.readFileSync(ctx.sessionsPath, "utf-8");
+            const content = fs20.readFileSync(ctx.sessionsPath, "utf-8");
             const data = JSON.parse(content);
             if (typeof data === "object" && data !== null && "sessions" in data) {
               results.push({ status: "pass", message: "Sessions file valid" });
@@ -2082,7 +3304,7 @@ var init_storage = __esm({
                 fixable: true,
                 fixRisk: "risky",
                 fix: async () => {
-                  fs18.writeFileSync(ctx.sessionsPath, JSON.stringify({ version: 1, sessions: {} }, null, 2));
+                  fs20.writeFileSync(ctx.sessionsPath, JSON.stringify({ version: 1, sessions: {} }, null, 2));
                   return { success: true, message: "reset sessions file" };
                 }
               });
@@ -2094,7 +3316,7 @@ var init_storage = __esm({
               fixable: true,
               fixRisk: "risky",
               fix: async () => {
-                fs18.writeFileSync(ctx.sessionsPath, JSON.stringify({ version: 1, sessions: {} }, null, 2));
+                fs20.writeFileSync(ctx.sessionsPath, JSON.stringify({ version: 1, sessions: {} }, null, 2));
                 return { success: true, message: "reset sessions file" };
               }
             });
@@ -2102,20 +3324,20 @@ var init_storage = __esm({
         } else {
           results.push({ status: "pass", message: "Sessions file not present yet (created on first session)" });
         }
-        if (!fs18.existsSync(ctx.logsDir)) {
+        if (!fs20.existsSync(ctx.logsDir)) {
           results.push({
             status: "warn",
             message: "Log directory does not exist",
             fixable: true,
             fixRisk: "safe",
             fix: async () => {
-              fs18.mkdirSync(ctx.logsDir, { recursive: true });
+              fs20.mkdirSync(ctx.logsDir, { recursive: true });
               return { success: true, message: "created log directory" };
             }
           });
         } else {
           try {
-            fs18.accessSync(ctx.logsDir, fs18.constants.W_OK);
+            fs20.accessSync(ctx.logsDir, fs20.constants.W_OK);
             results.push({ status: "pass", message: "Log directory exists and writable" });
           } catch {
             results.push({ status: "fail", message: "Log directory not writable" });
@@ -2128,8 +3350,8 @@ var init_storage = __esm({
 });
 
 // src/core/doctor/checks/workspace.ts
-import * as fs19 from "fs";
-import * as path19 from "path";
+import * as fs21 from "fs";
+import * as path20 from "path";
 var workspaceCheck;
 var init_workspace = __esm({
   "src/core/doctor/checks/workspace.ts"() {
@@ -2139,21 +3361,21 @@ var init_workspace = __esm({
       order: 5,
       async run(ctx) {
         const results = [];
-        const workspace = path19.dirname(ctx.dataDir);
-        if (!fs19.existsSync(workspace)) {
+        const workspace = path20.dirname(ctx.dataDir);
+        if (!fs21.existsSync(workspace)) {
           results.push({
             status: "warn",
             message: `Workspace directory does not exist: ${workspace}`,
             fixable: true,
             fixRisk: "safe",
             fix: async () => {
-              fs19.mkdirSync(workspace, { recursive: true });
+              fs21.mkdirSync(workspace, { recursive: true });
               return { success: true, message: "created directory" };
             }
           });
         } else {
           try {
-            fs19.accessSync(workspace, fs19.constants.W_OK);
+            fs21.accessSync(workspace, fs21.constants.W_OK);
             results.push({ status: "pass", message: `Workspace directory exists: ${workspace}` });
           } catch {
             results.push({ status: "fail", message: `Workspace directory not writable: ${workspace}` });
@@ -2166,8 +3388,8 @@ var init_workspace = __esm({
 });
 
 // src/core/doctor/checks/plugins.ts
-import * as fs20 from "fs";
-import * as path20 from "path";
+import * as fs22 from "fs";
+import * as path21 from "path";
 var pluginsCheck;
 var init_plugins = __esm({
   "src/core/doctor/checks/plugins.ts"() {
@@ -2177,16 +3399,16 @@ var init_plugins = __esm({
       order: 6,
       async run(ctx) {
         const results = [];
-        if (!fs20.existsSync(ctx.pluginsDir)) {
+        if (!fs22.existsSync(ctx.pluginsDir)) {
           results.push({
             status: "warn",
             message: "Plugins directory does not exist",
             fixable: true,
             fixRisk: "safe",
             fix: async () => {
-              fs20.mkdirSync(ctx.pluginsDir, { recursive: true });
-              fs20.writeFileSync(
-                path20.join(ctx.pluginsDir, "package.json"),
+              fs22.mkdirSync(ctx.pluginsDir, { recursive: true });
+              fs22.writeFileSync(
+                path21.join(ctx.pluginsDir, "package.json"),
                 JSON.stringify({ name: "openacp-plugins", private: true, dependencies: {} }, null, 2)
               );
               return { success: true, message: "initialized plugins directory" };
@@ -2195,15 +3417,15 @@ var init_plugins = __esm({
           return results;
         }
         results.push({ status: "pass", message: "Plugins directory exists" });
-        const pkgPath = path20.join(ctx.pluginsDir, "package.json");
-        if (!fs20.existsSync(pkgPath)) {
+        const pkgPath = path21.join(ctx.pluginsDir, "package.json");
+        if (!fs22.existsSync(pkgPath)) {
           results.push({
             status: "warn",
             message: "Plugins package.json missing",
             fixable: true,
             fixRisk: "safe",
             fix: async () => {
-              fs20.writeFileSync(
+              fs22.writeFileSync(
                 pkgPath,
                 JSON.stringify({ name: "openacp-plugins", private: true, dependencies: {} }, null, 2)
               );
@@ -2213,7 +3435,7 @@ var init_plugins = __esm({
           return results;
         }
         try {
-          const pkg = JSON.parse(fs20.readFileSync(pkgPath, "utf-8"));
+          const pkg = JSON.parse(fs22.readFileSync(pkgPath, "utf-8"));
           const deps = pkg.dependencies || {};
           const count = Object.keys(deps).length;
           results.push({ status: "pass", message: `Plugins package.json valid (${count} plugins)` });
@@ -2224,7 +3446,7 @@ var init_plugins = __esm({
             fixable: true,
             fixRisk: "risky",
             fix: async () => {
-              fs20.writeFileSync(
+              fs22.writeFileSync(
                 pkgPath,
                 JSON.stringify({ name: "openacp-plugins", private: true, dependencies: {} }, null, 2)
               );
@@ -2239,8 +3461,8 @@ var init_plugins = __esm({
 });
 
 // src/core/doctor/checks/daemon.ts
-import * as fs21 from "fs";
-import * as net from "net";
+import * as fs23 from "fs";
+import * as net3 from "net";
 function isProcessAlive(pid) {
   try {
     process.kill(pid, 0);
@@ -2251,7 +3473,7 @@ function isProcessAlive(pid) {
 }
 function checkPortInUse(port) {
   return new Promise((resolve7) => {
-    const server = net.createServer();
+    const server = net3.createServer();
     server.once("error", () => resolve7(true));
     server.once("listening", () => {
       server.close();
@@ -2269,8 +3491,8 @@ var init_daemon = __esm({
       order: 7,
       async run(ctx) {
         const results = [];
-        if (fs21.existsSync(ctx.pidPath)) {
-          const content = fs21.readFileSync(ctx.pidPath, "utf-8").trim();
+        if (fs23.existsSync(ctx.pidPath)) {
+          const content = fs23.readFileSync(ctx.pidPath, "utf-8").trim();
           const pid = parseInt(content, 10);
           if (isNaN(pid)) {
             results.push({
@@ -2279,7 +3501,7 @@ var init_daemon = __esm({
               fixable: true,
               fixRisk: "safe",
               fix: async () => {
-                fs21.unlinkSync(ctx.pidPath);
+                fs23.unlinkSync(ctx.pidPath);
                 return { success: true, message: "removed invalid PID file" };
               }
             });
@@ -2290,7 +3512,7 @@ var init_daemon = __esm({
               fixable: true,
               fixRisk: "safe",
               fix: async () => {
-                fs21.unlinkSync(ctx.pidPath);
+                fs23.unlinkSync(ctx.pidPath);
                 return { success: true, message: "removed stale PID file" };
               }
             });
@@ -2298,8 +3520,8 @@ var init_daemon = __esm({
             results.push({ status: "pass", message: `Daemon running (PID ${pid})` });
           }
         }
-        if (fs21.existsSync(ctx.portFilePath)) {
-          const content = fs21.readFileSync(ctx.portFilePath, "utf-8").trim();
+        if (fs23.existsSync(ctx.portFilePath)) {
+          const content = fs23.readFileSync(ctx.portFilePath, "utf-8").trim();
           const port = parseInt(content, 10);
           if (isNaN(port)) {
             results.push({
@@ -2308,7 +3530,7 @@ var init_daemon = __esm({
               fixable: true,
               fixRisk: "safe",
               fix: async () => {
-                fs21.unlinkSync(ctx.portFilePath);
+                fs23.unlinkSync(ctx.portFilePath);
                 return { success: true, message: "removed invalid port file" };
               }
             });
@@ -2320,8 +3542,8 @@ var init_daemon = __esm({
           const apiPort = 21420;
           const inUse = await checkPortInUse(apiPort);
           if (inUse) {
-            if (fs21.existsSync(ctx.pidPath)) {
-              const pid = parseInt(fs21.readFileSync(ctx.pidPath, "utf-8").trim(), 10);
+            if (fs23.existsSync(ctx.pidPath)) {
+              const pid = parseInt(fs23.readFileSync(ctx.pidPath, "utf-8").trim(), 10);
               if (!isNaN(pid) && isProcessAlive(pid)) {
                 results.push({ status: "pass", message: `API port ${apiPort} in use by OpenACP daemon` });
               } else {
@@ -2341,17 +3563,17 @@ var init_daemon = __esm({
 });
 
 // src/core/utils/install-binary.ts
-import fs22 from "fs";
-import path21 from "path";
+import fs24 from "fs";
+import path22 from "path";
 import https from "https";
 import os5 from "os";
 import { execFileSync as execFileSync4 } from "child_process";
 function downloadFile(url, dest, maxRedirects = 10) {
   return new Promise((resolve7, reject) => {
-    const file = fs22.createWriteStream(dest);
+    const file = fs24.createWriteStream(dest);
     const cleanup = () => {
       try {
-        if (fs22.existsSync(dest)) fs22.unlinkSync(dest);
+        if (fs24.existsSync(dest)) fs24.unlinkSync(dest);
       } catch {
       }
     };
@@ -2417,36 +3639,36 @@ function getDownloadUrl(spec) {
 async function ensureBinary(spec, binDir) {
   const resolvedBinDir = binDir ?? DEFAULT_BIN_DIR;
   const binName = IS_WINDOWS ? `${spec.name}.exe` : spec.name;
-  const binPath = path21.join(resolvedBinDir, binName);
+  const binPath = path22.join(resolvedBinDir, binName);
   if (commandExists(spec.name)) {
     log18.debug({ name: spec.name }, "Found in PATH");
     return spec.name;
   }
-  if (fs22.existsSync(binPath)) {
-    if (!IS_WINDOWS) fs22.chmodSync(binPath, "755");
+  if (fs24.existsSync(binPath)) {
+    if (!IS_WINDOWS) fs24.chmodSync(binPath, "755");
     log18.debug({ name: spec.name, path: binPath }, "Found in ~/.openacp/bin");
     return binPath;
   }
   log18.info({ name: spec.name }, "Not found, downloading from GitHub...");
-  fs22.mkdirSync(resolvedBinDir, { recursive: true });
+  fs24.mkdirSync(resolvedBinDir, { recursive: true });
   const url = getDownloadUrl(spec);
   const isArchive = spec.isArchive?.(url) ?? false;
-  const downloadDest = isArchive ? path21.join(resolvedBinDir, `${spec.name}.tgz`) : binPath;
+  const downloadDest = isArchive ? path22.join(resolvedBinDir, `${spec.name}.tgz`) : binPath;
   await downloadFile(url, downloadDest);
   if (isArchive) {
     const listing = execFileSync4("tar", ["-tf", downloadDest], { stdio: "pipe" }).toString().trim().split("\n").filter(Boolean);
     validateTarContents(listing, resolvedBinDir);
     execFileSync4("tar", ["-xzf", downloadDest, "-C", resolvedBinDir], { stdio: "pipe" });
     try {
-      fs22.unlinkSync(downloadDest);
+      fs24.unlinkSync(downloadDest);
     } catch {
     }
   }
-  if (!fs22.existsSync(binPath)) {
+  if (!fs24.existsSync(binPath)) {
     throw new Error(`${spec.name}: binary not found at ${binPath} after download/extraction. The archive structure may have changed.`);
   }
   if (!IS_WINDOWS) {
-    fs22.chmodSync(binPath, "755");
+    fs24.chmodSync(binPath, "755");
   }
   log18.info({ name: spec.name, path: binPath }, "Installed successfully");
   return binPath;
@@ -2459,7 +3681,7 @@ var init_install_binary = __esm({
     init_agent_dependencies();
     init_agent_installer();
     log18 = createChildLogger({ module: "binary-installer" });
-    DEFAULT_BIN_DIR = path21.join(os5.homedir(), ".openacp", "bin");
+    DEFAULT_BIN_DIR = path22.join(os5.homedir(), ".openacp", "bin");
     IS_WINDOWS = os5.platform() === "win32";
   }
 });
@@ -2500,8 +3722,8 @@ var init_install_cloudflared = __esm({
 });
 
 // src/core/doctor/checks/tunnel.ts
-import * as fs23 from "fs";
-import * as path22 from "path";
+import * as fs25 from "fs";
+import * as path23 from "path";
 import * as os6 from "os";
 import { execFileSync as execFileSync5 } from "child_process";
 var tunnelCheck;
@@ -2518,7 +3740,7 @@ var init_tunnel = __esm({
           return results;
         }
         const { SettingsManager: SettingsManager2 } = await Promise.resolve().then(() => (init_settings_manager(), settings_manager_exports));
-        const sm = new SettingsManager2(path22.join(ctx.pluginsDir, "data"));
+        const sm = new SettingsManager2(path23.join(ctx.pluginsDir, "data"));
         const tunnelSettings = await sm.loadSettings("@openacp/tunnel");
         const tunnelEnabled = tunnelSettings.enabled ?? false;
         const provider = tunnelSettings.provider ?? "cloudflare";
@@ -2530,9 +3752,9 @@ var init_tunnel = __esm({
         results.push({ status: "pass", message: `Tunnel provider: ${provider}` });
         if (provider === "cloudflare") {
           const binName = os6.platform() === "win32" ? "cloudflared.exe" : "cloudflared";
-          const binPath = path22.join(ctx.dataDir, "bin", binName);
+          const binPath = path23.join(ctx.dataDir, "bin", binName);
           let found = false;
-          if (fs23.existsSync(binPath)) {
+          if (fs25.existsSync(binPath)) {
             found = true;
           } else {
             try {
@@ -2572,14 +3794,48 @@ var init_tunnel = __esm({
   }
 });
 
+// src/core/doctor/checks/proxy.ts
+var proxyCheck;
+var init_proxy = __esm({
+  "src/core/doctor/checks/proxy.ts"() {
+    "use strict";
+    init_proxy_service();
+    init_proxy_store();
+    proxyCheck = {
+      name: "Proxy routing",
+      order: 85,
+      async run(ctx) {
+        try {
+          if (ctx.dataDir) new ProxyStore(ctx.dataDir).load();
+        } catch (error) {
+          if (error instanceof ProxyStoreCorruptError) return [{ status: "fail", message: `${error.message}. Network consumers are fail-closed; inspect quarantine/LKG before recovery.` }];
+          throw error;
+        }
+        const variables = PROXY_ENV_KEYS.filter((key) => {
+          const value = process.env[key];
+          return !["NO_PROXY", "no_proxy", "NODE_USE_ENV_PROXY"].includes(key) && value !== void 0 && value !== "";
+        });
+        if (!variables.length) {
+          return [{ status: "pass", message: "No daemon-wide proxy environment; native scoped routing is authoritative" }];
+        }
+        return [{
+          status: "warn",
+          message: `Daemon-wide proxy environment active (${variables.join(", ")}); scoped routing is in compatibility mode until legacy wrapper/drop-in injection is removed`
+        }];
+      }
+    };
+  }
+});
+
 // src/core/doctor/index.ts
-import * as fs24 from "fs";
-import * as path23 from "path";
+import * as fs26 from "fs";
+import * as path24 from "path";
 var ALL_CHECKS, CHECK_TIMEOUT_MS, DoctorEngine;
 var init_doctor = __esm({
   "src/core/doctor/index.ts"() {
     "use strict";
     init_config();
+    init_proxy_service();
     init_config2();
     init_agents();
     init_telegram();
@@ -2588,6 +3844,7 @@ var init_doctor = __esm({
     init_plugins();
     init_daemon();
     init_tunnel();
+    init_proxy();
     ALL_CHECKS = [
       configCheck,
       agentsCheck,
@@ -2596,15 +3853,18 @@ var init_doctor = __esm({
       workspaceCheck,
       pluginsCheck,
       daemonCheck,
-      tunnelCheck
+      tunnelCheck,
+      proxyCheck
     ];
     CHECK_TIMEOUT_MS = 1e4;
     DoctorEngine = class {
       dryRun;
       dataDir;
+      proxyService;
       constructor(options) {
         this.dryRun = options?.dryRun ?? false;
         this.dataDir = options.dataDir;
+        this.proxyService = options?.proxyService ?? new ProxyService(this.dataDir);
       }
       /**
        * Executes all checks and returns an aggregated report.
@@ -2662,28 +3922,29 @@ var init_doctor = __esm({
       /** Constructs the shared context used by all checks — loads config if available. */
       async buildContext() {
         const dataDir = this.dataDir;
-        const configPath = process.env.OPENACP_CONFIG_PATH || path23.join(dataDir, "config.json");
+        const configPath = process.env.OPENACP_CONFIG_PATH || path24.join(dataDir, "config.json");
         let config = null;
         let rawConfig = null;
         try {
-          const content = fs24.readFileSync(configPath, "utf-8");
+          const content = fs26.readFileSync(configPath, "utf-8");
           rawConfig = JSON.parse(content);
           const cm = new ConfigManager(configPath);
           await cm.load();
           config = cm.get();
         } catch {
         }
-        const logsDir = config ? expandHome2(config.logging.logDir) : path23.join(dataDir, "logs");
+        const logsDir = config ? expandHome2(config.logging.logDir) : path24.join(dataDir, "logs");
         return {
           config,
           rawConfig,
           configPath,
           dataDir,
-          sessionsPath: path23.join(dataDir, "sessions.json"),
-          pidPath: path23.join(dataDir, "openacp.pid"),
-          portFilePath: path23.join(dataDir, "api.port"),
-          pluginsDir: path23.join(dataDir, "plugins"),
-          logsDir
+          sessionsPath: path24.join(dataDir, "sessions.json"),
+          pidPath: path24.join(dataDir, "openacp.pid"),
+          portFilePath: path24.join(dataDir, "api.port"),
+          pluginsDir: path24.join(dataDir, "plugins"),
+          logsDir,
+          fetchForScope: (scope) => this.proxyService.createFetch(scope)
         };
       }
     };
@@ -2691,11 +3952,11 @@ var init_doctor = __esm({
 });
 
 // src/core/instance/instance-context.ts
-import path25 from "path";
-import fs26 from "fs";
+import path26 from "path";
+import fs28 from "fs";
 import os8 from "os";
 function getGlobalRoot() {
-  return path25.join(os8.homedir(), ".openacp");
+  return path26.join(os8.homedir(), ".openacp");
 }
 var init_instance_context = __esm({
   "src/core/instance/instance-context.ts"() {
@@ -2704,12 +3965,12 @@ var init_instance_context = __esm({
 });
 
 // src/core/instance/instance-registry.ts
-import fs27 from "fs";
-import path26 from "path";
+import fs29 from "fs";
+import path27 from "path";
 import { randomUUID as randomUUID2 } from "crypto";
 function readIdFromConfig(instanceRoot) {
   try {
-    const raw = JSON.parse(fs27.readFileSync(path26.join(instanceRoot, "config.json"), "utf-8"));
+    const raw = JSON.parse(fs29.readFileSync(path27.join(instanceRoot, "config.json"), "utf-8"));
     return typeof raw.id === "string" && raw.id ? raw.id : null;
   } catch {
     return null;
@@ -2728,7 +3989,7 @@ var init_instance_registry = __esm({
       /** Load the registry from disk. If the file is missing or corrupt, starts fresh. */
       load() {
         try {
-          const raw = fs27.readFileSync(this.registryPath, "utf-8");
+          const raw = fs29.readFileSync(this.registryPath, "utf-8");
           const parsed = JSON.parse(raw);
           if (parsed.version === 1 && parsed.instances) {
             this.data = parsed;
@@ -2755,9 +4016,9 @@ var init_instance_registry = __esm({
       }
       /** Persist the registry to disk, creating parent directories if needed. */
       save() {
-        const dir = path26.dirname(this.registryPath);
-        fs27.mkdirSync(dir, { recursive: true });
-        fs27.writeFileSync(this.registryPath, JSON.stringify(this.data, null, 2));
+        const dir = path27.dirname(this.registryPath);
+        fs29.mkdirSync(dir, { recursive: true });
+        fs29.writeFileSync(this.registryPath, JSON.stringify(this.data, null, 2));
       }
       /** Add or update an instance entry in the registry. Does not persist — call save() after. */
       register(id, root) {
@@ -2824,15 +4085,15 @@ __export(plugin_installer_exports, {
 });
 import { execFile as execFile2 } from "child_process";
 import { promisify as promisify2 } from "util";
-import * as fs29 from "fs/promises";
-import * as path28 from "path";
+import * as fs31 from "fs/promises";
+import * as path29 from "path";
 import { pathToFileURL } from "url";
 async function importFromDir(packageName, dir) {
-  const pkgDir = path28.join(dir, "node_modules", ...packageName.split("/"));
-  const pkgJsonPath = path28.join(pkgDir, "package.json");
+  const pkgDir = path29.join(dir, "node_modules", ...packageName.split("/"));
+  const pkgJsonPath = path29.join(pkgDir, "package.json");
   let pkgJson;
   try {
-    pkgJson = JSON.parse(await fs29.readFile(pkgJsonPath, "utf-8"));
+    pkgJson = JSON.parse(await fs31.readFile(pkgJsonPath, "utf-8"));
   } catch (err) {
     throw new Error(`Cannot read package.json for "${packageName}" at ${pkgJsonPath}: ${err.message}`);
   }
@@ -2845,15 +4106,15 @@ async function importFromDir(packageName, dir) {
   } else {
     entry = pkgJson.main ?? "index.js";
   }
-  const entryPath = path28.join(pkgDir, entry);
+  const entryPath = path29.join(pkgDir, entry);
   try {
-    await fs29.access(entryPath);
+    await fs31.access(entryPath);
   } catch {
     throw new Error(`Entry point "${entry}" not found for "${packageName}" at ${entryPath}`);
   }
   return import(pathToFileURL(entryPath).href);
 }
-async function installNpmPlugin(packageName, pluginsDir) {
+async function installNpmPlugin(packageName, pluginsDir, childEnv) {
   if (!VALID_NPM_NAME.test(packageName)) {
     throw new Error(`Invalid package name: "${packageName}". Must be a valid npm package name.`);
   }
@@ -2863,7 +4124,8 @@ async function installNpmPlugin(packageName, pluginsDir) {
   } catch {
   }
   await execFileAsync2("npm", ["install", packageName, "--prefix", dir, "--save", "--ignore-scripts"], {
-    timeout: 6e4
+    timeout: 6e4,
+    env: childEnv
   });
   return await importFromDir(packageName, dir);
 }
@@ -2939,10 +4201,10 @@ var install_context_exports = {};
 __export(install_context_exports, {
   createInstallContext: () => createInstallContext
 });
-import path29 from "path";
+import path30 from "path";
 function createInstallContext(opts) {
   const { pluginName, settingsManager, basePath, instanceRoot } = opts;
-  const dataDir = path29.join(basePath, pluginName, "data");
+  const dataDir = path30.join(basePath, pluginName, "data");
   return {
     pluginName,
     terminal: createTerminalIO(),
@@ -2967,16 +4229,17 @@ __export(api_client_exports, {
   readApiPort: () => readApiPort,
   readApiSecret: () => readApiSecret,
   removeStalePortFile: () => removeStalePortFile,
+  waitForApiReady: () => waitForApiReady,
   waitForPortFile: () => waitForPortFile
 });
-import * as fs30 from "fs";
-import * as path30 from "path";
+import * as fs32 from "fs";
+import * as path31 from "path";
 import { setTimeout as sleep } from "timers/promises";
 function defaultPortFile(root) {
-  return path30.join(root, "api.port");
+  return path31.join(root, "api.port");
 }
 function defaultSecretFile(root) {
-  return path30.join(root, "api-secret");
+  return path31.join(root, "api-secret");
 }
 async function waitForPortFile(portFilePath, timeoutMs = 5e3, intervalMs = 100) {
   const deadline = Date.now() + timeoutMs;
@@ -2987,10 +4250,30 @@ async function waitForPortFile(portFilePath, timeoutMs = 5e3, intervalMs = 100)
   }
   return readApiPort(portFilePath);
 }
+async function waitForApiReady(instanceRoot, expectedInstanceId, timeoutMs = 1e4, intervalMs = 100) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    const port = readApiPort(void 0, instanceRoot);
+    if (port !== null) {
+      try {
+        const response = await fetch(`http://127.0.0.1:${port}/api/v1/system/health`, {
+          signal: AbortSignal.timeout(Math.max(intervalMs, 250))
+        });
+        if (response.ok) {
+          const body = await response.json();
+          if (body.status === "ok" && body.instanceId === expectedInstanceId) return port;
+        }
+      } catch {
+      }
+    }
+    await sleep(intervalMs);
+  }
+  return null;
+}
 function readApiPort(portFilePath, instanceRoot) {
   const filePath = portFilePath ?? defaultPortFile(instanceRoot);
   try {
-    const content = fs30.readFileSync(filePath, "utf-8").trim();
+    const content = fs32.readFileSync(filePath, "utf-8").trim();
     const port = parseInt(content, 10);
     return isNaN(port) ? null : port;
   } catch {
@@ -3000,7 +4283,7 @@ function readApiPort(portFilePath, instanceRoot) {
 function readApiSecret(secretFilePath, instanceRoot) {
   const filePath = secretFilePath ?? defaultSecretFile(instanceRoot);
   try {
-    const content = fs30.readFileSync(filePath, "utf-8").trim();
+    const content = fs32.readFileSync(filePath, "utf-8").trim();
     return content || null;
   } catch {
     return null;
@@ -3009,7 +4292,7 @@ function readApiSecret(secretFilePath, instanceRoot) {
 function removeStalePortFile(portFilePath, instanceRoot) {
   const filePath = portFilePath ?? defaultPortFile(instanceRoot);
   try {
-    fs30.unlinkSync(filePath);
+    fs32.unlinkSync(filePath);
   } catch {
   }
 }
@@ -3146,8 +4429,8 @@ var init_notification = __esm({
 });
 
 // src/plugins/file-service/file-service.ts
-import fs32 from "fs";
-import path33 from "path";
+import fs34 from "fs";
+import path34 from "path";
 import { OggOpusDecoder } from "ogg-opus-decoder";
 import wav from "node-wav";
 function classifyMime(mimeType) {
@@ -3204,14 +4487,14 @@ var init_file_service = __esm({
         const cutoff = Date.now() - maxAgeDays * 24 * 60 * 60 * 1e3;
         let removed = 0;
         try {
-          const entries = await fs32.promises.readdir(this.baseDir, { withFileTypes: true });
+          const entries = await fs34.promises.readdir(this.baseDir, { withFileTypes: true });
           for (const entry of entries) {
             if (!entry.isDirectory()) continue;
-            const dirPath = path33.join(this.baseDir, entry.name);
+            const dirPath = path34.join(this.baseDir, entry.name);
             try {
-              const stat = await fs32.promises.stat(dirPath);
+              const stat = await fs34.promises.stat(dirPath);
               if (stat.mtimeMs < cutoff) {
-                await fs32.promises.rm(dirPath, { recursive: true, force: true });
+                await fs34.promises.rm(dirPath, { recursive: true, force: true });
                 removed++;
               }
             } catch {
@@ -3230,11 +4513,11 @@ var init_file_service = __esm({
        * so the user-facing name is not lost.
        */
       async saveFile(sessionId, fileName, data, mimeType) {
-        const sessionDir = path33.join(this.baseDir, sessionId);
-        await fs32.promises.mkdir(sessionDir, { recursive: true });
+        const sessionDir = path34.join(this.baseDir, sessionId);
+        await fs34.promises.mkdir(sessionDir, { recursive: true });
         const safeName = `${Date.now()}-${fileName.replace(/[^a-zA-Z0-9._-]/g, "_")}`;
-        const filePath = path33.join(sessionDir, safeName);
-        await fs32.promises.writeFile(filePath, data);
+        const filePath = path34.join(sessionDir, safeName);
+        await fs34.promises.writeFile(filePath, data);
         return {
           type: classifyMime(mimeType),
           filePath,
@@ -3249,14 +4532,14 @@ var init_file_service = __esm({
        */
       async resolveFile(filePath) {
         try {
-          const stat = await fs32.promises.stat(filePath);
+          const stat = await fs34.promises.stat(filePath);
           if (!stat.isFile()) return null;
-          const ext = path33.extname(filePath).toLowerCase();
+          const ext = path34.extname(filePath).toLowerCase();
           const mimeType = EXT_TO_MIME[ext] || "application/octet-stream";
           return {
             type: classifyMime(mimeType),
             filePath,
-            fileName: path33.basename(filePath),
+            fileName: path34.basename(filePath),
             mimeType,
             size: stat.size
           };
@@ -3375,6 +4658,10 @@ function globalErrorHandler(error, _request, reply) {
     });
     return;
   }
+  if (error instanceof ConflictError) {
+    reply.status(409).send({ error: { code: error.code, message: error.message, statusCode: 409 } });
+    return;
+  }
   if (error instanceof NotFoundError) {
     reply.status(404).send({
       error: {
@@ -3413,7 +4700,7 @@ function globalErrorHandler(error, _request, reply) {
     }
   });
 }
-var NotFoundError, BadRequestError, ServiceUnavailableError, AuthError;
+var NotFoundError, BadRequestError, ConflictError, ServiceUnavailableError, AuthError;
 var init_error_handler = __esm({
   "src/plugins/api-server/middleware/error-handler.ts"() {
     "use strict";
@@ -3434,6 +4721,14 @@ var init_error_handler = __esm({
       }
       code;
     };
+    ConflictError = class extends Error {
+      constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = "ConflictError";
+      }
+      code;
+    };
     ServiceUnavailableError = class extends Error {
       constructor(code, message) {
         super(message);
@@ -3887,8 +5182,8 @@ data: ${JSON.stringify(data)}
 });
 
 // src/plugins/api-server/static-server.ts
-import * as fs33 from "fs";
-import * as path34 from "path";
+import * as fs35 from "fs";
+import * as path35 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 var MIME_TYPES, StaticServer;
 var init_static_server = __esm({
@@ -3912,16 +5207,16 @@ var init_static_server = __esm({
         this.uiDir = uiDir;
         if (!this.uiDir) {
           const __filename = fileURLToPath2(import.meta.url);
-          const candidate = path34.resolve(path34.dirname(__filename), "../../ui/dist");
-          if (fs33.existsSync(path34.join(candidate, "index.html"))) {
+          const candidate = path35.resolve(path35.dirname(__filename), "../../ui/dist");
+          if (fs35.existsSync(path35.join(candidate, "index.html"))) {
             this.uiDir = candidate;
           }
           if (!this.uiDir) {
-            const publishCandidate = path34.resolve(
-              path34.dirname(__filename),
+            const publishCandidate = path35.resolve(
+              path35.dirname(__filename),
               "../ui"
             );
-            if (fs33.existsSync(path34.join(publishCandidate, "index.html"))) {
+            if (fs35.existsSync(path35.join(publishCandidate, "index.html"))) {
               this.uiDir = publishCandidate;
             }
           }
@@ -3939,23 +5234,23 @@ var init_static_server = __esm({
       serve(req, res) {
         if (!this.uiDir) return false;
         const urlPath = (req.url || "/").split("?")[0];
-        const safePath = path34.normalize(urlPath);
-        const filePath = path34.join(this.uiDir, safePath);
-        if (!filePath.startsWith(this.uiDir + path34.sep) && filePath !== this.uiDir)
+        const safePath = path35.normalize(urlPath);
+        const filePath = path35.join(this.uiDir, safePath);
+        if (!filePath.startsWith(this.uiDir + path35.sep) && filePath !== this.uiDir)
           return false;
         let realFilePath;
         try {
-          realFilePath = fs33.realpathSync(filePath);
+          realFilePath = fs35.realpathSync(filePath);
         } catch {
           realFilePath = null;
         }
         if (realFilePath !== null) {
-          const realUiDir = fs33.realpathSync(this.uiDir);
-          if (!realFilePath.startsWith(realUiDir + path34.sep) && realFilePath !== realUiDir)
+          const realUiDir = fs35.realpathSync(this.uiDir);
+          if (!realFilePath.startsWith(realUiDir + path35.sep) && realFilePath !== realUiDir)
             return false;
         }
-        if (realFilePath !== null && fs33.existsSync(realFilePath) && fs33.statSync(realFilePath).isFile()) {
-          const ext = path34.extname(filePath);
+        if (realFilePath !== null && fs35.existsSync(realFilePath) && fs35.statSync(realFilePath).isFile()) {
+          const ext = path35.extname(filePath);
           const contentType = MIME_TYPES[ext] ?? "application/octet-stream";
           const isHashed = /\.[a-zA-Z0-9]{8,}\.(js|css)$/.test(filePath);
           const cacheControl = isHashed ? "public, max-age=31536000, immutable" : "no-cache";
@@ -3963,16 +5258,16 @@ var init_static_server = __esm({
             "Content-Type": contentType,
             "Cache-Control": cacheControl
           });
-          fs33.createReadStream(realFilePath).pipe(res);
+          fs35.createReadStream(realFilePath).pipe(res);
           return true;
         }
-        const indexPath = path34.join(this.uiDir, "index.html");
-        if (fs33.existsSync(indexPath)) {
+        const indexPath = path35.join(this.uiDir, "index.html");
+        if (fs35.existsSync(indexPath)) {
           res.writeHead(200, {
             "Content-Type": "text/html; charset=utf-8",
             "Cache-Control": "no-cache"
           });
-          fs33.createReadStream(indexPath).pipe(res);
+          fs35.createReadStream(indexPath).pipe(res);
           return true;
         }
         return false;
@@ -4095,8 +5390,8 @@ var init_exports = __esm({
 });
 
 // src/plugins/context/context-cache.ts
-import * as fs34 from "fs";
-import * as path35 from "path";
+import * as fs36 from "fs";
+import * as path36 from "path";
 import * as crypto2 from "crypto";
 var DEFAULT_TTL_MS, ContextCache;
 var init_context_cache = __esm({
@@ -4107,7 +5402,7 @@ var init_context_cache = __esm({
       constructor(cacheDir, ttlMs = DEFAULT_TTL_MS) {
         this.cacheDir = cacheDir;
         this.ttlMs = ttlMs;
-        fs34.mkdirSync(cacheDir, { recursive: true });
+        fs36.mkdirSync(cacheDir, { recursive: true });
       }
       cacheDir;
       ttlMs;
@@ -4115,23 +5410,23 @@ var init_context_cache = __esm({
         return crypto2.createHash("sha256").update(`${repoPath}:${queryKey}`).digest("hex").slice(0, 16);
       }
       filePath(repoPath, queryKey) {
-        return path35.join(this.cacheDir, `${this.keyHash(repoPath, queryKey)}.json`);
+        return path36.join(this.cacheDir, `${this.keyHash(repoPath, queryKey)}.json`);
       }
       get(repoPath, queryKey) {
         const fp = this.filePath(repoPath, queryKey);
         try {
-          const stat = fs34.statSync(fp);
+          const stat = fs36.statSync(fp);
           if (Date.now() - stat.mtimeMs > this.ttlMs) {
-            fs34.unlinkSync(fp);
+            fs36.unlinkSync(fp);
             return null;
           }
-          return JSON.parse(fs34.readFileSync(fp, "utf-8"));
+          return JSON.parse(fs36.readFileSync(fp, "utf-8"));
         } catch {
           return null;
         }
       }
       set(repoPath, queryKey, result) {
-        fs34.writeFileSync(this.filePath(repoPath, queryKey), JSON.stringify(result));
+        fs36.writeFileSync(this.filePath(repoPath, queryKey), JSON.stringify(result));
       }
     };
   }
@@ -5105,8 +6400,8 @@ function formatToolSummary(name, rawInput, displaySummary) {
   }
   if (lowerName === "grep") {
     const pattern = args.pattern ?? "";
-    const path36 = args.path ?? "";
-    return pattern ? `\u{1F50D} Grep "${pattern}"${path36 ? ` in ${path36}` : ""}` : `\u{1F527} ${name}`;
+    const path37 = args.path ?? "";
+    return pattern ? `\u{1F50D} Grep "${pattern}"${path37 ? ` in ${path37}` : ""}` : `\u{1F527} ${name}`;
   }
   if (lowerName === "glob") {
     const pattern = args.pattern ?? "";
@@ -5142,8 +6437,8 @@ function formatToolTitle(name, rawInput, displayTitle) {
   }
   if (lowerName === "grep") {
     const pattern = args.pattern ?? "";
-    const path36 = args.path ?? "";
-    return pattern ? `"${pattern}"${path36 ? ` in ${path36}` : ""}` : name;
+    const path37 = args.path ?? "";
+    return pattern ? `"${pattern}"${path37 ? ` in ${path37}` : ""}` : name;
   }
   if (lowerName === "glob") {
     return String(args.pattern ?? name);
@@ -6454,11 +7749,23 @@ __export(version_exports, {
   compareVersions: () => compareVersions,
   getCurrentVersion: () => getCurrentVersion,
   getLatestVersion: () => getLatestVersion,
+  getUpdateNetwork: () => getUpdateNetwork,
   runUpdate: () => runUpdate
 });
 import { fileURLToPath as fileURLToPath3 } from "url";
 import { dirname as dirname12, join as join16, resolve as resolve6 } from "path";
-import { existsSync as existsSync17, readFileSync as readFileSync14 } from "fs";
+import { existsSync as existsSync17, readFileSync as readFileSync15 } from "fs";
+function getUpdateNetwork(instanceRoot) {
+  if (!instanceRoot) return {};
+  const proxy = new ProxyService(instanceRoot);
+  const inherited = Object.fromEntries(
+    Object.entries(process.env).filter((entry) => entry[1] !== void 0)
+  );
+  return {
+    fetcher: proxy.createFetch("services.npmUpdate"),
+    environment: proxy.buildChildEnv("services.npmUpdate", inherited)
+  };
+}
 function findPackageJson() {
   let dir = dirname12(fileURLToPath3(import.meta.url));
   for (let i = 0; i < 5; i++) {
@@ -6474,15 +7781,15 @@ function getCurrentVersion() {
   try {
     const pkgPath = findPackageJson();
     if (!pkgPath) return "0.0.0-dev";
-    const pkg = JSON.parse(readFileSync14(pkgPath, "utf-8"));
+    const pkg = JSON.parse(readFileSync15(pkgPath, "utf-8"));
     return pkg.version;
   } catch {
     return "0.0.0-dev";
   }
 }
-async function getLatestVersion() {
+async function getLatestVersion(fetcher = globalThis.fetch) {
   try {
-    const res = await fetch(`https://registry.npmjs.org/${NPM_PACKAGE}/latest`, {
+    const res = await fetcher(`https://registry.npmjs.org/${NPM_PACKAGE}/latest`, {
       signal: AbortSignal.timeout(5e3)
     });
     if (!res.ok) return null;
@@ -6501,12 +7808,13 @@ function compareVersions(current, latest) {
   }
   return 0;
 }
-async function runUpdate() {
+async function runUpdate(environment) {
   const { spawn: spawn4 } = await import("child_process");
   return new Promise((resolve7) => {
     const child = spawn4("npm", ["install", "-g", `${NPM_PACKAGE}@latest`], {
       stdio: "inherit",
-      shell: false
+      shell: false,
+      env: environment
     });
     const onSignal = () => {
       child.kill("SIGTERM");
@@ -6521,11 +7829,12 @@ async function runUpdate() {
     });
   });
 }
-async function checkAndPromptUpdate() {
+async function checkAndPromptUpdate(instanceRoot) {
   if (process.env.OPENACP_DEV_LOOP || process.env.OPENACP_SKIP_UPDATE_CHECK || !process.stdin.isTTY) return;
   const current = getCurrentVersion();
   if (current === "0.0.0-dev") return;
-  const latest = await getLatestVersion();
+  const network = getUpdateNetwork(instanceRoot);
+  const latest = await getLatestVersion(network.fetcher);
   if (!latest || compareVersions(current, latest) >= 0) return;
   console.log(`\x1B[33mUpdate available: v${current} \u2192 v${latest}\x1B[0m`);
   const clack3 = await import("@clack/prompts");
@@ -6535,7 +7844,7 @@ async function checkAndPromptUpdate() {
   if (clack3.isCancel(yes) || !yes) {
     return;
   }
-  const ok2 = await runUpdate();
+  const ok2 = await runUpdate(network.environment);
   if (ok2) {
     console.log(`\x1B[32m\u2713 Updated to v${latest}. Please re-run your command.\x1B[0m`);
     process.exit(0);
@@ -6547,6 +7856,7 @@ var NPM_PACKAGE;
 var init_version = __esm({
   "src/cli/version.ts"() {
     "use strict";
+    init_proxy_service();
     NPM_PACKAGE = "@n1creator/openacp-cli";
   }
 });
@@ -6729,7 +8039,8 @@ async function handleUpdate(ctx, core) {
     `\u{1F50D} Checking for updates... (current: v${escapeHtml(current)})`,
     { parse_mode: "HTML" }
   );
-  const latest = await getLatestVersion2();
+  const updateFetch = core.proxyService.createFetch("services.npmUpdate");
+  const latest = await getLatestVersion2(updateFetch);
   if (!latest) {
     await ctx.api.editMessageText(
       ctx.chat.id,
@@ -6754,7 +8065,11 @@ async function handleUpdate(ctx, core) {
     `\u2B07\uFE0F Updating v${escapeHtml(current)} \u2192 v${escapeHtml(latest)}...`,
     { parse_mode: "HTML" }
   );
-  const ok2 = await runUpdate2();
+  const updateEnv = core.proxyService.buildChildEnv(
+    "services.npmUpdate",
+    Object.fromEntries(Object.entries(process.env).filter((entry) => entry[1] !== void 0))
+  );
+  const ok2 = await runUpdate2(updateEnv);
   if (!ok2) {
     await ctx.api.editMessageText(
       ctx.chat.id,
@@ -7341,7 +8656,7 @@ __export(integrate_exports, {
   listIntegrations: () => listIntegrations,
   uninstallIntegration: () => uninstallIntegration
 });
-import { existsSync as existsSync18, mkdirSync as mkdirSync11, readFileSync as readFileSync15, writeFileSync as writeFileSync11, unlinkSync as unlinkSync7, chmodSync, rmdirSync } from "fs";
+import { existsSync as existsSync18, mkdirSync as mkdirSync11, readFileSync as readFileSync16, writeFileSync as writeFileSync11, unlinkSync as unlinkSync7, chmodSync, rmdirSync } from "fs";
 import { join as join17, dirname as dirname13 } from "path";
 import { homedir as homedir4 } from "os";
 function isHooksIntegrationSpec(spec) {
@@ -7504,7 +8819,7 @@ function mergeSettingsJson(settingsPath, hookEvent, hookScriptPath) {
   const fullPath = expandPath(settingsPath);
   let settings = {};
   if (existsSync18(fullPath)) {
-    const raw = readFileSync15(fullPath, "utf-8");
+    const raw = readFileSync16(fullPath, "utf-8");
     writeFileSync11(`${fullPath}.bak`, raw);
     settings = JSON.parse(raw);
   }
@@ -7527,7 +8842,7 @@ function mergeHooksJson(settingsPath, hookEvent, hookScriptPath) {
   const fullPath = expandPath(settingsPath);
   let config = { version: 1 };
   if (existsSync18(fullPath)) {
-    const raw = readFileSync15(fullPath, "utf-8");
+    const raw = readFileSync16(fullPath, "utf-8");
     writeFileSync11(`${fullPath}.bak`, raw);
     config = JSON.parse(raw);
   }
@@ -7545,7 +8860,7 @@ function mergeHooksJson(settingsPath, hookEvent, hookScriptPath) {
 function removeFromSettingsJson(settingsPath, hookEvent) {
   const fullPath = expandPath(settingsPath);
   if (!existsSync18(fullPath)) return;
-  const raw = readFileSync15(fullPath, "utf-8");
+  const raw = readFileSync16(fullPath, "utf-8");
   const settings = JSON.parse(raw);
   const hooks = settings.hooks;
   if (!hooks?.[hookEvent]) return;
@@ -7560,7 +8875,7 @@ function removeFromSettingsJson(settingsPath, hookEvent) {
 function removeFromHooksJson(settingsPath, hookEvent) {
   const fullPath = expandPath(settingsPath);
   if (!existsSync18(fullPath)) return;
-  const raw = readFileSync15(fullPath, "utf-8");
+  const raw = readFileSync16(fullPath, "utf-8");
   const config = JSON.parse(raw);
   const hooks = config.hooks;
   if (!hooks?.[hookEvent]) return;
@@ -7999,6 +9314,7 @@ Downloading... ${bar} ${percent}%`, { parse_mode: "HTML" });
   };
   const result = await catalog.install(nameOrId, progress);
   if (result.ok) {
+    core.proxyService.registerScope(`agents.${result.agentKey}`);
     const { getAgentCapabilities: getAgentCapabilities2 } = await Promise.resolve().then(() => (init_agent_dependencies(), agent_dependencies_exports));
     const caps = getAgentCapabilities2(result.agentKey);
     if (caps.integration) {
@@ -10089,9 +11405,12 @@ __export(validators_exports, {
   validateBotToken: () => validateBotToken,
   validateChatId: () => validateChatId
 });
-async function validateBotToken(token) {
+function safeNetworkError(error) {
+  return redactNetworkSecrets(error instanceof Error ? error.message : String(error));
+}
+async function validateBotToken(token, telegramFetch) {
   try {
-    const res = await fetch(`https://api.telegram.org/bot${token}/getMe`);
+    const res = await telegramFetch(`https://api.telegram.org/bot${token}/getMe`);
     const data = await res.json();
     if (data.ok && data.result) {
       return {
@@ -10102,12 +11421,12 @@ async function validateBotToken(token) {
     }
     return { ok: false, error: data.description || "Invalid token" };
   } catch (err) {
-    return { ok: false, error: err.message };
+    return { ok: false, error: safeNetworkError(err) };
   }
 }
-async function validateChatId(token, chatId) {
+async function validateChatId(token, chatId, telegramFetch) {
   try {
-    const res = await fetch(`https://api.telegram.org/bot${token}/getChat`, {
+    const res = await telegramFetch(`https://api.telegram.org/bot${token}/getChat`, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
       body: JSON.stringify({ chat_id: chatId })
@@ -10126,17 +11445,17 @@ async function validateChatId(token, chatId) {
       isForum: data.result.is_forum === true
     };
   } catch (err) {
-    return { ok: false, error: err.message };
+    return { ok: false, error: safeNetworkError(err) };
   }
 }
-async function validateBotAdmin(token, chatId) {
+async function validateBotAdmin(token, chatId, telegramFetch) {
   try {
-    const meRes = await fetch(`https://api.telegram.org/bot${token}/getMe`);
+    const meRes = await telegramFetch(`https://api.telegram.org/bot${token}/getMe`);
     const meData = await meRes.json();
     if (!meData.ok || !meData.result) {
       return { ok: false, error: "Could not retrieve bot info" };
     }
-    const res = await fetch(
+    const res = await telegramFetch(
       `https://api.telegram.org/bot${token}/getChatMember`,
       {
         method: "POST",
@@ -10167,14 +11486,14 @@ async function validateBotAdmin(token, chatId) {
       error: `Bot is "${status}" in this group \u2014 it must be an admin. Ask a group admin to go to Group Settings \u2192 Administrators \u2192 add the bot \u2192 tap Save/Done. Note: only existing admins can promote the bot.`
     };
   } catch (err) {
-    return { ok: false, error: err.message };
+    return { ok: false, error: safeNetworkError(err) };
   }
 }
-async function checkTopicsPrerequisites(token, chatId) {
+async function checkTopicsPrerequisites(token, chatId, telegramFetch) {
   const issues = [];
   log36.info({ chatId }, "checkTopicsPrerequisites: starting checks");
   try {
-    const res = await fetch(`https://api.telegram.org/bot${token}/getChat`, {
+    const res = await telegramFetch(`https://api.telegram.org/bot${token}/getChat`, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
       body: JSON.stringify({ chat_id: chatId })
@@ -10193,7 +11512,7 @@ async function checkTopicsPrerequisites(token, chatId) {
     log36.warn({ err, chatId }, "checkTopicsPrerequisites: getChat failed (network error)");
     issues.push("\u274C Could not check if Topics are enabled (network error).");
   }
-  const adminResult = await validateBotAdmin(token, chatId);
+  const adminResult = await validateBotAdmin(token, chatId, telegramFetch);
   log36.info(
     { chatId, adminOk: adminResult.ok, canManageTopics: adminResult.ok ? adminResult.canManageTopics : void 0, error: !adminResult.ok ? adminResult.error : void 0 },
     "checkTopicsPrerequisites: validateBotAdmin result"
@@ -10218,13 +11537,14 @@ var init_validators = __esm({
   "src/plugins/telegram/validators.ts"() {
     "use strict";
     init_log();
+    init_network_redaction();
     log36 = createChildLogger({ module: "telegram-validators" });
   }
 });
 
 // src/plugins/telegram/adapter.ts
 import { Bot, InputFile, InlineKeyboard as InlineKeyboard13 } from "grammy";
-function patchedFetch(input2, init) {
+function patchedFetch(input2, init, delegate) {
   if (init?.signal && !(init.signal instanceof AbortSignal)) {
     const nativeController = new AbortController();
     const polyfillSignal = init.signal;
@@ -10235,7 +11555,7 @@ function patchedFetch(input2, init) {
     }
     init = { ...init, signal: nativeController.signal };
   }
-  return fetch(input2, init);
+  return delegate(input2, init);
 }
 var log37, TelegramAdapter;
 var init_adapter = __esm({
@@ -10309,6 +11629,10 @@ var init_adapter = __esm({
       _prerequisiteWatcher = null;
       /** Set during normal shutdown so bot.stop() does not trigger a self-restart. */
       _stopping = false;
+      unregisterProxyTester;
+      telegramFetch() {
+        return this.core.proxyService.createFetch("channels.telegram");
+      }
       /** Returns the configured Telegram supergroup chat ID. */
       getChatId() {
         return this.telegramConfig.chatId;
@@ -10381,6 +11705,16 @@ var init_adapter = __esm({
         this.core = core;
         this.telegramConfig = config;
         this.saveTopicIds = saveTopicIds;
+        this.unregisterProxyTester = this.core.proxyService.registerRouteTester(
+          "channels.telegram",
+          async (fetcher) => {
+            const response = await fetcher(`https://api.telegram.org/bot${this.telegramConfig.botToken}/getMe`, {
+              signal: AbortSignal.timeout(1e4)
+            });
+            const body = await response.json().catch(() => null);
+            if (!response.ok || !body?.ok) throw new Error("Telegram rejected the candidate proxy route");
+          }
+        );
       }
       /**
        * Set up the grammY bot, register all callback and message handlers, then perform
@@ -10393,7 +11727,11 @@ var init_adapter = __esm({
         this.bot = new Bot(this.telegramConfig.botToken, {
           client: {
             baseFetchConfig: { duplex: "half" },
-            fetch: patchedFetch
+            fetch: (input2, init) => patchedFetch(
+              input2,
+              init,
+              this.telegramFetch()
+            )
           }
         });
         this.fileService = this.core.fileService;
@@ -10708,7 +12046,8 @@ ${p}` : p;
         const { checkTopicsPrerequisites: checkTopicsPrerequisites2 } = await Promise.resolve().then(() => (init_validators(), validators_exports));
         const prereqResult = await checkTopicsPrerequisites2(
           this.telegramConfig.botToken,
-          this.telegramConfig.chatId
+          this.telegramConfig.chatId,
+          this.telegramFetch()
         );
         if (prereqResult.ok) {
           log37.info("Telegram adapter: prerequisites OK, initializing topic-dependent features");
@@ -10936,7 +12275,8 @@ ${p}` : p;
         const { checkTopicsPrerequisites: checkTopicsPrerequisites2 } = await Promise.resolve().then(() => (init_validators(), validators_exports));
         const result = await checkTopicsPrerequisites2(
           this.telegramConfig.botToken,
-          this.telegramConfig.chatId
+          this.telegramConfig.chatId,
+          this.telegramFetch()
         );
         if (result.ok) {
           try {
@@ -10987,7 +12327,8 @@ OpenACP will automatically retry every 30 seconds. After fixing the issues above
           const { checkTopicsPrerequisites: checkTopicsPrerequisites2 } = await Promise.resolve().then(() => (init_validators(), validators_exports));
           const result = await checkTopicsPrerequisites2(
             this.telegramConfig.botToken,
-            this.telegramConfig.chatId
+            this.telegramConfig.chatId,
+            this.telegramFetch()
           );
           if (result.ok) {
             log37.info("Prerequisites met \u2014 completing Telegram adapter initialization");
@@ -11026,6 +12367,8 @@ System topics have been created. Tap${assistantTopicLink} to get started.`,
        */
       async stop() {
         this._stopping = true;
+        this.unregisterProxyTester?.();
+        this.unregisterProxyTester = void 0;
         if (this._prerequisiteWatcher !== null) {
           clearTimeout(this._prerequisiteWatcher);
           this._prerequisiteWatcher = null;
@@ -11765,7 +13108,7 @@ Task completed.
           const file = await this.bot.api.getFile(fileId);
           if (!file.file_path) return null;
           const url = `https://api.telegram.org/file/bot${this.telegramConfig.botToken}/${file.file_path}`;
-          const response = await fetch(url);
+          const response = await this.telegramFetch()(url);
           if (!response.ok) return null;
           const buffer = Buffer.from(await response.arrayBuffer());
           return { buffer, filePath: file.file_path };
@@ -12697,7 +14040,7 @@ var AgentInstance = class _AgentInstance extends TypedEmitter {
    *
    * Does NOT create a session — callers must follow up with newSession or loadSession.
    */
-  static async spawnSubprocess(agentDef, workingDirectory, allowedPaths = []) {
+  static async spawnSubprocess(agentDef, workingDirectory, allowedPaths = [], environment) {
     const instance = new _AgentInstance(agentDef.name);
     const resolved = resolveAgentCommand(agentDef.command);
     log4.debug(
@@ -12722,7 +14065,7 @@ var AgentInstance = class _AgentInstance extends TypedEmitter {
         cwd: workingDirectory,
         // envWhitelist from workspace.security.envWhitelist config would extend DEFAULT_ENV_WHITELIST.
         // Tracked as follow-up: pass workspace security config through spawn/resume call chain.
-        env: filterEnv(process.env, agentDef.env)
+        env: environment ?? filterEnv(process.env, agentDef.env)
       }
     );
     await new Promise((resolve7, reject) => {
@@ -12881,10 +14224,10 @@ ${stderr}`
    * @param mcpServers - Optional MCP server configs to extend agent capabilities
    * @param allowedPaths - Extra filesystem paths the agent may access
    */
-  static async spawn(agentDef, workingDirectory, mcpServers, allowedPaths) {
+  static async spawn(agentDef, workingDirectory, mcpServers, allowedPaths, environment) {
     log4.debug({ agentName: agentDef.name, command: agentDef.command }, "Spawning agent");
     const spawnStart = Date.now();
-    const instance = await _AgentInstance.spawnSubprocess(agentDef, workingDirectory, allowedPaths);
+    const instance = await _AgentInstance.spawnSubprocess(agentDef, workingDirectory, allowedPaths, environment);
     await instance.claimForSession(workingDirectory, mcpServers, agentDef.initTimeoutMs);
     log4.info(
       {
@@ -12906,13 +14249,14 @@ ${stderr}`
    *
    * @param agentSessionId - The agent-side session ID to restore
    */
-  static async resume(agentDef, workingDirectory, agentSessionId, mcpServers, allowedPaths) {
+  static async resume(agentDef, workingDirectory, agentSessionId, mcpServers, allowedPaths, environment) {
     log4.debug({ agentName: agentDef.name, agentSessionId }, "Resuming agent");
     const spawnStart = Date.now();
     const instance = await _AgentInstance.spawnSubprocess(
       agentDef,
       workingDirectory,
-      allowedPaths
+      allowedPaths,
+      environment
     );
     const resolvedMcp = _AgentInstance.mcpManager.resolve(mcpServers);
     try {
@@ -13411,13 +14755,24 @@ function pathListsEqual(a, b) {
   return true;
 }
 var AgentManager = class {
-  constructor(catalog) {
+  constructor(catalog, proxyService) {
     this.catalog = catalog;
+    this.proxyService = proxyService;
+    if (proxyService?.registerScope) for (const name of Object.keys(catalog.getInstalledEntries())) proxyService.registerScope(`agents.${name}`);
   }
   catalog;
+  proxyService;
   warmEntry = null;
   /** In-flight prewarm promise — guards against concurrent prewarm calls. */
   warming = null;
+  currentPolicyGeneration() {
+    return typeof this.proxyService?.getPolicyGeneration === "function" ? this.proxyService.getPolicyGeneration() : 0;
+  }
+  childEnv(agentDef, routeName = agentDef.name) {
+    if (!this.proxyService) return void 0;
+    const filtered = filterEnv(process.env, agentDef.env);
+    return this.proxyService.buildAgentEnv(routeName, filtered);
+  }
   /** Return definitions for all installed agents. */
   getAvailableAgents() {
     const installed = this.catalog.getInstalledEntries();
@@ -13465,10 +14820,12 @@ var AgentManager = class {
       log5.debug({ agentName }, "prewarm: agent not installed, skipping");
       return;
     }
+    const policyGeneration = this.currentPolicyGeneration();
     this.warming = (async () => {
       try {
-        const instance = await AgentInstance.spawnSubprocess(agentDef, workingDir, [...allowedPaths]);
-        if (this.warmEntry) {
+        const environment = this.childEnv(agentDef, agentName);
+        const instance = environment ? await AgentInstance.spawnSubprocess(agentDef, workingDir, [...allowedPaths], environment) : await AgentInstance.spawnSubprocess(agentDef, workingDir, [...allowedPaths]);
+        if (this.warmEntry || this.currentPolicyGeneration() !== policyGeneration) {
           await instance.destroy().catch(() => {
           });
           return;
@@ -13478,7 +14835,8 @@ var AgentManager = class {
           workingDir,
           allowedPaths: [...allowedPaths],
           instance,
-          createdAt: Date.now()
+          createdAt: Date.now(),
+          policyGeneration
         };
         log5.info({ agentName, workingDir }, "Agent warm-pool: instance ready");
       } catch (err) {
@@ -13494,6 +14852,13 @@ var AgentManager = class {
    * Best-effort — errors are swallowed since shutdown should not fail.
    */
   async destroyWarm() {
+    const inFlight = this.warming;
+    if (inFlight) {
+      try {
+        await inFlight;
+      } catch {
+      }
+    }
     const entry = this.warmEntry;
     this.warmEntry = null;
     if (entry) {
@@ -13517,6 +14882,12 @@ var AgentManager = class {
     const entry = this.warmEntry;
     if (!entry) return null;
     if (entry.agentName !== agentName || entry.workingDir !== workingDir) return null;
+    if (entry.policyGeneration !== this.currentPolicyGeneration()) {
+      this.warmEntry = null;
+      entry.instance.destroy().catch(() => {
+      });
+      return null;
+    }
     if (!pathListsEqual(entry.allowedPaths, allowedPaths)) {
       log5.debug(
         { agentName, workingDir },
@@ -13576,7 +14947,8 @@ var AgentManager = class {
         });
       }
     }
-    return AgentInstance.spawn(agentDef, workingDirectory, void 0, allowedPaths);
+    const environment = this.childEnv(agentDef, agentName);
+    return environment ? AgentInstance.spawn(agentDef, workingDirectory, void 0, allowedPaths, environment) : AgentInstance.spawn(agentDef, workingDirectory, void 0, allowedPaths);
   }
   /**
    * Spawn a subprocess and resume an existing agent session.
@@ -13591,7 +14963,8 @@ var AgentManager = class {
         `Agent "${agentName}" is not installed. Run "openacp agents install ${agentName}" to add it.`
       );
     }
-    return AgentInstance.resume(agentDef, workingDirectory, agentSessionId, void 0, allowedPaths);
+    const environment = this.childEnv(agentDef, agentName);
+    return environment ? AgentInstance.resume(agentDef, workingDirectory, agentSessionId, void 0, allowedPaths, environment) : AgentInstance.resume(agentDef, workingDirectory, agentSessionId, void 0, allowedPaths);
   }
 };
 
@@ -14560,7 +15933,7 @@ ${result.text}` : result.text;
     }
     this.queue.clear();
     await this.agentInstance.destroy();
-    closeSessionLogger(this.log);
+    await closeSessionLogger(this.log);
   }
 };
 
@@ -15611,12 +16984,12 @@ var SessionBridge = class {
         break;
       case "image_content": {
         if (this.deps.fileService) {
-          const fs35 = this.deps.fileService;
+          const fs37 = this.deps.fileService;
           const sid = this.session.id;
           const { data, mimeType } = event;
           const buffer = Buffer.from(data, "base64");
-          const ext = fs35.extensionFromMime(mimeType);
-          fs35.saveFile(sid, `agent-image${ext}`, buffer, mimeType).then((att) => {
+          const ext = fs37.extensionFromMime(mimeType);
+          fs37.saveFile(sid, `agent-image${ext}`, buffer, mimeType).then((att) => {
             this.sendMessage(sid, {
               type: "attachment",
               text: "",
@@ -15628,12 +17001,12 @@ var SessionBridge = class {
       }
       case "audio_content": {
         if (this.deps.fileService) {
-          const fs35 = this.deps.fileService;
+          const fs37 = this.deps.fileService;
           const sid = this.session.id;
           const { data, mimeType } = event;
           const buffer = Buffer.from(data, "base64");
-          const ext = fs35.extensionFromMime(mimeType);
-          fs35.saveFile(sid, `agent-audio${ext}`, buffer, mimeType).then((att) => {
+          const ext = fs37.extensionFromMime(mimeType);
+          fs37.saveFile(sid, `agent-audio${ext}`, buffer, mimeType).then((att) => {
             this.sendMessage(sid, {
               type: "attachment",
               text: "",
@@ -16245,7 +17618,7 @@ var SessionFactory = class {
 };
 
 // src/core/core.ts
-import path15 from "path";
+import path16 from "path";
 import { nanoid as nanoid3 } from "nanoid";
 
 // src/core/sessions/session-store.ts
@@ -16634,17 +18007,21 @@ var log12 = createChildLogger({ module: "agent-catalog" });
 var REGISTRY_URL = "https://cdn.agentclientprotocol.com/registry/v1/latest/registry.json";
 var DEFAULT_TTL_HOURS = 24;
 var AgentCatalog = class {
+  constructor(store, cachePath, agentsDir, scopedFetch = globalThis.fetch, registryUrl = REGISTRY_URL) {
+    this.scopedFetch = scopedFetch;
+    this.registryUrl = registryUrl;
+    this.store = store;
+    this.cachePath = cachePath;
+    this.agentsDir = agentsDir;
+  }
+  scopedFetch;
+  registryUrl;
   store;
   /** Agents available in the remote registry (cached in memory after load). */
   registryAgents = [];
   cachePath;
   /** Directory where binary agent archives are extracted to. */
   agentsDir;
-  constructor(store, cachePath, agentsDir) {
-    this.store = store;
-    this.cachePath = cachePath;
-    this.agentsDir = agentsDir;
-  }
   /**
    * Load installed agents from disk and hydrate the registry from cache/snapshot.
    *
@@ -16661,7 +18038,7 @@ var AgentCatalog = class {
   async fetchRegistry() {
     try {
       log12.info("Fetching agent registry from CDN...");
-      const response = await fetch(REGISTRY_URL);
+      const response = await this.scopedFetch(this.registryUrl);
       if (!response.ok) throw new Error(`HTTP ${response.status}`);
       const data = await response.json();
       this.registryAgents = data.agents ?? [];
@@ -16787,7 +18164,7 @@ var AgentCatalog = class {
       await progress?.onError(msg);
       return { ok: false, agentKey, error: msg };
     }
-    return installAgent(agent, this.store, progress, this.agentsDir);
+    return installAgent(agent, this.store, progress, this.agentsDir, this.scopedFetch);
   }
   /**
    * Register an agent directly into the catalog store without going through
@@ -18361,6 +19738,7 @@ function registerCoreMenuItems(registry) {
 init_log();
 init_native_stt();
 init_events();
+init_proxy_service();
 var log17 = createChildLogger({ module: "core" });
 var OpenACPCore = class {
   configManager;
@@ -18383,6 +19761,8 @@ var OpenACPCore = class {
   menuRegistry = new MenuRegistry();
   assistantRegistry = new AssistantRegistry();
   assistantManager;
+  /** Scoped proxy policy shared by transports, agent spawns, API and commands. */
+  proxyService;
   // Services (security, notifications, speech, etc.) are provided by plugins that
   // register during boot. Core accesses them lazily via ServiceRegistry so it doesn't
   // need compile-time dependencies on plugin implementations.
@@ -18430,13 +19810,21 @@ var OpenACPCore = class {
     this.configManager = configManager;
     this.instanceContext = ctx;
     const config = configManager.get();
+    this.proxyService = new ProxyService(ctx.root);
     this.agentCatalog = new AgentCatalog(
       new AgentStore(ctx.paths.agents),
       ctx.paths.registryCache,
-      ctx.paths.agentsDir
+      ctx.paths.agentsDir,
+      this.proxyService.createFetch("services.agentRegistry")
     );
     this.agentCatalog.load();
-    this.agentManager = new AgentManager(this.agentCatalog);
+    this.agentManager = new AgentManager(this.agentCatalog, this.proxyService);
+    this.proxyService.onRouteChanged(async (scope) => {
+      if (scope === "global" || scope === "agents.default" || scope.startsWith("agents.")) {
+        await this.agentManager.destroyWarm();
+        log17.info({ scope }, "Proxy route changed; idle agent warm pool invalidated");
+      }
+    });
     const storePath = ctx.paths.sessions;
     this.sessionStore = new JsonFileSessionStore(
       storePath,
@@ -18465,6 +19853,7 @@ var OpenACPCore = class {
       instanceRoot: ctx.root,
       log: createChildLogger({ module: "plugin" })
     });
+    this.lifecycleManager.serviceRegistry.register("proxy", this.proxyService, "@openacp/core");
     this.sessionFactory.middlewareChain = this.lifecycleManager.middlewareChain;
     this.sessionManager.middlewareChain = this.lifecycleManager.middlewareChain;
     this.sessionFactory.sessionStore = this.sessionStore;
@@ -18512,7 +19901,7 @@ var OpenACPCore = class {
       }
     );
     registerCoreMenuItems(this.menuRegistry);
-    this.assistantRegistry.setInstanceRoot(path15.dirname(ctx.root));
+    this.assistantRegistry.setInstanceRoot(path16.dirname(ctx.root));
     this.assistantRegistry.register(createSessionsSection(this));
     this.assistantRegistry.register(createAgentsSection(this));
     this.assistantRegistry.register(createConfigSection(this));
@@ -19332,29 +20721,71 @@ init_doctor();
 init_config_registry();
 
 // src/core/config/config-editor.ts
-import * as path31 from "path";
+import * as path32 from "path";
 import * as clack2 from "@clack/prompts";
 
 // src/cli/autostart.ts
 init_log();
 import { execFileSync as execFileSync6 } from "child_process";
-import * as fs25 from "fs";
-import * as path24 from "path";
+import * as fs27 from "fs";
+import * as path25 from "path";
 import * as os7 from "os";
 var log19 = createChildLogger({ module: "autostart" });
-var LEGACY_LAUNCHD_PLIST_PATH = path24.join(os7.homedir(), "Library", "LaunchAgents", "com.openacp.daemon.plist");
-var LEGACY_SYSTEMD_SERVICE_PATH = path24.join(os7.homedir(), ".config", "systemd", "user", "openacp.service");
+var LEGACY_LAUNCHD_PLIST_PATH = path25.join(os7.homedir(), "Library", "LaunchAgents", "com.openacp.daemon.plist");
+var LEGACY_SYSTEMD_SERVICE_PATH = path25.join(os7.homedir(), ".config", "systemd", "user", "openacp.service");
 function getLaunchdLabel(instanceId) {
   return `com.openacp.daemon.${instanceId}`;
 }
 function getLaunchdPlistPath(instanceId) {
-  return path24.join(os7.homedir(), "Library", "LaunchAgents", `${getLaunchdLabel(instanceId)}.plist`);
+  return path25.join(os7.homedir(), "Library", "LaunchAgents", `${getLaunchdLabel(instanceId)}.plist`);
 }
 function getSystemdServiceName(instanceId) {
   return `openacp-${instanceId}`;
 }
 function getSystemdServicePath(instanceId) {
-  return path24.join(os7.homedir(), ".config", "systemd", "user", `${getSystemdServiceName(instanceId)}.service`);
+  return path25.join(os7.homedir(), ".config", "systemd", "user", `${getSystemdServiceName(instanceId)}.service`);
+}
+function getAutoStartState(instanceId) {
+  if (process.platform === "linux") {
+    const installed = fs27.existsSync(getSystemdServicePath(instanceId));
+    if (!installed) return { installed: false, manager: null, active: false };
+    try {
+      const output = execFileSync6("systemctl", [
+        "--user",
+        "show",
+        getSystemdServiceName(instanceId),
+        "--property=ActiveState",
+        "--property=MainPID"
+      ], { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] });
+      const properties = Object.fromEntries(output.trim().split(/\r?\n/).map((line) => {
+        const index = line.indexOf("=");
+        return index >= 0 ? [line.slice(0, index), line.slice(index + 1)] : [line, ""];
+      }));
+      const active = properties.ActiveState === "active";
+      const pid = Number(properties.MainPID);
+      return { installed: true, manager: "systemd", active, ...pid > 0 ? { pid } : {} };
+    } catch {
+      return { installed: true, manager: "systemd", active: false };
+    }
+  }
+  if (process.platform === "darwin") {
+    const installed = fs27.existsSync(getLaunchdPlistPath(instanceId));
+    if (!installed) return { installed: false, manager: null, active: false };
+    try {
+      const uid = process.getuid();
+      const output = execFileSync6("launchctl", ["print", `gui/${uid}/${getLaunchdLabel(instanceId)}`], {
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+      const active = /^\s*state\s*=\s*running\s*$/m.test(output);
+      const pidMatch = output.match(/^\s*pid\s*=\s*(\d+)\s*$/m);
+      const pid = pidMatch ? Number(pidMatch[1]) : 0;
+      return { installed: true, manager: "launchd", active, ...pid > 0 ? { pid } : {} };
+    } catch {
+      return { installed: true, manager: "launchd", active: false };
+    }
+  }
+  return { installed: false, manager: null, active: false };
 }
 function isAutoStartSupported() {
   return process.platform === "darwin" || process.platform === "linux";
@@ -19368,7 +20799,7 @@ function escapeSystemdValue(str) {
 }
 function generateLaunchdPlist(nodePath, cliPath, logDir2, instanceRoot, instanceId) {
   const label = getLaunchdLabel(instanceId);
-  const logFile = path24.join(logDir2, "openacp.log");
+  const logFile = path25.join(logDir2, "openacp.log");
   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">
@@ -19385,6 +20816,8 @@ function generateLaunchdPlist(nodePath, cliPath, logDir2, instanceRoot, instance
   <dict>
     <key>OPENACP_INSTANCE_ROOT</key>
     <string>${escapeXml(instanceRoot)}</string>
+    <key>OPENACP_SUPERVISOR</key>
+    <string>launchd</string>
   </dict>
   <key>RunAtLoad</key>
   <true/>
@@ -19409,6 +20842,7 @@ Description=OpenACP Daemon (${instanceId})
 [Service]
 ExecStart=${escapeSystemdValue(nodePath)} ${escapeSystemdValue(cliPath)} --daemon-child
 Environment=OPENACP_INSTANCE_ROOT=${escapeSystemdValue(instanceRoot)}
+Environment=OPENACP_SUPERVISOR=systemd
 Restart=on-failure
 
 [Install]
@@ -19417,25 +20851,25 @@ WantedBy=default.target
 `;
 }
 function migrateLegacy() {
-  if (process.platform === "darwin" && fs25.existsSync(LEGACY_LAUNCHD_PLIST_PATH)) {
+  if (process.platform === "darwin" && fs27.existsSync(LEGACY_LAUNCHD_PLIST_PATH)) {
     try {
       const uid = process.getuid();
       execFileSync6("launchctl", ["bootout", `gui/${uid}`, "com.openacp.daemon"], { stdio: "pipe" });
     } catch {
     }
     try {
-      fs25.unlinkSync(LEGACY_LAUNCHD_PLIST_PATH);
+      fs27.unlinkSync(LEGACY_LAUNCHD_PLIST_PATH);
     } catch {
     }
     log19.info("Removed legacy single-instance LaunchAgent");
   }
-  if (process.platform === "linux" && fs25.existsSync(LEGACY_SYSTEMD_SERVICE_PATH)) {
+  if (process.platform === "linux" && fs27.existsSync(LEGACY_SYSTEMD_SERVICE_PATH)) {
     try {
       execFileSync6("systemctl", ["--user", "disable", "openacp"], { stdio: "pipe" });
     } catch {
     }
     try {
-      fs25.unlinkSync(LEGACY_SYSTEMD_SERVICE_PATH);
+      fs27.unlinkSync(LEGACY_SYSTEMD_SERVICE_PATH);
     } catch {
     }
     try {
@@ -19450,23 +20884,54 @@ function installAutoStart(logDir2, instanceRoot, instanceId) {
     return { success: false, error: "Auto-start not supported on this platform" };
   }
   const nodePath = process.execPath;
-  const cliPath = path24.resolve(process.argv[1]);
-  const resolvedLogDir = logDir2.startsWith("~") ? path24.join(os7.homedir(), logDir2.slice(1)) : logDir2;
+  const cliPath = path25.resolve(process.argv[1]);
+  const resolvedLogDir = logDir2.startsWith("~") ? path25.join(os7.homedir(), logDir2.slice(1)) : logDir2;
   try {
     migrateLegacy();
     if (process.platform === "darwin") {
       const plistPath = getLaunchdPlistPath(instanceId);
       const plist = generateLaunchdPlist(nodePath, cliPath, resolvedLogDir, instanceRoot, instanceId);
-      const dir = path24.dirname(plistPath);
-      fs25.mkdirSync(dir, { recursive: true });
-      fs25.writeFileSync(plistPath, plist);
+      const dir = path25.dirname(plistPath);
+      fs27.mkdirSync(dir, { recursive: true });
       const uid = process.getuid();
       const domain = `gui/${uid}`;
+      const previous = fs27.existsSync(plistPath) ? fs27.readFileSync(plistPath, "utf8") : void 0;
+      const previousState = getAutoStartState(instanceId);
+      const tmp = `${plistPath}.${process.pid}.tmp`;
+      let replaced = false;
+      let bootedOut = false;
       try {
-        execFileSync6("launchctl", ["bootout", domain, plistPath], { stdio: "pipe" });
-      } catch {
+        fs27.writeFileSync(tmp, plist, { mode: 384 });
+        execFileSync6("plutil", ["-lint", tmp], { stdio: "pipe" });
+        fs27.renameSync(tmp, plistPath);
+        replaced = true;
+        if (previousState.active) {
+          execFileSync6("launchctl", ["bootout", domain, plistPath], { stdio: "pipe" });
+          bootedOut = true;
+        }
+        execFileSync6("launchctl", ["bootstrap", domain, plistPath], { stdio: "pipe" });
+      } catch (error) {
+        try {
+          fs27.rmSync(tmp, { force: true });
+        } catch {
+        }
+        if (replaced) {
+          let rollbackBootedOut = false;
+          try {
+            execFileSync6("launchctl", ["bootout", domain, plistPath], { stdio: "pipe" });
+            rollbackBootedOut = true;
+          } catch {
+          }
+          if (previous === void 0) fs27.rmSync(plistPath, { force: true });
+          else {
+            const rollbackTmp = `${plistPath}.${process.pid}.rollback.tmp`;
+            fs27.writeFileSync(rollbackTmp, previous, { mode: 384 });
+            fs27.renameSync(rollbackTmp, plistPath);
+            if (previousState.active || bootedOut || rollbackBootedOut) execFileSync6("launchctl", ["bootstrap", domain, plistPath], { stdio: "pipe" });
+          }
+        }
+        throw error;
       }
-      execFileSync6("launchctl", ["bootstrap", domain, plistPath], { stdio: "pipe" });
       log19.info({ instanceId }, "LaunchAgent installed");
       return { success: true };
     }
@@ -19474,11 +20939,24 @@ function installAutoStart(logDir2, instanceRoot, instanceId) {
       const servicePath = getSystemdServicePath(instanceId);
       const serviceName = getSystemdServiceName(instanceId);
       const unit = generateSystemdUnit(nodePath, cliPath, instanceRoot, instanceId);
-      const dir = path24.dirname(servicePath);
-      fs25.mkdirSync(dir, { recursive: true });
-      fs25.writeFileSync(servicePath, unit);
-      execFileSync6("systemctl", ["--user", "daemon-reload"], { stdio: "pipe" });
-      execFileSync6("systemctl", ["--user", "enable", serviceName], { stdio: "pipe" });
+      const dir = path25.dirname(servicePath);
+      fs27.mkdirSync(dir, { recursive: true });
+      const previous = fs27.existsSync(servicePath) ? fs27.readFileSync(servicePath, "utf8") : void 0;
+      const tmp = `${servicePath}.${process.pid}.tmp`;
+      fs27.writeFileSync(tmp, unit, { mode: 384 });
+      fs27.renameSync(tmp, servicePath);
+      try {
+        execFileSync6("systemctl", ["--user", "daemon-reload"], { stdio: "pipe" });
+        execFileSync6("systemctl", ["--user", "enable", serviceName], { stdio: "pipe" });
+      } catch (error) {
+        if (previous === void 0) fs27.unlinkSync(servicePath);
+        else fs27.writeFileSync(servicePath, previous);
+        try {
+          execFileSync6("systemctl", ["--user", "daemon-reload"], { stdio: "pipe" });
+        } catch {
+        }
+        throw error;
+      }
       log19.info({ instanceId }, "systemd user service installed");
       return { success: true };
     }
@@ -19496,13 +20974,13 @@ function uninstallAutoStart(instanceId) {
   try {
     if (process.platform === "darwin") {
       const plistPath = getLaunchdPlistPath(instanceId);
-      if (fs25.existsSync(plistPath)) {
+      if (fs27.existsSync(plistPath)) {
         const uid = process.getuid();
         try {
           execFileSync6("launchctl", ["bootout", `gui/${uid}`, plistPath], { stdio: "pipe" });
         } catch {
         }
-        fs25.unlinkSync(plistPath);
+        fs27.unlinkSync(plistPath);
         log19.info({ instanceId }, "LaunchAgent removed");
       }
       return { success: true };
@@ -19510,12 +20988,12 @@ function uninstallAutoStart(instanceId) {
     if (process.platform === "linux") {
       const servicePath = getSystemdServicePath(instanceId);
       const serviceName = getSystemdServiceName(instanceId);
-      if (fs25.existsSync(servicePath)) {
+      if (fs27.existsSync(servicePath)) {
         try {
           execFileSync6("systemctl", ["--user", "disable", serviceName], { stdio: "pipe" });
         } catch {
         }
-        fs25.unlinkSync(servicePath);
+        fs27.unlinkSync(servicePath);
         execFileSync6("systemctl", ["--user", "daemon-reload"], { stdio: "pipe" });
         log19.info({ instanceId }, "systemd user service removed");
       }
@@ -19530,10 +21008,10 @@ function uninstallAutoStart(instanceId) {
 }
 function isAutoStartInstalled(instanceId) {
   if (process.platform === "darwin") {
-    return fs25.existsSync(getLaunchdPlistPath(instanceId));
+    return fs27.existsSync(getLaunchdPlistPath(instanceId));
   }
   if (process.platform === "linux") {
-    return fs25.existsSync(getSystemdServicePath(instanceId));
+    return fs27.existsSync(getSystemdServicePath(instanceId));
   }
   return false;
 }
@@ -19542,25 +21020,25 @@ function isAutoStartInstalled(instanceId) {
 init_instance_context();
 init_instance_registry();
 init_log();
-import fs28 from "fs";
-import path27 from "path";
+import fs30 from "fs";
+import path28 from "path";
 var log20 = createChildLogger({ module: "resolve-instance-id" });
 function resolveInstanceId(instanceRoot) {
   try {
-    const configPath = path27.join(instanceRoot, "config.json");
-    const raw = JSON.parse(fs28.readFileSync(configPath, "utf-8"));
+    const configPath = path28.join(instanceRoot, "config.json");
+    const raw = JSON.parse(fs30.readFileSync(configPath, "utf-8"));
     if (raw.id && typeof raw.id === "string") return raw.id;
   } catch {
   }
   try {
-    const reg = new InstanceRegistry(path27.join(getGlobalRoot(), "instances.json"));
+    const reg = new InstanceRegistry(path28.join(getGlobalRoot(), "instances.json"));
     reg.load();
     const entry = reg.getByRoot(instanceRoot);
     if (entry?.id) return entry.id;
   } catch (err) {
     log20.debug({ err: err.message, instanceRoot }, "Could not read instance registry, using fallback id");
   }
-  return path27.basename(path27.dirname(instanceRoot)).replace(/[^a-zA-Z0-9-]/g, "-") || "default";
+  return path28.basename(path28.dirname(instanceRoot)).replace(/[^a-zA-Z0-9-]/g, "-") || "default";
 }
 
 // src/core/config/config-editor.ts
@@ -20132,7 +21610,7 @@ async function runConfigEditor(configManager, mode = "file", apiPort, settingsMa
   await configManager.load();
   const config = configManager.get();
   const updates = {};
-  const instanceRoot = path31.dirname(configManager.getConfigPath());
+  const instanceRoot = path32.dirname(configManager.getConfigPath());
   console.log(`
 ${c.cyan}${c.bold}OpenACP Config Editor${c.reset}`);
   console.log(dim(`Config: ${configManager.getConfigPath()}`));
@@ -20189,17 +21667,17 @@ ${c.cyan}${c.bold}OpenACP Config Editor${c.reset}`);
 async function sendConfigViaApi(port, updates) {
   const { apiCall: call } = await Promise.resolve().then(() => (init_api_client(), api_client_exports));
   const paths = flattenToPaths(updates);
-  for (const { path: path36, value } of paths) {
+  for (const { path: path37, value } of paths) {
     const res = await call(port, "/api/config", {
       method: "PATCH",
       headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ path: path36, value })
+      body: JSON.stringify({ path: path37, value })
     });
     const data = await res.json();
     if (!res.ok) {
-      console.log(warn(`Failed to update ${path36}: ${data.error}`));
+      console.log(warn(`Failed to update ${path37}: ${data.error}`));
     } else if (data.needsRestart) {
-      console.log(warn(`${path36} updated \u2014 restart required`));
+      console.log(warn(`${path37} updated \u2014 restart required`));
     }
   }
 }
@@ -20219,25 +21697,25 @@ function flattenToPaths(obj, prefix = "") {
 // src/cli/daemon.ts
 init_config();
 import { spawn as spawn3 } from "child_process";
-import * as fs31 from "fs";
-import * as path32 from "path";
+import * as fs33 from "fs";
+import * as path33 from "path";
 function getPidPath(root) {
-  return path32.join(root, "openacp.pid");
+  return path33.join(root, "openacp.pid");
 }
 function getLogDir(root) {
-  return path32.join(root, "logs");
+  return path33.join(root, "logs");
 }
 function getRunningMarker(root) {
-  return path32.join(root, "running");
+  return path33.join(root, "running");
 }
 function writePidFile(pidPath, pid) {
-  const dir = path32.dirname(pidPath);
-  fs31.mkdirSync(dir, { recursive: true });
-  fs31.writeFileSync(pidPath, String(pid));
+  const dir = path33.dirname(pidPath);
+  fs33.mkdirSync(dir, { recursive: true });
+  fs33.writeFileSync(pidPath, String(pid));
 }
 function readPidFile(pidPath) {
   try {
-    const content = fs31.readFileSync(pidPath, "utf-8").trim();
+    const content = fs33.readFileSync(pidPath, "utf-8").trim();
     const pid = parseInt(content, 10);
     return isNaN(pid) ? null : pid;
   } catch {
@@ -20246,7 +21724,7 @@ function readPidFile(pidPath) {
 }
 function removePidFile(pidPath) {
   try {
-    fs31.unlinkSync(pidPath);
+    fs33.unlinkSync(pidPath);
   } catch {
   }
 }
@@ -20279,12 +21757,12 @@ function startDaemon(pidPath, logDir2, instanceRoot) {
     return { error: `Already running (PID ${pid})` };
   }
   const resolvedLogDir = logDir2 ? expandHome2(logDir2) : getLogDir(instanceRoot);
-  fs31.mkdirSync(resolvedLogDir, { recursive: true });
-  const logFile = path32.join(resolvedLogDir, "openacp.log");
-  const cliPath = path32.resolve(process.argv[1]);
+  fs33.mkdirSync(resolvedLogDir, { recursive: true });
+  const logFile = path33.join(resolvedLogDir, "openacp.log");
+  const cliPath = path33.resolve(process.argv[1]);
   const nodePath = process.execPath;
-  const out = fs31.openSync(logFile, "a");
-  const err = fs31.openSync(logFile, "a");
+  const out = fs33.openSync(logFile, "a");
+  const err = fs33.openSync(logFile, "a");
   const child = spawn3(nodePath, [cliPath, "--daemon-child"], {
     detached: true,
     stdio: ["ignore", out, err],
@@ -20293,8 +21771,8 @@ function startDaemon(pidPath, logDir2, instanceRoot) {
       ...instanceRoot ? { OPENACP_INSTANCE_ROOT: instanceRoot } : {}
     }
   });
-  fs31.closeSync(out);
-  fs31.closeSync(err);
+  fs33.closeSync(out);
+  fs33.closeSync(err);
   if (!child.pid) {
     return { error: "Failed to spawn daemon process" };
   }
@@ -20365,12 +21843,12 @@ async function stopDaemon(pidPath, instanceRoot) {
 }
 function markRunning(root) {
   const marker = getRunningMarker(root);
-  fs31.mkdirSync(path32.dirname(marker), { recursive: true });
-  fs31.writeFileSync(marker, "");
+  fs33.mkdirSync(path33.dirname(marker), { recursive: true });
+  fs33.writeFileSync(marker, "");
 }
 function clearRunning(root) {
   try {
-    fs31.unlinkSync(getRunningMarker(root));
+    fs33.unlinkSync(getRunningMarker(root));
   } catch {
   }
 }
@@ -21219,6 +22697,9 @@ Session records auto-cleanup: 30 days (configurable via \`sessionStore.ttlDays\`
 Session logs auto-cleanup: 30 days (configurable via \`logging.sessionLogRetentionDays\`).
 `;
 
+// src/core/index.ts
+init_proxy_service();
+
 // src/index.ts
 init_adapter();
 export {
@@ -21250,8 +22731,10 @@ export {
   OpenACPCore,
   OutputModeResolver,
   PRODUCT_GUIDE,
+  PROXY_ENV_KEYS,
   PermissionGate,
   PromptQueue,
+  ProxyService,
   SSEManager,
   STATUS_ICONS,
   SecurityGuard,