@turmind/halo 1.1.0 → 1.1.2

package/dist/index.js

@@ -1658,10 +1658,19 @@ function isAgentDisabled(agentId, workspaceRoot, disabledSet) {
   return disabledSet.has(`${scope}:${agentId}`);
 }
 async function loadAgentYaml(agentId, workspaceRoot) {
+  const yamlPath = path6.join(agentSourceDir(agentId, workspaceRoot), "agent.yaml");
   try {
-    const content = await fs6.readFile(path6.join(agentSourceDir(agentId, workspaceRoot), "agent.yaml"), "utf-8");
-    return YAML4.parse(content);
-  } catch {
+    const content = await fs6.readFile(yamlPath, "utf-8");
+    const parsed = YAML4.parse(content);
+    if (parsed === null || typeof parsed !== "object") {
+      console.warn(`[AgentLoader] Failed to parse ${yamlPath}: empty or non-object YAML`);
+      return null;
+    }
+    return parsed;
+  } catch (err) {
+    if (err.code === "ENOENT")
+      return null;
+    console.warn(`[AgentLoader] Failed to parse ${yamlPath}: ${err instanceof Error ? err.message : String(err)}`);
     return null;
   }
 }
@@ -2036,6 +2045,7 @@ __export(init_exports, {
   mergeAgentYaml: () => mergeAgentYaml,
   readInstalledOptionalSkills: () => readInstalledOptionalSkills,
   readSeedVersion: () => readSeedVersion,
+  writeFileAtomic: () => writeFileAtomic,
   writeInstalledOptionalSkills: () => writeInstalledOptionalSkills
 });
 import fs7 from "node:fs";
@@ -2057,10 +2067,28 @@ function readSeedVersion(haloHome2) {
     return 0;
   }
 }
+function writeFileAtomic(filePath, content, mode) {
+  fs7.mkdirSync(path8.dirname(filePath), { recursive: true });
+  const tmpPath = `${filePath}.tmp`;
+  fs7.writeFileSync(tmpPath, content, mode === void 0 ? { encoding: "utf-8" } : { encoding: "utf-8", mode });
+  try {
+    fs7.renameSync(tmpPath, filePath);
+  } catch {
+    fs7.writeFileSync(filePath, content, mode === void 0 ? { encoding: "utf-8" } : { encoding: "utf-8", mode });
+    try {
+      fs7.rmSync(tmpPath, { force: true });
+    } catch {
+    }
+  }
+}
 function copyTemplate(srcAbs, dstAbs) {
-  fs7.mkdirSync(path8.dirname(dstAbs), { recursive: true });
   const content = fs7.readFileSync(srcAbs, "utf-8");
-  fs7.writeFileSync(dstAbs, content, "utf-8");
+  try {
+    if (fs7.readFileSync(dstAbs, "utf-8") === content)
+      return;
+  } catch {
+  }
+  writeFileAtomic(dstAbs, content);
 }
 function writeIfMissing(filePath, content, mode) {
   if (fs7.existsSync(filePath))
@@ -2075,7 +2103,8 @@ function mergeAgentYaml(srcAbs, dstAbs) {
     return;
   }
   try {
-    const userDoc = YAML5.parseDocument(fs7.readFileSync(dstAbs, "utf-8"));
+    const userRaw = fs7.readFileSync(dstAbs, "utf-8");
+    const userDoc = YAML5.parseDocument(userRaw);
     const templateDoc = YAML5.parseDocument(fs7.readFileSync(srcAbs, "utf-8"));
     const userModel = userDoc.get("model");
     if (userModel != null) {
@@ -2085,7 +2114,10 @@ function mergeAgentYaml(srcAbs, dstAbs) {
     if (userContext != null) {
       templateDoc.set("context", userContext);
     }
-    fs7.writeFileSync(dstAbs, templateDoc.toString(), "utf-8");
+    const merged = templateDoc.toString();
+    if (merged === userRaw)
+      return;
+    writeFileAtomic(dstAbs, merged);
   } catch (err) {
     console.log(`[Init] mergeAgentYaml fallback (force-copy) for ${dstAbs}: ${err instanceof Error ? err.message : String(err)}`);
     copyTemplate(srcAbs, dstAbs);
@@ -4128,27 +4160,27 @@ var init_workspace = __esm({
       constructor(projectRoot) {
         this.projectRoot = projectRoot;
       }
-      async readFile(path65) {
-        const fullPath = this.validatePath(path65);
+      async readFile(path66) {
+        const fullPath = this.validatePath(path66);
         return readFile(fullPath, "utf-8");
       }
-      async writeFile(path65, content) {
-        const fullPath = this.validatePath(path65);
+      async writeFile(path66, content) {
+        const fullPath = this.validatePath(path66);
         const dir = resolve(fullPath, "..");
         await mkdir(dir, { recursive: true });
         await writeFile(fullPath, content, "utf-8");
       }
-      validatePath(path65) {
-        const fullPath = isAbsolute(path65) ? resolve(path65) : resolve(this.projectRoot, path65);
+      validatePath(path66) {
+        const fullPath = isAbsolute(path66) ? resolve(path66) : resolve(this.projectRoot, path66);
         const root = resolve(this.projectRoot);
         if (fullPath !== root && !fullPath.startsWith(root + sep)) {
-          throw new WorkspaceError(`Path "${path65}" is outside the workspace directory "${this.projectRoot}"`);
+          throw new WorkspaceError(`Path "${path66}" is outside the workspace directory "${this.projectRoot}"`);
         }
         try {
           const real = realpathSync(fullPath);
           const realRoot = realpathSync(root);
           if (real !== realRoot && !real.startsWith(realRoot + sep)) {
-            throw new WorkspaceError(`Path "${path65}" is outside the workspace directory "${this.projectRoot}"`);
+            throw new WorkspaceError(`Path "${path66}" is outside the workspace directory "${this.projectRoot}"`);
           }
         } catch (err) {
           if (err instanceof WorkspaceError)
@@ -4326,12 +4358,12 @@ var init_git_manager = __esm({
             const code = parts[0];
             const status = code[0];
             const isRenameOrCopy = status === "R" || status === "C";
-            const path65 = isRenameOrCopy ? parts[2] : parts[1];
-            if (!path65 || seen.has(path65))
+            const path66 = isRenameOrCopy ? parts[2] : parts[1];
+            if (!path66 || seen.has(path66))
               continue;
-            seen.add(path65);
+            seen.add(path66);
             files.push({
-              path: path65,
+              path: path66,
               status,
               from: isRenameOrCopy ? parts[1] : void 0
             });
@@ -4479,9 +4511,9 @@ var init_git_manager = __esm({
        *  empty for an added file or the root commit) and `modified` is the version
        *  at `commit` (empty for a deletion). The working-tree/staged path above is
        *  left entirely untouched (commit === undefined preserves existing behavior). */
-      async getFileDiff(path65, staged, from, commit) {
+      async getFileDiff(path66, staged, from, commit) {
         if (commit) {
-          const parentPath = from || path65;
+          const parentPath = from || path66;
           let original2 = "";
           try {
             original2 = await this.git.show([`${commit}^:${parentPath}`]);
@@ -4490,13 +4522,13 @@ var init_git_manager = __esm({
           }
           let modified2 = "";
           try {
-            modified2 = await this.git.show([`${commit}:${path65}`]);
+            modified2 = await this.git.show([`${commit}:${path66}`]);
           } catch {
             modified2 = "";
           }
           return { original: original2, modified: modified2 };
         }
-        const headPath = from || path65;
+        const headPath = from || path66;
         let original = "";
         try {
           original = await this.git.show([`HEAD:${headPath}`]);
@@ -4506,13 +4538,13 @@ var init_git_manager = __esm({
         let modified = "";
         if (staged) {
           try {
-            modified = await this.git.show([`:${path65}`]);
+            modified = await this.git.show([`:${path66}`]);
           } catch {
             modified = "";
           }
         } else {
           try {
-            modified = await this.workspace.readFile(path65);
+            modified = await this.workspace.readFile(path66);
           } catch {
             modified = "";
           }
@@ -5062,7 +5094,7 @@ var init_ui_log_builder = __esm({
 import fsSync5 from "node:fs";
 import path19 from "node:path";
 import { eq as eq3 } from "drizzle-orm";
-var SessionUIStore;
+var UI_STATE_IDLE_TTL_MS, UI_STATE_SWEEP_PERIOD_MS, SessionUIStore;
 var init_session_ui_store = __esm({
   "packages/server/dist/agents/session-ui-store.js"() {
     "use strict";
@@ -5071,6 +5103,8 @@ var init_session_ui_store = __esm({
     init_session_store();
     init_session_archive();
     init_ui_log_builder();
+    UI_STATE_IDLE_TTL_MS = 10 * 6e4;
+    UI_STATE_SWEEP_PERIOD_MS = 6e4;
     SessionUIStore = class {
       host;
       db;
@@ -5090,9 +5124,13 @@ var init_session_ui_store = __esm({
       uiStateProjectPaths = /* @__PURE__ */ new Map();
       /** Debounced persist timers — prevents flooding disk with writes during rapid tool loops */
       persistTimers = /* @__PURE__ */ new Map();
+      /** Last activity (event reduced / view built) per uiStates key — the idle
+       *  sweep's eviction clock. Invariant: every uiStates key has an entry. */
+      uiStateTouched = /* @__PURE__ */ new Map();
       constructor(host) {
         this.host = host;
         this.db = host.getDb();
+        setInterval(() => this.sweepIdleUIStates(), UI_STATE_SWEEP_PERIOD_MS).unref();
       }
       // ── Event routing ──────────────────────────────────────────────────
       /** Store global event handler (backward compat — Phase 2 only) */
@@ -5229,6 +5267,7 @@ var init_session_ui_store = __esm({
        * from the on-disk messages so the view is complete.
        */
       ensureUIState(rootId) {
+        this.uiStateTouched.set(rootId, Date.now());
         const existing = this.uiStates.get(rootId);
         if (existing)
           return existing;
@@ -5449,10 +5488,48 @@ var init_session_ui_store = __esm({
       /**
        * Drop the in-memory UIState for a session (e.g. after stopSession / clear).
        * The disk file stays. This is a no-op if not loaded.
+       *
+       * A pending debounced persist is flushed BEFORE eviction: dropping first
+       * would let a later ensureUIState rehydrate from a disk file that's missing
+       * the last batch, and the next persist of that shorter log would overwrite
+       * the orphaned timer's eventual write — messages lost. Must not be called
+       * while the session tree is mid-turn (callers gate on that): flushing then
+       * would snapshot a temp in-flight assistant message that the turn's own
+       * flush would later duplicate.
        */
       dropUIState(sessionId) {
+        const state = this.uiStates.get(sessionId);
+        if (state && this.persistTimers.has(sessionId))
+          this.flushPersist(sessionId, state);
         this.uiStates.delete(sessionId);
         this.uiStateProjectPaths.delete(sessionId);
+        this.uiStateTouched.delete(sessionId);
+      }
+      /**
+       * Evict UIStates whose tree has been idle past the TTL. This is THE eviction
+       * point for the common leak (channel / cron / admin-viewed sessions that just
+       * stop getting traffic) — archive and delete only cover explicit user action.
+       *
+       * Safety gates, in order:
+       *  - tree activity: an in-flight turn/compact anywhere in the tree keeps the
+       *    root's state (it holds the live sub buffers + streaming state);
+       *  - pending debounced persist counts as activity-in-progress? No — drop
+       *    flushes it first (see dropUIState), so a just-debounced write is safe.
+       *
+       * Re-entry cost after eviction: one loadSessionMessages disk read on the next
+       * event/view — turn-start cadence at worst (ensureSession already does a
+       * full-file read there anyway), never per-event.
+       */
+      sweepIdleUIStates() {
+        const cutoff = Date.now() - UI_STATE_IDLE_TTL_MS;
+        for (const [rootId, touched] of this.uiStateTouched) {
+          if (touched > cutoff)
+            continue;
+          if (this.host.hasActiveWorkInTree(rootId))
+            continue;
+          this.dropUIState(rootId);
+          console.debug(`[SessionUIStore] evicted idle UIState ${rootId}`);
+        }
       }
       // ── Operations the manager's session-lifecycle methods delegate here ──
       // These exist so the manager never reaches into the maps above directly.
@@ -5493,6 +5570,7 @@ var init_session_ui_store = __esm({
       purge(id) {
         this.uiStates.delete(id);
         this.uiStateProjectPaths.delete(id);
+        this.uiStateTouched.delete(id);
         const timer = this.persistTimers.get(id);
         if (timer) {
           clearTimeout(timer);
@@ -9075,13 +9153,20 @@ var init_session_agent_builder = __esm({
         });
         return { agent, yamlConfig, contextConfig, modelId, systemPrompt, thinkingEffort, meta, draftReset };
       }
-      /** Throw with a clear message if agent.yaml is missing the model triple. */
+      /** Throw with a clear message if agent.yaml is missing the model triple.
+       *  Includes the resolved yaml path and distinguishes "file unreadable"
+       *  (yamlConfig null — read/parse failed, see loadAgentYaml) from "config
+       *  genuinely incomplete", so the error is self-diagnosing. */
       validateAgentModelConfig(agentId, yamlConfig) {
-        const modelId = yamlConfig?.model?.id;
-        const endpoint = yamlConfig?.model?.endpoint;
-        const providerId = yamlConfig?.model?.provider;
+        const yamlPath = path23.join(agentSourceDir(agentId, this.host.workspaceRoot), "agent.yaml");
+        if (yamlConfig === null) {
+          throw new Error(`[SessionManager] Agent "${agentId}": agent.yaml missing or unreadable at ${yamlPath}.`);
+        }
+        const modelId = yamlConfig.model?.id;
+        const endpoint = yamlConfig.model?.endpoint;
+        const providerId = yamlConfig.model?.provider;
         if (!modelId || !endpoint || !providerId) {
-          throw new Error(`[SessionManager] Agent "${agentId}" is missing model config. agent.yaml must specify model.provider, model.id and model.endpoint.`);
+          throw new Error(`[SessionManager] Agent "${agentId}" is missing model config in ${yamlPath}. agent.yaml must specify model.provider, model.id and model.endpoint.`);
         }
         return { modelId, endpoint, providerId };
       }
@@ -11416,6 +11501,19 @@ ${result.summary}`, agentName: "user", report: true, taskId });
         }
         return false;
       }
+      /** Any in-flight turn or compact anywhere in a root's session tree (root or
+       *  `root>…` descendants). SessionUIStoreHost member — the UI store's idle
+       *  sweep gates eviction on this, because a root's UIState carries its running
+       *  subs' live buffers even while the root itself is between turns. */
+      hasActiveWorkInTree(rootId) {
+        for (const [id, session] of this.sessions) {
+          if (id !== rootId && !id.startsWith(`${rootId}>`))
+            continue;
+          if (session.promise !== null || session.isCompacting)
+            return true;
+        }
+        return false;
+      }
       /** Get context config for a session */
       async getContextConfig(sessionId) {
         const session = this.sessions.get(sessionId);
@@ -13985,6 +14083,41 @@ var init_setup_prompts = __esm({
   }
 });
 
+// packages/cli/src/upgrade-verify.ts
+var upgrade_verify_exports = {};
+__export(upgrade_verify_exports, {
+  ALLOW_SCRIPTS: () => ALLOW_SCRIPTS,
+  NATIVE_MODULE_SMOKES: () => NATIVE_MODULE_SMOKES,
+  verifyNativeModules: () => verifyNativeModules
+});
+import path33 from "node:path";
+import fs27 from "node:fs";
+import { spawnSync } from "node:child_process";
+function verifyNativeModules(pkgRoot) {
+  const broken = [];
+  for (const { name, smoke } of NATIVE_MODULE_SMOKES) {
+    const modDir = path33.join(pkgRoot, "node_modules", name);
+    if (!fs27.existsSync(modDir)) {
+      broken.push(name);
+      continue;
+    }
+    const probe = spawnSync(process.execPath, ["-e", smoke, modDir], { encoding: "utf-8" });
+    if (probe.error || probe.status !== 0) broken.push(name);
+  }
+  return broken;
+}
+var NATIVE_MODULE_SMOKES, ALLOW_SCRIPTS;
+var init_upgrade_verify = __esm({
+  "packages/cli/src/upgrade-verify.ts"() {
+    "use strict";
+    NATIVE_MODULE_SMOKES = [
+      { name: "better-sqlite3", smoke: "new (require(process.argv[1]))(':memory:')" },
+      { name: "node-pty", smoke: "require(process.argv[1])" }
+    ];
+    ALLOW_SCRIPTS = "better-sqlite3";
+  }
+});
+
 // packages/cli/src/render-md.ts
 import { marked } from "marked";
 import { markedTerminal } from "marked-terminal";
@@ -14001,8 +14134,8 @@ var init_render_md = __esm({
 });
 
 // packages/cli/src/resolve-refs.ts
-import fs27 from "node:fs";
-import path33 from "node:path";
+import fs28 from "node:fs";
+import path34 from "node:path";
 function resolveRefs(input, workspace) {
   const images = [];
   const attachments = [];
@@ -14015,11 +14148,11 @@ function resolveRefs(input, workspace) {
     lastIdx = match.index + match[0].length;
     const kind = match[1];
     const rawPath = match[2] ?? match[3];
-    const resolved = path33.isAbsolute(rawPath) ? rawPath : path33.resolve(workspace, rawPath);
-    const ext = path33.extname(resolved).toLowerCase();
+    const resolved = path34.isAbsolute(rawPath) ? rawPath : path34.resolve(workspace, rawPath);
+    const ext = path34.extname(resolved).toLowerCase();
     let stat = null;
     try {
-      stat = fs27.statSync(resolved);
+      stat = fs28.statSync(resolved);
     } catch {
     }
     if (!stat) {
@@ -14037,18 +14170,18 @@ function resolveRefs(input, workspace) {
           warnings.push(`${rawPath}: image too large (${(stat.size / 1024 / 1024).toFixed(1)}MB, max ${MAX_IMAGE_BYTES / 1024 / 1024}MB), skipped`);
           continue;
         }
-        const data = fs27.readFileSync(resolved).toString("base64");
+        const data = fs28.readFileSync(resolved).toString("base64");
         images.push({ data, mimeType: imageMimeFromExt(ext) ?? "application/octet-stream" });
       } else {
-        const relPath = path33.relative(workspace, resolved);
+        const relPath = path34.relative(workspace, resolved);
         if (stat.size > MAX_FILE_BYTES) {
           const buf = Buffer.alloc(MAX_FILE_BYTES);
-          const fd = fs27.openSync(resolved, "r");
+          const fd = fs28.openSync(resolved, "r");
           let n = 0;
           try {
-            n = fs27.readSync(fd, buf, 0, MAX_FILE_BYTES, 0);
+            n = fs28.readSync(fd, buf, 0, MAX_FILE_BYTES, 0);
           } finally {
-            fs27.closeSync(fd);
+            fs28.closeSync(fd);
           }
           const content = buf.subarray(0, n).toString("utf-8").replace(/\uFFFD+$/, "");
           parts.push(`
@@ -14059,7 +14192,7 @@ ${content}
 `);
           warnings.push(`${rawPath}: truncated (${(stat.size / 1024).toFixed(0)}KB, max ${MAX_FILE_BYTES / 1024}KB)`);
         } else {
-          const content = fs27.readFileSync(resolved, "utf-8");
+          const content = fs28.readFileSync(resolved, "utf-8");
           parts.push(`
 <file path="${relPath}">
 ${content}
@@ -14331,12 +14464,12 @@ var init_streaming = __esm({
 });
 
 // packages/cli/src/tui/history.ts
-import fs28 from "node:fs";
-import path34 from "node:path";
+import fs29 from "node:fs";
+import path35 from "node:path";
 import os2 from "node:os";
 function loadHistory() {
   try {
-    const arr = JSON.parse(fs28.readFileSync(HISTORY_FILE, "utf8"));
+    const arr = JSON.parse(fs29.readFileSync(HISTORY_FILE, "utf8"));
     if (Array.isArray(arr)) {
       return arr.filter((x) => typeof x === "string").slice(-MAX_ENTRIES);
     }
@@ -14349,8 +14482,8 @@ function appendHistory(entry) {
     const arr = loadHistory();
     if (arr[arr.length - 1] === entry) return;
     arr.push(entry);
-    fs28.mkdirSync(path34.dirname(HISTORY_FILE), { recursive: true });
-    fs28.writeFileSync(HISTORY_FILE, JSON.stringify(arr.slice(-MAX_ENTRIES)));
+    fs29.mkdirSync(path35.dirname(HISTORY_FILE), { recursive: true });
+    fs29.writeFileSync(HISTORY_FILE, JSON.stringify(arr.slice(-MAX_ENTRIES)));
   } catch {
   }
 }
@@ -14358,7 +14491,7 @@ var HISTORY_FILE, MAX_ENTRIES;
 var init_history = __esm({
   "packages/cli/src/tui/history.ts"() {
     "use strict";
-    HISTORY_FILE = path34.join(os2.homedir(), ".halo", "global", "tui-history.json");
+    HISTORY_FILE = path35.join(os2.homedir(), ".halo", "global", "tui-history.json");
     MAX_ENTRIES = 100;
   }
 });
@@ -14469,8 +14602,8 @@ var init_path_suggest = __esm({
 });
 
 // packages/cli/src/tui/path-suggest-engine.ts
-import fs29 from "node:fs";
-import path35 from "node:path";
+import fs30 from "node:fs";
+import path36 from "node:path";
 function detectActiveRef(value) {
   const reExplicit = /@(file|image|scope)\s+(?:"([^"]*)|(\S*))$/;
   const mExplicit = value.match(reExplicit);
@@ -14499,20 +14632,20 @@ function resolveDirAndPrefix(partial, workspace) {
   if (partial === "") {
     return { absDir: workspace, displayDir: ".", prefix: "" };
   }
-  const absBase = path35.isAbsolute(partial) ? partial : path35.join(workspace, partial);
+  const absBase = path36.isAbsolute(partial) ? partial : path36.join(workspace, partial);
   if (partial.endsWith("/")) {
     return { absDir: absBase, displayDir: partial.replace(/\/$/, "") || "/", prefix: "" };
   }
-  const dirAbs = path35.dirname(absBase);
-  const prefix = path35.basename(absBase);
-  const dirRel = path35.dirname(partial);
+  const dirAbs = path36.dirname(absBase);
+  const prefix = path36.basename(absBase);
+  const dirRel = path36.dirname(partial);
   return { absDir: dirAbs, displayDir: dirRel === "." ? "." : dirRel, prefix };
 }
 function scanCandidates(partial, workspace, kind) {
   const { absDir, displayDir, prefix } = resolveDirAndPrefix(partial, workspace);
   let entries;
   try {
-    entries = fs29.readdirSync(absDir, { withFileTypes: true });
+    entries = fs30.readdirSync(absDir, { withFileTypes: true });
   } catch {
     return { items: [], cwdLabel: displayDir };
   }
@@ -14521,17 +14654,17 @@ function scanCandidates(partial, workspace, kind) {
     if (e.name.startsWith(".")) continue;
     if (prefix && !e.name.toLowerCase().startsWith(prefix.toLowerCase())) continue;
     const isDir = e.isDirectory();
-    const ext = path35.extname(e.name).toLowerCase();
+    const ext = path36.extname(e.name).toLowerCase();
     const isImage = IMAGE_EXTS.has(ext);
     if (kind === "image" && !isDir && !isImage) continue;
     if (kind === "scope" && !isDir) continue;
     let insertPath;
-    if (path35.isAbsolute(partial)) {
-      insertPath = path35.join(absDir, e.name);
+    if (path36.isAbsolute(partial)) {
+      insertPath = path36.join(absDir, e.name);
     } else if (partial.endsWith("/") || partial === "") {
       insertPath = partial + e.name;
     } else {
-      const dirRel = path35.dirname(partial);
+      const dirRel = path36.dirname(partial);
       insertPath = (dirRel === "." ? "" : dirRel + "/") + e.name;
     }
     items.push({ name: e.name, insertPath, isDir, isImage });
@@ -14550,8 +14683,8 @@ function applyPathPick(value, ref, pick) {
   const before = value.slice(0, markerStart);
   const kind = ref.kind === "scope" ? "scope" : ref.kind === "image" ? "image" : pick.isImage ? "image" : "file";
   const needsQuote = pick.insertPath.includes(" ");
-  const path65 = pick.isDir ? needsQuote ? `"${pick.insertPath}/` : `${pick.insertPath}/` : needsQuote ? `"${pick.insertPath}" ` : `${pick.insertPath} `;
-  return `${before}@${kind} ${path65}`;
+  const path66 = pick.isDir ? needsQuote ? `"${pick.insertPath}/` : `${pick.insertPath}/` : needsQuote ? `"${pick.insertPath}" ` : `${pick.insertPath} `;
+  return `${before}@${kind} ${path66}`;
 }
 var init_path_suggest_engine = __esm({
   "packages/cli/src/tui/path-suggest-engine.ts"() {
@@ -16024,15 +16157,15 @@ var init_cli = __esm({
 });
 
 // packages/server/dist/channels/shared/media.js
-import path36 from "node:path";
+import path37 from "node:path";
 import os3 from "node:os";
 function tempDir() {
-  return path36.resolve(os3.tmpdir());
+  return path37.resolve(os3.tmpdir());
 }
 function isInTempDir(filePath) {
-  const resolved = path36.resolve(filePath);
+  const resolved = path37.resolve(filePath);
   const tmp = tempDir();
-  return resolved === tmp || resolved.startsWith(tmp + path36.sep);
+  return resolved === tmp || resolved.startsWith(tmp + path37.sep);
 }
 function extractMediaPaths(text5) {
   const mediaPaths = [];
@@ -16048,12 +16181,12 @@ function extractMediaMessage(text5) {
   return { text: stripped.replace(/\n{3,}/g, "\n\n").trim(), mediaPaths };
 }
 function isMediaPathAllowed(filePath, workspacePath) {
-  const resolved = path36.resolve(filePath);
-  const ws = path36.resolve(workspacePath);
-  return resolved === ws || resolved.startsWith(ws + path36.sep) || isInTempDir(resolved);
+  const resolved = path37.resolve(filePath);
+  const ws = path37.resolve(workspacePath);
+  return resolved === ws || resolved.startsWith(ws + path37.sep) || isInTempDir(resolved);
 }
 function classifyMedia(filePath) {
-  const ext = path36.extname(filePath).toLowerCase();
+  const ext = path37.extname(filePath).toLowerCase();
   if (IMAGE_EXTS.has(ext))
     return "image";
   if (VIDEO_EXTS.has(ext))
@@ -16074,13 +16207,13 @@ var init_media = __esm({
 });
 
 // packages/server/dist/routes/workspace-path.js
-import fs30 from "node:fs/promises";
+import fs31 from "node:fs/promises";
 import { existsSync as existsSync2, realpathSync as realpathSync3 } from "node:fs";
-import path37 from "node:path";
+import path38 from "node:path";
 async function resolveProjectPath(projectId) {
-  if (path37.isAbsolute(projectId)) {
+  if (path38.isAbsolute(projectId)) {
     try {
-      await fs30.access(projectId);
+      await fs31.access(projectId);
       return projectId;
     } catch {
       return null;
@@ -16089,13 +16222,13 @@ async function resolveProjectPath(projectId) {
   return null;
 }
 function realpathBounded2(filePath) {
-  let prefix = path37.resolve(filePath);
+  let prefix = path38.resolve(filePath);
   const tail = [];
   while (!existsSync2(prefix)) {
-    const parent = path37.dirname(prefix);
+    const parent = path38.dirname(prefix);
     if (parent === prefix)
       break;
-    tail.unshift(path37.basename(prefix));
+    tail.unshift(path38.basename(prefix));
     prefix = parent;
   }
   let realPrefix;
@@ -16104,12 +16237,12 @@ function realpathBounded2(filePath) {
   } catch {
     realPrefix = prefix;
   }
-  return tail.length > 0 ? path37.join(realPrefix, ...tail) : realPrefix;
+  return tail.length > 0 ? path38.join(realPrefix, ...tail) : realPrefix;
 }
 function validatePath(filePath, projectPath) {
-  const resolved = realpathBounded2(path37.resolve(projectPath, filePath));
+  const resolved = realpathBounded2(path38.resolve(projectPath, filePath));
   const proj = realpathBounded2(projectPath);
-  return resolved === proj || resolved.startsWith(proj + path37.sep);
+  return resolved === proj || resolved.startsWith(proj + path38.sep);
 }
 function isSafeIdSegment(id) {
   if (id === "." || id === "..")
@@ -16124,10 +16257,10 @@ var init_workspace_path = __esm({
 
 // packages/server/dist/routes/files.js
 import { Hono } from "hono";
-import fs31 from "node:fs/promises";
+import fs32 from "node:fs/promises";
 import { createReadStream } from "node:fs";
 import { Readable } from "node:stream";
-import path38 from "node:path";
+import path39 from "node:path";
 import { homedir as homedir17 } from "node:os";
 function createFileRoutes() {
   const app2 = new Hono();
@@ -16144,7 +16277,7 @@ function createFileRoutes() {
   }
   async function dirHasChildren(dirPath) {
     try {
-      const entries = await fs31.readdir(dirPath, { withFileTypes: true });
+      const entries = await fs32.readdir(dirPath, { withFileTypes: true });
       for (const entry of entries) {
         if (!isSkippedName(entry.name))
           return true;
@@ -16157,7 +16290,7 @@ function createFileRoutes() {
   async function listDir(dirPath, basePath) {
     let entries;
     try {
-      entries = await fs31.readdir(dirPath, { withFileTypes: true });
+      entries = await fs32.readdir(dirPath, { withFileTypes: true });
     } catch {
       return [];
     }
@@ -16172,8 +16305,8 @@ function createFileRoutes() {
     for (const entry of sorted) {
       if (isSkippedName(entry.name))
         continue;
-      const fullPath = path38.join(dirPath, entry.name);
-      const relativePath = path38.relative(basePath, fullPath).split(path38.sep).join("/");
+      const fullPath = path39.join(dirPath, entry.name);
+      const relativePath = path39.relative(basePath, fullPath).split(path39.sep).join("/");
       if (entry.isDirectory()) {
         nodes.push({
           name: entry.name,
@@ -16205,9 +16338,9 @@ function createFileRoutes() {
       if (relPath && !validatePath(relPath, projectPath)) {
         return c.json({ error: "Path traversal not allowed" }, 403);
       }
-      const targetPath = relPath ? path38.resolve(projectPath, relPath) : projectPath;
+      const targetPath = relPath ? path39.resolve(projectPath, relPath) : projectPath;
       try {
-        const stat = await fs31.stat(targetPath);
+        const stat = await fs32.stat(targetPath);
         if (!stat.isDirectory()) {
           return c.json({ error: "Path is not a directory" }, 400);
         }
@@ -16217,7 +16350,7 @@ function createFileRoutes() {
       const tree = await listDir(targetPath, projectPath);
       return c.json({
         projectId,
-        root: path38.basename(projectPath),
+        root: path39.basename(projectPath),
         path: relPath,
         tree
       });
@@ -16250,7 +16383,7 @@ function createFileRoutes() {
           return;
         let entries;
         try {
-          entries = await fs31.readdir(dirPath, { withFileTypes: true });
+          entries = await fs32.readdir(dirPath, { withFileTypes: true });
         } catch {
           return;
         }
@@ -16260,11 +16393,11 @@ function createFileRoutes() {
           if (isSkippedName(entry.name))
             continue;
           scanned++;
-          const fullPath = path38.join(dirPath, entry.name);
+          const fullPath = path39.join(dirPath, entry.name);
           if (entry.isDirectory()) {
             if (dirsOnly) {
               const name = entry.name.toLowerCase();
-              const rel = path38.relative(projectRoot, fullPath);
+              const rel = path39.relative(projectRoot, fullPath);
               if (!q || name.includes(q) || rel.toLowerCase().includes(q)) {
                 matches.push({ name: entry.name, path: rel });
               }
@@ -16272,7 +16405,7 @@ function createFileRoutes() {
             await walk(fullPath);
           } else if (entry.isFile() && !dirsOnly) {
             const name = entry.name.toLowerCase();
-            const rel = path38.relative(projectRoot, fullPath);
+            const rel = path39.relative(projectRoot, fullPath);
             if (!q || name.includes(q) || rel.toLowerCase().includes(q)) {
               matches.push({ name: entry.name, path: rel });
             }
@@ -16316,15 +16449,15 @@ function createFileRoutes() {
       }
       const uploaded = [];
       for (const file of files) {
-        const relPath = targetDir ? path38.join(targetDir, file.name) : file.name;
+        const relPath = targetDir ? path39.join(targetDir, file.name) : file.name;
         if (!validatePath(relPath, projectPath)) {
           continue;
         }
-        const destPath = path38.resolve(projectPath, relPath);
-        const destDir = path38.dirname(destPath);
-        await fs31.mkdir(destDir, { recursive: true });
+        const destPath = path39.resolve(projectPath, relPath);
+        const destDir = path39.dirname(destPath);
+        await fs32.mkdir(destDir, { recursive: true });
         const buffer = Buffer.from(await file.arrayBuffer());
-        await fs31.writeFile(destPath, buffer);
+        await fs32.writeFile(destPath, buffer);
         uploaded.push({
           name: file.name,
           path: relPath,
@@ -16352,9 +16485,9 @@ function createFileRoutes() {
       if (!validatePath(filePath, projectPath)) {
         return c.json({ error: "Path traversal not allowed" }, 403);
       }
-      const absolutePath = path38.resolve(projectPath, filePath);
-      await fs31.writeFile(absolutePath, content, "utf-8");
-      const stat = await fs31.stat(absolutePath);
+      const absolutePath = path39.resolve(projectPath, filePath);
+      await fs32.writeFile(absolutePath, content, "utf-8");
+      const stat = await fs32.stat(absolutePath);
       return c.json({ ok: true, path: filePath, modifiedAt: stat.mtimeMs });
     } catch (err) {
       const errorMessage = err instanceof Error ? err.message : String(err);
@@ -16376,14 +16509,14 @@ function createFileRoutes() {
       if (!validatePath(filePath, projectPath)) {
         return c.json({ error: "Path traversal not allowed" }, 403);
       }
-      const absolutePath = path38.resolve(projectPath, filePath);
-      await fs31.mkdir(path38.dirname(absolutePath), { recursive: true });
+      const absolutePath = path39.resolve(projectPath, filePath);
+      await fs32.mkdir(path39.dirname(absolutePath), { recursive: true });
       try {
-        await fs31.access(absolutePath);
+        await fs32.access(absolutePath);
         return c.json({ error: "File already exists" }, 409);
       } catch {
       }
-      await fs31.writeFile(absolutePath, "", "utf-8");
+      await fs32.writeFile(absolutePath, "", "utf-8");
       return c.json({ ok: true, path: filePath });
     } catch (err) {
       const errorMessage = err instanceof Error ? err.message : String(err);
@@ -16405,8 +16538,8 @@ function createFileRoutes() {
       if (!validatePath(dirPath, projectPath)) {
         return c.json({ error: "Path traversal not allowed" }, 403);
       }
-      const absolutePath = path38.resolve(projectPath, dirPath);
-      await fs31.mkdir(absolutePath, { recursive: true });
+      const absolutePath = path39.resolve(projectPath, dirPath);
+      await fs32.mkdir(absolutePath, { recursive: true });
       return c.json({ ok: true, path: dirPath });
     } catch (err) {
       const errorMessage = err instanceof Error ? err.message : String(err);
@@ -16428,10 +16561,10 @@ function createFileRoutes() {
       if (!validatePath(oldPath, projectPath) || !validatePath(newPath, projectPath)) {
         return c.json({ error: "Path traversal not allowed" }, 403);
       }
-      const absOld = path38.resolve(projectPath, oldPath);
-      const absNew = path38.resolve(projectPath, newPath);
-      await fs31.mkdir(path38.dirname(absNew), { recursive: true });
-      await fs31.rename(absOld, absNew);
+      const absOld = path39.resolve(projectPath, oldPath);
+      const absNew = path39.resolve(projectPath, newPath);
+      await fs32.mkdir(path39.dirname(absNew), { recursive: true });
+      await fs32.rename(absOld, absNew);
       return c.json({ ok: true, oldPath, newPath });
     } catch (err) {
       const errorMessage = err instanceof Error ? err.message : String(err);
@@ -16453,11 +16586,11 @@ function createFileRoutes() {
       if (!validatePath(filePath, projectPath)) {
         return c.json({ error: "Path traversal not allowed" }, 403);
       }
-      const absolutePath = path38.resolve(projectPath, filePath);
-      if (absolutePath === path38.resolve(projectPath)) {
+      const absolutePath = path39.resolve(projectPath, filePath);
+      if (absolutePath === path39.resolve(projectPath)) {
         return c.json({ error: "Cannot delete project root" }, 403);
       }
-      await fs31.rm(absolutePath, { recursive: true, force: true });
+      await fs32.rm(absolutePath, { recursive: true, force: true });
       return c.json({ ok: true, path: filePath });
     } catch (err) {
       const errorMessage = err instanceof Error ? err.message : String(err);
@@ -16491,16 +16624,16 @@ function createFileRoutes() {
       if (!projectPath) {
         return c.json({ error: "Project not found" }, 404);
       }
-      const isTmp = path38.isAbsolute(filePath) && isInTempDir(filePath);
+      const isTmp = path39.isAbsolute(filePath) && isInTempDir(filePath);
       if (!isTmp && !validatePath(filePath, projectPath)) {
         return c.json({ error: "Path traversal not allowed" }, 403);
       }
-      const absolutePath = isTmp ? path38.resolve(filePath) : path38.resolve(projectPath, filePath);
-      const stat = await fs31.stat(absolutePath);
+      const absolutePath = isTmp ? path39.resolve(filePath) : path39.resolve(projectPath, filePath);
+      const stat = await fs32.stat(absolutePath);
       if (stat.isDirectory()) {
         return c.json({ error: "Cannot download a directory" }, 400);
       }
-      const fileName = path38.basename(filePath);
+      const fileName = path39.basename(filePath);
       const ext = fileName.split(".").pop()?.toLowerCase() ?? "";
       const mime = inline ? imageMimeFromExt(ext) ?? MIME_MAP[ext] ?? "application/octet-stream" : "application/octet-stream";
       const disposition = inline ? `inline; filename="${encodeURIComponent(fileName)}"` : `attachment; filename="${encodeURIComponent(fileName)}"`;
@@ -16559,8 +16692,8 @@ function createFileRoutes() {
         return c.json({ error: "Project not found" }, 404);
       if (!validatePath(filePath, projectPath))
         return c.json({ error: "Path traversal not allowed" }, 403);
-      const absolutePath = path38.resolve(projectPath, filePath);
-      const stat = await fs31.stat(absolutePath);
+      const absolutePath = path39.resolve(projectPath, filePath);
+      const stat = await fs32.stat(absolutePath);
       return c.json({ path: filePath, modifiedAt: stat.mtimeMs, createdAt: stat.birthtimeMs, size: stat.size });
     } catch (err) {
       if (err.code === "ENOENT")
@@ -16582,9 +16715,9 @@ function createFileRoutes() {
       if (!validatePath(filePath, projectPath)) {
         return c.json({ error: "Path traversal not allowed" }, 403);
       }
-      const absolutePath = path38.resolve(projectPath, filePath);
+      const absolutePath = path39.resolve(projectPath, filePath);
       try {
-        const stat = await fs31.stat(absolutePath);
+        const stat = await fs32.stat(absolutePath);
         if (stat.isDirectory()) {
           return c.json({ error: "Path is a directory, use /files/tree instead" }, 400);
         }
@@ -16592,7 +16725,7 @@ function createFileRoutes() {
         if (stat.size > maxSize) {
           return c.json({ error: "File too large (max 10MB)" }, 413);
         }
-        const content = await fs31.readFile(absolutePath, "utf-8");
+        const content = await fs32.readFile(absolutePath, "utf-8");
         return c.json({
           path: filePath,
           content,
@@ -16619,16 +16752,16 @@ function createFileRoutes() {
     const body = await c.req.json();
     if (!body.path)
       return c.json({ error: "path required" }, 400);
-    const resolved = path38.resolve(body.path);
+    const resolved = path39.resolve(body.path);
     let stat;
     try {
-      stat = await fs31.stat(resolved);
+      stat = await fs32.stat(resolved);
     } catch {
       return c.json({ error: "path not found" }, 404);
     }
     if (!stat.isDirectory())
       return c.json({ error: "not a directory" }, 400);
-    if (resolved === path38.parse(resolved).root) {
+    if (resolved === path39.parse(resolved).root) {
       return c.json({ error: "filesystem root cannot be a workspace" }, 400);
     }
     const { ensureWorkspaceHalo: ensureWorkspaceHalo2 } = await Promise.resolve().then(() => (init_init(), init_exports));
@@ -16637,10 +16770,10 @@ function createFileRoutes() {
   });
   app2.get("/fs/exists", async (c) => {
     const target = c.req.query("path");
-    if (!target || !path38.isAbsolute(target))
+    if (!target || !path39.isAbsolute(target))
       return c.json({ exists: false, reason: "absolute path required" });
     try {
-      const stat = await fs31.stat(target);
+      const stat = await fs32.stat(target);
       return c.json({ exists: true, isDirectory: stat.isDirectory() });
     } catch {
       return c.json({ exists: false });
@@ -16648,13 +16781,13 @@ function createFileRoutes() {
   });
   app2.get("/fs/browse", async (c) => {
     const target = c.req.query("path") ?? homedir17();
-    if (!path38.isAbsolute(target))
+    if (!path39.isAbsolute(target))
       return c.json({ error: "absolute path required" }, 400);
     try {
-      const resolved = path38.resolve(target);
-      const entries = await fs31.readdir(resolved, { withFileTypes: true });
-      const dirs = entries.filter((e) => e.isDirectory() && !e.name.startsWith(".")).map((e) => ({ name: e.name, path: path38.join(resolved, e.name) })).sort((a, b) => a.name.localeCompare(b.name));
-      return c.json({ path: resolved, parent: path38.dirname(resolved), entries: dirs });
+      const resolved = path39.resolve(target);
+      const entries = await fs32.readdir(resolved, { withFileTypes: true });
+      const dirs = entries.filter((e) => e.isDirectory() && !e.name.startsWith(".")).map((e) => ({ name: e.name, path: path39.join(resolved, e.name) })).sort((a, b) => a.name.localeCompare(b.name));
+      return c.json({ path: resolved, parent: path39.dirname(resolved), entries: dirs });
     } catch (err) {
       return c.json({ error: err.message }, 404);
     }
@@ -16672,9 +16805,9 @@ var init_files = __esm({
 
 // packages/server/dist/routes/data-preview.js
 import { Hono as Hono2 } from "hono";
-import fs32 from "node:fs/promises";
+import fs33 from "node:fs/promises";
 import { createReadStream as createReadStream2 } from "node:fs";
-import path39 from "node:path";
+import path40 from "node:path";
 import Database3 from "better-sqlite3";
 import { asyncBufferFromFile, parquetMetadataAsync, parquetSchema, parquetReadObjects } from "hyparquet";
 import { compressors } from "hyparquet-compressors";
@@ -16705,7 +16838,7 @@ function quoteIdent(name) {
   return `"${name.replaceAll('"', '""')}"`;
 }
 async function sniffDelimiter(absolutePath) {
-  const fh = await fs32.open(absolutePath, "r");
+  const fh = await fs33.open(absolutePath, "r");
   let head;
   try {
     const buf = Buffer.alloc(65536);
@@ -16789,9 +16922,9 @@ function createDataPreviewRoutes() {
       return { error: "Project not found", status: 404 };
     if (!validatePath(filePath, projectPath))
       return { error: "Path traversal not allowed", status: 403 };
-    const absolutePath = path39.resolve(projectPath, filePath);
+    const absolutePath = path40.resolve(projectPath, filePath);
     try {
-      const stat = await fs32.stat(absolutePath);
+      const stat = await fs33.stat(absolutePath);
       if (stat.isDirectory())
         return { error: "Path is a directory", status: 400 };
     } catch {
@@ -16997,15 +17130,15 @@ var init_data_preview = __esm({
 });
 
 // packages/server/dist/git-credentials.js
-import fs33 from "node:fs";
-import path40 from "node:path";
+import fs34 from "node:fs";
+import path41 from "node:path";
 import { homedir as homedir18 } from "node:os";
-import { spawnSync } from "node:child_process";
+import { spawnSync as spawnSync2 } from "node:child_process";
 function writeGitCredentialsFile(host, username, token) {
   const line = `https://${encodeURIComponent(username)}:${encodeURIComponent(token)}@${host}`;
   let lines = [];
-  if (fs33.existsSync(GIT_CREDENTIALS_PATH)) {
-    lines = fs33.readFileSync(GIT_CREDENTIALS_PATH, "utf-8").split("\n").filter((l) => l.trim() !== "");
+  if (fs34.existsSync(GIT_CREDENTIALS_PATH)) {
+    lines = fs34.readFileSync(GIT_CREDENTIALS_PATH, "utf-8").split("\n").filter((l) => l.trim() !== "");
   }
   const kept = lines.filter((l) => {
     try {
@@ -17015,17 +17148,17 @@ function writeGitCredentialsFile(host, username, token) {
     }
   });
   kept.push(line);
-  fs33.writeFileSync(GIT_CREDENTIALS_PATH, kept.join("\n") + "\n", { encoding: "utf-8", mode: 384 });
+  fs34.writeFileSync(GIT_CREDENTIALS_PATH, kept.join("\n") + "\n", { encoding: "utf-8", mode: 384 });
   try {
-    fs33.chmodSync(GIT_CREDENTIALS_PATH, 384);
+    fs34.chmodSync(GIT_CREDENTIALS_PATH, 384);
   } catch {
   }
 }
 function ensureCredentialHelper() {
-  const current = spawnSync("git", ["config", "--global", "--get", "credential.helper"], { encoding: "utf-8" });
+  const current = spawnSync2("git", ["config", "--global", "--get", "credential.helper"], { encoding: "utf-8" });
   const helper = (current.stdout ?? "").trim();
   if (!helper) {
-    spawnSync("git", ["config", "--global", "credential.helper", "store"], { encoding: "utf-8" });
+    spawnSync2("git", ["config", "--global", "credential.helper", "store"], { encoding: "utf-8" });
   }
 }
 function saveGitCredentials({ host, username, token }) {
@@ -17034,9 +17167,9 @@ function saveGitCredentials({ host, username, token }) {
   console.log(`[GitCredentials] saved for host ${host}`);
 }
 function listGitCredentials() {
-  if (!fs33.existsSync(GIT_CREDENTIALS_PATH))
+  if (!fs34.existsSync(GIT_CREDENTIALS_PATH))
     return [];
-  const lines = fs33.readFileSync(GIT_CREDENTIALS_PATH, "utf-8").split("\n").filter((l) => l.trim() !== "");
+  const lines = fs34.readFileSync(GIT_CREDENTIALS_PATH, "utf-8").split("\n").filter((l) => l.trim() !== "");
   const byHost = /* @__PURE__ */ new Map();
   for (const line of lines) {
     try {
@@ -17050,9 +17183,9 @@ function listGitCredentials() {
   return [...byHost.values()];
 }
 function deleteGitCredential(host) {
-  if (!fs33.existsSync(GIT_CREDENTIALS_PATH))
+  if (!fs34.existsSync(GIT_CREDENTIALS_PATH))
     return;
-  const lines = fs33.readFileSync(GIT_CREDENTIALS_PATH, "utf-8").split("\n").filter((l) => l.trim() !== "");
+  const lines = fs34.readFileSync(GIT_CREDENTIALS_PATH, "utf-8").split("\n").filter((l) => l.trim() !== "");
   const kept = lines.filter((l) => {
     try {
       return new URL(l).host !== host;
@@ -17062,9 +17195,9 @@ function deleteGitCredential(host) {
   });
   if (kept.length === lines.length)
     return;
-  fs33.writeFileSync(GIT_CREDENTIALS_PATH, kept.length ? kept.join("\n") + "\n" : "", { encoding: "utf-8", mode: 384 });
+  fs34.writeFileSync(GIT_CREDENTIALS_PATH, kept.length ? kept.join("\n") + "\n" : "", { encoding: "utf-8", mode: 384 });
   try {
-    fs33.chmodSync(GIT_CREDENTIALS_PATH, 384);
+    fs34.chmodSync(GIT_CREDENTIALS_PATH, 384);
   } catch {
   }
   console.log(`[GitCredentials] removed for host ${host}`);
@@ -17073,15 +17206,15 @@ var GIT_CREDENTIALS_PATH;
 var init_git_credentials = __esm({
   "packages/server/dist/git-credentials.js"() {
     "use strict";
-    GIT_CREDENTIALS_PATH = path40.join(homedir18(), ".git-credentials");
+    GIT_CREDENTIALS_PATH = path41.join(homedir18(), ".git-credentials");
   }
 });
 
 // packages/server/dist/git-ssh.js
-import fs34 from "node:fs";
+import fs35 from "node:fs";
 import os4 from "node:os";
-import path41 from "node:path";
-import { spawnSync as spawnSync2 } from "node:child_process";
+import path42 from "node:path";
+import { spawnSync as spawnSync3 } from "node:child_process";
 function looksLikePrivateKey(name, abs) {
   if (name.endsWith(".pub"))
     return false;
@@ -17089,13 +17222,13 @@ function looksLikePrivateKey(name, abs) {
     return false;
   let firstLine = "";
   try {
-    const fd = fs34.openSync(abs, "r");
+    const fd = fs35.openSync(abs, "r");
     try {
       const buf = Buffer.alloc(64);
-      const n = fs34.readSync(fd, buf, 0, 64, 0);
+      const n = fs35.readSync(fd, buf, 0, 64, 0);
       firstLine = buf.toString("utf-8", 0, n).split("\n")[0];
     } finally {
-      fs34.closeSync(fd);
+      fs35.closeSync(fd);
     }
   } catch {
     return false;
@@ -17103,21 +17236,21 @@ function looksLikePrivateKey(name, abs) {
   return firstLine.includes("PRIVATE KEY-----");
 }
 function isKeyEncrypted(abs) {
-  const r = spawnSync2("ssh-keygen", ["-y", "-P", "", "-f", abs], { encoding: "utf-8" });
+  const r = spawnSync3("ssh-keygen", ["-y", "-P", "", "-f", abs], { encoding: "utf-8" });
   return r.status !== 0;
 }
 function listSshKeys() {
   let entries = [];
   try {
-    entries = fs34.readdirSync(SSH_DIR);
+    entries = fs35.readdirSync(SSH_DIR);
   } catch {
     return [];
   }
   const keys = [];
   for (const name of entries) {
-    const abs = path41.join(SSH_DIR, name);
+    const abs = path42.join(SSH_DIR, name);
     try {
-      if (!fs34.statSync(abs).isFile())
+      if (!fs35.statSync(abs).isFile())
         continue;
     } catch {
       continue;
@@ -17131,7 +17264,7 @@ function listSshKeys() {
 function getSshAgentStatus() {
   if (!process.env.SSH_AUTH_SOCK)
     return { agentRunning: false, loadedKeys: [] };
-  const r = spawnSync2("ssh-add", ["-l"], { encoding: "utf-8" });
+  const r = spawnSync3("ssh-add", ["-l"], { encoding: "utf-8" });
   if (r.status === 2)
     return { agentRunning: false, loadedKeys: [] };
   const loadedKeys = (r.stdout ?? "").split("\n").map((l) => l.trim()).filter(Boolean).filter((l) => l !== "The agent has no identities.");
@@ -17142,10 +17275,10 @@ function unlockSshKey(keyPath, passphrase) {
     return { ok: false, error: "ssh-agent is not running" };
   let dir = "";
   try {
-    dir = fs34.mkdtempSync(path41.join(os4.tmpdir(), "halo-askpass-"));
-    const askpass = path41.join(dir, "askpass.sh");
-    fs34.writeFileSync(askpass, ASKPASS_SCRIPT, { mode: 448 });
-    const r = spawnSync2("ssh-add", [keyPath], {
+    dir = fs35.mkdtempSync(path42.join(os4.tmpdir(), "halo-askpass-"));
+    const askpass = path42.join(dir, "askpass.sh");
+    fs35.writeFileSync(askpass, ASKPASS_SCRIPT, { mode: 448 });
+    const r = spawnSync3("ssh-add", [keyPath], {
       encoding: "utf-8",
       // stdin from /dev/null so ssh-add can never fall back to a tty prompt and block.
       stdio: ["ignore", "pipe", "pipe"],
@@ -17160,10 +17293,10 @@ function unlockSshKey(keyPath, passphrase) {
       }
     });
     if (r.status === 0) {
-      console.log(`[GitSsh] unlocked key ${path41.basename(keyPath)}`);
+      console.log(`[GitSsh] unlocked key ${path42.basename(keyPath)}`);
       return { ok: true };
     }
-    console.log(`[GitSsh] unlock failed for ${path41.basename(keyPath)} (exit ${r.status ?? "killed"})`);
+    console.log(`[GitSsh] unlock failed for ${path42.basename(keyPath)} (exit ${r.status ?? "killed"})`);
     if (r.status === 2)
       return { ok: false, error: "ssh-agent is not reachable" };
     return { ok: false, error: "Incorrect passphrase, or the key could not be unlocked" };
@@ -17173,19 +17306,19 @@ function unlockSshKey(keyPath, passphrase) {
     return { ok: false, error: "Failed to unlock key" };
   } finally {
     if (dir)
-      fs34.rmSync(dir, { recursive: true, force: true });
+      fs35.rmSync(dir, { recursive: true, force: true });
   }
 }
 function ensureSshAgent() {
   try {
     if (process.env.SSH_AUTH_SOCK) {
-      const probe = spawnSync2("ssh-add", ["-l"], { encoding: "utf-8" });
+      const probe = spawnSync3("ssh-add", ["-l"], { encoding: "utf-8" });
       if (probe.status !== 2) {
         console.log(`[GitSsh] using existing agent at ${process.env.SSH_AUTH_SOCK}`);
         return;
       }
     }
-    const r = spawnSync2("ssh-agent", ["-s"], { encoding: "utf-8" });
+    const r = spawnSync3("ssh-agent", ["-s"], { encoding: "utf-8" });
     if (r.status !== 0) {
       console.log("[GitSsh] ssh-agent unavailable; SSH push/pull will need a manually-started agent");
       return;
@@ -17230,19 +17363,19 @@ function parseRemote(url) {
   }
 }
 function switchRemoteProtocol(projectRoot, to) {
-  const cur = spawnSync2("git", ["-C", projectRoot, "remote", "get-url", "origin"], { encoding: "utf-8" });
+  const cur = spawnSync3("git", ["-C", projectRoot, "remote", "get-url", "origin"], { encoding: "utf-8" });
   if (cur.status !== 0)
     throw new Error((cur.stderr ?? "no origin remote").trim());
   const { host, repoPath } = parseRemote((cur.stdout ?? "").trim());
   const next = to === "ssh" ? `git@${host}:${repoPath}` : `https://${host}/${repoPath}`;
-  const set = spawnSync2("git", ["-C", projectRoot, "remote", "set-url", "origin", next], { encoding: "utf-8" });
+  const set = spawnSync3("git", ["-C", projectRoot, "remote", "set-url", "origin", next], { encoding: "utf-8" });
   if (set.status !== 0)
     throw new Error((set.stderr ?? "failed to set remote url").trim());
   console.log(`[GitSsh] switched origin to ${to}`);
   return next;
 }
 function getRemoteProtocol(projectRoot) {
-  const cur = spawnSync2("git", ["-C", projectRoot, "remote", "get-url", "origin"], { encoding: "utf-8" });
+  const cur = spawnSync3("git", ["-C", projectRoot, "remote", "get-url", "origin"], { encoding: "utf-8" });
   if (cur.status !== 0)
     return { url: "", protocol: "other" };
   const url = (cur.stdout ?? "").trim();
@@ -17256,7 +17389,7 @@ var SSH_DIR, NON_KEY_NAMES, ownedAgentPid, ASKPASS_SCRIPT;
 var init_git_ssh = __esm({
   "packages/server/dist/git-ssh.js"() {
     "use strict";
-    SSH_DIR = path41.join(os4.homedir(), ".ssh");
+    SSH_DIR = path42.join(os4.homedir(), ".ssh");
     NON_KEY_NAMES = /* @__PURE__ */ new Set(["known_hosts", "known_hosts2", "authorized_keys", "config"]);
     ownedAgentPid = null;
     ASKPASS_SCRIPT = `#!/bin/sh
@@ -17270,7 +17403,7 @@ printf '%s\\n' "$HALO_SSH_PASSPHRASE"
 // packages/server/dist/routes/git.js
 import { Hono as Hono3 } from "hono";
 import os5 from "node:os";
-import path42 from "node:path";
+import path43 from "node:path";
 function notifyGitChanged(workspacePath) {
   broadcastToWorkspace(workspacePath, { type: "file:changed", path: ".git", action: "change" });
 }
@@ -17587,9 +17720,9 @@ function createGitRoutes() {
       if (!keyPath || typeof passphrase !== "string") {
         return c.json({ error: "keyPath and passphrase are required" }, 400);
       }
-      const sshDir = path42.join(os5.homedir(), ".ssh");
-      const resolved = path42.resolve(keyPath);
-      if (path42.dirname(resolved) !== path42.resolve(sshDir)) {
+      const sshDir = path43.join(os5.homedir(), ".ssh");
+      const resolved = path43.resolve(keyPath);
+      if (path43.dirname(resolved) !== path43.resolve(sshDir)) {
         return c.json({ error: "keyPath must be inside ~/.ssh" }, 400);
       }
       return c.json(unlockSshKey(resolved, passphrase));
@@ -17665,8 +17798,8 @@ var init_mtime_cache = __esm({
 
 // packages/server/dist/routes/agent-configs.js
 import { Hono as Hono4 } from "hono";
-import fs35 from "node:fs/promises";
-import path43 from "node:path";
+import fs36 from "node:fs/promises";
+import path44 from "node:path";
 import { homedir as homedir19 } from "node:os";
 import YAML10 from "yaml";
 function getAvailableTools() {
@@ -17677,6 +17810,17 @@ function getAvailableTools() {
   _cachedTools = [...tools, draft].map((t2) => ({ name: t2.name, description: t2.description }));
   return _cachedTools;
 }
+async function writeFileAtomic2(filePath, content) {
+  const tmpPath = `${filePath}.tmp`;
+  await fs36.writeFile(tmpPath, content, "utf-8");
+  try {
+    await fs36.rename(tmpPath, filePath);
+  } catch {
+    await fs36.writeFile(filePath, content, "utf-8");
+    await fs36.rm(tmpPath, { force: true }).catch(() => {
+    });
+  }
+}
 function parseAgentYaml(content) {
   try {
     const data = YAML10.parse(content);
@@ -17762,29 +17906,29 @@ function defaultAgentYamlTemplate() {
   }, { lineWidth: 120 });
 }
 async function ensureDir2(dir) {
-  await fs35.mkdir(dir, { recursive: true });
+  await fs36.mkdir(dir, { recursive: true });
 }
 async function scanAgentsDir(dir, scope) {
   const agents = [];
   let names;
   try {
-    names = await fs35.readdir(dir);
+    names = await fs36.readdir(dir);
   } catch {
     return agents;
   }
   for (const entryName of names) {
-    const agentDir = path43.join(dir, entryName);
+    const agentDir = path44.join(dir, entryName);
     try {
-      const stat = await fs35.stat(agentDir);
+      const stat = await fs36.stat(agentDir);
       if (!stat.isDirectory())
         continue;
     } catch {
       continue;
     }
-    const yamlPath = path43.join(agentDir, "agent.yaml");
+    const yamlPath = path44.join(agentDir, "agent.yaml");
     try {
-      const yamlStat = await fs35.stat(yamlPath);
-      const parsed = _yamlCache.get(yamlPath, yamlStat.mtimeMs) ?? _yamlCache.set(yamlPath, yamlStat.mtimeMs, parseAgentYaml(await fs35.readFile(yamlPath, "utf-8")));
+      const yamlStat = await fs36.stat(yamlPath);
+      const parsed = _yamlCache.get(yamlPath, yamlStat.mtimeMs) ?? _yamlCache.set(yamlPath, yamlStat.mtimeMs, parseAgentYaml(await fs36.readFile(yamlPath, "utf-8")));
       const { name, description, model, priority, tools, skills, internal } = parsed;
       agents.push({
         id: entryName,
@@ -17805,13 +17949,13 @@ async function scanAgentsDir(dir, scope) {
   return agents;
 }
 async function ensureDefaultAgent(dir) {
-  const defaultDir = path43.join(dir, "default");
-  const yamlPath = path43.join(defaultDir, "agent.yaml");
+  const defaultDir = path44.join(dir, "default");
+  const yamlPath = path44.join(defaultDir, "agent.yaml");
   try {
-    await fs35.access(yamlPath);
+    await fs36.access(yamlPath);
   } catch {
     await ensureDir2(defaultDir);
-    await fs35.writeFile(yamlPath, defaultAgentYamlTemplate(), "utf-8");
+    await fs36.writeFile(yamlPath, defaultAgentYamlTemplate(), "utf-8");
   }
 }
 function createAgentConfigRoutes() {
@@ -17829,7 +17973,7 @@ function createAgentConfigRoutes() {
     const projectId = c.req.query("projectId");
     let workspaceAgents = [];
     if (projectId) {
-      const wsAgentsDir = path43.join(projectId, ".halo", "agents");
+      const wsAgentsDir = path44.join(projectId, ".halo", "agents");
       workspaceAgents = await scanAgentsDir(wsAgentsDir, "workspace");
     }
     const wsIds = new Set(workspaceAgents.map((a) => a.id));
@@ -17861,33 +18005,33 @@ function createAgentConfigRoutes() {
     if (scope === "workspace") {
       if (!body.projectId)
         return c.json({ error: "projectId required for workspace agents" }, 400);
-      baseDir = path43.join(body.projectId, ".halo", "agents");
+      baseDir = path44.join(body.projectId, ".halo", "agents");
     } else {
       baseDir = GLOBAL_AGENTS_DIR4;
     }
-    const agentDir = path43.join(baseDir, id);
+    const agentDir = path44.join(baseDir, id);
     try {
-      await fs35.access(agentDir);
+      await fs36.access(agentDir);
       return c.json({ error: "Agent already exists" }, 409);
     } catch {
     }
     let conflictScope = null;
     if (scope === "workspace") {
       try {
-        await fs35.access(path43.join(GLOBAL_AGENTS_DIR4, id));
+        await fs36.access(path44.join(GLOBAL_AGENTS_DIR4, id));
         conflictScope = "global";
       } catch {
       }
     } else if (body.projectId) {
       try {
-        await fs35.access(path43.join(body.projectId, ".halo", "agents", id));
+        await fs36.access(path44.join(body.projectId, ".halo", "agents", id));
         conflictScope = "workspace";
       } catch {
       }
     }
     await ensureDir2(agentDir);
-    await fs35.writeFile(path43.join(agentDir, "agent.yaml"), defaultAgentYaml(body.name, body.description ?? ""), "utf-8");
-    await fs35.writeFile(path43.join(agentDir, "AGENT.md"), `# ${body.name}
+    await fs36.writeFile(path44.join(agentDir, "agent.yaml"), defaultAgentYaml(body.name, body.description ?? ""), "utf-8");
+    await fs36.writeFile(path44.join(agentDir, "AGENT.md"), `# ${body.name}
 
 ${body.description ?? ""}
 `, "utf-8");
@@ -17901,13 +18045,13 @@ ${body.description ?? ""}
     const projectId = c.req.query("projectId");
     let agentDir;
     if (scope === "workspace" && projectId) {
-      agentDir = path43.join(projectId, ".halo", "agents", id);
+      agentDir = path44.join(projectId, ".halo", "agents", id);
     } else {
-      agentDir = path43.join(GLOBAL_AGENTS_DIR4, id);
+      agentDir = path44.join(GLOBAL_AGENTS_DIR4, id);
     }
-    const yamlPath = path43.join(agentDir, "agent.yaml");
+    const yamlPath = path44.join(agentDir, "agent.yaml");
     try {
-      const content = await fs35.readFile(yamlPath, "utf-8");
+      const content = await fs36.readFile(yamlPath, "utf-8");
       return c.json({ yaml: content });
     } catch {
       return c.json({ error: "Agent not found" }, 404);
@@ -17924,17 +18068,17 @@ ${body.description ?? ""}
     const scope = body.scope ?? "global";
     let agentDir;
     if (scope === "workspace" && body.projectId) {
-      agentDir = path43.join(body.projectId, ".halo", "agents", id);
+      agentDir = path44.join(body.projectId, ".halo", "agents", id);
     } else {
-      agentDir = path43.join(GLOBAL_AGENTS_DIR4, id);
+      agentDir = path44.join(GLOBAL_AGENTS_DIR4, id);
     }
-    const yamlPath = path43.join(agentDir, "agent.yaml");
+    const yamlPath = path44.join(agentDir, "agent.yaml");
     try {
-      await fs35.access(agentDir);
+      await fs36.access(agentDir);
     } catch {
       return c.json({ error: "Agent not found" }, 404);
     }
-    await fs35.writeFile(yamlPath, body.yaml, "utf-8");
+    await writeFileAtomic2(yamlPath, body.yaml);
     const { name, description, model } = parseAgentYaml(body.yaml);
     return c.json({ agent: { id, name, description, model, path: agentDir, scope } });
   });
@@ -17946,12 +18090,12 @@ ${body.description ?? ""}
     const projectId = c.req.query("projectId");
     let agentDir;
     if (scope === "workspace" && projectId) {
-      agentDir = path43.join(projectId, ".halo", "agents", id);
+      agentDir = path44.join(projectId, ".halo", "agents", id);
     } else {
-      agentDir = path43.join(GLOBAL_AGENTS_DIR4, id);
+      agentDir = path44.join(GLOBAL_AGENTS_DIR4, id);
     }
     try {
-      await fs35.access(agentDir);
+      await fs36.access(agentDir);
     } catch {
       return c.json({ error: "Agent not found" }, 404);
     }
@@ -17961,7 +18105,7 @@ ${body.description ?? ""}
         return c.json({ error: "Cannot delete the last global agent. At least one global agent must remain." }, 400);
       }
     }
-    await fs35.rm(agentDir, { recursive: true, force: true });
+    await fs36.rm(agentDir, { recursive: true, force: true });
     return c.json({ ok: true });
   });
   app2.patch("/agent-configs/:id/toggle", async (c) => {
@@ -17993,7 +18137,7 @@ ${body.description ?? ""}
     if (!filePath)
       return c.json({ content: "", exists: false, readOnly: !isMdWritable(fileType) });
     try {
-      const content = await fs35.readFile(filePath, "utf-8");
+      const content = await fs36.readFile(filePath, "utf-8");
       return c.json({ content, exists: true, path: filePath, readOnly: !isMdWritable(fileType) });
     } catch {
       return c.json({ content: "", exists: false, path: filePath, readOnly: !isMdWritable(fileType) });
@@ -18026,7 +18170,7 @@ ${body.description ?? ""}
         continue;
       }
       try {
-        const content = await fs35.readFile(filePath, "utf-8");
+        const content = await fs36.readFile(filePath, "utf-8");
         result[ft] = { content, exists: true, path: filePath, readOnly: !isMdWritable(ft) };
       } catch {
         result[ft] = { content: "", exists: false, path: filePath, readOnly: !isMdWritable(ft) };
@@ -18036,10 +18180,10 @@ ${body.description ?? ""}
   });
   function getSessionsDir(agentId, _source, projectId) {
     if (agentId.startsWith("__") && agentId.endsWith("__")) {
-      return path43.join(homedir19(), ".halo", "global", "internal-sessions", agentId);
+      return path44.join(homedir19(), ".halo", "global", "internal-sessions", agentId);
     }
-    const base = projectId ? path43.join(projectId, ".halo") : path43.join(homedir19(), ".halo");
-    return path43.join(base, "sessions", agentId);
+    const base = projectId ? path44.join(projectId, ".halo") : path44.join(homedir19(), ".halo");
+    return path44.join(base, "sessions", agentId);
   }
   app2.get("/agent-configs/:id/sessions", async (c) => {
     const agentId = c.req.param("id");
@@ -18050,7 +18194,7 @@ ${body.description ?? ""}
     const dir = getSessionsDir(agentId, source, projectId || void 0);
     let files;
     try {
-      files = await fs35.readdir(dir);
+      files = await fs36.readdir(dir);
     } catch {
       return c.json({ sessions: [] });
     }
@@ -18059,7 +18203,7 @@ ${body.description ?? ""}
       if (!f.endsWith(".json"))
         continue;
       try {
-        const raw = await fs35.readFile(path43.join(dir, f), "utf-8");
+        const raw = await fs36.readFile(path44.join(dir, f), "utf-8");
         const session = JSON.parse(raw);
         sessions.push({
           id: session.id,
@@ -18088,9 +18232,9 @@ ${body.description ?? ""}
     const projectId = c.req.query("projectId");
     const source = c.req.query("source") || "test-chat";
     const dir = getSessionsDir(agentId, source, projectId || void 0);
-    const filePath = path43.join(dir, `${sessionId}.json`);
+    const filePath = path44.join(dir, `${sessionId}.json`);
     try {
-      const raw = await fs35.readFile(filePath, "utf-8");
+      const raw = await fs36.readFile(filePath, "utf-8");
       return c.json({ session: JSON.parse(raw) });
     } catch {
       return c.json({ error: "Session not found" }, 404);
@@ -18124,7 +18268,7 @@ ${body.description ?? ""}
       agentSnapshot: body.agentSnapshot ?? {},
       messages: messages2
     };
-    await fs35.writeFile(path43.join(dir, `${sessionId}.json`), JSON.stringify(session, null, 2), "utf-8");
+    await fs36.writeFile(path44.join(dir, `${sessionId}.json`), JSON.stringify(session, null, 2), "utf-8");
     return c.json({ id: sessionId, session: { ...session, messages: void 0 } });
   });
   app2.delete("/agent-configs/:id/sessions", async (c) => {
@@ -18136,11 +18280,11 @@ ${body.description ?? ""}
     const dir = getSessionsDir(agentId, source, projectId || void 0);
     let deleted = 0;
     try {
-      const files = await fs35.readdir(dir);
+      const files = await fs36.readdir(dir);
       for (const f of files) {
         if (!f.endsWith(".json"))
           continue;
-        await fs35.rm(path43.join(dir, f));
+        await fs36.rm(path44.join(dir, f));
         deleted++;
       }
     } catch {
@@ -18157,7 +18301,7 @@ ${body.description ?? ""}
     const source = c.req.query("source") || "test-chat";
     const dir = getSessionsDir(agentId, source, projectId || void 0);
     try {
-      await fs35.rm(path43.join(dir, `${sessionId}.json`));
+      await fs36.rm(path44.join(dir, `${sessionId}.json`));
       return c.json({ ok: true });
     } catch {
       return c.json({ error: "Session not found" }, 404);
@@ -18177,7 +18321,7 @@ var init_agent_configs = __esm({
     init_workspace_path();
     init_mtime_cache();
     _cachedTools = null;
-    GLOBAL_AGENTS_DIR4 = path43.join(homedir19(), ".halo", "global", "agents");
+    GLOBAL_AGENTS_DIR4 = path44.join(homedir19(), ".halo", "global", "agents");
     FALLBACK_SCAFFOLD_PROVIDER = "aws-bedrock-claude-invoke";
     _yamlCache = createMtimeCache();
   }
@@ -18185,8 +18329,8 @@ var init_agent_configs = __esm({
 
 // packages/server/dist/routes/skills.js
 import { Hono as Hono5 } from "hono";
-import fs36 from "node:fs/promises";
-import path44 from "node:path";
+import fs37 from "node:fs/promises";
+import path45 from "node:path";
 import { homedir as homedir20 } from "node:os";
 import YAML11 from "yaml";
 function defaultSkillSettings() {
@@ -18205,20 +18349,20 @@ function defaultSkillSettings() {
 }
 async function readYamlFile3(filePath) {
   try {
-    const content = await fs36.readFile(filePath, "utf-8");
+    const content = await fs37.readFile(filePath, "utf-8");
     return YAML11.parse(content) ?? {};
   } catch {
     try {
       const jsonPath = filePath.replace(/\.yaml$/, ".json");
-      return JSON.parse(await fs36.readFile(jsonPath, "utf-8"));
+      return JSON.parse(await fs37.readFile(jsonPath, "utf-8"));
     } catch {
       return {};
     }
   }
 }
 async function writeYamlFile(filePath, data) {
-  await fs36.mkdir(path44.dirname(filePath), { recursive: true });
-  await fs36.writeFile(filePath, YAML11.stringify(data, { lineWidth: 120 }), "utf-8");
+  await fs37.mkdir(path45.dirname(filePath), { recursive: true });
+  await fs37.writeFile(filePath, YAML11.stringify(data, { lineWidth: 120 }), "utf-8");
 }
 async function addSkillSettings(settingsPath, skillId) {
   const settings = await readYamlFile3(settingsPath);
@@ -18241,7 +18385,7 @@ async function removeSkillSettings(settingsPath, skillId) {
   }
 }
 async function ensureDir3(dir) {
-  await fs36.mkdir(dir, { recursive: true });
+  await fs37.mkdir(dir, { recursive: true });
 }
 function toSkillMd(name, description) {
   return `---
@@ -18258,32 +18402,32 @@ async function scanSkillsDir(dir, scope) {
   const skills = [];
   let names;
   try {
-    names = await fs36.readdir(dir);
+    names = await fs37.readdir(dir);
   } catch {
     return skills;
   }
   for (const entryName of names) {
-    const skillDir = path44.join(dir, entryName);
+    const skillDir = path45.join(dir, entryName);
     try {
-      const stat = await fs36.stat(skillDir);
+      const stat = await fs37.stat(skillDir);
       if (!stat.isDirectory())
         continue;
     } catch {
       continue;
     }
-    const skillMdPath = path44.join(skillDir, "SKILL.md");
+    const skillMdPath = path45.join(skillDir, "SKILL.md");
     try {
-      const mdStat = await fs36.stat(skillMdPath);
+      const mdStat = await fs37.stat(skillMdPath);
       let meta = _skillMdCache.get(skillMdPath, mdStat.mtimeMs);
       if (!meta) {
-        const { name, description, command } = parseSkillFrontmatter(await fs36.readFile(skillMdPath, "utf-8"));
+        const { name, description, command } = parseSkillFrontmatter(await fs37.readFile(skillMdPath, "utf-8"));
         meta = _skillMdCache.set(skillMdPath, mdStat.mtimeMs, { name: name || entryName, description: description ?? "", command });
       }
       skills.push({ id: entryName, name: meta.name, description: meta.description, path: skillDir, scope, command: meta.command });
     } catch {
-      const yamlPath = path44.join(skillDir, "skill.yaml");
+      const yamlPath = path45.join(skillDir, "skill.yaml");
       try {
-        const yamlContent = await fs36.readFile(yamlPath, "utf-8");
+        const yamlContent = await fs37.readFile(yamlPath, "utf-8");
         const m = yamlContent.match(/^name:\s*(.+)$/m);
         const d = yamlContent.match(/^description:\s*(.+)$/m);
         skills.push({ id: entryName, name: m?.[1]?.trim() || entryName, description: d?.[1]?.trim() || "", path: skillDir, scope });
@@ -18302,7 +18446,7 @@ function createSkillRoutes() {
     const projectId = c.req.query("projectId");
     let workspaceSkills = [];
     if (projectId) {
-      const wsSkillsDir = path44.join(projectId, ".halo", "skills");
+      const wsSkillsDir = path45.join(projectId, ".halo", "skills");
       workspaceSkills = await scanSkillsDir(wsSkillsDir, "workspace");
     }
     const wsIds = new Set(workspaceSkills.map((s) => s.id));
@@ -18325,19 +18469,19 @@ function createSkillRoutes() {
     if (scope === "workspace") {
       if (!body.projectId)
         return c.json({ error: "projectId required for workspace skills" }, 400);
-      baseDir = path44.join(body.projectId, ".halo", "skills");
+      baseDir = path45.join(body.projectId, ".halo", "skills");
     } else {
       baseDir = GLOBAL_SKILLS_DIR2;
     }
-    const skillDir = path44.join(baseDir, id);
+    const skillDir = path45.join(baseDir, id);
     try {
-      await fs36.access(skillDir);
+      await fs37.access(skillDir);
       return c.json({ error: "Skill already exists" }, 409);
     } catch {
     }
     await ensureDir3(skillDir);
-    await fs36.writeFile(path44.join(skillDir, "SKILL.md"), toSkillMd(body.name, body.description ?? ""), "utf-8");
-    const settingsPath = scope === "workspace" && body.projectId ? path44.join(body.projectId, ".halo", "settings.yaml") : GLOBAL_SETTINGS_PATH;
+    await fs37.writeFile(path45.join(skillDir, "SKILL.md"), toSkillMd(body.name, body.description ?? ""), "utf-8");
+    const settingsPath = scope === "workspace" && body.projectId ? path45.join(body.projectId, ".halo", "settings.yaml") : GLOBAL_SETTINGS_PATH;
     await addSkillSettings(settingsPath, id);
     const skill = { id, name: body.name, description: body.description ?? "", path: skillDir, scope };
     return c.json({ skill }, 201);
@@ -18350,17 +18494,17 @@ function createSkillRoutes() {
     const projectId = c.req.query("projectId");
     let skillDir;
     if (scope === "workspace" && projectId) {
-      skillDir = path44.join(projectId, ".halo", "skills", id);
+      skillDir = path45.join(projectId, ".halo", "skills", id);
     } else {
-      skillDir = path44.join(GLOBAL_SKILLS_DIR2, id);
+      skillDir = path45.join(GLOBAL_SKILLS_DIR2, id);
     }
     try {
-      await fs36.access(skillDir);
+      await fs37.access(skillDir);
     } catch {
       return c.json({ error: "Skill not found" }, 404);
     }
-    await fs36.rm(skillDir, { recursive: true, force: true });
-    const settingsPath = scope === "workspace" && projectId ? path44.join(projectId, ".halo", "settings.yaml") : GLOBAL_SETTINGS_PATH;
+    await fs37.rm(skillDir, { recursive: true, force: true });
+    const settingsPath = scope === "workspace" && projectId ? path45.join(projectId, ".halo", "settings.yaml") : GLOBAL_SETTINGS_PATH;
     await removeSkillSettings(settingsPath, id);
     return c.json({ ok: true });
   });
@@ -18384,30 +18528,30 @@ var init_skills = __esm({
     init_db();
     init_workspace_path();
     init_mtime_cache();
-    GLOBAL_SETTINGS_PATH = path44.join(homedir20(), ".halo", "secrets", "settings.yaml");
+    GLOBAL_SETTINGS_PATH = path45.join(homedir20(), ".halo", "secrets", "settings.yaml");
     _skillMdCache = createMtimeCache();
   }
 });
 
 // packages/server/dist/routes/settings.js
 import { Hono as Hono6 } from "hono";
-import fs37 from "node:fs/promises";
-import path45 from "node:path";
+import fs38 from "node:fs/promises";
+import path46 from "node:path";
 import { homedir as homedir21 } from "node:os";
 import YAML12 from "yaml";
 async function readSettingsFile(filePath) {
   try {
-    const content = await fs37.readFile(filePath, "utf-8");
+    const content = await fs38.readFile(filePath, "utf-8");
     return YAML12.parse(content) ?? {};
   } catch {
     return {};
   }
 }
 async function writeSettingsFile(filePath, data) {
-  await fs37.mkdir(path45.dirname(filePath), { recursive: true });
-  await fs37.writeFile(filePath, YAML12.stringify(data, { lineWidth: 120 }), { encoding: "utf-8", mode: 384 });
+  await fs38.mkdir(path46.dirname(filePath), { recursive: true });
+  await fs38.writeFile(filePath, YAML12.stringify(data, { lineWidth: 120 }), { encoding: "utf-8", mode: 384 });
   try {
-    await fs37.chmod(filePath, 384);
+    await fs38.chmod(filePath, 384);
   } catch {
   }
 }
@@ -18521,8 +18665,8 @@ function detectOrphans(tree, declared) {
       if (!block || typeof block !== "object")
         continue;
       for (const k of Object.keys(block)) {
-        const path65 = `${namespaceId}.${kindWord}.${k}`;
-        if (!declaredMap.has(path65)) {
+        const path66 = `${namespaceId}.${kindWord}.${k}`;
+        if (!declaredMap.has(path66)) {
           out.push({ namespaceId, kind: kindWord === "params" ? "param" : "secret", key: k });
         }
       }
@@ -18537,7 +18681,7 @@ function createSettingsRoutes() {
     const globalTree = await readSettingsFile(GLOBAL_SETTINGS_PATH2);
     let workspaceTree = null;
     if (projectId) {
-      workspaceTree = await readSettingsFile(path45.join(projectId, ".halo", "settings.yaml"));
+      workspaceTree = await readSettingsFile(path46.join(projectId, ".halo", "settings.yaml"));
     }
     const declared = loadSettingsSchema(projectId ?? void 0);
     const sections = resolveSections(declared, globalTree, workspaceTree);
@@ -18587,7 +18731,7 @@ function createSettingsRoutes() {
       const offending = rejectGlobalOnlyAtWorkspace("workspace", flattenDotted(body.settings));
       if (offending)
         return c.json({ error: `${offending} is global-only and cannot be set per workspace` }, 400);
-      const wsPath = path45.join(projectPath, ".halo", "settings.yaml");
+      const wsPath = path46.join(projectPath, ".halo", "settings.yaml");
       await writeSettingsFile(wsPath, body.settings);
     } else {
       await writeSettingsFile(GLOBAL_SETTINGS_PATH2, body.settings);
@@ -18607,7 +18751,7 @@ function createSettingsRoutes() {
       const offending = rejectGlobalOnlyAtWorkspace("workspace", [body.key]);
       if (offending)
         return c.json({ error: `${offending} is global-only and cannot be set per workspace` }, 400);
-      filePath = path45.join(projectPath, ".halo", "settings.yaml");
+      filePath = path46.join(projectPath, ".halo", "settings.yaml");
     } else {
       filePath = GLOBAL_SETTINGS_PATH2;
     }
@@ -18636,7 +18780,7 @@ function createSettingsRoutes() {
       const projectPath = await resolveProjectPath(body.projectId);
       if (!projectPath)
         return c.json({ error: "Project not found" }, 404);
-      filePath = path45.join(projectPath, ".halo", "settings.yaml");
+      filePath = path46.join(projectPath, ".halo", "settings.yaml");
     } else {
       filePath = GLOBAL_SETTINGS_PATH2;
     }
@@ -18662,39 +18806,39 @@ var init_settings = __esm({
     "use strict";
     init_settings_schema();
     init_workspace_path();
-    GLOBAL_SETTINGS_PATH2 = path45.join(homedir21(), ".halo", "secrets", "settings.yaml");
+    GLOBAL_SETTINGS_PATH2 = path46.join(homedir21(), ".halo", "secrets", "settings.yaml");
     _changeListeners = [];
   }
 });
 
 // packages/server/dist/evolution/archive.js
-import fs38 from "node:fs";
-import path46 from "node:path";
+import fs39 from "node:fs";
+import path47 from "node:path";
 import { pipeline } from "node:stream/promises";
 import JSZip from "jszip";
 import { eq as eq7, and as and5, isNull as isNull4, lte, isNotNull as isNotNull3, lt as lt2 } from "drizzle-orm";
 async function zipDir(srcDir, outZip) {
-  if (!fs38.existsSync(srcDir))
+  if (!fs39.existsSync(srcDir))
     return false;
-  fs38.mkdirSync(path46.dirname(outZip), { recursive: true });
+  fs39.mkdirSync(path47.dirname(outZip), { recursive: true });
   const zip = new JSZip();
   const walk = (dir, rel) => {
-    const entries = fs38.readdirSync(dir, { withFileTypes: true });
+    const entries = fs39.readdirSync(dir, { withFileTypes: true });
     if (entries.length === 0 && rel) {
       zip.folder(rel);
       return;
     }
     for (const e of entries) {
-      const abs = path46.join(dir, e.name);
+      const abs = path47.join(dir, e.name);
       const childRel = rel ? `${rel}/${e.name}` : e.name;
       if (e.isDirectory()) {
         walk(abs, childRel);
       } else if (e.isFile()) {
-        zip.file(childRel, fs38.readFileSync(abs), { date: fs38.statSync(abs).mtime });
+        zip.file(childRel, fs39.readFileSync(abs), { date: fs39.statSync(abs).mtime });
       } else if (e.isSymbolicLink()) {
         try {
-          if (fs38.statSync(abs).isFile())
-            zip.file(childRel, fs38.readFileSync(abs));
+          if (fs39.statSync(abs).isFile())
+            zip.file(childRel, fs39.readFileSync(abs));
         } catch {
         }
       }
@@ -18702,7 +18846,7 @@ async function zipDir(srcDir, outZip) {
   };
   try {
     walk(srcDir, "");
-    await pipeline(zip.generateNodeStream({ type: "nodebuffer", streamFiles: true, compression: "DEFLATE" }), fs38.createWriteStream(outZip));
+    await pipeline(zip.generateNodeStream({ type: "nodebuffer", streamFiles: true, compression: "DEFLATE" }), fs39.createWriteStream(outZip));
     return true;
   } catch (err) {
     rmFile(outZip);
@@ -18712,20 +18856,20 @@ async function zipDir(srcDir, outZip) {
 }
 function rmDir(dir) {
   try {
-    fs38.rmSync(dir, { recursive: true, force: true });
+    fs39.rmSync(dir, { recursive: true, force: true });
   } catch {
   }
 }
 function rmFile(p) {
   try {
-    fs38.rmSync(p, { force: true });
+    fs39.rmSync(p, { force: true });
   } catch {
   }
 }
 async function archiveRun(workspacePath, runId, errors) {
   const runDir = wsEvoRunDir(workspacePath, runId);
   const outZip = wsEvoArchivedRunZip(workspacePath, runId);
-  if (!fs38.existsSync(runDir)) {
+  if (!fs39.existsSync(runDir)) {
     return true;
   }
   if (!await zipDir(runDir, outZip)) {
@@ -18738,7 +18882,7 @@ async function archiveRun(workspacePath, runId, errors) {
 async function archiveApply(workspacePath, applyId, errors) {
   const applyDir = wsEvoApplyDir(workspacePath, applyId);
   const outZip = wsEvoArchivedApplyZip(workspacePath, applyId);
-  if (!fs38.existsSync(applyDir))
+  if (!fs39.existsSync(applyDir))
     return true;
   if (!await zipDir(applyDir, outZip)) {
     errors.push(`zip failed for apply ${applyId}`);
@@ -18865,8 +19009,8 @@ var init_raw_sqlite = __esm({
 // packages/server/dist/routes/evolution.js
 import { Hono as Hono7 } from "hono";
 import { eq as eq8, desc as desc2, lt as lt3, and as and6, or, sql } from "drizzle-orm";
-import fs39 from "node:fs/promises";
-import path47 from "node:path";
+import fs40 from "node:fs/promises";
+import path48 from "node:path";
 function createEvolutionRoutes() {
   const router = new Hono7();
   router.get("/evolution/runs", async (c) => {
@@ -18931,33 +19075,33 @@ function createEvolutionRoutes() {
     const dir = wsEvoRunDir(row.workspacePath, id);
     let patchMd = null;
     try {
-      patchMd = await fs39.readFile(path47.join(dir, "patch.md"), "utf-8");
+      patchMd = await fs40.readFile(path48.join(dir, "patch.md"), "utf-8");
     } catch {
     }
     let scoreJson = null;
     try {
-      const raw = await fs39.readFile(path47.join(dir, "score.json"), "utf-8");
+      const raw = await fs40.readFile(path48.join(dir, "score.json"), "utf-8");
       scoreJson = JSON.parse(raw);
     } catch {
     }
     let wrapperLog = null;
     try {
-      wrapperLog = await fs39.readFile(evoWrapperLogFile(id), "utf-8");
+      wrapperLog = await fs40.readFile(evoWrapperLogFile(id), "utf-8");
     } catch {
     }
     let subCliLog = null;
     try {
-      subCliLog = await fs39.readFile(path47.join(dir, "sub-cli.log"), "utf-8");
+      subCliLog = await fs40.readFile(path48.join(dir, "sub-cli.log"), "utf-8");
     } catch {
     }
     let skipReasonMd = null;
     try {
-      skipReasonMd = await fs39.readFile(path47.join(dir, ".skip.md"), "utf-8");
+      skipReasonMd = await fs40.readFile(path48.join(dir, ".skip.md"), "utf-8");
     } catch {
     }
     let snapshotSummary = null;
     try {
-      const raw = await fs39.readFile(path47.join(dir, "source-snapshot.json"), "utf-8");
+      const raw = await fs40.readFile(path48.join(dir, "source-snapshot.json"), "utf-8");
       const parsed = JSON.parse(raw);
       const msgs = parsed.rawMessages ?? [];
       const firstUser = msgs.find((m) => m.role === "user");
@@ -19445,12 +19589,12 @@ var init_session_archive2 = __esm({
 import Database4 from "better-sqlite3";
 import { drizzle as drizzle3 } from "drizzle-orm/better-sqlite3";
 import { sqliteTable as sqliteTable3, text as text3, integer as integer3 } from "drizzle-orm/sqlite-core";
-import path48 from "node:path";
-import fs40 from "node:fs";
+import path49 from "node:path";
+import fs41 from "node:fs";
 function createChannelDb(secretsDir) {
-  const channelsDir = path48.join(secretsDir, "channels");
-  fs40.mkdirSync(channelsDir, { recursive: true });
-  const dbPath = path48.join(channelsDir, "channels.db");
+  const channelsDir = path49.join(secretsDir, "channels");
+  fs41.mkdirSync(channelsDir, { recursive: true });
+  const dbPath = path49.join(channelsDir, "channels.db");
   const sqlite = new Database4(dbPath);
   sqlite.pragma("journal_mode = WAL");
   sqlite.exec(CREATE_SQL2);
@@ -19500,11 +19644,11 @@ CREATE INDEX IF NOT EXISTS idx_channel_accounts_type ON channel_accounts(channel
 });
 
 // packages/server/dist/channels/shared/accounts.js
-import fs41 from "node:fs";
-import path49 from "node:path";
+import fs42 from "node:fs";
+import path50 from "node:path";
 import { eq as eq10, and as and7 } from "drizzle-orm";
 function resolveAccountWorkspace(account) {
-  if (!fs41.existsSync(account.workspacePath))
+  if (!fs42.existsSync(account.workspacePath))
     return null;
   ensureWorkspaceHalo(account.workspacePath);
   return account.workspacePath;
@@ -19517,9 +19661,9 @@ function accessLevelError(value, allowed) {
   return `accessLevel must be one of: ${allowed.join(", ")}`;
 }
 function validateWorkspaceBody(workspacePath) {
-  if (!path49.isAbsolute(workspacePath))
+  if (!path50.isAbsolute(workspacePath))
     return "workspacePath must be absolute";
-  if (!fs41.existsSync(workspacePath))
+  if (!fs42.existsSync(workspacePath))
     return "workspace path not found";
   ensureWorkspaceHalo(workspacePath);
   return null;
@@ -19819,22 +19963,22 @@ var init_session_types = __esm({
 
 // packages/server/dist/routes/halo-city.js
 import { Hono as Hono10 } from "hono";
-import fs42 from "node:fs";
-import path50 from "node:path";
+import fs43 from "node:fs";
+import path51 from "node:path";
 import Database5 from "better-sqlite3";
 function scanSkills2(dir) {
   let names;
   try {
-    names = fs42.readdirSync(dir);
+    names = fs43.readdirSync(dir);
   } catch {
     return [];
   }
   const out = [];
   for (const entry of names) {
-    const skillMd = path50.join(dir, entry, "SKILL.md");
+    const skillMd = path51.join(dir, entry, "SKILL.md");
     let stat;
     try {
-      stat = fs42.statSync(skillMd);
+      stat = fs43.statSync(skillMd);
       if (!stat.isFile())
         continue;
     } catch {
@@ -19843,7 +19987,7 @@ function scanSkills2(dir) {
     let meta = _skillCache.get(skillMd, stat.mtimeMs);
     if (!meta) {
       try {
-        const { name, description, command } = parseSkillFrontmatter(fs42.readFileSync(skillMd, "utf-8"));
+        const { name, description, command } = parseSkillFrontmatter(fs43.readFileSync(skillMd, "utf-8"));
         meta = _skillCache.set(skillMd, stat.mtimeMs, { id: entry, name: name || entry, description: description ?? "", command });
       } catch {
         continue;
@@ -19929,10 +20073,10 @@ function snapshotWorkspace(sm, wsPath, label) {
       messageCount: meta.messageCount
     };
   });
-  const wsSkills = scanSkills2(path50.join(wsPath, ".halo", "skills"));
+  const wsSkills = scanSkills2(path51.join(wsPath, ".halo", "skills"));
   return {
     path: wsPath,
-    key: path50.basename(wsPath) || wsPath,
+    key: path51.basename(wsPath) || wsPath,
     label,
     sessions,
     counts,
@@ -19943,15 +20087,15 @@ function snapshotWorkspace(sm, wsPath, label) {
 function roReader(rawPath) {
   let wsPath;
   try {
-    wsPath = fs42.realpathSync(rawPath);
+    wsPath = fs43.realpathSync(rawPath);
   } catch {
     return null;
   }
   const cached = _roReaders.get(wsPath);
   if (cached)
     return cached;
-  const dbPath = path50.join(wsPath, ".halo", "halo.db");
-  if (!fs42.existsSync(dbPath))
+  const dbPath = path51.join(wsPath, ".halo", "halo.db");
+  if (!fs43.existsSync(dbPath))
     return null;
   try {
     const db = new Database5(dbPath, { readonly: true, fileMustExist: true });
@@ -19979,7 +20123,7 @@ function dropRoReader(rawPath) {
     return;
   let wsPath = rawPath;
   try {
-    wsPath = fs42.realpathSync(rawPath);
+    wsPath = fs43.realpathSync(rawPath);
   } catch {
   }
   const r = _roReaders.get(wsPath);
@@ -20027,12 +20171,12 @@ function snapshotWorkspaceReadonly(wsPath, label) {
   });
   return {
     path: wsPath,
-    key: path50.basename(wsPath) || wsPath,
+    key: path51.basename(wsPath) || wsPath,
     label,
     sessions,
     counts,
     totalSessions: counts.total,
-    skills: scanSkills2(path50.join(wsPath, ".halo", "skills"))
+    skills: scanSkills2(path51.join(wsPath, ".halo", "skills"))
   };
 }
 function readonlySessionCounts(wsPath, limit) {
@@ -20076,7 +20220,7 @@ function workspaceBirth(wsPath) {
   let b = _birthCache.get(wsPath);
   if (b === void 0) {
     try {
-      b = fs42.statSync(wsPath).birthtimeMs || fs42.statSync(wsPath).ctimeMs;
+      b = fs43.statSync(wsPath).birthtimeMs || fs43.statSync(wsPath).ctimeMs;
     } catch {
       b = 0;
     }
@@ -20088,18 +20232,18 @@ function discoverWorkspaces(registry2) {
   const out = /* @__PURE__ */ new Map();
   const add = (p, label) => {
     try {
-      const resolved = fs42.realpathSync(p);
+      const resolved = fs43.realpathSync(p);
       if (!out.has(resolved))
         out.set(resolved, label);
     } catch {
     }
   };
   for (const { workspacePath } of registry2.list())
-    add(workspacePath, path50.basename(workspacePath));
+    add(workspacePath, path51.basename(workspacePath));
   try {
     const rows = getChannelDb().select().from(channelAccounts).all();
     for (const row of rows)
-      add(row.workspacePath, path50.basename(row.workspacePath));
+      add(row.workspacePath, path51.basename(row.workspacePath));
   } catch {
   }
   return out;
@@ -20118,7 +20262,7 @@ function createShowRoutes(registry2) {
       return a.response;
     const { account } = a;
     const globalView = account.accessLevel === "full" || account.accessLevel === "observer";
-    const targets = globalView ? discoverWorkspaces(registry2) : /* @__PURE__ */ new Map([[account.workspacePath, path50.basename(account.workspacePath)]]);
+    const targets = globalView ? discoverWorkspaces(registry2) : /* @__PURE__ */ new Map([[account.workspacePath, path51.basename(account.workspacePath)]]);
     const workspaces = [];
     for (const [wsPath, label] of targets) {
       try {
@@ -20152,7 +20296,7 @@ function createShowRoutes(registry2) {
     if (!globalView) {
       let allowed = false;
       try {
-        allowed = fs42.realpathSync(wsPath) === fs42.realpathSync(account.workspacePath);
+        allowed = fs43.realpathSync(wsPath) === fs43.realpathSync(account.workspacePath);
       } catch {
       }
       if (!allowed)
@@ -20346,14 +20490,14 @@ var init_commands3 = __esm({
 
 // packages/server/dist/routes/agentcore.js
 import { Hono as Hono13 } from "hono";
-import path51 from "node:path";
-import fs43 from "node:fs";
+import path52 from "node:path";
+import fs44 from "node:fs";
 function haloSessionId(runtimeSessionId) {
   return `agentcore_${runtimeSessionId.replace(/[^a-zA-Z0-9_-]/g, "-").slice(0, 80)}`;
 }
 function userWorkspace(base, runtimeSessionId) {
-  const dir = path51.join(base, "users", runtimeSessionId.replace(/[^a-zA-Z0-9_-]/g, "-").slice(0, 80));
-  fs43.mkdirSync(dir, { recursive: true });
+  const dir = path52.join(base, "users", runtimeSessionId.replace(/[^a-zA-Z0-9_-]/g, "-").slice(0, 80));
+  fs44.mkdirSync(dir, { recursive: true });
   return dir;
 }
 async function ensureSession(sm, workspace, sessionId) {
@@ -20610,8 +20754,8 @@ var init_agentcore = __esm({
 });
 
 // packages/server/dist/ws/file-watcher.js
-import fs44 from "node:fs";
-import path52 from "node:path";
+import fs45 from "node:fs";
+import path53 from "node:path";
 function enqueueNativeOp(op) {
   const result = nativeOpChain.then(op);
   nativeOpChain = result.catch(() => {
@@ -20619,12 +20763,12 @@ function enqueueNativeOp(op) {
   return result;
 }
 function isUnwatchablePath(absPath) {
-  const norm = path52.resolve(absPath);
-  if (norm === "/" || norm === path52.parse(norm).root)
+  const norm = path53.resolve(absPath);
+  if (norm === "/" || norm === path53.parse(norm).root)
     return "filesystem root";
   const banned = ["/System", "/Library", "/private", "/usr", "/bin", "/sbin", "/etc"];
   for (const b of banned) {
-    if (norm === b || norm.startsWith(b + path52.sep))
+    if (norm === b || norm.startsWith(b + path53.sep))
       return `system path ${b}`;
   }
   return null;
@@ -20720,7 +20864,7 @@ var init_file_watcher = __esm({
         }
         let root = workspaceRoot;
         try {
-          root = fs44.realpathSync(workspaceRoot);
+          root = fs45.realpathSync(workspaceRoot);
         } catch {
         }
         if (this.subscription && this.workspaceRoot === root)
@@ -20764,10 +20908,10 @@ var init_file_watcher = __esm({
         const root = this.workspaceRoot;
         if (!root)
           return;
-        const raw = path52.relative(root, absPath);
+        const raw = path53.relative(root, absPath);
         if (!raw || raw.startsWith(".."))
           return;
-        const rel = raw.split(path52.sep).join("/");
+        const rel = raw.split(path53.sep).join("/");
         if (IS_WIN32 && rel.split("/").some((seg) => IGNORED_SEGMENT_SET.has(seg)))
           return;
         let action;
@@ -20778,7 +20922,7 @@ var init_file_watcher = __esm({
         } else {
           let isDir = false;
           try {
-            isDir = fs44.statSync(absPath).isDirectory();
+            isDir = fs45.statSync(absPath).isDirectory();
           } catch {
           }
           action = isDir ? "addDir" : "add";
@@ -20854,8 +20998,8 @@ var init_file_watcher = __esm({
 });
 
 // packages/server/dist/ws/git-dir-watcher.js
-import fs45 from "node:fs";
-import path53 from "node:path";
+import fs46 from "node:fs";
+import path54 from "node:path";
 var GitDirWatcher;
 var init_git_dir_watcher = __esm({
   "packages/server/dist/ws/git-dir-watcher.js"() {
@@ -20879,8 +21023,8 @@ var init_git_dir_watcher = __esm({
           return;
         this.stop();
         this.workspaceRoot = workspaceRoot;
-        const gitDir = path53.join(workspaceRoot, ".git");
-        if (fs45.existsSync(gitDir)) {
+        const gitDir = path54.join(workspaceRoot, ".git");
+        if (fs46.existsSync(gitDir)) {
           this.watchGitDir(gitDir);
         } else {
           this.watchParentForGit(workspaceRoot);
@@ -20889,7 +21033,7 @@ var init_git_dir_watcher = __esm({
       /** Watch the `.git` dir for index/HEAD changes (steady state). */
       watchGitDir(gitDir) {
         try {
-          this.watcher = fs45.watch(gitDir, { persistent: true, recursive: false }, (_eventType, filename) => {
+          this.watcher = fs46.watch(gitDir, { persistent: true, recursive: false }, (_eventType, filename) => {
             this.handleGitEvent(filename);
           });
           this.watcher.on("error", (err) => {
@@ -20908,7 +21052,7 @@ var init_git_dir_watcher = __esm({
        *  Exists solely during the non-repo window; upgraded away on first `.git`. */
       watchParentForGit(workspaceRoot) {
         try {
-          this.watcher = fs45.watch(workspaceRoot, { persistent: true, recursive: false }, (_eventType, filename) => {
+          this.watcher = fs46.watch(workspaceRoot, { persistent: true, recursive: false }, (_eventType, filename) => {
             this.handleParentEvent(filename);
           });
           this.watcher.on("error", (err) => {
@@ -20944,8 +21088,8 @@ var init_git_dir_watcher = __esm({
         const root = this.workspaceRoot;
         if (!root)
           return;
-        const gitDir = path53.join(root, ".git");
-        if (!fs45.existsSync(gitDir))
+        const gitDir = path54.join(root, ".git");
+        if (!fs46.existsSync(gitDir))
           return;
         this.closeWatcher();
         this.watchGitDir(gitDir);
@@ -21261,7 +21405,7 @@ var init_terminal_manager = __esm({
 });
 
 // packages/server/dist/ws/handler.js
-import path54 from "node:path";
+import path55 from "node:path";
 function setupWebSocketHandler(deps) {
   const { wss: wss2, registry: registry2 } = deps;
   const clients = /* @__PURE__ */ new Set();
@@ -21283,7 +21427,7 @@ function setupWebSocketHandler(deps) {
     ackedChatIds.add(id);
   }
   function resolveProjectPath2(projectId) {
-    if (path54.isAbsolute(projectId))
+    if (path55.isAbsolute(projectId))
       return projectId;
     return null;
   }
@@ -21909,11 +22053,11 @@ var init_handler = __esm({
 import Database6 from "better-sqlite3";
 import { drizzle as drizzle4 } from "drizzle-orm/better-sqlite3";
 import { sqliteTable as sqliteTable4, text as text4, integer as integer4 } from "drizzle-orm/sqlite-core";
-import path55 from "node:path";
-import fs46 from "node:fs";
+import path56 from "node:path";
+import fs47 from "node:fs";
 function createCronDb(globalDir2) {
-  fs46.mkdirSync(globalDir2, { recursive: true });
-  const dbPath = path55.join(globalDir2, "cron.db");
+  fs47.mkdirSync(globalDir2, { recursive: true });
+  const dbPath = path56.join(globalDir2, "cron.db");
   const sqlite = new Database6(dbPath);
   sqlite.pragma("journal_mode = WAL");
   sqlite.exec(CREATE_SQL3);
@@ -22111,8 +22255,8 @@ var init_child_env = __esm({
 
 // packages/server/dist/cron/runner.js
 import { spawn as spawn3, execFileSync } from "node:child_process";
-import fs47 from "node:fs";
-import path56 from "node:path";
+import fs48 from "node:fs";
+import path57 from "node:path";
 import { homedir as homedir23 } from "node:os";
 import { Cron } from "croner";
 import { eq as eq11, lt as lt4 } from "drizzle-orm";
@@ -22183,10 +22327,10 @@ function isCronCliProcess(pid, jobId) {
   }
 }
 function logsDir() {
-  return path56.join(homedir23(), ".halo", "global", "logs", "cron");
+  return path57.join(homedir23(), ".halo", "global", "logs", "cron");
 }
 function logPathFor(runId) {
-  return path56.join(logsDir(), `${runId}.log`);
+  return path57.join(logsDir(), `${runId}.log`);
 }
 function newRunId() {
   return `${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}-${Math.random().toString(36).slice(2, 8)}`;
@@ -22237,7 +22381,7 @@ function sweepOrphanRuns(opts) {
   }
 }
 function startCronDaemon() {
-  fs47.mkdirSync(logsDir(), { recursive: true });
+  fs48.mkdirSync(logsDir(), { recursive: true });
   sweepOrphanRuns();
   reloadAll();
   _daemonTimers.push(setInterval(pruneOldLogs, DAY_MS2));
@@ -22394,7 +22538,7 @@ async function runJob(jobId, triggerKind) {
   const runId = newRunId();
   const startedAt = Date.now();
   const logPath = logPathFor(runId);
-  fs47.mkdirSync(logsDir(), { recursive: true });
+  fs48.mkdirSync(logsDir(), { recursive: true });
   if (_inflight.has(jobId)) {
     db.insert(cronRuns).values({
       id: runId,
@@ -22429,7 +22573,7 @@ async function runJob(jobId, triggerKind) {
     }).run();
     broadcast({ type: "cron:run_changed", jobId, runId, status: "running" });
     const targets = parseTargets(job.targets);
-    if (!fs47.existsSync(job.workspacePath)) {
+    if (!fs48.existsSync(job.workspacePath)) {
       finalize(runId, jobId, {
         status: "failed",
         output: null,
@@ -22443,7 +22587,7 @@ async function runJob(jobId, triggerKind) {
     const sessionId = `cron-${job.id}`;
     const args = ["cli", "-a", job.agentId, "-s", sessionId, "-w", job.workspacePath];
     const [spawnBin, spawnArgs] = process.platform === "win32" && cli.endsWith(".cmd") ? ["cmd.exe", ["/c", cli, ...args]] : [cli, args];
-    const teeStream = fs47.createWriteStream(logPath, { flags: "a" });
+    const teeStream = fs48.createWriteStream(logPath, { flags: "a" });
     teeStream.write(`=== ${(/* @__PURE__ */ new Date()).toISOString()} cron run ${runId} job=${jobId} trigger=${triggerKind} ===
 `);
     teeStream.write(`agent=${job.agentId} workspace=${job.workspacePath} schedule=${job.schedule}
@@ -22615,15 +22759,15 @@ function pruneOldRuns(jobId) {
 }
 function pruneOldLogs() {
   const dir = logsDir();
-  if (!fs47.existsSync(dir))
+  if (!fs48.existsSync(dir))
     return;
   const cutoff = Date.now() - LOG_RETENTION_DAYS * DAY_MS2;
-  for (const name of fs47.readdirSync(dir)) {
-    const p = path56.join(dir, name);
+  for (const name of fs48.readdirSync(dir)) {
+    const p = path57.join(dir, name);
     try {
-      const stat = fs47.statSync(p);
+      const stat = fs48.statSync(p);
       if (stat.mtimeMs < cutoff)
-        fs47.rmSync(p, { force: true });
+        fs48.rmSync(p, { force: true });
     } catch {
     }
   }
@@ -22656,7 +22800,7 @@ var init_runner = __esm({
 // packages/server/dist/routes/cron.js
 import { Hono as Hono14 } from "hono";
 import { eq as eq12, desc as desc3, lt as lt5, and as and8 } from "drizzle-orm";
-import fs48 from "node:fs/promises";
+import fs49 from "node:fs/promises";
 import { Cron as Cron2 } from "croner";
 function newJobId() {
   return `cron-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
@@ -22852,7 +22996,7 @@ function createCronRoutes() {
       return c.json({ log: null });
     let log2 = null;
     try {
-      log2 = await fs48.readFile(row.logPath, "utf-8");
+      log2 = await fs49.readFile(row.logPath, "utf-8");
     } catch {
     }
     return c.json({ log: log2 });
@@ -23154,7 +23298,7 @@ var init_ticker = __esm({
 });
 
 // packages/server/dist/evolution/spawn.js
-import path57 from "node:path";
+import path58 from "node:path";
 import { spawn as spawn4 } from "node:child_process";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 var __dirname2, WRAPPER_PATH, realEvoSpawner;
@@ -23162,8 +23306,8 @@ var init_spawn = __esm({
   "packages/server/dist/evolution/spawn.js"() {
     "use strict";
     init_child_env();
-    __dirname2 = path57.dirname(fileURLToPath2(import.meta.url));
-    WRAPPER_PATH = path57.resolve(__dirname2, "evo-wrapper.js");
+    __dirname2 = path58.dirname(fileURLToPath2(import.meta.url));
+    WRAPPER_PATH = path58.resolve(__dirname2, "evo-wrapper.js");
     realEvoSpawner = (mode, id) => {
       const child = spawn4(process.execPath, [WRAPPER_PATH, `--mode=${mode}`, `--id=${id}`], {
         detached: true,
@@ -23950,7 +24094,7 @@ var init_handler2 = __esm({
 // packages/server/dist/routes/telegram.js
 import { Hono as Hono15 } from "hono";
 import { Bot as Bot2 } from "grammy";
-import fs49 from "node:fs";
+import fs50 from "node:fs";
 function createTelegramRoutes(deps) {
   const { db, channel } = deps;
   const app2 = new Hono15();
@@ -23960,7 +24104,7 @@ function createTelegramRoutes(deps) {
         accountId: acc.accountId,
         botUsername: acc.botUsername,
         workspacePath: acc.workspacePath,
-        workspaceMissing: !fs49.existsSync(acc.workspacePath),
+        workspaceMissing: !fs50.existsSync(acc.workspacePath),
         label: acc.label,
         enabled: acc.enabled,
         accessLevel: acc.accessLevel,
@@ -24684,8 +24828,8 @@ var init_cdn = __esm({
 });
 
 // packages/server/dist/channels/wechat/send-media.js
-import fs50 from "node:fs/promises";
-import path58 from "node:path";
+import fs51 from "node:fs/promises";
+import path59 from "node:path";
 function inferKind(filePath) {
   const cls = classifyMedia(filePath);
   if (cls === "image")
@@ -24697,7 +24841,7 @@ function inferKind(filePath) {
 async function sendMediaFile(params) {
   const { baseUrl, token, toUserId, contextToken, filePath } = params;
   const kind = params.kind ?? inferKind(filePath);
-  const plaintext = await fs50.readFile(filePath);
+  const plaintext = await fs51.readFile(filePath);
   const prep = prepareUpload(plaintext);
   console.log(`[wechat] sendMediaFile: path=${filePath} kind=${kind} rawsize=${prep.rawsize} filesize=${prep.filesize}`);
   const mediaType = kind === "image" ? UploadMediaType.IMAGE : kind === "video" ? UploadMediaType.VIDEO : UploadMediaType.FILE;
@@ -24735,7 +24879,7 @@ async function sendMediaFile(params) {
     aesKeyBase64,
     fileSizeCiphertext: prep.filesize,
     fileSize: prep.rawsize,
-    fileName: path58.basename(filePath)
+    fileName: path59.basename(filePath)
   });
   const clientId = `halo-media-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
   const body = {
@@ -24898,8 +25042,8 @@ var init_login = __esm({
 });
 
 // packages/server/dist/channels/wechat/handler.js
-import fs51 from "node:fs";
-import path59 from "node:path";
+import fs52 from "node:fs";
+import path60 from "node:path";
 import QRCode from "qrcode";
 function wxRoute(fromUserId, contextToken) {
   return (prev) => ({
@@ -25288,7 +25432,7 @@ async function handleSlashCommand(args) {
         await reply(login.message);
         return true;
       }
-      const tmpPath = path59.join(tempDir(), `halo-qr-${login.sessionKey}.png`);
+      const tmpPath = path60.join(tempDir(), `halo-qr-${login.sessionKey}.png`);
       await QRCode.toFile(tmpPath, login.qrcodeUrl, { width: 256, margin: 2 });
       await sendMediaFile({
         baseUrl: account.baseUrl,
@@ -25297,7 +25441,7 @@ async function handleSlashCommand(args) {
         contextToken,
         filePath: tmpPath
       });
-      await fs51.promises.unlink(tmpPath).catch(() => {
+      await fs52.promises.unlink(tmpPath).catch(() => {
       });
       await reply(t("wechat.qr_sent", lang, { level, path: account.workspacePath }));
       waitLogin({ sessionKey: login.sessionKey }).then(async (result2) => {
@@ -25377,8 +25521,8 @@ var init_handler3 = __esm({
 
 // packages/server/dist/routes/wechat.js
 import { Hono as Hono16 } from "hono";
-import path60 from "node:path";
-import fs52 from "node:fs";
+import path61 from "node:path";
+import fs53 from "node:fs";
 function createWechatRoutes(deps) {
   const { db, channel } = deps;
   const app2 = new Hono16();
@@ -25387,7 +25531,7 @@ function createWechatRoutes(deps) {
       return {
         ...stripSecrets(acc),
         workspacePath: acc.workspacePath,
-        workspaceMissing: !fs52.existsSync(acc.workspacePath)
+        workspaceMissing: !fs53.existsSync(acc.workspacePath)
       };
     });
     return c.json({ accounts });
@@ -25403,7 +25547,7 @@ function createWechatRoutes(deps) {
       return c.json({ error: "sessionKey required" }, 400);
     if (!body.workspacePath)
       return c.json({ error: "workspacePath required" }, 400);
-    if (!path60.isAbsolute(body.workspacePath))
+    if (!path61.isAbsolute(body.workspacePath))
       return c.json({ error: "workspacePath must be absolute" }, 400);
     const levelError = accessLevelError(body.accessLevel, CHAT_ACCESS_LEVELS);
     if (levelError)
@@ -25607,14 +25751,14 @@ function createWebChannel(deps) {
     return findActiveSessionId(sm, accountId, prefix, activeOverrides2, "full") ?? void 0;
   }
   function resolveWorkspace(account, override) {
-    let path65 = account.workspacePath;
+    let path66 = account.workspacePath;
     if (override && override !== account.workspacePath) {
       if (account.accessLevel !== "full") {
         return { ok: false, error: "workspace override requires a full-access token" };
       }
-      path65 = override;
+      path66 = override;
     }
-    const resolved = resolveAccountWorkspace({ ...account, workspacePath: path65 });
+    const resolved = resolveAccountWorkspace({ ...account, workspacePath: path66 });
     if (!resolved)
       return { ok: false, error: "workspace not found" };
     return { ok: true, path: resolved };
@@ -25997,7 +26141,7 @@ var init_handler4 = __esm({
 import { Hono as Hono17 } from "hono";
 import { streamSSE } from "hono/streaming";
 import crypto4 from "node:crypto";
-import fs53 from "node:fs";
+import fs54 from "node:fs";
 function createWebRoutes(deps) {
   const { db, channel } = deps;
   const app2 = new Hono17();
@@ -26007,7 +26151,7 @@ function createWebRoutes(deps) {
         accountId: acc.accountId,
         token: acc.token,
         workspacePath: acc.workspacePath,
-        workspaceMissing: !fs53.existsSync(acc.workspacePath),
+        workspaceMissing: !fs54.existsSync(acc.workspacePath),
         label: acc.label,
         enabled: acc.enabled,
         accessLevel: acc.accessLevel,
@@ -26153,27 +26297,27 @@ function createWebRoutes(deps) {
     const filePath = c.req.query("path");
     if (!filePath)
       return c.json({ error: "path required" }, 400);
-    const path65 = await import("node:path");
-    const resolved = path65.default.resolve(account.workspacePath, filePath);
-    const root = path65.default.resolve(account.workspacePath);
-    if (resolved !== root && !resolved.startsWith(root + path65.default.sep)) {
+    const path66 = await import("node:path");
+    const resolved = path66.default.resolve(account.workspacePath, filePath);
+    const root = path66.default.resolve(account.workspacePath);
+    if (resolved !== root && !resolved.startsWith(root + path66.default.sep)) {
       return c.json({ error: "path traversal not allowed" }, 403);
     }
     let real;
     let realRoot;
     try {
-      real = fs53.realpathSync(resolved);
-      realRoot = fs53.realpathSync(root);
+      real = fs54.realpathSync(resolved);
+      realRoot = fs54.realpathSync(root);
     } catch {
       return c.json({ error: "file not found" }, 404);
     }
-    if (real !== realRoot && !real.startsWith(realRoot + path65.default.sep)) {
+    if (real !== realRoot && !real.startsWith(realRoot + path66.default.sep)) {
       return c.json({ error: "path traversal not allowed" }, 403);
     }
-    const stat = fs53.statSync(real);
+    const stat = fs54.statSync(real);
     if (stat.isDirectory())
       return c.json({ error: "cannot serve directory" }, 400);
-    const ext = path65.default.extname(real).toLowerCase();
+    const ext = path66.default.extname(real).toLowerCase();
     const nonImageMimes = {
       ".mp4": "video/mp4",
       ".webm": "video/webm",
@@ -26181,8 +26325,8 @@ function createWebRoutes(deps) {
       ".txt": "text/plain"
     };
     const contentType = imageMimeFromExt(ext) || nonImageMimes[ext] || "application/octet-stream";
-    const fileName = path65.default.basename(resolved);
-    const data = fs53.readFileSync(real);
+    const fileName = path66.default.basename(resolved);
+    const data = fs54.readFileSync(real);
     c.header("content-type", contentType);
     c.header("content-disposition", `inline; filename="${fileName}"`);
     return c.body(data);
@@ -26523,10 +26667,10 @@ async function authTest(botToken) {
   return slackPost("auth.test", botToken, {});
 }
 async function uploadFile(args) {
-  const fs58 = await import("node:fs");
-  const path65 = await import("node:path");
-  const filename = args.filename ?? path65.basename(args.filePath);
-  const stat = fs58.statSync(args.filePath);
+  const fs59 = await import("node:fs");
+  const path66 = await import("node:path");
+  const filename = args.filename ?? path66.basename(args.filePath);
+  const stat = fs59.statSync(args.filePath);
   if (!stat.isFile())
     throw new Error(`[slack:uploadFile] not a regular file: ${args.filePath}`);
   const length = stat.size;
@@ -26544,7 +26688,7 @@ async function uploadFile(args) {
   if (step1Parsed.ok === false || !step1Parsed.upload_url || !step1Parsed.file_id) {
     throw new Error(`[slack:files.getUploadURLExternal] ${step1Parsed.error ?? "unknown"}`);
   }
-  const buf = fs58.readFileSync(args.filePath);
+  const buf = fs59.readFileSync(args.filePath);
   const step2 = await fetch(step1Parsed.upload_url, {
     method: "POST",
     body: buf
@@ -26689,7 +26833,7 @@ var init_api2 = __esm({
 });
 
 // packages/server/dist/channels/slack/handler.js
-import path61 from "node:path";
+import path62 from "node:path";
 import { WebSocket } from "ws";
 function slashToBang(text5, commandNames) {
   if (commandNames.length === 0)
@@ -26794,7 +26938,7 @@ function startSlackChannel(deps) {
             const route = bridge.getRoute(sessionId);
             if (!account || !route)
               return;
-            const resolved = path61.resolve(filePath);
+            const resolved = path62.resolve(filePath);
             if (!isMediaPathAllowed(resolved, account.workspacePath)) {
               console.log(`[slack] sendMedia blocked: ${filePath} not under workspace`);
               return;
@@ -26813,7 +26957,7 @@ function startSlackChannel(deps) {
                 channel: route.channelId,
                 threadTs: route.replyTs,
                 text: t("handler.upload_failed", getLang(account), {
-                  name: path61.basename(filePath),
+                  name: path62.basename(filePath),
                   error: err instanceof Error ? err.message : String(err)
                 })
               }).catch(() => {
@@ -27070,7 +27214,7 @@ var init_handler5 = __esm({
 
 // packages/server/dist/routes/slack.js
 import { Hono as Hono18 } from "hono";
-import fs54 from "node:fs";
+import fs55 from "node:fs";
 function createSlackRoutes(deps) {
   const { db, channel } = deps;
   const app2 = new Hono18();
@@ -27093,7 +27237,7 @@ function createSlackRoutes(deps) {
       botUserId: a.botUserId,
       teamId: a.teamId,
       workspacePath: a.workspacePath,
-      workspaceMissing: !fs54.existsSync(a.workspacePath),
+      workspaceMissing: !fs55.existsSync(a.workspacePath),
       label: a.label,
       enabled: a.enabled,
       accessLevel: a.accessLevel,
@@ -27625,10 +27769,10 @@ async function replyMessage(args) {
   return { message_id: parsed.data?.message_id ?? "" };
 }
 async function uploadImage(args) {
-  const fs58 = await import("node:fs");
-  const path65 = await import("node:path");
-  const buf = fs58.readFileSync(args.filePath);
-  const filename = path65.basename(args.filePath);
+  const fs59 = await import("node:fs");
+  const path66 = await import("node:path");
+  const buf = fs59.readFileSync(args.filePath);
+  const filename = path66.basename(args.filePath);
   const send = async (token2) => {
     const form = new FormData();
     form.append("image_type", "message");
@@ -27659,10 +27803,10 @@ async function uploadImage(args) {
   return { imageKey: parsed.data.image_key };
 }
 async function uploadFile2(args) {
-  const fs58 = await import("node:fs");
-  const path65 = await import("node:path");
-  const buf = fs58.readFileSync(args.filePath);
-  const filename = args.filename ?? path65.basename(args.filePath);
+  const fs59 = await import("node:fs");
+  const path66 = await import("node:path");
+  const buf = fs59.readFileSync(args.filePath);
+  const filename = args.filename ?? path66.basename(args.filePath);
   const send = async (token2) => {
     const form = new FormData();
     form.append("file_type", args.fileType);
@@ -27768,7 +27912,7 @@ var init_api3 = __esm({
 });
 
 // packages/server/dist/channels/feishu/handler.js
-import path62 from "node:path";
+import path63 from "node:path";
 import * as Lark from "@larksuiteoapi/node-sdk";
 function buildSessionPrefixForThread2(chatId, rootId) {
   return sessionPrefix("feishu", `${chatId}:${rootId}`);
@@ -27891,7 +28035,7 @@ function startFeishuChannel(deps) {
             const route = bridge.getRoute(sessionId);
             if (!account || !route)
               return;
-            const resolved = path62.resolve(filePath);
+            const resolved = path63.resolve(filePath);
             if (!isMediaPathAllowed(resolved, account.workspacePath)) {
               console.log(`[feishu] sendMedia blocked: ${filePath} not under workspace`);
               return;
@@ -27904,7 +28048,7 @@ function startFeishuChannel(deps) {
                 account,
                 ...route,
                 text: t("handler.upload_failed", getLang(account), {
-                  name: path62.basename(filePath),
+                  name: path63.basename(filePath),
                   error: err instanceof Error ? err.message : String(err)
                 })
               }).catch(() => {
@@ -28068,7 +28212,7 @@ async function replyToInbound(args) {
 async function sendFeishuMedia(args) {
   const { account, inboundMessageId, isP2P, chatId, filePath } = args;
   const cls = classifyMedia(filePath);
-  const ext = path62.extname(filePath).toLowerCase();
+  const ext = path63.extname(filePath).toLowerCase();
   if (cls === "image") {
     const { imageKey } = await uploadImage({ appId: account.appId, appSecret: account.appSecret, filePath });
     await replyToInboundRaw({
@@ -28194,7 +28338,7 @@ var init_handler6 = __esm({
 
 // packages/server/dist/routes/feishu.js
 import { Hono as Hono19 } from "hono";
-import fs55 from "node:fs";
+import fs56 from "node:fs";
 function createFeishuRoutes(deps) {
   const { db, channel } = deps;
   const app2 = new Hono19();
@@ -28218,7 +28362,7 @@ function createFeishuRoutes(deps) {
       botOpenId: a.botOpenId,
       hasEncryptKey: !!a.encryptKey,
       workspacePath: a.workspacePath,
-      workspaceMissing: !fs55.existsSync(a.workspacePath),
+      workspaceMissing: !fs56.existsSync(a.workspacePath),
       label: a.label,
       enabled: a.enabled,
       accessLevel: a.accessLevel,
@@ -28606,14 +28750,14 @@ function passwordStrengthError(pw) {
 }
 function authMiddleware() {
   return async (c, next) => {
-    const path65 = c.req.path;
-    if (PUBLIC_PATHS.some((p) => path65 === p || path65.startsWith(p + "?"))) {
+    const path66 = c.req.path;
+    if (PUBLIC_PATHS.some((p) => path66 === p || path66.startsWith(p + "?"))) {
       return next();
     }
     const token = getCookie(c, COOKIE_NAME);
     const payload = validateToken(token);
     if (!payload) {
-      if (!path65.startsWith("/api/")) {
+      if (!path66.startsWith("/api/")) {
         return next();
       }
       return c.json({ error: "Unauthorized" }, 401);
@@ -28648,20 +28792,21 @@ var init_auth = __esm({
 var dist_exports = {};
 import { Hono as Hono21 } from "hono";
 import { cors } from "hono/cors";
+import { compress } from "hono/compress";
 import { serve } from "@hono/node-server";
 import { serveStatic } from "@hono/node-server/serve-static";
 import { WebSocketServer } from "ws";
-import path63 from "node:path";
-import fs56 from "node:fs";
-import { spawnSync as spawnSync3 } from "node:child_process";
+import path64 from "node:path";
+import fs57 from "node:fs";
+import { spawnSync as spawnSync4 } from "node:child_process";
 import { homedir as homedir24 } from "node:os";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 function findProjectRoot() {
   let dir = process.cwd();
   for (let i = 0; i < 32; i++) {
-    if (fs56.existsSync(path63.join(dir, "pnpm-workspace.yaml")))
+    if (fs57.existsSync(path64.join(dir, "pnpm-workspace.yaml")))
       return dir;
-    const parent = path63.dirname(dir);
+    const parent = path64.dirname(dir);
     if (parent === dir)
       break;
     dir = parent;
@@ -28670,15 +28815,15 @@ function findProjectRoot() {
   return process.cwd();
 }
 function acquireSingleInstanceLock(lockFile) {
-  fs56.mkdirSync(path63.dirname(lockFile), { recursive: true });
-  const fd = fs56.openSync(lockFile, fs56.constants.O_RDWR | fs56.constants.O_CREAT, 420);
-  const result = spawnSync3("flock", ["-n", "3"], {
+  fs57.mkdirSync(path64.dirname(lockFile), { recursive: true });
+  const fd = fs57.openSync(lockFile, fs57.constants.O_RDWR | fs57.constants.O_CREAT, 420);
+  const result = spawnSync4("flock", ["-n", "3"], {
     stdio: ["ignore", "ignore", "ignore", fd]
   });
   if (result.error) {
     const content = readLockPid(fd);
     if (content > 0 && isProcessAlive(content)) {
-      fs56.closeSync(fd);
+      fs57.closeSync(fd);
       console.error(`[Server] another halo server is already running (pid ${content}). kill it first.`);
       process.exit(1);
     }
@@ -28687,19 +28832,19 @@ function acquireSingleInstanceLock(lockFile) {
     if (content > 0 && !isProcessAlive(content)) {
       console.warn(`[Server] removing stale server.lock (pid ${content} not running)`);
     } else {
-      fs56.closeSync(fd);
+      fs57.closeSync(fd);
       console.error(`[Server] another halo server is already running${content > 0 ? ` (pid ${content})` : ""}. kill it first.`);
       process.exit(1);
     }
   }
-  fs56.ftruncateSync(fd);
-  fs56.writeSync(fd, String(process.pid));
-  fs56.fsyncSync(fd);
+  fs57.ftruncateSync(fd);
+  fs57.writeSync(fd, String(process.pid));
+  fs57.fsyncSync(fd);
 }
 function readLockPid(fd) {
   try {
     const buf = Buffer.alloc(32);
-    const n = fs56.readSync(fd, buf, 0, 32, 0);
+    const n = fs57.readSync(fd, buf, 0, 32, 0);
     return parseInt(buf.subarray(0, n).toString("utf-8").trim(), 10) || 0;
   } catch {
     return 0;
@@ -28708,7 +28853,7 @@ function readLockPid(fd) {
 function isProcessAlive(pid) {
   if (process.platform === "win32") {
     try {
-      const out = spawnSync3("tasklist", ["/FI", `PID eq ${pid}`, "/NH", "/FO", "CSV"], {
+      const out = spawnSync4("tasklist", ["/FI", `PID eq ${pid}`, "/NH", "/FO", "CSV"], {
         encoding: "utf-8",
         windowsHide: true
       });
@@ -28727,16 +28872,16 @@ function isProcessAlive(pid) {
   }
 }
 function readGitSha() {
-  if (!fs56.existsSync(path63.join(PROJECT_ROOT, "pnpm-workspace.yaml")) || !fs56.existsSync(path63.join(PROJECT_ROOT, ".git")))
+  if (!fs57.existsSync(path64.join(PROJECT_ROOT, "pnpm-workspace.yaml")) || !fs57.existsSync(path64.join(PROJECT_ROOT, ".git")))
     return null;
   try {
-    const rev = spawnSync3("git", ["rev-parse", "--short", "HEAD"], { cwd: PROJECT_ROOT, encoding: "utf-8" });
+    const rev = spawnSync4("git", ["rev-parse", "--short", "HEAD"], { cwd: PROJECT_ROOT, encoding: "utf-8" });
     if (rev.status !== 0)
       return null;
     const sha = rev.stdout.trim();
     if (!sha)
       return null;
-    const dirty = spawnSync3("git", ["status", "--porcelain"], { cwd: PROJECT_ROOT, encoding: "utf-8" }).stdout.trim().length > 0;
+    const dirty = spawnSync4("git", ["status", "--porcelain"], { cwd: PROJECT_ROOT, encoding: "utf-8" }).stdout.trim().length > 0;
     return dirty ? `${sha}-dirty` : sha;
   } catch {
     return null;
@@ -28744,14 +28889,14 @@ function readGitSha() {
 }
 function resolveFrontendDir() {
   if (process.env.HALO_FRONTEND_DIR)
-    return path63.resolve(process.env.HALO_FRONTEND_DIR);
-  const bundled = path63.resolve(__dirname3, "..", "admin-out");
-  if (fs56.existsSync(path63.join(bundled, "index.html")))
+    return path64.resolve(process.env.HALO_FRONTEND_DIR);
+  const bundled = path64.resolve(__dirname3, "..", "admin-out");
+  if (fs57.existsSync(path64.join(bundled, "index.html")))
     return bundled;
-  const sibling = path63.resolve(__dirname3, "..", "..", "admin", "out");
-  if (fs56.existsSync(path63.join(sibling, "index.html")))
+  const sibling = path64.resolve(__dirname3, "..", "..", "admin", "out");
+  if (fs57.existsSync(path64.join(sibling, "index.html")))
     return sibling;
-  return path63.resolve(PROJECT_ROOT, "packages", "admin", "out");
+  return path64.resolve(PROJECT_ROOT, "packages", "admin", "out");
 }
 async function gracefulShutdown(signal) {
   console.log(`[Server] Received ${signal}, shutting down gracefully...`);
@@ -28807,13 +28952,13 @@ var init_dist2 = __esm({
     init_sandbox();
     init_init();
     init_git_ssh();
-    __dirname3 = path63.dirname(fileURLToPath3(import.meta.url));
+    __dirname3 = path64.dirname(fileURLToPath3(import.meta.url));
     PORT = config.server.port;
-    HALO_VERSION = "1.1.0";
+    HALO_VERSION = "1.1.2";
     PROJECT_ROOT = findProjectRoot();
-    HALO_HOME4 = path63.join(homedir24(), ".halo");
+    HALO_HOME4 = path64.join(homedir24(), ".halo");
     GIT_SHA = readGitSha();
-    if (!fs56.existsSync(path63.join(HALO_HOME4, "global", ".template-version"))) {
+    if (!fs57.existsSync(path64.join(HALO_HOME4, "global", ".template-version"))) {
       process.stderr.write("\x1B[31m[Server] ~/.halo/global/ not initialized. Run `halo setup` first.\x1B[0m\n");
       process.exit(1);
     }
@@ -28834,7 +28979,7 @@ var init_dist2 = __esm({
       process.exit(1);
     }
     if (!AGENTCORE)
-      acquireSingleInstanceLock(path63.join(HALO_HOME4, "global", "server.lock"));
+      acquireSingleInstanceLock(path64.join(HALO_HOME4, "global", "server.lock"));
     {
       const declared = new Set(commandRegistry.listDescriptors().filter((d) => d.source === "builtin").map((d) => d.slashName));
       const dispatched = new Set(DISPATCH_COMMANDS);
@@ -28873,6 +29018,7 @@ var init_dist2 = __esm({
       maxAge: 86400,
       credentials: allowlist.length > 0
     }));
+    app.use("/*", compress({ threshold: 1024 }));
     app.use("/api/*", authMiddleware());
     authRoutes = createAuthRoutes();
     app.route("/api", authRoutes);
@@ -28902,10 +29048,10 @@ var init_dist2 = __esm({
     app.route("/api", evolutionRoutes);
     cronRoutes = createCronRoutes();
     app.route("/api", cronRoutes);
-    channelDb = createChannelDb(path63.join(HALO_HOME4, "secrets"));
+    channelDb = createChannelDb(path64.join(HALO_HOME4, "secrets"));
     setChannelDb(channelDb);
-    setEvoDb(createEvoDb(path63.join(HALO_HOME4, "global")));
-    setCronDb(createCronDb(path63.join(HALO_HOME4, "global")));
+    setEvoDb(createEvoDb(path64.join(HALO_HOME4, "global")));
+    setCronDb(createCronDb(path64.join(HALO_HOME4, "global")));
     setEvoSpawner(realEvoSpawner);
     if (!AGENTCORE) {
       startEvoTicker();
@@ -28931,11 +29077,11 @@ var init_dist2 = __esm({
       console.log(`[Server] AgentCore runtime mode \u2014 workspace: ${config.server.agentcoreWorkspace}`);
     }
     FRONTEND_DIR = resolveFrontendDir();
-    app.use("/*", serveStatic({ root: path63.relative(process.cwd(), FRONTEND_DIR) }));
+    app.use("/*", serveStatic({ root: path64.relative(process.cwd(), FRONTEND_DIR) }));
     app.get("/*", (c) => {
-      const indexPath = path63.join(FRONTEND_DIR, "index.html");
+      const indexPath = path64.join(FRONTEND_DIR, "index.html");
       try {
-        const html = fs56.readFileSync(indexPath, "utf-8");
+        const html = fs57.readFileSync(indexPath, "utf-8");
         return c.html(html);
       } catch {
         return c.text("Frontend not built. Run: cd packages/admin && npx next build", 503);
@@ -29706,11 +29852,11 @@ process.emitWarning = (warning, ...args) => {
 
 // packages/cli/src/index.ts
 init_server_supervisor();
-import path64 from "node:path";
-import fs57 from "node:fs";
+import path65 from "node:path";
+import fs58 from "node:fs";
 import { homedir as homedir25 } from "node:os";
 import { parseArgs as parseArgs2 } from "node:util";
-var VERSION = "1.1.0";
+var VERSION = "1.1.2";
 var HELP_TOP = `Usage: halo <command> [options]
 
 Commands:
@@ -29967,8 +30113,8 @@ async function cmdSetup(argv = []) {
   const { buildBindProviderPlan: buildBindProviderPlan2, KEEP_CURRENT: KEEP_CURRENT2, AWS_CHAIN_PROVIDER: AWS_CHAIN_PROVIDER2 } = await Promise.resolve().then(() => (init_setup_bind_provider(), setup_bind_provider_exports));
   const { promptText: promptText2, promptPassword: promptPassword2, promptSelect: promptSelect2, promptMultiSelect: promptMultiSelect2 } = await Promise.resolve().then(() => (init_setup_prompts(), setup_prompts_exports));
   const nonInteractive = argv.includes("--non-interactive") || argv.includes("-y");
-  const haloHome2 = path64.join(homedir25(), ".halo");
-  const globalDir2 = path64.join(haloHome2, "global");
+  const haloHome2 = path65.join(homedir25(), ".halo");
+  const globalDir2 = path65.join(haloHome2, "global");
   ensureHaloHome2(haloHome2);
   process.stderr.write(`[setup] ${haloHome2}/ ready
 `);
@@ -30271,10 +30417,10 @@ async function cmdUpgrade() {
     );
     process.exit(1);
   }
-  const { spawnSync: spawnSync4 } = await import("node:child_process");
+  const { spawnSync: spawnSync5 } = await import("node:child_process");
   process.stderr.write(`Checking npm for the latest ${PKG}\u2026
 `);
-  const view = spawnSync4("npm", ["view", PKG, "version"], { encoding: "utf-8" });
+  const view = spawnSync5("npm", ["view", PKG, "version"], { encoding: "utf-8" });
   if (view.error || view.status !== 0) {
     const err = view.error?.message ?? view.stderr?.trim() ?? `exit ${view.status}`;
     process.stderr.write(`halo: \`npm view\` failed \u2014 ${err}
@@ -30292,10 +30438,40 @@ async function cmdUpgrade() {
 `);
     return;
   }
+  const { ALLOW_SCRIPTS: ALLOW_SCRIPTS2, verifyNativeModules: verifyNativeModules2 } = await Promise.resolve().then(() => (init_upgrade_verify(), upgrade_verify_exports));
   process.stderr.write(`Upgrading ${installed} \u2192 ${latest}\u2026
 `);
-  const install = spawnSync4("npm", ["install", "-g", `${PKG}@latest`], { stdio: "inherit" });
+  const install = spawnSync5(
+    "npm",
+    ["install", "-g", `--allow-scripts=${ALLOW_SCRIPTS2}`, `${PKG}@latest`],
+    { stdio: "inherit" }
+  );
   if (install.status === 0) {
+    const npmRoot = spawnSync5("npm", ["root", "-g"], {
+      encoding: "utf-8",
+      shell: process.platform === "win32"
+    });
+    const rootDir = npmRoot.status === 0 ? npmRoot.stdout.trim() : "";
+    if (!rootDir) {
+      process.stderr.write(`halo: \`npm root -g\` failed \u2014 cannot verify the new install
+`);
+      process.exit(1);
+    }
+    const broken = verifyNativeModules2(path65.join(rootDir, PKG));
+    if (broken.length > 0) {
+      process.stderr.write(
+        `
+halo: upgrade installed, but native module(s) failed to load: ${broken.join(", ")}
+This usually means npm blocked the module's install scripts (npm 12+ allowScripts policy \u2014 check \`npm -v\`).
+
+Fix \u2014 reinstall with the scripts allowed:
+  sudo npm install -g --allow-scripts=${ALLOW_SCRIPTS2} ${PKG}@latest
+Or persist the allowance first, then reinstall:
+  npm config set allow-scripts=${ALLOW_SCRIPTS2} --location=user
+`
+      );
+      process.exit(1);
+    }
     process.stderr.write(
       `
 Upgraded to ${latest}. Run \`halo server restart\` (or your service manager's restart) to pick up the new templates.
@@ -30312,7 +30488,7 @@ halo: upgrade failed (npm exited ${install.status}). ${hint}
 async function cmdAgents(flags) {
   const { initRuntime: initRuntime2, listAgents: listAgents2 } = await Promise.resolve().then(() => (init_harness(), harness_exports));
   await initRuntime2();
-  const workspace = path64.resolve(flags.workspace ?? process.cwd());
+  const workspace = path65.resolve(flags.workspace ?? process.cwd());
   const agents = await listAgents2(workspace);
   if (agents.length === 0) {
     process.stderr.write("No agents found.\n");
@@ -30328,7 +30504,7 @@ async function cmdAgents(flags) {
 async function cmdSessions(flags) {
   const { initRuntime: initRuntime2, listSessions: listSessions2 } = await Promise.resolve().then(() => (init_harness(), harness_exports));
   await initRuntime2();
-  const workspace = path64.resolve(flags.workspace ?? process.cwd());
+  const workspace = path65.resolve(flags.workspace ?? process.cwd());
   const sessions = listSessions2(workspace);
   if (sessions.length === 0) {
     process.stderr.write("No sessions found.\n");
@@ -30441,11 +30617,11 @@ ${stdinContent}` : stdinContent;
     harness.destroy();
   }
 }
-var SERVER_LOCK_PATH = path64.join(homedir25(), ".halo", "global", "server.lock");
-var SERVER_LOG_PATH = path64.join(homedir25(), ".halo", "logs", "server.log");
+var SERVER_LOCK_PATH = path65.join(homedir25(), ".halo", "global", "server.lock");
+var SERVER_LOG_PATH = path65.join(homedir25(), ".halo", "logs", "server.log");
 function readServerPid() {
   try {
-    const txt = fs57.readFileSync(SERVER_LOCK_PATH, "utf-8").trim();
+    const txt = fs58.readFileSync(SERVER_LOCK_PATH, "utf-8").trim();
     const n = parseInt(txt, 10);
     return Number.isFinite(n) && n > 0 ? n : null;
   } catch {
@@ -30532,8 +30708,8 @@ async function cmdServerStart(argv, _unused) {
     return;
   }
   const { spawn: spawn5 } = await import("node:child_process");
-  fs57.mkdirSync(path64.dirname(SERVER_LOG_PATH), { recursive: true });
-  const out = fs57.openSync(SERVER_LOG_PATH, "a");
+  fs58.mkdirSync(path65.dirname(SERVER_LOG_PATH), { recursive: true });
+  const out = fs58.openSync(SERVER_LOG_PATH, "a");
   const child = spawn5(process.argv[0], [process.argv[1], "server", "start"], {
     detached: true,
     stdio: ["ignore", out, out],
@@ -30634,7 +30810,7 @@ async function cmdServerLogs(argv) {
       lines: { type: "string", short: "n" }
     }
   });
-  if (!fs57.existsSync(SERVER_LOG_PATH)) {
+  if (!fs58.existsSync(SERVER_LOG_PATH)) {
     process.stderr.write(`No log file at ${SERVER_LOG_PATH}
 `);
     return;
@@ -30652,7 +30828,7 @@ function exitMissingSetup() {
   process.exit(1);
 }
 function isHaloHomeReady() {
-  return fs57.existsSync(path64.join(homedir25(), ".halo", "global", ".template-version"));
+  return fs58.existsSync(path65.join(homedir25(), ".halo", "global", ".template-version"));
 }
 async function main2() {
   const argv = process.argv.slice(2);