dorkos 0.9.0 → 0.10.0

package/dist/server/index.js

@@ -9504,11 +9504,11 @@ var require_mime_types = __commonJS({
       }
       return exts[0];
     }
-    function lookup(path29) {
-      if (!path29 || typeof path29 !== "string") {
+    function lookup(path30) {
+      if (!path30 || typeof path30 !== "string") {
         return false;
       }
-      var extension2 = extname2("x." + path29).toLowerCase().substr(1);
+      var extension2 = extname2("x." + path30).toLowerCase().substr(1);
       if (!extension2) {
         return false;
       }
@@ -10017,19 +10017,19 @@ var require_utils = __commonJS({
       if (decode)
         return decode(data, hint);
     }
-    function basename4(path29) {
-      if (typeof path29 !== "string")
+    function basename4(path30) {
+      if (typeof path30 !== "string")
         return "";
-      for (let i2 = path29.length - 1; i2 >= 0; --i2) {
-        switch (path29.charCodeAt(i2)) {
+      for (let i2 = path30.length - 1; i2 >= 0; --i2) {
+        switch (path30.charCodeAt(i2)) {
           case 47:
           // '/'
           case 92:
-            path29 = path29.slice(i2 + 1);
-            return path29 === ".." || path29 === "." ? "" : path29;
+            path30 = path30.slice(i2 + 1);
+            return path30 === ".." || path30 === "." ? "" : path30;
         }
       }
-      return path29 === ".." || path29 === "." ? "" : path29;
+      return path30 === ".." || path30 === "." ? "" : path30;
     }
     var TOKEN = [
       0,
@@ -13874,7 +13874,7 @@ var require_disk = __commonJS({
   "../../node_modules/.pnpm/multer@2.1.1/node_modules/multer/storage/disk.js"(exports, module) {
     var fs20 = __require("fs");
     var os7 = __require("os");
-    var path29 = __require("path");
+    var path30 = __require("path");
     var crypto7 = __require("crypto");
     function getFilename(req, file, cb) {
       crypto7.randomBytes(16, function(err, raw) {
@@ -13901,7 +13901,7 @@ var require_disk = __commonJS({
         if (err) return cb(err);
         that.getFilename(req, file, function(err2, filename) {
           if (err2) return cb(err2);
-          var finalPath = path29.join(destination, filename);
+          var finalPath = path30.join(destination, filename);
           var outStream = fs20.createWriteStream(finalPath);
           file.stream.pipe(outStream);
           outStream.on("error", cb);
@@ -13917,11 +13917,11 @@ var require_disk = __commonJS({
       });
     };
     DiskStorage.prototype._removeFile = function _removeFile(req, file, cb) {
-      var path30 = file.path;
+      var path31 = file.path;
       delete file.destination;
       delete file.filename;
       delete file.path;
-      fs20.unlink(path30, cb);
+      fs20.unlink(path31, cb);
     };
     module.exports = function(opts) {
       return new DiskStorage(opts);
@@ -22440,14 +22440,14 @@ var require_url_state_machine = __commonJS({
       return url.replace(/\u0009|\u000A|\u000D/g, "");
     }
     function shortenPath(url) {
-      const path29 = url.path;
-      if (path29.length === 0) {
+      const path30 = url.path;
+      if (path30.length === 0) {
         return;
       }
-      if (url.scheme === "file" && path29.length === 1 && isNormalizedWindowsDriveLetter(path29[0])) {
+      if (url.scheme === "file" && path30.length === 1 && isNormalizedWindowsDriveLetter(path30[0])) {
         return;
       }
-      path29.pop();
+      path30.pop();
     }
     function includesCredentials(url) {
       return url.username !== "" || url.password !== "";
@@ -35879,8 +35879,8 @@ var require_utils3 = __commonJS({
       }
       return ind;
     }
-    function removeDotSegments(path29) {
-      let input = path29;
+    function removeDotSegments(path30) {
+      let input = path30;
       const output = [];
       let nextSlash = -1;
       let len = 0;
@@ -36079,8 +36079,8 @@ var require_schemes = __commonJS({
         wsComponent.secure = void 0;
       }
       if (wsComponent.resourceName) {
-        const [path29, query2] = wsComponent.resourceName.split("?");
-        wsComponent.path = path29 && path29 !== "/" ? path29 : void 0;
+        const [path30, query2] = wsComponent.resourceName.split("?");
+        wsComponent.path = path30 && path30 !== "/" ? path30 : void 0;
         wsComponent.query = query2;
         wsComponent.resourceName = void 0;
       }
@@ -39456,12 +39456,12 @@ var require_dist = __commonJS({
 });
 
 // ../../apps/server/src/index.ts
-import path28 from "path";
+import path29 from "path";
 
 // ../../apps/server/src/app.ts
 import express from "express";
 import cors from "cors";
-import path8 from "path";
+import path9 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { apiReference } from "@scalar/express-api-reference";
 
@@ -39823,7 +39823,9 @@ var HealthResponseSchema = z.object({
 }).openapi("HealthResponse");
 var ServerConfigSchema = z.object({
   version: z.string().openapi({ description: "Current server version" }),
-  latestVersion: z.string().nullable().openapi({ description: "Latest available version from npm, or null if unknown" }),
+  latestVersion: z.string().nullable().openapi({ description: "Latest available version from npm, or null if dev mode or unknown" }),
+  isDevMode: z.boolean().openapi({ description: "Whether the server is running a development build" }),
+  dismissedUpgradeVersions: z.array(z.string()).openapi({ description: "Versions the user has dismissed upgrade notifications for" }),
   port: z.number().int(),
   uptime: z.number(),
   workingDirectory: z.string(),
@@ -40105,7 +40107,7 @@ var serverEnvSchema = z3.object({
   DORKOS_BOUNDARY: z3.string().optional(),
   DORKOS_LOG_LEVEL: z3.coerce.number().int().min(0).max(5).optional(),
   DORK_HOME: z3.string().optional(),
-  DORKOS_VERSION: z3.string().optional(),
+  DORKOS_VERSION_OVERRIDE: z3.string().optional(),
   CLIENT_DIST_PATH: z3.string().optional(),
   // MCP external server — optional API key for authenticated access
   MCP_API_KEY: z3.string().optional(),
@@ -41700,7 +41702,20 @@ var TunnelManager = class extends EventEmitter {
 var tunnelManager = new TunnelManager();
 
 // ../../apps/server/src/lib/version.ts
-var SERVER_VERSION = true ? "0.9.0" : createRequire(import.meta.url)("../../package.json").version;
+import { createRequire } from "module";
+var DEV_VERSION_PATTERN = /^0\.0\.0/;
+var SERVER_VERSION = resolveVersion();
+var IS_DEV_BUILD = checkDevBuild(SERVER_VERSION);
+function resolveVersion() {
+  if (env.DORKOS_VERSION_OVERRIDE) return env.DORKOS_VERSION_OVERRIDE;
+  if (true) return "0.10.0";
+  return createRequire(import.meta.url)("../../package.json").version;
+}
+function checkDevBuild(version2) {
+  if (env.DORKOS_VERSION_OVERRIDE) return false;
+  if (true) return false;
+  return DEV_VERSION_PATTERN.test(version2);
+}
 
 // ../../apps/server/src/routes/health.ts
 var router3 = Router3();
@@ -41838,8 +41853,9 @@ var UserConfigSchema = z5.object({
     auth: z5.string().nullable().default(null)
   }).default(() => ({ enabled: false, domain: null, authtoken: null, auth: null })),
   ui: z5.object({
-    theme: z5.enum(["light", "dark", "system"]).default("system")
-  }).default(() => ({ theme: "system" })),
+    theme: z5.enum(["light", "dark", "system"]).default("system"),
+    dismissedUpgradeVersions: z5.array(z5.string()).default(() => []).describe("Version strings the user has dismissed upgrade notifications for")
+  }).default(() => ({ theme: "system", dismissedUpgradeVersions: [] })),
   logging: LoggingConfigSchema.default(() => ({ level: "info", maxLogSizeKb: 500, maxLogFiles: 14 })),
   relay: z5.object({
     enabled: z5.boolean().default(true),
@@ -42004,6 +42020,7 @@ var FETCH_TIMEOUT = 5e3;
 var cachedLatest = null;
 var lastChecked = 0;
 async function getLatestVersion() {
+  if (IS_DEV_BUILD) return null;
   if (Date.now() - lastChecked < CACHE_TTL) return cachedLatest;
   try {
     const controller = new AbortController();
@@ -42077,6 +42094,8 @@ router5.get("/", async (_req, res) => {
   res.json({
     version: SERVER_VERSION,
     latestVersion,
+    isDevMode: IS_DEV_BUILD,
+    dismissedUpgradeVersions: configManager.get("ui")?.dismissedUpgradeVersions ?? [],
     port: env.DORKOS_PORT,
     uptime: process.uptime(),
     workingDirectory: process.cwd(),
@@ -42535,6 +42554,7 @@ var capabilities_default = router10;
 
 // ../../apps/server/src/routes/uploads.ts
 var import_multer2 = __toESM(require_multer(), 1);
+import path8 from "path";
 import { Router as Router11 } from "express";
 
 // ../../apps/server/src/services/core/upload-handler.ts
@@ -42629,6 +42649,33 @@ router11.post("/", async (req, res) => {
     throw err;
   }
 });
+router11.get("/:filename", async (req, res) => {
+  try {
+    const cwd = req.query.cwd;
+    if (!cwd || typeof cwd !== "string") {
+      return res.status(400).json({ error: "Missing required parameter: cwd" });
+    }
+    const validatedCwd = await validateBoundary(cwd);
+    const filename = path8.basename(req.params.filename);
+    const filePath = path8.join(uploadHandler.getUploadDir(validatedCwd), filename);
+    const resolvedPath = path8.resolve(filePath);
+    const uploadDir = path8.resolve(uploadHandler.getUploadDir(validatedCwd));
+    if (!resolvedPath.startsWith(uploadDir + path8.sep) && resolvedPath !== uploadDir) {
+      return res.status(403).json({ error: "Access denied" });
+    }
+    res.sendFile(resolvedPath, (err) => {
+      if (err && !res.headersSent) {
+        const status = err.code === "ENOENT" ? 404 : 500;
+        res.status(status).json({ error: status === 404 ? "File not found" : "Internal error" });
+      }
+    });
+  } catch (err) {
+    if (err instanceof BoundaryError) {
+      return res.status(403).json({ error: err.message, code: err.code });
+    }
+    throw err;
+  }
+});
 var uploads_default = router11;
 
 // ../../apps/server/src/services/core/openapi-registry.ts
@@ -44108,7 +44155,7 @@ function requestLogger(req, res, next) {
 }
 
 // ../../apps/server/src/app.ts
-var __dirname = path8.dirname(fileURLToPath2(import.meta.url));
+var __dirname = path9.dirname(fileURLToPath2(import.meta.url));
 function buildCorsOrigin() {
   const envOrigin = process.env.DORKOS_CORS_ORIGIN;
   if (envOrigin === "*") return "*";
@@ -44161,10 +44208,10 @@ function finalizeApp(app) {
   });
   app.use(errorHandler);
   if (env.NODE_ENV === "production") {
-    const distPath = env.CLIENT_DIST_PATH ?? path8.join(__dirname, "../../client/dist");
+    const distPath = env.CLIENT_DIST_PATH ?? path9.join(__dirname, "../../client/dist");
     app.use(express.static(distPath));
     app.get("*", (_req, res) => {
-      res.sendFile(path8.join(distPath, "index.html"));
+      res.sendFile(path9.join(distPath, "index.html"));
     });
   }
 }
@@ -44255,7 +44302,7 @@ var SessionLockManager = class {
 
 // ../../apps/server/src/services/runtimes/claude-code/transcript-reader.ts
 import fs7 from "fs/promises";
-import path9 from "path";
+import path10 from "path";
 import os2 from "os";
 
 // ../../apps/server/src/services/runtimes/claude-code/transcript-parser.ts
@@ -44570,7 +44617,7 @@ var TranscriptReader = class {
   /** Resolve the SDK transcripts directory for a given vault root. */
   getTranscriptsDir(vaultRoot2) {
     const slug = this.getProjectSlug(vaultRoot2);
-    return path9.join(os2.homedir(), ".claude", "projects", slug);
+    return path10.join(os2.homedir(), ".claude", "projects", slug);
   }
   /**
    * List all sessions by scanning SDK JSONL transcript files.
@@ -44588,7 +44635,7 @@ var TranscriptReader = class {
     const sessions = [];
     for (const file of files) {
       const sessionId = file.replace(".jsonl", "");
-      const filePath = path9.join(transcriptsDir, file);
+      const filePath = path10.join(transcriptsDir, file);
       try {
         const fileStat = await fs7.stat(filePath);
         const cached = this.metaCache.get(sessionId);
@@ -44611,7 +44658,7 @@ var TranscriptReader = class {
    */
   async getSession(vaultRoot2, sessionId) {
     await validateBoundary(vaultRoot2);
-    const filePath = path9.join(this.getTranscriptsDir(vaultRoot2), `${sessionId}.jsonl`);
+    const filePath = path10.join(this.getTranscriptsDir(vaultRoot2), `${sessionId}.jsonl`);
     try {
       const session = await this.extractSessionMeta(filePath, sessionId);
       const tailStatus = await this.readTailStatus(filePath);
@@ -44767,7 +44814,7 @@ var TranscriptReader = class {
   async readTranscript(vaultRoot2, sessionId) {
     await validateBoundary(vaultRoot2);
     const transcriptsDir = this.getTranscriptsDir(vaultRoot2);
-    const filePath = path9.join(transcriptsDir, `${sessionId}.jsonl`);
+    const filePath = path10.join(transcriptsDir, `${sessionId}.jsonl`);
     let content;
     try {
       content = await fs7.readFile(filePath, "utf-8");
@@ -44793,7 +44840,7 @@ var TranscriptReader = class {
   /** Get an ETag for a session transcript (mtime + size) for HTTP caching. */
   async getTranscriptETag(vaultRoot2, sessionId) {
     await validateBoundary(vaultRoot2);
-    const filePath = path9.join(this.getTranscriptsDir(vaultRoot2), `${sessionId}.jsonl`);
+    const filePath = path10.join(this.getTranscriptsDir(vaultRoot2), `${sessionId}.jsonl`);
     try {
       const stat5 = await fs7.stat(filePath);
       return `"${stat5.mtimeMs}-${stat5.size}"`;
@@ -44808,7 +44855,7 @@ var TranscriptReader = class {
   async readTasks(vaultRoot2, sessionId) {
     await validateBoundary(vaultRoot2);
     const transcriptsDir = this.getTranscriptsDir(vaultRoot2);
-    const filePath = path9.join(transcriptsDir, `${sessionId}.jsonl`);
+    const filePath = path10.join(transcriptsDir, `${sessionId}.jsonl`);
     let content;
     try {
       content = await fs7.readFile(filePath, "utf-8");
@@ -44824,7 +44871,7 @@ var TranscriptReader = class {
    */
   async readFromOffset(vaultRoot2, sessionId, fromOffset) {
     await validateBoundary(vaultRoot2);
-    const filePath = path9.join(this.getTranscriptsDir(vaultRoot2), `${sessionId}.jsonl`);
+    const filePath = path10.join(this.getTranscriptsDir(vaultRoot2), `${sessionId}.jsonl`);
     const stat5 = await fs7.stat(filePath);
     if (stat5.size <= fromOffset) {
       return { content: "", newOffset: fromOffset };
@@ -44920,7 +44967,7 @@ var ReaddirpStream = class extends Readable {
     this._directoryFilter = normalizeFilter(opts.directoryFilter);
     const statMethod = opts.lstat ? lstat : stat;
     if (wantBigintFsStats) {
-      this._stat = (path29) => statMethod(path29, { bigint: true });
+      this._stat = (path30) => statMethod(path30, { bigint: true });
     } else {
       this._stat = statMethod;
     }
@@ -44945,8 +44992,8 @@ var ReaddirpStream = class extends Readable {
         const par = this.parent;
         const fil = par && par.files;
         if (fil && fil.length > 0) {
-          const { path: path29, depth } = par;
-          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path29));
+          const { path: path30, depth } = par;
+          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path30));
           const awaited = await Promise.all(slice);
           for (const entry of awaited) {
             if (!entry)
@@ -44986,20 +45033,20 @@ var ReaddirpStream = class extends Readable {
       this.reading = false;
     }
   }
-  async _exploreDir(path29, depth) {
+  async _exploreDir(path30, depth) {
     let files;
     try {
-      files = await readdir(path29, this._rdOptions);
+      files = await readdir(path30, this._rdOptions);
     } catch (error) {
       this._onError(error);
     }
-    return { files, depth, path: path29 };
+    return { files, depth, path: path30 };
   }
-  async _formatEntry(dirent, path29) {
+  async _formatEntry(dirent, path30) {
     let entry;
     const basename4 = this._isDirent ? dirent.name : dirent;
     try {
-      const fullPath = presolve(pjoin(path29, basename4));
+      const fullPath = presolve(pjoin(path30, basename4));
       entry = { path: prelative(this._root, fullPath), fullPath, basename: basename4 };
       entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
     } catch (err) {
@@ -45399,16 +45446,16 @@ var delFromSet = (main, prop, item) => {
 };
 var isEmptySet = (val) => val instanceof Set ? val.size === 0 : !val;
 var FsWatchInstances = /* @__PURE__ */ new Map();
-function createFsWatchInstance(path29, options, listener, errHandler, emitRaw) {
+function createFsWatchInstance(path30, options, listener, errHandler, emitRaw) {
   const handleEvent = (rawEvent, evPath) => {
-    listener(path29);
-    emitRaw(rawEvent, evPath, { watchedPath: path29 });
-    if (evPath && path29 !== evPath) {
-      fsWatchBroadcast(sysPath.resolve(path29, evPath), KEY_LISTENERS, sysPath.join(path29, evPath));
+    listener(path30);
+    emitRaw(rawEvent, evPath, { watchedPath: path30 });
+    if (evPath && path30 !== evPath) {
+      fsWatchBroadcast(sysPath.resolve(path30, evPath), KEY_LISTENERS, sysPath.join(path30, evPath));
     }
   };
   try {
-    return fs_watch(path29, {
+    return fs_watch(path30, {
       persistent: options.persistent
     }, handleEvent);
   } catch (error) {
@@ -45424,12 +45471,12 @@ var fsWatchBroadcast = (fullPath, listenerType, val1, val2, val3) => {
     listener(val1, val2, val3);
   });
 };
-var setFsWatchListener = (path29, fullPath, options, handlers) => {
+var setFsWatchListener = (path30, fullPath, options, handlers) => {
   const { listener, errHandler, rawEmitter } = handlers;
   let cont = FsWatchInstances.get(fullPath);
   let watcher;
   if (!options.persistent) {
-    watcher = createFsWatchInstance(path29, options, listener, errHandler, rawEmitter);
+    watcher = createFsWatchInstance(path30, options, listener, errHandler, rawEmitter);
     if (!watcher)
       return;
     return watcher.close.bind(watcher);
@@ -45440,7 +45487,7 @@ var setFsWatchListener = (path29, fullPath, options, handlers) => {
     addAndConvert(cont, KEY_RAW, rawEmitter);
   } else {
     watcher = createFsWatchInstance(
-      path29,
+      path30,
       options,
       fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS),
       errHandler,
@@ -45455,7 +45502,7 @@ var setFsWatchListener = (path29, fullPath, options, handlers) => {
         cont.watcherUnusable = true;
       if (isWindows2 && error.code === "EPERM") {
         try {
-          const fd = await open(path29, "r");
+          const fd = await open(path30, "r");
           await fd.close();
           broadcastErr(error);
         } catch (err) {
@@ -45486,7 +45533,7 @@ var setFsWatchListener = (path29, fullPath, options, handlers) => {
   };
 };
 var FsWatchFileInstances = /* @__PURE__ */ new Map();
-var setFsWatchFileListener = (path29, fullPath, options, handlers) => {
+var setFsWatchFileListener = (path30, fullPath, options, handlers) => {
   const { listener, rawEmitter } = handlers;
   let cont = FsWatchFileInstances.get(fullPath);
   const copts = cont && cont.options;
@@ -45508,7 +45555,7 @@ var setFsWatchFileListener = (path29, fullPath, options, handlers) => {
         });
         const currmtime = curr.mtimeMs;
         if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) {
-          foreach(cont.listeners, (listener2) => listener2(path29, curr));
+          foreach(cont.listeners, (listener2) => listener2(path30, curr));
         }
       })
     };
@@ -45536,13 +45583,13 @@ var NodeFsHandler = class {
    * @param listener on fs change
    * @returns closer for the watcher instance
    */
-  _watchWithNodeFs(path29, listener) {
+  _watchWithNodeFs(path30, listener) {
     const opts = this.fsw.options;
-    const directory = sysPath.dirname(path29);
-    const basename4 = sysPath.basename(path29);
+    const directory = sysPath.dirname(path30);
+    const basename4 = sysPath.basename(path30);
     const parent = this.fsw._getWatchedDir(directory);
     parent.add(basename4);
-    const absolutePath = sysPath.resolve(path29);
+    const absolutePath = sysPath.resolve(path30);
     const options = {
       persistent: opts.persistent
     };
@@ -45552,12 +45599,12 @@ var NodeFsHandler = class {
     if (opts.usePolling) {
       const enableBin = opts.interval !== opts.binaryInterval;
       options.interval = enableBin && isBinaryPath(basename4) ? opts.binaryInterval : opts.interval;
-      closer = setFsWatchFileListener(path29, absolutePath, options, {
+      closer = setFsWatchFileListener(path30, absolutePath, options, {
         listener,
         rawEmitter: this.fsw._emitRaw
       });
     } else {
-      closer = setFsWatchListener(path29, absolutePath, options, {
+      closer = setFsWatchListener(path30, absolutePath, options, {
         listener,
         errHandler: this._boundHandleError,
         rawEmitter: this.fsw._emitRaw
@@ -45579,7 +45626,7 @@ var NodeFsHandler = class {
     let prevStats = stats;
     if (parent.has(basename4))
       return;
-    const listener = async (path29, newStats) => {
+    const listener = async (path30, newStats) => {
       if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file, 5))
         return;
       if (!newStats || newStats.mtimeMs === 0) {
@@ -45593,11 +45640,11 @@ var NodeFsHandler = class {
             this.fsw._emit(EV.CHANGE, file, newStats2);
           }
           if ((isMacos || isLinux || isFreeBSD) && prevStats.ino !== newStats2.ino) {
-            this.fsw._closeFile(path29);
+            this.fsw._closeFile(path30);
             prevStats = newStats2;
             const closer2 = this._watchWithNodeFs(file, listener);
             if (closer2)
-              this.fsw._addPathCloser(path29, closer2);
+              this.fsw._addPathCloser(path30, closer2);
           } else {
             prevStats = newStats2;
           }
@@ -45629,7 +45676,7 @@ var NodeFsHandler = class {
    * @param item basename of this item
    * @returns true if no more processing is needed for this entry.
    */
-  async _handleSymlink(entry, directory, path29, item) {
+  async _handleSymlink(entry, directory, path30, item) {
     if (this.fsw.closed) {
       return;
     }
@@ -45639,7 +45686,7 @@ var NodeFsHandler = class {
       this.fsw._incrReadyCount();
       let linkPath;
       try {
-        linkPath = await fsrealpath(path29);
+        linkPath = await fsrealpath(path30);
       } catch (e2) {
         this.fsw._emitReady();
         return true;
@@ -45649,12 +45696,12 @@ var NodeFsHandler = class {
       if (dir.has(item)) {
         if (this.fsw._symlinkPaths.get(full) !== linkPath) {
           this.fsw._symlinkPaths.set(full, linkPath);
-          this.fsw._emit(EV.CHANGE, path29, entry.stats);
+          this.fsw._emit(EV.CHANGE, path30, entry.stats);
         }
       } else {
         dir.add(item);
         this.fsw._symlinkPaths.set(full, linkPath);
-        this.fsw._emit(EV.ADD, path29, entry.stats);
+        this.fsw._emit(EV.ADD, path30, entry.stats);
       }
       this.fsw._emitReady();
       return true;
@@ -45683,9 +45730,9 @@ var NodeFsHandler = class {
         return;
       }
       const item = entry.path;
-      let path29 = sysPath.join(directory, item);
+      let path30 = sysPath.join(directory, item);
       current.add(item);
-      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path29, item)) {
+      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path30, item)) {
         return;
       }
       if (this.fsw.closed) {
@@ -45694,8 +45741,8 @@ var NodeFsHandler = class {
       }
       if (item === target || !target && !previous.has(item)) {
         this.fsw._incrReadyCount();
-        path29 = sysPath.join(dir, sysPath.relative(dir, path29));
-        this._addToNodeFs(path29, initialAdd, wh, depth + 1);
+        path30 = sysPath.join(dir, sysPath.relative(dir, path30));
+        this._addToNodeFs(path30, initialAdd, wh, depth + 1);
       }
     }).on(EV.ERROR, this._boundHandleError);
     return new Promise((resolve4, reject) => {
@@ -45764,13 +45811,13 @@ var NodeFsHandler = class {
    * @param depth Child path actually targeted for watch
    * @param target Child path actually targeted for watch
    */
-  async _addToNodeFs(path29, initialAdd, priorWh, depth, target) {
+  async _addToNodeFs(path30, initialAdd, priorWh, depth, target) {
     const ready = this.fsw._emitReady;
-    if (this.fsw._isIgnored(path29) || this.fsw.closed) {
+    if (this.fsw._isIgnored(path30) || this.fsw.closed) {
       ready();
       return false;
     }
-    const wh = this.fsw._getWatchHelpers(path29);
+    const wh = this.fsw._getWatchHelpers(path30);
     if (priorWh) {
       wh.filterPath = (entry) => priorWh.filterPath(entry);
       wh.filterDir = (entry) => priorWh.filterDir(entry);
@@ -45786,8 +45833,8 @@ var NodeFsHandler = class {
       const follow = this.fsw.options.followSymlinks;
       let closer;
       if (stats.isDirectory()) {
-        const absPath = sysPath.resolve(path29);
-        const targetPath = follow ? await fsrealpath(path29) : path29;
+        const absPath = sysPath.resolve(path30);
+        const targetPath = follow ? await fsrealpath(path30) : path30;
         if (this.fsw.closed)
           return;
         closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
@@ -45797,29 +45844,29 @@ var NodeFsHandler = class {
           this.fsw._symlinkPaths.set(absPath, targetPath);
         }
       } else if (stats.isSymbolicLink()) {
-        const targetPath = follow ? await fsrealpath(path29) : path29;
+        const targetPath = follow ? await fsrealpath(path30) : path30;
         if (this.fsw.closed)
           return;
         const parent = sysPath.dirname(wh.watchPath);
         this.fsw._getWatchedDir(parent).add(wh.watchPath);
         this.fsw._emit(EV.ADD, wh.watchPath, stats);
-        closer = await this._handleDir(parent, stats, initialAdd, depth, path29, wh, targetPath);
+        closer = await this._handleDir(parent, stats, initialAdd, depth, path30, wh, targetPath);
         if (this.fsw.closed)
           return;
         if (targetPath !== void 0) {
-          this.fsw._symlinkPaths.set(sysPath.resolve(path29), targetPath);
+          this.fsw._symlinkPaths.set(sysPath.resolve(path30), targetPath);
         }
       } else {
         closer = this._handleFile(wh.watchPath, stats, initialAdd);
       }
       ready();
       if (closer)
-        this.fsw._addPathCloser(path29, closer);
+        this.fsw._addPathCloser(path30, closer);
       return false;
     } catch (error) {
       if (this.fsw._handleError(error)) {
         ready();
-        return path29;
+        return path30;
       }
     }
   }
@@ -45862,26 +45909,26 @@ function createPattern(matcher) {
   }
   return () => false;
 }
-function normalizePath(path29) {
-  if (typeof path29 !== "string")
+function normalizePath(path30) {
+  if (typeof path30 !== "string")
     throw new Error("string expected");
-  path29 = sysPath2.normalize(path29);
-  path29 = path29.replace(/\\/g, "/");
+  path30 = sysPath2.normalize(path30);
+  path30 = path30.replace(/\\/g, "/");
   let prepend = false;
-  if (path29.startsWith("//"))
+  if (path30.startsWith("//"))
     prepend = true;
   const DOUBLE_SLASH_RE2 = /\/\//;
-  while (path29.match(DOUBLE_SLASH_RE2))
-    path29 = path29.replace(DOUBLE_SLASH_RE2, "/");
+  while (path30.match(DOUBLE_SLASH_RE2))
+    path30 = path30.replace(DOUBLE_SLASH_RE2, "/");
   if (prepend)
-    path29 = "/" + path29;
-  return path29;
+    path30 = "/" + path30;
+  return path30;
 }
 function matchPatterns(patterns, testString, stats) {
-  const path29 = normalizePath(testString);
+  const path30 = normalizePath(testString);
   for (let index = 0; index < patterns.length; index++) {
     const pattern = patterns[index];
-    if (pattern(path29, stats)) {
+    if (pattern(path30, stats)) {
       return true;
     }
   }
@@ -45921,19 +45968,19 @@ var toUnix = (string2) => {
   }
   return str;
 };
-var normalizePathToUnix = (path29) => toUnix(sysPath2.normalize(toUnix(path29)));
-var normalizeIgnored = (cwd = "") => (path29) => {
-  if (typeof path29 === "string") {
-    return normalizePathToUnix(sysPath2.isAbsolute(path29) ? path29 : sysPath2.join(cwd, path29));
+var normalizePathToUnix = (path30) => toUnix(sysPath2.normalize(toUnix(path30)));
+var normalizeIgnored = (cwd = "") => (path30) => {
+  if (typeof path30 === "string") {
+    return normalizePathToUnix(sysPath2.isAbsolute(path30) ? path30 : sysPath2.join(cwd, path30));
   } else {
-    return path29;
+    return path30;
   }
 };
-var getAbsolutePath = (path29, cwd) => {
-  if (sysPath2.isAbsolute(path29)) {
-    return path29;
+var getAbsolutePath = (path30, cwd) => {
+  if (sysPath2.isAbsolute(path30)) {
+    return path30;
   }
-  return sysPath2.join(cwd, path29);
+  return sysPath2.join(cwd, path30);
 };
 var EMPTY_SET = Object.freeze(/* @__PURE__ */ new Set());
 var DirEntry = class {
@@ -45988,10 +46035,10 @@ var DirEntry = class {
 var STAT_METHOD_F = "stat";
 var STAT_METHOD_L = "lstat";
 var WatchHelper = class {
-  constructor(path29, follow, fsw) {
+  constructor(path30, follow, fsw) {
     this.fsw = fsw;
-    const watchPath = path29;
-    this.path = path29 = path29.replace(REPLACER_RE, "");
+    const watchPath = path30;
+    this.path = path30 = path30.replace(REPLACER_RE, "");
     this.watchPath = watchPath;
     this.fullWatchPath = sysPath2.resolve(watchPath);
     this.dirParts = [];
@@ -46113,20 +46160,20 @@ var FSWatcher = class extends EventEmitter2 {
     this._closePromise = void 0;
     let paths = unifyPaths(paths_);
     if (cwd) {
-      paths = paths.map((path29) => {
-        const absPath = getAbsolutePath(path29, cwd);
+      paths = paths.map((path30) => {
+        const absPath = getAbsolutePath(path30, cwd);
         return absPath;
       });
     }
-    paths.forEach((path29) => {
-      this._removeIgnoredPath(path29);
+    paths.forEach((path30) => {
+      this._removeIgnoredPath(path30);
     });
     this._userIgnored = void 0;
     if (!this._readyCount)
       this._readyCount = 0;
     this._readyCount += paths.length;
-    Promise.all(paths.map(async (path29) => {
-      const res = await this._nodeFsHandler._addToNodeFs(path29, !_internal, void 0, 0, _origAdd);
+    Promise.all(paths.map(async (path30) => {
+      const res = await this._nodeFsHandler._addToNodeFs(path30, !_internal, void 0, 0, _origAdd);
       if (res)
         this._emitReady();
       return res;
@@ -46148,17 +46195,17 @@ var FSWatcher = class extends EventEmitter2 {
       return this;
     const paths = unifyPaths(paths_);
     const { cwd } = this.options;
-    paths.forEach((path29) => {
-      if (!sysPath2.isAbsolute(path29) && !this._closers.has(path29)) {
+    paths.forEach((path30) => {
+      if (!sysPath2.isAbsolute(path30) && !this._closers.has(path30)) {
         if (cwd)
-          path29 = sysPath2.join(cwd, path29);
-        path29 = sysPath2.resolve(path29);
+          path30 = sysPath2.join(cwd, path30);
+        path30 = sysPath2.resolve(path30);
       }
-      this._closePath(path29);
-      this._addIgnoredPath(path29);
-      if (this._watched.has(path29)) {
+      this._closePath(path30);
+      this._addIgnoredPath(path30);
+      if (this._watched.has(path30)) {
         this._addIgnoredPath({
-          path: path29,
+          path: path30,
           recursive: true
         });
       }
@@ -46222,38 +46269,38 @@ var FSWatcher = class extends EventEmitter2 {
    * @param stats arguments to be passed with event
    * @returns the error if defined, otherwise the value of the FSWatcher instance's `closed` flag
    */
-  async _emit(event, path29, stats) {
+  async _emit(event, path30, stats) {
     if (this.closed)
       return;
     const opts = this.options;
     if (isWindows2)
-      path29 = sysPath2.normalize(path29);
+      path30 = sysPath2.normalize(path30);
     if (opts.cwd)
-      path29 = sysPath2.relative(opts.cwd, path29);
-    const args = [path29];
+      path30 = sysPath2.relative(opts.cwd, path30);
+    const args = [path30];
     if (stats != null)
       args.push(stats);
     const awf = opts.awaitWriteFinish;
     let pw;
-    if (awf && (pw = this._pendingWrites.get(path29))) {
+    if (awf && (pw = this._pendingWrites.get(path30))) {
       pw.lastChange = /* @__PURE__ */ new Date();
       return this;
     }
     if (opts.atomic) {
       if (event === EVENTS.UNLINK) {
-        this._pendingUnlinks.set(path29, [event, ...args]);
+        this._pendingUnlinks.set(path30, [event, ...args]);
         setTimeout(() => {
-          this._pendingUnlinks.forEach((entry, path30) => {
+          this._pendingUnlinks.forEach((entry, path31) => {
             this.emit(...entry);
             this.emit(EVENTS.ALL, ...entry);
-            this._pendingUnlinks.delete(path30);
+            this._pendingUnlinks.delete(path31);
           });
         }, typeof opts.atomic === "number" ? opts.atomic : 100);
         return this;
       }
-      if (event === EVENTS.ADD && this._pendingUnlinks.has(path29)) {
+      if (event === EVENTS.ADD && this._pendingUnlinks.has(path30)) {
         event = EVENTS.CHANGE;
-        this._pendingUnlinks.delete(path29);
+        this._pendingUnlinks.delete(path30);
       }
     }
     if (awf && (event === EVENTS.ADD || event === EVENTS.CHANGE) && this._readyEmitted) {
@@ -46271,16 +46318,16 @@ var FSWatcher = class extends EventEmitter2 {
           this.emitWithAll(event, args);
         }
       };
-      this._awaitWriteFinish(path29, awf.stabilityThreshold, event, awfEmit);
+      this._awaitWriteFinish(path30, awf.stabilityThreshold, event, awfEmit);
       return this;
     }
     if (event === EVENTS.CHANGE) {
-      const isThrottled = !this._throttle(EVENTS.CHANGE, path29, 50);
+      const isThrottled = !this._throttle(EVENTS.CHANGE, path30, 50);
       if (isThrottled)
         return this;
     }
     if (opts.alwaysStat && stats === void 0 && (event === EVENTS.ADD || event === EVENTS.ADD_DIR || event === EVENTS.CHANGE)) {
-      const fullPath = opts.cwd ? sysPath2.join(opts.cwd, path29) : path29;
+      const fullPath = opts.cwd ? sysPath2.join(opts.cwd, path30) : path30;
       let stats2;
       try {
         stats2 = await stat3(fullPath);
@@ -46311,23 +46358,23 @@ var FSWatcher = class extends EventEmitter2 {
    * @param timeout duration of time to suppress duplicate actions
    * @returns tracking object or false if action should be suppressed
    */
-  _throttle(actionType, path29, timeout) {
+  _throttle(actionType, path30, timeout) {
     if (!this._throttled.has(actionType)) {
       this._throttled.set(actionType, /* @__PURE__ */ new Map());
     }
     const action = this._throttled.get(actionType);
     if (!action)
       throw new Error("invalid throttle");
-    const actionPath = action.get(path29);
+    const actionPath = action.get(path30);
     if (actionPath) {
       actionPath.count++;
       return false;
     }
     let timeoutObject;
     const clear = () => {
-      const item = action.get(path29);
+      const item = action.get(path30);
       const count2 = item ? item.count : 0;
-      action.delete(path29);
+      action.delete(path30);
       clearTimeout(timeoutObject);
       if (item)
         clearTimeout(item.timeoutObject);
@@ -46335,7 +46382,7 @@ var FSWatcher = class extends EventEmitter2 {
     };
     timeoutObject = setTimeout(clear, timeout);
     const thr = { timeoutObject, clear, count: 0 };
-    action.set(path29, thr);
+    action.set(path30, thr);
     return thr;
   }
   _incrReadyCount() {
@@ -46349,44 +46396,44 @@ var FSWatcher = class extends EventEmitter2 {
    * @param event
    * @param awfEmit Callback to be called when ready for event to be emitted.
    */
-  _awaitWriteFinish(path29, threshold, event, awfEmit) {
+  _awaitWriteFinish(path30, threshold, event, awfEmit) {
     const awf = this.options.awaitWriteFinish;
     if (typeof awf !== "object")
       return;
     const pollInterval = awf.pollInterval;
     let timeoutHandler;
-    let fullPath = path29;
-    if (this.options.cwd && !sysPath2.isAbsolute(path29)) {
-      fullPath = sysPath2.join(this.options.cwd, path29);
+    let fullPath = path30;
+    if (this.options.cwd && !sysPath2.isAbsolute(path30)) {
+      fullPath = sysPath2.join(this.options.cwd, path30);
     }
     const now = /* @__PURE__ */ new Date();
     const writes = this._pendingWrites;
     function awaitWriteFinishFn(prevStat) {
       statcb(fullPath, (err, curStat) => {
-        if (err || !writes.has(path29)) {
+        if (err || !writes.has(path30)) {
           if (err && err.code !== "ENOENT")
             awfEmit(err);
           return;
         }
         const now2 = Number(/* @__PURE__ */ new Date());
         if (prevStat && curStat.size !== prevStat.size) {
-          writes.get(path29).lastChange = now2;
+          writes.get(path30).lastChange = now2;
         }
-        const pw = writes.get(path29);
+        const pw = writes.get(path30);
         const df = now2 - pw.lastChange;
         if (df >= threshold) {
-          writes.delete(path29);
+          writes.delete(path30);
           awfEmit(void 0, curStat);
         } else {
           timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval, curStat);
         }
       });
     }
-    if (!writes.has(path29)) {
-      writes.set(path29, {
+    if (!writes.has(path30)) {
+      writes.set(path30, {
         lastChange: now,
         cancelWait: () => {
-          writes.delete(path29);
+          writes.delete(path30);
           clearTimeout(timeoutHandler);
           return event;
         }
@@ -46397,8 +46444,8 @@ var FSWatcher = class extends EventEmitter2 {
   /**
    * Determines whether user has asked to ignore this path.
    */
-  _isIgnored(path29, stats) {
-    if (this.options.atomic && DOT_RE.test(path29))
+  _isIgnored(path30, stats) {
+    if (this.options.atomic && DOT_RE.test(path30))
       return true;
     if (!this._userIgnored) {
       const { cwd } = this.options;
@@ -46408,17 +46455,17 @@ var FSWatcher = class extends EventEmitter2 {
       const list = [...ignoredPaths.map(normalizeIgnored(cwd)), ...ignored];
       this._userIgnored = anymatch(list, void 0);
     }
-    return this._userIgnored(path29, stats);
+    return this._userIgnored(path30, stats);
   }
-  _isntIgnored(path29, stat5) {
-    return !this._isIgnored(path29, stat5);
+  _isntIgnored(path30, stat5) {
+    return !this._isIgnored(path30, stat5);
   }
   /**
    * Provides a set of common helpers and properties relating to symlink handling.
    * @param path file or directory pattern being watched
    */
-  _getWatchHelpers(path29) {
-    return new WatchHelper(path29, this.options.followSymlinks, this);
+  _getWatchHelpers(path30) {
+    return new WatchHelper(path30, this.options.followSymlinks, this);
   }
   // Directory helpers
   // -----------------
@@ -46450,63 +46497,63 @@ var FSWatcher = class extends EventEmitter2 {
    * @param item      base path of item/directory
    */
   _remove(directory, item, isDirectory) {
-    const path29 = sysPath2.join(directory, item);
-    const fullPath = sysPath2.resolve(path29);
-    isDirectory = isDirectory != null ? isDirectory : this._watched.has(path29) || this._watched.has(fullPath);
-    if (!this._throttle("remove", path29, 100))
+    const path30 = sysPath2.join(directory, item);
+    const fullPath = sysPath2.resolve(path30);
+    isDirectory = isDirectory != null ? isDirectory : this._watched.has(path30) || this._watched.has(fullPath);
+    if (!this._throttle("remove", path30, 100))
       return;
     if (!isDirectory && this._watched.size === 1) {
       this.add(directory, item, true);
     }
-    const wp = this._getWatchedDir(path29);
+    const wp = this._getWatchedDir(path30);
     const nestedDirectoryChildren = wp.getChildren();
-    nestedDirectoryChildren.forEach((nested) => this._remove(path29, nested));
+    nestedDirectoryChildren.forEach((nested) => this._remove(path30, nested));
     const parent = this._getWatchedDir(directory);
     const wasTracked = parent.has(item);
     parent.remove(item);
     if (this._symlinkPaths.has(fullPath)) {
       this._symlinkPaths.delete(fullPath);
     }
-    let relPath = path29;
+    let relPath = path30;
     if (this.options.cwd)
-      relPath = sysPath2.relative(this.options.cwd, path29);
+      relPath = sysPath2.relative(this.options.cwd, path30);
     if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
       const event = this._pendingWrites.get(relPath).cancelWait();
       if (event === EVENTS.ADD)
         return;
     }
-    this._watched.delete(path29);
+    this._watched.delete(path30);
     this._watched.delete(fullPath);
     const eventName = isDirectory ? EVENTS.UNLINK_DIR : EVENTS.UNLINK;
-    if (wasTracked && !this._isIgnored(path29))
-      this._emit(eventName, path29);
-    this._closePath(path29);
+    if (wasTracked && !this._isIgnored(path30))
+      this._emit(eventName, path30);
+    this._closePath(path30);
   }
   /**
    * Closes all watchers for a path
    */
-  _closePath(path29) {
-    this._closeFile(path29);
-    const dir = sysPath2.dirname(path29);
-    this._getWatchedDir(dir).remove(sysPath2.basename(path29));
+  _closePath(path30) {
+    this._closeFile(path30);
+    const dir = sysPath2.dirname(path30);
+    this._getWatchedDir(dir).remove(sysPath2.basename(path30));
   }
   /**
    * Closes only file-specific watchers
    */
-  _closeFile(path29) {
-    const closers = this._closers.get(path29);
+  _closeFile(path30) {
+    const closers = this._closers.get(path30);
     if (!closers)
       return;
     closers.forEach((closer) => closer());
-    this._closers.delete(path29);
+    this._closers.delete(path30);
   }
-  _addPathCloser(path29, closer) {
+  _addPathCloser(path30, closer) {
     if (!closer)
       return;
-    let list = this._closers.get(path29);
+    let list = this._closers.get(path30);
     if (!list) {
       list = [];
-      this._closers.set(path29, list);
+      this._closers.set(path30, list);
     }
     list.push(closer);
   }
@@ -46971,7 +47018,7 @@ data: ${JSON.stringify(event)}
 
 // ../../apps/server/src/services/runtimes/claude-code/command-registry.ts
 import fs8 from "fs/promises";
-import path10 from "path";
+import path11 from "path";
 import matter from "gray-matter";
 function parseFrontmatterFallback(content) {
   const match = content.match(/^---\n([\s\S]*?)\n---/);
@@ -46994,7 +47041,7 @@ var CommandRegistryService = class _CommandRegistryService {
   commandsDir;
   /** @param vaultRoot - Must be pre-validated against directory boundary by caller */
   constructor(vaultRoot2) {
-    this.commandsDir = path10.join(vaultRoot2, ".claude", "commands");
+    this.commandsDir = path11.join(vaultRoot2, ".claude", "commands");
   }
   async getCommands(forceRefresh = false) {
     const cacheExpired = Date.now() - this.cacheTime > _CommandRegistryService.CACHE_TTL_MS;
@@ -47006,11 +47053,11 @@ var CommandRegistryService = class _CommandRegistryService {
       });
       for (const entry of entries) {
         if (!entry.isDirectory()) continue;
-        const nsPath = path10.join(this.commandsDir, entry.name);
+        const nsPath = path11.join(this.commandsDir, entry.name);
         const files = await fs8.readdir(nsPath);
         for (const file of files) {
           if (!file.endsWith(".md")) continue;
-          const filePath = path10.join(nsPath, file);
+          const filePath = path11.join(nsPath, file);
           try {
             const content = await fs8.readFile(filePath, "utf-8");
             let frontmatter;
@@ -47028,7 +47075,7 @@ var CommandRegistryService = class _CommandRegistryService {
               description: frontmatter.description || "",
               argumentHint: frontmatter["argument-hint"],
               allowedTools: typeof allowedToolsRaw === "string" ? allowedToolsRaw.split(",").map((t2) => t2.trim()) : allowedToolsRaw,
-              filePath: path10.relative(process.cwd(), filePath)
+              filePath: path11.relative(process.cwd(), filePath)
             });
           } catch (fileErr) {
             logger.warn(
@@ -47351,12 +47398,12 @@ import os3 from "node:os";
 
 // ../shared/dist/manifest.js
 import fs9 from "fs/promises";
-import path11 from "path";
+import path12 from "path";
 import { randomUUID as randomUUID2 } from "crypto";
 var MANIFEST_DIR = ".dork";
 var MANIFEST_FILE = "agent.json";
 async function readManifest(projectPath) {
-  const manifestPath = path11.join(projectPath, MANIFEST_DIR, MANIFEST_FILE);
+  const manifestPath = path12.join(projectPath, MANIFEST_DIR, MANIFEST_FILE);
   try {
     const content = await fs9.readFile(manifestPath, "utf-8");
     const parsed = JSON.parse(content);
@@ -47367,17 +47414,17 @@ async function readManifest(projectPath) {
   }
 }
 async function writeManifest(projectPath, manifest) {
-  const dorkDir = path11.join(projectPath, MANIFEST_DIR);
+  const dorkDir = path12.join(projectPath, MANIFEST_DIR);
   await fs9.mkdir(dorkDir, { recursive: true });
-  const manifestPath = path11.join(dorkDir, MANIFEST_FILE);
-  const tempPath = path11.join(dorkDir, `.agent-${randomUUID2()}.tmp`);
+  const manifestPath = path12.join(dorkDir, MANIFEST_FILE);
+  const tempPath = path12.join(dorkDir, `.agent-${randomUUID2()}.tmp`);
   const content = JSON.stringify(manifest, null, 2) + "\n";
   await fs9.writeFile(tempPath, content, "utf-8");
   await fs9.rename(tempPath, manifestPath);
 }
 async function removeManifest(projectPath) {
   try {
-    await fs9.unlink(path11.join(projectPath, MANIFEST_DIR, MANIFEST_FILE));
+    await fs9.unlink(path12.join(projectPath, MANIFEST_DIR, MANIFEST_FILE));
   } catch {
   }
 }
@@ -47566,7 +47613,7 @@ async function buildEnvBlock(cwd) {
   const lines = [
     `Working directory: ${cwd}`,
     `Product: DorkOS`,
-    `Version: ${env.DORKOS_VERSION ?? "development"}`,
+    `Version: ${SERVER_VERSION}`,
     `Port: ${env.DORKOS_PORT}`,
     `Platform: ${os3.platform()}`,
     `OS Version: ${os3.release()}`,
@@ -48276,7 +48323,7 @@ async function handleGetServerInfo(args) {
   const info = {
     product: "DorkOS",
     port: env.DORKOS_PORT,
-    version: env.DORKOS_VERSION ?? "development"
+    version: SERVER_VERSION
   };
   if (args.include_uptime) {
     info.uptime_seconds = Math.floor(process.uptime());
@@ -50620,7 +50667,7 @@ var QueryPromise = class {
 function mapResultRow(columns, row, joinsNotNullableMap) {
   const nullifyMap = {};
   const result2 = columns.reduce(
-    (result22, { path: path29, field }, columnIndex) => {
+    (result22, { path: path30, field }, columnIndex) => {
       let decoder;
       if (is(field, Column)) {
         decoder = field;
@@ -50630,8 +50677,8 @@ function mapResultRow(columns, row, joinsNotNullableMap) {
         decoder = field.sql.decoder;
       }
       let node = result22;
-      for (const [pathChunkIndex, pathChunk] of path29.entries()) {
-        if (pathChunkIndex < path29.length - 1) {
+      for (const [pathChunkIndex, pathChunk] of path30.entries()) {
+        if (pathChunkIndex < path30.length - 1) {
           if (!(pathChunk in node)) {
             node[pathChunk] = {};
           }
@@ -50639,8 +50686,8 @@ function mapResultRow(columns, row, joinsNotNullableMap) {
         } else {
           const rawValue = row[columnIndex];
           const value = node[pathChunk] = rawValue === null ? null : decoder.mapFromDriverValue(rawValue);
-          if (joinsNotNullableMap && is(field, Column) && path29.length === 2) {
-            const objectName = path29[0];
+          if (joinsNotNullableMap && is(field, Column) && path30.length === 2) {
+            const objectName = path30[0];
             if (!(objectName in nullifyMap)) {
               nullifyMap[objectName] = value === null ? getTableName(field.table) : false;
             } else if (typeof nullifyMap[objectName] === "string" && nullifyMap[objectName] !== getTableName(field.table)) {
@@ -54502,9 +54549,9 @@ var rateLimitBuckets = sqliteTable(
 );
 
 // ../db/src/index.ts
-import path12 from "path";
+import path13 from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
-var __dirname2 = path12.dirname(fileURLToPath3(import.meta.url));
+var __dirname2 = path13.dirname(fileURLToPath3(import.meta.url));
 function createDb(dbPath) {
   const sqlite = new Database(dbPath);
   sqlite.pragma("journal_mode = WAL");
@@ -54514,7 +54561,7 @@ function createDb(dbPath) {
   return drizzle(sqlite, { schema: schema_exports });
 }
 function runMigrations(db) {
-  const migrationsFolder = path12.join(__dirname2, "../drizzle");
+  const migrationsFolder = path13.join(__dirname2, "../drizzle");
   migrate(db, { migrationsFolder });
 }
 
@@ -55954,7 +56001,7 @@ import { Router as Router12 } from "express";
 
 // ../../apps/server/src/services/pulse/pulse-presets.ts
 import { readFile, writeFile, mkdir } from "node:fs/promises";
-import path13 from "node:path";
+import path14 from "node:path";
 var DEFAULT_PRESETS = [
   {
     id: "health-check",
@@ -55994,7 +56041,7 @@ var DEFAULT_PRESETS = [
   }
 ];
 function resolvePresetsPath(dorkHome) {
-  return path13.join(dorkHome, "pulse", "presets.json");
+  return path14.join(dorkHome, "pulse", "presets.json");
 }
 async function loadPresets(dorkHome) {
   const presetsPath = resolvePresetsPath(dorkHome);
@@ -56129,7 +56176,7 @@ function createPulseRouter(store, scheduler, meshCore2) {
 }
 
 // ../relay/dist/relay-core.js
-import * as path18 from "node:path";
+import * as path19 from "node:path";
 import * as os4 from "node:os";
 import fs14 from "node:fs";
 
@@ -56649,7 +56696,7 @@ var noopHandler = () => {
 
 // ../relay/dist/maildir-store.js
 import * as fs11 from "node:fs/promises";
-import * as path14 from "node:path";
+import * as path15 from "node:path";
 import { constants } from "node:fs";
 var DIR_MODE = 448;
 var FILE_MODE = 384;
@@ -56673,7 +56720,7 @@ var MaildirStore = class {
   async ensureMaildir(endpointHash) {
     const base = this.endpointDir(endpointHash);
     for (const subdir of MAILDIR_SUBDIRS) {
-      await fs11.mkdir(path14.join(base, subdir), { recursive: true, mode: DIR_MODE });
+      await fs11.mkdir(path15.join(base, subdir), { recursive: true, mode: DIR_MODE });
     }
   }
   // --- Delivery ---
@@ -56695,8 +56742,8 @@ var MaildirStore = class {
     const messageId = generateUlid2();
     const filename = messageId + FILE_EXT;
     const base = this.endpointDir(endpointHash);
-    const tmpPath = path14.join(base, "tmp", filename);
-    const newPath = path14.join(base, "new", filename);
+    const tmpPath = path15.join(base, "tmp", filename);
+    const newPath = path15.join(base, "new", filename);
     try {
       const data = JSON.stringify(envelope, null, 2);
       await writeFileExclusive(tmpPath, data);
@@ -56722,8 +56769,8 @@ var MaildirStore = class {
   async claim(endpointHash, messageId) {
     const filename = messageId + FILE_EXT;
     const base = this.endpointDir(endpointHash);
-    const newPath = path14.join(base, "new", filename);
-    const curPath = path14.join(base, "cur", filename);
+    const newPath = path15.join(base, "new", filename);
+    const curPath = path15.join(base, "cur", filename);
     try {
       await fs11.rename(newPath, curPath);
       const data = await fs11.readFile(curPath, "utf-8");
@@ -56743,7 +56790,7 @@ var MaildirStore = class {
    */
   async complete(endpointHash, messageId) {
     const filename = messageId + FILE_EXT;
-    const curPath = path14.join(this.endpointDir(endpointHash), "cur", filename);
+    const curPath = path15.join(this.endpointDir(endpointHash), "cur", filename);
     await fs11.unlink(curPath);
   }
   // --- Fail ---
@@ -56761,8 +56808,8 @@ var MaildirStore = class {
   async fail(endpointHash, messageId, reason) {
     const filename = messageId + FILE_EXT;
     const base = this.endpointDir(endpointHash);
-    const curPath = path14.join(base, "cur", filename);
-    const failedPath = path14.join(base, "failed", filename);
+    const curPath = path15.join(base, "cur", filename);
+    const failedPath = path15.join(base, "failed", filename);
     try {
       await fs11.rename(curPath, failedPath);
       const data = await fs11.readFile(failedPath, "utf-8");
@@ -56773,7 +56820,7 @@ var MaildirStore = class {
         failedAt: (/* @__PURE__ */ new Date()).toISOString(),
         endpointHash
       };
-      const reasonPath = path14.join(base, "failed", `${messageId}.reason.json`);
+      const reasonPath = path15.join(base, "failed", `${messageId}.reason.json`);
       await writeFileExclusive(reasonPath, JSON.stringify(deadLetter, null, 2));
       return { ok: true, path: failedPath };
     } catch (err) {
@@ -56796,7 +56843,7 @@ var MaildirStore = class {
     const messageId = envelope.id;
     const filename = messageId + FILE_EXT;
     const base = this.endpointDir(endpointHash);
-    const failedPath = path14.join(base, "failed", filename);
+    const failedPath = path15.join(base, "failed", filename);
     try {
       await writeFileExclusive(failedPath, JSON.stringify(envelope, null, 2));
       const deadLetter = {
@@ -56805,7 +56852,7 @@ var MaildirStore = class {
         failedAt: (/* @__PURE__ */ new Date()).toISOString(),
         endpointHash
       };
-      const reasonPath = path14.join(base, "failed", `${messageId}.reason.json`);
+      const reasonPath = path15.join(base, "failed", `${messageId}.reason.json`);
       await writeFileExclusive(reasonPath, JSON.stringify(deadLetter, null, 2));
       return { ok: true, path: failedPath };
     } catch (err) {
@@ -56856,7 +56903,7 @@ var MaildirStore = class {
    */
   async readEnvelope(endpointHash, subdir, messageId) {
     const filename = messageId + FILE_EXT;
-    const filePath = path14.join(this.endpointDir(endpointHash), subdir, filename);
+    const filePath = path15.join(this.endpointDir(endpointHash), subdir, filename);
     try {
       const data = await fs11.readFile(filePath, "utf-8");
       return JSON.parse(data);
@@ -56872,7 +56919,7 @@ var MaildirStore = class {
    * @returns The parsed DeadLetter, or null if not found.
    */
   async readDeadLetter(endpointHash, messageId) {
-    const reasonPath = path14.join(this.endpointDir(endpointHash), "failed", `${messageId}.reason.json`);
+    const reasonPath = path15.join(this.endpointDir(endpointHash), "failed", `${messageId}.reason.json`);
     try {
       const data = await fs11.readFile(reasonPath, "utf-8");
       return JSON.parse(data);
@@ -56887,7 +56934,7 @@ var MaildirStore = class {
    * @param endpointHash - The hash identifying the endpoint.
    */
   endpointDir(endpointHash) {
-    return path14.join(this.rootDir, endpointHash);
+    return path15.join(this.rootDir, endpointHash);
   }
   /**
    * List message IDs in a given Maildir subdirectory.
@@ -56899,7 +56946,7 @@ var MaildirStore = class {
    * @param subdir - The subdirectory to list.
    */
   async listSubdir(endpointHash, subdir) {
-    const dirPath = path14.join(this.endpointDir(endpointHash), subdir);
+    const dirPath = path15.join(this.endpointDir(endpointHash), subdir);
     try {
       const entries = await fs11.readdir(dirPath);
       return entries.filter((f4) => f4.endsWith(FILE_EXT) && !f4.endsWith(".reason.json")).map((f4) => f4.slice(0, -FILE_EXT.length)).sort();
@@ -57201,7 +57248,7 @@ async function listMessageIds(store, hash, subdir) {
 
 // ../relay/dist/dead-letter-queue.js
 import * as fs12 from "node:fs/promises";
-import * as path15 from "node:path";
+import * as path16 from "node:path";
 var DeadLetterQueue = class {
   maildirStore;
   sqliteIndex;
@@ -57416,9 +57463,9 @@ var DeadLetterQueue = class {
    * @param messageId - The message ID to remove.
    */
   async removeDeadLetter(endpointHash, messageId) {
-    const failedDir = path15.join(this.rootDir, endpointHash, "failed");
-    await silentUnlink2(path15.join(failedDir, `${messageId}.json`));
-    await silentUnlink2(path15.join(failedDir, `${messageId}.reason.json`));
+    const failedDir = path16.join(this.rootDir, endpointHash, "failed");
+    await silentUnlink2(path16.join(failedDir, `${messageId}.json`));
+    await silentUnlink2(path16.join(failedDir, `${messageId}.reason.json`));
     this.sqliteIndex.insertMessage({
       id: messageId,
       subject: "",
@@ -57439,7 +57486,7 @@ async function silentUnlink2(filePath) {
 
 // ../relay/dist/access-control.js
 import fs13 from "node:fs";
-import path16 from "node:path";
+import path17 from "node:path";
 var RULES_FILENAME = "access-rules.json";
 function byPriorityDesc(a2, b3) {
   return b3.priority - a2.priority;
@@ -57468,7 +57515,7 @@ var AccessControl = class {
    * @param dataDir - Directory containing (or to contain) `access-rules.json`
    */
   constructor(dataDir) {
-    this.rulesPath = path16.join(dataDir, RULES_FILENAME);
+    this.rulesPath = path17.join(dataDir, RULES_FILENAME);
     this.loadRules();
     this.startWatcher();
   }
@@ -58078,7 +58125,7 @@ var AdapterDelivery = class _AdapterDelivery {
 };
 
 // ../relay/dist/watcher-manager.js
-import * as path17 from "node:path";
+import * as path18 from "node:path";
 var WatcherManager = class {
   maildirStore;
   subscriptionRegistry;
@@ -58116,7 +58163,7 @@ var WatcherManager = class {
   startWatcher(endpoint) {
     if (this.watchers.has(endpoint.hash))
       return Promise.resolve();
-    const newDir = path17.join(endpoint.maildirPath, "new");
+    const newDir = path18.join(endpoint.maildirPath, "new");
     const watcher = esm_default.watch(newDir, {
       persistent: true,
       ignoreInitial: true
@@ -58164,7 +58211,7 @@ var WatcherManager = class {
    * @param filePath - The path to the new message file
    */
   async handleNewMessage(endpoint, filePath) {
-    const filename = path17.basename(filePath);
+    const filename = path18.basename(filePath);
     if (!filename.endsWith(".json"))
       return;
     const messageId = filename.slice(0, -5);
@@ -58203,7 +58250,7 @@ function inferEndpointType2(subject) {
 }
 
 // ../relay/dist/relay-core.js
-var DEFAULT_DATA_DIR = path18.join(os4.homedir(), ".dork", "relay");
+var DEFAULT_DATA_DIR = path19.join(os4.homedir(), ".dork", "relay");
 var DEFAULT_TTL_MS2 = 36e5;
 var DEFAULT_MAX_HOPS2 = 5;
 var DEFAULT_CALL_BUDGET2 = 10;
@@ -58241,14 +58288,14 @@ var RelayCore = class {
       defaultCallBudget: options?.defaultCallBudget ?? DEFAULT_CALL_BUDGET2
     };
     fs14.mkdirSync(dataDir, { recursive: true });
-    const mailboxesDir = path18.join(dataDir, "mailboxes");
+    const mailboxesDir = path19.join(dataDir, "mailboxes");
     this.endpointRegistry = new EndpointRegistry(dataDir);
     this.subscriptionRegistry = new SubscriptionRegistry(dataDir);
     this.maildirStore = new MaildirStore({ rootDir: mailboxesDir });
     if (options?.db) {
       this.sqliteIndex = new SqliteIndex(options.db);
     } else {
-      const dbPath = path18.join(dataDir, "index.db");
+      const dbPath = path19.join(dataDir, "index.db");
       const legacyDb = createDb(dbPath);
       runMigrations(legacyDb);
       this.sqliteIndex = new SqliteIndex(legacyDb);
@@ -58280,7 +58327,7 @@ var RelayCore = class {
     this.adapterDelivery = new AdapterDelivery(options?.adapterRegistry, this.sqliteIndex);
     this.watcherManager = new WatcherManager(this.maildirStore, this.subscriptionRegistry, this.sqliteIndex, this.circuitBreaker);
     this.watcherManager.setWasDispatched((id) => this.deliveryPipeline.wasDispatched(id));
-    this.configPath = path18.join(dataDir, "config.json");
+    this.configPath = path19.join(dataDir, "config.json");
     this.loadReliabilityConfig();
     this.startConfigWatcher();
     this.dispatchInboxTtlMs = options?.dispatchInboxTtlMs ?? 30 * 60 * 1e3;
@@ -59945,13 +59992,15 @@ var ClaudeCodeAdapter = class {
       error: null
     };
     this.deps.traceStore.insertSpan(span);
+    const payloadCwd = typeof envelope.payload === "object" && envelope.payload !== null ? envelope.payload.cwd : void 0;
     const agentCwd = context?.agent?.directory;
+    const effectiveCwd = payloadCwd ?? agentCwd;
     const log = this.deps.logger ?? console;
-    log.debug?.(`[CCA] handleAgentMessage agentId=${agentId} ccaSessionKey=${ccaSessionKey}, context.agent.directory=${context?.agent?.directory ?? "(none)"}, resolvedCwd=${agentCwd ?? "(deferred to session)"}`);
+    log.debug?.(`[CCA] handleAgentMessage agentId=${agentId} ccaSessionKey=${ccaSessionKey}, payloadCwd=${payloadCwd ?? "(none)"}, context.agent.directory=${context?.agent?.directory ?? "(none)"}, resolvedCwd=${effectiveCwd ?? "(deferred to session)"}`);
     this.deps.agentManager.ensureSession(ccaSessionKey, {
       permissionMode: "default",
       hasStarted: true,
-      ...agentCwd ? { cwd: agentCwd } : {}
+      ...effectiveCwd ? { cwd: effectiveCwd } : {}
     });
     this.deps.traceStore.updateSpan(envelope.id, {
       status: "delivered",
@@ -59991,7 +60040,7 @@ var ClaudeCodeAdapter = class {
     const timeout = setTimeout(() => controller.abort(), timeoutMs);
     const isInboxReplyTo = envelope.replyTo?.startsWith("relay.inbox.");
     const eventStream = this.deps.agentManager.sendMessage(ccaSessionKey, prompt2, {
-      ...agentCwd ? { cwd: agentCwd } : {}
+      ...effectiveCwd ? { cwd: effectiveCwd } : {}
     });
     let eventCount = 0;
     let collectedText = "";
@@ -62125,7 +62174,7 @@ var TraceStore = class {
 };
 
 // ../mesh/dist/mesh-core.js
-import path25 from "path";
+import path26 from "path";
 import os5 from "os";
 
 // ../mesh/dist/health.js
@@ -62558,7 +62607,7 @@ var DenialList = class {
 };
 
 // ../mesh/dist/relay-bridge.js
-import path19 from "path";
+import path20 from "path";
 var SAME_NAMESPACE_ALLOW_PRIORITY = 100;
 var CROSS_NAMESPACE_DENY_PRIORITY = 10;
 var RelayBridge = class {
@@ -62587,7 +62636,7 @@ var RelayBridge = class {
   async registerAgent(agent, projectPath, namespace, _scanRoot) {
     if (!this.relayCore)
       return null;
-    const ns = namespace || path19.basename(projectPath);
+    const ns = namespace || path20.basename(projectPath);
     const subject = `relay.agent.${ns}.${agent.id}`;
     try {
       await this.relayCore.registerEndpoint(subject);
@@ -62813,7 +62862,7 @@ var TopologyManager = class {
 };
 
 // ../mesh/dist/namespace-resolver.js
-import path20 from "path";
+import path21 from "path";
 var MAX_NAMESPACE_LENGTH = 64;
 function normalizeNamespace(raw) {
   return raw.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
@@ -62836,8 +62885,8 @@ function resolveNamespace(projectPath, scanRoot, manifestNamespace) {
     }
     return normalized2;
   }
-  const relative3 = path20.relative(scanRoot, projectPath);
-  const firstSegment = relative3.split(path20.sep)[0];
+  const relative3 = path21.relative(scanRoot, projectPath);
+  const firstSegment = relative3.split(path21.sep)[0];
   if (!firstSegment) {
     throw new Error(`Cannot derive namespace: projectPath '${projectPath}' is at or above scanRoot '${scanRoot}'`);
   }
@@ -62851,21 +62900,21 @@ function resolveNamespace(projectPath, scanRoot, manifestNamespace) {
 
 // ../mesh/dist/strategies/claude-code-strategy.js
 import fs15 from "fs/promises";
-import path21 from "path";
+import path22 from "path";
 var MAX_CLAUDEMD_BYTES = 4096;
 var ClaudeCodeStrategy = class {
   name = "claude-code";
   runtime = "claude-code";
   async detect(dir) {
     try {
-      const stat5 = await fs15.stat(path21.join(dir, "CLAUDE.md"));
+      const stat5 = await fs15.stat(path22.join(dir, "CLAUDE.md"));
       return stat5.isFile();
     } catch {
       return false;
     }
   }
   async extractHints(dir) {
-    const suggestedName = path21.basename(dir);
+    const suggestedName = path22.basename(dir);
     const description = await this.extractDescription(dir);
     return {
       suggestedName,
@@ -62881,7 +62930,7 @@ var ClaudeCodeStrategy = class {
    */
   async extractDescription(dir) {
     try {
-      const claudeMdPath = path21.join(dir, "CLAUDE.md");
+      const claudeMdPath = path22.join(dir, "CLAUDE.md");
       const fd = await fs15.open(claudeMdPath, "r");
       try {
         const buf = Buffer.alloc(MAX_CLAUDEMD_BYTES);
@@ -62925,13 +62974,13 @@ function extractFirstParagraph(content) {
 
 // ../mesh/dist/strategies/cursor-strategy.js
 import fs16 from "fs/promises";
-import path22 from "path";
+import path23 from "path";
 var CursorStrategy = class {
   name = "cursor";
   runtime = "cursor";
   async detect(dir) {
     try {
-      const stat5 = await fs16.stat(path22.join(dir, ".cursor"));
+      const stat5 = await fs16.stat(path23.join(dir, ".cursor"));
       return stat5.isDirectory();
     } catch {
       return false;
@@ -62939,7 +62988,7 @@ var CursorStrategy = class {
   }
   async extractHints(dir) {
     return {
-      suggestedName: path22.basename(dir),
+      suggestedName: path23.basename(dir),
       detectedRuntime: "cursor",
       inferredCapabilities: ["code"]
     };
@@ -62948,13 +62997,13 @@ var CursorStrategy = class {
 
 // ../mesh/dist/strategies/codex-strategy.js
 import fs17 from "fs/promises";
-import path23 from "path";
+import path24 from "path";
 var CodexStrategy = class {
   name = "codex";
   runtime = "codex";
   async detect(dir) {
     try {
-      const stat5 = await fs17.stat(path23.join(dir, ".codex"));
+      const stat5 = await fs17.stat(path24.join(dir, ".codex"));
       return stat5.isDirectory();
     } catch {
       return false;
@@ -62962,7 +63011,7 @@ var CodexStrategy = class {
   }
   async extractHints(dir) {
     return {
-      suggestedName: path23.basename(dir),
+      suggestedName: path24.basename(dir),
       detectedRuntime: "codex",
       inferredCapabilities: ["code"]
     };
@@ -62972,7 +63021,7 @@ var CodexStrategy = class {
 // ../mesh/dist/discovery/unified-scanner.js
 import fs18 from "fs/promises";
 import { realpathSync as realpathSync2 } from "fs";
-import path24 from "path";
+import path25 from "path";
 
 // ../mesh/dist/discovery/types.js
 var UNIFIED_EXCLUDE_PATTERNS = /* @__PURE__ */ new Set([
@@ -63029,7 +63078,7 @@ async function* unifiedScan(options, strategies, registry2, denialList) {
       if (!item)
         continue;
       const { dir, depth } = item;
-      const dirName = path24.basename(dir);
+      const dirName = path25.basename(dir);
       if (UNIFIED_EXCLUDE_PATTERNS.has(dirName) || extraExcludes.has(dirName))
         continue;
       if (dirName.startsWith(".") && !ALLOWED_DOT_DIRS.has(dirName))
@@ -63096,7 +63145,7 @@ async function* unifiedScan(options, strategies, registry2, denialList) {
             continue;
           if (isSymlink && !followSymlinks)
             continue;
-          queue2.push({ dir: path24.join(dir, entry.name), depth: depth + 1 });
+          queue2.push({ dir: path25.join(dir, entry.name), depth: depth + 1 });
         }
       }
     }
@@ -63384,7 +63433,7 @@ var MeshCore = class {
       return;
     await removeManifest(agent.projectPath);
     const namespace = agent.namespace;
-    const subject = `relay.agent.${namespace || path25.basename(agent.projectPath)}.${agent.id}`;
+    const subject = `relay.agent.${namespace || path26.basename(agent.projectPath)}.${agent.id}`;
     await this.relayBridge.unregisterAgent(subject, agent.id, agent.name);
     this.registry.remove(agentId);
     for (const cb of this.onUnregisterCallbacks) {
@@ -63620,7 +63669,7 @@ var MeshCore = class {
     if (!health)
       return void 0;
     const manifest = this.toManifest(entry);
-    const ns = entry.namespace || path25.basename(entry.projectPath);
+    const ns = entry.namespace || path26.basename(entry.projectPath);
     const relaySubject = `relay.agent.${ns}.${agentId}`;
     return { agent: manifest, health, relaySubject };
   }
@@ -64024,7 +64073,7 @@ function createMeshRouter(deps) {
 
 // ../../apps/server/src/routes/agents.ts
 import { Router as Router15 } from "express";
-import path26 from "path";
+import path27 from "path";
 function createAgentsRouter(meshCore2) {
   const router12 = Router15();
   router12.get("/current", async (req, res) => {
@@ -64084,7 +64133,7 @@ function createAgentsRouter(meshCore2) {
       }
       const manifest = {
         id: ulid(),
-        name: name ?? path26.basename(agentPath),
+        name: name ?? path27.basename(agentPath),
         description: description ?? "",
         runtime: runtime ?? "claude-code",
         capabilities: [],
@@ -72349,13 +72398,13 @@ function validateMcpOrigin(req, res, next) {
 
 // ../../apps/server/src/lib/dork-home.ts
 import os6 from "os";
-import path27 from "path";
+import path28 from "path";
 function resolveDorkHome() {
   if (process.env.DORK_HOME) return process.env.DORK_HOME;
   if (process.env.NODE_ENV !== "production") {
-    return path27.join(process.cwd(), ".temp", ".dork");
+    return path28.join(process.cwd(), ".temp", ".dork");
   }
-  return path27.join(os6.homedir(), ".dork");
+  return path28.join(os6.homedir(), ".dork");
 }
 
 // ../../apps/server/src/index.ts
@@ -72373,18 +72422,18 @@ async function start() {
   process.env.DORK_HOME = dorkHome;
   console.log(`[DorkOS] Data directory: ${dorkHome}`);
   const logLevel = env.DORKOS_LOG_LEVEL;
-  initLogger({ level: logLevel, logDir: path28.join(dorkHome, "logs") });
+  initLogger({ level: logLevel, logDir: path29.join(dorkHome, "logs") });
   initConfigManager(dorkHome);
   const loggingConfig = configManager.get("logging");
   if (loggingConfig?.maxLogSizeKb || loggingConfig?.maxLogFiles) {
     initLogger({
       level: logLevel,
-      logDir: path28.join(dorkHome, "logs"),
+      logDir: path29.join(dorkHome, "logs"),
       maxLogSize: (loggingConfig.maxLogSizeKb ?? 500) * 1024,
       maxLogFiles: loggingConfig.maxLogFiles ?? 14
     });
   }
-  const dbPath = path28.join(dorkHome, "dork.db");
+  const dbPath = path29.join(dorkHome, "dork.db");
   const db = createDb(dbPath);
   runMigrations(db);
   logger.info(`[DB] Consolidated database ready at ${dbPath}`);
@@ -72409,7 +72458,7 @@ async function start() {
   }
   const relayConfig = configManager.get("relay");
   const relayEnabled = env.DORKOS_RELAY_ENABLED || relayConfig?.enabled;
-  const relayDataDir = relayConfig?.dataDir ?? path28.join(dorkHome, "relay");
+  const relayDataDir = relayConfig?.dataDir ?? path29.join(dorkHome, "relay");
   if (relayEnabled) {
     try {
       adapterRegistry = new AdapterRegistry();
@@ -72451,7 +72500,7 @@ async function start() {
   }
   if (relayEnabled && relayCore && adapterRegistry && traceStore) {
     try {
-      const adapterConfigPath = path28.join(dorkHome, "relay", "adapters.json");
+      const adapterConfigPath = path29.join(dorkHome, "relay", "adapters.json");
       adapterManager = new AdapterManager(adapterRegistry, adapterConfigPath, {
         agentManager: claudeRuntime,
         traceStore,