@turmind/halo 2.2.2 → 2.2.4

package/dist/evo-wrapper.js

@@ -1,8 +1,8 @@
 // ../server/dist/evolution/evo-wrapper.js
-import fs11 from "node:fs";
-import path13 from "node:path";
+import fs12 from "node:fs";
+import path14 from "node:path";
 import { spawn as spawn2 } from "node:child_process";
-import { homedir as homedir6 } from "node:os";
+import { homedir as homedir7 } from "node:os";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 import { parseArgs } from "node:util";
 import { eq as eq3, and as and3, inArray as inArray2 } from "drizzle-orm";
@@ -237,41 +237,133 @@ function evoApplyLogFile(applyId) {
 }
 
 // ../server/dist/config.js
+import fs9 from "node:fs";
+import path12 from "node:path";
+import { homedir as homedir6 } from "node:os";
+
+// ../server/dist/settings-schema.js
 import fs8 from "node:fs";
 import path11 from "node:path";
 import { homedir as homedir5 } from "node:os";
 import YAML5 from "yaml";
 
-// ../server/dist/settings-schema.js
-import fs7 from "node:fs";
-import path10 from "node:path";
-import { homedir as homedir4 } from "node:os";
-import YAML4 from "yaml";
-
 // ../server/dist/tools/sandbox.js
 import { exec, execFile, spawn } from "node:child_process";
 import { promisify } from "node:util";
+import path4 from "node:path";
+import { homedir as homedir3 } from "node:os";
+
+// ../server/dist/settings-file.js
+import fs2 from "node:fs";
 import path3 from "node:path";
 import { homedir as homedir2 } from "node:os";
+import YAML from "yaml";
+function loadYamlFile(filePath) {
+  try {
+    const raw = fs2.readFileSync(filePath, "utf-8");
+    return YAML.parse(raw) ?? {};
+  } catch {
+    return {};
+  }
+}
+var SETTINGS_PATH = path3.join(homedir2(), ".halo", "secrets", "settings.yaml");
+var _settingsCache = null;
+function getSettings() {
+  let mtimeMs = 0;
+  try {
+    mtimeMs = fs2.statSync(SETTINGS_PATH).mtimeMs;
+  } catch {
+  }
+  if (!_settingsCache || _settingsCache.mtimeMs !== mtimeMs) {
+    _settingsCache = { mtimeMs, data: loadYamlFile(SETTINGS_PATH) };
+  }
+  return _settingsCache.data;
+}
+var ENV_PATTERN = /<<([A-Z_][A-Z0-9_]*)>>/g;
+function expandEnv(raw) {
+  if (!raw)
+    return "";
+  return raw.replace(ENV_PATTERN, (m, name) => process.env[name] ?? m);
+}
+
+// ../server/dist/outbound-proxy.js
+var DEFAULT_NO_PROXY = ["localhost", "127.0.0.1", "::1"];
+function checkProxyUrl(raw) {
+  let url;
+  try {
+    url = new URL(raw);
+  } catch {
+    return "not a valid URL";
+  }
+  if (url.protocol !== "http:" && url.protocol !== "https:")
+    return "scheme must be http:// or https://";
+  if (url.username || url.password)
+    return "credentials are not allowed in the URL \u2014 put them in Token (general.outbound_proxy.token)";
+  return null;
+}
+var _cache = null;
+function outboundProxy() {
+  const settings = getSettings();
+  if (_cache?.settings !== settings)
+    _cache = { settings, proxy: resolve(settings) };
+  return _cache.proxy;
+}
+function resolve(settings) {
+  const general = settings.general;
+  const cfg = general?.outbound_proxy;
+  const enabled = ["true", "1"].includes(String(cfg?.enabled ?? "").trim().toLowerCase());
+  const raw = typeof cfg?.url === "string" ? cfg.url.trim() : "";
+  if (!enabled || !raw)
+    return null;
+  const bad = checkProxyUrl(raw);
+  if (bad) {
+    console.warn(`[OutboundProxy] general.outbound_proxy.url ignored (${bad}) \u2014 proxy off`);
+    return null;
+  }
+  const url = new URL(raw).origin;
+  const cred = cfg?.token == null ? "" : expandEnv(String(cfg.token)).trim();
+  const colon = cred.indexOf(":");
+  const user = colon < 0 ? cred : cred.slice(0, colon);
+  const pass = colon < 0 ? "" : cred.slice(colon + 1);
+  const userinfo = `${encodeURIComponent(user)}:${encodeURIComponent(pass)}`;
+  const basic = Buffer.from(`${user}:${pass}`).toString("base64");
+  const inherited = [process.env.NO_PROXY, process.env.no_proxy].flatMap((v) => (v ?? "").split(","));
+  const merged = [.../* @__PURE__ */ new Set([...DEFAULT_NO_PROXY, ...inherited.map((s) => s.trim()).filter(Boolean)])];
+  const noProxy = merged.includes("*") ? ["*"] : merged;
+  console.log(`[OutboundProxy] on: ${url}${cred ? " (with token)" : ""}`);
+  return {
+    url,
+    envUrl: cred ? url.replace("://", `://${userinfo}@`) : url,
+    authorization: cred ? `Basic ${basic}` : "",
+    noProxy,
+    credential: cred ? { raw: cred, plain: `${user}:${pass}`, userinfo, basic } : null
+  };
+}
 
 // ../server/dist/child-env.js
 var settingsOtelEnvKeys = /* @__PURE__ */ new Set();
-function cleanChildEnv() {
+function cleanChildEnv(proxyEnv = outboundProxyEnv()) {
   const env = { ...process.env };
   delete env.HALO_PASSWORD;
   delete env.HALO_JWT_SECRET;
   delete env.HALO_NODE_TOKEN;
   for (const key of settingsOtelEnvKeys)
     delete env[key];
-  return env;
+  return Object.assign(env, proxyEnv);
+}
+function outboundProxyEnv(proxy = outboundProxy()) {
+  if (!proxy)
+    return {};
+  const noProxy = proxy.noProxy.join(",");
+  return { http_proxy: proxy.envUrl, https_proxy: proxy.envUrl, HTTP_PROXY: proxy.envUrl, HTTPS_PROXY: proxy.envUrl, no_proxy: noProxy, NO_PROXY: noProxy };
 }
 
 // ../server/dist/tools/sandbox.js
 var execAsync = promisify(exec);
 var execFileAsync = promisify(execFile);
-var HOME = homedir2();
-var HALO_HOME = path3.join(HOME, ".halo");
-var EMPTY_MASK_FILE = path3.join(HALO_HOME, ".sandbox-empty");
+var HOME = homedir3();
+var HALO_HOME = path4.join(HOME, ".halo");
+var EMPTY_MASK_FILE = path4.join(HALO_HOME, ".sandbox-empty");
 var DEFAULT_HIDDEN_DIRS = [
   "~/.halo/secrets",
   "~/.aws",
@@ -313,9 +405,9 @@ var DEFAULT_HIDDEN_FILES = [
 ];
 
 // ../server/dist/models/registry.js
-import fs2 from "node:fs";
-import path4 from "node:path";
-import YAML from "yaml";
+import fs3 from "node:fs";
+import path5 from "node:path";
+import YAML2 from "yaml";
 var MODEL_RUNTIME_NAMES = [
   "anthropic-messages",
   "openai-chat",
@@ -346,15 +438,15 @@ function logOnce(msg) {
 function readProviderDir(dir, source) {
   let names;
   try {
-    names = fs2.readdirSync(dir, { withFileTypes: true }).filter((e) => e.isFile() && e.name.endsWith(".yaml")).map((e) => e.name).sort();
+    names = fs3.readdirSync(dir, { withFileTypes: true }).filter((e) => e.isFile() && e.name.endsWith(".yaml")).map((e) => e.name).sort();
   } catch {
     return [];
   }
   const out = [];
   for (const name of names) {
-    const file = path4.join(dir, name);
+    const file = path5.join(dir, name);
     try {
-      const parsed = YAML.parse(fs2.readFileSync(file, "utf-8"));
+      const parsed = YAML2.parse(fs3.readFileSync(file, "utf-8"));
       if (parsed && typeof parsed === "object" && typeof parsed.id === "string") {
         out.push({
           id: parsed.id,
@@ -402,34 +494,34 @@ function loadProviders(bundledDir = globalModelsDir(), hubDir = globalHubModelsD
 }
 
 // ../server/dist/extensions/registry.js
-import fs4 from "node:fs";
-import path7 from "node:path";
+import fs5 from "node:fs";
+import path8 from "node:path";
 
 // ../server/dist/extensions/state.js
-import fs3 from "node:fs";
-import path6 from "node:path";
+import fs4 from "node:fs";
+import path7 from "node:path";
 
 // ../server/dist/init.js
-import path5 from "node:path";
+import path6 from "node:path";
 import { fileURLToPath } from "node:url";
-import YAML2 from "yaml";
-var __dirname = path5.dirname(fileURLToPath(import.meta.url));
-var TEMPLATES_DIR = path5.resolve(__dirname, "..", "templates");
+import YAML3 from "yaml";
+var __dirname = path6.dirname(fileURLToPath(import.meta.url));
+var TEMPLATES_DIR = path6.resolve(__dirname, "..", "templates");
 var DOCS_SRC_CANDIDATES = [
-  path5.resolve(__dirname, "..", "bundled-docs"),
-  path5.resolve(__dirname, "..", "..", "..", ".halo", "docs")
+  path6.resolve(__dirname, "..", "bundled-docs"),
+  path6.resolve(__dirname, "..", "..", "..", ".halo", "docs")
 ];
 
 // ../server/dist/extensions/state.js
 function extensionStatePath() {
-  return path6.join(globalExtensionsDir(), ".state.json");
+  return path7.join(globalExtensionsDir(), ".state.json");
 }
 var cache = null;
 function load() {
   const file = extensionStatePath();
   let st;
   try {
-    st = fs3.statSync(file);
+    st = fs4.statSync(file);
   } catch {
     return { states: {}, disabled: /* @__PURE__ */ new Set() };
   }
@@ -438,7 +530,7 @@ function load() {
     return cache;
   let states = null;
   try {
-    const raw = JSON.parse(fs3.readFileSync(file, "utf-8"));
+    const raw = JSON.parse(fs4.readFileSync(file, "utf-8"));
     if (typeof raw === "object" && raw !== null && !Array.isArray(raw))
       states = raw;
   } catch {
@@ -683,17 +775,17 @@ function parseManifest(raw, dirName, entryExists) {
     ...m.source !== void 0 ? { source: m.source } : {}
   };
 }
-function readExtensionDir(dir, id = path7.basename(dir)) {
+function readExtensionDir(dir, id = path8.basename(dir)) {
   let raw;
   try {
-    raw = JSON.parse(fs4.readFileSync(path7.join(dir, MANIFEST_FILE), "utf-8"));
+    raw = JSON.parse(fs5.readFileSync(path8.join(dir, MANIFEST_FILE), "utf-8"));
   } catch (err) {
     const code = err.code;
     return { id, error: code === "ENOENT" ? `${MANIFEST_FILE} missing` : `${MANIFEST_FILE} unreadable: ${err instanceof Error ? err.message : String(err)}` };
   }
   const parsed = parseManifest(raw, id, (entry) => {
     try {
-      return fs4.statSync(path7.join(dir, entry)).isFile();
+      return fs5.statSync(path8.join(dir, entry)).isFile();
     } catch {
       return false;
     }
@@ -702,7 +794,7 @@ function readExtensionDir(dir, id = path7.basename(dir)) {
     return { id, error: parsed.error };
   let installedAt = 0;
   try {
-    installedAt = Math.round(fs4.statSync(dir).mtimeMs);
+    installedAt = Math.round(fs5.statSync(dir).mtimeMs);
   } catch {
   }
   return { ...parsed, installedAt };
@@ -713,9 +805,9 @@ function getSnapshot() {
 }
 
 // ../server/dist/agents/skill-sources.js
-import fs5 from "node:fs";
-import path8 from "node:path";
-import { homedir as homedir3 } from "node:os";
+import fs6 from "node:fs";
+import path9 from "node:path";
+import { homedir as homedir4 } from "node:os";
 
 // ../server/dist/routes/mtime-cache.js
 function createMtimeCache() {
@@ -733,11 +825,11 @@ function createMtimeCache() {
 }
 
 // ../server/dist/agents/skill-sources.js
-var GLOBAL_SKILLS_DIR = path8.join(homedir3(), ".halo", "global", "skills");
+var GLOBAL_SKILLS_DIR = path9.join(homedir4(), ".halo", "global", "skills");
 var SKILL_ID_RE = /^[\w-]+$/;
 function isFile(p) {
   try {
-    return fs5.statSync(p).isFile();
+    return fs6.statSync(p).isFile();
   } catch {
     return false;
   }
@@ -745,13 +837,13 @@ function isFile(p) {
 function childDirs(parent) {
   let names;
   try {
-    names = fs5.readdirSync(parent);
+    names = fs6.readdirSync(parent);
   } catch {
     return [];
   }
   return names.filter((n) => {
     try {
-      return fs5.statSync(path8.join(parent, n)).isDirectory();
+      return fs6.statSync(path9.join(parent, n)).isDirectory();
     } catch {
       return false;
     }
@@ -766,7 +858,7 @@ function extensionSkillDirs() {
   const root = extensionsRoot();
   let extIds;
   try {
-    extIds = fs5.readdirSync(root);
+    extIds = fs6.readdirSync(root);
   } catch {
     return [];
   }
@@ -774,31 +866,31 @@ function extensionSkillDirs() {
   const taken = /* @__PURE__ */ new Set();
   let off;
   for (const extId of extIds.filter(isExtensionId).sort()) {
-    const extDir = path8.join(root, extId);
-    const ids = childDirs(path8.join(extDir, "skills"));
+    const extDir = path9.join(root, extId);
+    const ids = childDirs(path9.join(extDir, "skills"));
     if (ids.length === 0)
       continue;
     off ??= disabledExtensionIds();
     if (off.has(extId))
       continue;
-    const manifest = path8.join(extDir, MANIFEST_FILE);
+    const manifest = path9.join(extDir, MANIFEST_FILE);
     let mtimeMs;
     try {
-      mtimeMs = fs5.statSync(manifest).mtimeMs;
+      mtimeMs = fs6.statSync(manifest).mtimeMs;
     } catch {
       continue;
     }
     let entry = _manifestEntry.get(manifest, mtimeMs);
     if (entry === void 0) {
       const ext = readExtensionDir(extDir);
-      entry = _manifestEntry.set(manifest, mtimeMs, "error" in ext ? null : path8.join(extDir, ext.entry));
+      entry = _manifestEntry.set(manifest, mtimeMs, "error" in ext ? null : path9.join(extDir, ext.entry));
     }
     if (!entry || !isFile(entry))
       continue;
     const ignored = [];
     for (const id of ids.sort()) {
-      const dir = path8.join(extDir, "skills", id);
-      if (!fs5.existsSync(path8.join(dir, "SKILL.md")))
+      const dir = path9.join(extDir, "skills", id);
+      if (!fs6.existsSync(path9.join(dir, "SKILL.md")))
         continue;
       if (!isExtensionSkillId(extId, id) || taken.has(id)) {
         ignored.push(id);
@@ -823,28 +915,28 @@ function listSkillDirs(workspaceRoot) {
     seen.add(s.id);
   };
   if (workspaceRoot) {
-    const wsDir = path8.join(workspaceRoot, ".halo", "skills");
+    const wsDir = path9.join(workspaceRoot, ".halo", "skills");
     for (const id of childDirs(wsDir))
-      add({ id, dir: path8.join(wsDir, id), scope: "workspace" });
+      add({ id, dir: path9.join(wsDir, id), scope: "workspace" });
   }
   for (const id of childDirs(GLOBAL_SKILLS_DIR))
-    add({ id, dir: path8.join(GLOBAL_SKILLS_DIR, id), scope: "global" });
+    add({ id, dir: path9.join(GLOBAL_SKILLS_DIR, id), scope: "global" });
   for (const s of extensionSkillDirs())
     add(s);
   return out;
 }
 
 // ../server/dist/a2a/remotes.js
-import fs6 from "node:fs";
-import path9 from "node:path";
-import YAML3 from "yaml";
+import fs7 from "node:fs";
+import path10 from "node:path";
+import YAML4 from "yaml";
 function remotesFile() {
-  return path9.join(secretsDir(), "a2a-remotes.yaml");
+  return path10.join(secretsDir(), "a2a-remotes.yaml");
 }
 function loadRemotes() {
   let doc;
   try {
-    doc = YAML3.parse(fs6.readFileSync(remotesFile(), "utf8")) ?? {};
+    doc = YAML4.parse(fs7.readFileSync(remotesFile(), "utf8")) ?? {};
   } catch {
     return {};
   }
@@ -858,7 +950,7 @@ function loadRemotes() {
 }
 
 // ../server/dist/settings-schema.js
-var GLOBAL_AGENTS_DIR = path10.join(homedir4(), ".halo", "global", "agents");
+var GLOBAL_AGENTS_DIR = path11.join(homedir5(), ".halo", "global", "agents");
 var DEFAULT_A2A_URL_ALLOWLIST = "100.64.0.0/10,*.ts.net";
 var DEFAULT_FILES_SUMMARY = DEFAULT_HIDDEN_FILES.filter((f) => !/-(wal|shm)$/.test(f)).join(", ");
 function generalSection() {
@@ -869,9 +961,12 @@ function generalSection() {
     displayName_zh: "\u5E38\u89C4",
     description: "Server behavior parameters (session limits, compaction, sandbox, logging).",
     description_zh: "\u670D\u52A1\u7AEF\u884C\u4E3A\u53C2\u6570\uFF08\u4F1A\u8BDD\u9650\u5236\u3001\u538B\u7F29\u3001\u6C99\u7BB1\u3001\u65E5\u5FD7\uFF09\u3002",
-    // Every general.* field is globalOnly: config.ts reads them via
-    // settingsValue() from the global settings.yaml only. Per-workspace
-    // layering exists solely for namespaced params/secrets (getServerSecret).
+    // Every general.* field is globalOnly — config.ts reads them via
+    // settingsValue() from the global settings.yaml only; per-workspace
+    // layering is for namespaced params/secrets (getServerSecret) — except
+    // evolution.level and evolution.auto_apply_threshold: how far evo may act
+    // on its own is a property of the workspace (an open one at L0, a private
+    // one at L2/L3), read per workspace by evoLevelFor / autoApplyThresholdFor.
     fields: [
       // system-wide language preference. Read by internal agents (evo, score)
       // that don't load INSTRUCTIONS.md, and available to anything else that
@@ -917,11 +1012,18 @@ function generalSection() {
       // a workspace must not widen; public_url names this server to peers.
       { key: "a2a.public_url", type: "string", globalOnly: true, description: "Origin peers use to reach this server for A2A (e.g. http://myhost.tailnet.ts.net:9527): the agent card's interface URL and the webhook URL given to remotes. Empty = derived from the request Host. Env HALO_A2A_PUBLIC_URL overrides.", description_zh: "\u5BF9\u7AEF\u8BBF\u95EE\u672C\u670D\u52A1\u7684 A2A \u6E90\u5730\u5740\uFF08\u5982 http://myhost.tailnet.ts.net:9527\uFF09\uFF1A\u7528\u4E8E agent card \u7684\u63A5\u53E3 URL \u548C\u4EA4\u7ED9\u8FDC\u7AEF\u7684 webhook URL\u3002\u7559\u7A7A\u5219\u6309\u8BF7\u6C42 Host \u63A8\u5BFC\u3002\u73AF\u5883\u53D8\u91CF HALO_A2A_PUBLIC_URL \u4F18\u5148\u3002", default: "" },
       { key: "a2a.url_allowlist", type: "string", globalOnly: true, description: "Comma-separated CIDRs / host patterns A2A may reach besides public https (push webhooks, remote cards and RPC). Private / loopback ranges are refused unless listed; plain http is allowed only to listed hosts / ranges. Link-local (169.254.0.0/16, fe80::/10) is always refused.", description_zh: "A2A \u9664\u516C\u7F51 https \u4E4B\u5916\u5141\u8BB8\u8BBF\u95EE\u7684 CIDR / \u4E3B\u673A\u6A21\u5F0F\uFF08\u9017\u53F7\u5206\u9694\uFF0C\u7528\u4E8E push webhook\u3001\u8FDC\u7AEF card \u548C RPC\uFF09\u3002\u79C1\u7F51 / \u56DE\u73AF\u5730\u5740\u5FC5\u987B\u5217\u51FA\u624D\u5141\u8BB8\uFF1B\u660E\u6587 http \u53EA\u5141\u8BB8\u5217\u51FA\u7684\u4E3B\u673A / \u7F51\u6BB5\u3002\u94FE\u8DEF\u672C\u5730\u5730\u5740\uFF08169.254.0.0/16\u3001fe80::/10\uFF09\u59CB\u7EC8\u62D2\u7EDD\u3002", default: DEFAULT_A2A_URL_ALLOWLIST },
-      // self-evolution (see plans/self-evolution.md). All evo settings are
-      // global-only — the worker / ticker live in the server process and
-      // would have to reload mid-flight if a workspace could override them.
-      { key: "evolution.level", type: "enum", options: ["L0", "L1", "L2", "L3"], globalOnly: true, description: "Self-evolution capability ladder. L0: manual only \u2014 drafts via /evo, manual approve/reject. L1: L0 plus automatic drafting on pre-compact. L2: L1 plus auto-applying prompt-only changes that score above evolution.auto_apply_threshold. L3: L2 plus auto-applying capability changes (agent.yaml tools / model, skill invocation). Auto-applied changes still pass the regression check and can be rolled back from the Evolution tab. Queued runs always execute regardless of level.", description_zh: "\u81EA\u6211\u8FDB\u5316\u7B49\u7EA7\u3002L0\uFF1A\u4EC5\u624B\u52A8\u2014\u2014\u901A\u8FC7 /evo \u8D77\u8349\uFF0C\u624B\u52A8 approve/reject\u3002L1\uFF1A\u5728 L0 \u57FA\u7840\u4E0A\uFF0C\u538B\u7F29\u524D\uFF08pre-compact\uFF09\u81EA\u52A8\u8D77\u8349\u3002L2\uFF1A\u5728 L1 \u57FA\u7840\u4E0A\uFF0C\u5BF9\u8BC4\u5206\u8D85\u8FC7 evolution.auto_apply_threshold \u7684\u7EAF\u63D0\u793A\u8BCD\u6539\u52A8\u81EA\u52A8\u5E94\u7528\u3002L3\uFF1A\u5728 L2 \u57FA\u7840\u4E0A\uFF0C\u5BF9\u80FD\u529B\u7C7B\u6539\u52A8\uFF08agent.yaml \u7684\u5DE5\u5177/\u6A21\u578B\u3001skill \u8C03\u7528\u65B9\u5F0F\uFF09\u4E5F\u81EA\u52A8\u5E94\u7528\u3002\u81EA\u52A8\u5E94\u7528\u7167\u6837\u8FC7\u56DE\u5F52\u68C0\u67E5\uFF0C\u53EF\u5728 Evolution \u9875\u56DE\u6EDA\u3002\u5DF2\u6392\u961F\u7684 run \u4E0D\u53D7\u7B49\u7EA7\u5F71\u54CD\uFF0C\u59CB\u7EC8\u6267\u884C\u3002", default: "L0" },
-      { key: "evolution.auto_apply_threshold", type: "int", min: 0, max: 100, globalOnly: true, description: "Minimum average score (0\u2013100) for auto-apply at L2/L3. Also required: confidence high, behavior \u2265 70, lint 100, all sandbox checks passed. Ignored at L0/L1.", description_zh: "L2/L3 \u81EA\u52A8\u5E94\u7528\u8981\u6C42\u7684\u6700\u4F4E\u5E73\u5747\u5206\uFF080\u2013100\uFF09\u3002\u53E6\u9700\u540C\u65F6\u6EE1\u8DB3\uFF1Aconfidence \u4E3A high\u3001behavior \u2265 70\u3001lint \u4E3A 100\u3001\u6C99\u7BB1\u68C0\u67E5\u5168\u90E8\u901A\u8FC7\u3002L0/L1 \u4E0B\u5FFD\u7565\u3002", default: "80" },
+      // Outbound proxy (outbound-proxy.ts). Global-only: a machine's way out,
+      // not a workspace's. Read per spawn / request — no restart.
+      { key: "outbound_proxy.enabled", type: "boolean", globalOnly: true, description: "Route outbound traffic through the proxy below: shell_exec, newly opened Terminals, notebook kernels and evolution runs get http_proxy / https_proxy (and the upper-case forms) in their env, and web_fetch and A2A requests to remotes go through it. localhost / 127.0.0.1 / ::1 always connect directly. Off = Halo sets no proxy vars (any the server inherited still pass). Applies on the next command / request; a Terminal already open keeps its env.", description_zh: "\u8BA9\u51FA\u7AD9\u6D41\u91CF\u8D70\u4E0B\u9762\u7684\u4EE3\u7406\uFF1Ashell_exec\u3001\u65B0\u5F00\u7684 Terminal\u3001notebook \u5185\u6838\u548C evolution \u8FD0\u884C\u7684\u73AF\u5883\u53D8\u91CF\u91CC\u4F1A\u8BBE\u4E0A http_proxy / https_proxy\uFF08\u5927\u5199\u5F62\u5F0F\u4E5F\u4E00\u8D77\u8BBE\uFF09\uFF0Cweb_fetch \u548C\u53D1\u5F80 A2A \u8FDC\u7AEF\u7684\u8BF7\u6C42\u4E5F\u8D70\u4EE3\u7406\u3002localhost / 127.0.0.1 / ::1 \u59CB\u7EC8\u76F4\u8FDE\u3002\u5173\u95ED\u540E Halo \u4E0D\u8BBE\u4EFB\u4F55\u4EE3\u7406\u53D8\u91CF\uFF08\u670D\u52A1\u8FDB\u7A0B\u672C\u8EAB\u7EE7\u627F\u7684\u7167\u5E38\u4F20\u4E0B\u53BB\uFF09\u3002\u4E0B\u4E00\u6761\u547D\u4EE4 / \u8BF7\u6C42\u5373\u751F\u6548\uFF1B\u5DF2\u7ECF\u6253\u5F00\u7684 Terminal \u4FDD\u6301\u539F\u6765\u7684\u73AF\u5883\u3002", default: "false" },
+      { key: "outbound_proxy.url", type: "string", globalOnly: true, description: "Proxy address, http:// or https:// (e.g. http://127.0.0.1:12334 for a local Hiddify / Clash). No user:pass@ in the URL \u2014 put credentials in Token. Empty = proxy off even when enabled.", description_zh: "\u4EE3\u7406\u5730\u5740\uFF0Chttp:// \u6216 https://\uFF08\u5982\u672C\u5730 Hiddify / Clash \u7684 http://127.0.0.1:12334\uFF09\u3002URL \u91CC\u4E0D\u80FD\u5E26 user:pass@\uFF0C\u51ED\u8BC1\u586B\u5230 Token\u3002\u7559\u7A7A\u65F6\u5373\u4F7F\u6253\u5F00\u5F00\u5173\u4E5F\u4E0D\u8D70\u4EE3\u7406\u3002", default: "", placeholder: "http://127.0.0.1:12334" },
+      { key: "outbound_proxy.token", type: "string", secret: true, globalOnly: true, description: "Optional proxy credential: user:password, or a bare token (sent as the user name, empty password). Sent as Basic auth \u2014 in the proxy URL's user-info for child processes (the form curl / git / pip read), as Proxy-Authorization for web_fetch and A2A. Leave empty for a proxy without auth.", description_zh: "\u53EF\u9009\u7684\u4EE3\u7406\u51ED\u8BC1\uFF1Auser:password\uFF0C\u6216\u5355\u72EC\u4E00\u4E2A token\uFF08\u4F5C\u4E3A\u7528\u6237\u540D\uFF0C\u5BC6\u7801\u4E3A\u7A7A\uFF09\u3002\u4EE5 Basic \u8BA4\u8BC1\u53D1\u9001\u2014\u2014\u5B50\u8FDB\u7A0B\u653E\u5728\u4EE3\u7406 URL \u7684 user-info \u91CC\uFF08curl / git / pip \u90FD\u8BA4\u8FD9\u79CD\u5199\u6CD5\uFF09\uFF0Cweb_fetch \u548C A2A \u7528 Proxy-Authorization \u5934\u3002\u4EE3\u7406\u4E0D\u9700\u8981\u9274\u6743\u5C31\u7559\u7A7A\u3002", default: "" },
+      // self-evolution (see plans/self-evolution.md). The level and the
+      // auto-apply threshold are per workspace (read where a run's workspace is
+      // known: the pre-compact trigger, the wrapper's auto-apply verdict and
+      // recheck). The rest stays global-only: the ticker's slots, timeouts and
+      // retries are server-wide, and pre-compact snapshots are a server switch.
+      { key: "evolution.level", type: "enum", options: ["L0", "L1", "L2", "L3"], description: "Self-evolution capability ladder. L0: manual only \u2014 drafts via /evo, manual approve/reject. L1: L0 plus automatic drafting on pre-compact. L2: L1 plus auto-applying prompt-only changes that score above evolution.auto_apply_threshold. L3: L2 plus auto-applying capability changes (agent.yaml tools / model, skill invocation). Auto-applied changes still pass the regression check and can be rolled back from the Evolution tab. Queued runs always execute regardless of level.", description_zh: "\u81EA\u6211\u8FDB\u5316\u7B49\u7EA7\u3002L0\uFF1A\u4EC5\u624B\u52A8\u2014\u2014\u901A\u8FC7 /evo \u8D77\u8349\uFF0C\u624B\u52A8 approve/reject\u3002L1\uFF1A\u5728 L0 \u57FA\u7840\u4E0A\uFF0C\u538B\u7F29\u524D\uFF08pre-compact\uFF09\u81EA\u52A8\u8D77\u8349\u3002L2\uFF1A\u5728 L1 \u57FA\u7840\u4E0A\uFF0C\u5BF9\u8BC4\u5206\u8D85\u8FC7 evolution.auto_apply_threshold \u7684\u7EAF\u63D0\u793A\u8BCD\u6539\u52A8\u81EA\u52A8\u5E94\u7528\u3002L3\uFF1A\u5728 L2 \u57FA\u7840\u4E0A\uFF0C\u5BF9\u80FD\u529B\u7C7B\u6539\u52A8\uFF08agent.yaml \u7684\u5DE5\u5177/\u6A21\u578B\u3001skill \u8C03\u7528\u65B9\u5F0F\uFF09\u4E5F\u81EA\u52A8\u5E94\u7528\u3002\u81EA\u52A8\u5E94\u7528\u7167\u6837\u8FC7\u56DE\u5F52\u68C0\u67E5\uFF0C\u53EF\u5728 Evolution \u9875\u56DE\u6EDA\u3002\u5DF2\u6392\u961F\u7684 run \u4E0D\u53D7\u7B49\u7EA7\u5F71\u54CD\uFF0C\u59CB\u7EC8\u6267\u884C\u3002", default: "L0" },
+      { key: "evolution.auto_apply_threshold", type: "int", min: 0, max: 100, description: "Minimum average score (0\u2013100) for auto-apply at L2/L3. Also required: confidence high, behavior \u2265 70, lint 100, all sandbox checks passed. Ignored at L0/L1.", description_zh: "L2/L3 \u81EA\u52A8\u5E94\u7528\u8981\u6C42\u7684\u6700\u4F4E\u5E73\u5747\u5206\uFF080\u2013100\uFF09\u3002\u53E6\u9700\u540C\u65F6\u6EE1\u8DB3\uFF1Aconfidence \u4E3A high\u3001behavior \u2265 70\u3001lint \u4E3A 100\u3001\u6C99\u7BB1\u68C0\u67E5\u5168\u90E8\u901A\u8FC7\u3002L0/L1 \u4E0B\u5FFD\u7565\u3002", default: "80" },
       { key: "evolution.max_concurrent_run", type: "int", globalOnly: true, description: "Max concurrent evo run wrappers (drafting patches).", description_zh: "\u540C\u65F6\u8FD0\u884C\u7684 evo run wrapper \u4E0A\u9650\uFF08\u8D77\u8349 patch\uFF09\u3002", default: "1" },
       { key: "evolution.max_concurrent_apply", type: "int", globalOnly: true, description: "Max concurrent evo apply wrappers (merging patches).", description_zh: "\u540C\u65F6\u8FD0\u884C\u7684 evo apply wrapper \u4E0A\u9650\uFF08\u5408\u5E76 patch\uFF09\u3002", default: "1" },
       { key: "evolution.run_timeout_minutes", type: "int", globalOnly: true, description: "Heartbeat timeout for run wrappers. The wrapper writes a heartbeat every 60s for as long as it lives, so exceeding this means the wrapper process died \u2014 the row is requeued (or marked timeout past max_attempts). This is dead-wrapper detection latency, NOT a budget for slow models; the per-phase model budget is the wrapper-internal cap (draft 60min, other phases 45min).", description_zh: "run wrapper \u5FC3\u8DF3\u8D85\u65F6\uFF08\u5206\u949F\uFF09\u3002wrapper \u5B58\u6D3B\u671F\u95F4\u6BCF 60 \u79D2\u5199\u4E00\u6B21\u5FC3\u8DF3\uFF0C\u8D85\u65F6\u5373\u89C6\u4E3A wrapper \u8FDB\u7A0B\u5DF2\u6B7B\uFF0C\u4EFB\u52A1\u91CD\u6392\uFF08\u8D85\u8FC7 max_attempts \u5219\u6807 timeout\uFF09\u3002\u8FD9\u662F\u6B7B wrapper \u7684\u68C0\u6D4B\u5EF6\u8FDF\uFF0C\u4E0D\u662F\u6162\u6A21\u578B\u7684\u8FD0\u884C\u9884\u7B97\u2014\u2014\u5355\u9636\u6BB5\u6A21\u578B\u9884\u7B97\u662F wrapper \u5185\u90E8\u7684\u4E0A\u9650\uFF08\u8D77\u8349 60 \u5206\u949F\uFF0C\u5176\u4F59\u9636\u6BB5 45 \u5206\u949F\uFF09\u3002", default: "12" },
@@ -951,11 +1053,11 @@ var _yamlCache = createMtimeCache();
 var _skillNameCache = createMtimeCache();
 function readYamlFile(p) {
   try {
-    const { mtimeMs } = fs7.statSync(p);
+    const { mtimeMs } = fs8.statSync(p);
     const hit = _yamlCache.get(p, mtimeMs);
     if (hit !== void 0)
       return hit;
-    const parsed = YAML4.parse(fs7.readFileSync(p, "utf-8"));
+    const parsed = YAML5.parse(fs8.readFileSync(p, "utf-8"));
     return _yamlCache.set(p, mtimeMs, parsed && typeof parsed === "object" ? parsed : null);
   } catch {
     return null;
@@ -1010,8 +1112,8 @@ function providerSections() {
   return sections;
 }
 function buildSkillSection(skillsDir, skillId) {
-  const configPath = path10.join(skillsDir, skillId, "config.yaml");
-  if (!fs7.existsSync(configPath))
+  const configPath = path11.join(skillsDir, skillId, "config.yaml");
+  if (!fs8.existsSync(configPath))
     return null;
   const parsed = readYamlFile(configPath);
   if (!parsed)
@@ -1022,11 +1124,11 @@ function buildSkillSection(skillsDir, skillId) {
     return null;
   let displayName = skillId;
   try {
-    const mdPath = path10.join(skillsDir, skillId, "SKILL.md");
-    const { mtimeMs } = fs7.statSync(mdPath);
+    const mdPath = path11.join(skillsDir, skillId, "SKILL.md");
+    const { mtimeMs } = fs8.statSync(mdPath);
     let name = _skillNameCache.get(mdPath, mtimeMs);
     if (name === void 0) {
-      const m = fs7.readFileSync(mdPath, "utf-8").match(/^---\s*\n([\s\S]*?)\n---/);
+      const m = fs8.readFileSync(mdPath, "utf-8").match(/^---\s*\n([\s\S]*?)\n---/);
       const nameMatch = m?.[1].match(/^name:\s*(.+)$/m);
       name = _skillNameCache.set(mdPath, mtimeMs, nameMatch ? nameMatch[1].trim() : null);
     }
@@ -1047,7 +1149,7 @@ function buildSkillSection(skillsDir, skillId) {
 function skillSections(workspaceRoot) {
   const byId = /* @__PURE__ */ new Map();
   for (const { id, dir } of listSkillDirs(workspaceRoot).reverse()) {
-    const section = buildSkillSection(path10.dirname(dir), id);
+    const section = buildSkillSection(path11.dirname(dir), id);
     if (section)
       byId.set(section.namespaceId, section);
   }
@@ -1057,7 +1159,7 @@ function agentSections() {
   const sections = [];
   let entries = [];
   try {
-    entries = fs7.readdirSync(GLOBAL_AGENTS_DIR, { withFileTypes: true });
+    entries = fs8.readdirSync(GLOBAL_AGENTS_DIR, { withFileTypes: true });
   } catch {
     return sections;
   }
@@ -1065,8 +1167,8 @@ function agentSections() {
     if (!entry.isDirectory())
       continue;
     const agentId = entry.name;
-    const configPath = path10.join(GLOBAL_AGENTS_DIR, agentId, "agent-config.yaml");
-    if (!fs7.existsSync(configPath))
+    const configPath = path11.join(GLOBAL_AGENTS_DIR, agentId, "agent-config.yaml");
+    if (!fs8.existsSync(configPath))
       continue;
     const parsed = readYamlFile(configPath);
     if (!parsed)
@@ -1077,7 +1179,7 @@ function agentSections() {
       continue;
     let displayName = agentId;
     try {
-      const ay = readYamlFile(path10.join(GLOBAL_AGENTS_DIR, agentId, "agent.yaml"));
+      const ay = readYamlFile(path11.join(GLOBAL_AGENTS_DIR, agentId, "agent.yaml"));
       if (ay && typeof ay.name === "string")
         displayName = ay.name;
     } catch {
@@ -1140,23 +1242,15 @@ function extensionSections() {
 }
 
 // ../server/dist/config.js
-var HALO_HOME2 = path11.join(homedir5(), ".halo");
-var HALO_GLOBAL_DIR = path11.join(HALO_HOME2, "global");
-var HALO_SECRETS_DIR = path11.join(HALO_HOME2, "secrets");
-function loadYamlFile(filePath) {
-  try {
-    const raw = fs8.readFileSync(filePath, "utf-8");
-    return YAML5.parse(raw) ?? {};
-  } catch {
-    return {};
-  }
-}
-var SYSTEM_CONFIG_PATH = path11.join(HALO_SECRETS_DIR, "config.yaml");
+var HALO_HOME2 = path12.join(homedir6(), ".halo");
+var HALO_GLOBAL_DIR = path12.join(HALO_HOME2, "global");
+var HALO_SECRETS_DIR = path12.join(HALO_HOME2, "secrets");
+var SYSTEM_CONFIG_PATH = path12.join(HALO_SECRETS_DIR, "config.yaml");
 var _systemConfigCache = null;
 function getSystemConfig() {
   let mtimeMs = 0;
   try {
-    mtimeMs = fs8.statSync(SYSTEM_CONFIG_PATH).mtimeMs;
+    mtimeMs = fs9.statSync(SYSTEM_CONFIG_PATH).mtimeMs;
   } catch {
   }
   if (!_systemConfigCache || _systemConfigCache.mtimeMs !== mtimeMs) {
@@ -1164,19 +1258,6 @@ function getSystemConfig() {
   }
   return _systemConfigCache.data;
 }
-var SETTINGS_PATH = path11.join(HALO_SECRETS_DIR, "settings.yaml");
-var _settingsCache = null;
-function getSettings() {
-  let mtimeMs = 0;
-  try {
-    mtimeMs = fs8.statSync(SETTINGS_PATH).mtimeMs;
-  } catch {
-  }
-  if (!_settingsCache || _settingsCache.mtimeMs !== mtimeMs) {
-    _settingsCache = { mtimeMs, data: loadYamlFile(SETTINGS_PATH) };
-  }
-  return _settingsCache.data;
-}
 function readYamlValue(tree, dotPath) {
   const parts = dotPath.split(".");
   let cur = tree;
@@ -1303,6 +1384,21 @@ function systemString(envKey, configPath, fallback) {
     return cv;
   return fallback;
 }
+var _wsSettingsCache = /* @__PURE__ */ new Map();
+function getWorkspaceSettings(workspaceRoot) {
+  const p = path12.join(workspaceRoot, ".halo", "settings.yaml");
+  let mtimeMs = 0;
+  try {
+    mtimeMs = fs9.statSync(p).mtimeMs;
+  } catch {
+  }
+  const hit = _wsSettingsCache.get(workspaceRoot);
+  if (hit && hit.mtimeMs === mtimeMs)
+    return hit.data;
+  const entry = { mtimeMs, data: loadYamlFile(p) };
+  _wsSettingsCache.set(workspaceRoot, entry);
+  return entry.data;
+}
 var EVO_LEVELS = ["L0", "L1", "L2", "L3"];
 function parseEvoLevel(raw) {
   return EVO_LEVELS.includes(raw) ? raw : "L0";
@@ -1310,6 +1406,19 @@ function parseEvoLevel(raw) {
 function evoLevelRank(level) {
   return EVO_LEVELS.indexOf(level);
 }
+function generalValueFor(workspaceRoot, dotPath) {
+  const ws = readYamlValue(getWorkspaceSettings(workspaceRoot), dotPath);
+  if (ws != null && String(ws) !== "")
+    return String(ws);
+  return settingsValue(dotPath);
+}
+function evoLevelFor(workspaceRoot) {
+  return parseEvoLevel(generalValueFor(workspaceRoot, "general.evolution.level") ?? schemaDefault("general.evolution.level", "L0"));
+}
+function autoApplyThresholdFor(workspaceRoot) {
+  const n = parseInt(generalValueFor(workspaceRoot, "general.evolution.auto_apply_threshold") ?? "", 10);
+  return isNaN(n) ? settingsInt("general.evolution.auto_apply_threshold", 80) : n;
+}
 var config = {
   // Goal entry points are retired, not the runtime. Internal/global-only, no UI:
   // set general.goal_mode_enabled in ~/.halo/secrets/settings.yaml, then restart.
@@ -1487,7 +1596,7 @@ var config = {
   a2a: {
     /** Base dir workspaces are exposed relative to: env HALO_A2A_ROOT, else the user's home. */
     get root() {
-      return process.env.HALO_A2A_ROOT?.trim() || homedir5();
+      return process.env.HALO_A2A_ROOT?.trim() || homedir6();
     },
     /** Server origin as peers see it (no trailing slash); '' = derive from the request. */
     get publicUrl() {
@@ -1498,16 +1607,10 @@ var config = {
     }
   },
   // Self-evolution (see plans/self-evolution.md). Getter-based so user edits
-  // in settings.yaml take effect on the next ticker run without restart.
+  // in settings.yaml take effect on the next ticker run without restart. The
+  // level and auto-apply threshold are per workspace: evoLevelFor /
+  // autoApplyThresholdFor.
   evolution: {
-    get level() {
-      return parseEvoLevel(settingsStr("general.evolution.level", "L0"));
-    },
-    // Minimum average score for L2/L3 auto-apply (see evolution/auto-apply.ts
-    // for the extra fixed floors).
-    get autoApplyThreshold() {
-      return settingsInt("general.evolution.auto_apply_threshold", 80);
-    },
     get maxConcurrentRun() {
       return settingsInt("general.evolution.max_concurrent_run", 1);
     },
@@ -1538,21 +1641,21 @@ var config = {
 };
 
 // ../server/dist/evolution/auto-apply.js
-import fs9 from "node:fs";
-import path12 from "node:path";
+import fs10 from "node:fs";
+import path13 from "node:path";
 import YAML6 from "yaml";
 var AUTO_APPLY_FILE = "auto-apply.json";
 var OVERRIDE_DIRS = /* @__PURE__ */ new Set(["agents", "skills", "prompts"]);
 function isDir(p) {
   try {
-    return fs9.statSync(p).isDirectory();
+    return fs10.statSync(p).isDirectory();
   } catch {
     return false;
   }
 }
 function readOrNull(p) {
   try {
-    return fs9.readFileSync(p);
+    return fs10.readFileSync(p);
   } catch {
     return null;
   }
@@ -1560,33 +1663,33 @@ function readOrNull(p) {
 function walkFiles(root, rel, out = []) {
   let st;
   try {
-    st = fs9.statSync(path12.join(root, rel));
+    st = fs10.statSync(path13.join(root, rel));
   } catch {
     return out;
   }
   if (st.isFile())
     out.push(rel);
   else if (st.isDirectory()) {
-    for (const e of fs9.readdirSync(path12.join(root, rel)))
-      walkFiles(root, path12.join(rel, e), out);
+    for (const e of fs10.readdirSync(path13.join(root, rel)))
+      walkFiles(root, path13.join(rel, e), out);
   }
   return out;
 }
-var toPosix = (rel) => rel.split(path12.sep).join("/");
+var toPosix = (rel) => rel.split(path13.sep).join("/");
 function isInternalAgentDir(dir) {
-  const raw = readOrNull(path12.join(dir, "agent.yaml"));
+  const raw = readOrNull(path13.join(dir, "agent.yaml"));
   return raw !== null && parseYamlLoose(raw.toString("utf-8"))?.internal === true;
 }
 function liveBaseline(dirs, rel) {
-  const parts = rel.split(path12.sep);
+  const parts = rel.split(path13.sep);
   if (!OVERRIDE_DIRS.has(parts[0]) || parts.length < 3)
-    return { file: path12.join(dirs.mainHalo, rel), newDir: false };
-  const dirRel = path12.join(parts[0], parts[1]);
-  const internal = (root) => parts[0] === "agents" && isInternalAgentDir(path12.join(root, dirRel));
-  if (isDir(path12.join(dirs.mainHalo, dirRel)))
-    return { file: path12.join(dirs.mainHalo, rel), newDir: false, internalAgent: internal(dirs.mainHalo) };
-  if (isDir(path12.join(dirs.globalHalo, dirRel)))
-    return { file: path12.join(dirs.globalHalo, rel), newDir: false, globalDir: dirRel, internalAgent: internal(dirs.globalHalo) };
+    return { file: path13.join(dirs.mainHalo, rel), newDir: false };
+  const dirRel = path13.join(parts[0], parts[1]);
+  const internal = (root) => parts[0] === "agents" && isInternalAgentDir(path13.join(root, dirRel));
+  if (isDir(path13.join(dirs.mainHalo, dirRel)))
+    return { file: path13.join(dirs.mainHalo, rel), newDir: false, internalAgent: internal(dirs.mainHalo) };
+  if (isDir(path13.join(dirs.globalHalo, dirRel)))
+    return { file: path13.join(dirs.globalHalo, rel), newDir: false, globalDir: dirRel, internalAgent: internal(dirs.globalHalo) };
   return { file: null, newDir: true };
 }
 function fileChange(rel, base, after) {
@@ -1608,15 +1711,15 @@ function publishChanges(dirs, files) {
     const base = liveBaseline(dirs, rel);
     if (base.globalDir)
       globalBacked.add(base.globalDir);
-    const c = fileChange(rel, base, fs9.readFileSync(full));
+    const c = fileChange(rel, base, fs10.readFileSync(full));
     if (c)
       out.push(c);
   }
   for (const dirRel of globalBacked) {
     for (const rel of walkFiles(dirs.globalHalo, dirRel)) {
-      if (fs9.existsSync(path12.join(dirs.sandboxHalo, rel)))
+      if (fs10.existsSync(path13.join(dirs.sandboxHalo, rel)))
         continue;
-      out.push({ rel: toPosix(rel), before: fs9.readFileSync(path12.join(dirs.globalHalo, rel), "utf-8"), after: null, newDir: false });
+      out.push({ rel: toPosix(rel), before: fs10.readFileSync(path13.join(dirs.globalHalo, rel), "utf-8"), after: null, newDir: false });
     }
   }
   return out;
@@ -1631,21 +1734,21 @@ function collectChanges(dirs) {
       const base = liveBaseline(dirs, rel);
       if (base.globalDir)
         globalBacked.add(base.globalDir);
-      const c = fileChange(rel, base, fs9.readFileSync(path12.join(dirs.sandboxHalo, rel)));
+      const c = fileChange(rel, base, fs10.readFileSync(path13.join(dirs.sandboxHalo, rel)));
       if (c)
         out.push(c);
     }
     for (const rel of walkFiles(dirs.mainHalo, top)) {
       if (seen.has(rel))
         continue;
-      out.push({ rel: toPosix(rel), before: fs9.readFileSync(path12.join(dirs.mainHalo, rel), "utf-8"), after: null, newDir: false });
+      out.push({ rel: toPosix(rel), before: fs10.readFileSync(path13.join(dirs.mainHalo, rel), "utf-8"), after: null, newDir: false });
     }
   }
   for (const dirRel of globalBacked) {
     for (const rel of walkFiles(dirs.globalHalo, dirRel)) {
       if (seen.has(rel))
         continue;
-      out.push({ rel: toPosix(rel), before: fs9.readFileSync(path12.join(dirs.globalHalo, rel), "utf-8"), after: null, newDir: false });
+      out.push({ rel: toPosix(rel), before: fs10.readFileSync(path13.join(dirs.globalHalo, rel), "utf-8"), after: null, newDir: false });
     }
   }
   return out;
@@ -1857,7 +1960,7 @@ function parseScore(raw) {
 }
 function readScore(file) {
   try {
-    return parseScore(JSON.parse(fs9.readFileSync(file, "utf-8")));
+    return parseScore(JSON.parse(fs10.readFileSync(file, "utf-8")));
   } catch {
     return null;
   }
@@ -1877,11 +1980,8 @@ function categoryGate(level, cls) {
   return null;
 }
 function sourceGate(sourceAccess) {
-  if (sourceAccess === SOURCE_WEBHOOK)
-    return "source_webhook";
   return sourceAccess === "full" ? null : "source_access";
 }
-var SOURCE_WEBHOOK = "webhook";
 function scoreGate(score, threshold) {
   if (!score)
     return "score_missing";
@@ -1939,7 +2039,7 @@ function extractLargerObservation(md) {
 }
 function readObservation(file) {
   try {
-    return extractLargerObservation(fs9.readFileSync(file, "utf-8"));
+    return extractLargerObservation(fs10.readFileSync(file, "utf-8"));
   } catch {
     return null;
   }
@@ -2001,11 +2101,11 @@ function failApply(db, applyId, input) {
 }
 
 // ../server/dist/evolution/rollback.js
-import fs10 from "node:fs";
+import fs11 from "node:fs";
 import { createHash } from "node:crypto";
 import { and as and2, eq as eq2, inArray } from "drizzle-orm";
 function sha256File(file) {
-  return createHash("sha256").update(fs10.readFileSync(file)).digest("hex");
+  return createHash("sha256").update(fs11.readFileSync(file)).digest("hex");
 }
 
 // ../server/dist/evolution/evo-wrapper.js
@@ -2067,9 +2167,9 @@ function spawnProc(bin, args, logFd, teePath, stdinInput, timeoutSec) {
   }
   writeLog(logFd, `[wrapper] $ ${bin} ${loggedArgs.join(" ")}${stdinInput === void 0 ? " <last-arg-omitted>" : " <prompt-on-stdin>"}${timeoutSec ? ` (timeout ${timeoutSec}s)` : ""}
 `);
-  const tee = teePath ? fs11.createWriteStream(teePath, { flags: "a" }) : null;
+  const tee = teePath ? fs12.createWriteStream(teePath, { flags: "a" }) : null;
   const [spawnBin, spawnArgs] = process.platform === "win32" && bin.endsWith(".cmd") ? ["cmd.exe", ["/c", bin, ...args]] : [bin, args];
-  return new Promise((resolve) => {
+  return new Promise((resolve2) => {
     const child = spawn2(spawnBin, spawnArgs, {
       // Pipe stdin only when we have input to write — the cli reads a prompt
       // from stdin when it's not a TTY, which is how long briefs are delivered
@@ -2141,7 +2241,7 @@ function spawnProc(bin, args, logFd, teePath, stdinInput, timeoutSec) {
       tee?.end();
       if (stopping)
         return;
-      resolve({ exitCode, stdout, stderr });
+      resolve2({ exitCode, stdout, stderr });
     });
     child.on("error", (err) => {
       liveProcs.delete(killTree);
@@ -2157,17 +2257,17 @@ function spawnProc(bin, args, logFd, teePath, stdinInput, timeoutSec) {
       tee?.end();
       if (stopping)
         return;
-      resolve({ exitCode: 1, stdout, stderr: stderr + `
+      resolve2({ exitCode: 1, stdout, stderr: stderr + `
 [spawn error] ${err.message}` });
     });
   });
 }
 function subCliLogPath(runDir) {
-  return path13.join(runDir, "sub-cli.log");
+  return path14.join(runDir, "sub-cli.log");
 }
 function appendSubCliHeader(runDir, header) {
   try {
-    fs11.appendFileSync(subCliLogPath(runDir), `
+    fs12.appendFileSync(subCliLogPath(runDir), `
 === ${(/* @__PURE__ */ new Date()).toISOString()} ${header} ===
 `);
   } catch {
@@ -2201,10 +2301,10 @@ function buildLanguageClause(langHint, scope) {
   ];
 }
 function readPatchFrontmatter(runDir) {
-  const patchPath = path13.join(runDir, "patch.md");
+  const patchPath = path14.join(runDir, "patch.md");
   let raw;
   try {
-    raw = fs11.readFileSync(patchPath, "utf-8");
+    raw = fs12.readFileSync(patchPath, "utf-8");
   } catch {
     return null;
   }
@@ -2234,14 +2334,14 @@ function extractTestScenario(fm) {
   return { agentId: o.agentId, testMessage, originalMessage };
 }
 function readEvoContext(runDir, logFd) {
-  const p = path13.join(runDir, "evo-context.json");
-  if (!fs11.existsSync(p)) {
+  const p = path14.join(runDir, "evo-context.json");
+  if (!fs12.existsSync(p)) {
     writeLog(logFd, `[brief] evo-context.json missing at ${p}
 `);
     return null;
   }
   try {
-    return JSON.parse(fs11.readFileSync(p, "utf-8"));
+    return JSON.parse(fs12.readFileSync(p, "utf-8"));
   } catch (err) {
     writeLog(logFd, `[brief] evo-context.json parse failed: ${err instanceof Error ? err.message : String(err)}
 `);
@@ -2249,12 +2349,12 @@ function readEvoContext(runDir, logFd) {
   }
 }
 function dumpSnapshotImages(runDir, logFd) {
-  const snapshotPath = path13.join(runDir, "source-snapshot.json");
-  if (!fs11.existsSync(snapshotPath))
+  const snapshotPath = path14.join(runDir, "source-snapshot.json");
+  if (!fs12.existsSync(snapshotPath))
     return [];
   let parsed;
   try {
-    parsed = JSON.parse(fs11.readFileSync(snapshotPath, "utf-8"));
+    parsed = JSON.parse(fs12.readFileSync(snapshotPath, "utf-8"));
   } catch {
     writeLog(logFd, `[dumpSnapshotImages] snapshot parse failed
 `);
@@ -2263,8 +2363,8 @@ function dumpSnapshotImages(runDir, logFd) {
   const messages = Array.isArray(parsed.rawMessages) ? parsed.rawMessages : [];
   if (messages.length === 0)
     return [];
-  const imagesDir = path13.join(runDir, "images");
-  fs11.mkdirSync(imagesDir, { recursive: true });
+  const imagesDir = path14.join(runDir, "images");
+  fs12.mkdirSync(imagesDir, { recursive: true });
   const out = [];
   const extByMime = {
     "image/png": "png",
@@ -2303,10 +2403,10 @@ function dumpSnapshotImages(runDir, logFd) {
           continue;
         const ext = extByMime[mediaType] ?? "bin";
         const fileName = c.subBlockIdx == null ? `${m}-${b}.${ext}` : `${m}-${b}-${c.subBlockIdx}.${ext}`;
-        const fullPath = path13.join(imagesDir, fileName);
+        const fullPath = path14.join(imagesDir, fileName);
         try {
           const buf = Buffer.from(data, "base64");
-          fs11.writeFileSync(fullPath, buf);
+          fs12.writeFileSync(fullPath, buf);
           out.push({
             relPath: `images/${fileName}`,
             msgIdx: m,
@@ -2393,15 +2493,15 @@ function renderEvoContextSections(ctx) {
     lines.push("");
   }
   if (ctx.skills.length > 0) {
-    const globalSkillsDir = path13.join(homedir6(), ".halo", "global", "skills");
+    const globalSkillsDir = path14.join(homedir7(), ".halo", "global", "skills");
     lines.push("=== Skills in this workspace ===");
     for (const s of ctx.skills)
       lines.push(`  ${s.id} [${s.scope}]`);
     lines.push("");
     lines.push("To read a skill's content, file_read its SKILL.md (you have full");
     lines.push("file access \u2014 absolute paths resolve):");
-    lines.push(`  [workspace] \u2192 ${path13.join("<workspace>", ".halo", "skills", "<id>", "SKILL.md")}`);
-    lines.push(`  [global] / [builtin] \u2192 ${path13.join(globalSkillsDir, "<id>", "SKILL.md")}`);
+    lines.push(`  [workspace] \u2192 ${path14.join("<workspace>", ".halo", "skills", "<id>", "SKILL.md")}`);
+    lines.push(`  [global] / [builtin] \u2192 ${path14.join(globalSkillsDir, "<id>", "SKILL.md")}`);
     lines.push("A [global]/[builtin] skill is NOT inside your sandbox \u2014 read it");
     lines.push(`from ${globalSkillsDir} directly; don't glob the sandbox for it.`);
     lines.push("Sibling resource files live next to SKILL.md in that same dir.");
@@ -2424,13 +2524,13 @@ function buildDraftBrief(args) {
   ];
   if (args.userHint)
     lines.push(`Reviewer hint: ${args.userHint}`);
-  lines.push("", "The triggering agent's full message log lives on disk:", `  ${path13.join(args.runDir, "tool-flow.md")}        \u2014 clipped, fast skim`, `  ${path13.join(args.runDir, "source-snapshot.json")}    \u2014 full rawMessages`, "", "Read tool-flow.md first to understand what the user wanted, what the", "agent did, and where it diverged. Each tool_result is clipped to a", "~200-char peek (with the `is_error` flag when the tool failed) \u2014", "enough to see the *shape* of the flow without re-tokenizing large", "grep / shell outputs. Fall back to source-snapshot.json only for", "messages whose full tool result actually matters to your patch.", "", ...renderEvoContextSections(args.evoContext), ...renderImageManifest(args.images), "=== Non-text media note ===", "", "Inline images in source-snapshot.json are base64 \u2014 you can't read them", "directly. The `images/` dump", "(see manifest above) decodes them to disk so you can `view_image` if", "a specific image is load-bearing. Video, audio, and binary documents", "(PDF, etc.) are even more limited: at trigger time the source agent", "worked with them via shell tooling (ffmpeg, pdftotext, etc.), and your", "view is limited to the textual results those tools produced (visible", "inside source-snapshot.json as tool_result text).", "", "When the patch you have in mind requires understanding what's INSIDE", "the media file (a video's visual content, an audio's acoustic", "content, a PDF's layout), the dry-run test scenario can't reliably", "verify it \u2014 skipping the run is the right call. When the patch is", "about the shell-tooling pattern itself (how to call ffmpeg, how to", "grep its output, how to handle credential errors), it can be", "verified at the textual level and the run proceeds normally.", "", "=== Task ===", "", "Decide what change in the prompt surface above would help the next time", "a similar conversation comes up. Three shapes, in order of preference:", "rewrite an existing rule; tighten / reorganize what's there; or, only", "when neither applies, add a new rule.", "", `Sandbox path: ${evoSandboxDir(args.runDir)}`, "", `When you have a change worth making, write ${path13.join(args.runDir, "patch.md")}`, "(frontmatter + body) and one new file at", `${evoSandboxHaloDir(args.runDir)}/<target> with the`, "full new contents. AGENT.md describes the patch.md schema.", "", "When the conversation has no signal worth a patch (rule already covers,", "too short to learn from, agent did fine, depends on media content", `you can't see), write ${path13.join(args.runDir, ".skip.md")} with a`, "one or two sentence reason instead, and skip the rest.", "", ...buildLanguageClause(args.langHint, "all natural-language content (patch.md body, prose drafted into sandbox files, .skip.md body)"));
+  lines.push("", "The triggering agent's full message log lives on disk:", `  ${path14.join(args.runDir, "tool-flow.md")}        \u2014 clipped, fast skim`, `  ${path14.join(args.runDir, "source-snapshot.json")}    \u2014 full rawMessages`, "", "Read tool-flow.md first to understand what the user wanted, what the", "agent did, and where it diverged. Each tool_result is clipped to a", "~200-char peek (with the `is_error` flag when the tool failed) \u2014", "enough to see the *shape* of the flow without re-tokenizing large", "grep / shell outputs. Fall back to source-snapshot.json only for", "messages whose full tool result actually matters to your patch.", "", ...renderEvoContextSections(args.evoContext), ...renderImageManifest(args.images), "=== Non-text media note ===", "", "Inline images in source-snapshot.json are base64 \u2014 you can't read them", "directly. The `images/` dump", "(see manifest above) decodes them to disk so you can `view_image` if", "a specific image is load-bearing. Video, audio, and binary documents", "(PDF, etc.) are even more limited: at trigger time the source agent", "worked with them via shell tooling (ffmpeg, pdftotext, etc.), and your", "view is limited to the textual results those tools produced (visible", "inside source-snapshot.json as tool_result text).", "", "When the patch you have in mind requires understanding what's INSIDE", "the media file (a video's visual content, an audio's acoustic", "content, a PDF's layout), the dry-run test scenario can't reliably", "verify it \u2014 skipping the run is the right call. When the patch is", "about the shell-tooling pattern itself (how to call ffmpeg, how to", "grep its output, how to handle credential errors), it can be", "verified at the textual level and the run proceeds normally.", "", "=== Task ===", "", "Decide what change in the prompt surface above would help the next time", "a similar conversation comes up. Three shapes, in order of preference:", "rewrite an existing rule; tighten / reorganize what's there; or, only", "when neither applies, add a new rule.", "", `Sandbox path: ${evoSandboxDir(args.runDir)}`, "", `When you have a change worth making, write ${path14.join(args.runDir, "patch.md")}`, "(frontmatter + body) and one new file at", `${evoSandboxHaloDir(args.runDir)}/<target> with the`, "full new contents. AGENT.md describes the patch.md schema.", "", "When the conversation has no signal worth a patch (rule already covers,", "too short to learn from, agent did fine, depends on media content", `you can't see), write ${path14.join(args.runDir, ".skip.md")} with a`, "one or two sentence reason instead, and skip the rest.", "", ...buildLanguageClause(args.langHint, "all natural-language content (patch.md body, prose drafted into sandbox files, .skip.md body)"));
   return lines.join("\n");
 }
 function buildFixBrief(args) {
   let failLogText = "";
   try {
-    failLogText = fs11.readFileSync(args.failLogPath, "utf-8");
+    failLogText = fs12.readFileSync(args.failLogPath, "utf-8");
   } catch {
     failLogText = `(failed to read ${args.failLogPath})`;
   }
@@ -2445,7 +2545,7 @@ function buildFixBrief(args) {
     `Fix attempt: ${args.attempt}/${args.maxAttempts}`,
     "",
     `An earlier draft pass produced patch.md + a sandbox at`,
-    `${path13.join(args.runDir, "patch.md")} and`,
+    `${path14.join(args.runDir, "patch.md")} and`,
     `${evoSandboxHaloDir(args.runDir)} respectively.`,
     "The dry-run failed; the wrapper's failure log:",
     "",
@@ -2466,16 +2566,16 @@ function buildFixBrief(args) {
 function buildScoreBrief(args) {
   function readOrEmpty(p, label) {
     try {
-      return fs11.readFileSync(p, "utf-8");
+      return fs12.readFileSync(p, "utf-8");
     } catch (err) {
       writeLog(args.logFd, `[buildScoreBrief] ${label} read failed: ${err instanceof Error ? err.message : String(err)}
 `);
       return `(${label} unavailable)`;
     }
   }
-  const patchMd = readOrEmpty(path13.join(args.runDir, "patch.md"), "patch.md");
-  const dryRun = readOrEmpty(path13.join(args.runDir, "dry-run-output.txt"), "dry-run-output.txt");
-  const meta = readOrEmpty(path13.join(args.runDir, "meta.json"), "meta.json");
+  const patchMd = readOrEmpty(path14.join(args.runDir, "patch.md"), "patch.md");
+  const dryRun = readOrEmpty(path14.join(args.runDir, "dry-run-output.txt"), "dry-run-output.txt");
+  const meta = readOrEmpty(path14.join(args.runDir, "meta.json"), "meta.json");
   return [
     "You are running as the Evolution scorer.",
     "",
@@ -2486,8 +2586,8 @@ function buildScoreBrief(args) {
     "write score.json with the absolute path given below)",
     "",
     `The original conversation lives on disk:`,
-    `  ${path13.join(args.runDir, "tool-flow.md")}    \u2014 clipped, fast skim`,
-    `  ${path13.join(args.runDir, "source-snapshot.json")}  \u2014 full rawMessages, when needed`,
+    `  ${path14.join(args.runDir, "tool-flow.md")}    \u2014 clipped, fast skim`,
+    `  ${path14.join(args.runDir, "source-snapshot.json")}  \u2014 full rawMessages, when needed`,
     "Read tool-flow.md first to find the user turn matching",
     "`testScenario.originalMessage` and the assistant reply that followed",
     "it. Fall back to source-snapshot.json only when the full tool result",
@@ -2537,7 +2637,7 @@ function buildScoreBrief(args) {
     "find the assistant turn that followed it in tool-flow.md (or",
     "source-snapshot.json) \u2014 that's your baseline. Compare baseline to",
     "dry-run-output.txt, rate lint / behavior / scope, write",
-    `${path13.join(args.runDir, "score.json")} with the shape AGENT.md describes.`,
+    `${path14.join(args.runDir, "score.json")} with the shape AGENT.md describes.`,
     "",
     ...buildLanguageClause(args.langHint, 'the score.json "notes" field'),
     'The numeric fields and "confidence" enum stay in their canonical form.'
@@ -2580,14 +2680,14 @@ async function phaseDraft(args) {
   return outcome;
 }
 function judgeDraft(runDir, workspacePath, exitCode) {
-  if (fs11.existsSync(path13.join(runDir, ".skip.md"))) {
+  if (fs12.existsSync(path14.join(runDir, ".skip.md"))) {
     return { outcome: "skipped", why: ".skip.md present \u2014 evo declared skip" };
   }
   if (exitCode !== 0) {
     const timeout = exitCode === 124 ? " (timeout)" : "";
     return { outcome: "failed", why: `drafter exited ${exitCode}${timeout} \u2014 draft interrupted, not trusted` };
   }
-  if (!fs11.existsSync(path13.join(runDir, "patch.md"))) {
+  if (!fs12.existsSync(path14.join(runDir, "patch.md"))) {
     return { outcome: "failed", why: "patch.md missing" };
   }
   const target = readPatchFrontmatter(runDir)?.target;
@@ -2595,16 +2695,16 @@ function judgeDraft(runDir, workspacePath, exitCode) {
     return { outcome: "drafted", why: "patch.md present, no target in frontmatter \u2014 target file not checked" };
   }
   const sandboxDir = evoSandboxDir(runDir);
-  const rel = path13.relative(sandboxDir, path13.resolve(sandboxDir, target));
-  if (!rel.startsWith(".halo" + path13.sep)) {
+  const rel = path14.relative(sandboxDir, path14.resolve(sandboxDir, target));
+  if (!rel.startsWith(".halo" + path14.sep)) {
     return { outcome: "failed", why: `target ${JSON.stringify(target)} does not resolve under sandbox/.halo/` };
   }
-  const sandboxFile = path13.join(sandboxDir, rel);
-  if (!fs11.statSync(sandboxFile, { throwIfNoEntry: false })?.isFile()) {
+  const sandboxFile = path14.join(sandboxDir, rel);
+  if (!fs12.statSync(sandboxFile, { throwIfNoEntry: false })?.isFile()) {
     return { outcome: "failed", why: `target not written to sandbox: ${target}` };
   }
-  const wsFile = path13.join(workspacePath, rel);
-  if (fs11.statSync(wsFile, { throwIfNoEntry: false })?.isFile() && fs11.readFileSync(wsFile).equals(fs11.readFileSync(sandboxFile))) {
+  const wsFile = path14.join(workspacePath, rel);
+  if (fs12.statSync(wsFile, { throwIfNoEntry: false })?.isFile() && fs12.readFileSync(wsFile).equals(fs12.readFileSync(sandboxFile))) {
     return { outcome: "failed", why: `target unchanged from workspace: ${target}` };
   }
   return { outcome: "drafted", why: `patch.md + target ${target} present` };
@@ -2631,15 +2731,15 @@ async function phaseDryRun(args) {
 }
 async function tryDryRun(args, attemptIndex) {
   const sandboxDir = evoSandboxDir(args.runDir);
-  const outputPath = path13.join(args.runDir, "dry-run-output.txt");
-  const failLogPath = path13.join(args.runDir, `dry-run-fail-${attemptIndex}.log`);
+  const outputPath = path14.join(args.runDir, "dry-run-output.txt");
+  const failLogPath = path14.join(args.runDir, `dry-run-fail-${attemptIndex}.log`);
   const cli = resolveHaloCli();
   const fm = readPatchFrontmatter(args.runDir);
   const scenario = extractTestScenario(fm);
   if (!scenario) {
     writeLog(args.logFd, `[tryDryRun:${attemptIndex}] patch.md frontmatter missing testScenario.{agentId, testMessage}
 `);
-    fs11.writeFileSync(failLogPath, "patch.md frontmatter missing testScenario.{agentId, testMessage} \u2014 wrapper cannot run dry-run without it.\n", "utf-8");
+    fs12.writeFileSync(failLogPath, "patch.md frontmatter missing testScenario.{agentId, testMessage} \u2014 wrapper cannot run dry-run without it.\n", "utf-8");
     return { kind: "no-scenario", failLogPath };
   }
   writeLog(args.logFd, `[tryDryRun:${attemptIndex}] agent=${scenario.agentId} testMessage=${JSON.stringify(scenario.testMessage).slice(0, 200)}
@@ -2657,14 +2757,14 @@ async function tryDryRun(args, attemptIndex) {
   const timedOut = result.exitCode === 124;
   const ok = result.exitCode === 0 && result.stdout.trim().length > 0;
   if (ok) {
-    fs11.writeFileSync(outputPath, result.stdout, "utf-8");
+    fs12.writeFileSync(outputPath, result.stdout, "utf-8");
     writeLog(args.logFd, `[tryDryRun:${attemptIndex}] success: wrote ${outputPath} (${result.stdout.length}B)
 `);
     return { kind: "ok" };
   }
   const stdoutTail = result.stdout.length > 4e3 ? "\u2026" + result.stdout.slice(-4e3) : result.stdout;
   const stderrTail = result.stderr.length > 4e3 ? "\u2026" + result.stderr.slice(-4e3) : result.stderr;
-  fs11.writeFileSync(failLogPath, [
+  fs12.writeFileSync(failLogPath, [
     `Wrapper command:  halo cli -a ${scenario.agentId} -n -w ${sandboxDir} <testMessage>`,
     `Test message:     ${scenario.testMessage}`,
     `Exit code:        ${result.exitCode}${timedOut ? " (timeout)" : ""}`,
@@ -2720,7 +2820,7 @@ async function phaseScore(args) {
   const sandboxWs = evoSandboxDir(args.runDir);
   buildEvoSandbox(args.workspacePath, args.runDir, args.logFd);
   const cliArgs = ["cli", "-a", "__score__", "-n", "-w", sandboxWs];
-  fs11.rmSync(path13.join(args.runDir, "score.json"), { force: true });
+  fs12.rmSync(path14.join(args.runDir, "score.json"), { force: true });
   appendSubCliHeader(args.runDir, "Phase C: __score__");
   const result = await spawnProc(
     resolveHaloCli(),
@@ -2741,7 +2841,7 @@ async function phaseScore(args) {
       writeLog(args.logFd, `[phaseScore] stdout (last 1KB): ${result.stdout.slice(-1e3)}
 `);
   }
-  const hasScore = fs11.existsSync(path13.join(args.runDir, "score.json"));
+  const hasScore = fs12.existsSync(path14.join(args.runDir, "score.json"));
   writeLog(args.logFd, `[phaseScore] score.json=${hasScore}
 `);
   return hasScore;
@@ -2755,7 +2855,7 @@ var RUN_INPUT_FILES = /* @__PURE__ */ new Set([
 function resetRunArtifacts(runDir, logFd) {
   let entries;
   try {
-    entries = fs11.readdirSync(runDir);
+    entries = fs12.readdirSync(runDir);
   } catch {
     return;
   }
@@ -2763,7 +2863,7 @@ function resetRunArtifacts(runDir, logFd) {
     if (RUN_INPUT_FILES.has(entry))
       continue;
     try {
-      fs11.rmSync(path13.join(runDir, entry), { recursive: true, force: true });
+      fs12.rmSync(path14.join(runDir, entry), { recursive: true, force: true });
     } catch (err) {
       writeLog(logFd, `[resetRunArtifacts] failed to remove ${entry}: ${err instanceof Error ? err.message : String(err)}
 `);
@@ -2773,7 +2873,7 @@ function resetRunArtifacts(runDir, logFd) {
 async function runMode(row, logFd) {
   const { id } = row;
   const runDir = wsEvoRunDir(row.workspacePath, id);
-  fs11.mkdirSync(runDir, { recursive: true });
+  fs12.mkdirSync(runDir, { recursive: true });
   resetRunArtifacts(runDir, logFd);
   const hb = setInterval(() => heartbeat("run", id, row.attempts, logFd), 6e4);
   const langHint = resolveLangHint();
@@ -2817,14 +2917,14 @@ async function runMode(row, logFd) {
   }
 }
 function markObservation(id, attempts, runDir, outcome, logFd) {
-  const has = outcome !== "failed" && readObservation(path13.join(runDir, outcome === "skipped" ? ".skip.md" : "patch.md")) !== null;
+  const has = outcome !== "failed" && readObservation(path14.join(runDir, outcome === "skipped" ? ".skip.md" : "patch.md")) !== null;
   getEvoDb().update(evolutionRuns).set({ hasObservation: has }).where(ownsRun(id, attempts)).run();
   if (has)
     writeLog(logFd, `[wrapper] draft carries a Larger observation
 `);
 }
 function maybeAutoApply(args) {
-  const level = config.evolution.level;
+  const level = evoLevelFor(args.workspacePath);
   if (evoLevelRank(level) < 2)
     return false;
   let record;
@@ -2835,12 +2935,12 @@ function maybeAutoApply(args) {
       sandboxHalo: evoSandboxHaloDir(args.runDir),
       entries: PUBLISH_WHITELIST,
       level,
-      threshold: config.evolution.autoApplyThreshold,
+      threshold: autoApplyThresholdFor(args.workspacePath),
       sourceAccess: args.sourceAccess,
-      score: readScore(path13.join(args.runDir, "score.json")),
-      observation: readObservation(path13.join(args.runDir, "patch.md"))
+      score: readScore(path14.join(args.runDir, "score.json")),
+      observation: readObservation(path14.join(args.runDir, "patch.md"))
     });
-    fs11.writeFileSync(path13.join(args.runDir, AUTO_APPLY_FILE), JSON.stringify(record, null, 2), "utf-8");
+    fs12.writeFileSync(path14.join(args.runDir, AUTO_APPLY_FILE), JSON.stringify(record, null, 2), "utf-8");
   } catch (err) {
     writeLog(args.logFd, `[autoApply] evaluation failed, leaving the run for review: ${err instanceof Error ? err.message : String(err)}
 `);
@@ -2938,14 +3038,14 @@ function loadApplyRow(id) {
 function buildEvoSandbox(workspacePath, sandboxParent, logFd) {
   const srcWs = wsHaloDir(workspacePath);
   const dstWs = evoSandboxHaloDir(sandboxParent);
-  fs11.mkdirSync(dstWs, { recursive: true });
+  fs12.mkdirSync(dstWs, { recursive: true });
   const whitelist = SANDBOX_WHITELIST;
   for (const entry of whitelist) {
-    const srcEntry = path13.join(srcWs, entry);
-    if (!fs11.existsSync(srcEntry))
+    const srcEntry = path14.join(srcWs, entry);
+    if (!fs12.existsSync(srcEntry))
       continue;
-    const dstEntry = path13.join(dstWs, entry);
-    if (fs11.existsSync(dstEntry))
+    const dstEntry = path14.join(dstWs, entry);
+    if (fs12.existsSync(dstEntry))
       continue;
     copyDereferenced(srcEntry, dstEntry);
   }
@@ -2953,13 +3053,13 @@ function buildEvoSandbox(workspacePath, sandboxParent, logFd) {
 `);
 }
 function copyDereferenced(src, dst) {
-  if (fs11.statSync(src).isDirectory()) {
-    fs11.mkdirSync(dst, { recursive: true });
-    for (const entry of fs11.readdirSync(src))
-      copyDereferenced(path13.join(src, entry), path13.join(dst, entry));
+  if (fs12.statSync(src).isDirectory()) {
+    fs12.mkdirSync(dst, { recursive: true });
+    for (const entry of fs12.readdirSync(src))
+      copyDereferenced(path14.join(src, entry), path14.join(dst, entry));
     return;
   }
-  fs11.copyFileSync(src, dst);
+  fs12.copyFileSync(src, dst);
 }
 function buildApplySandbox(workspacePath, applyDir, logFd) {
   buildEvoSandbox(workspacePath, applyDir, logFd);
@@ -2987,11 +3087,11 @@ function buildApplyMergeBrief(args) {
     "",
     "Hard rules: only edit files under sandbox/.halo/ \u2014 main workspace",
     "and ~/.halo/global/ are off-limits. Do NOT spawn halo cli. Do NOT",
-    `write score.json. Write ${path13.join(args.applyDir, "apply.log")}`,
+    `write score.json. Write ${path14.join(args.applyDir, "apply.log")}`,
     "with a summary of what you did.",
     "",
     "If the merge cannot proceed (irreconcilable patch conflicts, malformed",
-    `input, missing sandbox), write ${path13.join(args.applyDir, "ABORT.md")}`,
+    `input, missing sandbox), write ${path14.join(args.applyDir, "ABORT.md")}`,
     'with the diagnosis \u2014 the wrapper treats its presence as "abort this',
     'apply" and fails the apply instead of publishing. You cannot signal',
     "abort via exit code; ABORT.md is the only abort channel.",
@@ -3012,19 +3112,19 @@ function buildApplyScoreBrief(args) {
     "The apply agent has merged this patch (and possibly others) into",
     "an apply sandbox. The wrapper just ran the patch's testScenario",
     "against the merged sandbox; stdout is in",
-    `${path13.join(args.regressDir, "dry-run-output.txt")}.`,
+    `${path14.join(args.regressDir, "dry-run-output.txt")}.`,
     "An empty dry-run-output.txt means the dry-run against the merged",
     "sandbox failed \u2014 score lint 0 (that is the regression signal the",
     `wrapper acts on); the failure detail is in`,
-    `${path13.join(args.regressDir, "dry-run-fail.log")} when present.`,
+    `${path14.join(args.regressDir, "dry-run-fail.log")} when present.`,
     "",
     "Follow your AGENT.md procedure. Read:",
     `  patch.md      \u2192 ${args.patchMdPath}`,
-    `  tool-flow.md  \u2192 ${path13.join(path13.dirname(args.patchMdPath), "tool-flow.md")} (baseline conversation)`,
+    `  tool-flow.md  \u2192 ${path14.join(path14.dirname(args.patchMdPath), "tool-flow.md")} (baseline conversation)`,
     `  source-snapshot.json \u2192 ${args.snapshotPath}`,
-    `  dry-run output  \u2192 ${path13.join(args.regressDir, "dry-run-output.txt")}`,
+    `  dry-run output  \u2192 ${path14.join(args.regressDir, "dry-run-output.txt")}`,
     "",
-    `Write ${path13.join(args.regressDir, "score.json")} \u2014 NOT the source`,
+    `Write ${path14.join(args.regressDir, "score.json")} \u2014 NOT the source`,
     "run's score.json. Same format as run mode.",
     "Do not modify any other file.",
     ...buildLanguageClause(args.langHint, 'the score.json "notes" field'),
@@ -3036,9 +3136,9 @@ async function phaseApplyMerge(ctx) {
 === Phase A': merge ===
 `);
   buildApplySandbox(ctx.workspacePath, ctx.applyDir, ctx.logFd);
-  const abortPath = path13.join(ctx.applyDir, "ABORT.md");
+  const abortPath = path14.join(ctx.applyDir, "ABORT.md");
   try {
-    fs11.rmSync(abortPath, { force: true });
+    fs12.rmSync(abortPath, { force: true });
   } catch {
   }
   const brief = buildApplyMergeBrief(ctx);
@@ -3057,10 +3157,10 @@ async function phaseApplyMerge(ctx) {
 `);
     return { ok: false, reason: `apply cli exited ${result.exitCode}` };
   }
-  if (fs11.existsSync(abortPath)) {
+  if (fs12.existsSync(abortPath)) {
     let abortText = "";
     try {
-      abortText = fs11.readFileSync(abortPath, "utf-8").trim();
+      abortText = fs12.readFileSync(abortPath, "utf-8").trim();
     } catch {
     }
     writeLog(ctx.logFd, `[phaseApplyMerge] ABORT.md present \u2014 agent aborted the merge:
@@ -3069,7 +3169,7 @@ ${abortText}
     const firstLine = abortText.split("\n")[0]?.slice(0, 300) ?? "";
     return { ok: false, reason: `apply agent aborted: ${firstLine || "see ABORT.md in apply dir"}` };
   }
-  const hasLog = fs11.existsSync(path13.join(ctx.applyDir, "apply.log"));
+  const hasLog = fs12.existsSync(path14.join(ctx.applyDir, "apply.log"));
   writeLog(ctx.logFd, `[phaseApplyMerge] apply.log=${hasLog}
 `);
   if (!hasLog)
@@ -3081,17 +3181,17 @@ async function phaseApplyRegress(ctx) {
 === Phase B': regress ===
 `);
   const sandboxDir = evoSandboxDir(ctx.applyDir);
-  fs11.mkdirSync(evoRegressDir(ctx.applyDir), { recursive: true });
+  fs12.mkdirSync(evoRegressDir(ctx.applyDir), { recursive: true });
   const outcomes = [];
   for (const runId of ctx.sourceRunIds) {
     writeLog(ctx.logFd, `
 --- regress for source run ${runId} ---
 `);
     const regressDir = evoRegressRunDir(ctx.applyDir, runId);
-    fs11.mkdirSync(regressDir, { recursive: true });
+    fs12.mkdirSync(regressDir, { recursive: true });
     const runDir = wsEvoRunDir(ctx.workspacePath, runId);
-    const patchMdPath = path13.join(runDir, "patch.md");
-    const snapshotPath = path13.join(runDir, "source-snapshot.json");
+    const patchMdPath = path14.join(runDir, "patch.md");
+    const snapshotPath = path14.join(runDir, "source-snapshot.json");
     const fm = readPatchFrontmatter(runDir);
     const scenario = extractTestScenario(fm);
     if (!scenario) {
@@ -3118,14 +3218,14 @@ async function phaseApplyRegress(ctx) {
       // stdin, not argv
       DRY_RUN_TIMEOUT_SEC
     );
-    const dryRunOut = path13.join(regressDir, "dry-run-output.txt");
+    const dryRunOut = path14.join(regressDir, "dry-run-output.txt");
     if (dryRun.exitCode === 0 && dryRun.stdout.trim().length > 0) {
-      fs11.writeFileSync(dryRunOut, dryRun.stdout, "utf-8");
+      fs12.writeFileSync(dryRunOut, dryRun.stdout, "utf-8");
     } else {
       const tail = dryRun.stdout.length > 4e3 ? "\u2026" + dryRun.stdout.slice(-4e3) : dryRun.stdout;
       const errTail = dryRun.stderr.length > 4e3 ? "\u2026" + dryRun.stderr.slice(-4e3) : dryRun.stderr;
-      fs11.writeFileSync(dryRunOut, "", "utf-8");
-      fs11.writeFileSync(path13.join(regressDir, "dry-run-fail.log"), [
+      fs12.writeFileSync(dryRunOut, "", "utf-8");
+      fs12.writeFileSync(path14.join(regressDir, "dry-run-fail.log"), [
         `Wrapper command:  halo cli -a ${scenario.agentId} -n -w ${sandboxDir} <testMessage>`,
         `Test message:     ${scenario.testMessage}`,
         `Exit code:        ${dryRun.exitCode}${dryRun.exitCode === 124 ? " (timeout)" : ""}`,
@@ -3146,7 +3246,7 @@ async function phaseApplyRegress(ctx) {
       langHint: ctx.langHint
     });
     const scoreSandboxWs = evoSandboxDir(ctx.applyDir);
-    fs11.rmSync(path13.join(regressDir, "score.json"), { force: true });
+    fs12.rmSync(path14.join(regressDir, "score.json"), { force: true });
     const scoreRun = await spawnProc(
       resolveHaloCli(),
       ["cli", "-a", "__score__", "-n", "-w", scoreSandboxWs],
@@ -3160,10 +3260,10 @@ async function phaseApplyRegress(ctx) {
       writeLog(ctx.logFd, `[phaseApplyRegress:${runId}] scorer cli exited ${scoreRun.exitCode}
 `);
     }
-    const scorePath = path13.join(regressDir, "score.json");
+    const scorePath = path14.join(regressDir, "score.json");
     let scoreJson = null;
     try {
-      scoreJson = JSON.parse(fs11.readFileSync(scorePath, "utf-8"));
+      scoreJson = JSON.parse(fs12.readFileSync(scorePath, "utf-8"));
     } catch {
     }
     if (!scoreJson) {
@@ -3217,13 +3317,13 @@ function autoApplyRecheck(workspacePath, applyDir, changed) {
     globalHalo: globalDir(),
     sandboxHalo: evoSandboxHaloDir(applyDir)
   }, changed));
-  return categoryGate(config.evolution.level, cls);
+  return categoryGate(evoLevelFor(workspacePath), cls);
 }
 async function applyMode(id, logFd) {
   const row = loadApplyRow(id);
   const applyDir = wsEvoApplyDir(row.workspacePath, id);
-  fs11.mkdirSync(applyDir, { recursive: true });
-  fs11.writeFileSync(path13.join(applyDir, "meta.json"), JSON.stringify({
+  fs12.mkdirSync(applyDir, { recursive: true });
+  fs12.writeFileSync(path14.join(applyDir, "meta.json"), JSON.stringify({
     id,
     sourceRunIds: row.sourceRunIds,
     reviewerHint: row.reviewerHint,
@@ -3314,28 +3414,28 @@ async function phaseApplyPreflight(ctx, isResume) {
 `);
   const sandboxHalo = evoSandboxHaloDir(ctx.applyDir);
   const mainHalo = wsHaloDir(ctx.workspacePath);
-  if (!fs11.existsSync(sandboxHalo))
+  if (!fs12.existsSync(sandboxHalo))
     return { ok: false, reason: "sandbox missing \u2014 phase 11 must run first" };
   const whitelistTop = new Set(PUBLISH_WHITELIST);
   const filesToConsider = [];
-  for (const top of fs11.readdirSync(sandboxHalo)) {
+  for (const top of fs12.readdirSync(sandboxHalo)) {
     if (!whitelistTop.has(top))
       continue;
-    walkInto(path13.join(sandboxHalo, top), top, filesToConsider);
+    walkInto(path14.join(sandboxHalo, top), top, filesToConsider);
   }
   const historyDir = wsEvoHistoryDir(ctx.workspacePath, ctx.applyId);
   const changed = [];
   for (const { rel, full } of filesToConsider) {
-    const mainPath = path13.join(mainHalo, rel);
+    const mainPath = path14.join(mainHalo, rel);
     let existsInMain = false;
     try {
-      fs11.accessSync(mainPath);
+      fs12.accessSync(mainPath);
       existsInMain = true;
     } catch {
     }
     if (existsInMain) {
-      const sandboxBuf = fs11.readFileSync(full);
-      const mainBuf = fs11.readFileSync(mainPath);
+      const sandboxBuf = fs12.readFileSync(full);
+      const mainBuf = fs12.readFileSync(mainPath);
       if (sandboxBuf.equals(mainBuf))
         continue;
     }
@@ -3344,20 +3444,20 @@ async function phaseApplyPreflight(ctx, isResume) {
   writeLog(ctx.logFd, `[preflight] ${changed.length} of ${filesToConsider.length} whitelisted files differ from main
 `);
   if (!isResume)
-    fs11.rmSync(historyDir, { recursive: true, force: true });
+    fs12.rmSync(historyDir, { recursive: true, force: true });
   if (changed.length === 0) {
     return { ok: true, result: { changed, historyDir, fileCount: 0 } };
   }
-  fs11.mkdirSync(historyDir, { recursive: true });
-  const manifestPath = path13.join(historyDir, "MANIFEST.json");
+  fs12.mkdirSync(historyDir, { recursive: true });
+  const manifestPath = path14.join(historyDir, "MANIFEST.json");
   if (!isResume) {
     for (const { rel, existsInMain } of changed) {
       if (!existsInMain)
         continue;
-      const mainPath = path13.join(mainHalo, rel);
-      const histPath = path13.join(historyDir, rel);
-      fs11.mkdirSync(path13.dirname(histPath), { recursive: true });
-      fs11.copyFileSync(mainPath, histPath);
+      const mainPath = path14.join(mainHalo, rel);
+      const histPath = path14.join(historyDir, rel);
+      fs12.mkdirSync(path14.dirname(histPath), { recursive: true });
+      fs12.copyFileSync(mainPath, histPath);
     }
     const effective = new Set(publishChanges({ mainHalo, globalHalo: globalDir(), sandboxHalo }, changed).map((c) => c.rel));
     const manifest = {
@@ -3367,13 +3467,13 @@ async function phaseApplyPreflight(ctx, isResume) {
       files: changed.map((c) => ({
         rel: c.rel,
         kind: c.existsInMain ? "overwrite" : "new",
-        before: c.existsInMain ? sha256File(path13.join(mainHalo, c.rel)) : null,
+        before: c.existsInMain ? sha256File(path14.join(mainHalo, c.rel)) : null,
         after: sha256File(c.full),
-        ...effective.has(c.rel.split(path13.sep).join("/")) ? {} : { unchanged: true }
+        ...effective.has(c.rel.split(path14.sep).join("/")) ? {} : { unchanged: true }
       })),
       createdDirs: dirsCreatedBy(mainHalo, changed.filter((c) => !c.existsInMain).map((c) => c.rel))
     };
-    fs11.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2), "utf-8");
+    fs12.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2), "utf-8");
   } else {
     writeLog(ctx.logFd, `[preflight] resume path, skipping history backup (the pre-apply state is already preserved from the fresh claim's preflight)
 `);
@@ -3388,9 +3488,9 @@ async function phaseApplyPublish(ctx, preflight) {
 `);
   const mainHalo = wsHaloDir(ctx.workspacePath);
   for (const { rel, full } of preflight.changed) {
-    const mainPath = path13.join(mainHalo, rel);
-    fs11.mkdirSync(path13.dirname(mainPath), { recursive: true });
-    fs11.copyFileSync(full, mainPath);
+    const mainPath = path14.join(mainHalo, rel);
+    fs12.mkdirSync(path14.dirname(mainPath), { recursive: true });
+    fs12.copyFileSync(full, mainPath);
   }
   writeLog(ctx.logFd, `[publish] copied ${preflight.changed.length} files to ${mainHalo}
 `);
@@ -3398,10 +3498,10 @@ async function phaseApplyPublish(ctx, preflight) {
 function dirsCreatedBy(mainHalo, newFiles) {
   const dirs = /* @__PURE__ */ new Set();
   for (const rel of newFiles) {
-    for (let d = path13.dirname(rel); d !== "." && !fs11.existsSync(path13.join(mainHalo, d)); d = path13.dirname(d))
+    for (let d = path14.dirname(rel); d !== "." && !fs12.existsSync(path14.join(mainHalo, d)); d = path14.dirname(d))
       dirs.add(d);
   }
-  return [...dirs].sort((a, b) => b.split(path13.sep).length - a.split(path13.sep).length || (a < b ? -1 : 1));
+  return [...dirs].sort((a, b) => b.split(path14.sep).length - a.split(path14.sep).length || (a < b ? -1 : 1));
 }
 function ownsApply(id, status, attempts) {
   return and3(eq3(evolutionApplies.id, id), eq3(evolutionApplies.status, status), eq3(evolutionApplies.attempts, attempts));
@@ -3427,15 +3527,15 @@ function releaseSyncing(applyId, attempts, reason, logFd) {
 `);
 }
 function walkInto(absPath, relPath, out) {
-  const stat = fs11.statSync(absPath);
+  const stat = fs12.statSync(absPath);
   if (stat.isFile()) {
     out.push({ rel: relPath, full: absPath });
     return;
   }
   if (!stat.isDirectory())
     return;
-  for (const entry of fs11.readdirSync(absPath)) {
-    walkInto(path13.join(absPath, entry), path13.join(relPath, entry), out);
+  for (const entry of fs12.readdirSync(absPath)) {
+    walkInto(path14.join(absPath, entry), path14.join(relPath, entry), out);
   }
 }
 function finalizeApplied(applyId, attempts, sourceRunIds, logFd) {
@@ -3454,19 +3554,19 @@ function finalizeApplied(applyId, attempts, sourceRunIds, logFd) {
 }
 function writeLog(fd, msg) {
   try {
-    fs11.writeSync(fd, msg);
+    fs12.writeSync(fd, msg);
   } catch {
   }
 }
 function openLogFor(mode, id) {
-  fs11.mkdirSync(evoLogsDir(), { recursive: true });
+  fs12.mkdirSync(evoLogsDir(), { recursive: true });
   const logPath = mode === "run" ? evoWrapperLogFile(id) : evoApplyLogFile(id);
-  const fd = fs11.openSync(logPath, "a");
+  const fd = fs12.openSync(logPath, "a");
   return { fd, logPath };
 }
 async function main() {
   const { mode, id } = parseCli(process.argv.slice(2));
-  setEvoDb(createEvoDb(path13.join(homedir6(), ".halo", "global")));
+  setEvoDb(createEvoDb(path14.join(homedir7(), ".halo", "global")));
   const { fd, logPath } = openLogFor(mode, id);
   writeLog(fd, `
 === ${(/* @__PURE__ */ new Date()).toISOString()} wrapper start mode=${mode} id=${id} pid=${process.pid} ===
@@ -3494,7 +3594,7 @@ async function main() {
     process.exit(1);
   }
 }
-if (process.argv[1] && path13.resolve(process.argv[1]) === fileURLToPath2(import.meta.url)) {
+if (process.argv[1] && path14.resolve(process.argv[1]) === fileURLToPath2(import.meta.url)) {
   main().catch((err) => {
     process.stderr.write(`[wrapper] startup error: ${err instanceof Error ? err.message : String(err)}
 `);