@turmind/halo 1.6.4 → 1.6.5

package/dist/index.js

@@ -1381,6 +1381,9 @@ function globalHubModelsDir() {
 function globalExtensionsDir() {
   return path6.join(globalDir(), "extensions");
 }
+function globalSttModelsDir() {
+  return path6.join(globalDir(), "stt-models");
+}
 function globalLogsDir() {
   return path6.join(globalDir(), "logs");
 }
@@ -1566,7 +1569,79 @@ function parseManifest(raw, dirName, entryExists) {
     return { error: "version must be semver (x.y.z[-pre])" };
   if (m.description !== void 0 && (typeof m.description !== "string" || m.description.length > 200))
     return { error: "description must be a string (\u2264 200 chars)" };
-  if (!Array.isArray(m.extensions) || m.extensions.length === 0)
+  let activity;
+  if (m.activity !== void 0) {
+    if (typeof m.activity !== "object" || m.activity === null || Array.isArray(m.activity))
+      return { error: "activity must be an object" };
+    const a = m.activity;
+    activity = { order: 100 };
+    if (a.icon !== void 0) {
+      if (typeof a.icon !== "string" || a.icon === "" || a.icon.startsWith("/") || a.icon.split(/[\\/]/).includes("..") || !/\.(svg|png)$/i.test(a.icon)) {
+        return { error: "activity.icon must be a relative .svg or .png path inside the extension directory" };
+      }
+      if (!entryExists(a.icon))
+        return { error: `activity icon not found: ${a.icon}` };
+      activity.icon = a.icon;
+    }
+    for (const k of ["title", "title_zh"]) {
+      const v = a[k];
+      if (v === void 0)
+        continue;
+      if (typeof v !== "string" || v.trim() === "" || v.length > 64)
+        return { error: `activity.${k} must be a non-empty string (\u2264 64 chars)` };
+      activity[k] = v;
+    }
+    for (const k of ["description", "description_zh"]) {
+      const v = a[k];
+      if (v === void 0)
+        continue;
+      if (typeof v !== "string" || v.length > 200)
+        return { error: `activity.${k} must be a string (\u2264 200 chars)` };
+      activity[k] = v;
+    }
+    if (a.order !== void 0) {
+      if (typeof a.order !== "number" || !Number.isInteger(a.order) || a.order < 0 || a.order > 1e3)
+        return { error: "activity.order must be an integer 0\u20131000" };
+      activity.order = a.order;
+    }
+  }
+  let chatbar;
+  if (m.chatbar !== void 0) {
+    if (typeof m.chatbar !== "object" || m.chatbar === null || Array.isArray(m.chatbar))
+      return { error: "chatbar must be an object" };
+    const c = m.chatbar;
+    chatbar = { height: 160, order: 100 };
+    if (c.icon !== void 0) {
+      if (typeof c.icon !== "string" || c.icon === "" || c.icon.startsWith("/") || c.icon.split(/[\\/]/).includes("..") || !/\.(svg|png)$/i.test(c.icon)) {
+        return { error: "chatbar.icon must be a relative .svg or .png path inside the extension directory" };
+      }
+      if (!entryExists(c.icon))
+        return { error: `chatbar icon not found: ${c.icon}` };
+      chatbar.icon = c.icon;
+    }
+    for (const k of ["title", "title_zh"]) {
+      const v = c[k];
+      if (v === void 0)
+        continue;
+      if (typeof v !== "string" || v.trim() === "" || v.length > 64)
+        return { error: `chatbar.${k} must be a non-empty string (\u2264 64 chars)` };
+      chatbar[k] = v;
+    }
+    if (c.height !== void 0) {
+      if (typeof c.height !== "number" || !Number.isInteger(c.height) || c.height < 80 || c.height > 480)
+        return { error: "chatbar.height must be an integer 80\u2013480" };
+      chatbar.height = c.height;
+    }
+    if (c.order !== void 0) {
+      if (typeof c.order !== "number" || !Number.isInteger(c.order) || c.order < 0 || c.order > 1e3)
+        return { error: "chatbar.order must be an integer 0\u20131000" };
+      chatbar.order = c.order;
+    }
+  }
+  if (activity || chatbar) {
+    if (!Array.isArray(m.extensions))
+      return { error: "extensions must be an array (empty is fine with activity or chatbar)" };
+  } else if (!Array.isArray(m.extensions) || m.extensions.length === 0)
     return { error: "extensions must be a non-empty array" };
   for (const e of m.extensions) {
     if (typeof e !== "string" || !FILE_EXT_RE.test(e))
@@ -1635,6 +1710,8 @@ function parseManifest(raw, dirName, entryExists) {
     bundle,
     ...platforms ? { platforms } : {},
     ...settings ? { settings } : {},
+    ...activity ? { activity } : {},
+    ...chatbar ? { chatbar } : {},
     ...m.homepage !== void 0 ? { homepage: m.homepage } : {},
     ...m.license !== void 0 ? { license: m.license } : {}
   };
@@ -1711,7 +1788,7 @@ var init_registry2 = __esm({
     ID_RE = /^[a-z0-9][a-z0-9_-]{0,63}$/;
     VERSION_RE = /^\d+\.\d+\.\d+(-[0-9A-Za-z.-]+)?$/;
     FILE_EXT_RE = /^\.[a-z0-9]+$/;
-    CAPABILITIES = /* @__PURE__ */ new Set(["save", "media", "transcribe", "fs-read"]);
+    CAPABILITIES = /* @__PURE__ */ new Set(["save", "media", "transcribe", "fs-read", "stt-local"]);
     PLATFORMS = /* @__PURE__ */ new Set(["web", "desktop-mac", "desktop-win", "desktop-linux"]);
     SETTING_KEY_RE = /^[a-z][a-z0-9_]{0,63}$/;
     SETTING_TYPES = /* @__PURE__ */ new Set(["string", "int", "float", "boolean", "enum"]);
@@ -4072,7 +4149,7 @@ var init_init = __esm({
       path14.resolve(__dirname, "..", "bundled-docs"),
       path14.resolve(__dirname, "..", "..", "..", ".halo", "docs")
     ];
-    TEMPLATE_VERSION = 101;
+    TEMPLATE_VERSION = 102;
     VERSION_FILE = ".template-version";
     SKIP_NAMES = /* @__PURE__ */ new Set([".DS_Store", "schema.sql", "__pycache__", ".pytest_cache"]);
     BUILTIN_AGENT_IDS = /* @__PURE__ */ new Set([
@@ -7849,27 +7926,27 @@ var init_workspace = __esm({
       constructor(projectRoot) {
         this.projectRoot = projectRoot;
       }
-      async readFile(path89) {
-        const fullPath = this.validatePath(path89);
+      async readFile(path90) {
+        const fullPath = this.validatePath(path90);
         return readFile(fullPath, "utf-8");
       }
-      async writeFile(path89, content) {
-        const fullPath = this.validatePath(path89);
+      async writeFile(path90, content) {
+        const fullPath = this.validatePath(path90);
         const dir = resolve(fullPath, "..");
         await mkdir(dir, { recursive: true });
         await writeFile(fullPath, content, "utf-8");
       }
-      validatePath(path89) {
-        const fullPath = isAbsolute(path89) ? resolve(path89) : resolve(this.projectRoot, path89);
+      validatePath(path90) {
+        const fullPath = isAbsolute(path90) ? resolve(path90) : resolve(this.projectRoot, path90);
         const root = resolve(this.projectRoot);
         if (fullPath !== root && !fullPath.startsWith(root + sep)) {
-          throw new WorkspaceError(`Path "${path89}" is outside the workspace directory "${this.projectRoot}"`);
+          throw new WorkspaceError(`Path "${path90}" 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 "${path89}" is outside the workspace directory "${this.projectRoot}"`);
+            throw new WorkspaceError(`Path "${path90}" is outside the workspace directory "${this.projectRoot}"`);
           }
         } catch (err) {
           if (err instanceof WorkspaceError)
@@ -8056,12 +8133,12 @@ var init_git_manager = __esm({
             const code = parts[0];
             const status = code[0];
             const isRenameOrCopy = status === "R" || status === "C";
-            const path89 = isRenameOrCopy ? parts[2] : parts[1];
-            if (!path89 || seen.has(path89))
+            const path90 = isRenameOrCopy ? parts[2] : parts[1];
+            if (!path90 || seen.has(path90))
               continue;
-            seen.add(path89);
+            seen.add(path90);
             files.push({
-              path: path89,
+              path: path90,
               status,
               from: isRenameOrCopy ? parts[1] : void 0
             });
@@ -8209,9 +8286,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(path89, staged, from, commit) {
+      async getFileDiff(path90, staged, from, commit) {
         if (commit) {
-          const parentPath = from || path89;
+          const parentPath = from || path90;
           let original2 = "";
           try {
             original2 = await this.git.show([`${commit}^:${parentPath}`]);
@@ -8220,13 +8297,13 @@ var init_git_manager = __esm({
           }
           let modified2 = "";
           try {
-            modified2 = await this.git.show([`${commit}:${path89}`]);
+            modified2 = await this.git.show([`${commit}:${path90}`]);
           } catch {
             modified2 = "";
           }
           return { original: original2, modified: modified2 };
         }
-        const headPath = from || path89;
+        const headPath = from || path90;
         let original = "";
         try {
           original = await this.git.show([`HEAD:${headPath}`]);
@@ -8236,13 +8313,13 @@ var init_git_manager = __esm({
         let modified = "";
         if (staged) {
           try {
-            modified = await this.git.show([`:${path89}`]);
+            modified = await this.git.show([`:${path90}`]);
           } catch {
             modified = "";
           }
         } else {
           try {
-            modified = await this.workspace.readFile(path89);
+            modified = await this.workspace.readFile(path90);
           } catch {
             modified = "";
           }
@@ -14226,7 +14303,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, "1.6.4", haloProcess);
+  providers = await registerSdk2(process.env.OTEL_SERVICE_NAME, "1.6.5", 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;
 }
@@ -15747,8 +15824,8 @@ ${q.text}` : q.text).join("\n\n");
           try {
             await this.runAgentTurn(session, input);
           } catch (err) {
-            const errMsg3 = err instanceof Error ? err.message : String(err);
-            console.error(`[SessionManager] Drain run error for ${session.id}: ${errMsg3}`);
+            const errMsg4 = err instanceof Error ? err.message : String(err);
+            console.error(`[SessionManager] Drain run error for ${session.id}: ${errMsg4}`);
             throw err;
           }
           const nextTurnFollows = session.selfKick && !session.interruptRequested || session.messageQueue.length > 0;
@@ -16044,8 +16121,8 @@ ${q.text}` : q.text);
         }
         console.debug(`[SessionManager] querySession: ${targetSessionId} is IDLE \u2014 draining now`);
         this.runSession(targetSessionId, "").catch((err) => {
-          const errMsg3 = err instanceof Error ? err.message : String(err);
-          console.error(`[SessionManager] Query run error for ${targetSessionId}: ${errMsg3}`);
+          const errMsg4 = err instanceof Error ? err.message : String(err);
+          console.error(`[SessionManager] Query run error for ${targetSessionId}: ${errMsg4}`);
         });
         return JSON.stringify({ code: 0, message: `Message sent to session ${targetSessionId}.` });
       }
@@ -18950,8 +19027,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 path89 = pick.isDir ? needsQuote ? `"${pick.insertPath}/` : `${pick.insertPath}/` : needsQuote ? `"${pick.insertPath}" ` : `${pick.insertPath} `;
-  return `${before}@${kind} ${path89}`;
+  const path90 = pick.isDir ? needsQuote ? `"${pick.insertPath}/` : `${pick.insertPath}/` : needsQuote ? `"${pick.insertPath}" ` : `${pick.insertPath} `;
+  return `${before}@${kind} ${path90}`;
 }
 var init_path_suggest_engine = __esm({
   "src/tui/path-suggest-engine.ts"() {
@@ -23737,8 +23814,8 @@ function detectOrphans(tree, declared) {
       if (!block || typeof block !== "object")
         continue;
       for (const k of Object.keys(block)) {
-        const path89 = `${namespaceId}.${kindWord}.${k}`;
-        if (!declaredMap.has(path89)) {
+        const path90 = `${namespaceId}.${kindWord}.${k}`;
+        if (!declaredMap.has(path90)) {
           out.push({ namespaceId, kind: kindWord === "params" ? "param" : "secret", key: k });
         }
       }
@@ -24772,11 +24849,14 @@ var init_brute_force = __esm({
 });
 
 // ../server/dist/middleware/web-token.js
+function requestToken(c, opts) {
+  return opts?.headerOnly ? /^Bearer\s+(.+)$/i.exec(c.req.header("authorization") ?? "")?.[1]?.trim() || c.req.header("x-token") : c.req.header("x-token") || c.req.query("token");
+}
 function resolveTokenAuth(c, db3, opts) {
   const ip = getClientIp(c);
   if (isLockedOut(TOKEN_BUCKET, ip))
     return { ok: false, reason: "locked_out" };
-  const token = opts?.headerOnly ? /^Bearer\s+(.+)$/i.exec(c.req.header("authorization") ?? "")?.[1]?.trim() || c.req.header("x-token") : c.req.header("x-token") || c.req.query("token");
+  const token = requestToken(c, opts);
   if (!token) {
     return { ok: false, reason: "missing_token" };
   }
@@ -24811,6 +24891,233 @@ var init_web_token = __esm({
   }
 });
 
+// ../server/dist/middleware/auth.js
+import { Hono as Hono11 } from "hono";
+import { getCookie, setCookie } from "hono/cookie";
+import crypto5 from "node:crypto";
+function passwordHash() {
+  return config.server.password ?? "";
+}
+function passwordEnvPlaintext() {
+  return config.server.passwordEnvPlaintext;
+}
+function jwtSecret() {
+  const secret = config.server.jwtSecret ?? "";
+  if (!secret) {
+    throw new Error("jwt_secret missing \u2014 run `halo setup` to initialize");
+  }
+  return Buffer.from(secret, "base64");
+}
+function base64url(data) {
+  const buf = typeof data === "string" ? Buffer.from(data) : data;
+  return buf.toString("base64url");
+}
+function jwtSign(payload) {
+  const header = base64url(JSON.stringify({ alg: "HS256", typ: "JWT" }));
+  const body = base64url(JSON.stringify(payload));
+  const sig = crypto5.createHmac("sha256", jwtSecret()).update(`${header}.${body}`).digest();
+  return `${header}.${body}.${base64url(sig)}`;
+}
+function jwtVerify(token) {
+  const parts = token.split(".");
+  if (parts.length !== 3)
+    return null;
+  const [header, body, sig] = parts;
+  let secret;
+  try {
+    secret = jwtSecret();
+  } catch {
+    return null;
+  }
+  const expected = base64url(crypto5.createHmac("sha256", secret).update(`${header}.${body}`).digest());
+  if (sig !== expected)
+    return null;
+  try {
+    const payload = JSON.parse(Buffer.from(body, "base64url").toString());
+    if (typeof payload.exp === "number" && Date.now() / 1e3 > payload.exp)
+      return null;
+    return payload;
+  } catch {
+    return null;
+  }
+}
+function createToken() {
+  const now = Math.floor(Date.now() / 1e3);
+  return jwtSign({ iat: now, exp: now + TOKEN_MAX_AGE });
+}
+function constantTimeEqualString(a, b) {
+  const ab = Buffer.from(a, "utf-8");
+  const bb = Buffer.from(b, "utf-8");
+  const max = Math.max(ab.length, bb.length);
+  const ap = Buffer.alloc(max);
+  ab.copy(ap);
+  const bp = Buffer.alloc(max);
+  bb.copy(bp);
+  const eq17 = crypto5.timingSafeEqual(ap, bp);
+  return eq17 && ab.length === bb.length;
+}
+function validateToken(token) {
+  if (!token)
+    return null;
+  const payload = jwtVerify(token);
+  if (payload?.scope)
+    return null;
+  return payload;
+}
+function mintScopedToken(scope, maxAgeSec) {
+  const now = Math.floor(Date.now() / 1e3);
+  return jwtSign({ scope, iat: now, exp: now + maxAgeSec });
+}
+function verifyScopedToken(token, scope) {
+  if (!token)
+    return false;
+  const payload = jwtVerify(token);
+  return payload !== null && payload.scope === scope;
+}
+function shouldRefresh(payload) {
+  const iat = payload.iat;
+  if (!iat)
+    return true;
+  return Date.now() / 1e3 - iat > REFRESH_AFTER;
+}
+function isAuthDisabled() {
+  return passwordHash().length === 0 && passwordEnvPlaintext() == null;
+}
+function isAuthenticated(cookie) {
+  if (isAuthDisabled())
+    return true;
+  return validateToken(cookie) !== null;
+}
+function getTokenFromCookieHeader(cookieHeader) {
+  if (!cookieHeader)
+    return void 0;
+  const match = cookieHeader.match(new RegExp(`(?:^|;\\s*)${COOKIE_NAME}=([^;]+)`));
+  return match?.[1];
+}
+function setTokenCookie(c, token) {
+  setCookie(c, COOKIE_NAME, token, {
+    path: "/",
+    // WS upgrade requests carry cookies on the underlying HTTP handshake;
+    // the server reads them via the Cookie header, never via JS — so the
+    // cookie can stay httpOnly to avoid XSS exfiltration.
+    httpOnly: true,
+    maxAge: TOKEN_MAX_AGE,
+    sameSite: "Lax"
+  });
+}
+function createAuthRoutes() {
+  const app2 = new Hono11();
+  app2.post("/auth/login", async (c) => {
+    const ip = getClientIp(c);
+    if (isLockedOut2(ip)) {
+      return c.json({ error: "Too many attempts, try again later" }, 429);
+    }
+    const body = await c.req.json().catch(() => ({ password: "" }));
+    if (!body.password) {
+      recordFailure2(ip);
+      return c.json({ error: "Invalid password" }, 401);
+    }
+    const envPlain = passwordEnvPlaintext();
+    const ok = envPlain != null ? constantTimeEqualString(body.password, envPlain) : await verifyPassword(body.password, passwordHash());
+    if (!ok) {
+      recordFailure2(ip);
+      return c.json({ error: "Invalid password" }, 401);
+    }
+    clearFailures2(ip);
+    const token = createToken();
+    setTokenCookie(c, token);
+    return c.json({ ok: true });
+  });
+  app2.get("/auth/check", (c) => {
+    const token = getCookie(c, COOKIE_NAME);
+    const payload = validateToken(token);
+    if (payload) {
+      if (shouldRefresh(payload)) {
+        const newToken = createToken();
+        setTokenCookie(c, newToken);
+      }
+      return c.json({ authenticated: true, badge: config.server.badge, goalModeEnabled: config.goalModeEnabled });
+    }
+    return c.json({ authenticated: false, badge: config.server.badge }, 401);
+  });
+  app2.post("/auth/logout", (c) => {
+    setCookie(c, COOKIE_NAME, "", { path: "/", maxAge: 0 });
+    return c.json({ ok: true });
+  });
+  app2.post("/auth/change-password", async (c) => {
+    const body = await c.req.json().catch(() => ({}));
+    const oldPassword = typeof body.oldPassword === "string" ? body.oldPassword : "";
+    const newPassword = typeof body.newPassword === "string" ? body.newPassword : "";
+    if (passwordEnvPlaintext() != null) {
+      return c.json({ error: "Password is managed by the HALO_PASSWORD environment variable" }, 400);
+    }
+    if (!await verifyPassword(oldPassword, passwordHash())) {
+      return c.json({ error: "Incorrect current password" }, 401);
+    }
+    const weak = passwordStrengthError(newPassword);
+    if (weak)
+      return c.json({ error: weak }, 400);
+    if (newPassword === oldPassword) {
+      return c.json({ error: "New password must differ from the current password" }, 400);
+    }
+    updateConfigLeaves({ "server.password": await hashPassword(newPassword) });
+    return c.json({ ok: true });
+  });
+  return app2;
+}
+function passwordStrengthError(pw) {
+  if (pw.length < 8)
+    return "Password must be at least 8 characters";
+  if (!/[A-Za-z]/.test(pw))
+    return "Password must contain at least one letter";
+  if (!/[0-9]/.test(pw))
+    return "Password must contain at least one digit";
+  return null;
+}
+function authMiddleware() {
+  return async (c, next) => {
+    const path90 = c.req.path;
+    if (PUBLIC_PATHS.some((p) => path90 === p || path90.startsWith(p + "?"))) {
+      return next();
+    }
+    if (EXTENSION_ASSET_PATH.test(path90)) {
+      return next();
+    }
+    const token = getCookie(c, COOKIE_NAME);
+    const payload = validateToken(token);
+    if (!payload) {
+      if (!path90.startsWith("/api/")) {
+        return next();
+      }
+      return c.json({ error: "Unauthorized" }, 401);
+    }
+    if (shouldRefresh(payload)) {
+      const newToken = createToken();
+      setTokenCookie(c, newToken);
+    }
+    return next();
+  };
+}
+var TOKEN_MAX_AGE, REFRESH_AFTER, COOKIE_NAME, ADMIN_LOGIN_BUCKET, isLockedOut2, recordFailure2, clearFailures2, PUBLIC_PATHS, EXTENSION_ASSET_PATH;
+var init_auth = __esm({
+  "../server/dist/middleware/auth.js"() {
+    "use strict";
+    init_config();
+    init_password_hash();
+    init_setup_config();
+    init_brute_force();
+    TOKEN_MAX_AGE = config.auth.tokenMaxAge;
+    REFRESH_AFTER = config.auth.refreshAfter;
+    COOKIE_NAME = "halo_token";
+    ADMIN_LOGIN_BUCKET = "admin-login";
+    isLockedOut2 = (ip) => isLockedOut(ADMIN_LOGIN_BUCKET, ip);
+    recordFailure2 = (ip) => recordFailure(ADMIN_LOGIN_BUCKET, ip);
+    clearFailures2 = (ip) => clearFailures(ADMIN_LOGIN_BUCKET, ip);
+    PUBLIC_PATHS = ["/api/auth/login", "/api/auth/check", "/api/auth/logout", "/api/health", "/api/web/chat", "/api/web/sessions", "/api/web/stop", "/api/web/history", "/api/web/subscribe", "/api/web/file", "/api/show/state", "/api/show/session", "/api/metrics"];
+    EXTENSION_ASSET_PATH = /^\/api\/extensions\/[^/]+\/[^/]+\/[^/]+\/./;
+  }
+});
+
 // ../server/dist/channels/web/handler.js
 import fs58 from "node:fs";
 function buildWebSessionPrefix(accountId) {
@@ -24833,14 +25140,14 @@ function createWebChannel(deps) {
     return findActiveSessionId(sm, accountId, prefix, activeOverrides, "full") ?? void 0;
   }
   function resolveWorkspace(account, override, scaffold = true) {
-    let path89 = account.workspacePath;
+    let path90 = account.workspacePath;
     if (override && override !== account.workspacePath) {
       if (account.accessLevel !== "full") {
         return { ok: false, error: "workspace override requires a full-access token" };
       }
-      path89 = override;
+      path90 = override;
     }
-    const resolved = scaffold ? resolveAccountWorkspace({ ...account, workspacePath: path89 }) : fs58.existsSync(path89) ? path89 : null;
+    const resolved = scaffold ? resolveAccountWorkspace({ ...account, workspacePath: path90 }) : fs58.existsSync(path90) ? path90 : null;
     if (!resolved)
       return { ok: false, error: "workspace not found" };
     return { ok: true, path: resolved };
@@ -25250,7 +25557,7 @@ var init_session_types = __esm({
 });
 
 // ../server/dist/routes/halo-city.js
-import { Hono as Hono11 } from "hono";
+import { Hono as Hono12 } from "hono";
 import fs59 from "node:fs";
 import path67 from "node:path";
 import Database7 from "better-sqlite3";
@@ -25537,20 +25844,25 @@ function discoverWorkspaces(registry2) {
   return out;
 }
 function createShowRoutes(registry2) {
-  const app2 = new Hono11();
+  const app2 = new Hono12();
   function auth(c) {
+    const cookie = getTokenFromCookieHeader(c.req.header("cookie"));
+    if (!requestToken(c) && cookie && isAuthenticated(cookie)) {
+      return { ok: true, accessLevel: "full", scoped: null };
+    }
     const a = resolveTokenAuth(c, getChannelDb());
     if (!a.ok)
       return { ok: false, response: tokenAuthJsonError(c, a.reason) };
-    return { ok: true, account: a.account };
+    const { account } = a;
+    const globalView = account.accessLevel === "full" || account.accessLevel === "observer";
+    return { ok: true, accessLevel: account.accessLevel, scoped: globalView ? null : account };
   }
   app2.get("/show/state", (c) => {
     const a = auth(c);
     if (!a.ok)
       return a.response;
-    const { account } = a;
-    const globalView = account.accessLevel === "full" || account.accessLevel === "observer";
-    const targets = globalView ? discoverWorkspaces(registry2) : /* @__PURE__ */ new Map([[account.workspacePath, path67.basename(account.workspacePath)]]);
+    const { scoped } = a;
+    const targets = scoped ? /* @__PURE__ */ new Map([[scoped.workspacePath, path67.basename(scoped.workspacePath)]]) : discoverWorkspaces(registry2);
     const workspaces = [];
     for (const [wsPath, label] of targets) {
       try {
@@ -25566,7 +25878,7 @@ function createShowRoutes(registry2) {
     return c.json({
       serverTime: Date.now(),
       uptime: process.uptime(),
-      accessLevel: account.accessLevel,
+      accessLevel: a.accessLevel,
       skills: scanSkills2(GLOBAL_SKILLS_DIR),
       workspaces
     });
@@ -25575,19 +25887,18 @@ function createShowRoutes(registry2) {
     const a = auth(c);
     if (!a.ok)
       return a.response;
-    const { account } = a;
+    const { scoped } = a;
     const wsPath = c.req.query("ws") ?? "";
     const id = c.req.query("id") ?? "";
     if (!wsPath || !id)
       return c.json({ error: "ws and id required" }, 400);
-    const globalView = account.accessLevel === "full" || account.accessLevel === "observer";
-    if (!globalView) {
+    if (scoped) {
       let allowed = false;
       try {
-        allowed = fs59.realpathSync(wsPath) === fs59.realpathSync(account.workspacePath);
+        allowed = fs59.realpathSync(wsPath) === fs59.realpathSync(scoped.workspacePath);
       } catch {
       }
-      if (!allowed || !canAddressSession(account, id))
+      if (!allowed || !canAddressSession(scoped, id))
         return c.json({ error: "forbidden" }, 403);
     }
     try {
@@ -25640,6 +25951,7 @@ var init_halo_city = __esm({
     "use strict";
     init_channel_db();
     init_web_token();
+    init_auth();
     init_handler();
     init_agent_loader();
     init_session_store();
@@ -25655,7 +25967,7 @@ var init_halo_city = __esm({
 });
 
 // ../server/dist/routes/metrics.js
-import { Hono as Hono12 } from "hono";
+import { Hono as Hono13 } from "hono";
 function family(name, type, help, samples) {
   const lines = [`# HELP ${name} ${help}`, `# TYPE ${name} ${type}`];
   for (const s of samples)
@@ -25663,7 +25975,7 @@ function family(name, type, help, samples) {
   return lines.join("\n");
 }
 function createMetricsRoutes(registry2) {
-  const app2 = new Hono12();
+  const app2 = new Hono13();
   function auth(c) {
     const a = resolveTokenAuth(c, getChannelDb());
     if (!a.ok) {
@@ -25748,9 +26060,9 @@ var init_metrics = __esm({
 });
 
 // ../server/dist/routes/commands.js
-import { Hono as Hono13 } from "hono";
+import { Hono as Hono14 } from "hono";
 function createCommandRoutes(registry2, smRegistry) {
-  const app2 = new Hono13();
+  const app2 = new Hono14();
   app2.get("/commands", async (c) => {
     const projectId = c.req.query("projectId");
     const sessionId = c.req.query("sessionId");
@@ -25777,233 +26089,6 @@ var init_commands3 = __esm({
   }
 });
 
-// ../server/dist/middleware/auth.js
-import { Hono as Hono14 } from "hono";
-import { getCookie, setCookie } from "hono/cookie";
-import crypto5 from "node:crypto";
-function passwordHash() {
-  return config.server.password ?? "";
-}
-function passwordEnvPlaintext() {
-  return config.server.passwordEnvPlaintext;
-}
-function jwtSecret() {
-  const secret = config.server.jwtSecret ?? "";
-  if (!secret) {
-    throw new Error("jwt_secret missing \u2014 run `halo setup` to initialize");
-  }
-  return Buffer.from(secret, "base64");
-}
-function base64url(data) {
-  const buf = typeof data === "string" ? Buffer.from(data) : data;
-  return buf.toString("base64url");
-}
-function jwtSign(payload) {
-  const header = base64url(JSON.stringify({ alg: "HS256", typ: "JWT" }));
-  const body = base64url(JSON.stringify(payload));
-  const sig = crypto5.createHmac("sha256", jwtSecret()).update(`${header}.${body}`).digest();
-  return `${header}.${body}.${base64url(sig)}`;
-}
-function jwtVerify(token) {
-  const parts = token.split(".");
-  if (parts.length !== 3)
-    return null;
-  const [header, body, sig] = parts;
-  let secret;
-  try {
-    secret = jwtSecret();
-  } catch {
-    return null;
-  }
-  const expected = base64url(crypto5.createHmac("sha256", secret).update(`${header}.${body}`).digest());
-  if (sig !== expected)
-    return null;
-  try {
-    const payload = JSON.parse(Buffer.from(body, "base64url").toString());
-    if (typeof payload.exp === "number" && Date.now() / 1e3 > payload.exp)
-      return null;
-    return payload;
-  } catch {
-    return null;
-  }
-}
-function createToken() {
-  const now = Math.floor(Date.now() / 1e3);
-  return jwtSign({ iat: now, exp: now + TOKEN_MAX_AGE });
-}
-function constantTimeEqualString(a, b) {
-  const ab = Buffer.from(a, "utf-8");
-  const bb = Buffer.from(b, "utf-8");
-  const max = Math.max(ab.length, bb.length);
-  const ap = Buffer.alloc(max);
-  ab.copy(ap);
-  const bp = Buffer.alloc(max);
-  bb.copy(bp);
-  const eq17 = crypto5.timingSafeEqual(ap, bp);
-  return eq17 && ab.length === bb.length;
-}
-function validateToken(token) {
-  if (!token)
-    return null;
-  const payload = jwtVerify(token);
-  if (payload?.scope)
-    return null;
-  return payload;
-}
-function mintScopedToken(scope, maxAgeSec) {
-  const now = Math.floor(Date.now() / 1e3);
-  return jwtSign({ scope, iat: now, exp: now + maxAgeSec });
-}
-function verifyScopedToken(token, scope) {
-  if (!token)
-    return false;
-  const payload = jwtVerify(token);
-  return payload !== null && payload.scope === scope;
-}
-function shouldRefresh(payload) {
-  const iat = payload.iat;
-  if (!iat)
-    return true;
-  return Date.now() / 1e3 - iat > REFRESH_AFTER;
-}
-function isAuthDisabled() {
-  return passwordHash().length === 0 && passwordEnvPlaintext() == null;
-}
-function isAuthenticated(cookie) {
-  if (isAuthDisabled())
-    return true;
-  return validateToken(cookie) !== null;
-}
-function getTokenFromCookieHeader(cookieHeader) {
-  if (!cookieHeader)
-    return void 0;
-  const match = cookieHeader.match(new RegExp(`(?:^|;\\s*)${COOKIE_NAME}=([^;]+)`));
-  return match?.[1];
-}
-function setTokenCookie(c, token) {
-  setCookie(c, COOKIE_NAME, token, {
-    path: "/",
-    // WS upgrade requests carry cookies on the underlying HTTP handshake;
-    // the server reads them via the Cookie header, never via JS — so the
-    // cookie can stay httpOnly to avoid XSS exfiltration.
-    httpOnly: true,
-    maxAge: TOKEN_MAX_AGE,
-    sameSite: "Lax"
-  });
-}
-function createAuthRoutes() {
-  const app2 = new Hono14();
-  app2.post("/auth/login", async (c) => {
-    const ip = getClientIp(c);
-    if (isLockedOut2(ip)) {
-      return c.json({ error: "Too many attempts, try again later" }, 429);
-    }
-    const body = await c.req.json().catch(() => ({ password: "" }));
-    if (!body.password) {
-      recordFailure2(ip);
-      return c.json({ error: "Invalid password" }, 401);
-    }
-    const envPlain = passwordEnvPlaintext();
-    const ok = envPlain != null ? constantTimeEqualString(body.password, envPlain) : await verifyPassword(body.password, passwordHash());
-    if (!ok) {
-      recordFailure2(ip);
-      return c.json({ error: "Invalid password" }, 401);
-    }
-    clearFailures2(ip);
-    const token = createToken();
-    setTokenCookie(c, token);
-    return c.json({ ok: true });
-  });
-  app2.get("/auth/check", (c) => {
-    const token = getCookie(c, COOKIE_NAME);
-    const payload = validateToken(token);
-    if (payload) {
-      if (shouldRefresh(payload)) {
-        const newToken = createToken();
-        setTokenCookie(c, newToken);
-      }
-      return c.json({ authenticated: true, badge: config.server.badge, goalModeEnabled: config.goalModeEnabled });
-    }
-    return c.json({ authenticated: false, badge: config.server.badge }, 401);
-  });
-  app2.post("/auth/logout", (c) => {
-    setCookie(c, COOKIE_NAME, "", { path: "/", maxAge: 0 });
-    return c.json({ ok: true });
-  });
-  app2.post("/auth/change-password", async (c) => {
-    const body = await c.req.json().catch(() => ({}));
-    const oldPassword = typeof body.oldPassword === "string" ? body.oldPassword : "";
-    const newPassword = typeof body.newPassword === "string" ? body.newPassword : "";
-    if (passwordEnvPlaintext() != null) {
-      return c.json({ error: "Password is managed by the HALO_PASSWORD environment variable" }, 400);
-    }
-    if (!await verifyPassword(oldPassword, passwordHash())) {
-      return c.json({ error: "Incorrect current password" }, 401);
-    }
-    const weak = passwordStrengthError(newPassword);
-    if (weak)
-      return c.json({ error: weak }, 400);
-    if (newPassword === oldPassword) {
-      return c.json({ error: "New password must differ from the current password" }, 400);
-    }
-    updateConfigLeaves({ "server.password": await hashPassword(newPassword) });
-    return c.json({ ok: true });
-  });
-  return app2;
-}
-function passwordStrengthError(pw) {
-  if (pw.length < 8)
-    return "Password must be at least 8 characters";
-  if (!/[A-Za-z]/.test(pw))
-    return "Password must contain at least one letter";
-  if (!/[0-9]/.test(pw))
-    return "Password must contain at least one digit";
-  return null;
-}
-function authMiddleware() {
-  return async (c, next) => {
-    const path89 = c.req.path;
-    if (PUBLIC_PATHS.some((p) => path89 === p || path89.startsWith(p + "?"))) {
-      return next();
-    }
-    if (EXTENSION_ASSET_PATH.test(path89)) {
-      return next();
-    }
-    const token = getCookie(c, COOKIE_NAME);
-    const payload = validateToken(token);
-    if (!payload) {
-      if (!path89.startsWith("/api/")) {
-        return next();
-      }
-      return c.json({ error: "Unauthorized" }, 401);
-    }
-    if (shouldRefresh(payload)) {
-      const newToken = createToken();
-      setTokenCookie(c, newToken);
-    }
-    return next();
-  };
-}
-var TOKEN_MAX_AGE, REFRESH_AFTER, COOKIE_NAME, ADMIN_LOGIN_BUCKET, isLockedOut2, recordFailure2, clearFailures2, PUBLIC_PATHS, EXTENSION_ASSET_PATH;
-var init_auth = __esm({
-  "../server/dist/middleware/auth.js"() {
-    "use strict";
-    init_config();
-    init_password_hash();
-    init_setup_config();
-    init_brute_force();
-    TOKEN_MAX_AGE = config.auth.tokenMaxAge;
-    REFRESH_AFTER = config.auth.refreshAfter;
-    COOKIE_NAME = "halo_token";
-    ADMIN_LOGIN_BUCKET = "admin-login";
-    isLockedOut2 = (ip) => isLockedOut(ADMIN_LOGIN_BUCKET, ip);
-    recordFailure2 = (ip) => recordFailure(ADMIN_LOGIN_BUCKET, ip);
-    clearFailures2 = (ip) => clearFailures(ADMIN_LOGIN_BUCKET, ip);
-    PUBLIC_PATHS = ["/api/auth/login", "/api/auth/check", "/api/auth/logout", "/api/health", "/api/web/chat", "/api/web/sessions", "/api/web/stop", "/api/web/history", "/api/web/subscribe", "/api/web/file", "/api/show/state", "/api/show/session", "/api/metrics"];
-    EXTENSION_ASSET_PATH = /^\/api\/extensions\/[^/]+\/[^/]+\/[^/]+\/./;
-  }
-});
-
 // ../server/dist/routes/transcribe-ws.js
 import { WebSocketServer } from "ws";
 import { StartStreamTranscriptionCommand, TranscribeStreamingClient } from "@aws-sdk/client-transcribe-streaming";
@@ -26217,19 +26302,688 @@ var init_transcribe_ws = __esm({
   }
 });
 
+// ../server/dist/stt/models.js
+import { createHash as createHash2 } from "node:crypto";
+import fs60 from "node:fs";
+import fsp from "node:fs/promises";
+import http2 from "node:http";
+import https2 from "node:https";
+import path68 from "node:path";
+function httpGet(url, headers, signal, hops = 5) {
+  return new Promise((resolve2, reject) => {
+    const u = new URL(url);
+    const req = (u.protocol === "https:" ? https2 : http2).get(u, { headers: { "User-Agent": "halo-stt", ...headers }, signal }, (res) => {
+      res.on("error", () => {
+      });
+      const location = res.headers.location;
+      if (res.statusCode && res.statusCode >= 300 && res.statusCode < 400 && location) {
+        res.resume();
+        if (hops === 0)
+          reject(new Error("too many redirects"));
+        else
+          resolve2(httpGet(new URL(location, u).toString(), headers, signal, hops - 1));
+        return;
+      }
+      resolve2(res);
+    });
+    req.on("error", reject);
+  });
+}
+function createSttModelManager(opts = {}) {
+  const files = opts.files ?? STT_MODEL_FILES;
+  const connectTimeoutMs = opts.connectTimeoutMs ?? 15e3;
+  const stallTimeoutMs = opts.stallTimeoutMs ?? 3e4;
+  const progressIntervalMs = opts.progressIntervalMs ?? 500;
+  const filePath = (rel) => path68.join(opts.dir ?? globalSttModelsDir(), rel);
+  const total = files.reduce((n, f) => n + f.size, 0);
+  const listeners2 = /* @__PURE__ */ new Set();
+  let inflight = null;
+  let received = 0;
+  let lastError = "";
+  let lastEmit = 0;
+  let current = null;
+  let closed = false;
+  const fileReady = (f) => {
+    try {
+      return fs60.statSync(filePath(f.path)).size === f.size;
+    } catch {
+      return false;
+    }
+  };
+  function status() {
+    if (inflight)
+      return { state: "downloading", received, total };
+    if (files.every(fileReady))
+      return { state: "ready" };
+    if (lastError)
+      return { state: "error", message: lastError };
+    return { state: "missing" };
+  }
+  function emit2() {
+    lastEmit = Date.now();
+    const s = status();
+    for (const l of listeners2)
+      l(s);
+  }
+  async function fetchFile(f, url, base) {
+    const final = filePath(f.path);
+    const part = `${final}.part`;
+    fs60.mkdirSync(path68.dirname(final), { recursive: true });
+    let have = 0;
+    try {
+      have = fs60.statSync(part).size;
+    } catch {
+    }
+    if (have > f.size) {
+      fs60.rmSync(part, { force: true });
+      have = 0;
+    }
+    received = base + have;
+    if (have === f.size) {
+      const hash = createHash2("sha256");
+      for await (const chunk of fs60.createReadStream(part))
+        hash.update(chunk);
+      if (hash.digest("hex") === f.sha256) {
+        fs60.renameSync(part, final);
+        return;
+      }
+      fs60.rmSync(part, { force: true });
+      have = 0;
+    }
+    const ac = new AbortController();
+    current = ac;
+    let reason = "";
+    let timer2 = null;
+    const arm = (ms, why) => {
+      if (timer2)
+        clearTimeout(timer2);
+      timer2 = setTimeout(() => {
+        reason = why;
+        ac.abort();
+      }, ms);
+    };
+    arm(connectTimeoutMs, `no data within ${connectTimeoutMs / 1e3}s`);
+    try {
+      const res = await httpGet(url, have > 0 ? { Range: `bytes=${have}-` } : {}, ac.signal);
+      if (res.statusCode === 416) {
+        fs60.rmSync(part, { force: true });
+        throw new Error("HTTP 416");
+      }
+      if (res.statusCode !== 200 && res.statusCode !== 206)
+        throw new Error(`HTTP ${res.statusCode}`);
+      const resume = res.statusCode === 206;
+      if (resume && !(res.headers["content-range"] ?? "").startsWith(`bytes ${have}-`)) {
+        throw new Error(`unexpected Content-Range ${res.headers["content-range"] ?? "(none)"}`);
+      }
+      if (have > 0)
+        console.log(`[STT] ${f.path}: ${resume ? `resuming at ${have} bytes` : `source ignored Range, restarting from 0 (had ${have} bytes)`}`);
+      const hash = createHash2("sha256");
+      let got = 0;
+      if (resume) {
+        for await (const chunk of fs60.createReadStream(part))
+          hash.update(chunk);
+        got = have;
+      }
+      const fh = await fsp.open(part, resume ? "a" : "w");
+      try {
+        for await (const value of res) {
+          arm(stallTimeoutMs, `stalled for ${stallTimeoutMs / 1e3}s`);
+          got += value.length;
+          if (got > f.size)
+            break;
+          hash.update(value);
+          await fh.write(value);
+          received = base + got;
+          if (Date.now() - lastEmit >= progressIntervalMs)
+            emit2();
+        }
+      } finally {
+        await fh.close();
+      }
+      if (got < f.size)
+        throw new Error(`truncated (${got} of ${f.size} bytes)`);
+      if (got > f.size || hash.digest("hex") !== f.sha256) {
+        fs60.rmSync(part, { force: true });
+        throw new Error(got > f.size ? `size mismatch (more than ${f.size} bytes)` : "sha256 mismatch");
+      }
+      fs60.renameSync(part, final);
+    } catch (err) {
+      if (reason)
+        throw new Error(reason);
+      throw err;
+    } finally {
+      if (timer2)
+        clearTimeout(timer2);
+      ac.abort();
+      current = null;
+    }
+  }
+  async function run() {
+    let base = files.filter(fileReady).reduce((n, f) => n + f.size, 0);
+    received = base;
+    for (const f of files) {
+      if (fileReady(f))
+        continue;
+      const failures = [];
+      for (const src of f.sources) {
+        if (closed)
+          return;
+        const t0 = Date.now();
+        try {
+          await fetchFile(f, src.url, base);
+          console.log(`[STT] downloaded ${f.path} from ${src.name} (${(f.size / 1048576).toFixed(1)} MB in ${((Date.now() - t0) / 1e3).toFixed(1)}s)`);
+          failures.length = 0;
+          break;
+        } catch (err) {
+          if (closed)
+            return;
+          const msg = err instanceof Error ? err.message : String(err);
+          failures.push(`${src.name}: ${msg}`);
+          console.log(`[STT] download ${f.path} from ${src.name} failed: ${msg}`);
+        }
+      }
+      if (failures.length > 0) {
+        lastError = `${path68.basename(f.path)}: all sources failed (${failures.join("; ")})`;
+        return;
+      }
+      base += f.size;
+      received = base;
+    }
+  }
+  function ensure() {
+    if (inflight)
+      return inflight;
+    if (closed || files.every(fileReady))
+      return Promise.resolve();
+    lastError = "";
+    console.log("[STT] model download start");
+    inflight = run().finally(() => {
+      inflight = null;
+      emit2();
+    });
+    emit2();
+    return inflight;
+  }
+  return {
+    status,
+    ensure,
+    subscribe(listener) {
+      listeners2.add(listener);
+      return () => {
+        listeners2.delete(listener);
+      };
+    },
+    filePath,
+    close() {
+      closed = true;
+      current?.abort();
+    }
+  };
+}
+var SENSE_VOICE_MODEL, SENSE_VOICE_TOKENS, SILERO_VAD_MODEL, HF_SENSE_VOICE, MS_SENSE_VOICE, STT_MODEL_FILES, sttModels;
+var init_models = __esm({
+  "../server/dist/stt/models.js"() {
+    "use strict";
+    init_paths();
+    SENSE_VOICE_MODEL = "sense-voice-zh-en-ja-ko-yue-2024-07-17/model.int8.onnx";
+    SENSE_VOICE_TOKENS = "sense-voice-zh-en-ja-ko-yue-2024-07-17/tokens.txt";
+    SILERO_VAD_MODEL = "silero-vad-v4/silero_vad.onnx";
+    HF_SENSE_VOICE = "https://huggingface.co/csukuangfj/sherpa-onnx-sense-voice-zh-en-ja-ko-yue-2024-07-17/resolve/2365baeacb507f821a0c8120fcee3d484dba7a07";
+    MS_SENSE_VOICE = "https://www.modelscope.cn/api/v1/models/pengzhendong/sherpa-onnx-sense-voice-zh-en-ja-ko-yue/repo?Revision=master&FilePath=";
+    STT_MODEL_FILES = [
+      {
+        path: SENSE_VOICE_MODEL,
+        size: 239233841,
+        sha256: "c71f0ce00bec95b07744e116345e33d8cbbe08cef896382cf907bf4b51a2cd51",
+        sources: [
+          { name: "huggingface", url: `${HF_SENSE_VOICE}/model.int8.onnx` },
+          { name: "modelscope", url: `${MS_SENSE_VOICE}model.int8.onnx` }
+        ]
+      },
+      {
+        path: SENSE_VOICE_TOKENS,
+        size: 315894,
+        sha256: "f449eb28dc567533d7fa59be34e2abca8784f771850c78a47fb731a31429a1dc",
+        sources: [
+          { name: "huggingface", url: `${HF_SENSE_VOICE}/tokens.txt` },
+          { name: "modelscope", url: `${MS_SENSE_VOICE}tokens.txt` }
+        ]
+      },
+      {
+        path: SILERO_VAD_MODEL,
+        size: 1807522,
+        sha256: "a35ebf52fd3ce5f1469b2a36158dba761bc47b973ea3382b3186ca15b1f5af28",
+        sources: [
+          { name: "huggingface", url: "https://huggingface.co/csukuangfj/vad/resolve/fba88cd2e921609e7675c3aaf51e0b9b295da4bc/silero_vad.onnx" },
+          { name: "modelscope", url: "https://www.modelscope.cn/api/v1/models/pengzhendong/silero-vad/repo?Revision=master&FilePath=v4/silero_vad.onnx" }
+        ]
+      }
+    ];
+    sttModels = createSttModelManager();
+  }
+});
+
+// ../server/dist/stt/engine.js
+import os8 from "node:os";
+function createSttEngine(deps = {}) {
+  const loadSherpa = deps.loadSherpa ?? defaultLoadSherpa;
+  const models = deps.models ?? sttModels;
+  let sherpa = null;
+  let recognizer = null;
+  let loading = null;
+  const queue = [];
+  let decoding = false;
+  function load() {
+    if (recognizer)
+      return Promise.resolve();
+    loading ??= doLoad().finally(() => {
+      loading = null;
+    });
+    return loading;
+  }
+  async function doLoad() {
+    const t0 = Date.now();
+    try {
+      const m = await loadSherpa();
+      recognizer = await m.OfflineRecognizer.createAsync({
+        featConfig: { sampleRate: SAMPLE_RATE, featureDim: 80 },
+        modelConfig: {
+          // language '' = auto: setting one barely changed results in testing.
+          senseVoice: { model: models.filePath(SENSE_VOICE_MODEL), language: "", useInverseTextNormalization: 1 },
+          tokens: models.filePath(SENSE_VOICE_TOKENS),
+          numThreads: NUM_THREADS,
+          provider: "cpu",
+          debug: 0
+        }
+      });
+      sherpa = m;
+      console.log(`[STT] engine loaded in ${Date.now() - t0}ms (threads=${NUM_THREADS})`);
+    } catch (err) {
+      console.log(`[STT] engine load failed: ${errMsg2(err)}`);
+      throw new SttError("engine", `speech engine unavailable: ${errMsg2(err)}`);
+    }
+  }
+  async function pump() {
+    if (decoding || !recognizer)
+      return;
+    decoding = true;
+    while (queue.length > 0) {
+      const job = queue.shift();
+      try {
+        const stream = recognizer.createStream();
+        stream.acceptWaveform({ samples: job.samples, sampleRate: SAMPLE_RATE });
+        await recognizer.decodeAsync(stream);
+        job.owner.done(job, recognizer.getResult(stream));
+      } catch (err) {
+        job.owner.fail(new SttError("engine", `decode failed: ${errMsg2(err)}`));
+      }
+    }
+    decoding = false;
+  }
+  function open(handlers) {
+    if (!sherpa)
+      throw new SttError("engine", "speech engine not loaded");
+    let vad;
+    try {
+      vad = new sherpa.Vad({
+        sileroVad: {
+          model: models.filePath(SILERO_VAD_MODEL),
+          threshold: VAD_THRESHOLD,
+          minSilenceDuration: VAD_MIN_SILENCE_S,
+          minSpeechDuration: VAD_MIN_SPEECH_S,
+          maxSpeechDuration: VAD_MAX_SPEECH_S,
+          windowSize: VAD_WINDOW
+        },
+        sampleRate: SAMPLE_RATE,
+        numThreads: 1,
+        debug: false
+      }, RING_S);
+    } catch (err) {
+      throw new SttError("engine", `VAD unavailable: ${errMsg2(err)}`);
+    }
+    const ringLen = RING_S * SAMPLE_RATE;
+    const ring = new Float32Array(ringLen);
+    const win = new Float32Array(VAD_WINDOW);
+    let winFill = 0;
+    let total = 0;
+    let carry = null;
+    let prevEnd = 0;
+    let pendingSamples = 0;
+    let inFlight2 = 0;
+    let segments = 0;
+    let decodedSamples = 0;
+    let stopped = false;
+    let drained = null;
+    const checkDrain = () => {
+      if (drained && (stopped || inFlight2 === 0)) {
+        const d = drained;
+        drained = null;
+        d();
+      }
+    };
+    const dropQueued = () => {
+      for (let i = queue.length - 1; i >= 0; i--) {
+        if (queue[i].owner !== owner)
+          continue;
+        pendingSamples -= queue[i].samples.length;
+        inFlight2--;
+        queue.splice(i, 1);
+      }
+    };
+    function failStream(err) {
+      if (stopped)
+        return;
+      stopped = true;
+      dropQueued();
+      handlers.onError(err);
+      checkDrain();
+    }
+    const owner = {
+      done(job, result) {
+        pendingSamples -= job.samples.length;
+        inFlight2--;
+        if (!stopped) {
+          segments++;
+          decodedSamples += job.samples.length;
+          const text6 = (result.text ?? "").trim();
+          if (text6)
+            handlers.onFinal({ start: round3(job.start / SAMPLE_RATE), end: round3(job.end / SAMPLE_RATE), text: text6, lang: (result.lang ?? "").replace(/<\|([^|]*)\|>/g, "$1") });
+        }
+        checkDrain();
+      },
+      fail(err) {
+        inFlight2--;
+        failStream(err);
+        checkDrain();
+      }
+    };
+    function enqueue(segStart, segEnd) {
+      const start3 = Math.max(segStart - PAD_BEFORE_S * SAMPLE_RATE, prevEnd, total - ringLen, 0);
+      const end = Math.min(segEnd + PAD_AFTER_S * SAMPLE_RATE, total);
+      if (end <= start3)
+        return;
+      prevEnd = end;
+      if (queue.length >= MAX_QUEUED_SEGMENTS) {
+        failStream(new SttError("busy", `decode queue full (${MAX_QUEUED_SEGMENTS} segments waiting)`));
+        return;
+      }
+      if ((pendingSamples + end - start3) / SAMPLE_RATE > MAX_PENDING_AUDIO_S) {
+        failStream(new SttError("busy", `more than ${MAX_PENDING_AUDIO_S}s of audio waiting to be decoded`));
+        return;
+      }
+      const samples = new Float32Array(end - start3);
+      for (let i = 0; i < samples.length; i++)
+        samples[i] = ring[(start3 + i) % ringLen];
+      pendingSamples += samples.length;
+      inFlight2++;
+      queue.push({ owner, samples, start: start3, end });
+      void pump();
+    }
+    function drainVad() {
+      while (!stopped && !vad.isEmpty()) {
+        const seg = vad.front(false);
+        vad.pop();
+        enqueue(seg.start, seg.start + seg.samples.length);
+      }
+    }
+    function feed(samples) {
+      vad.acceptWaveform(samples);
+      drainVad();
+    }
+    return {
+      write(pcm) {
+        if (stopped)
+          return;
+        try {
+          const bytes = carry ? Buffer.concat([carry, pcm]) : pcm;
+          const n = bytes.length >> 1;
+          carry = bytes.length & 1 ? Buffer.from(bytes.subarray(bytes.length - 1)) : null;
+          for (let i = 0; i < n && !stopped; i++) {
+            const f = bytes.readInt16LE(i * 2) / 32768;
+            ring[total % ringLen] = f;
+            total++;
+            win[winFill++] = f;
+            if (winFill === VAD_WINDOW) {
+              winFill = 0;
+              feed(win);
+            }
+          }
+        } catch (err) {
+          failStream(new SttError("engine", `VAD failed: ${errMsg2(err)}`));
+        }
+      },
+      end() {
+        if (!stopped) {
+          try {
+            if (winFill > 0) {
+              win.fill(0, winFill);
+              winFill = 0;
+              feed(win);
+            }
+            vad.flush();
+            drainVad();
+          } catch (err) {
+            failStream(new SttError("engine", `VAD failed: ${errMsg2(err)}`));
+          }
+        }
+        return new Promise((resolve2) => {
+          drained = resolve2;
+          checkDrain();
+        });
+      },
+      abort() {
+        stopped = true;
+        dropQueued();
+        checkDrain();
+      },
+      stats: () => ({ segments, audioSeconds: round3(decodedSamples / SAMPLE_RATE) })
+    };
+  }
+  return { load, open };
+}
+var SAMPLE_RATE, VAD_WINDOW, VAD_THRESHOLD, VAD_MIN_SILENCE_S, VAD_MIN_SPEECH_S, VAD_MAX_SPEECH_S, PAD_BEFORE_S, PAD_AFTER_S, RING_S, MAX_QUEUED_SEGMENTS, MAX_PENDING_AUDIO_S, NUM_THREADS, SttError, defaultLoadSherpa, errMsg2, round3, sttEngine;
+var init_engine = __esm({
+  "../server/dist/stt/engine.js"() {
+    "use strict";
+    init_models();
+    SAMPLE_RATE = 16e3;
+    VAD_WINDOW = 512;
+    VAD_THRESHOLD = 0.5;
+    VAD_MIN_SILENCE_S = 0.5;
+    VAD_MIN_SPEECH_S = 0.25;
+    VAD_MAX_SPEECH_S = 20;
+    PAD_BEFORE_S = 0.3;
+    PAD_AFTER_S = 0.2;
+    RING_S = 30;
+    MAX_QUEUED_SEGMENTS = 32;
+    MAX_PENDING_AUDIO_S = 60;
+    NUM_THREADS = Math.min(4, Math.max(1, Math.floor(os8.availableParallelism() / 2)));
+    SttError = class extends Error {
+      code;
+      constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = "SttError";
+      }
+    };
+    defaultLoadSherpa = async () => (await import("sherpa-onnx-node")).default;
+    errMsg2 = (err) => err instanceof Error ? err.message : String(err);
+    round3 = (s) => Math.round(s * 1e3) / 1e3;
+    sttEngine = createSttEngine();
+  }
+});
+
+// ../server/dist/routes/stt-ws.js
+import { WebSocketServer as WebSocketServer2 } from "ws";
+function parseQuery2(req) {
+  const url = req.url ?? "";
+  const i = url.indexOf("?");
+  return new URLSearchParams(i < 0 ? "" : url.slice(i + 1));
+}
+function createSttProxy(deps = {}) {
+  const models = deps.models ?? sttModels;
+  const engine = deps.engine ?? sttEngine;
+  const wss2 = new WebSocketServer2({
+    noServer: true,
+    maxPayload: MAX_FRAME_BYTES2,
+    // Same cookie gate as /ws; the extension iframe is same-origin with the
+    // admin, so its WS handshake carries the login cookie.
+    verifyClient: (info, callback) => {
+      if (!isAuthenticated(getTokenFromCookieHeader(info.req.headers.cookie)))
+        return callback(false, 401, "Unauthorized");
+      const ext = getExtension(parseQuery2(info.req).get("ext") ?? "");
+      if (!ext || !ext.capabilities.includes("stt-local"))
+        return callback(false, 403, "Forbidden");
+      callback(true);
+    }
+  });
+  wss2.on("connection", (ws, req) => {
+    const extId = parseQuery2(req).get("ext");
+    const openedAt = Date.now();
+    let closed = false;
+    let failed = false;
+    let ended = false;
+    let stream = null;
+    let unsubscribe = null;
+    ws.on("error", (err) => {
+      console.log(`[STT] client error ext=${extId}: ${err.message}`);
+    });
+    const send2 = (frame) => {
+      if (ws.readyState === ws.OPEN)
+        ws.send(JSON.stringify(frame));
+    };
+    const fail2 = (code, message) => {
+      if (failed || closed)
+        return;
+      failed = true;
+      console.log(`[STT] stream error ext=${extId} code=${code}`);
+      send2({ type: "error", code, message });
+      ws.close(1011, code);
+    };
+    async function startEngine() {
+      try {
+        await engine.load();
+        if (closed || failed || ended)
+          return;
+        stream = engine.open({
+          // Recognized text goes to the client only — never to the log.
+          onFinal: (f) => send2({ type: "final", ...f }),
+          onError: (err) => fail2(err.code, err.message)
+        });
+      } catch (err) {
+        if (err instanceof SttError)
+          fail2(err.code, err.message);
+        else
+          fail2("io", err instanceof Error ? err.message : String(err));
+        return;
+      }
+      if (closed || failed)
+        return;
+      send2({ type: "ready" });
+    }
+    const onModel = (s) => {
+      if (closed || failed)
+        return;
+      send2({ type: "model", ...s });
+      if (s.state === "ready" || s.state === "error") {
+        unsubscribe?.();
+        unsubscribe = null;
+      }
+      if (s.state === "ready")
+        void startEngine();
+      else if (s.state === "error")
+        fail2("model", s.message ?? "model download failed");
+    };
+    console.log(`[STT] stream open ext=${extId}`);
+    ws.on("message", (data, isBinary) => {
+      if (ended || failed)
+        return;
+      if (isBinary) {
+        if (!stream)
+          return;
+        stream.write(Buffer.isBuffer(data) ? data : Buffer.concat(Array.isArray(data) ? data : [Buffer.from(data)]));
+        return;
+      }
+      let msg;
+      try {
+        msg = JSON.parse(data.toString());
+      } catch {
+        msg = null;
+      }
+      if (msg?.type !== "end") {
+        fail2("bad-request", 'expected binary PCM or {"type":"end"}');
+        return;
+      }
+      ended = true;
+      if (!stream) {
+        ws.close(1e3);
+        return;
+      }
+      void stream.end().then(() => {
+        if (!closed && !failed)
+          ws.close(1e3);
+      });
+    });
+    ws.on("close", () => {
+      closed = true;
+      unsubscribe?.();
+      unsubscribe = null;
+      stream?.abort();
+      const st = stream?.stats();
+      console.log(`[STT] stream closed after ${((Date.now() - openedAt) / 1e3).toFixed(1)}s ext=${extId}${st ? ` segments=${st.segments} audio=${st.audioSeconds.toFixed(1)}s` : ""}`);
+    });
+    const initial = models.status();
+    if (initial.state === "ready") {
+      onModel(initial);
+      return;
+    }
+    let pushed = false;
+    unsubscribe = models.subscribe((s) => {
+      pushed = true;
+      onModel(s);
+    });
+    void models.ensure();
+    if (!pushed)
+      onModel(models.status());
+  });
+  return {
+    handleUpgrade(req, socket, head) {
+      wss2.handleUpgrade(req, socket, head, (ws) => wss2.emit("connection", ws, req));
+    },
+    close() {
+      models.close();
+      for (const client of wss2.clients)
+        client.close(1001, "Server shutting down");
+      wss2.close();
+    }
+  };
+}
+var STT_PATH, MAX_FRAME_BYTES2;
+var init_stt_ws = __esm({
+  "../server/dist/routes/stt-ws.js"() {
+    "use strict";
+    init_auth();
+    init_registry2();
+    init_models();
+    init_engine();
+    STT_PATH = "/api/stt/stream";
+    MAX_FRAME_BYTES2 = 1024 * 1024;
+  }
+});
+
 // ../server/dist/jupyter/manager.js
 import { spawn as nodeSpawn } from "node:child_process";
 import { randomBytes as randomBytes2 } from "node:crypto";
-import fs60 from "node:fs";
+import fs61 from "node:fs";
 import net from "node:net";
-import os8 from "node:os";
-import path68 from "node:path";
+import os9 from "node:os";
+import path69 from "node:path";
 import { WebSocket } from "ws";
 function resolveExecutable(configured) {
   const isExe = (p) => {
     try {
-      fs60.accessSync(p, fs60.constants.X_OK);
-      return fs60.statSync(p).isFile();
+      fs61.accessSync(p, fs61.constants.X_OK);
+      return fs61.statSync(p).isFile();
     } catch {
       return false;
     }
@@ -26237,9 +26991,9 @@ function resolveExecutable(configured) {
   if (configured)
     return isExe(configured) ? configured : null;
   const name = process.platform === "win32" ? "jupyter.exe" : "jupyter";
-  for (const dir of (process.env.PATH ?? "").split(path68.delimiter)) {
-    if (dir && isExe(path68.join(dir, name)))
-      return path68.join(dir, name);
+  for (const dir of (process.env.PATH ?? "").split(path69.delimiter)) {
+    if (dir && isExe(path69.join(dir, name)))
+      return path69.join(dir, name);
   }
   return null;
 }
@@ -26267,9 +27021,9 @@ function createJupyterManager(deps = {}) {
       let err = "";
       let child;
       try {
-        child = spawnFn(exe, ["server", "--version"], { cwd: os8.homedir(), env: cleanChildEnv(), stdio: ["ignore", "pipe", "pipe"], windowsHide: true });
+        child = spawnFn(exe, ["server", "--version"], { cwd: os9.homedir(), env: cleanChildEnv(), stdio: ["ignore", "pipe", "pipe"], windowsHide: true });
       } catch (e) {
-        resolve2({ ok: false, error: errMsg2(e) });
+        resolve2({ ok: false, error: errMsg3(e) });
         return;
       }
       const timer2 = setTimeout(() => child.kill(), PROBE_TIMEOUT_MS);
@@ -26350,7 +27104,7 @@ function createJupyterManager(deps = {}) {
       "--ServerApp.ip=127.0.0.1",
       `--ServerApp.port=${port}`,
       "--ServerApp.port_retries=0",
-      `--ServerApp.root_dir=${path68.parse(process.cwd()).root}`,
+      `--ServerApp.root_dir=${path69.parse(process.cwd()).root}`,
       "--ServerApp.terminals_enabled=False",
       "--ServerApp.shutdown_no_activity_timeout=600",
       "--MappingKernelManager.cull_idle_timeout=3600",
@@ -26360,7 +27114,7 @@ function createJupyterManager(deps = {}) {
       // its terminal does too, and kernels match the terminal.
       ...process.getuid?.() === 0 ? ["--ServerApp.allow_root=True"] : []
     ];
-    const child = spawnFn(exe, args, { cwd: os8.homedir(), env: { ...cleanChildEnv(), JUPYTER_TOKEN: token }, stdio: ["ignore", "ignore", "pipe"], windowsHide: true });
+    const child = spawnFn(exe, args, { cwd: os9.homedir(), env: { ...cleanChildEnv(), JUPYTER_TOKEN: token }, stdio: ["ignore", "ignore", "pipe"], windowsHide: true });
     proc = child;
     let tail = "";
     child.stderr?.on("data", (d) => {
@@ -26428,7 +27182,7 @@ function createJupyterManager(deps = {}) {
       if (kernels.get(id) !== k || k.sockets.size > 0)
         return;
       console.log(`[Jupyter] kernel ${id}: no client for ${KERNEL_GRACE_MS / 1e3}s, shutting it down`);
-      kernelOp(id, "delete").catch((e) => console.log(`[Jupyter] kernel ${id} shutdown failed: ${errMsg2(e)}`));
+      kernelOp(id, "delete").catch((e) => console.log(`[Jupyter] kernel ${id} shutdown failed: ${errMsg3(e)}`));
     }, KERNEL_GRACE_MS);
     k.grace.unref?.();
   }
@@ -26538,7 +27292,7 @@ function createJupyterManager(deps = {}) {
     }
   };
 }
-var JUPYTER_HINT, KERNEL_GRACE_MS, START_TIMEOUT_MS, PROBE_TIMEOUT_MS, STOP_TIMEOUT_MS, JupyterError, errMsg2, lastLine;
+var JUPYTER_HINT, KERNEL_GRACE_MS, START_TIMEOUT_MS, PROBE_TIMEOUT_MS, STOP_TIMEOUT_MS, JupyterError, errMsg3, lastLine;
 var init_manager = __esm({
   "../server/dist/jupyter/manager.js"() {
     "use strict";
@@ -26558,16 +27312,16 @@ var init_manager = __esm({
         this.hint = hint;
       }
     };
-    errMsg2 = (err) => err instanceof Error ? err.message : String(err);
+    errMsg3 = (err) => err instanceof Error ? err.message : String(err);
     lastLine = (s) => s.trim().split("\n").pop()?.trim() ?? "";
   }
 });
 
 // ../server/dist/routes/jupyter.js
-import fs61 from "node:fs/promises";
-import path69 from "node:path";
+import fs62 from "node:fs/promises";
+import path70 from "node:path";
 import { Hono as Hono15 } from "hono";
-import { WebSocketServer as WebSocketServer2 } from "ws";
+import { WebSocketServer as WebSocketServer3 } from "ws";
 function fail(c, err) {
   if (err instanceof JupyterError)
     return c.json({ error: err.message, ...err.hint ? { hint: err.hint } : {} }, err.status);
@@ -26596,8 +27350,8 @@ function createJupyterRoutes(jm) {
       return c.json({ error: "Project not found" }, 400);
     if (!validatePath(nbPath, projectPath))
       return c.json({ error: "Path outside the workspace" }, 400);
-    const cwd = await fs61.realpath(path69.dirname(path69.resolve(projectPath, nbPath))).catch(() => null);
-    if (!cwd || !(await fs61.stat(cwd)).isDirectory())
+    const cwd = await fs62.realpath(path70.dirname(path70.resolve(projectPath, nbPath))).catch(() => null);
+    if (!cwd || !(await fs62.stat(cwd)).isDirectory())
       return c.json({ error: "Notebook directory not found" }, 400);
     try {
       return c.json(await jm.startKernel(name, cwd));
@@ -26641,9 +27395,9 @@ function queryOf(req) {
   return new URLSearchParams(i < 0 ? "" : url.slice(i + 1));
 }
 function createJupyterChannels(jm) {
-  const wss2 = new WebSocketServer2({
+  const wss2 = new WebSocketServer3({
     noServer: true,
-    maxPayload: MAX_FRAME_BYTES2,
+    maxPayload: MAX_FRAME_BYTES3,
     // The client speaks the legacy JSON protocol; never echo a subprotocol.
     handleProtocols: () => false,
     // Same cookie gate as /ws and the transcribe proxy.
@@ -26737,7 +27491,7 @@ function createJupyterChannels(jm) {
     }
   };
 }
-var JUPYTER_CHANNELS_PATH, KERNEL_NAME_RE, SESSION_ID_RE, MAX_FRAME_BYTES2;
+var JUPYTER_CHANNELS_PATH, KERNEL_NAME_RE, SESSION_ID_RE, MAX_FRAME_BYTES3;
 var init_jupyter = __esm({
   "../server/dist/routes/jupyter.js"() {
     "use strict";
@@ -26747,7 +27501,7 @@ var init_jupyter = __esm({
     JUPYTER_CHANNELS_PATH = "/api/jupyter/channels";
     KERNEL_NAME_RE = /^[\w.-]{1,128}$/;
     SESSION_ID_RE = /^[\w-]{1,128}$/;
-    MAX_FRAME_BYTES2 = 64 * 1024 * 1024;
+    MAX_FRAME_BYTES3 = 64 * 1024 * 1024;
   }
 });
 
@@ -26768,8 +27522,8 @@ var init_upgrade_router = __esm({
 });
 
 // ../server/dist/ws/git-dir-watcher.js
-import fs62 from "node:fs";
-import path70 from "node:path";
+import fs63 from "node:fs";
+import path71 from "node:path";
 var GitDirWatcher;
 var init_git_dir_watcher = __esm({
   "../server/dist/ws/git-dir-watcher.js"() {
@@ -26793,8 +27547,8 @@ var init_git_dir_watcher = __esm({
           return;
         this.stop();
         this.workspaceRoot = workspaceRoot;
-        const gitDir = path70.join(workspaceRoot, ".git");
-        if (fs62.existsSync(gitDir)) {
+        const gitDir = path71.join(workspaceRoot, ".git");
+        if (fs63.existsSync(gitDir)) {
           this.watchGitDir(gitDir);
         } else {
           this.watchParentForGit(workspaceRoot);
@@ -26803,7 +27557,7 @@ var init_git_dir_watcher = __esm({
       /** Watch the `.git` dir for index/HEAD changes (steady state). */
       watchGitDir(gitDir) {
         try {
-          this.watcher = fs62.watch(gitDir, { persistent: true, recursive: false }, (_eventType, filename) => {
+          this.watcher = fs63.watch(gitDir, { persistent: true, recursive: false }, (_eventType, filename) => {
             this.handleGitEvent(filename);
           });
           this.watcher.on("error", (err) => {
@@ -26822,7 +27576,7 @@ var init_git_dir_watcher = __esm({
        *  Exists solely during the non-repo window; upgraded away on first `.git`. */
       watchParentForGit(workspaceRoot) {
         try {
-          this.watcher = fs62.watch(workspaceRoot, { persistent: true, recursive: false }, (_eventType, filename) => {
+          this.watcher = fs63.watch(workspaceRoot, { persistent: true, recursive: false }, (_eventType, filename) => {
             this.handleParentEvent(filename);
           });
           this.watcher.on("error", (err) => {
@@ -26858,8 +27612,8 @@ var init_git_dir_watcher = __esm({
         const root = this.workspaceRoot;
         if (!root)
           return;
-        const gitDir = path70.join(root, ".git");
-        if (!fs62.existsSync(gitDir))
+        const gitDir = path71.join(root, ".git");
+        if (!fs63.existsSync(gitDir))
           return;
         this.closeWatcher();
         this.watchGitDir(gitDir);
@@ -27277,7 +28031,7 @@ var init_terminal_manager = __esm({
 });
 
 // ../server/dist/ws/handler.js
-import path71 from "node:path";
+import path72 from "node:path";
 function setupWebSocketHandler(deps) {
   const { wss: wss2, registry: registry2 } = deps;
   const clients = /* @__PURE__ */ new Set();
@@ -27300,7 +28054,7 @@ function setupWebSocketHandler(deps) {
     ackedChatIds.add(id);
   }
   function resolveProjectPath2(projectId) {
-    if (path71.isAbsolute(projectId))
+    if (path72.isAbsolute(projectId))
       return projectId;
     return null;
   }
@@ -27901,11 +28655,11 @@ var init_handler2 = __esm({
 import Database8 from "better-sqlite3";
 import { drizzle as drizzle5 } from "drizzle-orm/better-sqlite3";
 import { sqliteTable as sqliteTable5, text as text5, integer as integer5 } from "drizzle-orm/sqlite-core";
-import path72 from "node:path";
-import fs63 from "node:fs";
+import path73 from "node:path";
+import fs64 from "node:fs";
 function createCronDb(globalDir2) {
-  fs63.mkdirSync(globalDir2, { recursive: true });
-  const dbPath = path72.join(globalDir2, "cron.db");
+  fs64.mkdirSync(globalDir2, { recursive: true });
+  const dbPath = path73.join(globalDir2, "cron.db");
   const sqlite = new Database8(dbPath);
   sqlite.pragma("journal_mode = WAL");
   sqlite.exec(CREATE_SQL5);
@@ -28015,7 +28769,12 @@ var init_cron_db = __esm({
       /** Session this run's cli was spawned on (`-s`). The orphan sweep's
        *  fingerprint — a stateless job's per-run id can't be re-derived from
        *  the job row. NULL on skipped rows and rows from before the column. */
-      sessionId: text5("session_id")
+      sessionId: text5("session_id"),
+      /** Workspace the run fired against (the job's at fire time) — where a
+       *  stateless run's session lives, even after the job moves workspace or is
+       *  deleted. NULL on rows from before the column whose job was already gone
+       *  (deleteRuns falls back to the job row). */
+      workspacePath: text5("workspace_path")
     });
     CREATE_SQL5 = `
 CREATE TABLE IF NOT EXISTS cron_jobs (
@@ -28057,7 +28816,8 @@ CREATE TABLE IF NOT EXISTS cron_runs (
   log_path         TEXT,
   dispatch_results TEXT,
   pid              INTEGER,
-  session_id       TEXT
+  session_id       TEXT,
+  workspace_path   TEXT
 );
 CREATE INDEX IF NOT EXISTS idx_cron_runs_job ON cron_runs(job_id, started_at);
 CREATE INDEX IF NOT EXISTS idx_cron_runs_status ON cron_runs(status);
@@ -28098,6 +28858,15 @@ CREATE INDEX IF NOT EXISTS idx_cron_runs_status ON cron_runs(status);
         addColumnIfMissing(s, "cron_jobs", "working_dir", "TEXT");
         addColumnIfMissing(s, "cron_jobs", "stateless", "INTEGER NOT NULL DEFAULT 0");
         addColumnIfMissing(s, "cron_runs", "session_id", "TEXT");
+      },
+      // v6: `cron_runs.workspace_path` — the workspace a run's session is in.
+      // Backfilled from the job row; runs of an already-deleted job stay NULL.
+      (s) => {
+        addColumnIfMissing(s, "cron_runs", "workspace_path", "TEXT");
+        s.exec(`
+      UPDATE cron_runs SET workspace_path = (SELECT workspace_path FROM cron_jobs WHERE cron_jobs.id = cron_runs.job_id)
+      WHERE workspace_path IS NULL
+    `);
       }
     ];
     _cronDb = null;
@@ -28105,8 +28874,8 @@ CREATE INDEX IF NOT EXISTS idx_cron_runs_status ON cron_runs(status);
 });
 
 // ../server/dist/a2a/exposure.js
-import fs64 from "node:fs";
-import path73 from "node:path";
+import fs65 from "node:fs";
+import path74 from "node:path";
 import crypto6 from "node:crypto";
 function samePath(a, b, platform = process.platform) {
   if (platform !== "win32")
@@ -28119,7 +28888,7 @@ function realBase() {
   if (baseCache?.raw !== raw) {
     let real = null;
     try {
-      real = fs64.realpathSync(raw);
+      real = fs65.realpathSync(raw);
     } catch {
       console.warn(`[A2A] base dir ${raw} not found \u2014 nothing is exposed`);
     }
@@ -28144,14 +28913,14 @@ function resolveExposedWorkspace(base, rel) {
   }
   let real;
   try {
-    real = fs64.realpathSync(path73.join(base, ...segs));
+    real = fs65.realpathSync(path74.join(base, ...segs));
   } catch {
     return null;
   }
-  if (!real.startsWith(base.endsWith(path73.sep) ? base : base + path73.sep))
+  if (!real.startsWith(base.endsWith(path74.sep) ? base : base + path74.sep))
     return null;
   try {
-    if (!fs64.statSync(path73.join(real, CARD_FILE)).isFile())
+    if (!fs65.statSync(path74.join(real, CARD_FILE)).isFile())
       return null;
   } catch {
     return null;
@@ -28166,14 +28935,14 @@ function publicOrigin(c) {
   return `${proto}://${c.req.header("host") ?? url.host}`;
 }
 function buildCard(workspace, interfaceUrl, caps) {
-  const raw = JSON.parse(fs64.readFileSync(path73.join(workspace, CARD_FILE), "utf8"));
+  const raw = JSON.parse(fs65.readFileSync(path74.join(workspace, CARD_FILE), "utf8"));
   if (typeof raw.name !== "string" || typeof raw.description !== "string" || !Array.isArray(raw.skills)) {
     throw new Error('agent-card.json needs string "name", string "description" and array "skills"');
   }
   return {
     name: raw.name,
     description: raw.description,
-    version: typeof raw.version === "string" ? raw.version : "1.6.4",
+    version: typeof raw.version === "string" ? raw.version : "1.6.5",
     supportedInterfaces: [{ url: interfaceUrl, protocolBinding: "JSONRPC", protocolVersion: A2A_VERSION }],
     capabilities: { streaming: caps.streaming, pushNotifications: true, extendedAgentCard: false },
     ...caps.tokenAuth === false ? {} : {
@@ -28200,7 +28969,7 @@ var init_exposure = __esm({
     init_channel_db();
     init_media_store();
     init_wire();
-    CARD_FILE = path73.join(".halo", "agent-card.json");
+    CARD_FILE = path74.join(".halo", "agent-card.json");
     IO_MODES = ["text/plain", ...VISION_IMAGE_MIME_TYPES];
     baseCache = null;
     homeStrategies = {
@@ -28214,7 +28983,7 @@ var init_exposure = __esm({
           return { ok: false, status: 404 };
         let bound;
         try {
-          bound = fs64.realpathSync(auth.account.workspacePath);
+          bound = fs65.realpathSync(auth.account.workspacePath);
         } catch {
           return { ok: false, status: 404 };
         }
@@ -28656,17 +29425,17 @@ var init_routes = __esm({
 });
 
 // ../server/dist/a2a/agentcore.js
-import fs65 from "node:fs";
-import os9 from "node:os";
-import path74 from "node:path";
+import fs66 from "node:fs";
+import os10 from "node:os";
+import path75 from "node:path";
 import crypto8 from "node:crypto";
 import { Hono as Hono17 } from "hono";
 function readLease(file) {
   let raw;
   let mtimeMs;
   try {
-    raw = fs65.readFileSync(file, "utf8");
-    mtimeMs = fs65.statSync(file).mtimeMs;
+    raw = fs66.readFileSync(file, "utf8");
+    mtimeMs = fs66.statSync(file).mtimeMs;
   } catch (err) {
     if (err.code === "ENOENT")
       return null;
@@ -28680,16 +29449,16 @@ function readLease(file) {
   }
 }
 function leaseJson(owner, now) {
-  return JSON.stringify({ owner, host: os9.hostname(), pid: process.pid, heartbeatAt: now });
+  return JSON.stringify({ owner, host: os10.hostname(), pid: process.pid, heartbeatAt: now });
 }
 function writeLease(file, owner, now) {
   const tmp = `${file}.${owner}.tmp`;
-  fs65.writeFileSync(tmp, leaseJson(owner, now));
-  fs65.renameSync(tmp, file);
+  fs66.writeFileSync(tmp, leaseJson(owner, now));
+  fs66.renameSync(tmp, file);
 }
 function tryAcquireLease(file, owner, now = Date.now()) {
   try {
-    fs65.writeFileSync(file, leaseJson(owner, now), { flag: "wx" });
+    fs66.writeFileSync(file, leaseJson(owner, now), { flag: "wx" });
     return "held";
   } catch (err) {
     if (err.code !== "EEXIST")
@@ -28717,7 +29486,7 @@ function heartbeatLease(file, owner, now = Date.now()) {
 function releaseLease(file, owner) {
   try {
     if (readLease(file)?.body?.owner === owner)
-      fs65.unlinkSync(file);
+      fs66.unlinkSync(file);
   } catch {
   }
 }
@@ -28739,7 +29508,7 @@ function upstreamStrategies(workspace, accessLevel) {
 function seedAgentCard(workspace) {
   const card = { name: "Halo", description: "Halo multi-agent workspace on Amazon Bedrock AgentCore. Send a task as plain text.", skills: [] };
   try {
-    fs65.writeFileSync(path74.join(workspace, CARD_FILE), `${JSON.stringify(card, null, 2)}
+    fs66.writeFileSync(path75.join(workspace, CARD_FILE), `${JSON.stringify(card, null, 2)}
 `, { flag: "wx" });
     return true;
   } catch (err) {
@@ -28787,16 +29556,16 @@ function createAgentCoreA2ARoutes(deps) {
   return app2;
 }
 function createAgentCoreA2A(registry2, rawWorkspace, onLost) {
-  const workspace = fs65.realpathSync(rawWorkspace);
-  const haloDir = path74.join(workspace, ".halo");
+  const workspace = fs66.realpathSync(rawWorkspace);
+  const haloDir = path75.join(workspace, ".halo");
   if (!config.a2a.publicUrl)
     console.warn("[AgentCoreA2A] HALO_A2A_PUBLIC_URL is not set \u2014 the card advertises the container's own URL, not the AgentCore invoke URL");
   const accessLevel = upstreamAccessLevel();
-  const lease = new WorkspaceLease(path74.join(haloDir, LEASE_FILE), {
+  const lease = new WorkspaceLease(path75.join(haloDir, LEASE_FILE), {
     onAcquired() {
       setA2ADb(createA2ADb(haloDir));
       setRunsDb(createRunsDb(haloDir));
-      fs65.rmSync(path74.join(haloDir, RUNTIME_LOCK_FILE), { force: true });
+      fs66.rmSync(path75.join(haloDir, RUNTIME_LOCK_FILE), { force: true });
       registry2.getOrCreate(workspace);
       startPushSender({ maxAgeMs: PUSH_MAX_AGE_MS });
       reconcileOpenDispatches();
@@ -28810,9 +29579,9 @@ function createAgentCoreA2A(registry2, rawWorkspace, onLost) {
   const activate = () => {
     if (active)
       return;
-    fs65.mkdirSync(haloDir, { recursive: true });
+    fs66.mkdirSync(haloDir, { recursive: true });
     if (seedAgentCard(workspace))
-      console.log(`[AgentCoreA2A] seeded ${path74.join(workspace, CARD_FILE)}`);
+      console.log(`[AgentCoreA2A] seeded ${path75.join(workspace, CARD_FILE)}`);
     active = true;
   };
   return { app: createAgentCoreA2ARoutes({ registry: registry2, workspace, accessLevel, lease, activate }), lease, workspace };
@@ -28977,12 +29746,12 @@ var init_dispatcher = __esm({
 
 // ../server/dist/cron/runner.js
 import { spawn as spawn3, execFileSync } from "node:child_process";
-import fs66 from "node:fs";
-import path75 from "node:path";
+import fs67 from "node:fs";
+import path76 from "node:path";
 import { homedir as homedir24 } from "node:os";
 import { Cron } from "croner";
 import Database9 from "better-sqlite3";
-import { and as and11, eq as eq14, gte as gte3, inArray as inArray2, lt as lt5, or as or2 } from "drizzle-orm";
+import { and as and11, eq as eq14, gte as gte3, inArray as inArray2, lt as lt5, notInArray, or as or2 } from "drizzle-orm";
 function resolveHaloCli() {
   if (process.env.HALO_CLI)
     return process.env.HALO_CLI;
@@ -29083,9 +29852,9 @@ function jobChangedFields(job) {
 function sessionKeyFor(workspacePath, sessionId) {
   let ws;
   try {
-    ws = fs66.realpathSync(workspacePath);
+    ws = fs67.realpathSync(workspacePath);
   } catch {
-    ws = path75.resolve(workspacePath);
+    ws = path76.resolve(workspacePath);
   }
   return `${ws}
 ${sessionId}`;
@@ -29094,10 +29863,10 @@ function setCronSessionRegistry(r) {
   _sessionRegistry = r;
 }
 function logsDir() {
-  return path75.join(homedir24(), ".halo", "global", "logs", "cron");
+  return path76.join(homedir24(), ".halo", "global", "logs", "cron");
 }
 function logPathFor(runId) {
-  return path75.join(logsDir(), `${runId}.log`);
+  return path76.join(logsDir(), `${runId}.log`);
 }
 function newRunId() {
   return `${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}-${Math.random().toString(36).slice(2, 8)}`;
@@ -29158,7 +29927,7 @@ function sweepOrphanRuns(opts) {
   }
 }
 function startCronDaemon() {
-  fs66.mkdirSync(logsDir(), { recursive: true });
+  fs67.mkdirSync(logsDir(), { recursive: true });
   sweepOrphanRuns();
   reloadAll();
   _daemonTimers.push(setInterval(() => {
@@ -29288,6 +30057,7 @@ function reconcileFromDb() {
   if (dv !== null && _lastCronDataVersion === dv)
     return;
   _lastCronDataVersion = dv;
+  deleteOrphanRuns().catch((err) => console.warn(`[Cron] deleting runs of deleted jobs failed: ${err instanceof Error ? err.message : String(err)}`));
   const db3 = getCronDb();
   const rows = db3.select().from(cronJobs).all();
   const liveIds = /* @__PURE__ */ new Set();
@@ -29342,7 +30112,7 @@ async function runJob(jobId, triggerKind) {
   const runId = newRunId();
   const startedAt = Date.now();
   const logPath = logPathFor(runId);
-  fs66.mkdirSync(logsDir(), { recursive: true });
+  fs67.mkdirSync(logsDir(), { recursive: true });
   const sessionId = job.stateless ? perRunSessionId(job, startedAt) : effectiveSessionId(job);
   const sessionKey = sessionKeyFor(job.workspacePath, sessionId);
   const host = _sessionRegistry?.peek(job.workspacePath);
@@ -29359,7 +30129,8 @@ async function runJob(jobId, triggerKind) {
       exitCode: null,
       failureReason: skipReason,
       logPath: null,
-      dispatchResults: null
+      dispatchResults: null,
+      workspacePath: job.workspacePath
     }).run();
     broadcast({ type: "cron:run_changed", jobId, runId, status: "skipped" });
     return runId;
@@ -29379,11 +30150,12 @@ async function runJob(jobId, triggerKind) {
       failureReason: null,
       logPath,
       dispatchResults: null,
-      sessionId
+      sessionId,
+      workspacePath: job.workspacePath
     }).run();
     broadcast({ type: "cron:run_changed", jobId, runId, status: "running" });
     const targets = parseTargets(job.targets);
-    if (!fs66.existsSync(job.workspacePath)) {
+    if (!fs67.existsSync(job.workspacePath)) {
       finalize(runId, jobId, {
         status: "failed",
         output: null,
@@ -29426,7 +30198,7 @@ async function runJob(jobId, triggerKind) {
       args.push("--access", accessLevel);
     const [spawnBin, spawnArgs] = process.platform === "win32" && cli.endsWith(".cmd") ? ["cmd.exe", ["/c", cli, ...args]] : [cli, args];
     const timeoutSec = job.timeoutSec ?? CLI_TIMEOUT_SEC;
-    const teeStream = fs66.createWriteStream(logPath, { flags: "a" });
+    const teeStream = fs67.createWriteStream(logPath, { flags: "a" });
     teeStream.write(`=== ${(/* @__PURE__ */ new Date()).toISOString()} cron run ${runId} job=${jobId} trigger=${triggerKind} ===
 `);
     teeStream.write(`agent=${job.agentId} session=${sessionId}${job.stateless ? " (stateless)" : ""}${accessLevel ? ` access=${accessLevel}` : ""} workspace=${job.workspacePath} dir=${job.workingDir ?? "."} schedule=${job.schedule}
@@ -29552,8 +30324,8 @@ function readSessionRow(workspacePath, sessionId) {
   try {
     let entry = _sessionRows.get(workspacePath);
     if (!entry) {
-      const file = path75.join(workspacePath, ".halo", "halo.db");
-      if (!fs66.existsSync(file))
+      const file = path76.join(workspacePath, ".halo", "halo.db");
+      if (!fs67.existsSync(file))
         return null;
       entry = { db: new Database9(file, { readonly: true, fileMustExist: true }), version: -1, rows: /* @__PURE__ */ new Map() };
       _sessionRows.set(workspacePath, entry);
@@ -29624,10 +30396,14 @@ function parseTargets(raw) {
 async function pruneOldRuns(jobId) {
   const db3 = getCronDb();
   const job = db3.select({ stateless: cronJobs.stateless }).from(cronJobs).where(eq14(cronJobs.id, jobId)).get();
-  const keep = job?.stateless ? STATELESS_RUNS_PER_JOB_KEEP : RUNS_PER_JOB_KEEP;
+  if (!job) {
+    await deleteJobRuns(jobId);
+    return;
+  }
+  const keep = job.stateless ? STATELESS_RUNS_PER_JOB_KEEP : RUNS_PER_JOB_KEEP;
   const doomed = rawSqlite(db3).prepare(`
     SELECT id, job_id AS jobId, session_id AS sessionId, started_at AS startedAt,
-           completed_at AS completedAt, status
+           completed_at AS completedAt, status, workspace_path AS workspacePath
     FROM cron_runs
     WHERE job_id = ?
       AND id NOT IN (
@@ -29642,31 +30418,44 @@ async function pruneOldRuns(jobId) {
 async function deleteJobRuns(jobId) {
   await deleteRuns(getCronDb().select(DOOMED_RUN_COLUMNS).from(cronRuns).where(eq14(cronRuns.jobId, jobId)).all());
 }
+async function deleteOrphanRuns() {
+  const db3 = getCronDb();
+  await deleteRuns(db3.select(DOOMED_RUN_COLUMNS).from(cronRuns).where(notInArray(cronRuns.jobId, db3.select({ id: cronJobs.id }).from(cronJobs))).all());
+}
 async function deleteRuns(runs) {
   if (runs.length === 0)
     return;
   const db3 = getCronDb();
   const workspaceOf = /* @__PURE__ */ new Map();
-  const failed = /* @__PURE__ */ new Set();
+  const openWorkspace = (workspacePath) => {
+    let ws = workspaceOf.get(workspacePath);
+    if (ws === void 0) {
+      ws = fs67.existsSync(path76.join(workspacePath, ".halo", "halo.db")) ? { workspacePath, db: getWorkspaceDb(workspacePath).db } : null;
+      workspaceOf.set(workspacePath, ws);
+    }
+    return ws;
+  };
+  const keptRows = /* @__PURE__ */ new Set();
   let deleted = 0;
   for (const run of runs) {
     if (run.sessionId !== perRunSessionId({ id: run.jobId }, run.startedAt))
       continue;
+    if (run.status === "running" || run.completedAt === null) {
+      keptRows.add(run.id);
+      console.log(`[Cron] run ${run.id}: still in progress, kept with its session ${run.sessionId}`);
+      continue;
+    }
     try {
-      let ws = workspaceOf.get(run.jobId);
-      if (ws === void 0) {
-        const workspacePath = db3.select({ ws: cronJobs.workspacePath }).from(cronJobs).where(eq14(cronJobs.id, run.jobId)).get()?.ws;
-        ws = workspacePath && fs66.existsSync(path75.join(workspacePath, ".halo", "halo.db")) ? { workspacePath, db: getWorkspaceDb(workspacePath).db } : null;
-        workspaceOf.set(run.jobId, ws);
-      }
+      const workspacePath = run.workspacePath ?? db3.select({ ws: cronJobs.workspacePath }).from(cronJobs).where(eq14(cronJobs.id, run.jobId)).get()?.ws;
+      const ws = workspacePath ? openWorkspace(workspacePath) : null;
       if (ws && await deleteRunSession(ws, run))
         deleted++;
     } catch (err) {
-      failed.add(run.id);
+      keptRows.add(run.id);
       console.warn(`[Cron] run ${run.id}: deleting session ${run.sessionId} failed, run row kept for the next prune: ${err instanceof Error ? err.message : String(err)}`);
     }
   }
-  const ids = runs.map((r) => r.id).filter((id) => !failed.has(id));
+  const ids = runs.map((r) => r.id).filter((id) => !keptRows.has(id));
   if (ids.length > 0)
     db3.delete(cronRuns).where(inArray2(cronRuns.id, ids)).run();
   if (deleted > 0) {
@@ -29680,8 +30469,6 @@ async function deleteRunSession({ workspacePath, db: db3 }, run) {
     console.log(`[Cron] run ${run.id}: kept session ${sid} (${why}); pruning the run row only`);
     return false;
   };
-  if (run.status === "running" || run.completedAt === null)
-    return keep("its run is still in progress");
   const host = _sessionRegistry?.peek(workspacePath);
   if (host?.hasActiveWorkInTree(sid))
     return keep("a turn is running in it");
@@ -29700,15 +30487,15 @@ async function deleteRunSession({ workspacePath, db: db3 }, run) {
 }
 async function pruneOldLogs() {
   const dir = logsDir();
-  if (!fs66.existsSync(dir))
+  if (!fs67.existsSync(dir))
     return;
   const cutoff = Date.now() - LOG_RETENTION_DAYS * DAY_MS2;
-  for (const name of fs66.readdirSync(dir)) {
-    const p = path75.join(dir, name);
+  for (const name of fs67.readdirSync(dir)) {
+    const p = path76.join(dir, name);
     try {
-      const stat = fs66.statSync(p);
+      const stat = fs67.statSync(p);
       if (stat.mtimeMs < cutoff)
-        fs66.rmSync(p, { force: true });
+        fs67.rmSync(p, { force: true });
     } catch {
     }
   }
@@ -29751,7 +30538,8 @@ var init_runner = __esm({
       sessionId: cronRuns.sessionId,
       startedAt: cronRuns.startedAt,
       completedAt: cronRuns.completedAt,
-      status: cronRuns.status
+      status: cronRuns.status,
+      workspacePath: cronRuns.workspacePath
     };
   }
 });
@@ -29759,8 +30547,8 @@ var init_runner = __esm({
 // ../server/dist/routes/cron.js
 import { Hono as Hono18 } from "hono";
 import { eq as eq15, desc as desc3, lt as lt6, and as and12 } from "drizzle-orm";
-import fs67 from "node:fs/promises";
-import path76 from "node:path";
+import fs68 from "node:fs/promises";
+import path77 from "node:path";
 import { Cron as Cron2 } from "croner";
 function newJobId() {
   return `cron-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
@@ -29805,7 +30593,7 @@ async function parseWorkingDir(workspacePath, v) {
     return { workingDir: null };
   try {
     const abs = await resolveWorkingDir(workspacePath, s);
-    return { workingDir: path76.relative(path76.resolve(workspacePath), abs) || null };
+    return { workingDir: path77.relative(path77.resolve(workspacePath), abs) || null };
   } catch (err) {
     return { error: `workingDir: ${err instanceof Error ? err.message : String(err)}` };
   }
@@ -30110,7 +30898,7 @@ function createCronRoutes() {
       return c.json({ log: null });
     let log2 = null;
     try {
-      log2 = await fs67.readFile(row.logPath, "utf-8");
+      log2 = await fs68.readFile(row.logPath, "utf-8");
     } catch {
     }
     return c.json({ log: log2 });
@@ -30176,8 +30964,8 @@ var init_cron = __esm({
 });
 
 // ../server/dist/extensions/install.js
-import fs68 from "node:fs";
-import path77 from "node:path";
+import fs69 from "node:fs";
+import path78 from "node:path";
 import { randomBytes as randomBytes3 } from "node:crypto";
 import JSZip2 from "jszip";
 function safeEntryPath(name) {
@@ -30208,43 +30996,43 @@ async function unpackZip(zipBuf, dest) {
     const perm = entry.unixPermissions;
     if (typeof perm === "number" && (perm & S_IFMT) === S_IFLNK)
       throw new ExtensionInstallError(`zip entry is a symlink: ${entry.name}`);
-    const abs = path77.join(dest, rel);
+    const abs = path78.join(dest, rel);
     if (entry.dir) {
-      fs68.mkdirSync(abs, { recursive: true });
+      fs69.mkdirSync(abs, { recursive: true });
       continue;
     }
-    fs68.mkdirSync(path77.dirname(abs), { recursive: true });
-    fs68.writeFileSync(abs, await entry.async("nodebuffer"));
+    fs69.mkdirSync(path78.dirname(abs), { recursive: true });
+    fs69.writeFileSync(abs, await entry.async("nodebuffer"));
   }
 }
 function stripWrapperDir(dir) {
-  if (fs68.existsSync(path77.join(dir, MANIFEST_FILE)))
+  if (fs69.existsSync(path78.join(dir, MANIFEST_FILE)))
     return;
-  const children = fs68.readdirSync(dir, { withFileTypes: true });
+  const children = fs69.readdirSync(dir, { withFileTypes: true });
   if (children.length !== 1 || !children[0].isDirectory())
     return;
-  const inner = path77.join(dir, children[0].name);
-  if (!fs68.existsSync(path77.join(inner, MANIFEST_FILE)))
+  const inner = path78.join(dir, children[0].name);
+  if (!fs69.existsSync(path78.join(inner, MANIFEST_FILE)))
     return;
-  for (const name of fs68.readdirSync(inner)) {
-    fs68.renameSync(path77.join(inner, name), path77.join(dir, name));
+  for (const name of fs69.readdirSync(inner)) {
+    fs69.renameSync(path78.join(inner, name), path78.join(dir, name));
   }
-  fs68.rmdirSync(inner);
+  fs69.rmdirSync(inner);
 }
 function rand() {
   return randomBytes3(3).toString("hex");
 }
 async function installExtensionZip(zipBuf, expectId) {
   const root = extensionsRoot();
-  fs68.mkdirSync(root, { recursive: true });
-  const stage = path77.join(root, `.tmp-unpack-${rand()}`);
-  fs68.mkdirSync(stage);
+  fs69.mkdirSync(root, { recursive: true });
+  const stage = path78.join(root, `.tmp-unpack-${rand()}`);
+  fs69.mkdirSync(stage);
   try {
     await unpackZip(zipBuf, stage);
     stripWrapperDir(stage);
     let manifestId;
     try {
-      const raw = JSON.parse(fs68.readFileSync(path77.join(stage, MANIFEST_FILE), "utf-8"));
+      const raw = JSON.parse(fs69.readFileSync(path78.join(stage, MANIFEST_FILE), "utf-8"));
       manifestId = typeof raw.id === "string" ? raw.id : "";
     } catch (err) {
       throw new ExtensionInstallError(`${MANIFEST_FILE} missing or unreadable at the zip root: ${err instanceof Error ? err.message : String(err)}`);
@@ -30256,36 +31044,36 @@ async function installExtensionZip(zipBuf, expectId) {
     const verdict2 = readExtensionDir(stage, manifestId);
     if ("error" in verdict2)
       throw new ExtensionInstallError(`invalid extension: ${verdict2.error}`);
-    const target = path77.join(root, manifestId);
-    const old = path77.join(root, `.old-${manifestId}-${rand()}`);
-    const hadOld = fs68.existsSync(target);
+    const target = path78.join(root, manifestId);
+    const old = path78.join(root, `.old-${manifestId}-${rand()}`);
+    const hadOld = fs69.existsSync(target);
     if (hadOld)
-      fs68.renameSync(target, old);
+      fs69.renameSync(target, old);
     try {
-      fs68.renameSync(stage, target);
+      fs69.renameSync(stage, target);
     } catch (err) {
       if (hadOld)
-        fs68.renameSync(old, target);
+        fs69.renameSync(old, target);
       throw err;
     }
     if (hadOld)
-      fs68.rmSync(old, { recursive: true, force: true });
+      fs69.rmSync(old, { recursive: true, force: true });
     const info = readExtensionDir(target);
     if ("error" in info)
       throw new ExtensionInstallError(`installed but failed re-validation: ${info.error}`);
     console.log(`[Extensions] installed ${info.id}@${info.version}${hadOld ? " (replaced previous)" : ""}`);
     return info;
   } finally {
-    fs68.rmSync(stage, { recursive: true, force: true });
+    fs69.rmSync(stage, { recursive: true, force: true });
   }
 }
 function uninstallExtension(id) {
   if (!isExtensionId(id))
     throw new ExtensionInstallError(`"${id}" is not a valid extension id`);
-  const dir = path77.join(extensionsRoot(), id);
-  if (!fs68.existsSync(dir))
+  const dir = path78.join(extensionsRoot(), id);
+  if (!fs69.existsSync(dir))
     return false;
-  fs68.rmSync(dir, { recursive: true, force: true });
+  fs69.rmSync(dir, { recursive: true, force: true });
   console.log(`[Extensions] removed ${id}`);
   return true;
 }
@@ -30302,7 +31090,7 @@ var init_install2 = __esm({
 });
 
 // ../server/dist/extensions/watcher.js
-import fs69 from "node:fs";
+import fs70 from "node:fs";
 function scheduleFlush() {
   if (flushTimer)
     return;
@@ -30313,15 +31101,23 @@ function scheduleFlush() {
 }
 function rescanAndBroadcast() {
   const snap = scanExtensions();
+  reconcileSttModels(snap);
   const key = snapshotKey(snap);
   if (key === lastKey)
     return;
   lastKey = key;
   broadcast({ type: "extension:changed", ...snap });
 }
+function reconcileSttModels(snap) {
+  if (!snap.extensions.some((e) => e.capabilities.includes("stt-local")))
+    return;
+  const { state } = sttModels.status();
+  if (state !== "ready" && state !== "downloading")
+    void sttModels.ensure();
+}
 function openWatcher(root) {
   try {
-    watcher = fs69.watch(root, { persistent: false, recursive: false }, () => scheduleFlush());
+    watcher = fs70.watch(root, { persistent: false, recursive: false }, () => scheduleFlush());
     watcher.on("error", (err) => {
       console.warn(`[Extensions] watch error on ${root}: ${err.message} \u2014 retrying in 1s`);
       closeWatcher();
@@ -30347,11 +31143,13 @@ function start() {
     return;
   const root = extensionsRoot();
   try {
-    fs69.mkdirSync(root, { recursive: true });
+    fs70.mkdirSync(root, { recursive: true });
   } catch (err) {
     console.warn(`[Extensions] cannot create ${root}: ${err instanceof Error ? err.message : String(err)}`);
   }
-  lastKey = snapshotKey(scanExtensions());
+  const snap = scanExtensions();
+  lastKey = snapshotKey(snap);
+  reconcileSttModels(snap);
   openWatcher(root);
   const { extensions, errors } = getSnapshot();
   if (extensions.length > 0 || errors.length > 0) {
@@ -30372,6 +31170,7 @@ var init_watcher = __esm({
   "../server/dist/extensions/watcher.js"() {
     "use strict";
     init_broadcast();
+    init_models();
     init_registry2();
     watcher = null;
     flushTimer = null;
@@ -30382,8 +31181,8 @@ var init_watcher = __esm({
 
 // ../server/dist/routes/extensions.js
 import { Hono as Hono19 } from "hono";
-import fs70 from "node:fs";
-import path78 from "node:path";
+import fs71 from "node:fs";
+import path79 from "node:path";
 import { Readable as Readable2 } from "node:stream";
 function assetMime(fileName) {
   const ext = fileName.split(".").pop()?.toLowerCase() ?? "";
@@ -30401,15 +31200,15 @@ function resolveAsset(id, version, rest) {
   let dir;
   let real;
   try {
-    dir = fs70.realpathSync(path78.join(extensionsRoot(), id));
-    real = fs70.realpathSync(path78.join(dir, ...segments));
+    dir = fs71.realpathSync(path79.join(extensionsRoot(), id));
+    real = fs71.realpathSync(path79.join(dir, ...segments));
   } catch {
     return null;
   }
-  if (real !== dir && !real.startsWith(dir + path78.sep))
+  if (real !== dir && !real.startsWith(dir + path79.sep))
     return null;
   try {
-    if (!fs70.statSync(real).isFile())
+    if (!fs71.statSync(real).isFile())
       return null;
   } catch {
     return null;
@@ -30471,8 +31270,8 @@ function createExtensionRoutes() {
     const abs = resolveAsset(c.req.param("id"), c.req.param("version"), c.req.param("rest"));
     if (!abs)
       return c.json({ error: "Not found" }, 404);
-    const stat = fs70.statSync(abs);
-    const nodeStream = fs70.createReadStream(abs);
+    const stat = fs71.statSync(abs);
+    const nodeStream = fs71.createReadStream(abs);
     c.req.raw.signal?.addEventListener("abort", () => nodeStream.destroy(), { once: true });
     return new Response(Readable2.toWeb(nodeStream), {
       headers: {
@@ -30526,7 +31325,7 @@ var init_extensions = __esm({
 });
 
 // ../server/dist/models/watcher.js
-import fs71 from "node:fs";
+import fs72 from "node:fs";
 function snapshot2() {
   const { effective } = loadProviders();
   return {
@@ -30554,7 +31353,7 @@ function reloadAndBroadcast() {
 }
 function openWatcher2(root) {
   try {
-    watcher2 = fs71.watch(root, { persistent: false, recursive: false }, () => scheduleFlush2());
+    watcher2 = fs72.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();
@@ -30580,7 +31379,7 @@ function start2() {
     return;
   const root = globalHubModelsDir();
   try {
-    fs71.mkdirSync(root, { recursive: true });
+    fs72.mkdirSync(root, { recursive: true });
   } catch (err) {
     console.warn(`[Models] cannot create ${root}: ${err instanceof Error ? err.message : String(err)}`);
   }
@@ -30857,7 +31656,7 @@ var init_ticker = __esm({
 });
 
 // ../server/dist/evolution/spawn.js
-import path79 from "node:path";
+import path80 from "node:path";
 import { spawn as spawn4 } from "node:child_process";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 var __dirname2, WRAPPER_PATH, realEvoSpawner;
@@ -30865,8 +31664,8 @@ var init_spawn = __esm({
   "../server/dist/evolution/spawn.js"() {
     "use strict";
     init_child_env();
-    __dirname2 = path79.dirname(fileURLToPath2(import.meta.url));
-    WRAPPER_PATH = path79.resolve(__dirname2, "evo-wrapper.js");
+    __dirname2 = path80.dirname(fileURLToPath2(import.meta.url));
+    WRAPPER_PATH = path80.resolve(__dirname2, "evo-wrapper.js");
     realEvoSpawner = (mode, id) => {
       const child = spawn4(process.execPath, [WRAPPER_PATH, `--mode=${mode}`, `--id=${id}`], {
         detached: true,
@@ -31697,12 +32496,12 @@ var init_handler3 = __esm({
 });
 
 // ../server/dist/routes/channel-accounts.js
-import fs72 from "node:fs";
+import fs73 from "node:fs";
 function accountListFields(a) {
   return {
     accountId: a.accountId,
     workspacePath: a.workspacePath,
-    workspaceMissing: !fs72.existsSync(a.workspacePath),
+    workspaceMissing: !fs73.existsSync(a.workspacePath),
     label: a.label,
     enabled: a.enabled,
     accessLevel: a.accessLevel,
@@ -32238,7 +33037,7 @@ var init_event_adapter2 = __esm({
 });
 
 // ../server/dist/channels/wechat/cdn.js
-import { createDecipheriv, createCipheriv, randomBytes as randomBytes4, createHash as createHash2 } from "node:crypto";
+import { createDecipheriv, createCipheriv, randomBytes as randomBytes4, createHash as createHash3 } from "node:crypto";
 function decryptAesEcb(ciphertext, key) {
   const decipher = createDecipheriv("aes-128-ecb", key, null);
   return Buffer.concat([decipher.update(ciphertext), decipher.final()]);
@@ -32292,7 +33091,7 @@ function prepareUpload(plaintext) {
     aeskey,
     aeskeyHex: aeskey.toString("hex"),
     rawsize: plaintext.length,
-    rawfilemd5: createHash2("md5").update(plaintext).digest("hex"),
+    rawfilemd5: createHash3("md5").update(plaintext).digest("hex"),
     filesize: aesEcbPaddedSize(plaintext.length)
   };
 }
@@ -32344,8 +33143,8 @@ var init_cdn = __esm({
 });
 
 // ../server/dist/channels/wechat/send-media.js
-import fs73 from "node:fs/promises";
-import path80 from "node:path";
+import fs74 from "node:fs/promises";
+import path81 from "node:path";
 function inferKind(filePath) {
   const cls = classifyMedia(filePath);
   if (cls === "image")
@@ -32357,7 +33156,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 fs73.readFile(filePath);
+  const plaintext = await fs74.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;
@@ -32395,7 +33194,7 @@ async function sendMediaFile(params) {
     aesKeyBase64,
     fileSizeCiphertext: prep.filesize,
     fileSize: prep.rawsize,
-    fileName: path80.basename(filePath)
+    fileName: path81.basename(filePath)
   });
   const clientId = `halo-media-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
   const body = {
@@ -32558,8 +33357,8 @@ var init_login = __esm({
 });
 
 // ../server/dist/channels/wechat/handler.js
-import fs74 from "node:fs";
-import path81 from "node:path";
+import fs75 from "node:fs";
+import path82 from "node:path";
 import QRCode from "qrcode";
 function wxRoute(fromUserId, contextToken, contextTokenAt) {
   return (prev) => {
@@ -32980,7 +33779,7 @@ async function handleSlashCommand(args) {
         await reply(login.message);
         return true;
       }
-      const tmpPath = path81.join(tempDir(), `halo-qr-${login.sessionKey}.png`);
+      const tmpPath = path82.join(tempDir(), `halo-qr-${login.sessionKey}.png`);
       await QRCode.toFile(tmpPath, login.qrcodeUrl, { width: 256, margin: 2 });
       await sendMediaFile({
         baseUrl: account.baseUrl,
@@ -32989,7 +33788,7 @@ async function handleSlashCommand(args) {
         contextToken,
         filePath: tmpPath
       });
-      await fs74.promises.unlink(tmpPath).catch(() => {
+      await fs75.promises.unlink(tmpPath).catch(() => {
       });
       await reply(t("wechat.qr_sent", lang, { level, path: account.workspacePath }));
       waitLogin({ sessionKey: login.sessionKey }).then(async (result2) => {
@@ -33069,8 +33868,8 @@ var init_handler4 = __esm({
 
 // ../server/dist/routes/wechat.js
 import { Hono as Hono21 } from "hono";
-import path82 from "node:path";
-import fs75 from "node:fs";
+import path83 from "node:path";
+import fs76 from "node:fs";
 function createWechatRoutes(deps) {
   const { db: db3, channel } = deps;
   const app2 = new Hono21();
@@ -33079,7 +33878,7 @@ function createWechatRoutes(deps) {
       return {
         ...stripSecrets(acc),
         workspacePath: acc.workspacePath,
-        workspaceMissing: !fs75.existsSync(acc.workspacePath)
+        workspaceMissing: !fs76.existsSync(acc.workspacePath)
       };
     });
     return c.json({ accounts });
@@ -33095,7 +33894,7 @@ function createWechatRoutes(deps) {
       return c.json({ error: "sessionKey required" }, 400);
     if (!body.workspacePath)
       return c.json({ error: "workspacePath required" }, 400);
-    if (!path82.isAbsolute(body.workspacePath))
+    if (!path83.isAbsolute(body.workspacePath))
       return c.json({ error: "workspacePath must be absolute" }, 400);
     const levelError = accessLevelError(body.accessLevel, CHAT_ACCESS_LEVELS);
     if (levelError)
@@ -33308,7 +34107,7 @@ var init_descriptor2 = __esm({
 import { Hono as Hono22 } from "hono";
 import { streamSSE as streamSSE2 } from "hono/streaming";
 import crypto10 from "node:crypto";
-import fs76 from "node:fs";
+import fs77 from "node:fs";
 function streamWithKeepalive(c, chunks) {
   return streamSSE2(c, async (stream) => {
     const timer2 = setInterval(() => {
@@ -33499,30 +34298,30 @@ function createWebRoutes(deps) {
     const filePath = c.req.query("path");
     if (!filePath)
       return c.json({ error: "path required" }, 400);
-    const path89 = await import("node:path");
-    const resolved = path89.default.resolve(account.workspacePath, filePath);
-    const root = path89.default.resolve(account.workspacePath);
-    if (resolved !== root && !resolved.startsWith(root + path89.default.sep)) {
+    const path90 = await import("node:path");
+    const resolved = path90.default.resolve(account.workspacePath, filePath);
+    const root = path90.default.resolve(account.workspacePath);
+    if (resolved !== root && !resolved.startsWith(root + path90.default.sep)) {
       return c.json({ error: "path traversal not allowed" }, 403);
     }
     let real;
     let realRoot;
     try {
-      real = fs76.realpathSync(resolved);
-      realRoot = fs76.realpathSync(root);
+      real = fs77.realpathSync(resolved);
+      realRoot = fs77.realpathSync(root);
     } catch {
       return c.json({ error: "file not found" }, 404);
     }
-    if (real !== realRoot && !real.startsWith(realRoot + path89.default.sep)) {
+    if (real !== realRoot && !real.startsWith(realRoot + path90.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 = fs76.statSync(real);
+    const stat = fs77.statSync(real);
     if (stat.isDirectory())
       return c.json({ error: "cannot serve directory" }, 400);
-    const ext = path89.default.extname(real).toLowerCase();
+    const ext = path90.default.extname(real).toLowerCase();
     const nonImageMimes = {
       ".mp4": "video/mp4",
       ".webm": "video/webm",
@@ -33530,8 +34329,8 @@ function createWebRoutes(deps) {
       ".txt": "text/plain"
     };
     const contentType = imageMimeFromExt(ext) || nonImageMimes[ext] || "application/octet-stream";
-    const fileName = path89.default.basename(resolved);
-    const data = fs76.readFileSync(real);
+    const fileName = path90.default.basename(resolved);
+    const data = fs77.readFileSync(real);
     c.header("content-type", contentType);
     c.header("content-disposition", `inline; filename="${fileName}"`);
     return c.body(data);
@@ -33753,10 +34552,10 @@ async function authTest(botToken) {
   return slackPost("auth.test", botToken, {});
 }
 async function uploadFile(args) {
-  const fs80 = await import("node:fs");
-  const path89 = await import("node:path");
-  const filename = args.filename ?? path89.basename(args.filePath);
-  const stat = fs80.statSync(args.filePath);
+  const fs81 = await import("node:fs");
+  const path90 = await import("node:path");
+  const filename = args.filename ?? path90.basename(args.filePath);
+  const stat = fs81.statSync(args.filePath);
   if (!stat.isFile())
     throw new Error(`[slack:uploadFile] not a regular file: ${args.filePath}`);
   const length = stat.size;
@@ -33774,7 +34573,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 = fs80.readFileSync(args.filePath);
+  const buf = fs81.readFileSync(args.filePath);
   const step2 = await fetch(step1Parsed.upload_url, {
     method: "POST",
     body: buf
@@ -33919,7 +34718,7 @@ var init_api2 = __esm({
 });
 
 // ../server/dist/channels/slack/handler.js
-import path83 from "node:path";
+import path84 from "node:path";
 import { WebSocket as WebSocket2 } from "ws";
 function slashToBang(text6, commandNames) {
   if (commandNames.length === 0)
@@ -34050,7 +34849,7 @@ function startSlackChannel(deps) {
             const route = bridge.getRoute(sessionId);
             if (!account || !route)
               return;
-            const resolved = path83.resolve(filePath);
+            const resolved = path84.resolve(filePath);
             await sendMediaOrReport({
               filePath,
               account,
@@ -34692,10 +35491,10 @@ async function replyMessage(args) {
   return { message_id: parsed.data?.message_id ?? "" };
 }
 async function uploadImage(args) {
-  const fs80 = await import("node:fs");
-  const path89 = await import("node:path");
-  const buf = fs80.readFileSync(args.filePath);
-  const filename = path89.basename(args.filePath);
+  const fs81 = await import("node:fs");
+  const path90 = await import("node:path");
+  const buf = fs81.readFileSync(args.filePath);
+  const filename = path90.basename(args.filePath);
   const send2 = async (token) => {
     const form = new FormData();
     form.append("image_type", "message");
@@ -34711,10 +35510,10 @@ async function uploadImage(args) {
   return { imageKey: parsed.data.image_key };
 }
 async function uploadFile2(args) {
-  const fs80 = await import("node:fs");
-  const path89 = await import("node:path");
-  const buf = fs80.readFileSync(args.filePath);
-  const filename = args.filename ?? path89.basename(args.filePath);
+  const fs81 = await import("node:fs");
+  const path90 = await import("node:path");
+  const buf = fs81.readFileSync(args.filePath);
+  const filename = args.filename ?? path90.basename(args.filePath);
   const send2 = async (token) => {
     const form = new FormData();
     form.append("file_type", args.fileType);
@@ -34781,7 +35580,7 @@ var init_api3 = __esm({
 });
 
 // ../server/dist/channels/feishu/handler.js
-import path84 from "node:path";
+import path85 from "node:path";
 import * as Lark from "@larksuiteoapi/node-sdk";
 function buildSessionPrefixForThread2(chatId, rootId) {
   return sessionPrefix("feishu", `${chatId}:${rootId}`);
@@ -34984,7 +35783,7 @@ function startFeishuChannel(deps) {
             const route = bridge.getRoute(sessionId);
             if (!account || !route)
               return;
-            const resolved = path84.resolve(filePath);
+            const resolved = path85.resolve(filePath);
             await sendMediaOrReport({
               filePath,
               account,
@@ -35151,7 +35950,7 @@ async function replyToInbound(args) {
 async function sendFeishuMedia(args) {
   const { account, inboundMessageId, isP2P, chatId, filePath } = args;
   const cls = classifyMedia(filePath);
-  const ext = path84.extname(filePath).toLowerCase();
+  const ext = path85.extname(filePath).toLowerCase();
   if (cls === "image") {
     const { imageKey } = await uploadImage({ appId: account.appId, appSecret: account.appSecret, filePath });
     await replyToInboundRaw({
@@ -35540,8 +36339,8 @@ var init_event_adapter5 = __esm({
 });
 
 // ../server/dist/channels/wecom/handler.js
-import path85 from "node:path";
-import fs77 from "node:fs/promises";
+import path86 from "node:path";
+import fs78 from "node:fs/promises";
 import { WSClient as WSClient2, generateReqId } from "@wecom/aibot-node-sdk";
 function pickConversation(body) {
   const userid = body.from?.userid ?? "unknown";
@@ -35664,13 +36463,13 @@ async function replyText(wsClient, route, text6) {
 }
 async function sendWecomMedia(args) {
   const { wsClient, route, filePath } = args;
-  const ext = path85.extname(filePath).toLowerCase();
+  const ext = path86.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 fs77.readFile(filePath);
+  const buf = await fs78.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: path85.basename(filePath) });
+  const { media_id: mediaId } = await wsClient.uploadMedia(buf, { type, filename: path86.basename(filePath) });
   if (route.reqId)
     await wsClient.replyMedia({ headers: { req_id: route.reqId } }, type, mediaId);
   else
@@ -35715,7 +36514,7 @@ function startWecomChannel(deps) {
             const wsClient = states.get(accountId)?.wsClient;
             if (!account || !route || !wsClient)
               return;
-            const resolved = path85.resolve(filePath);
+            const resolved = path86.resolve(filePath);
             await sendMediaOrReport({
               filePath,
               account,
@@ -36140,18 +36939,18 @@ import { cors } from "hono/cors";
 import { compress } from "hono/compress";
 import { serve } from "@hono/node-server";
 import { serveStatic } from "@hono/node-server/serve-static";
-import { WebSocketServer as WebSocketServer3 } from "ws";
-import path86 from "node:path";
-import fs78 from "node:fs";
+import { WebSocketServer as WebSocketServer4 } from "ws";
+import path87 from "node:path";
+import fs79 from "node:fs";
 import { spawnSync as spawnSync4 } from "node:child_process";
 import { homedir as homedir25 } from "node:os";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 function findProjectRoot() {
   let dir = process.cwd();
   for (let i = 0; i < 32; i++) {
-    if (fs78.existsSync(path86.join(dir, "pnpm-workspace.yaml")))
+    if (fs79.existsSync(path87.join(dir, "pnpm-workspace.yaml")))
       return dir;
-    const parent = path86.dirname(dir);
+    const parent = path87.dirname(dir);
     if (parent === dir)
       break;
     dir = parent;
@@ -36161,15 +36960,15 @@ function findProjectRoot() {
   return process.cwd();
 }
 function acquireSingleInstanceLock(lockFile) {
-  fs78.mkdirSync(path86.dirname(lockFile), { recursive: true });
-  const fd = fs78.openSync(lockFile, fs78.constants.O_RDWR | fs78.constants.O_CREAT, 420);
+  fs79.mkdirSync(path87.dirname(lockFile), { recursive: true });
+  const fd = fs79.openSync(lockFile, fs79.constants.O_RDWR | fs79.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)) {
-      fs78.closeSync(fd);
+      fs79.closeSync(fd);
       console.error(`[Server] another halo server is already running (pid ${content}). kill it first.`);
       process.exit(1);
     }
@@ -36178,19 +36977,19 @@ function acquireSingleInstanceLock(lockFile) {
     if (content > 0 && !isProcessAlive(content)) {
       console.warn(`[Server] removing stale server.lock (pid ${content} not running)`);
     } else {
-      fs78.closeSync(fd);
+      fs79.closeSync(fd);
       console.error(`[Server] another halo server is already running${content > 0 ? ` (pid ${content})` : ""}. kill it first.`);
       process.exit(1);
     }
   }
-  fs78.ftruncateSync(fd);
-  fs78.writeSync(fd, String(process.pid));
-  fs78.fsyncSync(fd);
+  fs79.ftruncateSync(fd);
+  fs79.writeSync(fd, String(process.pid));
+  fs79.fsyncSync(fd);
 }
 function readLockPid(fd) {
   try {
     const buf = Buffer.alloc(32);
-    const n = fs78.readSync(fd, buf, 0, 32, 0);
+    const n = fs79.readSync(fd, buf, 0, 32, 0);
     return parseInt(buf.subarray(0, n).toString("utf-8").trim(), 10) || 0;
   } catch {
     return 0;
@@ -36218,7 +37017,7 @@ function isProcessAlive(pid) {
   }
 }
 function readGitSha() {
-  if (!fs78.existsSync(path86.join(PROJECT_ROOT, "pnpm-workspace.yaml")) || !fs78.existsSync(path86.join(PROJECT_ROOT, ".git")))
+  if (!fs79.existsSync(path87.join(PROJECT_ROOT, "pnpm-workspace.yaml")) || !fs79.existsSync(path87.join(PROJECT_ROOT, ".git")))
     return null;
   try {
     const rev = spawnSync4("git", ["rev-parse", "--short", "HEAD"], { cwd: PROJECT_ROOT, encoding: "utf-8" });
@@ -36239,14 +37038,14 @@ function applySandboxPaths() {
 }
 function resolveFrontendDir() {
   if (process.env.HALO_FRONTEND_DIR)
-    return path86.resolve(process.env.HALO_FRONTEND_DIR);
-  const bundled = path86.resolve(__dirname3, "..", "admin-out");
-  if (fs78.existsSync(path86.join(bundled, "index.html")))
+    return path87.resolve(process.env.HALO_FRONTEND_DIR);
+  const bundled = path87.resolve(__dirname3, "..", "admin-out");
+  if (fs79.existsSync(path87.join(bundled, "index.html")))
     return bundled;
-  const sibling = path86.resolve(__dirname3, "..", "..", "admin", "out");
-  if (fs78.existsSync(path86.join(sibling, "index.html")))
+  const sibling = path87.resolve(__dirname3, "..", "..", "admin", "out");
+  if (fs79.existsSync(path87.join(sibling, "index.html")))
     return sibling;
-  return path86.resolve(PROJECT_ROOT, "packages", "admin", "out");
+  return path87.resolve(PROJECT_ROOT, "packages", "admin", "out");
 }
 async function gracefulShutdown(signal) {
   console.log(`[Server] Received ${signal}, shutting down gracefully...`);
@@ -36262,6 +37061,7 @@ async function gracefulShutdown(signal) {
   });
   wss.close();
   transcribe?.close();
+  stt?.close();
   jupyterChannels?.close();
   await jupyter?.stop();
   if (server && typeof server.close === "function") {
@@ -36280,7 +37080,7 @@ async function gracefulShutdown(signal) {
   await shutdownObservability();
   process.exit(0);
 }
-var __dirname3, PORT, HALO_VERSION, PROJECT_ROOT, HALO_HOME4, GIT_SHA, AGENTCORE, sandboxWarning, app, allowlist, jupyter, channelDb, OWNS_RUNTIMES, registry, agentcoreLease, FRONTEND_DIR, server, wss, transcribe, jupyterChannels, upgradeRoutes;
+var __dirname3, PORT, HALO_VERSION, PROJECT_ROOT, HALO_HOME4, GIT_SHA, AGENTCORE, sandboxWarning, app, allowlist, jupyter, channelDb, OWNS_RUNTIMES, registry, agentcoreLease, FRONTEND_DIR, server, wss, transcribe, stt, jupyterChannels, upgradeRoutes;
 var init_dist2 = __esm({
   async "../server/dist/index.js"() {
     "use strict";
@@ -36297,6 +37097,7 @@ var init_dist2 = __esm({
     init_metrics();
     init_commands3();
     init_transcribe_ws();
+    init_stt_ws();
     init_jupyter();
     init_manager();
     init_upgrade_router();
@@ -36334,13 +37135,13 @@ var init_dist2 = __esm({
     init_sandbox();
     init_init();
     init_git_ssh();
-    __dirname3 = path86.dirname(fileURLToPath3(import.meta.url));
+    __dirname3 = path87.dirname(fileURLToPath3(import.meta.url));
     PORT = config.server.port;
-    HALO_VERSION = "1.6.4";
+    HALO_VERSION = "1.6.5";
     PROJECT_ROOT = findProjectRoot();
-    HALO_HOME4 = path86.join(homedir25(), ".halo");
+    HALO_HOME4 = path87.join(homedir25(), ".halo");
     GIT_SHA = readGitSha();
-    if (!fs78.existsSync(path86.join(HALO_HOME4, "global", ".template-version"))) {
+    if (!fs79.existsSync(path87.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);
     }
@@ -36351,7 +37152,7 @@ var init_dist2 = __esm({
       process.exit(1);
     }
     if (!AGENTCORE)
-      acquireSingleInstanceLock(path86.join(HALO_HOME4, "global", "server.lock"));
+      acquireSingleInstanceLock(path87.join(HALO_HOME4, "global", "server.lock"));
     commandRegistry.assertDispatchCommands(DISPATCH_COMMANDS);
     await initObservability();
     initLogger();
@@ -36421,12 +37222,12 @@ var init_dist2 = __esm({
       app.route("/api", createJupyterRoutes(jupyter));
     }
     start2();
-    channelDb = createChannelDb(path86.join(HALO_HOME4, "secrets"));
+    channelDb = createChannelDb(path87.join(HALO_HOME4, "secrets"));
     setChannelDb(channelDb);
-    setEvoDb(createEvoDb(path86.join(HALO_HOME4, "global")));
-    setCronDb(createCronDb(path86.join(HALO_HOME4, "global")));
+    setEvoDb(createEvoDb(path87.join(HALO_HOME4, "global")));
+    setCronDb(createCronDb(path87.join(HALO_HOME4, "global")));
     if (!AGENTCORE)
-      setRunsDb(createRunsDb(path86.join(HALO_HOME4, "global")));
+      setRunsDb(createRunsDb(path87.join(HALO_HOME4, "global")));
     setEvoSpawner(realEvoSpawner);
     if (!AGENTCORE) {
       startEvoTicker();
@@ -36441,7 +37242,7 @@ var init_dist2 = __esm({
     setCronSessionRegistry(registry);
     if (OWNS_RUNTIMES && !AGENTCORE) {
       for (const ws of listRunningWorkspaces()) {
-        if (!fs78.existsSync(path86.join(ws, ".halo")))
+        if (!fs79.existsSync(path87.join(ws, ".halo")))
           continue;
         if (!claimWorkspaceRuntime(ws))
           continue;
@@ -36467,7 +37268,7 @@ var init_dist2 = __esm({
       startCronDaemon();
     }
     if (!AGENTCORE) {
-      setA2ADb(createA2ADb(path86.join(HALO_HOME4, "global")));
+      setA2ADb(createA2ADb(path87.join(HALO_HOME4, "global")));
       setA2AOutboundRegistry(registry);
       app.route("/a2a", createA2ARoutes({ registry, ownsRuntimes: OWNS_RUNTIMES }));
       app.route("/", createA2APushRoutes());
@@ -36483,11 +37284,11 @@ var init_dist2 = __esm({
     }
     FRONTEND_DIR = resolveFrontendDir();
     if (!AGENTCORE) {
-      app.use("/*", serveStatic({ root: path86.relative(process.cwd(), FRONTEND_DIR) }));
+      app.use("/*", serveStatic({ root: path87.relative(process.cwd(), FRONTEND_DIR) }));
       app.get("/*", (c) => {
-        const indexPath = path86.join(FRONTEND_DIR, "index.html");
+        const indexPath = path87.join(FRONTEND_DIR, "index.html");
         try {
-          const html = fs78.readFileSync(indexPath, "utf-8");
+          const html = fs79.readFileSync(indexPath, "utf-8");
           return c.html(html);
         } catch {
           return c.text("Frontend not built. Run: cd packages/admin && npx next build", 503);
@@ -36506,7 +37307,7 @@ var init_dist2 = __esm({
       for (const line of AGENTCORE ? lines.slice(0, 1) : lines)
         logAlways(line);
     });
-    wss = new WebSocketServer3({
+    wss = new WebSocketServer4({
       noServer: true,
       verifyClient: (info, callback) => {
         const token = getTokenFromCookieHeader(info.req.headers.cookie);
@@ -36522,12 +37323,15 @@ var init_dist2 = __esm({
       setBroadcastWss(wss);
     }
     transcribe = AGENTCORE ? null : createTranscribeProxy();
+    stt = AGENTCORE ? null : createSttProxy();
     jupyterChannels = jupyter ? createJupyterChannels(jupyter) : null;
     upgradeRoutes = new Map(AGENTCORE ? [] : [
       ["/ws", (req, socket, head) => wss.handleUpgrade(req, socket, head, (ws) => wss.emit("connection", ws, req))]
     ]);
     if (transcribe)
       upgradeRoutes.set(TRANSCRIBE_PATH, transcribe.handleUpgrade);
+    if (stt)
+      upgradeRoutes.set(STT_PATH, stt.handleUpgrade);
     if (jupyterChannels)
       upgradeRoutes.set(JUPYTER_CHANNELS_PATH, jupyterChannels.handleUpgrade);
     server.on("upgrade", createUpgradeRouter(upgradeRoutes));
@@ -36695,8 +37499,8 @@ var init_halo_client = __esm({
         }
         return await res.json();
       }
-      sessionUrl(path89, workspace, sessionId) {
-        const url = new URL(`${this.opts.baseUrl}${path89}`);
+      sessionUrl(path90, workspace, sessionId) {
+        const url = new URL(`${this.opts.baseUrl}${path90}`);
         url.searchParams.set("workspace", workspace);
         url.searchParams.set("sessionId", sessionId);
         return url;
@@ -36844,7 +37648,7 @@ var init_version = __esm({
 });
 
 // ../acp-adapter/dist/adapter.js
-import path87 from "node:path";
+import path88 from "node:path";
 function composePrompt(blocks) {
   const segments = [];
   let run = "";
@@ -37037,7 +37841,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 && path87.resolve(p.cwd) !== path87.resolve(page.workspace))
+        if (p.cwd !== void 0 && path88.resolve(p.cwd) !== path88.resolve(page.workspace))
           return { sessions: [] };
         return {
           sessions: page.sessions.map((s) => ({
@@ -37651,8 +38455,8 @@ process.emitWarning = (warning, ...args) => {
 
 // src/index.ts
 init_server_supervisor();
-import path88 from "node:path";
-import fs79 from "node:fs";
+import path89 from "node:path";
+import fs80 from "node:fs";
 import { homedir as homedir26, userInfo } from "node:os";
 import { parseArgs as parseArgs2 } from "node:util";
 
@@ -37943,7 +38747,7 @@ function installUserUnit(opts, run = runCommand) {
 }
 
 // src/index.ts
-var VERSION = "1.6.4";
+var VERSION = "1.6.5";
 var HELP_TOP = `Usage: halo <command> [options]
 
 Commands:
@@ -38285,8 +39089,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 = path88.join(homedir26(), ".halo");
-  const globalDir2 = path88.join(haloHome2, "global");
+  const haloHome2 = path89.join(homedir26(), ".halo");
+  const globalDir2 = path89.join(haloHome2, "global");
   ensureHaloHome2(haloHome2);
   process.stderr.write(`[setup] ${haloHome2}/ ready
 `);
@@ -38639,7 +39443,7 @@ async function cmdUpgrade() {
 `);
       process.exit(1);
     }
-    const broken = verifyNativeModules2(path88.join(rootDir, PKG));
+    const broken = verifyNativeModules2(path89.join(rootDir, PKG));
     if (broken.length > 0) {
       process.stderr.write(
         `
@@ -38670,7 +39474,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 = path88.resolve(flags.workspace ?? process.cwd());
+  const workspace = path89.resolve(flags.workspace ?? process.cwd());
   const agents = await listAgents2(workspace);
   if (agents.length === 0) {
     process.stderr.write("No agents found.\n");
@@ -38686,7 +39490,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 = path88.resolve(flags.workspace ?? process.cwd());
+  const workspace = path89.resolve(flags.workspace ?? process.cwd());
   const sessions = listSessions2(workspace);
   if (sessions.length === 0) {
     process.stderr.write("No sessions found.\n");
@@ -38717,7 +39521,7 @@ async function cmdModels(argv) {
     process.exitCode = 1;
     return;
   }
-  const plan = mod.planModelsInstall(path88.resolve(dir));
+  const plan = mod.planModelsInstall(path89.resolve(dir));
   for (const line of mod.formatPlan(plan)) process.stdout.write(`${line}
 `);
   if (plan.needsConfirm && !values.yes) {
@@ -38826,11 +39630,11 @@ ${stdinContent}` : stdinContent;
     harness.destroy();
   }
 }
-var SERVER_LOCK_PATH = path88.join(homedir26(), ".halo", "global", "server.lock");
-var SERVER_LOG_PATH = path88.join(homedir26(), ".halo", "logs", "server.log");
+var SERVER_LOCK_PATH = path89.join(homedir26(), ".halo", "global", "server.lock");
+var SERVER_LOG_PATH = path89.join(homedir26(), ".halo", "logs", "server.log");
 function readServerPid() {
   try {
-    const txt = fs79.readFileSync(SERVER_LOCK_PATH, "utf-8").trim();
+    const txt = fs80.readFileSync(SERVER_LOCK_PATH, "utf-8").trim();
     const n = parseInt(txt, 10);
     return Number.isFinite(n) && n > 0 ? n : null;
   } catch {
@@ -38937,8 +39741,8 @@ async function cmdServerStart(argv, restart) {
   }
   if (plan.note) writeDim(plan.note);
   const { spawn: spawn5 } = await import("node:child_process");
-  fs79.mkdirSync(path88.dirname(SERVER_LOG_PATH), { recursive: true });
-  const out = fs79.openSync(SERVER_LOG_PATH, "a");
+  fs80.mkdirSync(path89.dirname(SERVER_LOG_PATH), { recursive: true });
+  const out = fs80.openSync(SERVER_LOG_PATH, "a");
   const child = spawn5(process.argv[0], [process.argv[1], "server", "start"], {
     detached: true,
     stdio: ["ignore", out, out],
@@ -39018,8 +39822,8 @@ ${HELP_AGENTCORE}`);
     process.exitCode = 1;
     return;
   }
-  const workspace = path88.resolve(raw);
-  if (!fs79.statSync(workspace, { throwIfNoEntry: false })?.isDirectory()) {
+  const workspace = path89.resolve(raw);
+  if (!fs80.statSync(workspace, { throwIfNoEntry: false })?.isDirectory()) {
     process.stderr.write(`Workspace is not a directory: ${workspace}
 `);
     process.exitCode = 1;
@@ -39125,7 +39929,7 @@ async function cmdServerLogs(argv) {
       lines: { type: "string", short: "n" }
     }
   });
-  if (!fs79.existsSync(SERVER_LOG_PATH)) {
+  if (!fs80.existsSync(SERVER_LOG_PATH)) {
     process.stderr.write(`No log file at ${SERVER_LOG_PATH}
 `);
     return;
@@ -39143,7 +39947,7 @@ function exitMissingSetup() {
   process.exit(1);
 }
 function isHaloHomeReady() {
-  return fs79.existsSync(path88.join(homedir26(), ".halo", "global", ".template-version"));
+  return fs80.existsSync(path89.join(homedir26(), ".halo", "global", ".template-version"));
 }
 async function main2() {
   const argv = process.argv.slice(2);