@turmind/halo 2.2.4 → 2.2.6

package/dist/index.js

@@ -2121,7 +2121,7 @@ var init_init = __esm({
       path9.resolve(__dirname, "..", "bundled-docs"),
       path9.resolve(__dirname, "..", "..", "..", ".halo", "docs")
     ];
-    TEMPLATE_VERSION = 123;
+    TEMPLATE_VERSION = 124;
     VERSION_FILE = ".template-version";
     SKIP_NAMES = /* @__PURE__ */ new Set([".DS_Store", "schema.sql", "__pycache__", ".pytest_cache"]);
     BUILTIN_AGENT_IDS = /* @__PURE__ */ new Set([
@@ -9350,27 +9350,27 @@ var init_workspace = __esm({
       constructor(projectRoot) {
         this.projectRoot = projectRoot;
       }
-      async readFile(path98) {
-        const fullPath = this.validatePath(path98);
+      async readFile(path99) {
+        const fullPath = this.validatePath(path99);
         return readFile(fullPath, "utf-8");
       }
-      async writeFile(path98, content) {
-        const fullPath = this.validatePath(path98);
+      async writeFile(path99, content) {
+        const fullPath = this.validatePath(path99);
         const dir = resolve2(fullPath, "..");
         await mkdir(dir, { recursive: true });
         await writeFile(fullPath, content, "utf-8");
       }
-      validatePath(path98) {
-        const fullPath = isAbsolute(path98) ? resolve2(path98) : resolve2(this.projectRoot, path98);
+      validatePath(path99) {
+        const fullPath = isAbsolute(path99) ? resolve2(path99) : resolve2(this.projectRoot, path99);
         const root = resolve2(this.projectRoot);
         if (fullPath !== root && !fullPath.startsWith(root + sep)) {
-          throw new WorkspaceError(`Path "${path98}" is outside the workspace directory "${this.projectRoot}"`);
+          throw new WorkspaceError(`Path "${path99}" is outside the workspace directory "${this.projectRoot}"`);
         }
         try {
           const real = realpathSync2(fullPath);
           const realRoot = realpathSync2(root);
           if (real !== realRoot && !real.startsWith(realRoot + sep)) {
-            throw new WorkspaceError(`Path "${path98}" is outside the workspace directory "${this.projectRoot}"`);
+            throw new WorkspaceError(`Path "${path99}" is outside the workspace directory "${this.projectRoot}"`);
           }
         } catch (err) {
           if (err instanceof WorkspaceError)
@@ -9557,12 +9557,12 @@ var init_git_manager = __esm({
             const code = parts[0];
             const status = code[0];
             const isRenameOrCopy = status === "R" || status === "C";
-            const path98 = isRenameOrCopy ? parts[2] : parts[1];
-            if (!path98 || seen.has(path98))
+            const path99 = isRenameOrCopy ? parts[2] : parts[1];
+            if (!path99 || seen.has(path99))
               continue;
-            seen.add(path98);
+            seen.add(path99);
             files.push({
-              path: path98,
+              path: path99,
               status,
               from: isRenameOrCopy ? parts[1] : void 0
             });
@@ -9710,9 +9710,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(path98, staged, from, commit) {
+      async getFileDiff(path99, staged, from, commit) {
         if (commit) {
-          const parentPath = from || path98;
+          const parentPath = from || path99;
           let original2 = "";
           try {
             original2 = await this.git.show([`${commit}^:${parentPath}`]);
@@ -9721,13 +9721,13 @@ var init_git_manager = __esm({
           }
           let modified2 = "";
           try {
-            modified2 = await this.git.show([`${commit}:${path98}`]);
+            modified2 = await this.git.show([`${commit}:${path99}`]);
           } catch {
             modified2 = "";
           }
           return { original: original2, modified: modified2 };
         }
-        const headPath = from || path98;
+        const headPath = from || path99;
         let original = "";
         try {
           original = await this.git.show([`HEAD:${headPath}`]);
@@ -9737,13 +9737,13 @@ var init_git_manager = __esm({
         let modified = "";
         if (staged) {
           try {
-            modified = await this.git.show([`:${path98}`]);
+            modified = await this.git.show([`:${path99}`]);
           } catch {
             modified = "";
           }
         } else {
           try {
-            modified = await this.workspace.readFile(path98);
+            modified = await this.workspace.readFile(path99);
           } catch {
             modified = "";
           }
@@ -15847,7 +15847,7 @@ function createNodeHub(deps) {
     since: c.since
   }));
   const announce = () => {
-    broadcast({ type: "nodes:changed", online: online().map(({ accountId, root, shell, os: os12, since }) => ({ accountId, root, shell, os: os12, since })) });
+    broadcast({ type: "nodes:changed", online: online().map(({ accountId, root, shell, os: os13, since }) => ({ accountId, root, shell, os: os13, since })) });
   };
   const settle = (conn, id, fn) => {
     const p = conn.pending.get(id);
@@ -16830,7 +16830,7 @@ async function initObservability(haloProcess = "server") {
     return true;
   }
   const { registerSdk: registerSdk2 } = await Promise.resolve().then(() => (init_otel_sdk(), otel_sdk_exports));
-  providers = await registerSdk2(process.env.OTEL_SERVICE_NAME, "2.2.4", haloProcess);
+  providers = await registerSdk2(process.env.OTEL_SERVICE_NAME, "2.2.6", haloProcess);
   console.log(`[Observability] OTLP export \u2192 ${process.env.OTEL_EXPORTER_OTLP_ENDPOINT} (service.name=${process.env.OTEL_SERVICE_NAME}, halo.process=${haloProcess}, capture_content=${config.observability.captureContent})`);
   return true;
 }
@@ -22018,8 +22018,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 path98 = pick.isDir ? needsQuote ? `"${pick.insertPath}/` : `${pick.insertPath}/` : needsQuote ? `"${pick.insertPath}" ` : `${pick.insertPath} `;
-  return `${before}@${kind} ${path98}`;
+  const path99 = pick.isDir ? needsQuote ? `"${pick.insertPath}/` : `${pick.insertPath}/` : needsQuote ? `"${pick.insertPath}" ` : `${pick.insertPath} `;
+  return `${before}@${kind} ${path99}`;
 }
 var init_path_suggest_engine = __esm({
   "src/tui/path-suggest-engine.ts"() {
@@ -23920,6 +23920,31 @@ async function planFolderZip(root, projectPath, opts) {
   const [rootReal, wsReal] = await Promise.all([fs53.realpath(root), fs53.realpath(projectPath)]);
   if (isBlockedPath(rootReal, wsReal))
     throw new FolderZipError(403, "Path is not accessible");
+  const planner = createPlanner(wsReal, opts);
+  await planner.walk(rootReal, "");
+  return planner.plan;
+}
+async function planSelectionZip(rels, projectPath, opts) {
+  const selected = new Set(rels);
+  const kept = [...selected].filter((rel) => rel === "" || !rel.split("/").some((_, i, segs) => selected.has(segs.slice(0, i).join("/")))).sort();
+  let common = kept[0].split("/").slice(0, -1);
+  for (const rel of kept) {
+    const segs = rel.split("/").slice(0, -1);
+    let i = 0;
+    while (i < common.length && common[i] === segs[i])
+      i++;
+    common = common.slice(0, i);
+  }
+  const parent = common.join("/");
+  const wsReal = await fs53.realpath(projectPath);
+  const planner = createPlanner(wsReal, opts);
+  for (const rel of kept) {
+    const real = rel ? path60.join(await fs53.realpath(path60.join(wsReal, path60.dirname(rel))), path60.basename(rel)) : wsReal;
+    await planner.addSelected(real, parent ? rel.slice(parent.length + 1) : rel);
+  }
+  return { plan: planner.plan, parent };
+}
+function createPlanner(wsReal, opts) {
   const { includeIgnored, limits, signal } = opts;
   const deadline = Date.now() + limits.maxWalkMs;
   const plan = { items: [], files: 0, bytes: 0, excluded: new ExcludedLog() };
@@ -24012,8 +24037,31 @@ async function planFolderZip(root, projectPath, opts) {
     }
     return nonEmpty2;
   }
-  await walk(rootReal, "");
-  return plan;
+  async function addSelected(real, rel) {
+    signal?.throwIfAborted();
+    if (Date.now() > deadline)
+      throw walkTimeout();
+    const name = path60.basename(real);
+    const st = await fs53.lstat(real);
+    if (rel.split("/").some((seg, i) => isZipUnsafeName(seg, i === 0))) {
+      excluded.add("unreadable", `${rel}${st.isDirectory() ? "/" : ""} (name not valid in a zip)`);
+    } else if (st.isSymbolicLink()) {
+      await addSymlink(real, rel, name);
+    } else if (st.isDirectory()) {
+      if (isBlockedPath(real, wsReal))
+        excluded.add("blocked", `${rel}/`);
+      else if (!await walk(real, rel) && rel)
+        plan.items.push({ rel, mtimeMs: st.mtimeMs });
+    } else if (st.isFile()) {
+      if (isEnvName(name) || isBlockedPath(real, wsReal))
+        excluded.add("blocked", rel);
+      else
+        addFile(rel, real, st);
+    } else {
+      excluded.add("unreadable", `${rel} (not a regular file)`);
+    }
+  }
+  return { plan, walk, addSelected };
 }
 function planSummary(plan) {
   return { files: plan.files, bytes: plan.bytes, excluded: { ...plan.excluded.counts }, ignoredNames: { ...plan.excluded.ignoredNames } };
@@ -24747,26 +24795,44 @@ function createFileRoutes(opts = {}) {
     }
   });
   app2.get("/files/download-folder", async (c) => {
-    const relPath = c.req.query("path") ?? "";
+    const relPaths = c.req.queries("path") ?? [];
+    const relPath = relPaths[0] ?? "";
     const projectId = c.req.query("projectId");
     if (!projectId)
       return c.json({ error: "projectId is required" }, 400);
     const signal = c.req.raw.signal;
+    const planOpts = { includeIgnored: c.req.query("include") === "excluded", limits: folderZipLimits, signal };
     try {
-      const resolved = await resolveProjectFile(projectId, relPath);
-      if ("error" in resolved)
-        return c.json({ error: resolved.error }, resolved.status);
-      const { projectPath, absolutePath } = resolved;
-      if (!(await fs54.stat(absolutePath)).isDirectory())
-        return c.json({ error: "Not a directory" }, 400);
-      const plan = await planFolderZip(absolutePath, projectPath, {
-        includeIgnored: c.req.query("include") === "excluded",
-        limits: folderZipLimits,
-        signal
-      });
+      let plan;
+      let folderName;
+      if (relPaths.length > 1) {
+        let projectPath = "";
+        const rels = [];
+        for (const p of relPaths) {
+          const resolved = await resolveProjectFile(projectId, p);
+          if ("error" in resolved)
+            return c.json({ error: resolved.error }, resolved.status);
+          projectPath = resolved.projectPath;
+          const rel = path61.relative(projectPath, resolved.absolutePath);
+          if (rel === ".." || rel.startsWith(`..${path61.sep}`) || path61.isAbsolute(rel))
+            return c.json({ error: "Path traversal not allowed" }, 403);
+          rels.push(rel.split(path61.sep).join("/"));
+        }
+        const selection = await planSelectionZip(rels, projectPath, planOpts);
+        plan = selection.plan;
+        folderName = `${path61.basename(path61.resolve(projectPath, selection.parent)) || "workspace"}-selection`;
+      } else {
+        const resolved = await resolveProjectFile(projectId, relPath);
+        if ("error" in resolved)
+          return c.json({ error: resolved.error }, resolved.status);
+        const { projectPath, absolutePath } = resolved;
+        if (!(await fs54.stat(absolutePath)).isDirectory())
+          return c.json({ error: "Not a directory" }, 400);
+        plan = await planFolderZip(absolutePath, projectPath, planOpts);
+        folderName = path61.basename(absolutePath) || "workspace";
+      }
       if (c.req.query("estimate") === "1")
         return c.json(planSummary(plan));
-      const folderName = path61.basename(absolutePath) || "workspace";
       const fileName = `${folderName}.zip`;
       const asciiName = fileName.replace(/[^\x20-\x7e]|["\\]/g, "_");
       const encodedName = encodeURIComponent(fileName).replace(/['()*]/g, (ch) => `%${ch.charCodeAt(0).toString(16).toUpperCase()}`);
@@ -26855,8 +26921,8 @@ function detectOrphans(tree, declared, kept) {
       if (!block || typeof block !== "object")
         continue;
       for (const k of Object.keys(block)) {
-        const path98 = `${namespaceId}.${kindWord}.${k}`;
-        if (!declaredMap.has(path98)) {
+        const path99 = `${namespaceId}.${kindWord}.${k}`;
+        if (!declaredMap.has(path99)) {
           out.push({ namespaceId, kind: kindWord === "params" ? "param" : "secret", key: k });
         }
       }
@@ -28460,17 +28526,17 @@ function passwordStrengthError(pw) {
 }
 function authMiddleware() {
   return async (c, next) => {
-    const path98 = c.req.path;
-    if (PUBLIC_PATHS.some((p) => path98 === p || path98.startsWith(p + "?"))) {
+    const path99 = c.req.path;
+    if (PUBLIC_PATHS.some((p) => path99 === p || path99.startsWith(p + "?"))) {
       return next();
     }
-    if (EXTENSION_ASSET_PATH.test(path98)) {
+    if (EXTENSION_ASSET_PATH.test(path99)) {
       return next();
     }
     const token = getCookie(c, COOKIE_NAME);
     const payload = validateToken(token);
     if (!payload) {
-      if (!path98.startsWith("/api/")) {
+      if (!path99.startsWith("/api/")) {
         return next();
       }
       return c.json({ error: "Unauthorized" }, 401);
@@ -28524,14 +28590,14 @@ function createWebChannel(deps) {
     return findActiveSessionId(sm, accountId, prefix, activeOverrides, "full") ?? void 0;
   }
   function resolveWorkspace(account, override, scaffold = true) {
-    let path98 = account.workspacePath;
+    let path99 = account.workspacePath;
     if (override && override !== account.workspacePath) {
       if (account.accessLevel !== "full") {
         return { ok: false, error: "workspace override requires a full-access token" };
       }
-      path98 = override;
+      path99 = override;
     }
-    const resolved = scaffold ? resolveAccountWorkspace({ ...account, workspacePath: path98 }) : fs64.existsSync(path98) ? path98 : null;
+    const resolved = scaffold ? resolveAccountWorkspace({ ...account, workspacePath: path99 }) : fs64.existsSync(path99) ? path99 : null;
     if (!resolved)
       return { ok: false, error: "workspace not found" };
     return { ok: true, path: resolved };
@@ -32756,7 +32822,7 @@ function buildCard(workspace, interfaceUrl, caps) {
   return {
     name: raw.name,
     description: raw.description,
-    version: typeof raw.version === "string" ? raw.version : "2.2.4",
+    version: typeof raw.version === "string" ? raw.version : "2.2.6",
     supportedInterfaces: [{ url: interfaceUrl, protocolBinding: "JSONRPC", protocolVersion: A2A_VERSION }],
     capabilities: { streaming: caps.streaming, pushNotifications: true, extendedAgentCard: false },
     ...caps.tokenAuth === false ? {} : {
@@ -34238,7 +34304,7 @@ async function finishRun(runId, db4, session) {
     if (session.turnError) {
       status = "failed";
       failureReason = session.turnError.slice(0, 500);
-    } else if (!text6) {
+    } else if (!answer) {
       status = "failed";
       failureReason = "run produced no output (nothing to dispatch)";
     }
@@ -34250,7 +34316,7 @@ async function finishRun(runId, db4, session) {
     const targets = job ? parseTargets(job.targets) : [];
     let dispatchResults = [];
     if (job && status === "succeeded" && targets.length > 0) {
-      dispatchResults = await dispatchToTargets(text6, targets, row.workspacePath ?? job.workspacePath);
+      dispatchResults = await dispatchToTargets(answer, targets, row.workspacePath ?? job.workspacePath);
       if (dispatchResults.length > 0 && dispatchResults.every((r) => !r.ok)) {
         status = "failed";
         failureReason = `all ${dispatchResults.length} target(s) failed: ${dispatchResults.map((r) => `${r.channelType}:${r.error ?? "?"}`).join("; ")}`;
@@ -35780,11 +35846,15 @@ function haloBaseVersion(haloVersion) {
   return semver.valid(stripped) === stripped ? stripped : null;
 }
 function defaultHubBase(hubRepo) {
+  const gh = githubHubRepo(hubRepo);
+  return gh ? `https://raw.githubusercontent.com/${gh.owner}/${gh.repo}/main/extensions` : null;
+}
+function githubHubRepo(hubRepo) {
   let h = hubRepo.trim();
   if (h === "" || h.startsWith("{{"))
     h = DEFAULT_HUB_REPO;
   const m = /^(?:https:\/\/github\.com\/)?([A-Za-z0-9][A-Za-z0-9_.-]*)\/([A-Za-z0-9_.-]+?)(?:\.git)?\/?$/.exec(h);
-  return m ? `https://raw.githubusercontent.com/${m[1]}/${m[2]}/main/extensions` : null;
+  return m ? { owner: m[1], repo: m[2] } : null;
 }
 function updateJsonUrl(id, source, hubBase2) {
   if (source)
@@ -35924,7 +35994,7 @@ function createCoreChecker(opts) {
 }
 function getCoreStatus(force) {
   checker ??= createCoreChecker({
-    haloVersion: "2.2.4",
+    haloVersion: "2.2.6",
     fetchLatest: fetchNpmLatest,
     onChange: (status) => broadcast({ type: "updates:changed", scope: "core", status })
   });
@@ -36092,7 +36162,7 @@ function hubBase() {
 }
 function serverChecker() {
   checker2 ??= createExtensionsChecker({
-    haloVersion: "2.2.4",
+    haloVersion: "2.2.6",
     installed: () => {
       const s = getSnapshot();
       return [...s.extensions, ...s.disabled];
@@ -36427,6 +36497,97 @@ var init_extensions = __esm({
   }
 });
 
+// ../server/dist/models/hub-update.js
+import fs80 from "node:fs";
+import os11 from "node:os";
+import path86 from "node:path";
+import JSZip3 from "jszip";
+function pickModelsRelease(releases) {
+  if (!Array.isArray(releases))
+    return null;
+  for (const r of releases) {
+    if (typeof r?.tag_name !== "string" || !/^models-v\d/.test(r.tag_name) || r.draft || r.prerelease)
+      continue;
+    const assets = Array.isArray(r.assets) ? r.assets : [];
+    const zip = assets.find((a) => typeof a?.name === "string" && a.name.endsWith(".zip") && typeof a.browser_download_url === "string");
+    if (zip)
+      return { tag: r.tag_name, url: zip.browser_download_url };
+  }
+  return null;
+}
+async function unpackYamls(zipBuf, dest) {
+  let zip;
+  try {
+    zip = await JSZip3.loadAsync(zipBuf);
+  } catch (err) {
+    throw new ModelsHubError(`release asset is not a zip: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  const seen = /* @__PURE__ */ new Set();
+  for (const entry of Object.values(zip.files)) {
+    if (entry.dir)
+      continue;
+    const name = path86.posix.basename(entry.name.replace(/\\/g, "/"));
+    if (!name.endsWith(".yaml") || name.startsWith("."))
+      continue;
+    if (seen.has(name))
+      throw new ModelsHubError(`zip holds ${name} twice`);
+    seen.add(name);
+    fs80.writeFileSync(path86.join(dest, name), await entry.async("nodebuffer"));
+  }
+}
+async function updateModelsFromHub(hubRepo, opts = {}) {
+  const gh = githubHubRepo(hubRepo);
+  if (!gh)
+    throw new ModelsHubError(`not a GitHub hub: ${hubRepo}`);
+  const hub = `${gh.owner}/${gh.repo}`;
+  const api = `https://api.github.com/repos/${hub}/releases?per_page=100`;
+  const res = await httpsGet(api, { maxBytes: RELEASES_MAX_BYTES, timeoutMs: RELEASES_TIMEOUT_MS, headers: { accept: "application/vnd.github+json" } });
+  if (res.status !== 200)
+    throw new ModelsHubError(`GitHub release API answered HTTP ${res.status} for ${hub} \u2014 rate-limited, private or wrong repo?`);
+  let releases;
+  try {
+    releases = JSON.parse(res.body.toString("utf-8"));
+  } catch {
+    throw new ModelsHubError(`GitHub release API sent invalid JSON for ${hub}`);
+  }
+  const picked = pickModelsRelease(releases);
+  if (!picked)
+    throw new ModelsHubError(`no models-v* release with a .zip asset in ${hub}`);
+  const zip = await httpsGet(picked.url, { maxBytes: ZIP_MAX_BYTES, timeoutMs: ZIP_TIMEOUT_MS, idleTimeoutMs: ZIP_IDLE_TIMEOUT_MS });
+  if (zip.status !== 200)
+    throw new ModelsHubError(`download of ${picked.tag} failed: HTTP ${zip.status}`);
+  const tmp = fs80.mkdtempSync(path86.join(os11.tmpdir(), "halo-models-"));
+  try {
+    await unpackYamls(zip.body, tmp);
+    let plan;
+    try {
+      plan = planModelsInstall(tmp, opts.dirs);
+    } catch (err) {
+      throw new ModelsHubError(`${picked.tag}: ${err instanceof Error ? err.message.replace(tmp, "the release zip") : String(err)}`);
+    }
+    const written = plan.needsConfirm && !opts.confirm ? null : applyModelsInstall(plan);
+    return { hub, release: picked.tag, plan, written, summary: written ? summaryLine(plan, written) : null };
+  } finally {
+    fs80.rmSync(tmp, { recursive: true, force: true });
+  }
+}
+var ModelsHubError, RELEASES_MAX_BYTES, ZIP_MAX_BYTES, RELEASES_TIMEOUT_MS, ZIP_TIMEOUT_MS, ZIP_IDLE_TIMEOUT_MS;
+var init_hub_update = __esm({
+  "../server/dist/models/hub-update.js"() {
+    "use strict";
+    init_https_get();
+    init_update_json();
+    init_install();
+    ModelsHubError = class extends Error {
+    };
+    RELEASES_MAX_BYTES = 2 * 1024 * 1024;
+    ZIP_MAX_BYTES = 10 * 1024 * 1024;
+    RELEASES_TIMEOUT_MS = 15e3;
+    ZIP_TIMEOUT_MS = 6e4;
+    ZIP_IDLE_TIMEOUT_MS = 2e4;
+  }
+});
+
 // ../server/dist/routes/updates.js
 import { Hono as Hono22 } from "hono";
 function statusOf(scope, force) {
@@ -36447,20 +36608,55 @@ function createUpdateRoutes() {
     const status = statusOf(body?.scope, true);
     return status ? c.json(status) : c.json({ error: SCOPE_ERROR }, 400);
   });
+  app2.post("/models/update", async (c) => {
+    const body = await c.req.json().catch(() => null);
+    const hubRepo = getServerParam("extension", "hub_repo");
+    if (!githubHubRepo(hubRepo)) {
+      return c.json({ error: `Sync latest models supports GitHub hubs only (extension hub_repo is ${hubRepo}) \u2014 use /extension models in a chat, which also handles Gitea / Forgejo / GitLab` }, 400);
+    }
+    if (syncingModels)
+      return c.json({ error: "A model sync is already running" }, 409);
+    syncingModels = true;
+    try {
+      const r = await updateModelsFromHub(hubRepo, { confirm: body?.confirm === true });
+      if (r.written)
+        console.log(`[Models] synced ${r.hub} ${r.release}: ${r.summary}`);
+      return c.json({
+        hub: r.hub,
+        release: r.release,
+        needsConfirm: r.written === null,
+        written: r.written ?? [],
+        summary: r.summary,
+        // `raw` (the yaml text) stays server-side.
+        entries: r.plan.entries.map(({ raw: _raw, ...e }) => e)
+      });
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      console.log(`[Models] sync from ${hubRepo || "the default hub"} failed: ${msg}`);
+      return c.json({ error: msg }, err instanceof ModelsHubError || err instanceof HttpsGetError ? 502 : 500);
+    } finally {
+      syncingModels = false;
+    }
+  });
   return app2;
 }
-var SCOPE_ERROR;
+var SCOPE_ERROR, syncingModels;
 var init_updates = __esm({
   "../server/dist/routes/updates.js"() {
     "use strict";
+    init_config();
     init_core_check();
     init_extension_check();
+    init_update_json();
+    init_https_get();
+    init_hub_update();
     SCOPE_ERROR = 'scope must be "core" or "extensions"';
+    syncingModels = false;
   }
 });
 
 // ../server/dist/models/watcher.js
-import fs80 from "node:fs";
+import fs81 from "node:fs";
 function snapshot2() {
   const { effective } = loadProviders();
   return {
@@ -36488,7 +36684,7 @@ function reloadAndBroadcast() {
 }
 function openWatcher2(root) {
   try {
-    watcher2 = fs80.watch(root, { persistent: false, recursive: false }, () => scheduleFlush2());
+    watcher2 = fs81.watch(root, { persistent: false, recursive: false }, () => scheduleFlush2());
     watcher2.on("error", (err) => {
       console.warn(`[Models] watch error on ${root}: ${err.message} \u2014 retrying in 1s`);
       closeWatcher2();
@@ -36514,7 +36710,7 @@ function start2() {
     return;
   const root = globalHubModelsDir();
   try {
-    fs80.mkdirSync(root, { recursive: true });
+    fs81.mkdirSync(root, { recursive: true });
   } catch (err) {
     console.warn(`[Models] cannot create ${root}: ${err instanceof Error ? err.message : String(err)}`);
   }
@@ -36549,8 +36745,8 @@ var init_watcher2 = __esm({
 });
 
 // ../server/dist/evolution/notify.js
-import fs81 from "node:fs";
-import path86 from "node:path";
+import fs82 from "node:fs";
+import path87 from "node:path";
 import { and as and18, eq as eq22, isNull as isNull7 } from "drizzle-orm";
 function setEvoSessionRegistry(r) {
   _registry4 = r;
@@ -36569,7 +36765,7 @@ function formatAutoAppliedNotice(input) {
 }
 function readJson(file) {
   try {
-    return JSON.parse(fs81.readFileSync(file, "utf-8"));
+    return JSON.parse(fs82.readFileSync(file, "utf-8"));
   } catch {
     return null;
   }
@@ -36583,10 +36779,10 @@ function notifyAutoApplied(db4) {
     try {
       const runId = JSON.parse(a.sourceRunIds)[0];
       const run = runId ? db4.select().from(evolutionRuns).where(eq22(evolutionRuns.id, runId)).get() : void 0;
-      if (run && fs81.existsSync(path86.join(a.workspacePath, ".halo"))) {
+      if (run && fs82.existsSync(path87.join(a.workspacePath, ".halo"))) {
         const sm = registry2.getOrCreate(a.workspacePath);
         if (sm.getSessionById(run.sourceSession)) {
-          const verdict2 = readJson(path86.join(wsEvoRunDir(a.workspacePath, run.id), AUTO_APPLY_FILE));
+          const verdict2 = readJson(path87.join(wsEvoRunDir(a.workspacePath, run.id), AUTO_APPLY_FILE));
           sm.notifySystem(run.sourceSession, formatAutoAppliedNotice({
             files: readPublishedFiles(a.workspacePath, a.id) ?? [],
             avg: verdict2?.score?.avg ?? null,
@@ -36872,14 +37068,14 @@ var init_ticker = __esm({
 });
 
 // ../server/dist/evolution/spawn.js
-import fs82 from "node:fs";
-import path87 from "node:path";
+import fs83 from "node:fs";
+import path88 from "node:path";
 import { spawn as spawn5 } from "node:child_process";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 function spawnEvoWrapper(wrapperPath, mode, id) {
-  fs82.mkdirSync(evoLogsDir(), { recursive: true });
+  fs83.mkdirSync(evoLogsDir(), { recursive: true });
   const logPath = mode === "run" ? evoWrapperLogFile(id) : evoApplyLogFile(id);
-  const logFd = fs82.openSync(logPath, "a");
+  const logFd = fs83.openSync(logPath, "a");
   let child;
   try {
     child = spawn5(process.execPath, [wrapperPath, `--mode=${mode}`, `--id=${id}`], {
@@ -36892,7 +37088,7 @@ function spawnEvoWrapper(wrapperPath, mode, id) {
       windowsHide: true
     });
   } finally {
-    fs82.closeSync(logFd);
+    fs83.closeSync(logFd);
   }
   child.once("exit", (code, signal) => {
     if (code === 0)
@@ -36909,8 +37105,8 @@ var init_spawn = __esm({
     "use strict";
     init_child_env();
     init_paths();
-    __dirname2 = path87.dirname(fileURLToPath2(import.meta.url));
-    WRAPPER_PATH = path87.resolve(__dirname2, "evo-wrapper.js");
+    __dirname2 = path88.dirname(fileURLToPath2(import.meta.url));
+    WRAPPER_PATH = path88.resolve(__dirname2, "evo-wrapper.js");
     realEvoSpawner = (mode, id) => {
       spawnEvoWrapper(WRAPPER_PATH, mode, id);
     };
@@ -37730,12 +37926,12 @@ var init_handler3 = __esm({
 });
 
 // ../server/dist/routes/channel-accounts.js
-import fs83 from "node:fs";
+import fs84 from "node:fs";
 function accountListFields(a) {
   return {
     accountId: a.accountId,
     workspacePath: a.workspacePath,
-    workspaceMissing: !fs83.existsSync(a.workspacePath),
+    workspaceMissing: !fs84.existsSync(a.workspacePath),
     label: a.label,
     enabled: a.enabled,
     accessLevel: a.accessLevel,
@@ -38377,8 +38573,8 @@ var init_cdn = __esm({
 });
 
 // ../server/dist/channels/wechat/send-media.js
-import fs84 from "node:fs/promises";
-import path88 from "node:path";
+import fs85 from "node:fs/promises";
+import path89 from "node:path";
 function inferKind(filePath) {
   const cls = classifyMedia(filePath);
   if (cls === "image")
@@ -38390,7 +38586,7 @@ function inferKind(filePath) {
 async function sendMediaFile(params) {
   const { baseUrl, token, toUserId, contextToken, contextTokenAt, filePath } = params;
   const kind = params.kind ?? inferKind(filePath);
-  const plaintext = await fs84.readFile(filePath);
+  const plaintext = await fs85.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;
@@ -38428,7 +38624,7 @@ async function sendMediaFile(params) {
     aesKeyBase64,
     fileSizeCiphertext: prep.filesize,
     fileSize: prep.rawsize,
-    fileName: path88.basename(filePath)
+    fileName: path89.basename(filePath)
   });
   const clientId = `halo-media-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
   const body = {
@@ -38591,8 +38787,8 @@ var init_login = __esm({
 });
 
 // ../server/dist/channels/wechat/handler.js
-import fs85 from "node:fs";
-import path89 from "node:path";
+import fs86 from "node:fs";
+import path90 from "node:path";
 import QRCode from "qrcode";
 function wxRoute(fromUserId, contextToken, contextTokenAt) {
   return (prev) => {
@@ -39013,7 +39209,7 @@ async function handleSlashCommand(args) {
         await reply(login.message);
         return true;
       }
-      const tmpPath = path89.join(tempDir(), `halo-qr-${login.sessionKey}.png`);
+      const tmpPath = path90.join(tempDir(), `halo-qr-${login.sessionKey}.png`);
       await QRCode.toFile(tmpPath, login.qrcodeUrl, { width: 256, margin: 2 });
       await sendMediaFile({
         baseUrl: account.baseUrl,
@@ -39022,7 +39218,7 @@ async function handleSlashCommand(args) {
         contextToken,
         filePath: tmpPath
       });
-      await fs85.promises.unlink(tmpPath).catch(() => {
+      await fs86.promises.unlink(tmpPath).catch(() => {
       });
       await reply(t("wechat.qr_sent", lang, { level, path: account.workspacePath }));
       waitLogin({ sessionKey: login.sessionKey }).then(async (result2) => {
@@ -39102,8 +39298,8 @@ var init_handler4 = __esm({
 
 // ../server/dist/routes/wechat.js
 import { Hono as Hono24 } from "hono";
-import path90 from "node:path";
-import fs86 from "node:fs";
+import path91 from "node:path";
+import fs87 from "node:fs";
 function createWechatRoutes(deps) {
   const { db: db4, channel } = deps;
   const app2 = new Hono24();
@@ -39112,7 +39308,7 @@ function createWechatRoutes(deps) {
       return {
         ...stripSecrets(acc),
         workspacePath: acc.workspacePath,
-        workspaceMissing: !fs86.existsSync(acc.workspacePath)
+        workspaceMissing: !fs87.existsSync(acc.workspacePath)
       };
     });
     return c.json({ accounts });
@@ -39128,7 +39324,7 @@ function createWechatRoutes(deps) {
       return c.json({ error: "sessionKey required" }, 400);
     if (!body.workspacePath)
       return c.json({ error: "workspacePath required" }, 400);
-    if (!path90.isAbsolute(body.workspacePath))
+    if (!path91.isAbsolute(body.workspacePath))
       return c.json({ error: "workspacePath must be absolute" }, 400);
     const levelError = accessLevelError(body.accessLevel, CHAT_ACCESS_LEVELS);
     if (levelError)
@@ -39341,7 +39537,7 @@ var init_descriptor2 = __esm({
 import { Hono as Hono25 } from "hono";
 import { streamSSE as streamSSE3 } from "hono/streaming";
 import crypto15 from "node:crypto";
-import fs87 from "node:fs";
+import fs88 from "node:fs";
 function streamWithKeepalive(c, chunks) {
   return streamSSE3(c, async (stream) => {
     const timer2 = setInterval(() => {
@@ -39537,30 +39733,30 @@ function createWebRoutes(deps) {
     const filePath = c.req.query("path");
     if (!filePath)
       return c.json({ error: "path required" }, 400);
-    const path98 = await import("node:path");
-    const resolved = path98.default.resolve(account.workspacePath, filePath);
-    const root = path98.default.resolve(account.workspacePath);
-    if (resolved !== root && !resolved.startsWith(root + path98.default.sep)) {
+    const path99 = await import("node:path");
+    const resolved = path99.default.resolve(account.workspacePath, filePath);
+    const root = path99.default.resolve(account.workspacePath);
+    if (resolved !== root && !resolved.startsWith(root + path99.default.sep)) {
       return c.json({ error: "path traversal not allowed" }, 403);
     }
     let real;
     let realRoot;
     try {
-      real = fs87.realpathSync(resolved);
-      realRoot = fs87.realpathSync(root);
+      real = fs88.realpathSync(resolved);
+      realRoot = fs88.realpathSync(root);
     } catch {
       return c.json({ error: "file not found" }, 404);
     }
-    if (real !== realRoot && !real.startsWith(realRoot + path98.default.sep)) {
+    if (real !== realRoot && !real.startsWith(realRoot + path99.default.sep)) {
       return c.json({ error: "path traversal not allowed" }, 403);
     }
     if (isHiddenWorkspacePath(real, realRoot)) {
       return c.json({ error: "path is not accessible" }, 403);
     }
-    const stat = fs87.statSync(real);
+    const stat = fs88.statSync(real);
     if (stat.isDirectory())
       return c.json({ error: "cannot serve directory" }, 400);
-    const ext = path98.default.extname(real).toLowerCase();
+    const ext = path99.default.extname(real).toLowerCase();
     const nonImageMimes = {
       ".mp4": "video/mp4",
       ".webm": "video/webm",
@@ -39568,8 +39764,8 @@ function createWebRoutes(deps) {
       ".txt": "text/plain"
     };
     const contentType = imageMimeFromExt(ext) || nonImageMimes[ext] || "application/octet-stream";
-    const fileName = path98.default.basename(resolved);
-    const data = fs87.readFileSync(real);
+    const fileName = path99.default.basename(resolved);
+    const data = fs88.readFileSync(real);
     c.header("content-type", contentType);
     c.header("content-disposition", `inline; filename="${fileName}"`);
     return c.body(data);
@@ -39791,10 +39987,10 @@ async function authTest(botToken) {
   return slackPost("auth.test", botToken, {});
 }
 async function uploadFile(args) {
-  const fs92 = await import("node:fs");
-  const path98 = await import("node:path");
-  const filename = args.filename ?? path98.basename(args.filePath);
-  const stat = fs92.statSync(args.filePath);
+  const fs93 = await import("node:fs");
+  const path99 = await import("node:path");
+  const filename = args.filename ?? path99.basename(args.filePath);
+  const stat = fs93.statSync(args.filePath);
   if (!stat.isFile())
     throw new Error(`[slack:uploadFile] not a regular file: ${args.filePath}`);
   const length = stat.size;
@@ -39812,7 +40008,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 = fs92.readFileSync(args.filePath);
+  const buf = fs93.readFileSync(args.filePath);
   const step2 = await fetch(step1Parsed.upload_url, {
     method: "POST",
     body: buf
@@ -39957,7 +40153,7 @@ var init_api2 = __esm({
 });
 
 // ../server/dist/channels/slack/handler.js
-import path91 from "node:path";
+import path92 from "node:path";
 import { WebSocket as WebSocket3 } from "ws";
 function slashToBang(text6, commandNames) {
   if (commandNames.length === 0)
@@ -40088,7 +40284,7 @@ function startSlackChannel(deps) {
             const route = bridge.getRoute(sessionId);
             if (!account || !route)
               return;
-            const resolved = path91.resolve(filePath);
+            const resolved = path92.resolve(filePath);
             await sendMediaOrReport({
               filePath,
               account,
@@ -40732,10 +40928,10 @@ async function replyMessage(args) {
   return { message_id: parsed.data?.message_id ?? "" };
 }
 async function uploadImage(args) {
-  const fs92 = await import("node:fs");
-  const path98 = await import("node:path");
-  const buf = fs92.readFileSync(args.filePath);
-  const filename = path98.basename(args.filePath);
+  const fs93 = await import("node:fs");
+  const path99 = await import("node:path");
+  const buf = fs93.readFileSync(args.filePath);
+  const filename = path99.basename(args.filePath);
   const send2 = async (token) => {
     const form = new FormData();
     form.append("image_type", "message");
@@ -40751,10 +40947,10 @@ async function uploadImage(args) {
   return { imageKey: parsed.data.image_key };
 }
 async function uploadFile2(args) {
-  const fs92 = await import("node:fs");
-  const path98 = await import("node:path");
-  const buf = fs92.readFileSync(args.filePath);
-  const filename = args.filename ?? path98.basename(args.filePath);
+  const fs93 = await import("node:fs");
+  const path99 = await import("node:path");
+  const buf = fs93.readFileSync(args.filePath);
+  const filename = args.filename ?? path99.basename(args.filePath);
   const send2 = async (token) => {
     const form = new FormData();
     form.append("file_type", args.fileType);
@@ -40821,8 +41017,7 @@ var init_api3 = __esm({
 });
 
 // ../server/dist/channels/feishu/handler.js
-import path92 from "node:path";
-import * as Lark from "@larksuiteoapi/node-sdk";
+import path93 from "node:path";
 function buildSessionPrefixForThread2(chatId, rootId) {
   return sessionPrefix("feishu", `${chatId}:${rootId}`);
 }
@@ -41024,7 +41219,7 @@ function startFeishuChannel(deps) {
             const route = bridge.getRoute(sessionId);
             if (!account || !route)
               return;
-            const resolved = path92.resolve(filePath);
+            const resolved = path93.resolve(filePath);
             await sendMediaOrReport({
               filePath,
               account,
@@ -41069,13 +41264,16 @@ function startFeishuChannel(deps) {
     const state = ensureState(accountId);
     if (state.stopped || state.wsClient)
       return;
-    const wsClient = new Lark.WSClient({
+    const { WSClient: WSClient2, EventDispatcher, LoggerLevel } = await import("./feishu-sdk.cjs");
+    if (state.stopped || state.wsClient)
+      return;
+    const wsClient = new WSClient2({
       appId: account.appId,
       appSecret: account.appSecret,
-      loggerLevel: Lark.LoggerLevel.warn
+      loggerLevel: LoggerLevel.warn
     });
     state.wsClient = wsClient;
-    const dispatcher = new Lark.EventDispatcher({});
+    const dispatcher = new EventDispatcher({});
     dispatcher.register({
       "im.message.receive_v1": async (data) => {
         dispatchEvent(accountId, data);
@@ -41191,7 +41389,7 @@ async function replyToInbound(args) {
 async function sendFeishuMedia(args) {
   const { account, inboundMessageId, isP2P, chatId, filePath } = args;
   const cls = classifyMedia(filePath);
-  const ext = path92.extname(filePath).toLowerCase();
+  const ext = path93.extname(filePath).toLowerCase();
   if (cls === "image") {
     const { imageKey } = await uploadImage({ appId: account.appId, appSecret: account.appSecret, filePath });
     await replyToInboundRaw({
@@ -41586,9 +41784,9 @@ var init_event_adapter5 = __esm({
 });
 
 // ../server/dist/channels/wecom/handler.js
-import path93 from "node:path";
-import fs88 from "node:fs/promises";
-import { WSClient as WSClient2, generateReqId } from "@wecom/aibot-node-sdk";
+import path94 from "node:path";
+import fs89 from "node:fs/promises";
+import { WSClient, generateReqId } from "@wecom/aibot-node-sdk";
 function pickConversation(body) {
   const userid = body.from?.userid ?? "unknown";
   if (body.chattype === "group" && body.chatid) {
@@ -41710,13 +41908,13 @@ async function replyText(wsClient, route, text6) {
 }
 async function sendWecomMedia(args) {
   const { wsClient, route, filePath } = args;
-  const ext = path93.extname(filePath).toLowerCase();
+  const ext = path94.extname(filePath).toLowerCase();
   const cls = classifyMedia(filePath);
   const type = cls === "image" && [".png", ".jpg", ".jpeg", ".gif"].includes(ext) ? "image" : cls === "video" && ext === ".mp4" ? "video" : "file";
-  const buf = await fs88.readFile(filePath);
+  const buf = await fs89.readFile(filePath);
   if (buf.length > MAX_WECOM_DOWNLOAD_BYTES)
     throw new Error("file exceeds 20MB");
-  const { media_id: mediaId } = await wsClient.uploadMedia(buf, { type, filename: path93.basename(filePath) });
+  const { media_id: mediaId } = await wsClient.uploadMedia(buf, { type, filename: path94.basename(filePath) });
   if (route.reqId)
     await wsClient.replyMedia({ headers: { req_id: route.reqId } }, type, mediaId);
   else
@@ -41761,7 +41959,7 @@ function startWecomChannel(deps) {
             const wsClient = states.get(accountId)?.wsClient;
             if (!account || !route || !wsClient)
               return;
-            const resolved = path93.resolve(filePath);
+            const resolved = path94.resolve(filePath);
             await sendMediaOrReport({
               filePath,
               account,
@@ -41820,7 +42018,7 @@ function startWecomChannel(deps) {
     const state = ensureState(accountId);
     if (state.stopped || state.wsClient)
       return;
-    const wsClient = new WSClient2({
+    const wsClient = new WSClient({
       botId: account.botId,
       secret: account.secret,
       maxReconnectAttempts: -1,
@@ -42249,17 +42447,17 @@ import { cors } from "hono/cors";
 import { serve } from "@hono/node-server";
 import { serveStatic } from "@hono/node-server/serve-static";
 import { WebSocketServer as WebSocketServer5 } from "ws";
-import path94 from "node:path";
-import fs89 from "node:fs";
+import path95 from "node:path";
+import fs90 from "node:fs";
 import { spawnSync as spawnSync4 } from "node:child_process";
 import { homedir as homedir26 } from "node:os";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 function findProjectRoot() {
   let dir = process.cwd();
   for (let i = 0; i < 32; i++) {
-    if (fs89.existsSync(path94.join(dir, "pnpm-workspace.yaml")))
+    if (fs90.existsSync(path95.join(dir, "pnpm-workspace.yaml")))
       return dir;
-    const parent = path94.dirname(dir);
+    const parent = path95.dirname(dir);
     if (parent === dir)
       break;
     dir = parent;
@@ -42269,15 +42467,15 @@ function findProjectRoot() {
   return process.cwd();
 }
 function acquireSingleInstanceLock(lockFile) {
-  fs89.mkdirSync(path94.dirname(lockFile), { recursive: true });
-  const fd = fs89.openSync(lockFile, fs89.constants.O_RDWR | fs89.constants.O_CREAT, 420);
+  fs90.mkdirSync(path95.dirname(lockFile), { recursive: true });
+  const fd = fs90.openSync(lockFile, fs90.constants.O_RDWR | fs90.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)) {
-      fs89.closeSync(fd);
+      fs90.closeSync(fd);
       console.error(`[Server] another halo server is already running (pid ${content}). kill it first.`);
       process.exit(1);
     }
@@ -42286,19 +42484,19 @@ function acquireSingleInstanceLock(lockFile) {
     if (content > 0 && !isProcessAlive(content)) {
       console.warn(`[Server] removing stale server.lock (pid ${content} not running)`);
     } else {
-      fs89.closeSync(fd);
+      fs90.closeSync(fd);
       console.error(`[Server] another halo server is already running${content > 0 ? ` (pid ${content})` : ""}. kill it first.`);
       process.exit(1);
     }
   }
-  fs89.ftruncateSync(fd);
-  fs89.writeSync(fd, String(process.pid));
-  fs89.fsyncSync(fd);
+  fs90.ftruncateSync(fd);
+  fs90.writeSync(fd, String(process.pid));
+  fs90.fsyncSync(fd);
 }
 function readLockPid(fd) {
   try {
     const buf = Buffer.alloc(32);
-    const n = fs89.readSync(fd, buf, 0, 32, 0);
+    const n = fs90.readSync(fd, buf, 0, 32, 0);
     return parseInt(buf.subarray(0, n).toString("utf-8").trim(), 10) || 0;
   } catch {
     return 0;
@@ -42326,7 +42524,7 @@ function isProcessAlive(pid) {
   }
 }
 function readGitSha() {
-  if (!fs89.existsSync(path94.join(PROJECT_ROOT, "pnpm-workspace.yaml")) || !fs89.existsSync(path94.join(PROJECT_ROOT, ".git")))
+  if (!fs90.existsSync(path95.join(PROJECT_ROOT, "pnpm-workspace.yaml")) || !fs90.existsSync(path95.join(PROJECT_ROOT, ".git")))
     return null;
   try {
     const rev = spawnSync4("git", ["rev-parse", "--short", "HEAD"], { cwd: PROJECT_ROOT, encoding: "utf-8" });
@@ -42347,14 +42545,14 @@ function applySandboxPaths() {
 }
 function resolveFrontendDir() {
   if (process.env.HALO_FRONTEND_DIR)
-    return path94.resolve(process.env.HALO_FRONTEND_DIR);
-  const bundled = path94.resolve(__dirname3, "..", "admin-out");
-  if (fs89.existsSync(path94.join(bundled, "index.html")))
+    return path95.resolve(process.env.HALO_FRONTEND_DIR);
+  const bundled = path95.resolve(__dirname3, "..", "admin-out");
+  if (fs90.existsSync(path95.join(bundled, "index.html")))
     return bundled;
-  const sibling = path94.resolve(__dirname3, "..", "..", "admin", "out");
-  if (fs89.existsSync(path94.join(sibling, "index.html")))
+  const sibling = path95.resolve(__dirname3, "..", "..", "admin", "out");
+  if (fs90.existsSync(path95.join(sibling, "index.html")))
     return sibling;
-  return path94.resolve(PROJECT_ROOT, "packages", "admin", "out");
+  return path95.resolve(PROJECT_ROOT, "packages", "admin", "out");
 }
 async function gracefulShutdown(signal) {
   beginShutdown();
@@ -42461,13 +42659,13 @@ var init_dist2 = __esm({
     init_sandbox();
     init_init();
     init_git_ssh();
-    __dirname3 = path94.dirname(fileURLToPath3(import.meta.url));
+    __dirname3 = path95.dirname(fileURLToPath3(import.meta.url));
     PORT = config.server.port;
-    HALO_VERSION = "2.2.4";
+    HALO_VERSION = "2.2.6";
     PROJECT_ROOT = findProjectRoot();
-    HALO_HOME4 = path94.join(homedir26(), ".halo");
+    HALO_HOME4 = path95.join(homedir26(), ".halo");
     GIT_SHA = readGitSha();
-    if (!fs89.existsSync(path94.join(HALO_HOME4, "global", ".template-version"))) {
+    if (!fs90.existsSync(path95.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);
     }
@@ -42478,7 +42676,7 @@ var init_dist2 = __esm({
       process.exit(1);
     }
     if (!AGENTCORE)
-      acquireSingleInstanceLock(path94.join(HALO_HOME4, "global", "server.lock"));
+      acquireSingleInstanceLock(path95.join(HALO_HOME4, "global", "server.lock"));
     commandRegistry.assertDispatchCommands(DISPATCH_COMMANDS);
     await initObservability();
     initLogger();
@@ -42549,14 +42747,14 @@ var init_dist2 = __esm({
       app.route("/api", createJupyterRoutes(jupyter));
     }
     start2();
-    channelDb = createChannelDb(path94.join(HALO_HOME4, "secrets"));
+    channelDb = createChannelDb(path95.join(HALO_HOME4, "secrets"));
     setChannelDb(channelDb);
     nodeHub = AGENTCORE ? null : createNodeHub({ db: channelDb });
     setNodeHub(nodeHub);
-    setEvoDb(createEvoDb(path94.join(HALO_HOME4, "global")));
-    setCronDb(createCronDb(path94.join(HALO_HOME4, "global")));
+    setEvoDb(createEvoDb(path95.join(HALO_HOME4, "global")));
+    setCronDb(createCronDb(path95.join(HALO_HOME4, "global")));
     if (!AGENTCORE)
-      setRunsDb(createRunsDb(path94.join(HALO_HOME4, "global")));
+      setRunsDb(createRunsDb(path95.join(HALO_HOME4, "global")));
     setEvoSpawner(realEvoSpawner);
     if (!AGENTCORE) {
       startEvoTicker();
@@ -42572,7 +42770,7 @@ var init_dist2 = __esm({
     setEvoSessionRegistry(registry);
     if (OWNS_RUNTIMES && !AGENTCORE) {
       for (const ws of listRunningWorkspaces()) {
-        if (!fs89.existsSync(path94.join(ws, ".halo")))
+        if (!fs90.existsSync(path95.join(ws, ".halo")))
           continue;
         if (!claimWorkspaceRuntime(ws))
           continue;
@@ -42600,7 +42798,7 @@ var init_dist2 = __esm({
       startCronDaemon();
     }
     if (!AGENTCORE) {
-      setA2ADb(createA2ADb(path94.join(HALO_HOME4, "global")));
+      setA2ADb(createA2ADb(path95.join(HALO_HOME4, "global")));
       setA2AOutboundRegistry(registry);
       app.route("/a2a", createA2ARoutes({ registry, ownsRuntimes: OWNS_RUNTIMES }));
       app.route("/", createA2APushRoutes());
@@ -42617,7 +42815,7 @@ var init_dist2 = __esm({
     FRONTEND_DIR = resolveFrontendDir();
     if (!AGENTCORE) {
       app.use("/*", serveStatic({
-        root: path94.relative(process.cwd(), FRONTEND_DIR),
+        root: path95.relative(process.cwd(), FRONTEND_DIR),
         // Next's `/_next/static/` files are content-hashed (under a buildId dir),
         // so they can be cached forever. Only on a found file — the SPA fallback
         // below must stay uncached, or a missing chunk caches index.html as js.
@@ -42631,9 +42829,9 @@ var init_dist2 = __esm({
       app.get("/*", (c) => {
         if (c.req.path.startsWith("/_next/static/"))
           return c.notFound();
-        const indexPath = path94.join(FRONTEND_DIR, "index.html");
+        const indexPath = path95.join(FRONTEND_DIR, "index.html");
         try {
-          const html = fs89.readFileSync(indexPath, "utf-8");
+          const html = fs90.readFileSync(indexPath, "utf-8");
           return c.html(html);
         } catch {
           return c.text("Frontend not built. Run: cd packages/admin && npx next build", 503);
@@ -42724,10 +42922,10 @@ __export(agentcore_front_exports, {
   workerEnv: () => workerEnv
 });
 import http3 from "node:http";
-import fs90 from "node:fs";
+import fs91 from "node:fs";
 import fsp2 from "node:fs/promises";
-import os11 from "node:os";
-import path95 from "node:path";
+import os12 from "node:os";
+import path96 from "node:path";
 import crypto16 from "node:crypto";
 import { pipeline as pipeline2 } from "node:stream";
 import { execFile as execFile2, spawn as spawn6 } from "node:child_process";
@@ -42750,44 +42948,44 @@ function mountLayers(dir, mountinfo) {
   }).length;
 }
 function skipTemplateEntry(rel) {
-  const name = path95.basename(rel);
-  return rel === path95.join(".halo", "sessions") || /\.db(-wal|-shm|-journal)?$/.test(name) || name === "runtime.lock" || name.startsWith("agentcore.lease");
+  const name = path96.basename(rel);
+  return rel === path96.join(".halo", "sessions") || /\.db(-wal|-shm|-journal)?$/.test(name) || name === "runtime.lock" || name.startsWith("agentcore.lease");
 }
 function chownTree(dir, owner, sid) {
   try {
-    fs90.lchownSync(dir, owner.uid, owner.gid);
-    for (const rel of fs90.readdirSync(dir, { recursive: true }))
-      fs90.lchownSync(path95.join(dir, rel), owner.uid, owner.gid);
+    fs91.lchownSync(dir, owner.uid, owner.gid);
+    for (const rel of fs91.readdirSync(dir, { recursive: true }))
+      fs91.lchownSync(path96.join(dir, rel), owner.uid, owner.gid);
   } catch (err) {
     console.warn(`[AgentCore] front: chown ${sid} to ${owner.uid}:${owner.gid} failed (${err.message}) \u2014 serving it as is`);
   }
 }
 function ensureSessionDir(base, sid, owner) {
-  const dir = path95.join(base, sid);
-  if (fs90.existsSync(dir))
+  const dir = path96.join(base, sid);
+  if (fs91.existsSync(dir))
     return false;
-  const tmp = path95.join(base, `.tmp-${crypto16.randomBytes(8).toString("hex")}`);
-  fs90.mkdirSync(tmp, { mode: 448 });
+  const tmp = path96.join(base, `.tmp-${crypto16.randomBytes(8).toString("hex")}`);
+  fs91.mkdirSync(tmp, { mode: 448 });
   try {
-    const template = path95.join(base, TEMPLATE_DIR);
-    if (fs90.statSync(template, { throwIfNoEntry: false })?.isDirectory()) {
-      fs90.cpSync(template, tmp, { recursive: true, verbatimSymlinks: true, filter: (src) => !skipTemplateEntry(path95.relative(template, src)) });
+    const template = path96.join(base, TEMPLATE_DIR);
+    if (fs91.statSync(template, { throwIfNoEntry: false })?.isDirectory()) {
+      fs91.cpSync(template, tmp, { recursive: true, verbatimSymlinks: true, filter: (src) => !skipTemplateEntry(path96.relative(template, src)) });
     }
     if (owner)
       chownTree(tmp, owner, sid);
-    if (fs90.readdirSync(tmp).length === 0) {
-      fs90.rmdirSync(tmp);
-      fs90.mkdirSync(dir, { mode: 448 });
+    if (fs91.readdirSync(tmp).length === 0) {
+      fs91.rmdirSync(tmp);
+      fs91.mkdirSync(dir, { mode: 448 });
       if (owner)
         chownTree(dir, owner, sid);
       return true;
     }
-    fs90.renameSync(tmp, dir);
+    fs91.renameSync(tmp, dir);
     return true;
   } catch (err) {
-    fs90.rmSync(tmp, { recursive: true, force: true });
+    fs91.rmSync(tmp, { recursive: true, force: true });
     const code = err.code;
-    if ((code === "EEXIST" || code === "ENOTEMPTY") && fs90.existsSync(dir))
+    if ((code === "EEXIST" || code === "ENOTEMPTY") && fs91.existsSync(dir))
       return false;
     throw err;
   }
@@ -42831,7 +43029,7 @@ async function runViewSetup(base, sessionDir, deps = SYSTEM_SETUP) {
   const left = mountLayers(base, deps.mountinfo());
   if (left > 0)
     throw new Error(`view setup: ${base} still has ${left} mount(s) after ${MAX_UMOUNTS} \xD7 umount -l`);
-  if (fs90.existsSync(sessionDir))
+  if (fs91.existsSync(sessionDir))
     throw new Error(`view setup: ${base} is still visible after umount -l`);
 }
 function workerEnv(src, front) {
@@ -42846,19 +43044,19 @@ function workerEnv(src, front) {
   return env;
 }
 async function copyMediaFile(p, root, dest, max = MAX_MEDIA_BYTES) {
-  if (!path95.isAbsolute(p))
+  if (!path96.isAbsolute(p))
     return "not an absolute path";
   let pfd;
   try {
-    pfd = fs90.openSync(p, O_PATH);
+    pfd = fs91.openSync(p, O_PATH);
   } catch (err) {
     return `cannot open (${err.code})`;
   }
   try {
-    const link = fs90.readlinkSync(`/proc/self/fd/${pfd}`);
+    const link = fs91.readlinkSync(`/proc/self/fd/${pfd}`);
     if (!link.startsWith(`${root}/`))
       return `not under ${root}/`;
-    const st = fs90.fstatSync(pfd);
+    const st = fs91.fstatSync(pfd);
     if (!st.isFile())
       return "not a regular file";
     if (st.size > max)
@@ -42885,7 +43083,7 @@ async function copyMediaFile(p, root, dest, max = MAX_MEDIA_BYTES) {
       await src.close();
     }
   } finally {
-    fs90.closeSync(pfd);
+    fs91.closeSync(pfd);
   }
 }
 async function copyMediaLines(text6, root, dir, sid) {
@@ -42897,16 +43095,16 @@ async function copyMediaLines(text6, root, dir, sid) {
       out.push(line);
       continue;
     }
-    const sub = path95.join(dir, String(n++));
-    fs90.mkdirSync(sub);
-    const name = path95.basename(m[1]).replace(/[\x00-\x1f\x7f]/g, "_").replace(/^\.+/, "") || "file";
-    const dest = path95.join(sub, name);
+    const sub = path96.join(dir, String(n++));
+    fs91.mkdirSync(sub);
+    const name = path96.basename(m[1]).replace(/[\x00-\x1f\x7f]/g, "_").replace(/^\.+/, "") || "file";
+    const dest = path96.join(sub, name);
     const why = await copyMediaFile(m[1], root, dest).catch((err) => err.message);
     if (why === null) {
       out.push(`MEDIA:${dest}`);
       continue;
     }
-    fs90.rmSync(sub, { recursive: true, force: true });
+    fs91.rmSync(sub, { recursive: true, force: true });
     console.warn(`[AgentCore] notify ${sid}: MEDIA dropped (${why}): ${JSON.stringify(m[1].slice(0, 300))}`);
   }
   return out.join("\n");
@@ -42950,7 +43148,7 @@ function readBody(req, max) {
   });
 }
 async function startAgentCoreFront(o) {
-  const base = fs90.realpathSync(o.base);
+  const base = fs91.realpathSync(o.base);
   const workerPort = o.workerPort ?? WORKER_PORT;
   const token = crypto16.randomBytes(32).toString("hex");
   const isMounted = o.isMounted ?? ((b) => mountLayers(b, readMountinfo()) > 0);
@@ -43012,11 +43210,11 @@ async function startAgentCoreFront(o) {
     preparing++;
     let dir = "";
     const cleanup = () => {
-      fs90.rmSync(dir, { recursive: true, force: true });
+      fs91.rmSync(dir, { recursive: true, force: true });
       settle();
     };
     try {
-      dir = fs90.mkdtempSync(path95.join(os11.tmpdir(), "halo-notify-"));
+      dir = fs91.mkdtempSync(path96.join(os12.tmpdir(), "halo-notify-"));
       const text6 = await copyMediaLines(b.text, viewRoot, dir, b.session);
       runNotify(cmd, text6, { HALO_SESSION_ID: b.session, HALO_RUN_STATUS: b.status, HALO_WORKSPACE: dir }, dir, cleanup);
     } catch (err) {
@@ -43031,7 +43229,7 @@ async function startAgentCoreFront(o) {
   const activate = async (sid) => {
     if (!isMounted(base))
       throw Object.assign(new Error(`${base} is not a mount point (the EFS not mounted yet, or HALO_WORKSPACE is not its mount path) \u2014 refusing to serve the image's empty dir`), { status: 503 });
-    const sessionDir = path95.join(base, sid);
+    const sessionDir = path96.join(base, sid);
     if (ensureSessionDir(base, sid, { uid: WORKER_UID, gid: WORKER_GID }))
       console.log(`[AgentCore] front: created ${sessionDir}`);
     try {
@@ -43186,7 +43384,7 @@ async function runAgentCoreFront(o) {
     throw new Error("HALO_AGENTCORE_SESSION_DIRS=1 needs root (bind mount, umount); the worker drops to an unprivileged uid itself");
   if (o.port === WORKER_PORT)
     throw new Error(`port ${WORKER_PORT} is the worker's loopback port \u2014 pick another HALO_PORT`);
-  const base = path95.resolve(o.base);
+  const base = path96.resolve(o.base);
   const overlaps = (a, b) => a === b || a.startsWith(b === "/" ? "/" : `${b}/`);
   if (overlaps(WORKER_ROOT, base) || overlaps(base, WORKER_ROOT))
     throw new Error(`HALO_WORKSPACE (${base}) must not overlap ${WORKER_ROOT}`);
@@ -43233,7 +43431,7 @@ var init_agentcore_front = __esm({
     MAX_MEDIA_BYTES = 20 * 1024 * 1024;
     O_PATH = 2097152;
     execFileP = promisify3(execFile2);
-    readMountinfo = () => fs90.readFileSync("/proc/self/mountinfo", "utf8");
+    readMountinfo = () => fs91.readFileSync("/proc/self/mountinfo", "utf8");
     SYSTEM_SETUP = {
       mountinfo: readMountinfo,
       exec: (argv) => execFileP(argv[0], argv.slice(1), { timeout: SETUP_TIMEOUT_MS })
@@ -43413,8 +43611,8 @@ var init_halo_client = __esm({
         }
         return await res.json();
       }
-      sessionUrl(path98, workspace, sessionId) {
-        const url = new URL(`${this.opts.baseUrl}${path98}`);
+      sessionUrl(path99, workspace, sessionId) {
+        const url = new URL(`${this.opts.baseUrl}${path99}`);
         url.searchParams.set("workspace", workspace);
         url.searchParams.set("sessionId", sessionId);
         return url;
@@ -43562,7 +43760,7 @@ var init_version = __esm({
 });
 
 // ../acp-adapter/dist/adapter.js
-import path96 from "node:path";
+import path97 from "node:path";
 function composePrompt(blocks) {
   const segments = [];
   let run = "";
@@ -43755,7 +43953,7 @@ var init_adapter = __esm({
         if (cursor !== void 0 && !/^\d+$/.test(cursor))
           throw newError(`invalid cursor: ${cursor}`, -32602);
         const page = await this.client.listSessions(this.config.workspace, cursor === void 0 ? void 0 : Number(cursor));
-        if (p.cwd !== void 0 && path96.resolve(p.cwd) !== path96.resolve(page.workspace))
+        if (p.cwd !== void 0 && path97.resolve(p.cwd) !== path97.resolve(page.workspace))
           return { sessions: [] };
         return {
           sessions: page.sessions.map((s) => ({
@@ -44369,8 +44567,8 @@ process.emitWarning = (warning, ...args) => {
 
 // src/index.ts
 init_server_supervisor();
-import path97 from "node:path";
-import fs91 from "node:fs";
+import path98 from "node:path";
+import fs92 from "node:fs";
 import { homedir as homedir27, userInfo } from "node:os";
 import { parseArgs as parseArgs2 } from "node:util";
 
@@ -44661,7 +44859,7 @@ function installUserUnit(opts, run = runCommand) {
 }
 
 // src/index.ts
-var VERSION = "2.2.4";
+var VERSION = "2.2.6";
 var HELP_TOP = `Usage: halo <command> [options]
 
 Commands:
@@ -45028,8 +45226,8 @@ async function cmdSetup(argv = []) {
   const { buildBindProviderPlan: buildBindProviderPlan2, envKeyPlaceholders: envKeyPlaceholders2, 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 = path97.join(homedir27(), ".halo");
-  const globalDir2 = path97.join(haloHome2, "global");
+  const haloHome2 = path98.join(homedir27(), ".halo");
+  const globalDir2 = path98.join(haloHome2, "global");
   ensureHaloHome2(haloHome2);
   process.stderr.write(`[setup] ${haloHome2}/ ready
 `);
@@ -45382,7 +45580,7 @@ async function cmdUpgrade() {
 `);
       process.exit(1);
     }
-    const broken = verifyNativeModules2(path97.join(rootDir, PKG));
+    const broken = verifyNativeModules2(path98.join(rootDir, PKG));
     if (broken.length > 0) {
       process.stderr.write(
         `
@@ -45413,7 +45611,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 = path97.resolve(flags.workspace ?? process.cwd());
+  const workspace = path98.resolve(flags.workspace ?? process.cwd());
   const agents = await listAgents2(workspace);
   if (agents.length === 0) {
     process.stderr.write("No agents found.\n");
@@ -45436,12 +45634,12 @@ ${HELP_SESSIONS}`);
       process.exitCode = 1;
       return;
     }
-    await cmdSessionsMigrate(path97.resolve(flags.workspace ?? process.cwd()));
+    await cmdSessionsMigrate(path98.resolve(flags.workspace ?? process.cwd()));
     return;
   }
   const { initRuntime: initRuntime2, listSessions: listSessions2 } = await Promise.resolve().then(() => (init_harness(), harness_exports));
   await initRuntime2();
-  const workspace = path97.resolve(flags.workspace ?? process.cwd());
+  const workspace = path98.resolve(flags.workspace ?? process.cwd());
   const sessions = listSessions2(workspace);
   if (sessions.length === 0) {
     process.stderr.write("No sessions found.\n");
@@ -45455,7 +45653,7 @@ ${HELP_SESSIONS}`);
   }
 }
 async function cmdSessionsMigrate(workspace) {
-  if (!fs91.existsSync(path97.join(workspace, ".halo"))) {
+  if (!fs92.existsSync(path98.join(workspace, ".halo"))) {
     process.stderr.write(`Not a Halo workspace (no .halo/): ${workspace}
 `);
     process.exitCode = 1;
@@ -45487,7 +45685,7 @@ async function cmdModels(argv) {
     process.exitCode = 1;
     return;
   }
-  const plan = mod.planModelsInstall(path97.resolve(dir));
+  const plan = mod.planModelsInstall(path98.resolve(dir));
   for (const line of mod.formatPlan(plan)) process.stdout.write(`${line}
 `);
   if (plan.needsConfirm && !values.yes) {
@@ -45596,11 +45794,11 @@ ${stdinContent}` : stdinContent;
     harness.destroy();
   }
 }
-var SERVER_LOCK_PATH = path97.join(homedir27(), ".halo", "global", "server.lock");
-var SERVER_LOG_PATH = path97.join(homedir27(), ".halo", "logs", "server.log");
+var SERVER_LOCK_PATH = path98.join(homedir27(), ".halo", "global", "server.lock");
+var SERVER_LOG_PATH = path98.join(homedir27(), ".halo", "logs", "server.log");
 function readServerPid() {
   try {
-    const txt = fs91.readFileSync(SERVER_LOCK_PATH, "utf-8").trim();
+    const txt = fs92.readFileSync(SERVER_LOCK_PATH, "utf-8").trim();
     const n = parseInt(txt, 10);
     return Number.isFinite(n) && n > 0 ? n : null;
   } catch {
@@ -45707,8 +45905,8 @@ async function cmdServerStart(argv, restart) {
   }
   if (plan.note) writeDim(plan.note);
   const { spawn: spawn7 } = await import("node:child_process");
-  fs91.mkdirSync(path97.dirname(SERVER_LOG_PATH), { recursive: true });
-  const out = fs91.openSync(SERVER_LOG_PATH, "a");
+  fs92.mkdirSync(path98.dirname(SERVER_LOG_PATH), { recursive: true });
+  const out = fs92.openSync(SERVER_LOG_PATH, "a");
   const child = spawn7(process.argv[0], [process.argv[1], "server", "start"], {
     detached: true,
     stdio: ["ignore", out, out],
@@ -45789,8 +45987,8 @@ ${HELP_AGENTCORE}`);
     process.exitCode = 1;
     return;
   }
-  const workspace = path97.resolve(raw);
-  if (!fs91.statSync(workspace, { throwIfNoEntry: false })?.isDirectory()) {
+  const workspace = path98.resolve(raw);
+  if (!fs92.statSync(workspace, { throwIfNoEntry: false })?.isDirectory()) {
     process.stderr.write(`Workspace is not a directory: ${workspace}
 `);
     process.exitCode = 1;
@@ -45901,7 +46099,7 @@ async function cmdServerLogs(argv) {
       lines: { type: "string", short: "n" }
     }
   });
-  if (!fs91.existsSync(SERVER_LOG_PATH)) {
+  if (!fs92.existsSync(SERVER_LOG_PATH)) {
     process.stderr.write(`No log file at ${SERVER_LOG_PATH}
 `);
     return;
@@ -45919,7 +46117,7 @@ function exitMissingSetup() {
   process.exit(1);
 }
 function isHaloHomeReady() {
-  return fs91.existsSync(path97.join(homedir27(), ".halo", "global", ".template-version"));
+  return fs92.existsSync(path98.join(homedir27(), ".halo", "global", ".template-version"));
 }
 async function main2() {
   const argv = process.argv.slice(2);