@turmind/halo 1.1.1 → 1.1.3

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);
@@ -2368,7 +2400,7 @@ var init_init = __esm({
       path8.resolve(__dirname, "..", "bundled-docs"),
       path8.resolve(__dirname, "..", "..", "..", ".halo", "docs")
     ];
-    TEMPLATE_VERSION = 49;
+    TEMPLATE_VERSION = 50;
     VERSION_FILE = ".template-version";
     SKIP_NAMES = /* @__PURE__ */ new Set([".DS_Store", "schema.sql", "__pycache__", ".pytest_cache"]);
     BUILTIN_AGENT_IDS = /* @__PURE__ */ new Set([
@@ -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 = "";
           }
@@ -9121,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 };
       }
@@ -14044,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";
@@ -14060,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 = [];
@@ -14074,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) {
@@ -14096,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(`
@@ -14118,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}
@@ -14390,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);
     }
@@ -14408,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 {
   }
 }
@@ -14417,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;
   }
 });
@@ -14528,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);
@@ -14558,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 };
   }
@@ -14580,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 });
@@ -14609,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"() {
@@ -16083,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 = [];
@@ -16107,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))
@@ -16133,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;
@@ -16148,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;
@@ -16163,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 === "..")
@@ -16183,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();
@@ -16203,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;
@@ -16216,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 [];
     }
@@ -16231,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,
@@ -16264,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);
         }
@@ -16276,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
       });
@@ -16309,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;
         }
@@ -16319,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 });
               }
@@ -16331,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 });
             }
@@ -16375,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,
@@ -16411,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);
@@ -16435,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);
@@ -16464,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);
@@ -16487,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);
@@ -16512,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);
@@ -16550,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)}"`;
@@ -16618,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")
@@ -16641,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);
         }
@@ -16651,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,
@@ -16678,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));
@@ -16696,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 });
@@ -16707,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);
     }
@@ -16731,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";
@@ -16764,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);
@@ -16848,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 {
@@ -17056,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 {
@@ -17074,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 }) {
@@ -17093,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 {
@@ -17109,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;
@@ -17121,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}`);
@@ -17132,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;
@@ -17148,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;
@@ -17162,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;
@@ -17190,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.");
@@ -17201,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"],
@@ -17219,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" };
@@ -17232,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;
@@ -17289,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();
@@ -17315,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
@@ -17329,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" });
 }
@@ -17646,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));
@@ -17724,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() {
@@ -17736,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);
@@ -17821,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,
@@ -17864,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() {
@@ -17888,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));
@@ -17920,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");
@@ -17960,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);
@@ -17983,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 } });
   });
@@ -18005,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);
     }
@@ -18020,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) => {
@@ -18052,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) });
@@ -18085,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) };
@@ -18095,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");
@@ -18109,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: [] });
     }
@@ -18118,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,
@@ -18147,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);
@@ -18183,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) => {
@@ -18195,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 {
@@ -18216,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);
@@ -18236,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();
   }
@@ -18244,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() {
@@ -18264,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);
@@ -18300,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 `---
@@ -18317,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 });
@@ -18361,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));
@@ -18384,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);
@@ -18409,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 });
   });
@@ -18443,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 {
   }
 }
@@ -18580,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 });
         }
       }
@@ -18596,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);
@@ -18646,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);
@@ -18666,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;
     }
@@ -18695,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;
     }
@@ -18721,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 {
         }
       }
@@ -18761,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);
@@ -18771,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)) {
@@ -18797,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}`);
@@ -18924,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) => {
@@ -18990,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");
@@ -19504,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);
@@ -19559,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;
@@ -19576,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;
@@ -19878,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 {
@@ -19902,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;
@@ -19988,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,
@@ -20002,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 });
@@ -20038,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);
@@ -20086,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) {
@@ -20135,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;
     }
@@ -20147,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;
@@ -20177,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 {
@@ -20211,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)
@@ -20405,16 +20490,77 @@ 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 sanitizeRuntimeId(runtimeSessionId) {
+  return runtimeSessionId.replace(/[^a-zA-Z0-9_-]/g, "-").slice(0, 80);
+}
 function haloSessionId(runtimeSessionId) {
-  return `agentcore_${runtimeSessionId.replace(/[^a-zA-Z0-9_-]/g, "-").slice(0, 80)}`;
+  return `agentcore_${sanitizeRuntimeId(runtimeSessionId)}`;
 }
 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", sanitizeRuntimeId(runtimeSessionId));
+  fs44.mkdirSync(dir, { recursive: true });
   return dir;
 }
+function acceptChunk(uploads, msg) {
+  const uploadId = msg.uploadId;
+  const seq = msg.seq;
+  const total = msg.total;
+  const mimeType = msg.mimeType;
+  const data = msg.data;
+  if (typeof uploadId !== "string" || !uploadId || uploadId.length > 64)
+    return "image_chunk: uploadId must be a non-empty string (\u226464 chars)";
+  if (typeof seq !== "number" || !Number.isInteger(seq) || seq < 0)
+    return "image_chunk: seq must be a non-negative integer";
+  if (typeof total !== "number" || !Number.isInteger(total) || total < 1 || total > MAX_CHUNKS_PER_UPLOAD)
+    return `image_chunk: total must be 1..${MAX_CHUNKS_PER_UPLOAD}`;
+  if (typeof mimeType !== "string" || typeof data !== "string" || !data)
+    return "image_chunk: string mimeType and non-empty string data required";
+  if (seq >= total)
+    return "image_chunk: seq out of range";
+  let up = uploads.get(uploadId);
+  if (!up) {
+    if (uploads.size >= MAX_PENDING_UPLOADS)
+      return `too many pending uploads (max ${MAX_PENDING_UPLOADS} per connection)`;
+    up = { chunks: new Array(total), received: 0, mimeType, size: 0 };
+    uploads.set(uploadId, up);
+  }
+  if (up.chunks.length !== total)
+    return "image_chunk: total mismatch across chunks of one uploadId";
+  if (up.chunks[seq] !== void 0)
+    return null;
+  if (up.size + data.length > MAX_IMAGE_BASE64_LENGTH) {
+    uploads.delete(uploadId);
+    return "image too large (max 8MB base64 per image)";
+  }
+  up.chunks[seq] = data;
+  up.received++;
+  up.size += data.length;
+  return null;
+}
+function claimImageRefs(uploads, raw) {
+  if (raw === void 0)
+    return [];
+  if (!Array.isArray(raw))
+    return { error: "imageRefs must be an array" };
+  if (raw.length > MAX_IMAGES_PER_MESSAGE)
+    return { error: `too many images (max ${MAX_IMAGES_PER_MESSAGE} per message)` };
+  const images = [];
+  for (const ref of raw) {
+    if (typeof ref !== "string")
+      return { error: "imageRefs entries must be strings" };
+    const up = uploads.get(ref);
+    if (!up)
+      return { error: `unknown uploadId: ${ref}` };
+    if (up.received !== up.chunks.length)
+      return { error: `upload ${ref} incomplete (${up.received}/${up.chunks.length} chunks)` };
+    images.push({ data: up.chunks.join(""), mimeType: up.mimeType });
+  }
+  for (const ref of raw)
+    uploads.delete(ref);
+  return images;
+}
 async function ensureSession(sm, workspace, sessionId) {
   if (sm.getSessionById(sessionId))
     return;
@@ -20553,6 +20699,7 @@ function setupAgentCoreWebSocket(deps) {
       ready ??= ensureSession(sm, userWs, sessionId).then(() => attachListener());
       return ready;
     };
+    const uploads = /* @__PURE__ */ new Map();
     ws.on("message", (raw) => {
       let msg;
       try {
@@ -20578,8 +20725,20 @@ function setupAgentCoreWebSocket(deps) {
         });
         return;
       }
+      if (msg.type === "image_chunk") {
+        const err = acceptChunk(uploads, msg);
+        if (err)
+          send({ type: "error", error: err });
+        return;
+      }
       const text5 = typeof msg.inputText === "string" ? msg.inputText.trim() : "";
-      if (!text5) {
+      const claimed = claimImageRefs(uploads, msg.imageRefs);
+      if (!Array.isArray(claimed)) {
+        send({ type: "error", error: claimed.error });
+        return;
+      }
+      const images = claimed;
+      if (!text5 && images.length === 0) {
         return;
       }
       if (text5.startsWith("/")) {
@@ -20637,10 +20796,29 @@ function setupAgentCoreWebSocket(deps) {
       void (async () => {
         try {
           await ensureOnce();
-          sm.appendUserMessage(sessionId, text5);
+          const notes = [];
+          for (const img of images) {
+            try {
+              const savedPath = await saveInboundMedia({
+                workspacePath: userWs,
+                accountId: sanitizeRuntimeId(runtimeSessionId),
+                channel: "agentcore",
+                buffer: Buffer.from(img.data, "base64"),
+                kind: "image",
+                mimeType: img.mimeType
+              });
+              notes.push(`[\u56FE\u7247\u5DF2\u4FDD\u5B58: ${savedPath}]`);
+            } catch (err) {
+              console.log(`[AgentCore] image save failed: ${err instanceof Error ? err.message : String(err)}`);
+              notes.push("[\u56FE\u7247]");
+            }
+          }
+          const fullText = notes.length > 0 ? text5 ? `${text5}
+${notes.join("\n")}` : notes.join("\n") : text5;
+          sm.appendUserMessage(sessionId, fullText);
           const result = await sm.sendUserMessage(sessionId, `[channel: agentcore]
 
-${text5}`);
+${fullText}`, images.length > 0 ? images : void 0);
           if (result === "queued")
             send({ type: "queued" });
         } catch (err) {
@@ -20651,26 +20829,32 @@ ${text5}`);
     ws.on("close", () => {
       unsubscribe?.();
       unsubscribe = null;
+      uploads.clear();
       activeOverrides.delete(runtimeSessionId);
     });
     console.log(`[AgentCore] ws connected \u2014 session ${sessionId}`);
   });
 }
-var SESSION_HEADER, activeOverrides;
+var SESSION_HEADER, MAX_IMAGES_PER_MESSAGE, MAX_IMAGE_BASE64_LENGTH, MAX_PENDING_UPLOADS, MAX_CHUNKS_PER_UPLOAD, activeOverrides;
 var init_agentcore = __esm({
   "packages/server/dist/routes/agentcore.js"() {
     "use strict";
     init_commands2();
     init_ui_log_builder();
     init_session_types();
+    init_media_store();
     SESSION_HEADER = "x-amzn-bedrock-agentcore-runtime-session-id";
+    MAX_IMAGES_PER_MESSAGE = 4;
+    MAX_IMAGE_BASE64_LENGTH = 8 * 1024 * 1024;
+    MAX_PENDING_UPLOADS = 4;
+    MAX_CHUNKS_PER_UPLOAD = 256;
     activeOverrides = /* @__PURE__ */ new Map();
   }
 });
 
 // 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(() => {
@@ -20678,12 +20862,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;
@@ -20779,7 +20963,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)
@@ -20823,10 +21007,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;
@@ -20837,7 +21021,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";
@@ -20913,8 +21097,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"() {
@@ -20938,8 +21122,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);
@@ -20948,7 +21132,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) => {
@@ -20967,7 +21151,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) => {
@@ -21003,8 +21187,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);
@@ -21320,7 +21504,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();
@@ -21342,7 +21526,7 @@ function setupWebSocketHandler(deps) {
     ackedChatIds.add(id);
   }
   function resolveProjectPath2(projectId) {
-    if (path54.isAbsolute(projectId))
+    if (path55.isAbsolute(projectId))
       return projectId;
     return null;
   }
@@ -21968,11 +22152,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);
@@ -21980,6 +22164,9 @@ function createCronDb(globalDir2) {
   if (!cols.some((c) => c.name === "run_at")) {
     sqlite.exec(`ALTER TABLE cron_jobs ADD COLUMN run_at INTEGER`);
   }
+  if (!cols.some((c) => c.name === "timeout_sec")) {
+    sqlite.exec(`ALTER TABLE cron_jobs ADD COLUMN timeout_sec INTEGER`);
+  }
   const runCols = sqlite.prepare(`PRAGMA table_info(cron_runs)`).all();
   if (!runCols.some((c) => c.name === "pid")) {
     sqlite.exec(`ALTER TABLE cron_runs ADD COLUMN pid INTEGER`);
@@ -22020,6 +22207,10 @@ var init_cron_db = __esm({
       runAt: integer4("run_at"),
       /** IANA timezone name; null = host timezone. */
       timezone: text4("timezone"),
+      /** Max seconds a single cron-fired cli may run before the runner kills
+       *  it. NULL = default 3600 (runner.ts CLI_TIMEOUT_SEC). Range 60–21600,
+       *  enforced at the write points (REST routes / skill helper). */
+      timeoutSec: integer4("timeout_sec"),
       /** JSON array of `{channelType, accountId}` records. Cron output (final
        *  assistant text) is dispatched to each one. Empty array = log only. */
       targets: text4("targets").notNull().default("[]"),
@@ -22069,6 +22260,7 @@ CREATE TABLE IF NOT EXISTS cron_jobs (
   schedule        TEXT NOT NULL,
   run_at          INTEGER,
   timezone        TEXT,
+  timeout_sec     INTEGER,
   targets         TEXT NOT NULL DEFAULT '[]',
   enabled         INTEGER NOT NULL DEFAULT 1,
   last_run_status TEXT,
@@ -22170,8 +22362,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";
@@ -22242,10 +22434,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)}`;
@@ -22296,7 +22488,7 @@ function sweepOrphanRuns(opts) {
   }
 }
 function startCronDaemon() {
-  fs47.mkdirSync(logsDir(), { recursive: true });
+  fs48.mkdirSync(logsDir(), { recursive: true });
   sweepOrphanRuns();
   reloadAll();
   _daemonTimers.push(setInterval(pruneOldLogs, DAY_MS2));
@@ -22453,7 +22645,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,
@@ -22488,7 +22680,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,
@@ -22502,7 +22694,8 @@ 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 timeoutSec = job.timeoutSec ?? CLI_TIMEOUT_SEC;
+    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}
@@ -22532,7 +22725,7 @@ async function runJob(jobId, triggerKind) {
       const killTimer = setTimeout(() => {
         timedOut = true;
         teeStream.write(`
-[runner] timeout ${CLI_TIMEOUT_SEC}s \u2014 SIGTERM, grace ${KILL_GRACE_SEC}s
+[runner] timeout ${timeoutSec}s \u2014 SIGTERM, grace ${KILL_GRACE_SEC}s
 `);
         try {
           child.kill("SIGTERM");
@@ -22544,7 +22737,7 @@ async function runJob(jobId, triggerKind) {
           if (child.pid)
             killTreeHard(child.pid);
         }, KILL_GRACE_SEC * 1e3);
-      }, CLI_TIMEOUT_SEC * 1e3);
+      }, timeoutSec * 1e3);
       child.stdout?.on("data", (chunk) => {
         stdout += chunk.toString("utf-8");
         teeStream.write(chunk);
@@ -22580,7 +22773,7 @@ async function runJob(jobId, triggerKind) {
     let failureReason = null;
     if (result.exitCode === 124) {
       status = "timeout";
-      failureReason = `cli exceeded ${CLI_TIMEOUT_SEC}s timeout`;
+      failureReason = `cli exceeded ${timeoutSec}s timeout`;
     } else if (result.exitCode !== 0) {
       status = "failed";
       failureReason = stderr.slice(-500).trim() || `cli exited ${result.exitCode}`;
@@ -22674,15 +22867,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 {
     }
   }
@@ -22715,7 +22908,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)}`;
@@ -22728,6 +22921,15 @@ function validateSchedule(expr) {
     return err instanceof Error ? err.message : String(err);
   }
 }
+function validateTimeoutSec(v) {
+  if (typeof v !== "number" || !Number.isInteger(v)) {
+    return "timeoutSec must be an integer (seconds)";
+  }
+  if (v < TIMEOUT_SEC_MIN || v > TIMEOUT_SEC_MAX) {
+    return `timeoutSec must be between ${TIMEOUT_SEC_MIN} and ${TIMEOUT_SEC_MAX}`;
+  }
+  return null;
+}
 function createCronRoutes() {
   const router = new Hono14();
   router.get("/cron/jobs", async (c) => {
@@ -22771,6 +22973,11 @@ function createCronRoutes() {
     if (hasRunAt && body.runAt <= Date.now()) {
       return c.json({ error: "runAt must be in the future" }, 400);
     }
+    if (body.timeoutSec !== void 0 && body.timeoutSec !== null) {
+      const err = validateTimeoutSec(body.timeoutSec);
+      if (err)
+        return c.json({ error: err }, 400);
+    }
     const id = newJobId();
     const now = Date.now();
     getCronDb().insert(cronJobs).values({
@@ -22782,6 +22989,7 @@ function createCronRoutes() {
       schedule: hasSchedule ? body.schedule : "",
       runAt: hasRunAt ? body.runAt : null,
       timezone: body.timezone ?? null,
+      timeoutSec: body.timeoutSec ?? null,
       targets: JSON.stringify(body.targets ?? []),
       enabled: body.enabled === false ? 0 : 1,
       lastRunStatus: null,
@@ -22818,6 +23026,11 @@ function createCronRoutes() {
       if (body.runAt <= Date.now())
         return c.json({ error: "runAt must be in the future" }, 400);
     }
+    if (body.timeoutSec !== void 0 && body.timeoutSec !== null) {
+      const err = validateTimeoutSec(body.timeoutSec);
+      if (err)
+        return c.json({ error: err }, 400);
+    }
     const hasSchedule = typeof body.schedule === "string" && body.schedule.trim().length > 0;
     const hasRunAt = typeof body.runAt === "number";
     if (hasSchedule && hasRunAt) {
@@ -22845,6 +23058,8 @@ function createCronRoutes() {
       patch.runAt = nextRunAt;
     if (body.timezone !== void 0)
       patch.timezone = body.timezone || null;
+    if (body.timeoutSec !== void 0)
+      patch.timeoutSec = body.timeoutSec;
     if (body.targets !== void 0)
       patch.targets = JSON.stringify(body.targets);
     if (body.enabled !== void 0)
@@ -22911,7 +23126,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 });
@@ -22960,6 +23175,7 @@ function computeNextRun(j) {
     return null;
   }
 }
+var TIMEOUT_SEC_MIN, TIMEOUT_SEC_MAX;
 var init_cron = __esm({
   "packages/server/dist/routes/cron.js"() {
     "use strict";
@@ -22967,6 +23183,8 @@ var init_cron = __esm({
     init_runner();
     init_dispatcher();
     init_broadcast();
+    TIMEOUT_SEC_MIN = 60;
+    TIMEOUT_SEC_MAX = 21600;
   }
 });
 
@@ -23213,7 +23431,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;
@@ -23221,8 +23439,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,
@@ -24009,7 +24227,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();
@@ -24019,7 +24237,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,
@@ -24743,8 +24961,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")
@@ -24756,7 +24974,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;
@@ -24794,7 +25012,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 = {
@@ -24957,8 +25175,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) => ({
@@ -25347,7 +25565,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,
@@ -25356,7 +25574,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) => {
@@ -25436,8 +25654,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();
@@ -25446,7 +25664,7 @@ function createWechatRoutes(deps) {
       return {
         ...stripSecrets(acc),
         workspacePath: acc.workspacePath,
-        workspaceMissing: !fs52.existsSync(acc.workspacePath)
+        workspaceMissing: !fs53.existsSync(acc.workspacePath)
       };
     });
     return c.json({ accounts });
@@ -25462,7 +25680,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)
@@ -25666,14 +25884,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 };
@@ -26056,7 +26274,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();
@@ -26066,7 +26284,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,
@@ -26212,27 +26430,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",
@@ -26240,8 +26458,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);
@@ -26582,10 +26800,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;
@@ -26603,7 +26821,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
@@ -26748,7 +26966,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)
@@ -26853,7 +27071,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;
@@ -26872,7 +27090,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(() => {
@@ -27129,7 +27347,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();
@@ -27152,7 +27370,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,
@@ -27684,10 +27902,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");
@@ -27718,10 +27936,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);
@@ -27827,7 +28045,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}`);
@@ -27950,7 +28168,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;
@@ -27963,7 +28181,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(() => {
@@ -28127,7 +28345,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({
@@ -28253,7 +28471,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();
@@ -28277,7 +28495,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,
@@ -28665,14 +28883,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);
@@ -28711,17 +28929,17 @@ 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;
@@ -28730,15 +28948,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);
     }
@@ -28747,19 +28965,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;
@@ -28768,7 +28986,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
       });
@@ -28787,16 +29005,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;
@@ -28804,14 +29022,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...`);
@@ -28867,13 +29085,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.1";
+    HALO_VERSION = "1.1.3";
     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);
     }
@@ -28894,7 +29112,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);
@@ -28963,10 +29181,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();
@@ -28992,11 +29210,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);
@@ -29767,11 +29985,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.1";
+var VERSION = "1.1.3";
 var HELP_TOP = `Usage: halo <command> [options]
 
 Commands:
@@ -30028,8 +30246,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
 `);
@@ -30332,10 +30550,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}
@@ -30353,10 +30571,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.
@@ -30373,7 +30621,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");
@@ -30389,7 +30637,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");
@@ -30502,11 +30750,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 {
@@ -30593,8 +30841,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],
@@ -30695,7 +30943,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;
@@ -30713,7 +30961,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);