reasonix 0.49.0 → 0.50.1

package/dist/cli/{server-Z3IMJNNI.js → server-SZZDKTH2.js}

@@ -13,8 +13,8 @@ import {
   listCheckpoints,
   loadCheckpoint,
   restoreCheckpoint
-} from "./chunk-TEDWJKEI.js";
-import "./chunk-E5WCLUIU.js";
+} from "./chunk-3RNFYDDM.js";
+import "./chunk-XJZWMU5P.js";
 import {
   fetchSmitheryDetail,
   handleToFetchResult,
@@ -24,11 +24,11 @@ import {
 } from "./chunk-XJXDHAES.js";
 import {
   registerSemanticSearchTool
-} from "./chunk-TAIKVL35.js";
+} from "./chunk-WSBFVOCO.js";
 import {
   BUILTIN_ALLOWLIST,
   lineDiff
-} from "./chunk-ZWHSHFDP.js";
+} from "./chunk-6IUMTRFP.js";
 import {
   PROJECT_MEMORY_FILE,
   SKILLS_DIRNAME,
@@ -38,13 +38,13 @@ import {
   parseFrontmatter,
   resolveProjectMemoryWritePath,
   validateSkillFrontmatter
-} from "./chunk-JNTMOX7G.js";
+} from "./chunk-ENFBF6HI.js";
 import "./chunk-PLHAZOLZ.js";
 import {
   checkOllamaStatus,
   pullOllamaModel,
   startOllamaDaemon
-} from "./chunk-PEMG6CUB.js";
+} from "./chunk-TX652NBA.js";
 import {
   INDEX_DIR_NAME,
   buildIndex,
@@ -53,47 +53,51 @@ import {
   querySemantic,
   readIndexMeta,
   walkChunks
-} from "./chunk-DFX5ZH5L.js";
+} from "./chunk-AAHB2PFX.js";
 import {
   HOOK_EVENTS,
   globalSettingsPath,
   loadHooks,
   projectSettingsPath
-} from "./chunk-PB3MAFEI.js";
+} from "./chunk-AJIZ5KFK.js";
 import "./chunk-S4XVGLRW.js";
 import {
   deleteSession,
   listSessions,
   sessionPath,
   sessionsDir
-} from "./chunk-RRXUIPWG.js";
+} from "./chunk-IK6WWRIX.js";
 import {
   aggregateUsage,
   bucketCacheHitRatio,
   formatLogSize,
   readUsageLog
-} from "./chunk-ZAEJWKXB.js";
+} from "./chunk-GMSAB2TC.js";
 import {
   DEEPSEEK_PRICING,
   cacheSavingsUsd
-} from "./chunk-QX5TWXRZ.js";
+} from "./chunk-FQSQFCBI.js";
 import {
   getLanguage,
   getSupportedLanguages,
   setLanguage
-} from "./chunk-YEF7C4XI.js";
+} from "./chunk-PYIZZAVQ.js";
 import {
   DEFAULT_INDEX_EXCLUDES,
   DEFAULT_MAX_FILE_BYTES,
+  DEFAULT_MODEL,
   DEFAULT_RESPECT_GITIGNORE,
+  REASONING_EFFORT_VALUES,
   addProjectShellAllowed,
   clearProjectShellAllowed,
   isPlausibleKey,
+  isReasoningEffort,
   loadIndexConfig,
   loadIndexUserConfig,
   loadProjectShellAllowed,
   loadResolvedSkillPaths,
   loadSemanticEmbeddingUserConfig,
+  loadSubagentModels,
   normalizeSkillPathEntries,
   normalizeSkillPaths,
   readConfig,
@@ -102,11 +106,12 @@ import {
   removeProjectShellAllowed,
   resolveIndexConfig,
   resolveSemanticEmbeddingConfig,
+  saveEditMode,
   saveSemanticEmbeddingConfig,
   trustProjectHooks,
   webSearchEngine,
   writeConfig
-} from "./chunk-WMTMMSXU.js";
+} from "./chunk-MXWPAPZW.js";
 import {
   VERSION
 } from "./chunk-XXC2BYTV.js";
@@ -183,12 +188,13 @@ function resolveAssetDir() {
   return candidates[0];
 }
 var ASSET_DIR = resolveAssetDir();
-var fileCache = /* @__PURE__ */ new Map();
-function loadCachedFile(path) {
+var textCache = /* @__PURE__ */ new Map();
+var binaryCache = /* @__PURE__ */ new Map();
+function loadCachedText(path) {
   const fd = openSync(path, "r");
   try {
     const stat = fstatSync(fd);
-    const cached = fileCache.get(path);
+    const cached = textCache.get(path);
     if (cached && cached.mtimeMs === stat.mtimeMs) return cached.body;
     const buf = Buffer.alloc(stat.size);
     let read = 0;
@@ -198,27 +204,73 @@ function loadCachedFile(path) {
       read += n;
     }
     const body = buf.toString("utf8", 0, read);
-    fileCache.set(path, { body, mtimeMs: stat.mtimeMs });
+    textCache.set(path, { body, mtimeMs: stat.mtimeMs });
     return body;
   } finally {
     closeSync(fd);
   }
 }
+function loadCachedBinary(path) {
+  const fd = openSync(path, "r");
+  try {
+    const stat = fstatSync(fd);
+    const cached = binaryCache.get(path);
+    if (cached && cached.mtimeMs === stat.mtimeMs) return cached.body;
+    const buf = Buffer.alloc(stat.size);
+    let read = 0;
+    while (read < stat.size) {
+      const n = readSync(fd, buf, read, stat.size - read, read);
+      if (n <= 0) break;
+      read += n;
+    }
+    binaryCache.set(path, { body: buf.slice(0, read), mtimeMs: stat.mtimeMs });
+    return buf.slice(0, read);
+  } finally {
+    closeSync(fd);
+  }
+}
 function loadIndexTemplate() {
-  return loadCachedFile(join(ASSET_DIR, "index.html"));
+  return loadCachedText(join(ASSET_DIR, "index.html"));
+}
+function injectTokenIntoChunkImports(body, token) {
+  return body.replace(
+    /(from\s*|import\s*)(["'])(\.\/[\w.-]+\.js)\2/g,
+    (_, kw, q, path) => `${kw}${q}${path}?token=${token}${q}`
+  );
 }
-function loadApp() {
-  return loadCachedFile(join(ASSET_DIR, "dist", "app.js"));
+function injectTokenIntoCssAssetUrls(body, token) {
+  return body.replace(
+    /url\((['"]?)(\/assets\/[\w./-]+\.(?:woff2?|ttf|otf|png|svg))(?:\?[^)'"]*)?\1\)/g,
+    (_, q, path) => `url(${q}${path}?token=${token}${q})`
+  );
+}
+function loadApp(token) {
+  const raw = loadCachedText(join(ASSET_DIR, "dist", "app.js"));
+  return injectTokenIntoChunkImports(raw, token);
+}
+function loadChunk(name, token) {
+  try {
+    const raw = loadCachedText(join(ASSET_DIR, "dist", name));
+    return injectTokenIntoChunkImports(raw, token);
+  } catch {
+    return null;
+  }
 }
 function loadAppMap() {
   try {
-    return loadCachedFile(join(ASSET_DIR, "dist", "app.js.map"));
+    return loadCachedText(join(ASSET_DIR, "dist", "app.js.map"));
   } catch {
     return null;
   }
 }
-function loadCss() {
-  return loadCachedFile(join(ASSET_DIR, "app.css"));
+function loadCss(token) {
+  let raw;
+  try {
+    raw = loadCachedText(join(ASSET_DIR, "dist", "app.css"));
+  } catch {
+    raw = loadCachedText(join(ASSET_DIR, "app.css"));
+  }
+  return injectTokenIntoCssAssetUrls(raw, token);
 }
 function renderIndexHtml(token, mode) {
   const tpl = loadIndexTemplate();
@@ -226,22 +278,77 @@ function renderIndexHtml(token, mode) {
   return tpl.replaceAll("__REASONIX_TOKEN__", safeToken).replaceAll("__REASONIX_MODE__", mode);
 }
 var VENDOR_CSS_NAMES = /* @__PURE__ */ new Set(["vendor-hljs.css", "vendor-uplot.css"]);
-function loadVendorCss(name) {
-  return loadCachedFile(join(ASSET_DIR, "dist", name));
+function loadVendorCss(name, token) {
+  try {
+    return injectTokenIntoCssAssetUrls(loadCachedText(join(ASSET_DIR, "dist", name)), token);
+  } catch {
+    return null;
+  }
 }
-function serveAsset(name) {
+var MIME_MAP = {
+  ".js": "application/javascript; charset=utf-8",
+  ".mjs": "application/javascript; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".woff2": "font/woff2",
+  ".woff": "font/woff",
+  ".ttf": "font/ttf",
+  ".svg": "image/svg+xml",
+  ".png": "image/png",
+  ".ico": "image/x-icon",
+  ".json": "application/json; charset=utf-8"
+};
+var BINARY_EXTS = /* @__PURE__ */ new Set([".woff2", ".woff", ".ttf", ".png", ".ico"]);
+function mimetypeFor(name) {
+  for (const [ext, mt] of Object.entries(MIME_MAP)) {
+    if (name.endsWith(ext)) return mt;
+  }
+  return null;
+}
+function isBinaryAsset(name) {
+  for (const ext of BINARY_EXTS) {
+    if (name.endsWith(ext)) return true;
+  }
+  return false;
+}
+function loadDistFile(name) {
+  const paths = [join(ASSET_DIR, "dist", "assets", name), join(ASSET_DIR, "dist", name)];
+  const binary = isBinaryAsset(name);
+  for (const p of paths) {
+    try {
+      return {
+        body: binary ? loadCachedBinary(p) : loadCachedText(p),
+        isBinary: binary
+      };
+    } catch {
+    }
+  }
+  return null;
+}
+function serveAsset(name, token = "") {
   if (name === "app.js") {
-    return { body: loadApp(), contentType: "application/javascript; charset=utf-8" };
+    return { body: loadApp(token), contentType: "application/javascript; charset=utf-8" };
   }
   if (name === "app.js.map") {
     const body = loadAppMap();
     return body == null ? null : { body, contentType: "application/json; charset=utf-8" };
   }
   if (name === "app.css") {
-    return { body: loadCss(), contentType: "text/css; charset=utf-8" };
+    return { body: loadCss(token), contentType: "text/css; charset=utf-8" };
+  }
+  if (/^vendor-[\w.-]+\.js$/.test(name)) {
+    const body = loadChunk(name, token);
+    if (body == null) return null;
+    return { body, contentType: "application/javascript; charset=utf-8" };
   }
   if (VENDOR_CSS_NAMES.has(name)) {
-    return { body: loadVendorCss(name), contentType: "text/css; charset=utf-8" };
+    const body = loadVendorCss(name, token);
+    if (body == null) return null;
+    return { body, contentType: "text/css; charset=utf-8" };
+  }
+  const mt = mimetypeFor(name);
+  if (mt) {
+    const result = loadDistFile(name);
+    if (result != null) return { body: result.body, contentType: mt };
   }
   return null;
 }
@@ -262,6 +369,121 @@ async function handleAbort(method, _rest, _body, ctx) {
   return { status: 202, body: { aborted: true } };
 }
 
+// src/server/api/browse.ts
+import { execSync } from "child_process";
+import { existsSync, readdirSync, statSync } from "fs";
+import { homedir } from "os";
+import { dirname as dirname2, isAbsolute, resolve } from "path";
+var SKIP_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  ".svn",
+  ".hg",
+  ".next",
+  ".cache",
+  "__pycache__",
+  ".venv",
+  "venv",
+  ".pytest_cache",
+  ".mypy_cache",
+  ".tox",
+  "dist",
+  "build"
+]);
+var cachedDriveList = null;
+function listWindowsDrives() {
+  if (cachedDriveList) return cachedDriveList;
+  try {
+    const raw = execSync("wmic logicaldisk get deviceid /value", {
+      encoding: "utf8",
+      timeout: 1500
+    });
+    const drives = raw.split(/\r?\n/).map((l) => l.trim()).filter((l) => l.startsWith("DeviceID=")).map((l) => `${l.slice("DeviceID=".length)}\\`).filter((d) => existsSync(d));
+    cachedDriveList = drives.length > 0 ? drives : ["C:\\"];
+  } catch {
+    const found = [];
+    for (const letter of "CDEFGHIJKLMNOPQRSTUVWXYZ") {
+      const p = `${letter}:\\`;
+      try {
+        if (existsSync(p)) found.push(p);
+      } catch {
+      }
+    }
+    cachedDriveList = found.length > 0 ? found : ["C:\\"];
+  }
+  return cachedDriveList;
+}
+function isWindowsDriveRoot(p) {
+  return /^[A-Za-z]:[\\/]?$/.test(p);
+}
+function defaultRoot() {
+  try {
+    return homedir();
+  } catch {
+    return process.platform === "win32" ? "C:\\" : "/";
+  }
+}
+function readSubdirs(path) {
+  let names;
+  try {
+    names = readdirSync(path);
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const name of names) {
+    if (SKIP_DIRS.has(name)) continue;
+    if (name.startsWith(".") && name.length > 1) continue;
+    const full = resolve(path, name);
+    try {
+      if (!statSync(full).isDirectory()) continue;
+    } catch {
+      continue;
+    }
+    out.push({ name, full });
+  }
+  out.sort((a, b) => a.name.localeCompare(b.name, void 0, { sensitivity: "base" }));
+  return out;
+}
+async function handleBrowse(method, _rest, _body, _ctx, query) {
+  if (method !== "GET") return { status: 405, body: { error: "GET only" } };
+  const rawPath = (query.get("path") ?? "").trim();
+  const isWin = process.platform === "win32";
+  if (!rawPath) {
+    const home = defaultRoot();
+    const entries = readSubdirs(home);
+    if (isWin) {
+      const drives = listWindowsDrives().filter((d) => resolve(d) !== resolve(home)).map((d) => ({ name: d, full: d }));
+      entries.unshift(...drives);
+    }
+    const result2 = { path: home, parent: null, entries };
+    return { status: 200, body: result2 };
+  }
+  if (!isAbsolute(rawPath)) {
+    return { status: 400, body: { error: "path must be absolute" } };
+  }
+  const absolute = resolve(rawPath);
+  if (!existsSync(absolute)) {
+    return { status: 404, body: { error: `no such directory: ${absolute}` } };
+  }
+  let isDir = false;
+  try {
+    isDir = statSync(absolute).isDirectory();
+  } catch {
+  }
+  if (!isDir) {
+    return { status: 400, body: { error: `not a directory: ${absolute}` } };
+  }
+  let parent = dirname2(absolute);
+  if (parent === absolute || isWin && isWindowsDriveRoot(absolute)) parent = null;
+  const result = {
+    path: absolute,
+    parent,
+    entries: readSubdirs(absolute)
+  };
+  return { status: 200, body: result };
+}
+
 // src/server/api/checkpoint-create.ts
 async function handleCheckpointCreate(method, _rest, body, ctx) {
   if (method !== "POST") return { status: 405, body: { error: "POST only" } };
@@ -276,12 +498,12 @@ async function handleCheckpointCreate(method, _rest, body, ctx) {
   if (!parsed.name) return { status: 400, body: { error: "missing name" } };
   let paths;
   try {
-    const { execSync: execSync2 } = await import("child_process");
+    const { execSync: execSync3 } = await import("child_process");
     const env = { ...process.env };
     for (const k of Object.keys(env)) {
       if (k.startsWith("GIT_")) delete env[k];
     }
-    const stdout = execSync2("git ls-files --cached --others --exclude-standard", {
+    const stdout = execSync3("git ls-files --cached --others --exclude-standard", {
       cwd: rootDir,
       env,
       encoding: "utf8",
@@ -337,7 +559,7 @@ async function handleCheckpointDelete(method, _rest, body, ctx) {
 
 // src/server/api/checkpoint-diffs.ts
 import { readFileSync as readFileSync2 } from "fs";
-import { resolve } from "path";
+import { resolve as resolve2 } from "path";
 async function handleCheckpointDiffs(method, _rest, _body, ctx, query = new URLSearchParams()) {
   if (method !== "GET") return { status: 405, body: { error: "GET only" } };
   const rootDir = ctx.getCurrentCwd?.();
@@ -348,7 +570,7 @@ async function handleCheckpointDiffs(method, _rest, _body, ctx, query = new URLS
   if (!checkpoint) return { status: 404, body: { error: "checkpoint not found" } };
   const diffs = [];
   for (const snap of checkpoint.files) {
-    const absPath = resolve(rootDir, snap.path);
+    const absPath = resolve2(rootDir, snap.path);
     let currentContent = null;
     try {
       currentContent = readFileSync2(absPath, "utf8");
@@ -484,9 +706,9 @@ async function handleEditMode(method, _rest, body, ctx) {
 
 // src/server/api/file-read.ts
 import { closeSync as closeSync2, fstatSync as fstatSync2, openSync as openSync2, readSync as readSync2 } from "fs";
-import { extname, join as join2, resolve as resolve2, sep } from "path";
+import { extname, join as join2, resolve as resolve3, sep } from "path";
 var MAX_FILE_SIZE = 500 * 1024;
-var BINARY_EXTS = /* @__PURE__ */ new Set([
+var BINARY_EXTS2 = /* @__PURE__ */ new Set([
   ".png",
   ".jpg",
   ".jpeg",
@@ -522,13 +744,13 @@ async function handleFileRead(method, rest, _body, ctx) {
   if (!filePath) return { status: 400, body: { error: "file path required" } };
   const cwd = ctx.getCurrentCwd?.();
   if (!cwd) return { status: 503, body: { error: "no project directory available" } };
-  const resolved = resolve2(join2(cwd, filePath));
-  const normalizedCwd = resolve2(cwd);
+  const resolved = resolve3(join2(cwd, filePath));
+  const normalizedCwd = resolve3(cwd);
   if (!resolved.startsWith(normalizedCwd + sep) && resolved !== normalizedCwd) {
     return { status: 403, body: { error: "path escapes workspace" } };
   }
   const ext = extname(filePath).toLowerCase();
-  if (BINARY_EXTS.has(ext)) {
+  if (BINARY_EXTS2.has(ext)) {
     return { status: 400, body: { error: "binary file not supported" } };
   }
   let fd;
@@ -561,11 +783,11 @@ async function handleFileRead(method, rest, _body, ctx) {
 }
 
 // src/server/api/files.ts
-import { existsSync, readdirSync, statSync } from "fs";
+import { existsSync as existsSync2, readdirSync as readdirSync2, statSync as statSync2 } from "fs";
 import { extname as extname2, join as join3, relative, sep as sep2 } from "path";
 var RESULT_CAP = 50;
 var MAX_DEPTH = 4;
-var SKIP_DIRS = /* @__PURE__ */ new Set([
+var SKIP_DIRS2 = /* @__PURE__ */ new Set([
   "node_modules",
   ".git",
   ".reasonix",
@@ -598,7 +820,7 @@ var SKIP_EXTS = /* @__PURE__ */ new Set([
 async function handleFiles(method, _rest, body, ctx) {
   if (method !== "POST") return { status: 405, body: { error: "POST only" } };
   const cwd = ctx.getCurrentCwd?.();
-  if (!cwd || !existsSync(cwd)) {
+  if (!cwd || !existsSync2(cwd)) {
     return { status: 503, body: { error: "@-mention picker requires a code-mode session" } };
   }
   let parsed;
@@ -619,18 +841,18 @@ function walk(root, prefix) {
     if (depth > MAX_DEPTH) continue;
     let names;
     try {
-      names = readdirSync(path);
+      names = readdirSync2(path);
     } catch {
       continue;
     }
     for (const name of names) {
       if (out.length >= RESULT_CAP) break;
       if (name.startsWith(".") && depth === 0) continue;
-      if (SKIP_DIRS.has(name)) continue;
+      if (SKIP_DIRS2.has(name)) continue;
       const full = join3(path, name);
       let st;
       try {
-        st = statSync(full);
+        st = statSync2(full);
       } catch {
         continue;
       }
@@ -649,7 +871,7 @@ function walk(root, prefix) {
 }
 
 // src/server/api/git-diffs.ts
-import { execSync } from "child_process";
+import { execSync as execSync2 } from "child_process";
 function parseGitDiff(stdout) {
   const files = [];
   const blocks = stdout.split(/\ndiff --git /).filter(Boolean);
@@ -679,17 +901,17 @@ async function handleGitDiffs(method, _rest, _body, _ctx) {
   let stagedStdout;
   let untracked;
   try {
-    diffStdout = execSync("git diff --no-color --unified=3 HEAD", {
+    diffStdout = execSync2("git diff --no-color --unified=3 HEAD", {
       encoding: "utf8",
       maxBuffer: 10 * 1024 * 1024,
       windowsHide: true
     });
-    stagedStdout = execSync("git diff --no-color --unified=3 --cached", {
+    stagedStdout = execSync2("git diff --no-color --unified=3 --cached", {
       encoding: "utf8",
       maxBuffer: 10 * 1024 * 1024,
       windowsHide: true
     });
-    untracked = execSync("git ls-files --others --exclude-standard", {
+    untracked = execSync2("git ls-files --others --exclude-standard", {
       encoding: "utf8",
       maxBuffer: 1024 * 1024,
       windowsHide: true
@@ -722,28 +944,28 @@ ${stagedStdout}` : "");
 }
 
 // src/server/api/health.ts
-import { existsSync as existsSync2, readdirSync as readdirSync2, statSync as statSync2 } from "fs";
-import { homedir } from "os";
+import { existsSync as existsSync3, readdirSync as readdirSync3, statSync as statSync3 } from "fs";
+import { homedir as homedir2 } from "os";
 import { join as join4 } from "path";
 function dirSize(path) {
-  if (!existsSync2(path)) return { path, exists: false, fileCount: 0, totalBytes: 0 };
+  if (!existsSync3(path)) return { path, exists: false, fileCount: 0, totalBytes: 0 };
   let fileCount = 0;
   let totalBytes = 0;
   try {
-    const entries = readdirSync2(path);
+    const entries = readdirSync3(path);
     for (const name of entries) {
       const full = join4(path, name);
       try {
-        const s = statSync2(full);
+        const s = statSync3(full);
         if (s.isFile()) {
           fileCount++;
           totalBytes += s.size;
         } else if (s.isDirectory()) {
           try {
-            const inner = readdirSync2(full);
+            const inner = readdirSync3(full);
             for (const child of inner) {
               try {
-                const cs = statSync2(join4(full, child));
+                const cs = statSync3(join4(full, child));
                 if (cs.isFile()) {
                   fileCount++;
                   totalBytes += cs.size;
@@ -766,15 +988,15 @@ async function handleHealth(method, _rest, _body, ctx) {
   if (method !== "GET") {
     return { status: 405, body: { error: "GET only" } };
   }
-  const home = homedir();
+  const home = homedir2();
   const reasonixHome = join4(home, ".reasonix");
   const sessionsStat = dirSize(join4(reasonixHome, "sessions"));
   const memoryStat = dirSize(join4(reasonixHome, "memory"));
   const semanticStat = dirSize(join4(reasonixHome, "semantic"));
   let usageBytes = 0;
-  if (existsSync2(ctx.usageLogPath)) {
+  if (existsSync3(ctx.usageLogPath)) {
     try {
-      usageBytes = statSync2(ctx.usageLogPath).size;
+      usageBytes = statSync3(ctx.usageLogPath).size;
     } catch {
     }
   }
@@ -811,15 +1033,15 @@ async function handleHealth(method, _rest, _body, ctx) {
 }
 
 // src/server/api/hooks.ts
-import { existsSync as existsSync4, mkdirSync, readFileSync as readFileSync3, writeFileSync } from "fs";
-import { dirname as dirname2 } from "path";
+import { existsSync as existsSync5, mkdirSync, readFileSync as readFileSync3, writeFileSync } from "fs";
+import { dirname as dirname3 } from "path";
 
 // src/server/api/hooks-events.ts
-import { existsSync as existsSync3 } from "fs";
+import { existsSync as existsSync4 } from "fs";
 var HOOK_LOG_CAP = 12;
 function readRecentHookRuns(now = Date.now(), sessionsDirOverride) {
   const dir = sessionsDirOverride ?? sessionsDir();
-  if (!existsSync3(dir)) return null;
+  if (!existsSync4(dir)) return null;
   const files = recentEventFiles(dir, now);
   if (files.length === 0) return null;
   const rows = [];
@@ -852,7 +1074,7 @@ function parseBody2(raw) {
   }
 }
 function readSettingsFile(path) {
-  if (!existsSync4(path)) return {};
+  if (!existsSync5(path)) return {};
   try {
     const raw = readFileSync3(path, "utf8");
     const parsed = JSON.parse(raw);
@@ -864,7 +1086,7 @@ function readSettingsFile(path) {
 function writeSettingsFile(path, hooksBlock) {
   const existing = readSettingsFile(path);
   existing.hooks = hooksBlock;
-  mkdirSync(dirname2(path), { recursive: true });
+  mkdirSync(dirname3(path), { recursive: true });
   writeFileSync(path, `${JSON.stringify(existing, null, 2)}
 `, "utf8");
 }
@@ -1414,24 +1636,24 @@ async function handleMcp(method, rest, body, ctx, query = new URLSearchParams())
 // src/server/api/memory.ts
 import { createHash } from "crypto";
 import {
-  existsSync as existsSync5,
+  existsSync as existsSync6,
   mkdirSync as mkdirSync2,
   readFileSync as readFileSync4,
-  readdirSync as readdirSync3,
-  statSync as statSync3,
+  readdirSync as readdirSync4,
+  statSync as statSync4,
   unlinkSync,
   writeFileSync as writeFileSync2
 } from "fs";
-import { homedir as homedir2 } from "os";
-import { basename, dirname as dirname3, join as join5, resolve as resolvePath } from "path";
+import { homedir as homedir3 } from "os";
+import { basename, dirname as dirname4, join as join5, resolve as resolvePath } from "path";
 function projectHash(rootDir) {
   return createHash("sha1").update(resolvePath(rootDir)).digest("hex").slice(0, 16);
 }
 function globalMemoryDir() {
-  return join5(homedir2(), ".reasonix", "memory", "global");
+  return join5(homedir3(), ".reasonix", "memory", "global");
 }
 function projectMemoryDir(rootDir) {
-  return join5(homedir2(), ".reasonix", "memory", projectHash(rootDir));
+  return join5(homedir3(), ".reasonix", "memory", projectHash(rootDir));
 }
 function parseBody6(raw) {
   if (!raw) return {};
@@ -1444,10 +1666,10 @@ function parseBody6(raw) {
 }
 var SAFE_NAME = /^[a-zA-Z0-9][a-zA-Z0-9._-]{0,63}$/;
 function listMemoryFiles(dir) {
-  if (!existsSync5(dir)) return [];
+  if (!existsSync6(dir)) return [];
   try {
-    return readdirSync3(dir).filter((f) => f.endsWith(".md")).map((f) => {
-      const stat = statSync3(join5(dir, f));
+    return readdirSync4(dir).filter((f) => f.endsWith(".md")).map((f) => {
+      const stat = statSync4(join5(dir, f));
       return {
         name: f.replace(/\.md$/, ""),
         size: stat.size,
@@ -1498,7 +1720,7 @@ async function handleMemory(method, rest, body, ctx) {
       const dir = scope === "global" ? globalDir : projectMemDir;
       if (!dir) return { status: 503, body: { error: "no project root for project-mem" } };
       const path = join5(dir, `${name}.md`);
-      if (!existsSync5(path)) return { status: 404, body: { error: "not found" } };
+      if (!existsSync6(path)) return { status: 404, body: { error: "not found" } };
       return { status: 200, body: { path, body: readFileSync4(path, "utf8") } };
     }
     return { status: 400, body: { error: "bad scope or name" } };
@@ -1511,7 +1733,7 @@ async function handleMemory(method, rest, body, ctx) {
     if (scope === "project") {
       if (!cwd) return { status: 503, body: { error: "no active project" } };
       const path = resolveProjectMemoryWritePath(cwd);
-      mkdirSync2(dirname3(path), { recursive: true });
+      mkdirSync2(dirname4(path), { recursive: true });
       writeFileSync2(path, contents, "utf8");
       ctx.audit?.({ ts: Date.now(), action: "save-memory", payload: { scope, path } });
       return { status: 200, body: { saved: true, path } };
@@ -1532,7 +1754,7 @@ async function handleMemory(method, rest, body, ctx) {
       const dir = scope === "global" ? globalDir : projectMemDir;
       if (!dir) return { status: 503, body: { error: "no project root for project-mem" } };
       const path = join5(dir, `${name}.md`);
-      if (existsSync5(path)) {
+      if (existsSync6(path)) {
         unlinkSync(path);
         ctx.audit?.({ ts: Date.now(), action: "delete-memory", payload: { scope, name, path } });
         return { status: 200, body: { deleted: true } };
@@ -1752,14 +1974,14 @@ async function handleModels(method, _rest, _body, ctx) {
 }
 
 // src/server/api/cockpit-events.ts
-import { existsSync as existsSync6 } from "fs";
+import { existsSync as existsSync7 } from "fs";
 var DAY_MS = 864e5;
 var RECENT_FILES_CAP = 8;
 var PLAN_FEED_CAP = 4;
 var TOOL_FEED_CAP = 6;
 function computeEventsCockpit(now = Date.now(), sessionsDirOverride) {
   const dir = sessionsDirOverride ?? sessionsDir();
-  if (!existsSync6(dir)) {
+  if (!existsSync7(dir)) {
     return { toolCalls24h: null, recentPlans: null, toolActivity: null };
   }
   const files = recentEventFiles(dir, now, RECENT_FILES_CAP);
@@ -2002,8 +2224,7 @@ async function handleOverview(method, _rest, _body, ctx) {
     pendingEdits: ctx.getPendingEditCount?.() ?? null,
     mcpServerCount: ctx.getMcpServers?.().length ?? null,
     toolCount: ctx.tools ? ctx.tools.size : null,
-    preset: cfg.preset ?? "auto",
-    reasoningEffort: cfg.reasoningEffort ?? "max",
+    reasoningEffort: isReasoningEffort(cfg.reasoningEffort) ? cfg.reasoningEffort : "high",
     budgetUsd: ctx.loop?.budgetUsd ?? null,
     stats: ctx.getStats?.() ?? null,
     semanticIndexExists,
@@ -2142,10 +2363,10 @@ async function handlePlans(method, _rest, _body, _ctx) {
 }
 
 // src/server/api/project-tree.ts
-import { existsSync as existsSync7, readdirSync as readdirSync4, statSync as statSync4 } from "fs";
+import { existsSync as existsSync8, readdirSync as readdirSync5, statSync as statSync5 } from "fs";
 import { extname as extname3, join as join6, relative as relative2, sep as sep3 } from "path";
 var MAX_DEPTH2 = 6;
-var SKIP_DIRS2 = /* @__PURE__ */ new Set([
+var SKIP_DIRS3 = /* @__PURE__ */ new Set([
   "node_modules",
   ".git",
   ".reasonix",
@@ -2178,7 +2399,7 @@ var SKIP_EXTS2 = /* @__PURE__ */ new Set([
 async function handleProjectTree(method, _rest, _body, ctx) {
   if (method !== "GET") return { status: 405, body: { error: "GET only" } };
   const cwd = ctx.getCurrentCwd?.();
-  if (!cwd || !existsSync7(cwd)) {
+  if (!cwd || !existsSync8(cwd)) {
     return { status: 503, body: { error: "no project directory available" } };
   }
   const tree = buildTree(cwd, cwd, 0);
@@ -2188,7 +2409,7 @@ function buildTree(root, dirPath, depth) {
   if (depth > MAX_DEPTH2) return [];
   let names;
   try {
-    names = readdirSync4(dirPath);
+    names = readdirSync5(dirPath);
   } catch {
     return [];
   }
@@ -2196,11 +2417,11 @@ function buildTree(root, dirPath, depth) {
   const dirs = [];
   const files = [];
   for (const name of names) {
-    if (SKIP_DIRS2.has(name)) continue;
+    if (SKIP_DIRS3.has(name)) continue;
     const full = join6(dirPath, name);
     let st;
     try {
-      st = statSync4(full);
+      st = statSync5(full);
     } catch {
       continue;
     }
@@ -2670,7 +2891,7 @@ function isAbortError(err) {
 }
 
 // src/server/api/sessions.ts
-import { existsSync as existsSync8, readFileSync as readFileSync5 } from "fs";
+import { existsSync as existsSync9, readFileSync as readFileSync5 } from "fs";
 function parseTranscript(path, maxBytes = 4 * 1024 * 1024) {
   let raw;
   try {
@@ -2688,8 +2909,23 @@ function parseTranscript(path, maxBytes = 4 * 1024 * 1024) {
       const msg = { role };
       if (typeof rec.content === "string") msg.content = rec.content;
       else if (rec.content !== void 0) msg.content = JSON.stringify(rec.content);
+      if (typeof rec.reasoning_content === "string") msg.reasoning = rec.reasoning_content;
+      if (Array.isArray(rec.tool_calls)) {
+        const calls = [];
+        for (const c of rec.tool_calls) {
+          const fn = c?.function ?? {};
+          const id = typeof c?.id === "string" ? c.id : "";
+          const name = typeof fn.name === "string" ? fn.name : "";
+          const args = typeof fn.arguments === "string" ? fn.arguments : "";
+          if (id || name) calls.push({ id, name, arguments: args });
+        }
+        if (calls.length > 0) msg.toolCalls = calls;
+      }
+      if (typeof rec.tool_call_id === "string") msg.toolCallId = rec.tool_call_id;
+      else if (typeof rec.toolCallId === "string") msg.toolCallId = rec.toolCallId;
       if (typeof rec.tool_name === "string") msg.toolName = rec.tool_name;
-      if (typeof rec.toolName === "string") msg.toolName = rec.toolName;
+      else if (typeof rec.toolName === "string") msg.toolName = rec.toolName;
+      else if (typeof rec.name === "string" && role === "tool") msg.toolName = rec.name;
       out.push(msg);
     } catch {
     }
@@ -2698,7 +2934,8 @@ function parseTranscript(path, maxBytes = 4 * 1024 * 1024) {
 }
 async function handleSessions(method, rest, _body, ctx) {
   if (method === "GET" && rest.length === 0) {
-    const sessions = listSessions();
+    const workspaceFilter = ctx.getCurrentCwd?.();
+    const sessions = workspaceFilter ? listSessions({ workspaceFilter }) : listSessions();
     const currentName2 = ctx.getSessionName?.() ?? null;
     return {
       status: 200,
@@ -2708,7 +2945,8 @@ async function handleSessions(method, rest, _body, ctx) {
           path: s.path,
           size: s.size,
           messageCount: s.messageCount,
-          mtime: s.mtime.getTime()
+          mtime: s.mtime.getTime(),
+          summary: s.meta?.summary
         })),
         currentSession: currentName2,
         canSwitch: Boolean(ctx.switchSession)
@@ -2724,7 +2962,7 @@ async function handleSessions(method, rest, _body, ctx) {
     }
     const result = ctx.switchSession(void 0);
     if (!result.ok) return { status: 500, body: { error: result.reason } };
-    return { status: 200, body: { ok: true } };
+    return { status: 200, body: { ok: true, name: ctx.getSessionName?.() ?? null } };
   }
   if (rest.length === 0) {
     return { status: 405, body: { error: `method ${method} not supported on /sessions` } };
@@ -2739,7 +2977,7 @@ async function handleSessions(method, rest, _body, ctx) {
         body: { error: "live session swap requires an attached CLI session." }
       };
     }
-    if (!existsSync8(path)) return { status: 404, body: { error: `no such session: ${name}` } };
+    if (!existsSync9(path)) return { status: 404, body: { error: `no such session: ${name}` } };
     const result = ctx.switchSession(name);
     if (!result.ok) return { status: 500, body: { error: result.reason } };
     return { status: 200, body: { ok: true } };
@@ -2754,7 +2992,7 @@ async function handleSessions(method, rest, _body, ctx) {
         body: { error: "cannot delete the currently-active session \u2014 switch away first." }
       };
     }
-    if (!existsSync8(path)) return { status: 404, body: { error: `no such session: ${name}` } };
+    if (!existsSync9(path)) return { status: 404, body: { error: `no such session: ${name}` } };
     const removed = deleteSession(name);
     if (!removed) return { status: 500, body: { error: `failed to delete ${name}` } };
     ctx.audit?.({ ts: Date.now(), action: "delete-session", payload: { name } });
@@ -2764,7 +3002,7 @@ async function handleSessions(method, rest, _body, ctx) {
     if (rest.length !== 1) {
       return { status: 405, body: { error: `method ${method} not supported on this path` } };
     }
-    if (!existsSync8(path)) return { status: 404, body: { error: `no such session: ${name}` } };
+    if (!existsSync9(path)) return { status: 404, body: { error: `no such session: ${name}` } };
     const messages = parseTranscript(path);
     return {
       status: 200,
@@ -2775,7 +3013,6 @@ async function handleSessions(method, rest, _body, ctx) {
 }
 
 // src/server/api/settings.ts
-import { appendFileSync } from "fs";
 function parseBody9(raw) {
   if (!raw) return {};
   try {
@@ -2785,8 +3022,6 @@ function parseBody9(raw) {
     return {};
   }
 }
-var VALID_PRESETS = /* @__PURE__ */ new Set(["auto", "flash", "pro", "fast", "smart", "max"]);
-var VALID_EFFORTS = /* @__PURE__ */ new Set(["high", "max"]);
 var VALID_WEB_SEARCH_ENGINES = /* @__PURE__ */ new Set([
   "bing",
   "searxng",
@@ -2795,19 +3030,7 @@ var VALID_WEB_SEARCH_ENGINES = /* @__PURE__ */ new Set([
   "perplexity",
   "exa"
 ]);
-function debugLogPresetWriteFromDashboard(preset) {
-  const debugPath = process.env.REASONIX_DEBUG_PRESET;
-  if (!debugPath) return;
-  try {
-    const stack = new Error("trace").stack ?? "";
-    const line = `${(/* @__PURE__ */ new Date()).toISOString()} dashboard PATCH /api/settings { preset: ${JSON.stringify(preset)} }
-${stack.split("\n").slice(1, 8).map((l) => `  ${l.trim()}`).join("\n")}
-
-`;
-    appendFileSync(debugPath, line);
-  } catch {
-  }
-}
+var VALID_EDIT_MODES = /* @__PURE__ */ new Set(["review", "auto", "yolo"]);
 async function handleSettings(method, _rest, body, ctx) {
   if (method === "GET") {
     const cfg = readConfig(ctx.configPath);
@@ -2823,14 +3046,12 @@ async function handleSettings(method, _rest, body, ctx) {
         apiKeySet: Boolean(cfg.apiKey),
         baseUrl: cfg.baseUrl ?? null,
         lang: getLanguage(),
-        preset: cfg.preset ?? "auto",
-        reasoningEffort: cfg.reasoningEffort ?? "max",
+        reasoningEffort: isReasoningEffort(cfg.reasoningEffort) ? cfg.reasoningEffort : "high",
         search: cfg.search !== false,
         webSearchEngine: webSearchEngine(ctx.configPath),
-        editMode: cfg.editMode ?? "review",
+        editMode: ctx.getEditMode?.() ?? cfg.editMode ?? "review",
         session: cfg.session ?? null,
-        model: live?.model ?? null,
-        proNext: live?.proArmed ?? false,
+        model: live?.model ?? cfg.model ?? DEFAULT_MODEL,
         budgetUsd: live?.budgetUsd ?? null,
         sessionSpendUsd: ctx.getStats?.()?.totalCostUsd ?? null,
         skillPaths: normalizeSkillPaths(
@@ -2841,18 +3062,17 @@ async function handleSettings(method, _rest, body, ctx) {
           cfg.skills?.paths ?? [],
           ctx.getCurrentCwd?.() ?? process.cwd()
         ),
-        // Hint to the SPA which fields require restart.
+        subagentModels: cfg.subagentModels ?? {},
         appliesAt: {
           apiKey: "next-session",
           baseUrl: "next-session",
-          preset: "next-session",
           reasoningEffort: "next-turn",
           search: "next-session",
           webSearchEngine: "next-turn",
           model: "next-turn",
-          proNext: "next-turn",
           budgetUsd: "live",
-          skillPaths: "next-session"
+          skillPaths: "next-session",
+          subagentModels: "next-skill-run"
         }
       }
     };
@@ -2862,7 +3082,6 @@ async function handleSettings(method, _rest, body, ctx) {
     const cfg = readConfig(ctx.configPath);
     const changed = [];
     let langPending = null;
-    let presetPendingLive = null;
     let effortPendingLive = null;
     if (fields.lang !== void 0) {
       const raw = String(fields.lang);
@@ -2890,21 +3109,23 @@ async function handleSettings(method, _rest, body, ctx) {
       cfg.baseUrl = trimmed.length > 0 ? trimmed : void 0;
       changed.push("baseUrl");
     }
-    if (fields.preset !== void 0) {
-      if (typeof fields.preset !== "string" || !VALID_PRESETS.has(fields.preset)) {
-        return { status: 400, body: { error: "preset must be auto | flash | pro" } };
+    if (fields.editMode !== void 0) {
+      if (typeof fields.editMode !== "string" || !VALID_EDIT_MODES.has(fields.editMode)) {
+        return { status: 400, body: { error: "editMode must be review | auto | yolo" } };
       }
-      debugLogPresetWriteFromDashboard(fields.preset);
-      cfg.preset = fields.preset;
-      presetPendingLive = fields.preset;
-      changed.push("preset");
+      cfg.editMode = fields.editMode;
+      changed.push("editMode");
     }
     if (fields.reasoningEffort !== void 0) {
-      if (typeof fields.reasoningEffort !== "string" || !VALID_EFFORTS.has(fields.reasoningEffort)) {
-        return { status: 400, body: { error: "reasoningEffort must be high | max" } };
+      const raw = typeof fields.reasoningEffort === "string" ? fields.reasoningEffort.toLowerCase() : "";
+      if (!isReasoningEffort(raw)) {
+        return {
+          status: 400,
+          body: { error: `reasoningEffort must be one of: ${REASONING_EFFORT_VALUES.join(" | ")}` }
+        };
       }
-      cfg.reasoningEffort = fields.reasoningEffort;
-      effortPendingLive = fields.reasoningEffort;
+      cfg.reasoningEffort = raw;
+      effortPendingLive = raw;
       changed.push("reasoningEffort");
     }
     if (fields.search !== void 0) {
@@ -2927,22 +3148,16 @@ async function handleSettings(method, _rest, body, ctx) {
       changed.push("webSearchEngine");
     }
     let modelPendingLive = null;
-    let proNextPending = null;
     let budgetPending;
     if (fields.model !== void 0) {
       if (typeof fields.model !== "string" || !fields.model.trim()) {
         return { status: 400, body: { error: "model must be a non-empty string" } };
       }
-      modelPendingLive = fields.model.trim();
+      const trimmed = fields.model.trim();
+      cfg.model = trimmed;
+      modelPendingLive = trimmed;
       changed.push("model");
     }
-    if (fields.proNext !== void 0) {
-      if (typeof fields.proNext !== "boolean") {
-        return { status: 400, body: { error: "proNext must be a boolean" } };
-      }
-      proNextPending = fields.proNext;
-      changed.push("proNext");
-    }
     if (fields.budgetUsd !== void 0) {
       if (fields.budgetUsd === null) {
         budgetPending = null;
@@ -2967,13 +3182,32 @@ async function handleSettings(method, _rest, body, ctx) {
       };
       changed.push("skillPaths");
     }
+    if (fields.subagentModels !== void 0) {
+      if (typeof fields.subagentModels !== "object" || fields.subagentModels === null || Array.isArray(fields.subagentModels)) {
+        return {
+          status: 400,
+          body: { error: "subagentModels must be an object mapping skill name \u2192 'flash' | 'pro'" }
+        };
+      }
+      const sanitized = /* @__PURE__ */ new Map();
+      for (const [name, value] of Object.entries(fields.subagentModels)) {
+        if (typeof name !== "string" || !name) continue;
+        if (name === "__proto__" || name === "constructor" || name === "prototype") continue;
+        if (value === "flash" || value === "pro") sanitized.set(name, value);
+      }
+      cfg.subagentModels = sanitized.size > 0 ? Object.fromEntries(sanitized) : void 0;
+      changed.push("subagentModels");
+    }
     if (changed.length > 0) {
       writeConfig(cfg, ctx.configPath);
       if (langPending) setLanguage(langPending);
-      if (presetPendingLive) ctx.applyPresetLive?.(presetPendingLive);
+      if (fields.editMode !== void 0) {
+        const mode = fields.editMode;
+        if (ctx.setEditMode) ctx.setEditMode(mode);
+        else saveEditMode(mode, ctx.configPath);
+      }
       if (effortPendingLive) ctx.applyEffortLive?.(effortPendingLive);
       if (modelPendingLive) ctx.applyModelLive?.(modelPendingLive);
-      if (proNextPending !== null) ctx.setProNextLive?.(proNextPending);
       if (budgetPending !== void 0) ctx.setBudgetUsdLive?.(budgetPending);
       ctx.audit?.({ ts: Date.now(), action: "set-settings", payload: { fields: changed } });
     }
@@ -2985,19 +3219,19 @@ async function handleSettings(method, _rest, body, ctx) {
 // src/server/api/skills.ts
 import {
   closeSync as closeSync4,
-  existsSync as existsSync9,
+  existsSync as existsSync10,
   fstatSync as fstatSync4,
   mkdirSync as mkdirSync3,
   openSync as openSync4,
   readFileSync as readFileSync6,
   readSync as readSync4,
-  readdirSync as readdirSync5,
+  readdirSync as readdirSync6,
   rmSync,
-  statSync as statSync5,
+  statSync as statSync6,
   writeFileSync as writeFileSync3
 } from "fs";
-import { homedir as homedir3 } from "os";
-import { dirname as dirname4, join as join8 } from "path";
+import { homedir as homedir4 } from "os";
+import { dirname as dirname5, join as join8 } from "path";
 function parseBody10(raw) {
   if (!raw) return {};
   try {
@@ -3009,7 +3243,7 @@ function parseBody10(raw) {
 }
 var SAFE_NAME2 = /^[a-zA-Z0-9][a-zA-Z0-9._-]{0,63}$/;
 function globalSkillsDir() {
-  return join8(homedir3(), ".reasonix", SKILLS_DIRNAME);
+  return join8(homedir4(), ".reasonix", SKILLS_DIRNAME);
 }
 function projectSkillsDir(rootDir) {
   return join8(rootDir, ".reasonix", SKILLS_DIRNAME);
@@ -3054,12 +3288,12 @@ function readSkillListEntry(skillPath, name, scope) {
 function resolveSkillPath(dir, name) {
   const folderPath = join8(dir, name, SKILL_FILE);
   try {
-    if (statSync5(folderPath).isFile()) return { path: folderPath, layout: "folder" };
+    if (statSync6(folderPath).isFile()) return { path: folderPath, layout: "folder" };
   } catch {
   }
   const flatPath = join8(dir, `${name}.md`);
   try {
-    if (statSync5(flatPath).isFile()) return { path: flatPath, layout: "flat" };
+    if (statSync6(flatPath).isFile()) return { path: flatPath, layout: "flat" };
   } catch {
   }
   return null;
@@ -3068,10 +3302,10 @@ function defaultSkillPath(dir, name) {
   return { path: join8(dir, name, SKILL_FILE), layout: "folder" };
 }
 function listSkills(dir, scope) {
-  if (!existsSync9(dir)) return [];
+  if (!existsSync10(dir)) return [];
   const out = [];
   try {
-    for (const entry of readdirSync5(dir, { withFileTypes: true })) {
+    for (const entry of readdirSync6(dir, { withFileTypes: true })) {
       let name;
       let skillPath;
       if (entry.isDirectory()) {
@@ -3110,7 +3344,8 @@ async function handleSkills(method, rest, body, ctx) {
     const tag = (rows) => rows.map((r) => ({ ...r, runs7d: runs7d.get(r.name) ?? 0 }));
     const store = new SkillStore({
       projectRoot: cwd,
-      customSkillPaths: loadResolvedSkillPaths(cwd ?? process.cwd(), ctx.configPath)
+      customSkillPaths: loadResolvedSkillPaths(cwd ?? process.cwd(), ctx.configPath),
+      subagentModels: loadSubagentModels(ctx.configPath)
     });
     const customRoots = store.customRoots();
     return {
@@ -3182,7 +3417,7 @@ async function handleSkills(method, rest, body, ctx) {
       return { status: 400, body: { error: fm.error } };
     }
     const target = resolved ?? defaultSkillPath(dir, name);
-    mkdirSync3(dirname4(target.path), { recursive: true });
+    mkdirSync3(dirname5(target.path), { recursive: true });
     writeFileSync3(target.path, contents, "utf8");
     ctx.audit?.({
       ts: Date.now(),
@@ -3193,7 +3428,7 @@ async function handleSkills(method, rest, body, ctx) {
   }
   if (method === "DELETE") {
     if (!resolved) return { status: 404, body: { error: "skill not found" } };
-    rmSync(resolved.layout === "folder" ? dirname4(resolved.path) : resolved.path, {
+    rmSync(resolved.layout === "folder" ? dirname5(resolved.path) : resolved.path, {
       recursive: true,
       force: true
     });
@@ -3404,6 +3639,8 @@ async function handleApi(pathTail, method, body, ctx, query = new URLSearchParam
         return await handleSlash(method, rest, body, ctx);
       case "files":
         return await handleFiles(method, rest, body, ctx);
+      case "browse":
+        return await handleBrowse(method, rest, body, ctx, query);
       case "project-tree":
         return await handleProjectTree(method, rest, body, ctx);
       case "git-diffs":
@@ -3477,7 +3714,7 @@ var MAX_BODY_BYTES = 256 * 1024;
 async function readBody(req) {
   let total = 0;
   const chunks = [];
-  return new Promise((resolve3, reject) => {
+  return new Promise((resolve4, reject) => {
     req.on("data", (chunk) => {
       total += chunk.length;
       if (total > MAX_BODY_BYTES) {
@@ -3487,7 +3724,7 @@ async function readBody(req) {
       }
       chunks.push(chunk);
     });
-    req.on("end", () => resolve3(Buffer.concat(chunks).toString("utf8")));
+    req.on("end", () => resolve4(Buffer.concat(chunks).toString("utf8")));
     req.on("error", reject);
   });
 }
@@ -3515,7 +3752,7 @@ async function dispatch(req, res, ctx, expectedToken) {
       res.end();
       return;
     }
-    const asset = serveAsset(path.slice("/assets/".length));
+    const asset = serveAsset(path.slice("/assets/".length), expectedToken);
     if (!asset) {
       res.writeHead(404);
       res.end("not found");
@@ -3564,9 +3801,10 @@ function startDashboardServer(ctx, opts = {}) {
   const token = opts.token ?? mintToken();
   const host = opts.host ?? "127.0.0.1";
   const port = opts.port ?? 0;
-  return new Promise((resolve3, reject) => {
+  const ctxRef = { current: ctx };
+  return new Promise((resolve4, reject) => {
     const server = createServer((req, res) => {
-      dispatch(req, res, ctx, token).catch((err) => {
+      dispatch(req, res, ctxRef.current, token).catch((err) => {
         if (!res.headersSent) {
           res.writeHead(500, { "content-type": "application/json" });
         }
@@ -3591,7 +3829,10 @@ function startDashboardServer(ctx, opts = {}) {
         server.close(() => doneResolve());
         setTimeout(() => server.closeAllConnections?.(), 1e3).unref();
       });
-      resolve3({ url, token, port: finalPort, close });
+      const updateContext = (next) => {
+        ctxRef.current = next;
+      };
+      resolve4({ url, token, port: finalPort, close, updateContext });
     });
   });
 }
@@ -3602,4 +3843,4 @@ export {
   readBody,
   startDashboardServer
 };
-//# sourceMappingURL=server-Z3IMJNNI.js.map
+//# sourceMappingURL=server-SZZDKTH2.js.map