dorkos 0.12.0 → 0.13.0

package/dist/bin/cli.js

@@ -5,10 +5,16 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x2) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x2, {
+  get: (a2, b2) => (typeof require !== "undefined" ? require : a2)[b2]
+}) : x2)(function(x2) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x2 + '" is not supported');
+});
 var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
 };
-var __commonJS = (cb, mod) => function __require() {
+var __commonJS = (cb, mod) => function __require2() {
   return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 };
 var __export = (target, all) => {
@@ -284,10 +290,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path4) {
-  if (!path4)
+function getElementAtPath(obj, path5) {
+  if (!path5)
     return obj;
-  return path4.reduce((acc, key) => acc?.[key], obj);
+  return path5.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -599,11 +605,11 @@ function aborted(x2, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path4, issues) {
+function prefixIssues(path5, issues) {
   return issues.map((iss) => {
     var _a2;
     (_a2 = iss).path ?? (_a2.path = []);
-    iss.path.unshift(path4);
+    iss.path.unshift(path5);
     return iss;
   });
 }
@@ -845,7 +851,7 @@ function formatError(error48, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error48, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error49, path4 = []) => {
+  const processError = (error49, path5 = []) => {
     var _a2, _b;
     for (const issue2 of error49.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
@@ -855,7 +861,7 @@ function treeifyError(error48, mapper = (issue2) => issue2.message) {
       } else if (issue2.code === "invalid_element") {
         processError({ issues: issue2.issues }, issue2.path);
       } else {
-        const fullpath = [...path4, ...issue2.path];
+        const fullpath = [...path5, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -887,8 +893,8 @@ function treeifyError(error48, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path4 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path4) {
+  const path5 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path5) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -13582,13 +13588,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path4 = ref.slice(1).split("/").filter(Boolean);
-  if (path4.length === 0) {
+  const path5 = ref.slice(1).split("/").filter(Boolean);
+  if (path5.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path4[0] === defsKey) {
-    const key = path4[1];
+  if (path5[0] === defsKey) {
+    const key = path5[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -14442,6 +14448,907 @@ var init_config_schema = __esm({
   }
 });
 
+// ../../node_modules/.pnpm/better-sqlite3@12.6.2/node_modules/better-sqlite3/lib/util.js
+var require_util = __commonJS({
+  "../../node_modules/.pnpm/better-sqlite3@12.6.2/node_modules/better-sqlite3/lib/util.js"(exports) {
+    "use strict";
+    exports.getBooleanOption = (options, key) => {
+      let value = false;
+      if (key in options && typeof (value = options[key]) !== "boolean") {
+        throw new TypeError(`Expected the "${key}" option to be a boolean`);
+      }
+      return value;
+    };
+    exports.cppdb = Symbol();
+    exports.inspect = Symbol.for("nodejs.util.inspect.custom");
+  }
+});
+
+// ../../node_modules/.pnpm/better-sqlite3@12.6.2/node_modules/better-sqlite3/lib/sqlite-error.js
+var require_sqlite_error = __commonJS({
+  "../../node_modules/.pnpm/better-sqlite3@12.6.2/node_modules/better-sqlite3/lib/sqlite-error.js"(exports, module) {
+    "use strict";
+    var descriptor = { value: "SqliteError", writable: true, enumerable: false, configurable: true };
+    function SqliteError(message, code) {
+      if (new.target !== SqliteError) {
+        return new SqliteError(message, code);
+      }
+      if (typeof code !== "string") {
+        throw new TypeError("Expected second argument to be a string");
+      }
+      Error.call(this, message);
+      descriptor.value = "" + message;
+      Object.defineProperty(this, "message", descriptor);
+      Error.captureStackTrace(this, SqliteError);
+      this.code = code;
+    }
+    Object.setPrototypeOf(SqliteError, Error);
+    Object.setPrototypeOf(SqliteError.prototype, Error.prototype);
+    Object.defineProperty(SqliteError.prototype, "name", descriptor);
+    module.exports = SqliteError;
+  }
+});
+
+// ../../node_modules/.pnpm/file-uri-to-path@1.0.0/node_modules/file-uri-to-path/index.js
+var require_file_uri_to_path = __commonJS({
+  "../../node_modules/.pnpm/file-uri-to-path@1.0.0/node_modules/file-uri-to-path/index.js"(exports, module) {
+    var sep2 = __require("path").sep || "/";
+    module.exports = fileUriToPath;
+    function fileUriToPath(uri) {
+      if ("string" != typeof uri || uri.length <= 7 || "file://" != uri.substring(0, 7)) {
+        throw new TypeError("must pass in a file:// URI to convert to a file path");
+      }
+      var rest = decodeURI(uri.substring(7));
+      var firstSlash = rest.indexOf("/");
+      var host = rest.substring(0, firstSlash);
+      var path5 = rest.substring(firstSlash + 1);
+      if ("localhost" == host) host = "";
+      if (host) {
+        host = sep2 + sep2 + host;
+      }
+      path5 = path5.replace(/^(.+)\|/, "$1:");
+      if (sep2 == "\\") {
+        path5 = path5.replace(/\//g, "\\");
+      }
+      if (/^.+\:/.test(path5)) {
+      } else {
+        path5 = sep2 + path5;
+      }
+      return host + path5;
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/bindings@1.5.0/node_modules/bindings/bindings.js
+var require_bindings = __commonJS({
+  "../../node_modules/.pnpm/bindings@1.5.0/node_modules/bindings/bindings.js"(exports, module) {
+    var fs5 = __require("fs");
+    var path5 = __require("path");
+    var fileURLToPath2 = require_file_uri_to_path();
+    var join2 = path5.join;
+    var dirname2 = path5.dirname;
+    var exists = fs5.accessSync && function(path6) {
+      try {
+        fs5.accessSync(path6);
+      } catch (e2) {
+        return false;
+      }
+      return true;
+    } || fs5.existsSync || path5.existsSync;
+    var defaults = {
+      arrow: process.env.NODE_BINDINGS_ARROW || " \u2192 ",
+      compiled: process.env.NODE_BINDINGS_COMPILED_DIR || "compiled",
+      platform: process.platform,
+      arch: process.arch,
+      nodePreGyp: "node-v" + process.versions.modules + "-" + process.platform + "-" + process.arch,
+      version: process.versions.node,
+      bindings: "bindings.node",
+      try: [
+        // node-gyp's linked version in the "build" dir
+        ["module_root", "build", "bindings"],
+        // node-waf and gyp_addon (a.k.a node-gyp)
+        ["module_root", "build", "Debug", "bindings"],
+        ["module_root", "build", "Release", "bindings"],
+        // Debug files, for development (legacy behavior, remove for node v0.9)
+        ["module_root", "out", "Debug", "bindings"],
+        ["module_root", "Debug", "bindings"],
+        // Release files, but manually compiled (legacy behavior, remove for node v0.9)
+        ["module_root", "out", "Release", "bindings"],
+        ["module_root", "Release", "bindings"],
+        // Legacy from node-waf, node <= 0.4.x
+        ["module_root", "build", "default", "bindings"],
+        // Production "Release" buildtype binary (meh...)
+        ["module_root", "compiled", "version", "platform", "arch", "bindings"],
+        // node-qbs builds
+        ["module_root", "addon-build", "release", "install-root", "bindings"],
+        ["module_root", "addon-build", "debug", "install-root", "bindings"],
+        ["module_root", "addon-build", "default", "install-root", "bindings"],
+        // node-pre-gyp path ./lib/binding/{node_abi}-{platform}-{arch}
+        ["module_root", "lib", "binding", "nodePreGyp", "bindings"]
+      ]
+    };
+    function bindings(opts) {
+      if (typeof opts == "string") {
+        opts = { bindings: opts };
+      } else if (!opts) {
+        opts = {};
+      }
+      Object.keys(defaults).map(function(i3) {
+        if (!(i3 in opts)) opts[i3] = defaults[i3];
+      });
+      if (!opts.module_root) {
+        opts.module_root = exports.getRoot(exports.getFileName());
+      }
+      if (path5.extname(opts.bindings) != ".node") {
+        opts.bindings += ".node";
+      }
+      var requireFunc = typeof __webpack_require__ === "function" ? __non_webpack_require__ : __require;
+      var tries = [], i2 = 0, l2 = opts.try.length, n2, b2, err;
+      for (; i2 < l2; i2++) {
+        n2 = join2.apply(
+          null,
+          opts.try[i2].map(function(p) {
+            return opts[p] || p;
+          })
+        );
+        tries.push(n2);
+        try {
+          b2 = opts.path ? requireFunc.resolve(n2) : requireFunc(n2);
+          if (!opts.path) {
+            b2.path = n2;
+          }
+          return b2;
+        } catch (e2) {
+          if (e2.code !== "MODULE_NOT_FOUND" && e2.code !== "QUALIFIED_PATH_RESOLUTION_FAILED" && !/not find/i.test(e2.message)) {
+            throw e2;
+          }
+        }
+      }
+      err = new Error(
+        "Could not locate the bindings file. Tried:\n" + tries.map(function(a2) {
+          return opts.arrow + a2;
+        }).join("\n")
+      );
+      err.tries = tries;
+      throw err;
+    }
+    module.exports = exports = bindings;
+    exports.getFileName = function getFileName(calling_file) {
+      var origPST = Error.prepareStackTrace, origSTL = Error.stackTraceLimit, dummy = {}, fileName;
+      Error.stackTraceLimit = 10;
+      Error.prepareStackTrace = function(e2, st) {
+        for (var i2 = 0, l2 = st.length; i2 < l2; i2++) {
+          fileName = st[i2].getFileName();
+          if (fileName !== __filename) {
+            if (calling_file) {
+              if (fileName !== calling_file) {
+                return;
+              }
+            } else {
+              return;
+            }
+          }
+        }
+      };
+      Error.captureStackTrace(dummy);
+      dummy.stack;
+      Error.prepareStackTrace = origPST;
+      Error.stackTraceLimit = origSTL;
+      var fileSchema = "file://";
+      if (fileName.indexOf(fileSchema) === 0) {
+        fileName = fileURLToPath2(fileName);
+      }
+      return fileName;
+    };
+    exports.getRoot = function getRoot(file2) {
+      var dir = dirname2(file2), prev;
+      while (true) {
+        if (dir === ".") {
+          dir = process.cwd();
+        }
+        if (exists(join2(dir, "package.json")) || exists(join2(dir, "node_modules"))) {
+          return dir;
+        }
+        if (prev === dir) {
+          throw new Error(
+            'Could not find module root given file: "' + file2 + '". Do you have a `package.json` file? '
+          );
+        }
+        prev = dir;
+        dir = join2(dir, "..");
+      }
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/better-sqlite3@12.6.2/node_modules/better-sqlite3/lib/methods/wrappers.js
+var require_wrappers = __commonJS({
+  "../../node_modules/.pnpm/better-sqlite3@12.6.2/node_modules/better-sqlite3/lib/methods/wrappers.js"(exports) {
+    "use strict";
+    var { cppdb } = require_util();
+    exports.prepare = function prepare(sql) {
+      return this[cppdb].prepare(sql, this, false);
+    };
+    exports.exec = function exec(sql) {
+      this[cppdb].exec(sql);
+      return this;
+    };
+    exports.close = function close() {
+      this[cppdb].close();
+      return this;
+    };
+    exports.loadExtension = function loadExtension(...args) {
+      this[cppdb].loadExtension(...args);
+      return this;
+    };
+    exports.defaultSafeIntegers = function defaultSafeIntegers(...args) {
+      this[cppdb].defaultSafeIntegers(...args);
+      return this;
+    };
+    exports.unsafeMode = function unsafeMode(...args) {
+      this[cppdb].unsafeMode(...args);
+      return this;
+    };
+    exports.getters = {
+      name: {
+        get: function name() {
+          return this[cppdb].name;
+        },
+        enumerable: true
+      },
+      open: {
+        get: function open() {
+          return this[cppdb].open;
+        },
+        enumerable: true
+      },
+      inTransaction: {
+        get: function inTransaction() {
+          return this[cppdb].inTransaction;
+        },
+        enumerable: true
+      },
+      readonly: {
+        get: function readonly2() {
+          return this[cppdb].readonly;
+        },
+        enumerable: true
+      },
+      memory: {
+        get: function memory() {
+          return this[cppdb].memory;
+        },
+        enumerable: true
+      }
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/better-sqlite3@12.6.2/node_modules/better-sqlite3/lib/methods/transaction.js
+var require_transaction = __commonJS({
+  "../../node_modules/.pnpm/better-sqlite3@12.6.2/node_modules/better-sqlite3/lib/methods/transaction.js"(exports, module) {
+    "use strict";
+    var { cppdb } = require_util();
+    var controllers = /* @__PURE__ */ new WeakMap();
+    module.exports = function transaction(fn) {
+      if (typeof fn !== "function") throw new TypeError("Expected first argument to be a function");
+      const db = this[cppdb];
+      const controller = getController(db, this);
+      const { apply } = Function.prototype;
+      const properties = {
+        default: { value: wrapTransaction(apply, fn, db, controller.default) },
+        deferred: { value: wrapTransaction(apply, fn, db, controller.deferred) },
+        immediate: { value: wrapTransaction(apply, fn, db, controller.immediate) },
+        exclusive: { value: wrapTransaction(apply, fn, db, controller.exclusive) },
+        database: { value: this, enumerable: true }
+      };
+      Object.defineProperties(properties.default.value, properties);
+      Object.defineProperties(properties.deferred.value, properties);
+      Object.defineProperties(properties.immediate.value, properties);
+      Object.defineProperties(properties.exclusive.value, properties);
+      return properties.default.value;
+    };
+    var getController = (db, self) => {
+      let controller = controllers.get(db);
+      if (!controller) {
+        const shared = {
+          commit: db.prepare("COMMIT", self, false),
+          rollback: db.prepare("ROLLBACK", self, false),
+          savepoint: db.prepare("SAVEPOINT `	_bs3.	`", self, false),
+          release: db.prepare("RELEASE `	_bs3.	`", self, false),
+          rollbackTo: db.prepare("ROLLBACK TO `	_bs3.	`", self, false)
+        };
+        controllers.set(db, controller = {
+          default: Object.assign({ begin: db.prepare("BEGIN", self, false) }, shared),
+          deferred: Object.assign({ begin: db.prepare("BEGIN DEFERRED", self, false) }, shared),
+          immediate: Object.assign({ begin: db.prepare("BEGIN IMMEDIATE", self, false) }, shared),
+          exclusive: Object.assign({ begin: db.prepare("BEGIN EXCLUSIVE", self, false) }, shared)
+        });
+      }
+      return controller;
+    };
+    var wrapTransaction = (apply, fn, db, { begin, commit, rollback, savepoint, release, rollbackTo }) => function sqliteTransaction() {
+      let before, after, undo;
+      if (db.inTransaction) {
+        before = savepoint;
+        after = release;
+        undo = rollbackTo;
+      } else {
+        before = begin;
+        after = commit;
+        undo = rollback;
+      }
+      before.run();
+      try {
+        const result = apply.call(fn, this, arguments);
+        if (result && typeof result.then === "function") {
+          throw new TypeError("Transaction function cannot return a promise");
+        }
+        after.run();
+        return result;
+      } catch (ex) {
+        if (db.inTransaction) {
+          undo.run();
+          if (undo !== rollback) after.run();
+        }
+        throw ex;
+      }
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/better-sqlite3@12.6.2/node_modules/better-sqlite3/lib/methods/pragma.js
+var require_pragma = __commonJS({
+  "../../node_modules/.pnpm/better-sqlite3@12.6.2/node_modules/better-sqlite3/lib/methods/pragma.js"(exports, module) {
+    "use strict";
+    var { getBooleanOption, cppdb } = require_util();
+    module.exports = function pragma(source, options) {
+      if (options == null) options = {};
+      if (typeof source !== "string") throw new TypeError("Expected first argument to be a string");
+      if (typeof options !== "object") throw new TypeError("Expected second argument to be an options object");
+      const simple = getBooleanOption(options, "simple");
+      const stmt = this[cppdb].prepare(`PRAGMA ${source}`, this, true);
+      return simple ? stmt.pluck().get() : stmt.all();
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/better-sqlite3@12.6.2/node_modules/better-sqlite3/lib/methods/backup.js
+var require_backup = __commonJS({
+  "../../node_modules/.pnpm/better-sqlite3@12.6.2/node_modules/better-sqlite3/lib/methods/backup.js"(exports, module) {
+    "use strict";
+    var fs5 = __require("fs");
+    var path5 = __require("path");
+    var { promisify } = __require("util");
+    var { cppdb } = require_util();
+    var fsAccess = promisify(fs5.access);
+    module.exports = async function backup(filename, options) {
+      if (options == null) options = {};
+      if (typeof filename !== "string") throw new TypeError("Expected first argument to be a string");
+      if (typeof options !== "object") throw new TypeError("Expected second argument to be an options object");
+      filename = filename.trim();
+      const attachedName = "attached" in options ? options.attached : "main";
+      const handler = "progress" in options ? options.progress : null;
+      if (!filename) throw new TypeError("Backup filename cannot be an empty string");
+      if (filename === ":memory:") throw new TypeError('Invalid backup filename ":memory:"');
+      if (typeof attachedName !== "string") throw new TypeError('Expected the "attached" option to be a string');
+      if (!attachedName) throw new TypeError('The "attached" option cannot be an empty string');
+      if (handler != null && typeof handler !== "function") throw new TypeError('Expected the "progress" option to be a function');
+      await fsAccess(path5.dirname(filename)).catch(() => {
+        throw new TypeError("Cannot save backup because the directory does not exist");
+      });
+      const isNewFile = await fsAccess(filename).then(() => false, () => true);
+      return runBackup(this[cppdb].backup(this, attachedName, filename, isNewFile), handler || null);
+    };
+    var runBackup = (backup, handler) => {
+      let rate = 0;
+      let useDefault = true;
+      return new Promise((resolve, reject) => {
+        setImmediate(function step() {
+          try {
+            const progress = backup.transfer(rate);
+            if (!progress.remainingPages) {
+              backup.close();
+              resolve(progress);
+              return;
+            }
+            if (useDefault) {
+              useDefault = false;
+              rate = 100;
+            }
+            if (handler) {
+              const ret = handler(progress);
+              if (ret !== void 0) {
+                if (typeof ret === "number" && ret === ret) rate = Math.max(0, Math.min(2147483647, Math.round(ret)));
+                else throw new TypeError("Expected progress callback to return a number or undefined");
+              }
+            }
+            setImmediate(step);
+          } catch (err) {
+            backup.close();
+            reject(err);
+          }
+        });
+      });
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/better-sqlite3@12.6.2/node_modules/better-sqlite3/lib/methods/serialize.js
+var require_serialize = __commonJS({
+  "../../node_modules/.pnpm/better-sqlite3@12.6.2/node_modules/better-sqlite3/lib/methods/serialize.js"(exports, module) {
+    "use strict";
+    var { cppdb } = require_util();
+    module.exports = function serialize(options) {
+      if (options == null) options = {};
+      if (typeof options !== "object") throw new TypeError("Expected first argument to be an options object");
+      const attachedName = "attached" in options ? options.attached : "main";
+      if (typeof attachedName !== "string") throw new TypeError('Expected the "attached" option to be a string');
+      if (!attachedName) throw new TypeError('The "attached" option cannot be an empty string');
+      return this[cppdb].serialize(attachedName);
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/better-sqlite3@12.6.2/node_modules/better-sqlite3/lib/methods/function.js
+var require_function = __commonJS({
+  "../../node_modules/.pnpm/better-sqlite3@12.6.2/node_modules/better-sqlite3/lib/methods/function.js"(exports, module) {
+    "use strict";
+    var { getBooleanOption, cppdb } = require_util();
+    module.exports = function defineFunction(name, options, fn) {
+      if (options == null) options = {};
+      if (typeof options === "function") {
+        fn = options;
+        options = {};
+      }
+      if (typeof name !== "string") throw new TypeError("Expected first argument to be a string");
+      if (typeof fn !== "function") throw new TypeError("Expected last argument to be a function");
+      if (typeof options !== "object") throw new TypeError("Expected second argument to be an options object");
+      if (!name) throw new TypeError("User-defined function name cannot be an empty string");
+      const safeIntegers = "safeIntegers" in options ? +getBooleanOption(options, "safeIntegers") : 2;
+      const deterministic = getBooleanOption(options, "deterministic");
+      const directOnly = getBooleanOption(options, "directOnly");
+      const varargs = getBooleanOption(options, "varargs");
+      let argCount = -1;
+      if (!varargs) {
+        argCount = fn.length;
+        if (!Number.isInteger(argCount) || argCount < 0) throw new TypeError("Expected function.length to be a positive integer");
+        if (argCount > 100) throw new RangeError("User-defined functions cannot have more than 100 arguments");
+      }
+      this[cppdb].function(fn, name, argCount, safeIntegers, deterministic, directOnly);
+      return this;
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/better-sqlite3@12.6.2/node_modules/better-sqlite3/lib/methods/aggregate.js
+var require_aggregate = __commonJS({
+  "../../node_modules/.pnpm/better-sqlite3@12.6.2/node_modules/better-sqlite3/lib/methods/aggregate.js"(exports, module) {
+    "use strict";
+    var { getBooleanOption, cppdb } = require_util();
+    module.exports = function defineAggregate(name, options) {
+      if (typeof name !== "string") throw new TypeError("Expected first argument to be a string");
+      if (typeof options !== "object" || options === null) throw new TypeError("Expected second argument to be an options object");
+      if (!name) throw new TypeError("User-defined function name cannot be an empty string");
+      const start = "start" in options ? options.start : null;
+      const step = getFunctionOption(options, "step", true);
+      const inverse = getFunctionOption(options, "inverse", false);
+      const result = getFunctionOption(options, "result", false);
+      const safeIntegers = "safeIntegers" in options ? +getBooleanOption(options, "safeIntegers") : 2;
+      const deterministic = getBooleanOption(options, "deterministic");
+      const directOnly = getBooleanOption(options, "directOnly");
+      const varargs = getBooleanOption(options, "varargs");
+      let argCount = -1;
+      if (!varargs) {
+        argCount = Math.max(getLength(step), inverse ? getLength(inverse) : 0);
+        if (argCount > 0) argCount -= 1;
+        if (argCount > 100) throw new RangeError("User-defined functions cannot have more than 100 arguments");
+      }
+      this[cppdb].aggregate(start, step, inverse, result, name, argCount, safeIntegers, deterministic, directOnly);
+      return this;
+    };
+    var getFunctionOption = (options, key, required2) => {
+      const value = key in options ? options[key] : null;
+      if (typeof value === "function") return value;
+      if (value != null) throw new TypeError(`Expected the "${key}" option to be a function`);
+      if (required2) throw new TypeError(`Missing required option "${key}"`);
+      return null;
+    };
+    var getLength = ({ length }) => {
+      if (Number.isInteger(length) && length >= 0) return length;
+      throw new TypeError("Expected function.length to be a positive integer");
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/better-sqlite3@12.6.2/node_modules/better-sqlite3/lib/methods/table.js
+var require_table = __commonJS({
+  "../../node_modules/.pnpm/better-sqlite3@12.6.2/node_modules/better-sqlite3/lib/methods/table.js"(exports, module) {
+    "use strict";
+    var { cppdb } = require_util();
+    module.exports = function defineTable(name, factory) {
+      if (typeof name !== "string") throw new TypeError("Expected first argument to be a string");
+      if (!name) throw new TypeError("Virtual table module name cannot be an empty string");
+      let eponymous = false;
+      if (typeof factory === "object" && factory !== null) {
+        eponymous = true;
+        factory = defer(parseTableDefinition(factory, "used", name));
+      } else {
+        if (typeof factory !== "function") throw new TypeError("Expected second argument to be a function or a table definition object");
+        factory = wrapFactory(factory);
+      }
+      this[cppdb].table(factory, name, eponymous);
+      return this;
+    };
+    function wrapFactory(factory) {
+      return function virtualTableFactory(moduleName, databaseName, tableName, ...args) {
+        const thisObject = {
+          module: moduleName,
+          database: databaseName,
+          table: tableName
+        };
+        const def = apply.call(factory, thisObject, args);
+        if (typeof def !== "object" || def === null) {
+          throw new TypeError(`Virtual table module "${moduleName}" did not return a table definition object`);
+        }
+        return parseTableDefinition(def, "returned", moduleName);
+      };
+    }
+    function parseTableDefinition(def, verb, moduleName) {
+      if (!hasOwnProperty.call(def, "rows")) {
+        throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition without a "rows" property`);
+      }
+      if (!hasOwnProperty.call(def, "columns")) {
+        throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition without a "columns" property`);
+      }
+      const rows = def.rows;
+      if (typeof rows !== "function" || Object.getPrototypeOf(rows) !== GeneratorFunctionPrototype) {
+        throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with an invalid "rows" property (should be a generator function)`);
+      }
+      let columns = def.columns;
+      if (!Array.isArray(columns) || !(columns = [...columns]).every((x2) => typeof x2 === "string")) {
+        throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with an invalid "columns" property (should be an array of strings)`);
+      }
+      if (columns.length !== new Set(columns).size) {
+        throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with duplicate column names`);
+      }
+      if (!columns.length) {
+        throw new RangeError(`Virtual table module "${moduleName}" ${verb} a table definition with zero columns`);
+      }
+      let parameters;
+      if (hasOwnProperty.call(def, "parameters")) {
+        parameters = def.parameters;
+        if (!Array.isArray(parameters) || !(parameters = [...parameters]).every((x2) => typeof x2 === "string")) {
+          throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with an invalid "parameters" property (should be an array of strings)`);
+        }
+      } else {
+        parameters = inferParameters(rows);
+      }
+      if (parameters.length !== new Set(parameters).size) {
+        throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with duplicate parameter names`);
+      }
+      if (parameters.length > 32) {
+        throw new RangeError(`Virtual table module "${moduleName}" ${verb} a table definition with more than the maximum number of 32 parameters`);
+      }
+      for (const parameter of parameters) {
+        if (columns.includes(parameter)) {
+          throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with column "${parameter}" which was ambiguously defined as both a column and parameter`);
+        }
+      }
+      let safeIntegers = 2;
+      if (hasOwnProperty.call(def, "safeIntegers")) {
+        const bool = def.safeIntegers;
+        if (typeof bool !== "boolean") {
+          throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with an invalid "safeIntegers" property (should be a boolean)`);
+        }
+        safeIntegers = +bool;
+      }
+      let directOnly = false;
+      if (hasOwnProperty.call(def, "directOnly")) {
+        directOnly = def.directOnly;
+        if (typeof directOnly !== "boolean") {
+          throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with an invalid "directOnly" property (should be a boolean)`);
+        }
+      }
+      const columnDefinitions = [
+        ...parameters.map(identifier).map((str) => `${str} HIDDEN`),
+        ...columns.map(identifier)
+      ];
+      return [
+        `CREATE TABLE x(${columnDefinitions.join(", ")});`,
+        wrapGenerator(rows, new Map(columns.map((x2, i2) => [x2, parameters.length + i2])), moduleName),
+        parameters,
+        safeIntegers,
+        directOnly
+      ];
+    }
+    function wrapGenerator(generator, columnMap, moduleName) {
+      return function* virtualTable(...args) {
+        const output = args.map((x2) => Buffer.isBuffer(x2) ? Buffer.from(x2) : x2);
+        for (let i2 = 0; i2 < columnMap.size; ++i2) {
+          output.push(null);
+        }
+        for (const row of generator(...args)) {
+          if (Array.isArray(row)) {
+            extractRowArray(row, output, columnMap.size, moduleName);
+            yield output;
+          } else if (typeof row === "object" && row !== null) {
+            extractRowObject(row, output, columnMap, moduleName);
+            yield output;
+          } else {
+            throw new TypeError(`Virtual table module "${moduleName}" yielded something that isn't a valid row object`);
+          }
+        }
+      };
+    }
+    function extractRowArray(row, output, columnCount, moduleName) {
+      if (row.length !== columnCount) {
+        throw new TypeError(`Virtual table module "${moduleName}" yielded a row with an incorrect number of columns`);
+      }
+      const offset = output.length - columnCount;
+      for (let i2 = 0; i2 < columnCount; ++i2) {
+        output[i2 + offset] = row[i2];
+      }
+    }
+    function extractRowObject(row, output, columnMap, moduleName) {
+      let count = 0;
+      for (const key of Object.keys(row)) {
+        const index = columnMap.get(key);
+        if (index === void 0) {
+          throw new TypeError(`Virtual table module "${moduleName}" yielded a row with an undeclared column "${key}"`);
+        }
+        output[index] = row[key];
+        count += 1;
+      }
+      if (count !== columnMap.size) {
+        throw new TypeError(`Virtual table module "${moduleName}" yielded a row with missing columns`);
+      }
+    }
+    function inferParameters({ length }) {
+      if (!Number.isInteger(length) || length < 0) {
+        throw new TypeError("Expected function.length to be a positive integer");
+      }
+      const params = [];
+      for (let i2 = 0; i2 < length; ++i2) {
+        params.push(`$${i2 + 1}`);
+      }
+      return params;
+    }
+    var { hasOwnProperty } = Object.prototype;
+    var { apply } = Function.prototype;
+    var GeneratorFunctionPrototype = Object.getPrototypeOf(function* () {
+    });
+    var identifier = (str) => `"${str.replace(/"/g, '""')}"`;
+    var defer = (x2) => () => x2;
+  }
+});
+
+// ../../node_modules/.pnpm/better-sqlite3@12.6.2/node_modules/better-sqlite3/lib/methods/inspect.js
+var require_inspect = __commonJS({
+  "../../node_modules/.pnpm/better-sqlite3@12.6.2/node_modules/better-sqlite3/lib/methods/inspect.js"(exports, module) {
+    "use strict";
+    var DatabaseInspection = function Database() {
+    };
+    module.exports = function inspect(depth, opts) {
+      return Object.assign(new DatabaseInspection(), this);
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/better-sqlite3@12.6.2/node_modules/better-sqlite3/lib/database.js
+var require_database = __commonJS({
+  "../../node_modules/.pnpm/better-sqlite3@12.6.2/node_modules/better-sqlite3/lib/database.js"(exports, module) {
+    "use strict";
+    var fs5 = __require("fs");
+    var path5 = __require("path");
+    var util = require_util();
+    var SqliteError = require_sqlite_error();
+    var DEFAULT_ADDON;
+    function Database(filenameGiven, options) {
+      if (new.target == null) {
+        return new Database(filenameGiven, options);
+      }
+      let buffer;
+      if (Buffer.isBuffer(filenameGiven)) {
+        buffer = filenameGiven;
+        filenameGiven = ":memory:";
+      }
+      if (filenameGiven == null) filenameGiven = "";
+      if (options == null) options = {};
+      if (typeof filenameGiven !== "string") throw new TypeError("Expected first argument to be a string");
+      if (typeof options !== "object") throw new TypeError("Expected second argument to be an options object");
+      if ("readOnly" in options) throw new TypeError('Misspelled option "readOnly" should be "readonly"');
+      if ("memory" in options) throw new TypeError('Option "memory" was removed in v7.0.0 (use ":memory:" filename instead)');
+      const filename = filenameGiven.trim();
+      const anonymous = filename === "" || filename === ":memory:";
+      const readonly2 = util.getBooleanOption(options, "readonly");
+      const fileMustExist = util.getBooleanOption(options, "fileMustExist");
+      const timeout = "timeout" in options ? options.timeout : 5e3;
+      const verbose = "verbose" in options ? options.verbose : null;
+      const nativeBinding = "nativeBinding" in options ? options.nativeBinding : null;
+      if (readonly2 && anonymous && !buffer) throw new TypeError("In-memory/temporary databases cannot be readonly");
+      if (!Number.isInteger(timeout) || timeout < 0) throw new TypeError('Expected the "timeout" option to be a positive integer');
+      if (timeout > 2147483647) throw new RangeError('Option "timeout" cannot be greater than 2147483647');
+      if (verbose != null && typeof verbose !== "function") throw new TypeError('Expected the "verbose" option to be a function');
+      if (nativeBinding != null && typeof nativeBinding !== "string" && typeof nativeBinding !== "object") throw new TypeError('Expected the "nativeBinding" option to be a string or addon object');
+      let addon;
+      if (nativeBinding == null) {
+        addon = DEFAULT_ADDON || (DEFAULT_ADDON = require_bindings()("better_sqlite3.node"));
+      } else if (typeof nativeBinding === "string") {
+        const requireFunc = typeof __non_webpack_require__ === "function" ? __non_webpack_require__ : __require;
+        addon = requireFunc(path5.resolve(nativeBinding).replace(/(\.node)?$/, ".node"));
+      } else {
+        addon = nativeBinding;
+      }
+      if (!addon.isInitialized) {
+        addon.setErrorConstructor(SqliteError);
+        addon.isInitialized = true;
+      }
+      if (!anonymous && !filename.startsWith("file:") && !fs5.existsSync(path5.dirname(filename))) {
+        throw new TypeError("Cannot open database because the directory does not exist");
+      }
+      Object.defineProperties(this, {
+        [util.cppdb]: { value: new addon.Database(filename, filenameGiven, anonymous, readonly2, fileMustExist, timeout, verbose || null, buffer || null) },
+        ...wrappers.getters
+      });
+    }
+    var wrappers = require_wrappers();
+    Database.prototype.prepare = wrappers.prepare;
+    Database.prototype.transaction = require_transaction();
+    Database.prototype.pragma = require_pragma();
+    Database.prototype.backup = require_backup();
+    Database.prototype.serialize = require_serialize();
+    Database.prototype.function = require_function();
+    Database.prototype.aggregate = require_aggregate();
+    Database.prototype.table = require_table();
+    Database.prototype.loadExtension = wrappers.loadExtension;
+    Database.prototype.exec = wrappers.exec;
+    Database.prototype.close = wrappers.close;
+    Database.prototype.defaultSafeIntegers = wrappers.defaultSafeIntegers;
+    Database.prototype.unsafeMode = wrappers.unsafeMode;
+    Database.prototype[util.inspect] = require_inspect();
+    module.exports = Database;
+  }
+});
+
+// ../../node_modules/.pnpm/better-sqlite3@12.6.2/node_modules/better-sqlite3/lib/index.js
+var require_lib = __commonJS({
+  "../../node_modules/.pnpm/better-sqlite3@12.6.2/node_modules/better-sqlite3/lib/index.js"(exports, module) {
+    "use strict";
+    module.exports = require_database();
+    module.exports.SqliteError = require_sqlite_error();
+  }
+});
+
+// src/cleanup-command.ts
+var cleanup_command_exports = {};
+__export(cleanup_command_exports, {
+  runCleanup: () => runCleanup
+});
+import { confirm } from "@inquirer/prompts";
+import fs from "fs";
+import path from "path";
+import http from "node:http";
+function readPort(dorkHome) {
+  try {
+    const raw = fs.readFileSync(path.join(dorkHome, "config.json"), "utf-8");
+    const config2 = JSON.parse(raw);
+    const port2 = config2?.server?.port;
+    if (typeof port2 === "number" && port2 > 0) return port2;
+  } catch {
+  }
+  return DEFAULT_PORT2;
+}
+function isServerRunning(port2) {
+  return new Promise((resolve) => {
+    const req = http.get(`http://localhost:${port2}/api/health`, { timeout: 1e3 }, (res) => {
+      res.resume();
+      resolve(res.statusCode === 200);
+    });
+    req.on("error", () => resolve(false));
+    req.on("timeout", () => {
+      req.destroy();
+      resolve(false);
+    });
+  });
+}
+async function findProjectPaths(dbPath) {
+  try {
+    const { default: Database } = await Promise.resolve().then(() => __toESM(require_lib(), 1));
+    const db = new Database(dbPath, { readonly: true });
+    try {
+      const rows = db.prepare("SELECT DISTINCT project_path FROM agents").all();
+      return rows.map((r3) => r3.project_path).filter((p) => fs.existsSync(path.join(p, ".dork")));
+    } finally {
+      db.close();
+    }
+  } catch {
+    return [];
+  }
+}
+async function runCleanup(options) {
+  const { dorkHome } = options;
+  if (!fs.existsSync(dorkHome)) {
+    console.log("\nNo DorkOS data found. Nothing to clean up.\n");
+    return;
+  }
+  const port2 = readPort(dorkHome);
+  if (await isServerRunning(port2)) {
+    console.log(
+      `
+DorkOS server is running on port ${port2}. Stop it before running cleanup.
+`
+    );
+    process.exitCode = 1;
+    return;
+  }
+  console.log("\nDorkOS Cleanup\n");
+  const entries = fs.readdirSync(dorkHome);
+  if (entries.length === 0) {
+    console.log("No DorkOS data found. Nothing to clean up.\n");
+    return;
+  }
+  console.log(`Global data (${dorkHome}):`);
+  for (const entry of entries) {
+    const description = KNOWN_ENTRIES[entry] ?? "unknown";
+    console.log(`  ${entry.padEnd(20)} (${description})`);
+  }
+  console.log("");
+  const dbPath = path.join(dorkHome, "dork.db");
+  const projectPaths = fs.existsSync(dbPath) ? await findProjectPaths(dbPath) : [];
+  const removeGlobal = await confirm({
+    message: `Remove global DorkOS data (${dorkHome})?`,
+    default: false
+  });
+  if (!removeGlobal) {
+    console.log("\n  Aborted.\n");
+    return;
+  }
+  fs.rmSync(dorkHome, { recursive: true, force: true });
+  console.log(`
+  Removed ${dorkHome}
+`);
+  if (projectPaths.length > 0) {
+    console.log(`Found ${projectPaths.length} project(s) with agent data:`);
+    for (const p of projectPaths) {
+      console.log(`  ${p}/.dork/`);
+    }
+    console.log("");
+    const removeProjects = await confirm({
+      message: "Also remove per-project agent data?",
+      default: false
+    });
+    if (removeProjects) {
+      for (const p of projectPaths) {
+        const dorkDir = path.join(p, ".dork");
+        fs.rmSync(dorkDir, { recursive: true, force: true });
+        console.log(`  Removed ${dorkDir}`);
+      }
+      console.log("");
+    } else {
+      console.log("\n  Skipped per-project data.\n");
+    }
+  }
+  console.log("Will NOT touch:");
+  console.log("  ~/.claude/           (Claude Code \u2014 not managed by DorkOS)\n");
+  console.log("To complete uninstall: npm uninstall -g dorkos\n");
+}
+var DEFAULT_PORT2, KNOWN_ENTRIES;
+var init_cleanup_command = __esm({
+  "src/cleanup-command.ts"() {
+    "use strict";
+    DEFAULT_PORT2 = 4242;
+    KNOWN_ENTRIES = {
+      "config.json": "user configuration",
+      "dork.db": "SQLite database",
+      "dork.db-wal": "SQLite write-ahead log",
+      "dork.db-shm": "SQLite shared memory",
+      logs: "server logs",
+      relay: "adapter state"
+    };
+  }
+});
+
 // ../../node_modules/.pnpm/consola@3.4.2/node_modules/consola/dist/core.mjs
 function isPlainObject$1(value) {
   if (value === null || typeof value !== "object") {
@@ -16338,8 +17245,8 @@ __export(config_manager_exports, {
   initConfigManager: () => initConfigManager
 });
 import Conf from "conf";
-import fs from "fs";
-import path from "path";
+import fs2 from "fs";
+import path2 from "path";
 function initConfigManager(dorkHome) {
   configManager = new ConfigManager(dorkHome);
   return configManager;
@@ -16360,8 +17267,8 @@ var init_config_manager = __esm({
       _isFirstRun = false;
       constructor(dorkHome) {
         const configDir = dorkHome;
-        const configPath = path.join(configDir, "config.json");
-        this._isFirstRun = !fs.existsSync(configPath);
+        const configPath = path2.join(configDir, "config.json");
+        this._isFirstRun = !fs2.existsSync(configPath);
         try {
           this.store = new Conf({
             configName: "config",
@@ -16378,11 +17285,12 @@ var init_config_manager = __esm({
               }
             }
           });
+          logger.info(`[Config] Loaded from ${configPath} (first run: ${this._isFirstRun})`);
         } catch (_error) {
-          if (fs.existsSync(configPath)) {
+          if (fs2.existsSync(configPath)) {
             const backupPath = configPath + ".bak";
-            fs.copyFileSync(configPath, backupPath);
-            fs.unlinkSync(configPath);
+            fs2.copyFileSync(configPath, backupPath);
+            fs2.unlinkSync(configPath);
             logger.warn(`Corrupt config backed up to ${backupPath}`);
             logger.warn("Creating fresh config with defaults.");
           }
@@ -16625,19 +17533,19 @@ var init_wizard_exports = {};
 __export(init_wizard_exports, {
   runInitWizard: () => runInitWizard
 });
-import { input, select, confirm } from "@inquirer/prompts";
-import fs2 from "fs";
-import path2 from "path";
+import { input, select, confirm as confirm2 } from "@inquirer/prompts";
+import fs3 from "fs";
+import path3 from "path";
 async function runInitWizard(options) {
   const { yes, dorkHome, store } = options;
-  const configPath = path2.join(dorkHome, "config.json");
+  const configPath = path3.join(dorkHome, "config.json");
   if (yes) {
     store.reset();
     console.log(`Config initialized with defaults at ${configPath}`);
     return;
   }
-  if (fs2.existsSync(configPath)) {
-    const overwrite = await confirm({
+  if (fs3.existsSync(configPath)) {
+    const overwrite = await confirm2({
       message: "Config already exists. Overwrite with new settings?",
       default: false
     });
@@ -16667,7 +17575,7 @@ async function runInitWizard(options) {
     ],
     default: "system"
   });
-  const tunnelEnabled = await confirm({
+  const tunnelEnabled = await confirm2({
     message: "Enable tunnel by default?",
     default: false
   });
@@ -16680,7 +17588,7 @@ async function runInitWizard(options) {
   store.setDot("ui.theme", theme);
   store.setDot("tunnel.enabled", tunnelEnabled);
   if (cwd && cwd.trim() !== "") {
-    store.setDot("server.cwd", path2.resolve(cwd));
+    store.setDot("server.cwd", path3.resolve(cwd));
   }
   console.log(`
 Config saved to ${configPath}`);
@@ -17841,9 +18749,9 @@ var require_main = __commonJS({
 // src/cli.ts
 import { parseArgs } from "node:util";
 import os, { networkInterfaces } from "os";
-import path3 from "path";
+import path4 from "path";
 import { fileURLToPath } from "url";
-import fs3 from "fs";
+import fs4 from "fs";
 
 // src/check-claude.ts
 import { execSync } from "child_process";
@@ -17925,7 +18833,7 @@ var cliEnvSchema = external_exports.object({
 var env = cliEnvSchema.parse(process.env);
 
 // src/cli.ts
-var __dirname = path3.dirname(fileURLToPath(import.meta.url));
+var __dirname = path4.dirname(fileURLToPath(import.meta.url));
 var { values, positionals } = parseArgs({
   options: {
     port: { type: "string", short: "p" },
@@ -17958,6 +18866,7 @@ Commands:
   config validate      Check config validity
   init                 Interactive setup wizard
   init --yes           Accept all defaults
+  cleanup              Remove all DorkOS data
 
 Options:
   -p, --port <port>      Port to listen on (default: ${DEFAULT_PORT})
@@ -17988,20 +18897,25 @@ Examples:
   process.exit(0);
 }
 if (values.version) {
-  console.log("0.12.0");
+  console.log("0.13.0");
   process.exit(0);
 }
 if (values["post-install-check"]) {
   checkClaude();
-  console.log(`dorkos ${"0.12.0"}`);
+  console.log(`dorkos ${"0.13.0"}`);
   console.log("Installation verified.");
   process.exit(0);
 }
-var DORK_HOME = env.DORK_HOME || path3.join(os.homedir(), ".dork");
-fs3.mkdirSync(DORK_HOME, { recursive: true });
-fs3.mkdirSync(path3.join(DORK_HOME, "logs"), { recursive: true });
-process.env.DORK_HOME = DORK_HOME;
+var DORK_HOME = env.DORK_HOME || path4.join(os.homedir(), ".dork");
 var subcommand = positionals[0];
+if (subcommand === "cleanup") {
+  const { runCleanup: runCleanup2 } = await Promise.resolve().then(() => (init_cleanup_command(), cleanup_command_exports));
+  await runCleanup2({ dorkHome: DORK_HOME });
+  process.exit(process.exitCode ?? 0);
+}
+fs4.mkdirSync(DORK_HOME, { recursive: true });
+fs4.mkdirSync(path4.join(DORK_HOME, "logs"), { recursive: true });
+process.env.DORK_HOME = DORK_HOME;
 if (subcommand === "config") {
   const { initConfigManager: initConfigManager3 } = await Promise.resolve().then(() => (init_config_manager(), config_manager_exports));
   const cfgMgr2 = initConfigManager3(DORK_HOME);
@@ -18030,7 +18944,7 @@ if (cliPort) {
   process.env.DORKOS_PORT = configPort ? String(configPort) : String(DEFAULT_PORT);
 }
 process.env.NODE_ENV = "production";
-process.env.CLIENT_DIST_PATH = path3.join(__dirname, "../client");
+process.env.CLIENT_DIST_PATH = path4.join(__dirname, "../client");
 if (values.tunnel) {
   process.env.TUNNEL_ENABLED = "true";
 } else if (!process.env.TUNNEL_ENABLED && cfgMgr.getDot("tunnel.enabled")) {
@@ -18055,30 +18969,30 @@ if (values.pulse !== void 0) {
 }
 var cliDir = values.dir;
 if (cliDir) {
-  process.env.DORKOS_DEFAULT_CWD = path3.resolve(cliDir);
+  process.env.DORKOS_DEFAULT_CWD = path4.resolve(cliDir);
 } else if (!process.env.DORKOS_DEFAULT_CWD) {
   const configCwd = cfgMgr.getDot("server.cwd");
-  process.env.DORKOS_DEFAULT_CWD = configCwd ? path3.resolve(configCwd) : process.cwd();
+  process.env.DORKOS_DEFAULT_CWD = configCwd ? path4.resolve(configCwd) : process.cwd();
 }
 var cliBoundary = values.boundary;
 if (cliBoundary) {
-  process.env.DORKOS_BOUNDARY = path3.resolve(cliBoundary);
+  process.env.DORKOS_BOUNDARY = path4.resolve(cliBoundary);
 } else if (!process.env.DORKOS_BOUNDARY) {
   const configBoundary = cfgMgr.getDot("server.boundary");
   if (configBoundary) {
-    process.env.DORKOS_BOUNDARY = path3.resolve(configBoundary);
+    process.env.DORKOS_BOUNDARY = path4.resolve(configBoundary);
   }
 }
 var boundaryVal = process.env.DORKOS_BOUNDARY;
 var home = os.homedir();
-if (boundaryVal && !boundaryVal.startsWith(home + path3.sep) && boundaryVal !== home) {
+if (boundaryVal && !boundaryVal.startsWith(home + path4.sep) && boundaryVal !== home) {
   console.warn(
     `[Warning] Directory boundary "${boundaryVal}" is above home directory "${home}". This grants access to system directories.`
   );
 }
 var effectiveBoundary = process.env.DORKOS_BOUNDARY || home;
 var resolvedDir = process.env.DORKOS_DEFAULT_CWD;
-if (resolvedDir !== effectiveBoundary && !resolvedDir.startsWith(effectiveBoundary + path3.sep)) {
+if (resolvedDir !== effectiveBoundary && !resolvedDir.startsWith(effectiveBoundary + path4.sep)) {
   console.warn(
     `[Warning] Default CWD "${resolvedDir}" is outside boundary "${effectiveBoundary}". Falling back to boundary root.`
   );
@@ -18086,15 +19000,15 @@ if (resolvedDir !== effectiveBoundary && !resolvedDir.startsWith(effectiveBounda
 }
 var logLevelName = values["log-level"] || env.LOG_LEVEL || cfgMgr.getDot("logging.level") || (env.NODE_ENV === "production" ? "info" : "debug");
 process.env.DORKOS_LOG_LEVEL = String(LOG_LEVEL_MAP[logLevelName] ?? 3);
-var envPath = path3.join(process.env.DORKOS_DEFAULT_CWD, ".env");
-if (fs3.existsSync(envPath)) {
+var envPath = path4.join(process.env.DORKOS_DEFAULT_CWD, ".env");
+if (fs4.existsSync(envPath)) {
   const dotenv = await import("dotenv");
   dotenv.config({ path: envPath, override: false });
 }
 await import("../server/index.js");
 var port = process.env.DORKOS_PORT || String(DEFAULT_PORT);
 console.log("");
-console.log(`  DorkOS v${"0.12.0"}`);
+console.log(`  DorkOS v${"0.13.0"}`);
 console.log(`  Local:   http://localhost:${port}`);
 var nets = networkInterfaces();
 var networkUrl = null;
@@ -18150,9 +19064,9 @@ console.log("");
     }
   });
 }
-checkForUpdate("0.12.0").then((latestVersion) => {
+checkForUpdate("0.13.0").then((latestVersion) => {
   if (latestVersion) {
-    const msg = `Update available: ${"0.12.0"} \u2192 ${latestVersion}`;
+    const msg = `Update available: ${"0.13.0"} \u2192 ${latestVersion}`;
     const cmd = "Run npm install -g dorkos@latest to update";
     const width = Math.max(msg.length, cmd.length) + 6;
     const pad = (s2) => `\u2502   ${s2}${" ".repeat(width - s2.length - 6)}   \u2502`;