agenter 0.0.4 → 0.0.5

package/dist/agenter.js

@@ -138181,151 +138181,14 @@ var init_recording = () => {};
 var init_warnings = () => {};
 
 // node_modules/.bun/@termless+core@0.6.0/node_modules/@termless/core/src/backends.ts
-import { readFileSync as readFileSync11, existsSync as existsSync9, readdirSync as readdirSync4, mkdirSync as mkdirSync8, writeFileSync as writeFileSync5 } from "fs";
 import { dirname as dirname12, join as join17 } from "path";
 import { homedir as homedir6 } from "os";
 import { fileURLToPath as fileURLToPath5 } from "url";
-import { execSync } from "child_process";
-function manifest() {
-  if (_manifest)
-    return _manifest;
-  const raw2 = JSON.parse(readFileSync11(MANIFEST_PATH, "utf-8"));
-  const backends = {};
-  for (const [name2, entry] of Object.entries(raw2.backends)) {
-    backends[name2] = {
-      package: entry.package,
-      upstream: entry.upstream ?? null,
-      version: entry.upstreamVersion ?? null,
-      type: entry.type,
-      default: entry.default,
-      platforms: entry.platforms,
-      label: entry.label,
-      description: entry.description,
-      url: entry.url,
-      caveat: entry.caveat,
-      slug: entry.slug,
-      terminal: entry.terminal
-    };
-  }
-  _manifest = { version: raw2.version, backends };
-  return _manifest;
-}
-function hasFilesWithExt(dir, ext, subdirs = []) {
-  const dirs = [dir, ...subdirs.map((s) => join17(dir, s))];
-  for (const d of dirs) {
-    if (!existsSync9(d))
-      continue;
-    try {
-      for (const f of readdirSync4(d)) {
-        if (f.endsWith(ext))
-          return true;
-      }
-    } catch {}
-  }
-  return false;
-}
-function resolveModule(pkg, opts) {
-  return async () => {
-    const mod2 = await import(pkg);
-    return typeof mod2.resolve === "function" ? mod2.resolve(opts) : mod2[Object.keys(mod2).find((k) => k.startsWith("create"))](opts);
-  };
-}
-function runBuildScript(pkgDir) {
-  const buildScript = join17(pkgDir, "build", "build.sh");
-  if (!existsSync9(buildScript))
-    return;
-  console.log(`  Building in ${pkgDir}...`);
-  try {
-    execSync(`bash build/build.sh`, { cwd: pkgDir, stdio: "inherit" });
-  } catch {
-    const flakeDir = join17(__dirname3, "..");
-    if (existsSync9(join17(flakeDir, "flake.nix"))) {
-      execSync(`nix develop ${flakeDir} --command bash build/build.sh`, { cwd: pkgDir, stdio: "inherit" });
-    } else {
-      throw new Error(`Build failed. Install dependencies or use the nix flake: nix develop`);
-    }
-  }
-}
-function buildBackend(name2) {
-  const m = manifest();
-  const e = m.backends[name2];
-  if (!e)
-    throw new Error(`Unknown backend: ${name2}`);
-  const type = backendTypes[e.type];
-  if (!type)
-    return;
-  const pkgDir = findPackageDir(e.package);
-  if (!pkgDir)
-    return;
-  if (!type.isReady(pkgDir)) {
-    type.build(pkgDir);
-  }
-}
-function isReady(name2) {
-  const m = manifest();
-  const entry = m.backends[name2];
-  if (!entry)
-    return false;
-  try {
-    import.meta.resolve(entry.package);
-  } catch {
-    return false;
-  }
-  const type = backendTypes[entry.type];
-  if (!type)
-    return false;
-  const pkgDir = findPackageDir(entry.package);
-  return pkgDir ? type.isReady(pkgDir) : false;
-}
-function findPackageDir(packageName) {
-  try {
-    const resolved = fileURLToPath5(import.meta.resolve(packageName));
-    let dir = dirname12(resolved);
-    for (let i = 0;i < 10; i++) {
-      if (existsSync9(join17(dir, "package.json"))) {
-        try {
-          const pkg = JSON.parse(readFileSync11(join17(dir, "package.json"), "utf-8"));
-          if (pkg.name === packageName)
-            return dir;
-        } catch {}
-      }
-      const parent = dirname12(dir);
-      if (parent === dir)
-        break;
-      dir = parent;
-    }
-  } catch {}
-  return null;
-}
-var __dirname3, MANIFEST_PATH, _manifest = null, backendTypes, CACHE_DIR;
+var __dirname3, MANIFEST_PATH, CACHE_DIR;
 var init_backends = __esm(() => {
   init_terminal();
   __dirname3 = dirname12(fileURLToPath5(import.meta.url));
   MANIFEST_PATH = join17(__dirname3, "..", "backends.json");
-  backendTypes = {
-    js: {
-      isReady: () => true,
-      build: () => {},
-      resolve: async (pkg, opts) => resolveModule(pkg, opts)()
-    },
-    wasm: {
-      isReady: (pkgDir) => {
-        return hasFilesWithExt(pkgDir, ".wasm", ["wasm", "build"]) || !existsSync9(join17(pkgDir, "build"));
-      },
-      build: (pkgDir) => runBuildScript(pkgDir),
-      resolve: async (pkg, opts) => resolveModule(pkg, opts)()
-    },
-    native: {
-      isReady: (pkgDir) => hasFilesWithExt(pkgDir, ".node", ["build", "native"]),
-      build: (pkgDir) => runBuildScript(pkgDir),
-      resolve: async (pkg, opts) => resolveModule(pkg, opts)()
-    },
-    os: {
-      isReady: () => true,
-      build: () => {},
-      resolve: async (pkg, opts) => resolveModule(pkg, opts)()
-    }
-  };
   CACHE_DIR = join17(process.env.XDG_CACHE_HOME ?? join17(homedir6(), ".cache"), "termless", "backends");
 });
 
@@ -142603,10 +142466,10 @@ var init_termless_xtermjs = __esm(() => {
 
 // packages/termless-core/src/backend-factory.ts
 import { execFileSync } from "child_process";
-import { existsSync as existsSync10, readFileSync as readFileSync12 } from "fs";
+import { existsSync as existsSync9, readFileSync as readFileSync11 } from "fs";
 import { createRequire as createRequire2 } from "module";
 import { dirname as dirname13, join as join18 } from "path";
-var TERMINAL_BACKEND_KINDS, DEFAULT_TERMINAL_BACKEND = "xterm", isTerminalBackendKind = (value) => typeof value === "string" && TERMINAL_BACKEND_KINDS.includes(value), toOfficialBackendName = (backend2) => backend2 === "xterm" ? "xtermjs" : "ghostty-native", require2, loadGhosttyNativeModule = () => {
+var TERMINAL_BACKEND_KINDS, DEFAULT_TERMINAL_BACKEND = "xterm", isTerminalBackendKind = (value) => typeof value === "string" && TERMINAL_BACKEND_KINDS.includes(value), require2, loadGhosttyNativeModule = () => {
   return require2("@jixo/ghostty-native");
 }, resolveInstalledPackageRoot = (packageName) => {
   try {
@@ -142614,9 +142477,9 @@ var TERMINAL_BACKEND_KINDS, DEFAULT_TERMINAL_BACKEND = "xterm", isTerminalBacken
     let dir = dirname13(resolvedEntry);
     for (let depth = 0;depth < 10; depth += 1) {
       const packageJsonPath = join18(dir, "package.json");
-      if (existsSync10(packageJsonPath)) {
+      if (existsSync9(packageJsonPath)) {
         try {
-          const pkg = JSON.parse(readFileSync12(packageJsonPath, "utf8"));
+          const pkg = JSON.parse(readFileSync11(packageJsonPath, "utf8"));
           if (pkg.name === packageName) {
             return dir;
           }
@@ -142632,30 +142495,31 @@ var TERMINAL_BACKEND_KINDS, DEFAULT_TERMINAL_BACKEND = "xterm", isTerminalBacken
     return null;
   }
   return null;
-}, hasGhosttyNativeArtifact = (packageRoot) => existsSync10(join18(packageRoot, "termless-ghostty-native.node")) || existsSync10(join18(packageRoot, "native", "zig-out", "lib", "termless-ghostty-native.node")), ensureGhosttyNativeWorkspaceBuild = () => {
+}, hasGhosttyNativeArtifact = (packageRoot) => existsSync9(join18(packageRoot, "termless-ghostty-native.node")), ensureGhosttyNativeReady = () => {
   const packageRoot = resolveInstalledPackageRoot("@jixo/ghostty-native");
-  if (!packageRoot || hasGhosttyNativeArtifact(packageRoot)) {
+  if (!packageRoot) {
     return;
   }
-  const buildScript = join18(packageRoot, "build", "build.sh");
-  if (!existsSync10(buildScript)) {
+  if (hasGhosttyNativeArtifact(packageRoot)) {
     return;
   }
-  execFileSync("bash", [buildScript], {
-    cwd: packageRoot,
-    stdio: "inherit"
-  });
-}, ensureOfficialBackendReady = (backend2) => {
-  const officialBackendName = toOfficialBackendName(backend2);
-  if (!isReady(officialBackendName)) {
-    buildBackend(officialBackendName);
+  const buildScript = join18(packageRoot, "build", "build.sh");
+  if (existsSync9(buildScript)) {
+    execFileSync("bash", [buildScript], {
+      cwd: packageRoot,
+      stdio: "inherit"
+    });
+  }
+  if (!hasGhosttyNativeArtifact(packageRoot)) {
+    throw new Error(`ghostty-native artifact is missing in ${packageRoot}`);
   }
+}, ensureTerminalBackendReady = (backend2) => {
   if (backend2 === "ghostty-native") {
-    ensureGhosttyNativeWorkspaceBuild();
+    ensureGhosttyNativeReady();
   }
 }, createOfficialTerminalBackend = (backend2, input) => {
   try {
-    ensureOfficialBackendReady(backend2);
+    ensureTerminalBackendReady(backend2);
     if (backend2 === "xterm") {
       return createXtermBackend2({
         cols: input.cols,
@@ -142700,7 +142564,6 @@ var TERMINAL_BACKEND_KINDS, DEFAULT_TERMINAL_BACKEND = "xterm", isTerminalBacken
   }
 };
 var init_backend_factory = __esm(() => {
-  init_src16();
   init_termless_xtermjs();
   TERMINAL_BACKEND_KINDS = ["xterm", "ghostty-native"];
   require2 = createRequire2(import.meta.url);
@@ -143231,7 +143094,7 @@ class Committer {
 }
 
 // packages/terminal-system/src/git-log.ts
-import { appendFileSync, existsSync as existsSync11, mkdirSync as mkdirSync9 } from "fs";
+import { appendFileSync, existsSync as existsSync10, mkdirSync as mkdirSync8 } from "fs";
 import { join as join19 } from "path";
 
 class TerminalGitLogger {
@@ -143245,7 +143108,7 @@ class TerminalGitLogger {
     this.workspace = workspace;
     this.mode = mode;
     const debugDir = join19(workspace, "debug");
-    mkdirSync9(debugDir, { recursive: true });
+    mkdirSync8(debugDir, { recursive: true });
     this.debugPath = join19(debugDir, "git-log.ndjson");
     this.env = {
       ...Object.fromEntries(Object.entries(process.env).filter((entry2) => typeof entry2[1] === "string")),
@@ -143264,7 +143127,7 @@ class TerminalGitLogger {
     }
     this.queue = this.queue.then(async () => {
       const gitDir = join19(this.workspace, ".git");
-      if (!existsSync11(gitDir)) {
+      if (!existsSync10(gitDir)) {
         const initResult = this.runGit(["init", "-q"]);
         this.logDebug("git.init", {
           ok: initResult.ok,
@@ -143371,7 +143234,7 @@ var decodeText = (data) => {
 var init_git_log = () => {};
 
 // packages/terminal-system/src/input-inbox.ts
-import { mkdirSync as mkdirSync10, readdirSync as readdirSync5, readFileSync as readFileSync13, renameSync, watch } from "fs";
+import { mkdirSync as mkdirSync9, readdirSync as readdirSync4, readFileSync as readFileSync12, renameSync, watch } from "fs";
 import { join as join20 } from "path";
 
 class InputInbox {
@@ -143392,9 +143255,9 @@ class InputInbox {
     this.doneDir = join20(options.inputDir, "done");
     this.failedDir = join20(options.inputDir, "failed");
     this.pollMs = options.pollMs ?? 120;
-    mkdirSync10(this.pendingDir, { recursive: true });
-    mkdirSync10(this.doneDir, { recursive: true });
-    mkdirSync10(this.failedDir, { recursive: true });
+    mkdirSync9(this.pendingDir, { recursive: true });
+    mkdirSync9(this.doneDir, { recursive: true });
+    mkdirSync9(this.failedDir, { recursive: true });
   }
   start() {
     if (this.running) {
@@ -143442,7 +143305,7 @@ class InputInbox {
     }
     const files = (() => {
       try {
-        return readdirSync5(this.pendingDir).filter(isInputFile).sort();
+        return readdirSync4(this.pendingDir).filter(isInputFile).sort();
       } catch (cause) {
         const error53 = cause;
         if (error53?.code === "ENOENT") {
@@ -143466,7 +143329,7 @@ class InputInbox {
           if (!mode) {
             throw new Error(`unsupported pending input suffix: ${name2}`);
           }
-          const raw2 = readFileSync13(src, "utf8");
+          const raw2 = readFileSync12(src, "utf8");
           await this.options.onInput(raw2, name2, mode);
           renameSync(src, join20(this.doneDir, `${name2}.done`));
         } catch (cause) {
@@ -143676,13 +143539,13 @@ var init_input_parser = __esm(() => {
 // packages/terminal-system/src/pagination.ts
 import {
   appendFileSync as appendFileSync2,
-  existsSync as existsSync12,
-  mkdirSync as mkdirSync11,
-  readFileSync as readFileSync14,
-  readdirSync as readdirSync6,
+  existsSync as existsSync11,
+  mkdirSync as mkdirSync10,
+  readFileSync as readFileSync13,
+  readdirSync as readdirSync5,
   renameSync as renameSync2,
   rmSync as rmSync3,
-  writeFileSync as writeFileSync6
+  writeFileSync as writeFileSync5
 } from "fs";
 import { dirname as dirname14, join as join21 } from "path";
 
@@ -143699,9 +143562,9 @@ class HtmlPaginationStore {
   constructor(workspace, maxLinesPerFile) {
     this.workspace = workspace;
     this.maxLinesPerFile = maxLinesPerFile;
-    mkdirSync11(this.workspace, { recursive: true });
+    mkdirSync10(this.workspace, { recursive: true });
     this.outputDir = join21(this.workspace, "output");
-    mkdirSync11(this.outputDir, { recursive: true });
+    mkdirSync10(this.outputDir, { recursive: true });
     this.latestPath = join21(this.outputDir, "latest.log.html");
     const state = this.restoreState();
     this.latestStartLine = state.latestStartLine;
@@ -143765,7 +143628,7 @@ class HtmlPaginationStore {
     this.lastLoggedAbsoluteY = Math.max(this.lastLoggedAbsoluteY, total);
   }
   sealForResize(currentTotalLines, seed) {
-    if (!existsSync12(this.latestPath)) {
+    if (!existsSync11(this.latestPath)) {
       return null;
     }
     const endLine = Math.max(this.latestStartLine, currentTotalLines);
@@ -143777,7 +143640,7 @@ class HtmlPaginationStore {
     };
     appendResizeSplitFooter(this.latestPath, splitMeta);
     const archivePath = join21(this.outputDir, archiveName);
-    if (existsSync12(archivePath)) {
+    if (existsSync11(archivePath)) {
       rmSync3(archivePath, { force: true });
     }
     renameSync2(this.latestPath, archivePath);
@@ -143870,7 +143733,7 @@ class HtmlPaginationStore {
     const lastArchive = latestArchive(this.outputDir);
     let latestStartLine = (lastArchive?.end ?? 0) + 1;
     let lastLoggedAbsoluteY = lastArchive?.end ?? 0;
-    if (!existsSync12(this.latestPath)) {
+    if (!existsSync11(this.latestPath)) {
       return {
         latestStartLine: Math.max(1, latestStartLine),
         archiveChain: chain,
@@ -143897,7 +143760,7 @@ class HtmlPaginationStore {
     const latestEnd = latestStart + latestLines.length - 1;
     const archivedName = `${latestStart}~${latestEnd}.log.html`;
     const archivedPath = join21(this.outputDir, archivedName);
-    if (!existsSync12(archivedPath)) {
+    if (!existsSync11(archivedPath)) {
       renameSync2(this.latestPath, archivedPath);
     } else {
       rmSync3(this.latestPath, { force: true });
@@ -143946,7 +143809,7 @@ var ARCHIVE_FILE, META_PRE_FILE, LEGACY_META_PRE_FILE, toLineNumber = (value) =>
     return null;
   }
   return { name: name2, start, end };
-}, listArchives = (dir) => readdirSync6(dir).map((name2) => parseArchiveName(name2)).filter((item) => item !== null).sort((a, b) => a.start - b.start), latestArchive = (dir) => {
+}, listArchives = (dir) => readdirSync5(dir).map((name2) => parseArchiveName(name2)).filter((item) => item !== null).sort((a, b) => a.start - b.start), latestArchive = (dir) => {
   const items = listArchives(dir);
   if (items.length === 0) {
     return null;
@@ -143968,10 +143831,10 @@ var ARCHIVE_FILE, META_PRE_FILE, LEGACY_META_PRE_FILE, toLineNumber = (value) =>
   }
   return trim3.slice(marker + 3);
 }, readBodyLines = (filePath) => {
-  if (!existsSync12(filePath)) {
+  if (!existsSync11(filePath)) {
     return [];
   }
-  const raw2 = readFileSync14(filePath, "utf8");
+  const raw2 = readFileSync13(filePath, "utf8");
   const withoutMeta = stripLeadingMetaComment(raw2);
   const withoutSource = stripSourceComments(withoutMeta);
   const withoutResizeFooter = stripResizeFooterComments(withoutSource);
@@ -143982,10 +143845,10 @@ var ARCHIVE_FILE, META_PRE_FILE, LEGACY_META_PRE_FILE, toLineNumber = (value) =>
   }
   return lines;
 }, parsePreFileFromLatest = (latestPath) => {
-  if (!existsSync12(latestPath)) {
+  if (!existsSync11(latestPath)) {
     return null;
   }
-  const raw2 = readFileSync14(latestPath, "utf8");
+  const raw2 = readFileSync13(latestPath, "utf8");
   const match2 = META_PRE_FILE.exec(raw2) ?? LEGACY_META_PRE_FILE.exec(raw2);
   if (!match2) {
     return null;
@@ -144042,11 +143905,11 @@ ${buildSourceYaml(source, false)}`;
   return `${head}
 ${joinHtmlLines(lines)}`;
 }, writeArchiveFile = (filePath, meta3, source, lines, splitMeta) => {
-  mkdirSync11(dirname14(filePath), { recursive: true });
-  writeFileSync6(filePath, buildArchiveContent(meta3, source, lines, splitMeta), "utf8");
+  mkdirSync10(dirname14(filePath), { recursive: true });
+  writeFileSync5(filePath, buildArchiveContent(meta3, source, lines, splitMeta), "utf8");
 }, writeLatestFile = (filePath, meta3, source, lines, eventTag) => {
-  mkdirSync11(dirname14(filePath), { recursive: true });
-  writeFileSync6(filePath, buildLatestContent(meta3, source, lines, eventTag), "utf8");
+  mkdirSync10(dirname14(filePath), { recursive: true });
+  writeFileSync5(filePath, buildLatestContent(meta3, source, lines, eventTag), "utf8");
 }, appendResizeSplitFooter = (filePath, splitMeta) => {
   const footer = [
     "<!--",
@@ -144067,7 +143930,7 @@ var init_pagination3 = __esm(() => {
 });
 
 // packages/terminal-system/src/pty.ts
-import { mkdirSync as mkdirSync12 } from "fs";
+import { mkdirSync as mkdirSync11 } from "fs";
 
 class Pty {
   command;
@@ -144102,7 +143965,7 @@ class Pty {
       const env3 = createEnv(this.color, this.env);
       const command2 = resolveCommand(this.command, env3);
       if (this.cwd && this.cwd.length > 0) {
-        mkdirSync12(this.cwd, { recursive: true });
+        mkdirSync11(this.cwd, { recursive: true });
       }
       this.proc = Bun.spawn([command2, ...this.args], {
         cwd: this.cwd,
@@ -144438,14 +144301,14 @@ var init_types9 = __esm(() => {
 });
 
 // packages/terminal-system/src/workspace.ts
-import { existsSync as existsSync13, mkdirSync as mkdirSync13, readdirSync as readdirSync7, rmSync as rmSync4, statSync as statSync3 } from "fs";
+import { existsSync as existsSync12, mkdirSync as mkdirSync12, readdirSync as readdirSync6, rmSync as rmSync4, statSync as statSync3 } from "fs";
 import { tmpdir } from "os";
 import { isAbsolute as isAbsolute2, join as join22, resolve as resolve17 } from "path";
 function createWorkspace(options) {
   const rootDir3 = resolveOutputRoot(options?.outputRoot);
-  mkdirSync13(rootDir3, { recursive: true });
+  mkdirSync12(rootDir3, { recursive: true });
   if (options?.workspacePath) {
-    if (!existsSync13(options.workspacePath)) {
+    if (!existsSync12(options.workspacePath)) {
       throw new Error(`Workspace does not exist: ${options.workspacePath}`);
     }
     return options.workspacePath;
@@ -144458,14 +144321,14 @@ function createWorkspace(options) {
     return found;
   }
   const dir = createUtcWorkspacePath(rootDir3, process.pid);
-  mkdirSync13(dir, { recursive: true });
+  mkdirSync12(dir, { recursive: true });
   return dir;
 }
 function destroyWorkspace(workspace, keepLogs) {
   if (keepLogs) {
     return;
   }
-  if (existsSync13(workspace)) {
+  if (existsSync12(workspace)) {
     rmSync4(workspace, { recursive: true, force: true });
   }
 }
@@ -144485,16 +144348,16 @@ var BASE_DIR, resolveOutputRoot = (outputRoot) => {
   const hour = pad22(now.getUTCHours());
   const minute = pad22(now.getUTCMinutes());
   const dayDir = join22(rootDir3, year, month, day);
-  mkdirSync13(dayDir, { recursive: true });
+  mkdirSync12(dayDir, { recursive: true });
   const baseName = `${hour}_${minute}-${pid}`;
   let candidate = join22(dayDir, baseName);
-  if (!existsSync13(candidate)) {
+  if (!existsSync12(candidate)) {
     return candidate;
   }
   for (let index2 = 1;index2 < 100; index2 += 1) {
     const suffix2 = pad22(index2);
     candidate = join22(dayDir, `${baseName}-${suffix2}`);
-    if (!existsSync13(candidate)) {
+    if (!existsSync12(candidate)) {
       return candidate;
     }
   }
@@ -144509,7 +144372,7 @@ var BASE_DIR, resolveOutputRoot = (outputRoot) => {
   const stack = [rootDir3];
   while (stack.length > 0) {
     const current = stack.pop();
-    const entries = readdirSync7(current, { withFileTypes: true });
+    const entries = readdirSync6(current, { withFileTypes: true });
     for (const entry2 of entries) {
       if (!entry2.isDirectory()) {
         continue;
@@ -144523,7 +144386,7 @@ var BASE_DIR, resolveOutputRoot = (outputRoot) => {
   }
   return out;
 }, findByPid = (rootDir3, pid) => {
-  if (!existsSync13(rootDir3)) {
+  if (!existsSync12(rootDir3)) {
     return null;
   }
   const candidates = collectWorkspaceCandidates(rootDir3, pid).sort((a, b) => {
@@ -144652,7 +144515,7 @@ var OSC_PREFIX = "\x1B]", OSC_TERMINATOR_BEL = "\x07", OSC_TERMINATOR_ST = "\x1B
 };
 
 // packages/terminal-system/src/agentic-terminal.ts
-import { appendFileSync as appendFileSync3, mkdirSync as mkdirSync14, writeFileSync as writeFileSync7 } from "fs";
+import { appendFileSync as appendFileSync3, mkdirSync as mkdirSync13, writeFileSync as writeFileSync6 } from "fs";
 import { join as join23 } from "path";
 
 class AgenticTerminal {
@@ -144741,8 +144604,8 @@ class AgenticTerminal {
     });
     const inputDir = join23(this.workspace, "input");
     const debugDir = join23(this.workspace, "debug");
-    mkdirSync14(inputDir, { recursive: true });
-    mkdirSync14(debugDir, { recursive: true });
+    mkdirSync13(inputDir, { recursive: true });
+    mkdirSync13(debugDir, { recursive: true });
     this.debugLogPath = join23(debugDir, "terminal.ndjson");
     this.debug("start", {
       command: this.command,
@@ -144880,7 +144743,7 @@ class AgenticTerminal {
     const failedFile = `${file2}.failed`;
     const donePath = join23(this.workspace, "input", "done", doneFile);
     const failedPath = join23(this.workspace, "input", "failed", failedFile);
-    writeFileSync7(pendingPath, input, "utf8");
+    writeFileSync6(pendingPath, input, "utf8");
     this.appendInputLog(input, `queue:${file2}`);
     this.debug("input.enqueue", { id, file: file2, mode });
     this.inbox?.poke();
@@ -145666,7 +145529,7 @@ class AgenticTerminal {
     }
     try {
       const debugDir = join23(this.workspace, "debug");
-      mkdirSync14(debugDir, { recursive: true });
+      mkdirSync13(debugDir, { recursive: true });
       appendFileSync3(this.debugLogPath, `${JSON.stringify({
         ts: new Date().toISOString(),
         source: "agentic-terminal",
@@ -145685,7 +145548,7 @@ class AgenticTerminal {
     const end = Math.min(render.plainLines.length - 1, row + 4);
     const context = render.plainLines.slice(start, end + 1);
     const logPath = join23(this.workspace, "output", "cursor-debug.ndjson");
-    mkdirSync14(join23(this.workspace, "output"), { recursive: true });
+    mkdirSync13(join23(this.workspace, "output"), { recursive: true });
     const record2 = {
       timestamp: new Date().toISOString(),
       seq: this.renderSerial,
@@ -145815,7 +145678,7 @@ var init_agentic_terminal = __esm(() => {
 });
 
 // packages/terminal-system/src/default-shell-command.ts
-import { existsSync as existsSync14 } from "fs";
+import { existsSync as existsSync13 } from "fs";
 import { delimiter, isAbsolute as isAbsolute3, join as join24 } from "path";
 var findExecutableOnPath = (command2) => {
   const pathValue = process.env.PATH;
@@ -145827,7 +145690,7 @@ var findExecutableOnPath = (command2) => {
       continue;
     }
     const candidate = join24(segment, command2);
-    if (existsSync14(candidate)) {
+    if (existsSync13(candidate)) {
       return candidate;
     }
   }
@@ -145838,7 +145701,7 @@ var findExecutableOnPath = (command2) => {
       continue;
     }
     if (isAbsolute3(candidate)) {
-      if (existsSync14(candidate)) {
+      if (existsSync13(candidate)) {
         return candidate;
       }
       continue;
@@ -150833,7 +150696,7 @@ var init_terminal_control_plane_types = __esm(() => {
 
 // packages/terminal-system/src/terminal-db.ts
 import { randomUUID as randomUUID6 } from "crypto";
-import { mkdirSync as mkdirSync15 } from "fs";
+import { mkdirSync as mkdirSync14 } from "fs";
 import { dirname as dirname15, resolve as resolve18 } from "path";
 import { Database as Database5 } from "bun:sqlite";
 
@@ -150842,7 +150705,7 @@ class TerminalDb {
   hasLegacyCwdColumn = false;
   constructor(filePath) {
     const fullPath = resolve18(filePath);
-    mkdirSync15(dirname15(fullPath), { recursive: true });
+    mkdirSync14(dirname15(fullPath), { recursive: true });
     this.db = new Database5(fullPath, { create: true, strict: true });
     this.migrate();
   }
@@ -156182,7 +156045,7 @@ var init_auth_draft_types = __esm(() => {
 
 // packages/app-server/src/auth-draft-store.ts
 import { randomUUID as randomUUID8 } from "crypto";
-import { mkdirSync as mkdirSync16 } from "fs";
+import { mkdirSync as mkdirSync15 } from "fs";
 import { homedir as homedir8 } from "os";
 import { dirname as dirname17, join as join26, resolve as resolve20 } from "path";
 import { Database as Database6 } from "bun:sqlite";
@@ -156192,7 +156055,7 @@ class AuthDraftStore {
   listeners = new Set;
   constructor(filePath = resolveAuthDraftDbPath()) {
     const fullPath = resolve20(filePath);
-    mkdirSync16(dirname17(fullPath), { recursive: true });
+    mkdirSync15(dirname17(fullPath), { recursive: true });
     this.db = new Database6(fullPath, { create: true, strict: true });
     this.migrate();
   }
@@ -156599,7 +156462,7 @@ var init_auth_kv_types = __esm(() => {
 });
 
 // packages/app-server/src/auth-kv-store.ts
-import { mkdirSync as mkdirSync17 } from "fs";
+import { mkdirSync as mkdirSync16 } from "fs";
 import { homedir as homedir9 } from "os";
 import { dirname as dirname18, join as join27, resolve as resolve21 } from "path";
 import { Database as Database7 } from "bun:sqlite";
@@ -156609,7 +156472,7 @@ class AuthKvStore {
   listeners = new Set;
   constructor(filePath = resolveAuthKvDbPath()) {
     const fullPath = resolve21(filePath);
-    mkdirSync17(dirname18(fullPath), { recursive: true });
+    mkdirSync16(dirname18(fullPath), { recursive: true });
     this.db = new Database7(fullPath, { create: true, strict: true });
     this.migrate();
   }
@@ -156852,7 +156715,7 @@ var init_auth_kv_store = __esm(() => {
 });
 
 // packages/app-server/src/auth-service-bridge-impl.ts
-import { existsSync as existsSync15 } from "fs";
+import { existsSync as existsSync14 } from "fs";
 import { join as join28 } from "path";
 import { suffix as suffix2 } from "bun:ffi";
 
@@ -157285,7 +157148,7 @@ var toOwnedArrayBuffer2 = (bytes) => new Uint8Array(bytes).buffer, jsonHeaders,
     return;
   }
   const path4 = join28(root, ...segments);
-  return existsSync15(path4) ? path4 : undefined;
+  return existsSync14(path4) ? path4 : undefined;
 }, withBearerToken = (token, headers = {}) => token ? { ...headers, authorization: `Bearer ${token}` } : headers, withTrailingSlashTrimmed = (value) => value.replace(/\/$/, ""), toExternalLikeAuthDescriptor = (descriptor) => ({
   ...descriptor,
   rootAuthBootstrapMode: "external",
@@ -218510,7 +218373,7 @@ var require_sql_wasm = __commonJS((exports, module) => {
     if (initSqlJsPromise) {
       return initSqlJsPromise;
     }
-    initSqlJsPromise = new Promise(function(resolveModule2, reject) {
+    initSqlJsPromise = new Promise(function(resolveModule, reject) {
       var Module = typeof moduleConfig !== "undefined" ? moduleConfig : {};
       var originalOnAbortFunction = Module["onAbort"];
       Module["onAbort"] = function(errorThatCausedAbort) {
@@ -218521,7 +218384,7 @@ var require_sql_wasm = __commonJS((exports, module) => {
       };
       Module["postRun"] = Module["postRun"] || [];
       Module["postRun"].push(function() {
-        resolveModule2(Module);
+        resolveModule(Module);
       });
       module = undefined;
       var k16;
@@ -233746,11 +233609,11 @@ var GLOBAL_WORKSPACE_PATH = "~/", normalizeGlobalToken = (value) => {
 var init_workspace_target = () => {};
 
 // packages/app-server/src/workspace-system/paths.ts
-import { existsSync as existsSync17, realpathSync as realpathSync5 } from "fs";
+import { existsSync as existsSync16, realpathSync as realpathSync5 } from "fs";
 import { homedir as homedir11 } from "os";
 import { join as join34 } from "path";
 var normalizeWorkspaceAssetKind = (value) => value, resolveAliasTargetOrSelf2 = (path6) => {
-  if (!existsSync17(path6)) {
+  if (!existsSync16(path6)) {
     return path6;
   }
   try {
@@ -233789,7 +233652,7 @@ var init_paths = __esm(() => {
 });
 
 // packages/app-server/src/workspace-system/tool-bindings.ts
-import { accessSync, existsSync as existsSync18, constants as fsConstants, readdirSync as readdirSync10, readFileSync as readFileSync15, statSync as statSync5 } from "fs";
+import { accessSync, existsSync as existsSync17, constants as fsConstants, readdirSync as readdirSync9, readFileSync as readFileSync14, statSync as statSync5 } from "fs";
 import { join as join35, resolve as resolve28 } from "path";
 var WORKSPACE_TOOL_HELP_METADATA_SUFFIX = ".cli.json", workspaceToolHelpcenterMetadataSchema, ensureReadableDirectory = (path6) => {
   try {
@@ -233799,7 +233662,7 @@ var WORKSPACE_TOOL_HELP_METADATA_SUFFIX = ".cli.json", workspaceToolHelpcenterMe
     return false;
   }
 }, isWorkspaceToolMetadataFile = (fileName) => fileName.endsWith(WORKSPACE_TOOL_HELP_METADATA_SUFFIX), resolveToolRunner = (filePath) => {
-  const firstLine = readFileSync15(filePath, "utf8").split(/\r?\n/u, 1)[0] ?? "";
+  const firstLine = readFileSync14(filePath, "utf8").split(/\r?\n/u, 1)[0] ?? "";
   if (firstLine.includes("python")) {
     return "python3";
   }
@@ -233817,11 +233680,11 @@ var WORKSPACE_TOOL_HELP_METADATA_SUFFIX = ".cli.json", workspaceToolHelpcenterMe
   }
   return "bash";
 }, resolveWorkspaceToolMetadataPath = (rootPath, fileName) => join35(rootPath, `${fileName}${WORKSPACE_TOOL_HELP_METADATA_SUFFIX}`), readWorkspaceToolHelpcenterMetadata = (metadataPath) => {
-  if (!existsSync18(metadataPath)) {
+  if (!existsSync17(metadataPath)) {
     return null;
   }
   try {
-    const parsed = JSON.parse(readFileSync15(metadataPath, "utf8"));
+    const parsed = JSON.parse(readFileSync14(metadataPath, "utf8"));
     return workspaceToolHelpcenterMetadataSchema.parse(parsed);
   } catch {
     return null;
@@ -233842,7 +233705,7 @@ var WORKSPACE_TOOL_HELP_METADATA_SUFFIX = ".cli.json", workspaceToolHelpcenterMe
     if (!ensureReadableDirectory(root2.rootPath)) {
       continue;
     }
-    for (const entry2 of readdirSync10(root2.rootPath, { withFileTypes: true })) {
+    for (const entry2 of readdirSync9(root2.rootPath, { withFileTypes: true })) {
       if (!entry2.isFile() || isWorkspaceToolMetadataFile(entry2.name)) {
         continue;
       }
@@ -233864,7 +233727,7 @@ var WORKSPACE_TOOL_HELP_METADATA_SUFFIX = ".cli.json", workspaceToolHelpcenterMe
           description: metadata.description,
           skillRef: metadata.skillRef
         } : {
-          metadataPath: existsSync18(metadataPath) ? metadataPath : null,
+          metadataPath: existsSync17(metadataPath) ? metadataPath : null,
           registered: false,
           name: entry2.name,
           description: buildWorkspaceToolFallbackDescription({
@@ -234219,7 +234082,7 @@ var init_one_shot_shell_guard = __esm(() => {
 });
 
 // packages/app-server/src/workspace-system/private-isolation.ts
-import { readdirSync as readdirSync11, realpathSync as realpathSync6 } from "fs";
+import { readdirSync as readdirSync10, realpathSync as realpathSync6 } from "fs";
 import { relative as relative4, resolve as resolve29 } from "path";
 var resolveExistingPath = (path6) => {
   try {
@@ -234235,7 +234098,7 @@ var resolveExistingPath = (path6) => {
   return relation.length === 0 ? "/" : `/${relation}`;
 }, listSiblingDirectories = (root2) => {
   try {
-    return readdirSync11(root2, { withFileTypes: true }).filter((entry2) => entry2.isDirectory() || entry2.isSymbolicLink()).map((entry2) => entry2.name);
+    return readdirSync10(root2, { withFileTypes: true }).filter((entry2) => entry2.isDirectory() || entry2.isSymbolicLink()).map((entry2) => entry2.name);
   } catch {
     return [];
   }
@@ -234265,10 +234128,10 @@ var init_private_isolation = __esm(() => {
 });
 
 // packages/app-server/src/workspace-system/exec.ts
-import { mkdirSync as mkdirSync18 } from "fs";
+import { mkdirSync as mkdirSync17 } from "fs";
 import { relative as relative5, resolve as resolve30 } from "path";
 var WORKSPACE_SYSTEM_GRANT_KINDS, createBashFs = (input) => {
-  mkdirSync18(input.workspacePath, { recursive: true });
+  mkdirSync17(input.workspacePath, { recursive: true });
   const systemGrantPatterns = WORKSPACE_SYSTEM_GRANT_KINDS.flatMap((kind7) => {
     const roots = [
       resolveWorkspacePublicAssetRoot(input.workspacePath, kind7),
@@ -234492,7 +234355,7 @@ try {
 });
 
 // packages/app-server/src/workspace-system/root-exec.ts
-import { mkdirSync as mkdirSync19 } from "fs";
+import { mkdirSync as mkdirSync18 } from "fs";
 import { relative as relative6, resolve as resolve31 } from "path";
 
 class RootWorkspaceShellWorld {
@@ -234505,7 +234368,7 @@ class RootWorkspaceShellWorld {
   constructor(input) {
     this.rootWorkspacePath = resolve31(input.rootWorkspacePath);
     ensureMountParentDirs(this.baseFs, this.rootWorkspacePath);
-    mkdirSync19(this.rootWorkspacePath, { recursive: true });
+    mkdirSync18(this.rootWorkspacePath, { recursive: true });
     this.mountableFs.mount(this.rootWorkspacePath, new Ss3({ root: this.rootWorkspacePath }));
     this.bash = new xt7({
       fs: this.mountableFs,
@@ -234572,7 +234435,7 @@ class RootWorkspaceShellWorld {
         this.mountableFs.unmount(path6);
       }
       ensureMountParentDirs(this.baseFs, path6);
-      mkdirSync19(path6, { recursive: true });
+      mkdirSync18(path6, { recursive: true });
       const nextState = createDynamicMountState(mount);
       this.mountableFs.mount(path6, nextState.fs);
       this.dynamicMounts.set(path6, nextState);
@@ -234716,7 +234579,7 @@ var init_root_exec = __esm(() => {
 
 // packages/app-server/src/workspace-system/store.ts
 import { createHash as createHash10, randomUUID as randomUUID9 } from "crypto";
-import { mkdirSync as mkdirSync20, readFileSync as readFileSync16, writeFileSync as writeFileSync8 } from "fs";
+import { mkdirSync as mkdirSync19, readFileSync as readFileSync15, writeFileSync as writeFileSync7 } from "fs";
 import { homedir as homedir12 } from "os";
 import { dirname as dirname23, join as join36 } from "path";
 
@@ -234902,7 +234765,7 @@ class WorkspaceSystemStore {
   }
   readSnapshot() {
     try {
-      const parsed = JSON.parse(readFileSync16(this.filePath, "utf8"));
+      const parsed = JSON.parse(readFileSync15(this.filePath, "utf8"));
       if (parsed.version === 3) {
         return {
           version: 3,
@@ -234986,8 +234849,8 @@ class WorkspaceSystemStore {
     return index2 >= 0 ? index2 + 1 : ordered.length + 1;
   }
   flush() {
-    mkdirSync20(dirname23(this.filePath), { recursive: true });
-    writeFileSync8(this.filePath, `${JSON.stringify(this.snapshot, null, 2)}
+    mkdirSync19(dirname23(this.filePath), { recursive: true });
+    writeFileSync7(this.filePath, `${JSON.stringify(this.snapshot, null, 2)}
 `, "utf8");
   }
 }
@@ -235030,16 +234893,16 @@ var init_workspace_system = __esm(() => {
 
 // packages/app-server/src/avatar-seat-store.ts
 import {
-  existsSync as existsSync19,
+  existsSync as existsSync18,
   lstatSync as lstatSync4,
-  mkdirSync as mkdirSync21,
-  readdirSync as readdirSync12,
-  readFileSync as readFileSync17,
+  mkdirSync as mkdirSync20,
+  readdirSync as readdirSync11,
+  readFileSync as readFileSync16,
   realpathSync as realpathSync7,
   renameSync as renameSync3,
   rmSync as rmSync5,
   symlinkSync,
-  writeFileSync as writeFileSync9
+  writeFileSync as writeFileSync8
 } from "fs";
 import { homedir as homedir13 } from "os";
 import { dirname as dirname24, join as join37, relative as relative7 } from "path";
@@ -235048,11 +234911,11 @@ var createEmptyAvatarSeatDocument = () => ({
   messageSeats: {},
   terminalSeats: {}
 }), mergeLegacyAvatarDirectory = (sourceRoot, canonicalRoot) => {
-  mkdirSync21(canonicalRoot, { recursive: true });
-  for (const entry2 of readdirSync12(sourceRoot, { withFileTypes: true })) {
+  mkdirSync20(canonicalRoot, { recursive: true });
+  for (const entry2 of readdirSync11(sourceRoot, { withFileTypes: true })) {
     const sourcePath = join37(sourceRoot, entry2.name);
     const canonicalPath = join37(canonicalRoot, entry2.name);
-    if (existsSync19(canonicalPath)) {
+    if (existsSync18(canonicalPath)) {
       if (entry2.isDirectory() && lstatSync4(canonicalPath).isDirectory()) {
         mergeLegacyAvatarDirectory(sourcePath, canonicalPath);
         rmSync5(sourcePath, { recursive: true, force: true });
@@ -235067,8 +234930,8 @@ var createEmptyAvatarSeatDocument = () => ({
   const homeDir = input.homeDir ?? homedir13();
   const canonicalRoot = resolveWorkspaceAvatarCanonicalRoot(input.workspacePath, input.principalId, homeDir);
   const aliasPath = resolveWorkspaceAvatarAliasRoot(input.workspacePath, input.avatar, homeDir);
-  mkdirSync21(canonicalRoot, { recursive: true });
-  mkdirSync21(dirname24(aliasPath), { recursive: true });
+  mkdirSync20(canonicalRoot, { recursive: true });
+  mkdirSync20(dirname24(aliasPath), { recursive: true });
   try {
     const stats = lstatSync4(aliasPath);
     if (stats.isDirectory()) {
@@ -235187,11 +235050,11 @@ var createEmptyAvatarSeatDocument = () => ({
   };
 }, readAvatarSeatDocument = (workspacePath, avatar, homeDir = homedir13()) => {
   const filePath = resolveAvatarSeatSettingsPath(workspacePath, avatar, homeDir);
-  if (!existsSync19(filePath)) {
+  if (!existsSync18(filePath)) {
     return createEmptyAvatarSeatDocument();
   }
   try {
-    return normalizeSeatDocument(JSON.parse(readFileSync17(filePath, "utf8")));
+    return normalizeSeatDocument(JSON.parse(readFileSync16(filePath, "utf8")));
   } catch {
     return createEmptyAvatarSeatDocument();
   }
@@ -235232,8 +235095,8 @@ var createEmptyAvatarSeatDocument = () => ({
     principalId: input.doc.principalId,
     homeDir
   }).canonicalRoot, "settings.local.json") : resolveAvatarSeatSettingsPath(input.workspacePath, input.avatar, homeDir);
-  mkdirSync21(dirname24(filePath), { recursive: true });
-  writeFileSync9(filePath, `${JSON.stringify(input.doc, null, 2)}
+  mkdirSync20(dirname24(filePath), { recursive: true });
+  writeFileSync8(filePath, `${JSON.stringify(input.doc, null, 2)}
 `, "utf8");
   return input.doc;
 }, saveAvatarMessageSeatCredential = (input) => {
@@ -235284,7 +235147,7 @@ var init_avatar_seat_store = __esm(() => {
 });
 
 // packages/app-server/src/avatar-catalog.ts
-import { existsSync as existsSync20, readdirSync as readdirSync13 } from "fs";
+import { existsSync as existsSync19, readdirSync as readdirSync12 } from "fs";
 import { homedir as homedir14 } from "os";
 var compareAvatarNickname = (left2, right2) => {
   if (left2 === defaultAvatarNickname()) {
@@ -235297,11 +235160,11 @@ var compareAvatarNickname = (left2, right2) => {
 }, resolveWorkspaceAvatarRoot = (workspacePath, homeDir) => {
   return isGlobalWorkspacePath(workspacePath, homeDir) ? resolveGlobalAvatarNicknamesRoot(homeDir) : resolveWorkspaceAvatarNicknamesRoot(workspacePath, homeDir);
 }, listAvatarNicknames = (root2) => {
-  if (!existsSync20(root2)) {
+  if (!existsSync19(root2)) {
     return [];
   }
   try {
-    return readdirSync13(root2, { withFileTypes: true }).filter((entry2) => entry2.isDirectory() || entry2.isSymbolicLink()).map((entry2) => normalizeAvatarNickname(entry2.name));
+    return readdirSync12(root2, { withFileTypes: true }).filter((entry2) => entry2.isDirectory() || entry2.isSymbolicLink()).map((entry2) => normalizeAvatarNickname(entry2.name));
   } catch {
     return [];
   }
@@ -235324,8 +235187,8 @@ var compareAvatarNickname = (left2, right2) => {
   const nickname = normalizeAvatarNickname(input.nickname);
   const globalPath = resolveGlobalAvatarRoot(nickname, input.homeDir);
   const workspacePrivatePath = resolveWorkspaceAvatarPrivateRoot(input.workspacePath, nickname, input.homeDir);
-  const globalAvailable = input.globalAvailable ?? (existsSync20(resolveGlobalAvatarAliasRoot(nickname, input.homeDir)) || existsSync20(globalPath));
-  const workspacePrivateSlotReady = !isGlobalWorkspacePath(input.workspacePath, input.homeDir) && existsSync20(resolveWorkspaceAvatarAliasRoot(input.workspacePath, nickname, input.homeDir));
+  const globalAvailable = input.globalAvailable ?? (existsSync19(resolveGlobalAvatarAliasRoot(nickname, input.homeDir)) || existsSync19(globalPath));
+  const workspacePrivateSlotReady = !isGlobalWorkspacePath(input.workspacePath, input.homeDir) && existsSync19(resolveWorkspaceAvatarAliasRoot(input.workspacePath, nickname, input.homeDir));
   return {
     avatarPrincipalId: input.avatarPrincipalId ?? null,
     runtimeId: resolveAvatarRuntimeId(nickname),
@@ -235903,7 +235766,7 @@ var init_heartbeat_groups_page = __esm(() => {
 });
 
 // packages/app-server/src/local-env.ts
-import { existsSync as existsSync21, mkdirSync as mkdirSync22, readFileSync as readFileSync18, writeFileSync as writeFileSync10 } from "fs";
+import { existsSync as existsSync20, mkdirSync as mkdirSync21, readFileSync as readFileSync17, writeFileSync as writeFileSync9 } from "fs";
 import { join as join39 } from "path";
 var splitEnvLine = (line) => {
   const trimmed = line.trim();
@@ -235931,16 +235794,16 @@ var splitEnvLine = (line) => {
 `)}
 `, resolveLocalEnvPath = (homeDir) => join39(homeDir, ".agenter", "local.env"), readLocalEnvValue = (homeDir, key) => {
   const filePath = resolveLocalEnvPath(homeDir);
-  if (!existsSync21(filePath)) {
+  if (!existsSync20(filePath)) {
     return null;
   }
-  return parseEnvFile(readFileSync18(filePath, "utf8")).get(key) ?? null;
+  return parseEnvFile(readFileSync17(filePath, "utf8")).get(key) ?? null;
 }, writeLocalEnvValue = (homeDir, key, value) => {
   const filePath = resolveLocalEnvPath(homeDir);
-  mkdirSync22(join39(homeDir, ".agenter"), { recursive: true });
-  const entries = existsSync21(filePath) ? parseEnvFile(readFileSync18(filePath, "utf8")) : new Map;
+  mkdirSync21(join39(homeDir, ".agenter"), { recursive: true });
+  const entries = existsSync20(filePath) ? parseEnvFile(readFileSync17(filePath, "utf8")) : new Map;
   entries.set(key, value.trim());
-  writeFileSync10(filePath, serializeEnvFile(entries), "utf8");
+  writeFileSync9(filePath, serializeEnvFile(entries), "utf8");
   return filePath;
 };
 var init_local_env = () => {};
@@ -241256,7 +241119,7 @@ var init_session_assets = __esm(() => {
 
 // packages/app-server/src/room-assets.ts
 import { randomUUID as randomUUID10 } from "crypto";
-import { existsSync as existsSync22, mkdirSync as mkdirSync23, readFileSync as readFileSync19, writeFileSync as writeFileSync11 } from "fs";
+import { existsSync as existsSync21, mkdirSync as mkdirSync22, readFileSync as readFileSync18, writeFileSync as writeFileSync10 } from "fs";
 import { dirname as dirname26, join as join40, posix as posixPath2 } from "path";
 
 class RoomAssetStore {
@@ -241275,15 +241138,15 @@ class RoomAssetStore {
   }
   readIndex(roomId) {
     const indexPath = this.getIndexPath(roomId);
-    if (!existsSync22(indexPath)) {
+    if (!existsSync21(indexPath)) {
       return [];
     }
-    return parseRoomAssetIndex(readFileSync19(indexPath, "utf8"));
+    return parseRoomAssetIndex(readFileSync18(indexPath, "utf8"));
   }
   writeIndex(roomId, records) {
     const indexPath = this.getIndexPath(roomId);
-    mkdirSync23(dirname26(indexPath), { recursive: true });
-    writeFileSync11(indexPath, `${JSON.stringify(records, null, 2)}
+    mkdirSync22(dirname26(indexPath), { recursive: true });
+    writeFileSync10(indexPath, `${JSON.stringify(records, null, 2)}
 `, "utf8");
   }
   uploadAssets(roomId, files, input = {}) {
@@ -241305,8 +241168,8 @@ class RoomAssetStore {
         uploadedByActorId: input.uploadedByActorId
       };
       const filePath = this.resolveAbsolutePath(record2.relativePath);
-      mkdirSync23(dirname26(filePath), { recursive: true });
-      writeFileSync11(filePath, file3.bytes);
+      mkdirSync22(dirname26(filePath), { recursive: true });
+      writeFileSync10(filePath, file3.bytes);
       created.push(record2);
     }
     if (created.length > 0) {
@@ -241676,20 +241539,20 @@ var init_runtime_tool_views = __esm(() => {
 });
 
 // packages/app-server/src/session-doc.ts
-import { existsSync as existsSync23, mkdirSync as mkdirSync24, readFileSync as readFileSync20, writeFileSync as writeFileSync12 } from "fs";
+import { existsSync as existsSync22, mkdirSync as mkdirSync23, readFileSync as readFileSync19, writeFileSync as writeFileSync11 } from "fs";
 import { dirname as dirname27 } from "path";
 var readSessionDocument = (filePath) => {
-  if (!existsSync23(filePath)) {
+  if (!existsSync22(filePath)) {
     return null;
   }
   try {
-    return JSON.parse(readFileSync20(filePath, "utf8"));
+    return JSON.parse(readFileSync19(filePath, "utf8"));
   } catch {
     return null;
   }
 }, writeSessionDocument = (filePath, doc2) => {
-  mkdirSync24(dirname27(filePath), { recursive: true });
-  writeFileSync12(filePath, `${JSON.stringify(doc2, null, 2)}
+  mkdirSync23(dirname27(filePath), { recursive: true });
+  writeFileSync11(filePath, `${JSON.stringify(doc2, null, 2)}
 `, "utf8");
 };
 var init_session_doc = () => {};
@@ -241703,7 +241566,7 @@ var init_session_identity = __esm(() => {
 });
 
 // packages/app-server/src/session-catalog.ts
-import { existsSync as existsSync24, mkdirSync as mkdirSync25, readdirSync as readdirSync14, renameSync as renameSync4, rmSync as rmSync6 } from "fs";
+import { existsSync as existsSync23, mkdirSync as mkdirSync24, readdirSync as readdirSync13, renameSync as renameSync4, rmSync as rmSync6 } from "fs";
 import { homedir as homedir16 } from "os";
 import { basename as basename9, dirname as dirname28, join as join41, resolve as resolve32 } from "path";
 
@@ -241766,7 +241629,7 @@ class SessionCatalog {
       }),
       storeTarget: input.storeTarget
     };
-    mkdirSync25(session.sessionRoot, { recursive: true });
+    mkdirSync24(session.sessionRoot, { recursive: true });
     this.persistMeta(session);
     this.byId.set(id, session);
     return session;
@@ -241799,7 +241662,7 @@ class SessionCatalog {
     }
     const archivedAt = isoNow();
     const nextRoot = this.resolveArchiveSessionRoot(current.id, archivedAt);
-    mkdirSync25(dirname28(nextRoot), { recursive: true });
+    mkdirSync24(dirname28(nextRoot), { recursive: true });
     renameSync4(current.sessionRoot, nextRoot);
     const next2 = {
       ...current,
@@ -241823,7 +241686,7 @@ class SessionCatalog {
       return current;
     }
     const nextRoot = this.resolveActiveSessionRoot(current);
-    mkdirSync25(dirname28(nextRoot), { recursive: true });
+    mkdirSync24(dirname28(nextRoot), { recursive: true });
     renameSync4(current.sessionRoot, nextRoot);
     const restoredAt = isoNow();
     const next2 = {
@@ -241909,7 +241772,7 @@ class SessionCatalog {
     const roots = [];
     for (const avatarRoot of legacyRoots) {
       try {
-        const avatars = readdirSync14(avatarRoot, { withFileTypes: true });
+        const avatars = readdirSync13(avatarRoot, { withFileTypes: true });
         for (const avatar of avatars) {
           if (!avatar.isDirectory()) {
             continue;
@@ -241961,14 +241824,14 @@ class SessionCatalog {
     return meta3.id === resolveWorkspaceAvatarSessionId(GLOBAL_WORKSPACE_PATH, meta3.avatar);
   }
   quarantineSessionRoot(sessionRoot) {
-    if (!existsSync24(sessionRoot)) {
+    if (!existsSync23(sessionRoot)) {
       return;
     }
     const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
     const baseName = basename9(sessionRoot) || "session";
     const targetRoot = join41(this.legacyRoot, timestamp, baseName);
     try {
-      mkdirSync25(dirname28(targetRoot), { recursive: true });
+      mkdirSync24(dirname28(targetRoot), { recursive: true });
       renameSync4(sessionRoot, targetRoot);
     } catch {
       rmSync6(sessionRoot, { recursive: true, force: true });
@@ -242024,22 +241887,22 @@ var isoNow = () => new Date().toISOString(), toUtcBucket = (isoLike) => {
 }, scanBucketedSessionRoots = (baseDir) => {
   const roots = [];
   try {
-    for (const year of readdirSync14(baseDir, { withFileTypes: true })) {
+    for (const year of readdirSync13(baseDir, { withFileTypes: true })) {
       if (!year.isDirectory()) {
         continue;
       }
       const yearDir = join41(baseDir, year.name);
-      for (const month of readdirSync14(yearDir, { withFileTypes: true })) {
+      for (const month of readdirSync13(yearDir, { withFileTypes: true })) {
         if (!month.isDirectory()) {
           continue;
         }
         const monthDir = join41(yearDir, month.name);
-        for (const day of readdirSync14(monthDir, { withFileTypes: true })) {
+        for (const day of readdirSync13(monthDir, { withFileTypes: true })) {
           if (!day.isDirectory()) {
             continue;
           }
           const dayDir = join41(monthDir, day.name);
-          for (const session of readdirSync14(dayDir, { withFileTypes: true })) {
+          for (const session of readdirSync13(dayDir, { withFileTypes: true })) {
             if (session.isDirectory()) {
               roots.push(join41(dayDir, session.name));
             }
@@ -242053,7 +241916,7 @@ var isoNow = () => new Date().toISOString(), toUtcBucket = (isoLike) => {
   return roots;
 }, scanDirectSessionRoots = (baseDir) => {
   try {
-    return readdirSync14(baseDir, { withFileTypes: true }).filter((entry2) => entry2.isDirectory()).map((entry2) => join41(baseDir, entry2.name)).filter((entry2) => existsSync24(join41(entry2, "session.json")));
+    return readdirSync13(baseDir, { withFileTypes: true }).filter((entry2) => entry2.isDirectory()).map((entry2) => join41(baseDir, entry2.name)).filter((entry2) => existsSync23(join41(entry2, "session.json")));
   } catch {
     return [];
   }
@@ -242074,7 +241937,7 @@ var resolveSessionRoomActorId = (sessionId) => `session:${sessionId}`;
 
 // packages/app-server/src/i18n.ts
 import { copyFile, mkdir as mkdir5, mkdtemp, readFile as readFile4, rm as rm2 } from "fs/promises";
-import { existsSync as existsSync25 } from "fs";
+import { existsSync as existsSync24 } from "fs";
 import { homedir as homedir17, tmpdir as tmpdir2 } from "os";
 import { join as join42 } from "path";
 var APP_SERVER_PACKAGE_JSON_PATH, BUNDLED_ASSETS_ROOT_ENV2 = "AGENTER_BUNDLED_ASSETS_ROOT", DEFAULT_LANGUAGE = "en", LANG_PACKAGES, VERSION_PATTERN, textDecoder2, parseLangAlias = (value) => {
@@ -242122,7 +241985,7 @@ var APP_SERVER_PACKAGE_JSON_PATH, BUNDLED_ASSETS_ROOT_ENV2 = "AGENTER_BUNDLED_AS
   const bundledRoot = process.env[BUNDLED_ASSETS_ROOT_ENV2]?.trim();
   if (bundledRoot) {
     const promptsDir2 = join42(bundledRoot, config2.workspaceDirName, "prompts");
-    if (existsSync25(promptsDir2)) {
+    if (existsSync24(promptsDir2)) {
       return buildPromptDocsFromDir(promptsDir2);
     }
   }
@@ -254986,7 +254849,7 @@ var init_sql = __esm(() => {
 });
 
 // packages/app-server/src/mcp-system/store.ts
-import { mkdirSync as mkdirSync26 } from "fs";
+import { mkdirSync as mkdirSync25 } from "fs";
 import { dirname as dirname29, resolve as resolve34 } from "path";
 import { Database as Database8 } from "bun:sqlite";
 
@@ -254994,7 +254857,7 @@ class McpSystemStore {
   db;
   constructor(filePath) {
     const fullPath = resolve34(filePath);
-    mkdirSync26(dirname29(fullPath), { recursive: true });
+    mkdirSync25(dirname29(fullPath), { recursive: true });
     this.db = new Database8(fullPath, { create: true, strict: true });
     this.db.exec(`pragma journal_mode = WAL;`);
     this.db.exec(`pragma foreign_keys = on;`);
@@ -255523,7 +255386,7 @@ var init_store2 = __esm(() => {
 });
 
 // packages/app-server/src/mcp-system/system.ts
-import { mkdirSync as mkdirSync27 } from "fs";
+import { mkdirSync as mkdirSync26 } from "fs";
 import { resolve as resolve35 } from "path";
 
 class McpSystem {
@@ -255537,7 +255400,7 @@ class McpSystem {
   locks = new Map;
   constructor(options) {
     this.rootWorkspacePath = resolve35(options.rootWorkspacePath);
-    mkdirSync27(this.rootWorkspacePath, { recursive: true });
+    mkdirSync26(this.rootWorkspacePath, { recursive: true });
     this.runtimeEnv = cloneStringRecord(options.runtimeEnv);
     this.clientName = options.clientName ?? "agenter-mcp-system";
     this.clientVersion = options.clientVersion ?? "0.0.0";
@@ -279990,7 +279853,7 @@ References:
 
 // packages/app-server/src/runtime-skill-config.ts
 import { createHash as createHash13 } from "crypto";
-import { existsSync as existsSync26, readFileSync as readFileSync21, readdirSync as readdirSync15, statSync as statSync6, writeFileSync as writeFileSync13 } from "fs";
+import { existsSync as existsSync25, readFileSync as readFileSync20, readdirSync as readdirSync14, statSync as statSync6, writeFileSync as writeFileSync12 } from "fs";
 import { basename as basename11, isAbsolute as isAbsolute11, join as join47, relative as relative9, resolve as resolve38 } from "path";
 var RUNTIME_SKILL_CONFIG_BASENAME = "ccski.config.json", MATCH_OPTIONS2, runtimeSkillConfigSchema, MAGIC_PATTERN, normalizeConfigPattern = (value) => {
   const normalized = value.replace(/\\/gu, "/").trim().replace(/^\.\/+/u, "");
@@ -280010,8 +279873,8 @@ var RUNTIME_SKILL_CONFIG_BASENAME = "ccski.config.json", MATCH_OPTIONS2, runtime
   return segments.join("/");
 }, normalizeConfigFiles = (value) => ({
   files: value.files?.map((item) => normalizeConfigPattern(item)).filter((item, index3, items) => items.indexOf(item) === index3).sort((left2, right2) => left2.localeCompare(right2)) ?? undefined
-}), parseConfigJson = (raw2) => normalizeConfigFiles(runtimeSkillConfigSchema.parse(JSON.parse(raw2))), hashContent = (value) => createHash13("sha1").update(value).digest("hex"), readFileFingerprint = (path6) => hashContent(readFileSync21(path6, "utf8")), walkFiles = (root3, depth = 0, maxDepth = Number.POSITIVE_INFINITY) => {
-  if (depth > maxDepth || !existsSync26(root3)) {
+}), parseConfigJson = (raw2) => normalizeConfigFiles(runtimeSkillConfigSchema.parse(JSON.parse(raw2))), hashContent = (value) => createHash13("sha1").update(value).digest("hex"), readFileFingerprint = (path6) => hashContent(readFileSync20(path6, "utf8")), walkFiles = (root3, depth = 0, maxDepth = Number.POSITIVE_INFINITY) => {
+  if (depth > maxDepth || !existsSync25(root3)) {
     return [];
   }
   const stats = statSync6(root3);
@@ -280019,7 +279882,7 @@ var RUNTIME_SKILL_CONFIG_BASENAME = "ccski.config.json", MATCH_OPTIONS2, runtime
     return stats.isFile() ? [root3] : [];
   }
   const output = [];
-  for (const entry2 of readdirSync15(root3, { withFileTypes: true })) {
+  for (const entry2 of readdirSync14(root3, { withFileTypes: true })) {
     const nextPath = join47(root3, entry2.name);
     if (entry2.isDirectory()) {
       output.push(...walkFiles(nextPath, depth + 1, maxDepth));
@@ -280046,7 +279909,7 @@ var RUNTIME_SKILL_CONFIG_BASENAME = "ccski.config.json", MATCH_OPTIONS2, runtime
   };
 }, resolvePatternMatches = (skillDir, spec) => {
   const matcher = new Minimatch(spec.pattern, MATCH_OPTIONS2);
-  if (!existsSync26(spec.anchorPath)) {
+  if (!existsSync25(spec.anchorPath)) {
     return [];
   }
   const stats = statSync6(spec.anchorPath);
@@ -280060,18 +279923,18 @@ var RUNTIME_SKILL_CONFIG_BASENAME = "ccski.config.json", MATCH_OPTIONS2, runtime
   return walkFiles(spec.anchorPath, 0, maxDepth).map((path6) => resolve38(path6)).filter((path6) => matcher.match(relative9(skillDir, path6).replace(/\\/gu, "/"))).sort((left2, right2) => left2.localeCompare(right2));
 }, resolveDeclaredPatterns = (skill, config2) => (config2?.files ?? []).map((pattern) => {
   const absoluteCandidate = resolve38(skill.skillDir, pattern);
-  if (!pattern.includes("*") && existsSync26(absoluteCandidate) && statSync6(absoluteCandidate).isDirectory()) {
+  if (!pattern.includes("*") && existsSync25(absoluteCandidate) && statSync6(absoluteCandidate).isDirectory()) {
     return `${pattern.replace(/\/$/u, "")}/**`;
   }
   return pattern;
 }), getRuntimeSkillConfigPath = (skill) => resolve38(skill.configPath || join47(skill.skillDir, RUNTIME_SKILL_CONFIG_BASENAME)), readRuntimeSkillConfigState = (skill) => {
   const configPath = getRuntimeSkillConfigPath(skill);
-  const configExists = existsSync26(configPath);
+  const configExists = existsSync25(configPath);
   let config2 = null;
   let configError = null;
   if (configExists) {
     try {
-      config2 = parseConfigJson(readFileSync21(configPath, "utf8"));
+      config2 = parseConfigJson(readFileSync20(configPath, "utf8"));
     } catch (error53) {
       configError = error53 instanceof Error ? error53.message : String(error53);
     }
@@ -280102,7 +279965,7 @@ var RUNTIME_SKILL_CONFIG_BASENAME = "ccski.config.json", MATCH_OPTIONS2, runtime
   };
 }, buildRuntimeSkillObservedFiles = (skill, state = readRuntimeSkillConfigState(skill)) => {
   const observed = new Set;
-  if (existsSync26(skill.path)) {
+  if (existsSync25(skill.path)) {
     observed.add(resolve38(skill.path));
   } else if (typeof skill.content === "string" && skill.content.length > 0) {
     observed.add(resolve38(skill.path));
@@ -280114,7 +279977,7 @@ var RUNTIME_SKILL_CONFIG_BASENAME = "ccski.config.json", MATCH_OPTIONS2, runtime
     if (target2 === resolve38(skill.path) || target2 === resolve38(state.configPath)) {
       continue;
     }
-    if (existsSync26(target2) && statSync6(target2).isFile()) {
+    if (existsSync25(target2) && statSync6(target2).isFile()) {
       observed.add(resolve38(target2));
     }
   }
@@ -280122,7 +279985,7 @@ var RUNTIME_SKILL_CONFIG_BASENAME = "ccski.config.json", MATCH_OPTIONS2, runtime
 }, buildRuntimeSkillFileFingerprintMap = (skill, state = readRuntimeSkillConfigState(skill)) => {
   const fingerprints = new Map;
   for (const path6 of buildRuntimeSkillObservedFiles(skill, state)) {
-    if (existsSync26(path6)) {
+    if (existsSync25(path6)) {
       fingerprints.set(path6, readFileFingerprint(path6));
       continue;
     }
@@ -280134,7 +279997,7 @@ var RUNTIME_SKILL_CONFIG_BASENAME = "ccski.config.json", MATCH_OPTIONS2, runtime
 }, writeRuntimeSkillConfigFile = (skill, config2) => {
   const normalized = normalizeConfigFiles(config2);
   const configPath = getRuntimeSkillConfigPath(skill);
-  writeFileSync13(configPath, `${JSON.stringify(normalized, null, 2)}
+  writeFileSync12(configPath, `${JSON.stringify(normalized, null, 2)}
 `, "utf8");
   return configPath;
 }, hasRuntimeSkillRecursiveWatchSpec = (state) => state.watchSpecs.some((spec) => spec.recursive), formatRuntimeSkillRelativeFiles = (skillDir, paths, maxItems = 3) => {
@@ -280201,12 +280064,12 @@ var normalizeRuntimeSkillName = (value) => value.trim().toLowerCase(), parseRunt
 };
 
 // packages/app-server/src/runtime-skills.ts
-import { existsSync as existsSync27, mkdirSync as mkdirSync28, readFileSync as readFileSync22, readdirSync as readdirSync16, rmSync as rmSync7, statSync as statSync7, writeFileSync as writeFileSync14 } from "fs";
+import { existsSync as existsSync26, mkdirSync as mkdirSync27, readFileSync as readFileSync21, readdirSync as readdirSync15, rmSync as rmSync7, statSync as statSync7, writeFileSync as writeFileSync13 } from "fs";
 import { homedir as homedir19 } from "os";
 import { basename as basename12, dirname as dirname31, join as join48, relative as relative10, resolve as resolve39 } from "path";
 import { fileURLToPath as fileURLToPath9 } from "url";
 var RUNTIME_API_BASE_URL_ENV = "AGENTER_ATTENTION_API_BASE_URL", RUNTIME_MANAGED_SEAT_AUTHORITY_URL_ENV = "AGENTER_MANAGED_SEAT_AUTHORITY_URL", RUNTIME_HOME_DIR_ENV = "AGENTER_HOME_DIR", RUNTIME_PRINCIPAL_ID_ENV = "AGENTER_AVATAR_PRINCIPAL_ID", RUNTIME_PRIVATE_KEY_ENV = "AGENTER_AVATAR_PRIVATE_KEY", RUNTIME_ROOT_WORKSPACE_ENV = "AGENTER_ROOT_WORKSPACE", DEFAULT_REPO_ROOT, RUNTIME_TOOL_NAMESPACES, EXAMPLE_SLOT_PATTERN, RUNTIME_SKILL_VISIBLE_LAYER_ORDER, collectSkillFiles = (root3, depth = 0) => {
-  if (!existsSync27(root3) || depth > 4) {
+  if (!existsSync26(root3) || depth > 4) {
     return [];
   }
   let stats;
@@ -280219,11 +280082,11 @@ var RUNTIME_API_BASE_URL_ENV = "AGENTER_ATTENTION_API_BASE_URL", RUNTIME_MANAGED
     return [];
   }
   const directSkill = join48(root3, "SKILL.md");
-  if (existsSync27(directSkill)) {
+  if (existsSync26(directSkill)) {
     return [directSkill];
   }
   const output = [];
-  for (const entry2 of readdirSync16(root3, { withFileTypes: true })) {
+  for (const entry2 of readdirSync15(root3, { withFileTypes: true })) {
     if (!entry2.isDirectory()) {
       continue;
     }
@@ -280238,11 +280101,11 @@ var RUNTIME_API_BASE_URL_ENV = "AGENTER_ATTENTION_API_BASE_URL", RUNTIME_MANAGED
     path: resolve39(input.path),
     skillDir,
     configPath,
-    configExists: existsSync27(configPath)
+    configExists: existsSync26(configPath)
   };
 }, readSkillRecord = (filePath, root3) => {
   try {
-    const content3 = readFileSync22(filePath, "utf8");
+    const content3 = readFileSync21(filePath, "utf8");
     const frontmatter = parseRuntimeSkillFrontmatter(content3);
     const fallbackName = basename12(relative10(root3.path, filePath).replace(/\/SKILL\.md$/u, ""));
     const name3 = normalizeRuntimeSkillName(frontmatter.name ?? fallbackName);
@@ -280317,9 +280180,9 @@ var RUNTIME_API_BASE_URL_ENV = "AGENTER_ATTENTION_API_BASE_URL", RUNTIME_MANAGED
 `);
 }, readBuiltinSkillTemplate = (entry2, repoRoot) => {
   const sourcePath = resolve39(repoRoot, entry2.sourcePath);
-  if (existsSync27(sourcePath)) {
+  if (existsSync26(sourcePath)) {
     return {
-      template: readFileSync22(sourcePath, "utf8"),
+      template: readFileSync21(sourcePath, "utf8"),
       sourcePath
     };
   }
@@ -280391,7 +280254,7 @@ var RUNTIME_API_BASE_URL_ENV = "AGENTER_ATTENTION_API_BASE_URL", RUNTIME_MANAGED
   }
   const source = input.rootKind ? listRuntimeSkillsByVisibleLayerOrder(input) : listRuntimeSkills(input);
   return source.find((skill) => skill.name === normalizedName && (input.rootKind ? skill.rootKind === input.rootKind : true)) ?? null;
-}, readRuntimeSkillContent = (skill) => typeof skill === "string" ? readFileSync22(skill, "utf8") : skill.content ?? readFileSync22(skill.path, "utf8"), upsertRuntimeSkillFile = (input) => {
+}, readRuntimeSkillContent = (skill) => typeof skill === "string" ? readFileSync21(skill, "utf8") : skill.content ?? readFileSync21(skill.path, "utf8"), upsertRuntimeSkillFile = (input) => {
   const normalizedName = normalizeRuntimeSkillName(input.name);
   if (!normalizedName) {
     throw new Error(`invalid skill name: ${input.name}`);
@@ -280404,8 +280267,8 @@ var RUNTIME_API_BASE_URL_ENV = "AGENTER_ATTENTION_API_BASE_URL", RUNTIME_MANAGED
   const root3 = resolveRuntimeSkillRootByKind(input, input.rootKind ?? "avatar");
   const skillDir = join48(root3.path, normalizedName);
   const skillPath = join48(skillDir, "SKILL.md");
-  mkdirSync28(skillDir, { recursive: true });
-  writeFileSync14(skillPath, input.content.endsWith(`
+  mkdirSync27(skillDir, { recursive: true });
+  writeFileSync13(skillPath, input.content.endsWith(`
 `) ? input.content : `${input.content}
 `, "utf8");
   const record3 = readSkillRecord(skillPath, root3);
@@ -280515,12 +280378,12 @@ var init_runtime_skills = __esm(() => {
 });
 
 // packages/app-server/src/runtime-tools.ts
-import { copyFileSync, existsSync as existsSync28, mkdirSync as mkdirSync29, readdirSync as readdirSync17, statSync as statSync8 } from "fs";
+import { copyFileSync, existsSync as existsSync27, mkdirSync as mkdirSync28, readdirSync as readdirSync16, statSync as statSync8 } from "fs";
 import { homedir as homedir20 } from "os";
 import { dirname as dirname32, join as join49, relative as relative11, resolve as resolve40 } from "path";
 import { fileURLToPath as fileURLToPath10 } from "url";
 var DEFAULT_REPO_ROOT2, BUILTIN_RUNTIME_TOOLS_SOURCE = "packages/app-server/tools", BUILTIN_RUNTIME_TOOL_DESCRIPTORS, collectToolFiles = (root3, depth = 0) => {
-  if (!existsSync28(root3) || depth > 4) {
+  if (!existsSync27(root3) || depth > 4) {
     return [];
   }
   let stats;
@@ -280533,7 +280396,7 @@ var DEFAULT_REPO_ROOT2, BUILTIN_RUNTIME_TOOLS_SOURCE = "packages/app-server/tool
     return [];
   }
   const output = [];
-  for (const entry2 of readdirSync17(root3, { withFileTypes: true })) {
+  for (const entry2 of readdirSync16(root3, { withFileTypes: true })) {
     const nextPath = join49(root3, entry2.name);
     if (entry2.isDirectory()) {
       output.push(...collectToolFiles(nextPath, depth + 1));
@@ -280547,7 +280410,7 @@ var DEFAULT_REPO_ROOT2, BUILTIN_RUNTIME_TOOLS_SOURCE = "packages/app-server/tool
 }, copyToolFile = (sourcePath, sourceRoot, targetRoot) => {
   const relativePath = relative11(sourceRoot, sourcePath);
   const targetPath = join49(targetRoot, relativePath);
-  mkdirSync29(dirname32(targetPath), { recursive: true });
+  mkdirSync28(dirname32(targetPath), { recursive: true });
   copyFileSync(sourcePath, targetPath);
 }, getBuiltinRuntimeToolDescriptor = (fileName) => BUILTIN_RUNTIME_TOOL_DESCRIPTORS[fileName] ?? null, renderBuiltinRuntimeToolHelp = (descriptor) => [
   descriptor.fileName,
@@ -280568,7 +280431,7 @@ var DEFAULT_REPO_ROOT2, BUILTIN_RUNTIME_TOOLS_SOURCE = "packages/app-server/tool
   const repoRoot = resolve40(input.repoRoot ?? DEFAULT_REPO_ROOT2);
   const sourceRoot = resolve40(repoRoot, BUILTIN_RUNTIME_TOOLS_SOURCE);
   const targetRoot = getRuntimeToolRoot(input);
-  mkdirSync29(targetRoot, { recursive: true });
+  mkdirSync28(targetRoot, { recursive: true });
   const files = collectToolFiles(sourceRoot);
   for (const filePath of files) {
     copyToolFile(filePath, sourceRoot, targetRoot);
@@ -280585,7 +280448,7 @@ var init_runtime_tools = __esm(() => {
 });
 
 // packages/app-server/src/runtime-cli.ts
-import { existsSync as existsSync29, readFileSync as readFileSync23 } from "fs";
+import { existsSync as existsSync28, readFileSync as readFileSync22 } from "fs";
 import { join as join50 } from "path";
 var json3 = (value) => `${JSON.stringify(value, null, 2)}
 `, isHelpArg2 = (value) => value === "--help", isCompactArg = (value) => value === "--compact", parseRuntimeSubcommandArgs = (args) => {
@@ -280703,10 +280566,10 @@ Config error: ${result.configError}` : "",
   }
   return payload;
 }, resolveToolRunner2 = (filePath) => {
-  if (!existsSync29(filePath)) {
+  if (!existsSync28(filePath)) {
     throw new Error(`tool file not found: ${filePath}`);
   }
-  const firstLine = readFileSync23(filePath, "utf8").split(/\r?\n/u, 1)[0] ?? "";
+  const firstLine = readFileSync22(filePath, "utf8").split(/\r?\n/u, 1)[0] ?? "";
   if (firstLine.includes("python")) {
     return "python3";
   }
@@ -281319,14 +281182,14 @@ var init_runtime_local_api = __esm(() => {
 });
 
 // packages/app-server/src/runtime-shell-bin.ts
-import { chmodSync, mkdirSync as mkdirSync30, writeFileSync as writeFileSync15 } from "fs";
+import { chmodSync, mkdirSync as mkdirSync29, writeFileSync as writeFileSync14 } from "fs";
 import { join as join51, resolve as resolve41 } from "path";
 var RUNTIME_BIN_DIRNAME = ".runtime-bin", RUNTIME_SHELL_COMMANDS, writeExecutable = (filePath, content3) => {
-  writeFileSync15(filePath, content3, "utf8");
+  writeFileSync14(filePath, content3, "utf8");
   chmodSync(filePath, 493);
 }, resolveRuntimeShellBinDir = (rootWorkspacePath) => resolve41(rootWorkspacePath, RUNTIME_BIN_DIRNAME), materializeRuntimeShellBin = (rootWorkspacePath) => {
   const binDir = resolveRuntimeShellBinDir(rootWorkspacePath);
-  mkdirSync30(binDir, { recursive: true });
+  mkdirSync29(binDir, { recursive: true });
   for (const commandName of RUNTIME_SHELL_COMMANDS) {
     writeExecutable(join51(binDir, commandName), [
       "#!/usr/bin/env bash",
@@ -281468,14 +281331,14 @@ var init_runtime_shell_bin = __esm(() => {
 });
 
 // packages/app-server/src/runtime-skill-fingerprint-manifest.ts
-import { existsSync as existsSync30, mkdirSync as mkdirSync31, readFileSync as readFileSync24, renameSync as renameSync5, rmSync as rmSync8, writeFileSync as writeFileSync16 } from "fs";
+import { existsSync as existsSync29, mkdirSync as mkdirSync30, readFileSync as readFileSync23, renameSync as renameSync5, rmSync as rmSync8, writeFileSync as writeFileSync15 } from "fs";
 import { dirname as dirname33 } from "path";
 var RUNTIME_SKILL_FINGERPRINT_MANIFEST_VERSION = 1, runtimeSkillFingerprintFileSchema, runtimeSkillFingerprintEntrySchema, runtimeSkillFingerprintManifestSchema, readRuntimeSkillFingerprintManifest = (path6) => {
-  if (!existsSync30(path6)) {
+  if (!existsSync29(path6)) {
     return { kind: "missing" };
   }
   try {
-    const parsed = runtimeSkillFingerprintManifestSchema.parse(JSON.parse(readFileSync24(path6, "utf8")));
+    const parsed = runtimeSkillFingerprintManifestSchema.parse(JSON.parse(readFileSync23(path6, "utf8")));
     return {
       kind: "ok",
       trackedSkills: new Map(parsed.skills.map((entry2) => [
@@ -281517,10 +281380,10 @@ var RUNTIME_SKILL_FINGERPRINT_MANIFEST_VERSION = 1, runtimeSkillFingerprintFileS
     generatedAt: new Date().toISOString(),
     skills
   };
-  mkdirSync31(dirname33(path6), { recursive: true });
+  mkdirSync30(dirname33(path6), { recursive: true });
   const tempPath = `${path6}.${process.pid}.${Date.now()}.tmp`;
   try {
-    writeFileSync16(tempPath, `${JSON.stringify(manifest2, null, 2)}
+    writeFileSync15(tempPath, `${JSON.stringify(manifest2, null, 2)}
 `, "utf8");
     renameSync5(tempPath, path6);
   } catch (error53) {
@@ -281752,7 +281615,7 @@ var init_runtime_skill_ingress = __esm(() => {
 });
 
 // packages/app-server/src/runtime-skill-watch-service.ts
-import { existsSync as existsSync31, statSync as statSync9, watch as watch2 } from "fs";
+import { existsSync as existsSync30, statSync as statSync9, watch as watch2 } from "fs";
 import { basename as basename13, dirname as dirname34, resolve as resolve42 } from "path";
 
 class RuntimeSkillWatchService {
@@ -281946,7 +281809,7 @@ var DEFAULT_SKILL_WATCH_DEBOUNCE_MS = 800, DEFAULT_SKILL_WATCH_POLL_MS = 2000, n
 }, resolveWatchLocation = (path6) => {
   let current2 = resolve42(path6);
   let filterName = null;
-  while (!existsSync31(current2)) {
+  while (!existsSync30(current2)) {
     filterName = basename13(current2);
     const parent = dirname34(current2);
     if (parent === current2) {
@@ -282691,7 +282554,7 @@ var cloneWatch = (watch3) => ({
 });
 
 // packages/app-server/src/session-store.ts
-import { mkdirSync as mkdirSync32 } from "fs";
+import { mkdirSync as mkdirSync31 } from "fs";
 import { join as join52, resolve as resolve43 } from "path";
 
 class SessionStore {
@@ -282700,8 +282563,8 @@ class SessionStore {
   constructor(options) {
     const now3 = new Date().toISOString();
     const sessionRoot = resolve43(options.sessionRoot);
-    mkdirSync32(sessionRoot, { recursive: true });
-    mkdirSync32(join52(sessionRoot, "logs"), { recursive: true });
+    mkdirSync31(sessionRoot, { recursive: true });
+    mkdirSync31(join52(sessionRoot, "logs"), { recursive: true });
     this.filePath = join52(sessionRoot, "session.json");
     const existingSession = readSessionDocument(this.filePath)?.session;
     this.doc = existingSession ? {
@@ -282755,7 +282618,7 @@ var init_session_store = __esm(() => {
 });
 
 // packages/app-server/src/settings-editor.ts
-import { mkdirSync as mkdirSync33 } from "fs";
+import { mkdirSync as mkdirSync32 } from "fs";
 import { readFile as readFile7, stat as stat3, writeFile as writeFile7 } from "fs/promises";
 import { dirname as dirname35, resolve as resolve44 } from "path";
 
@@ -282783,7 +282646,7 @@ class SettingsEditor {
         latest: current2
       };
     }
-    mkdirSync33(dirname35(path6), { recursive: true });
+    mkdirSync32(dirname35(path6), { recursive: true });
     await writeFile7(path6, content3, "utf8");
     const next2 = await readMaybe(path6);
     return {
@@ -282840,7 +282703,7 @@ var stableSnapshotStringify = (value) => JSON.stringify(value), buildFingerprint
 var init_terminal_snapshot_fingerprint = () => {};
 
 // packages/app-server/src/usage-analytics-db.ts
-import { mkdirSync as mkdirSync34 } from "fs";
+import { mkdirSync as mkdirSync33 } from "fs";
 import { dirname as dirname36, resolve as resolve45 } from "path";
 import { Database as Database9 } from "bun:sqlite";
 
@@ -282848,7 +282711,7 @@ class UsageAnalyticsDb {
   db;
   constructor(filePath) {
     const fullPath = resolve45(filePath);
-    mkdirSync34(dirname36(fullPath), { recursive: true });
+    mkdirSync33(dirname36(fullPath), { recursive: true });
     this.db = new Database9(fullPath, { create: true, strict: true });
     this.migrate();
   }
@@ -292932,7 +292795,7 @@ var init_session_runtime = __esm(() => {
 });
 
 // packages/app-server/src/skill-browser.ts
-import { existsSync as existsSync32, readdirSync as readdirSync18, readFileSync as readFileSync25, statSync as statSync10 } from "fs";
+import { existsSync as existsSync31, readdirSync as readdirSync17, readFileSync as readFileSync24, statSync as statSync10 } from "fs";
 import { extname as extname4, join as join56, relative as relative13, resolve as resolve49 } from "path";
 var DEFAULT_TREE_LIMIT = 1000, DEFAULT_TEXT_PREVIEW_BYTES, DEFAULT_MEDIA_PREVIEW_BYTES, TEXT_EXTENSIONS, IMAGE_EXTENSIONS, AUDIO_EXTENSIONS, VIDEO_EXTENSIONS, PDF_EXTENSIONS, compareDirectoryEntryName = (left2, right2) => left2.localeCompare(right2, undefined, { numeric: true }), normalizeRelativePath = (value) => {
   const normalized = (value ?? "/").replace(/\\/gu, "/").trim();
@@ -293079,7 +292942,7 @@ var DEFAULT_TREE_LIMIT = 1000, DEFAULT_TEXT_PREVIEW_BYTES, DEFAULT_MEDIA_PREVIEW
   if (!directoryStat.isDirectory()) {
     throw new Error(`skill tree target is not a directory: ${relativePath}`);
   }
-  const entries = readdirSync18(absolutePath, { withFileTypes: true }).sort((left2, right2) => {
+  const entries = readdirSync17(absolutePath, { withFileTypes: true }).sort((left2, right2) => {
     if (left2.isDirectory() !== right2.isDirectory()) {
       return left2.isDirectory() ? -1 : 1;
     }
@@ -293135,7 +292998,7 @@ var DEFAULT_TREE_LIMIT = 1000, DEFAULT_TEXT_PREVIEW_BYTES, DEFAULT_MEDIA_PREVIEW
   const maxBytes = Math.max(1, Math.min(previewKind === "text" ? DEFAULT_TEXT_PREVIEW_BYTES : DEFAULT_MEDIA_PREVIEW_BYTES, input.maxBytes ?? (previewKind === "text" ? DEFAULT_TEXT_PREVIEW_BYTES : DEFAULT_MEDIA_PREVIEW_BYTES)));
   const truncated = sizeBytes > maxBytes;
   if (previewKind === "text") {
-    const buffer = readFileSync25(absolutePath);
+    const buffer = readFileSync24(absolutePath);
     const sliced = truncated ? buffer.subarray(0, maxBytes) : buffer;
     return {
       path: relativePath,
@@ -293167,7 +293030,7 @@ var DEFAULT_TREE_LIMIT = 1000, DEFAULT_TEXT_PREVIEW_BYTES, DEFAULT_MEDIA_PREVIEW
         note: `Preview unavailable because the file exceeds the ${maxBytes}-byte preview limit.`
       };
     }
-    const buffer = readFileSync25(absolutePath);
+    const buffer = readFileSync24(absolutePath);
     return {
       path: relativePath,
       name: relativePath.split("/").filter(Boolean).at(-1) ?? "",
@@ -293539,7 +293402,7 @@ var require_ignore = __commonJS((exports, module) => {
 
 // packages/app-server/src/workspace-path-search.ts
 import { execFileSync as execFileSync2 } from "child_process";
-import { existsSync as existsSync33, readFileSync as readFileSync26, realpathSync as realpathSync8, readdirSync as readdirSync19, statSync as statSync11 } from "fs";
+import { existsSync as existsSync32, readFileSync as readFileSync25, realpathSync as realpathSync8, readdirSync as readdirSync18, statSync as statSync11 } from "fs";
 import { dirname as dirname39, isAbsolute as isAbsolute14, join as join57, relative as relative14, resolve as resolve50, sep as sep4 } from "path";
 
 class WorkspacePathSearchIndex {
@@ -293583,7 +293446,7 @@ class WorkspacePathSearchIndex {
     this.cache.delete(resolve50(cwd));
   }
   getEntries(workspacePath) {
-    if (!existsSync33(workspacePath) || !statSync11(workspacePath).isDirectory()) {
+    if (!existsSync32(workspacePath) || !statSync11(workspacePath).isDirectory()) {
       this.cache.delete(workspacePath);
       return [];
     }
@@ -293720,11 +293583,11 @@ var import_ignore, INDEX_TTL_MS = 30000, isMissingWorkspaceError = (error53) =>
   }).filter((filePath) => filePath.length > 0 && !filePath.startsWith("../"));
 }, loadWorkspaceFilePathsWithRg = (workspacePath) => parseNullSeparatedLines(readCommandOutput("rg", ["--files", "--hidden", "--no-require-git", "-0"], workspacePath)), loadWorkspaceIgnoreFilter = (workspacePath) => {
   const gitignorePath = join57(workspacePath, ".gitignore");
-  if (!existsSync33(gitignorePath)) {
+  if (!existsSync32(gitignorePath)) {
     return null;
   }
   try {
-    const patterns = readFileSync26(gitignorePath, "utf8");
+    const patterns = readFileSync25(gitignorePath, "utf8");
     if (patterns.trim().length === 0) {
       return null;
     }
@@ -293745,7 +293608,7 @@ var import_ignore, INDEX_TTL_MS = 30000, isMissingWorkspaceError = (error53) =>
     }
     let entries;
     try {
-      entries = readdirSync19(current2, { withFileTypes: true });
+      entries = readdirSync18(current2, { withFileTypes: true });
     } catch (error53) {
       if (isMissingWorkspaceError(error53)) {
         continue;
@@ -293842,7 +293705,7 @@ var import_ignore, INDEX_TTL_MS = 30000, isMissingWorkspaceError = (error53) =>
   const normalizedLeafQuery = leafQuery.toLowerCase();
   let entries;
   try {
-    entries = readdirSync19(parentAbsolutePath, { withFileTypes: true });
+    entries = readdirSync18(parentAbsolutePath, { withFileTypes: true });
   } catch (error53) {
     if (isMissingWorkspaceError(error53)) {
       return [];
@@ -293880,7 +293743,7 @@ var init_workspace_path_search = __esm(() => {
 });
 
 // packages/app-server/src/workspace-workbench.ts
-import { existsSync as existsSync34, mkdirSync as mkdirSync35, readdirSync as readdirSync20, readFileSync as readFileSync27, statSync as statSync12, writeFileSync as writeFileSync17 } from "fs";
+import { existsSync as existsSync33, mkdirSync as mkdirSync34, readdirSync as readdirSync19, readFileSync as readFileSync26, statSync as statSync12, writeFileSync as writeFileSync16 } from "fs";
 import { extname as extname5, join as join58, relative as relative15, resolve as resolve51 } from "path";
 var DEFAULT_TREE_LIMIT2 = 1000, DEFAULT_PREVIEW_BYTES, DEFAULT_MEDIA_PREVIEW_BYTES2, TEXT_EXTENSIONS2, IMAGE_EXTENSIONS2, AUDIO_EXTENSIONS2, VIDEO_EXTENSIONS2, toRelativePath = (value) => {
   const normalized = value.replace(/\\/gu, "/").trim();
@@ -293899,7 +293762,7 @@ var DEFAULT_TREE_LIMIT2 = 1000, DEFAULT_PREVIEW_BYTES, DEFAULT_MEDIA_PREVIEW_BYT
 }, resolveWorkbenchRoot = (input) => {
   if (input.mode === "private") {
     const root3 = resolveWorkspaceAvatarPrivateRoot(input.workspacePath, input.avatar);
-    mkdirSync35(root3, { recursive: true });
+    mkdirSync34(root3, { recursive: true });
     return root3;
   }
   return toWorkspaceCwd(input.workspacePath);
@@ -293963,7 +293826,7 @@ var DEFAULT_TREE_LIMIT2 = 1000, DEFAULT_PREVIEW_BYTES, DEFAULT_MEDIA_PREVIEW_BYT
   if (!directoryStat.isDirectory()) {
     throw new Error(`workspace tree target is not a directory: ${relativePath}`);
   }
-  const entries = readdirSync20(absolutePath, { withFileTypes: true }).sort((left2, right2) => {
+  const entries = readdirSync19(absolutePath, { withFileTypes: true }).sort((left2, right2) => {
     if (left2.isDirectory() !== right2.isDirectory()) {
       return left2.isDirectory() ? -1 : 1;
     }
@@ -294033,7 +293896,7 @@ var DEFAULT_TREE_LIMIT2 = 1000, DEFAULT_PREVIEW_BYTES, DEFAULT_MEDIA_PREVIEW_BYT
   }
   const maxBytes = Math.max(1, input.maxBytes ?? DEFAULT_PREVIEW_BYTES);
   if (previewKind === "text") {
-    const raw2 = readFileSync27(absolutePath);
+    const raw2 = readFileSync26(absolutePath);
     const truncated = raw2.byteLength > maxBytes;
     return {
       path: relativePath,
@@ -294050,7 +293913,7 @@ var DEFAULT_TREE_LIMIT2 = 1000, DEFAULT_PREVIEW_BYTES, DEFAULT_MEDIA_PREVIEW_BYT
     };
   }
   if (previewKind === "image" || previewKind === "audio" || previewKind === "video") {
-    const raw2 = readFileSync27(absolutePath);
+    const raw2 = readFileSync26(absolutePath);
     const overLimit = raw2.byteLength > DEFAULT_MEDIA_PREVIEW_BYTES2;
     return {
       path: relativePath,
@@ -294087,25 +293950,25 @@ var DEFAULT_TREE_LIMIT2 = 1000, DEFAULT_PREVIEW_BYTES, DEFAULT_MEDIA_PREVIEW_BYT
   });
   const parentPath = toRelativePath(input.parentPath ?? "/");
   const parentAbsolutePath = ensureInsideRoot2(rootPath, parentPath);
-  mkdirSync35(parentAbsolutePath, { recursive: true });
+  mkdirSync34(parentAbsolutePath, { recursive: true });
   const targetRelativePath = toRelativePath(parentPath === "/" ? input.name : join58(parentPath.slice(1), input.name));
   const targetAbsolutePath = ensureInsideRoot2(rootPath, targetRelativePath);
   if (input.kind === "directory") {
-    mkdirSync35(targetAbsolutePath, { recursive: true });
+    mkdirSync34(targetAbsolutePath, { recursive: true });
   } else {
-    mkdirSync35(resolve51(targetAbsolutePath, ".."), { recursive: true });
-    writeFileSync17(targetAbsolutePath, "", "utf8");
+    mkdirSync34(resolve51(targetAbsolutePath, ".."), { recursive: true });
+    writeFileSync16(targetAbsolutePath, "", "utf8");
   }
   return { path: targetRelativePath };
 }, ensureWorkspacePrivateTextAsset = (input) => {
   const rootPath = resolveWorkspaceAvatarAssetRoot(input.workspacePath, input.avatar, input.assetKind);
-  mkdirSync35(rootPath, { recursive: true });
+  mkdirSync34(rootPath, { recursive: true });
   const relativePath = toRelativePath(input.relativePath);
   if (relativePath === "/") {
     throw new Error("private text asset path must point to a file");
   }
   const absolutePath = ensureInsideRoot2(rootPath, relativePath);
-  if (existsSync34(absolutePath)) {
+  if (existsSync33(absolutePath)) {
     const current2 = statSync12(absolutePath);
     if (current2.isDirectory()) {
       throw new Error(`private text asset path is a directory: ${relativePath}`);
@@ -294113,17 +293976,17 @@ var DEFAULT_TREE_LIMIT2 = 1000, DEFAULT_PREVIEW_BYTES, DEFAULT_MEDIA_PREVIEW_BYT
     return {
       path: relativePath,
       created: false,
-      content: readFileSync27(absolutePath, "utf8"),
+      content: readFileSync26(absolutePath, "utf8"),
       mtimeMs: current2.mtimeMs
     };
   }
-  mkdirSync35(resolve51(absolutePath, ".."), { recursive: true });
-  writeFileSync17(absolutePath, input.seedContent, "utf8");
+  mkdirSync34(resolve51(absolutePath, ".."), { recursive: true });
+  writeFileSync16(absolutePath, input.seedContent, "utf8");
   const created = statSync12(absolutePath);
   return {
     path: relativePath,
     created: true,
-    content: readFileSync27(absolutePath, "utf8"),
+    content: readFileSync26(absolutePath, "utf8"),
     mtimeMs: created.mtimeMs
   };
 };
@@ -294168,7 +294031,7 @@ var init_workspace_workbench = __esm(() => {
 });
 
 // packages/app-server/src/workspaces-store.ts
-import { closeSync as closeSync2, mkdirSync as mkdirSync36, openSync as openSync2, readFileSync as readFileSync28, renameSync as renameSync6, statSync as statSync13, unlinkSync as unlinkSync4, writeFileSync as writeFileSync18 } from "fs";
+import { closeSync as closeSync2, mkdirSync as mkdirSync35, openSync as openSync2, readFileSync as readFileSync27, renameSync as renameSync6, statSync as statSync13, unlinkSync as unlinkSync4, writeFileSync as writeFileSync17 } from "fs";
 import { homedir as homedir23 } from "os";
 import { dirname as dirname40, resolve as resolve52 } from "path";
 
@@ -294305,14 +294168,14 @@ class WorkspacesStore {
     });
   }
   load() {
-    mkdirSync36(dirname40(this.filePath), { recursive: true });
+    mkdirSync35(dirname40(this.filePath), { recursive: true });
     const loaded = this.readFromDisk();
     this.replace(loaded);
     this.flushAtomic(this.doc);
   }
   readFromDisk() {
     try {
-      return parseWorkspaceYaml(readFileSync28(this.filePath, "utf8"));
+      return parseWorkspaceYaml(readFileSync27(this.filePath, "utf8"));
     } catch {
       return emptyDocument();
     }
@@ -294321,14 +294184,14 @@ class WorkspacesStore {
     this.doc = normalizeDocument(next2);
   }
   flushAtomic(doc2) {
-    mkdirSync36(dirname40(this.filePath), { recursive: true });
+    mkdirSync35(dirname40(this.filePath), { recursive: true });
     const tempPath = `${this.filePath}.tmp-${process.pid}-${Date.now()}`;
-    writeFileSync18(tempPath, toYaml3(doc2), "utf8");
+    writeFileSync17(tempPath, toYaml3(doc2), "utf8");
     renameSync6(tempPath, this.filePath);
   }
   withFileLock(run2) {
     const lockPath = `${this.filePath}.lock`;
-    mkdirSync36(dirname40(this.filePath), { recursive: true });
+    mkdirSync35(dirname40(this.filePath), { recursive: true });
     const start2 = Date.now();
     while (true) {
       try {
@@ -294475,11 +294338,11 @@ var init_workspaces_store = __esm(() => {
 // packages/app-server/src/app-kernel.ts
 import {
   accessSync as accessSync2,
-  existsSync as existsSync35,
+  existsSync as existsSync34,
   constants as fsConstants2,
-  mkdirSync as mkdirSync37,
-  readdirSync as readdirSync21,
-  readFileSync as readFileSync29,
+  mkdirSync as mkdirSync36,
+  readdirSync as readdirSync20,
+  readFileSync as readFileSync28,
   statSync as statSync14,
   watch as watch3
 } from "fs";
@@ -294577,15 +294440,15 @@ class AppKernel {
     const homeDir = this.getHomeDir();
     const normalizedWorkspacePath = isGlobalWorkspacePath(workspacePath, homeDir) ? GLOBAL_WORKSPACE_PATH : workspacePath;
     const workspaceCwd = toWorkspaceCwd(normalizedWorkspacePath, homeDir);
-    if (!existsSync35(workspaceCwd)) {
+    if (!existsSync34(workspaceCwd)) {
       return null;
     }
     const agenterRoot = join59(workspaceCwd, ".agenter");
     const avatarRoot = resolveWorkspaceAvatarRoot(normalizedWorkspacePath, homeDir);
-    if (existsSync35(avatarRoot)) {
+    if (existsSync34(avatarRoot)) {
       return avatarRoot;
     }
-    if (existsSync35(agenterRoot)) {
+    if (existsSync34(agenterRoot)) {
       return agenterRoot;
     }
     return workspaceCwd;
@@ -295479,7 +295342,7 @@ class AppKernel {
       archive: resolveWorkspaceAvatarAssetRoot(workspacePath, avatar, "archive", homeDir)
     };
     for (const root3 of [...Object.values(publicRoots), ...Object.values(privateRoots)]) {
-      mkdirSync37(root3, { recursive: true });
+      mkdirSync36(root3, { recursive: true });
     }
     return {
       workspacePath,
@@ -295774,9 +295637,9 @@ class AppKernel {
   }
   ensureRuntimeAvatarRootWorkspace(input) {
     const rootWorkspacePath = resolveGlobalAvatarCanonicalRoot(input.avatarPrincipalId, this.getHomeDir());
-    mkdirSync37(rootWorkspacePath, { recursive: true });
+    mkdirSync36(rootWorkspacePath, { recursive: true });
     for (const directory of ["skills", "memories", "tools", "tmp"]) {
-      mkdirSync37(join59(rootWorkspacePath, directory), { recursive: true });
+      mkdirSync36(join59(rootWorkspacePath, directory), { recursive: true });
     }
     this.workspaceSystem.attachRuntime({
       runtimeId: input.runtimeId,
@@ -295927,7 +295790,7 @@ class AppKernel {
     const includeHidden = input.includeHidden ?? false;
     try {
       accessSync2(root3, fsConstants2.R_OK);
-      const entries = readdirSync21(root3, { withFileTypes: true });
+      const entries = readdirSync20(root3, { withFileTypes: true });
       return entries.filter((entry2) => entry2.isDirectory()).filter((entry2) => includeHidden || !entry2.name.startsWith(".")).map((entry2) => ({
         name: entry2.name,
         path: join59(root3, entry2.name)
@@ -297296,7 +297159,7 @@ class AppKernel {
       return null;
     }
     const dbPath = join59(session.sessionRoot, "session.db");
-    if (!existsSync35(dbPath)) {
+    if (!existsSync34(dbPath)) {
       return null;
     }
     const db = new SessionDb(dbPath);
@@ -297611,7 +297474,7 @@ class AppKernel {
       return createEmptyUsageAnalyticsResult(input);
     }
     const dbPath = resolveUsageAnalyticsDbPathFromAvatarRoot(resolveGlobalAvatarCanonicalRoot(session.avatarPrincipalId, this.getHomeDir()));
-    if (!existsSync35(dbPath)) {
+    if (!existsSync34(dbPath)) {
       return createEmptyUsageAnalyticsResult(input);
     }
     const db = new UsageAnalyticsDb(dbPath);
@@ -297959,7 +297822,7 @@ class AppKernel {
   }
   readChatMessagesFromDb(sessionRoot, sessionId, afterId, limit2) {
     const dbPath = join59(sessionRoot, "session.db");
-    if (!existsSync35(dbPath)) {
+    if (!existsSync34(dbPath)) {
       return [];
     }
     const db = new SessionDb(dbPath);
@@ -297971,7 +297834,7 @@ class AppKernel {
   }
   readChatMessagesPageFromDb(sessionRoot, sessionId, input) {
     const dbPath = join59(sessionRoot, "session.db");
-    if (!existsSync35(dbPath)) {
+    if (!existsSync34(dbPath)) {
       return emptyReversePage();
     }
     const db = new SessionDb(dbPath);
@@ -298010,7 +297873,7 @@ class AppKernel {
       createdAt: Date.parse(commit.createdAt) || Date.now()
     })));
     const dbPath = join59(session.sessionRoot, "session.db");
-    const dispatches = existsSync35(dbPath) ? (() => {
+    const dispatches = existsSync34(dbPath) ? (() => {
       const db = new SessionDb(dbPath);
       try {
         return db.listAttentionDispatches({
@@ -298023,7 +297886,7 @@ class AppKernel {
         db.close();
       }
     })() : [];
-    const receipts = existsSync35(dbPath) ? (() => {
+    const receipts = existsSync34(dbPath) ? (() => {
       const db = new SessionDb(dbPath);
       try {
         return db.listAttentionReceipts({
@@ -298172,7 +298035,7 @@ class AppKernel {
       homeDir: this.getHomeDir()
     });
     const dbPath = join59(session.sessionRoot, "session.db");
-    if (!existsSync35(dbPath)) {
+    if (!existsSync34(dbPath)) {
       return {
         config: {
           providerId: resolved.ai.providerId,
@@ -298236,7 +298099,7 @@ class AppKernel {
   }
   readChatMessagesBeforeFromDb(sessionRoot, sessionId, beforeId, limit2) {
     const dbPath = join59(sessionRoot, "session.db");
-    if (!existsSync35(dbPath)) {
+    if (!existsSync34(dbPath)) {
       return [];
     }
     const db = new SessionDb(dbPath);
@@ -298248,7 +298111,7 @@ class AppKernel {
   }
   readChatCyclesFromDb(sessionRoot, sessionId, limit2) {
     const dbPath = join59(sessionRoot, "session.db");
-    if (!existsSync35(dbPath)) {
+    if (!existsSync34(dbPath)) {
       return [];
     }
     const db = new SessionDb(dbPath);
@@ -298260,7 +298123,7 @@ class AppKernel {
   }
   readChatCyclesPageFromDb(sessionRoot, sessionId, input) {
     const dbPath = join59(sessionRoot, "session.db");
-    if (!existsSync35(dbPath)) {
+    if (!existsSync34(dbPath)) {
       return emptyReversePage();
     }
     const db = new SessionDb(dbPath);
@@ -298277,7 +298140,7 @@ class AppKernel {
   }
   readChatCyclesBeforeFromDb(sessionRoot, sessionId, beforeCycleId, limit2) {
     const dbPath = join59(sessionRoot, "session.db");
-    if (!existsSync35(dbPath)) {
+    if (!existsSync34(dbPath)) {
       return [];
     }
     const db = new SessionDb(dbPath);
@@ -298314,7 +298177,7 @@ class AppKernel {
   }
   readModelCallsPageFromDb(sessionRoot, input) {
     const dbPath = join59(sessionRoot, "session.db");
-    if (!existsSync35(dbPath)) {
+    if (!existsSync34(dbPath)) {
       return emptyReversePage();
     }
     const db = new SessionDb(dbPath);
@@ -298331,7 +298194,7 @@ class AppKernel {
   }
   readRequestAuxPageFromDb(sessionRoot, input) {
     const dbPath = join59(sessionRoot, "session.db");
-    if (!existsSync35(dbPath)) {
+    if (!existsSync34(dbPath)) {
       return emptyReversePage();
     }
     const db = new SessionDb(dbPath);
@@ -298343,7 +298206,7 @@ class AppKernel {
   }
   readHeartbeatPartsPageFromDb(sessionRoot, input) {
     const dbPath = join59(sessionRoot, "session.db");
-    if (!existsSync35(dbPath)) {
+    if (!existsSync34(dbPath)) {
       return emptyReversePage();
     }
     const db = new SessionDb(dbPath);
@@ -298355,7 +298218,7 @@ class AppKernel {
   }
   readHeartbeatGroupsPageFromDb(sessionRoot, input) {
     const dbPath = join59(sessionRoot, "session.db");
-    if (!existsSync35(dbPath)) {
+    if (!existsSync34(dbPath)) {
       return emptyReversePage();
     }
     const db = new SessionDb(dbPath);
@@ -298367,7 +298230,7 @@ class AppKernel {
   }
   readApiCallsPageFromDb(sessionRoot, input) {
     const dbPath = join59(sessionRoot, "session.db");
-    if (!existsSync35(dbPath)) {
+    if (!existsSync34(dbPath)) {
       return emptyReversePage();
     }
     const db = new SessionDb(dbPath);
@@ -298618,11 +298481,11 @@ var now3 = () => Date.now(), clonePromptWindowMessages2 = (messages3) => structu
   };
 }, resolveWorkspaceGroup = (workspacePath) => {
   const gitConfigPath = join59(workspacePath, ".git", "config");
-  if (!existsSync35(gitConfigPath)) {
+  if (!existsSync34(gitConfigPath)) {
     return "Other";
   }
   try {
-    const lines = readFileSync29(gitConfigPath, "utf8").split(/\r?\n/);
+    const lines = readFileSync28(gitConfigPath, "utf8").split(/\r?\n/);
     let inOriginRemote = false;
     let userName = null;
     for (const line of lines) {
@@ -298787,7 +298650,7 @@ var now3 = () => Date.now(), clonePromptWindowMessages2 = (messages3) => structu
 }, resolveDefaultAuthServiceDataDir = (stateRoot) => {
   const canonical = join59(stateRoot, "auth-service");
   const legacy = join59(stateRoot, "profile-service");
-  return !existsSync35(canonical) && existsSync35(legacy) ? legacy : canonical;
+  return !existsSync34(canonical) && existsSync34(legacy) ? legacy : canonical;
 };
 var init_app_kernel = __esm(() => {
   init_src9();
@@ -301322,7 +301185,7 @@ var exports_trpc_server = {};
 __export(exports_trpc_server, {
   startTrpcServer: () => startTrpcServer
 });
-import { createReadStream as createReadStream2, existsSync as existsSync36 } from "fs";
+import { createReadStream as createReadStream2, existsSync as existsSync35 } from "fs";
 import { createServer as createServer2 } from "http";
 import { extname as extname6, join as join60, normalize as normalize6, resolve as resolve54 } from "path";
 import { Readable as Readable3 } from "stream";
@@ -301335,7 +301198,7 @@ var MIME_BY_EXT, MEDIA_AUTH_TOKEN_QUERY_KEY = "authToken", STATIC_ENTRY_FILENAME
 }, resolveStaticEntryDocumentPath = (staticDir) => {
   for (const filename of STATIC_ENTRY_FILENAMES) {
     const filePath = join60(staticDir, filename);
-    if (existsSync36(filePath)) {
+    if (existsSync35(filePath)) {
       return filePath;
     }
   }
@@ -301454,11 +301317,11 @@ var MIME_BY_EXT, MEDIA_AUTH_TOKEN_QUERY_KEY = "authToken", STATIC_ENTRY_FILENAME
     return;
   }
   let targetPath = resolvedPath;
-  if (!existsSync36(targetPath)) {
+  if (!existsSync35(targetPath)) {
     const fallback200 = join60(staticDir, "200.html");
-    targetPath = existsSync36(fallback200) ? fallback200 : entryDocumentPath ?? join60(staticDir, "index.html");
+    targetPath = existsSync35(fallback200) ? fallback200 : entryDocumentPath ?? join60(staticDir, "index.html");
   }
-  if (!existsSync36(targetPath)) {
+  if (!existsSync35(targetPath)) {
     res.statusCode = 404;
     res.end("web assets not found");
     return;
@@ -307803,7 +307666,7 @@ import { mkdir as mkdir10, writeFile as writeFileNode } from "fs/promises";
 import { dirname as dirname41, isAbsolute as isAbsolute15, resolve as resolve55 } from "path";
 import { fileURLToPath as fileURLToPath12 } from "url";
 import { resolve as resolve210, isAbsolute as isAbsolute22, parse as parse10 } from "path";
-import { existsSync as existsSync37 } from "fs";
+import { existsSync as existsSync36 } from "fs";
 import { basename as basename15, join as join61 } from "path";
 import os5 from "os";
 import path6 from "path";
@@ -307816,7 +307679,7 @@ import * as path32 from "path";
 import { readdir as readdir2 } from "fs/promises";
 import { createRequire as createRequire4 } from "module";
 import { fileURLToPath as fileURLToPath22 } from "url";
-import { existsSync as existsSync210, writeFileSync as writeFileSync19 } from "fs";
+import { existsSync as existsSync210, writeFileSync as writeFileSync18 } from "fs";
 import { EventEmitter as EventEmitter4 } from "events";
 import { EventEmitter as EventEmitter5 } from "events";
 import util from "util";
@@ -315322,7 +315185,7 @@ function convertToDebugSymbols(symbols3) {
   if (env3.OTUI_DEBUG_FFI && globalFFILogPath) {
     const logPath = globalFFILogPath;
     const writeSync = (msg) => {
-      writeFileSync19(logPath, msg + `
+      writeFileSync18(logPath, msg + `
 `, { flag: "a" });
     };
     Object.entries(symbols3).forEach(([key, value]) => {
@@ -323719,7 +323582,7 @@ var init_index_t4yn324k = __esm(async () => {
         return this.options.workerPath;
       }
       let workerPath = new URL("./parser.worker.js", import.meta.url).href;
-      if (!existsSync37(resolve210(import.meta.dirname, "parser.worker.js"))) {
+      if (!existsSync36(resolve210(import.meta.dirname, "parser.worker.js"))) {
         workerPath = new URL("./parser.worker.ts", import.meta.url).href;
       }
       return workerPath;
@@ -343958,7 +343821,7 @@ var import_reflect_metadata2 = __toESM(require_Reflect(), 1);
 
 // packages/cli/src/run-cli.ts
 import { spawn as spawnChildProcess } from "child_process";
-import { closeSync as closeSync3, existsSync as existsSync38, mkdirSync as mkdirSync38, openSync as openSync3, readFileSync as readFileSync30 } from "fs";
+import { closeSync as closeSync3, existsSync as existsSync37, mkdirSync as mkdirSync37, openSync as openSync3, readFileSync as readFileSync29 } from "fs";
 import { createRequire as createRequire5 } from "module";
 import { request as httpRequest2 } from "http";
 import { request as httpsRequest } from "https";
@@ -349114,7 +348977,7 @@ var resolveDaemonHealthLabel = (args) => `http://${args.host}:${args.port}/healt
 var resolveCliEntryPath = () => resolve57(import.meta.dir, "bin", "agenter.ts");
 var resolveCurrentCliEntrypointArgv = () => {
   const entrypoint = process.argv[1];
-  if (entrypoint && existsSync38(entrypoint)) {
+  if (entrypoint && existsSync37(entrypoint)) {
     return [entrypoint];
   }
   return ["run", resolveCliEntryPath()];
@@ -349127,7 +348990,7 @@ var resolveBundledAssetPath2 = (...segments) => {
     return;
   }
   const path7 = join64(root3, ...segments);
-  return existsSync38(path7) ? path7 : undefined;
+  return existsSync37(path7) ? path7 : undefined;
 };
 var isHttpHealthAlive = async (urlString, timeoutMs = HEALTH_REQUEST_TIMEOUT_MS) => {
   const url2 = new URL(urlString);
@@ -349196,7 +349059,7 @@ var buildDaemonServeArgv = (args) => {
 };
 var readLogTail = (path7, maxBytes = 16384) => {
   try {
-    const text4 = readFileSync30(path7, "utf8");
+    const text4 = readFileSync29(path7, "utf8");
     return text4.length > maxBytes ? text4.slice(-maxBytes) : text4;
   } catch {
     return "";
@@ -349204,7 +349067,7 @@ var readLogTail = (path7, maxBytes = 16384) => {
 };
 var spawnManagedDaemonProcess = (args) => {
   const logPath = resolveDaemonLogPath(resolveLauncherHomeDir(), args);
-  mkdirSync38(dirname44(logPath), { recursive: true });
+  mkdirSync37(dirname44(logPath), { recursive: true });
   const logFd = openSync3(logPath, "a");
   const child = (() => {
     try {