@mndrk/agx 2.0.21 → 2.0.23

package/cloud-runtime/standalone/Projects/Agents/agx-cloud/worker/index.js

@@ -1,4780 +0,0 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
-var __commonJS = (cb, mod) => function __require() {
-  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
-};
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// ../agx-cloud/node_modules/better-sqlite3/lib/util.js
-var require_util = __commonJS({
-  "../agx-cloud/node_modules/better-sqlite3/lib/util.js"(exports2) {
-    "use strict";
-    exports2.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;
-    };
-    exports2.cppdb = Symbol();
-    exports2.inspect = Symbol.for("nodejs.util.inspect.custom");
-  }
-});
-
-// ../agx-cloud/node_modules/better-sqlite3/lib/sqlite-error.js
-var require_sqlite_error = __commonJS({
-  "../agx-cloud/node_modules/better-sqlite3/lib/sqlite-error.js"(exports2, module2) {
-    "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);
-    module2.exports = SqliteError;
-  }
-});
-
-// ../agx-cloud/node_modules/file-uri-to-path/index.js
-var require_file_uri_to_path = __commonJS({
-  "../agx-cloud/node_modules/file-uri-to-path/index.js"(exports2, module2) {
-    var sep = require("path").sep || "/";
-    module2.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 path4 = rest.substring(firstSlash + 1);
-      if ("localhost" == host) host = "";
-      if (host) {
-        host = sep + sep + host;
-      }
-      path4 = path4.replace(/^(.+)\|/, "$1:");
-      if (sep == "\\") {
-        path4 = path4.replace(/\//g, "\\");
-      }
-      if (/^.+\:/.test(path4)) {
-      } else {
-        path4 = sep + path4;
-      }
-      return host + path4;
-    }
-  }
-});
-
-// ../agx-cloud/node_modules/bindings/bindings.js
-var require_bindings = __commonJS({
-  "../agx-cloud/node_modules/bindings/bindings.js"(exports2, module2) {
-    var fs4 = require("fs");
-    var path4 = require("path");
-    var fileURLToPath = require_file_uri_to_path();
-    var join = path4.join;
-    var dirname = path4.dirname;
-    var exists = fs4.accessSync && function(path5) {
-      try {
-        fs4.accessSync(path5);
-      } catch (e) {
-        return false;
-      }
-      return true;
-    } || fs4.existsSync || path4.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(i2) {
-        if (!(i2 in opts)) opts[i2] = defaults[i2];
-      });
-      if (!opts.module_root) {
-        opts.module_root = exports2.getRoot(exports2.getFileName());
-      }
-      if (path4.extname(opts.bindings) != ".node") {
-        opts.bindings += ".node";
-      }
-      var requireFunc = typeof __webpack_require__ === "function" ? __non_webpack_require__ : require;
-      var tries = [], i = 0, l = opts.try.length, n, b, err;
-      for (; i < l; i++) {
-        n = join.apply(
-          null,
-          opts.try[i].map(function(p) {
-            return opts[p] || p;
-          })
-        );
-        tries.push(n);
-        try {
-          b = opts.path ? requireFunc.resolve(n) : requireFunc(n);
-          if (!opts.path) {
-            b.path = n;
-          }
-          return b;
-        } catch (e) {
-          if (e.code !== "MODULE_NOT_FOUND" && e.code !== "QUALIFIED_PATH_RESOLUTION_FAILED" && !/not find/i.test(e.message)) {
-            throw e;
-          }
-        }
-      }
-      err = new Error(
-        "Could not locate the bindings file. Tried:\n" + tries.map(function(a) {
-          return opts.arrow + a;
-        }).join("\n")
-      );
-      err.tries = tries;
-      throw err;
-    }
-    module2.exports = exports2 = bindings;
-    exports2.getFileName = function getFileName(calling_file) {
-      var origPST = Error.prepareStackTrace, origSTL = Error.stackTraceLimit, dummy = {}, fileName;
-      Error.stackTraceLimit = 10;
-      Error.prepareStackTrace = function(e, st) {
-        for (var i = 0, l = st.length; i < l; i++) {
-          fileName = st[i].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 = fileURLToPath(fileName);
-      }
-      return fileName;
-    };
-    exports2.getRoot = function getRoot(file) {
-      var dir = dirname(file), prev;
-      while (true) {
-        if (dir === ".") {
-          dir = process.cwd();
-        }
-        if (exists(join(dir, "package.json")) || exists(join(dir, "node_modules"))) {
-          return dir;
-        }
-        if (prev === dir) {
-          throw new Error(
-            'Could not find module root given file: "' + file + '". Do you have a `package.json` file? '
-          );
-        }
-        prev = dir;
-        dir = join(dir, "..");
-      }
-    };
-  }
-});
-
-// ../agx-cloud/node_modules/better-sqlite3/lib/methods/wrappers.js
-var require_wrappers = __commonJS({
-  "../agx-cloud/node_modules/better-sqlite3/lib/methods/wrappers.js"(exports2) {
-    "use strict";
-    var { cppdb } = require_util();
-    exports2.prepare = function prepare(sql) {
-      return this[cppdb].prepare(sql, this, false);
-    };
-    exports2.exec = function exec(sql) {
-      this[cppdb].exec(sql);
-      return this;
-    };
-    exports2.close = function close() {
-      this[cppdb].close();
-      return this;
-    };
-    exports2.loadExtension = function loadExtension(...args) {
-      this[cppdb].loadExtension(...args);
-      return this;
-    };
-    exports2.defaultSafeIntegers = function defaultSafeIntegers(...args) {
-      this[cppdb].defaultSafeIntegers(...args);
-      return this;
-    };
-    exports2.unsafeMode = function unsafeMode(...args) {
-      this[cppdb].unsafeMode(...args);
-      return this;
-    };
-    exports2.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 readonly() {
-          return this[cppdb].readonly;
-        },
-        enumerable: true
-      },
-      memory: {
-        get: function memory() {
-          return this[cppdb].memory;
-        },
-        enumerable: true
-      }
-    };
-  }
-});
-
-// ../agx-cloud/node_modules/better-sqlite3/lib/methods/transaction.js
-var require_transaction = __commonJS({
-  "../agx-cloud/node_modules/better-sqlite3/lib/methods/transaction.js"(exports2, module2) {
-    "use strict";
-    var { cppdb } = require_util();
-    var controllers = /* @__PURE__ */ new WeakMap();
-    module2.exports = function transaction(fn) {
-      if (typeof fn !== "function") throw new TypeError("Expected first argument to be a function");
-      const db2 = this[cppdb];
-      const controller = getController(db2, this);
-      const { apply } = Function.prototype;
-      const properties = {
-        default: { value: wrapTransaction(apply, fn, db2, controller.default) },
-        deferred: { value: wrapTransaction(apply, fn, db2, controller.deferred) },
-        immediate: { value: wrapTransaction(apply, fn, db2, controller.immediate) },
-        exclusive: { value: wrapTransaction(apply, fn, db2, 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 = (db2, self) => {
-      let controller = controllers.get(db2);
-      if (!controller) {
-        const shared = {
-          commit: db2.prepare("COMMIT", self, false),
-          rollback: db2.prepare("ROLLBACK", self, false),
-          savepoint: db2.prepare("SAVEPOINT `	_bs3.	`", self, false),
-          release: db2.prepare("RELEASE `	_bs3.	`", self, false),
-          rollbackTo: db2.prepare("ROLLBACK TO `	_bs3.	`", self, false)
-        };
-        controllers.set(db2, controller = {
-          default: Object.assign({ begin: db2.prepare("BEGIN", self, false) }, shared),
-          deferred: Object.assign({ begin: db2.prepare("BEGIN DEFERRED", self, false) }, shared),
-          immediate: Object.assign({ begin: db2.prepare("BEGIN IMMEDIATE", self, false) }, shared),
-          exclusive: Object.assign({ begin: db2.prepare("BEGIN EXCLUSIVE", self, false) }, shared)
-        });
-      }
-      return controller;
-    };
-    var wrapTransaction = (apply, fn, db2, { begin, commit, rollback, savepoint, release, rollbackTo }) => function sqliteTransaction() {
-      let before, after, undo;
-      if (db2.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 (db2.inTransaction) {
-          undo.run();
-          if (undo !== rollback) after.run();
-        }
-        throw ex;
-      }
-    };
-  }
-});
-
-// ../agx-cloud/node_modules/better-sqlite3/lib/methods/pragma.js
-var require_pragma = __commonJS({
-  "../agx-cloud/node_modules/better-sqlite3/lib/methods/pragma.js"(exports2, module2) {
-    "use strict";
-    var { getBooleanOption, cppdb } = require_util();
-    module2.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();
-    };
-  }
-});
-
-// ../agx-cloud/node_modules/better-sqlite3/lib/methods/backup.js
-var require_backup = __commonJS({
-  "../agx-cloud/node_modules/better-sqlite3/lib/methods/backup.js"(exports2, module2) {
-    "use strict";
-    var fs4 = require("fs");
-    var path4 = require("path");
-    var { promisify } = require("util");
-    var { cppdb } = require_util();
-    var fsAccess = promisify(fs4.access);
-    module2.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(path4.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);
-          }
-        });
-      });
-    };
-  }
-});
-
-// ../agx-cloud/node_modules/better-sqlite3/lib/methods/serialize.js
-var require_serialize = __commonJS({
-  "../agx-cloud/node_modules/better-sqlite3/lib/methods/serialize.js"(exports2, module2) {
-    "use strict";
-    var { cppdb } = require_util();
-    module2.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);
-    };
-  }
-});
-
-// ../agx-cloud/node_modules/better-sqlite3/lib/methods/function.js
-var require_function = __commonJS({
-  "../agx-cloud/node_modules/better-sqlite3/lib/methods/function.js"(exports2, module2) {
-    "use strict";
-    var { getBooleanOption, cppdb } = require_util();
-    module2.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;
-    };
-  }
-});
-
-// ../agx-cloud/node_modules/better-sqlite3/lib/methods/aggregate.js
-var require_aggregate = __commonJS({
-  "../agx-cloud/node_modules/better-sqlite3/lib/methods/aggregate.js"(exports2, module2) {
-    "use strict";
-    var { getBooleanOption, cppdb } = require_util();
-    module2.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, required) => {
-      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 (required) 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");
-    };
-  }
-});
-
-// ../agx-cloud/node_modules/better-sqlite3/lib/methods/table.js
-var require_table = __commonJS({
-  "../agx-cloud/node_modules/better-sqlite3/lib/methods/table.js"(exports2, module2) {
-    "use strict";
-    var { cppdb } = require_util();
-    module2.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((x) => typeof x === "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((x) => typeof x === "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((x, i) => [x, parameters.length + i])), moduleName),
-        parameters,
-        safeIntegers,
-        directOnly
-      ];
-    }
-    function wrapGenerator(generator, columnMap, moduleName) {
-      return function* virtualTable(...args) {
-        const output = args.map((x) => Buffer.isBuffer(x) ? Buffer.from(x) : x);
-        for (let i = 0; i < columnMap.size; ++i) {
-          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 i = 0; i < columnCount; ++i) {
-        output[i + offset] = row[i];
-      }
-    }
-    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 i = 0; i < length; ++i) {
-        params.push(`$${i + 1}`);
-      }
-      return params;
-    }
-    var { hasOwnProperty } = Object.prototype;
-    var { apply } = Function.prototype;
-    var GeneratorFunctionPrototype = Object.getPrototypeOf(function* () {
-    });
-    var identifier = (str) => `"${str.replace(/"/g, '""')}"`;
-    var defer = (x) => () => x;
-  }
-});
-
-// ../agx-cloud/node_modules/better-sqlite3/lib/methods/inspect.js
-var require_inspect = __commonJS({
-  "../agx-cloud/node_modules/better-sqlite3/lib/methods/inspect.js"(exports2, module2) {
-    "use strict";
-    var DatabaseInspection = function Database3() {
-    };
-    module2.exports = function inspect(depth, opts) {
-      return Object.assign(new DatabaseInspection(), this);
-    };
-  }
-});
-
-// ../agx-cloud/node_modules/better-sqlite3/lib/database.js
-var require_database = __commonJS({
-  "../agx-cloud/node_modules/better-sqlite3/lib/database.js"(exports2, module2) {
-    "use strict";
-    var fs4 = require("fs");
-    var path4 = require("path");
-    var util = require_util();
-    var SqliteError = require_sqlite_error();
-    var DEFAULT_ADDON;
-    function Database3(filenameGiven, options) {
-      if (new.target == null) {
-        return new Database3(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 readonly = 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 (readonly && 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(path4.resolve(nativeBinding).replace(/(\.node)?$/, ".node"));
-      } else {
-        addon = nativeBinding;
-      }
-      if (!addon.isInitialized) {
-        addon.setErrorConstructor(SqliteError);
-        addon.isInitialized = true;
-      }
-      if (!anonymous && !filename.startsWith("file:") && !fs4.existsSync(path4.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, readonly, fileMustExist, timeout, verbose || null, buffer || null) },
-        ...wrappers.getters
-      });
-    }
-    var wrappers = require_wrappers();
-    Database3.prototype.prepare = wrappers.prepare;
-    Database3.prototype.transaction = require_transaction();
-    Database3.prototype.pragma = require_pragma();
-    Database3.prototype.backup = require_backup();
-    Database3.prototype.serialize = require_serialize();
-    Database3.prototype.function = require_function();
-    Database3.prototype.aggregate = require_aggregate();
-    Database3.prototype.table = require_table();
-    Database3.prototype.loadExtension = wrappers.loadExtension;
-    Database3.prototype.exec = wrappers.exec;
-    Database3.prototype.close = wrappers.close;
-    Database3.prototype.defaultSafeIntegers = wrappers.defaultSafeIntegers;
-    Database3.prototype.unsafeMode = wrappers.unsafeMode;
-    Database3.prototype[util.inspect] = require_inspect();
-    module2.exports = Database3;
-  }
-});
-
-// ../agx-cloud/node_modules/better-sqlite3/lib/index.js
-var require_lib = __commonJS({
-  "../agx-cloud/node_modules/better-sqlite3/lib/index.js"(exports2, module2) {
-    "use strict";
-    module2.exports = require_database();
-    module2.exports.SqliteError = require_sqlite_error();
-  }
-});
-
-// ../agx-cloud/lib/startup.ts
-function compareVersions(a, b) {
-  const pa = a.split(".").map(Number);
-  const pb = b.split(".").map(Number);
-  for (let i = 0; i < 3; i++) {
-    const diff = (pa[i] || 0) - (pb[i] || 0);
-    if (diff !== 0) return diff;
-  }
-  return 0;
-}
-function detectFilesystemType(dbPath) {
-  if (import_os.default.platform() !== "linux" && import_os.default.platform() !== "darwin") return null;
-  try {
-    const resolvedPath = import_path.default.resolve(dbPath);
-    const { execSync } = require("child_process");
-    if (import_os.default.platform() === "darwin") {
-      const out = execSync(`df -T "${resolvedPath}" 2>/dev/null || df "${resolvedPath}"`, {
-        encoding: "utf-8",
-        timeout: 3e3
-      });
-      const lines = out.trim().split("\n");
-      if (lines.length >= 2) {
-        const parts = lines[1].split(/\s+/);
-        const source = parts[0]?.toLowerCase() || "";
-        if (source.includes("://") || source.includes("nfs") || source.includes("smb")) {
-          return source;
-        }
-      }
-    } else {
-      const mounts = import_fs.default.readFileSync("/proc/mounts", "utf-8");
-      let bestMatch = "";
-      let bestFs = "unknown";
-      for (const line of mounts.split("\n")) {
-        const [, mountpoint, fstype] = line.split(/\s+/);
-        if (mountpoint && resolvedPath.startsWith(mountpoint) && mountpoint.length > bestMatch.length) {
-          bestMatch = mountpoint;
-          bestFs = fstype || "unknown";
-        }
-      }
-      return bestFs;
-    }
-  } catch {
-  }
-  return null;
-}
-function checkExtension(db2, ext) {
-  try {
-    if (ext === "json1") {
-      db2.prepare("SELECT json('{}')").get();
-      return true;
-    }
-    if (ext === "fts5") {
-      db2.exec("CREATE VIRTUAL TABLE IF NOT EXISTS _fts5_check USING fts5(x)");
-      db2.exec("DROP TABLE IF EXISTS _fts5_check");
-      return true;
-    }
-    return false;
-  } catch {
-    return false;
-  }
-}
-function validateSQLiteEnvironment(db2, dbPath) {
-  const errors = [];
-  const version = db2.prepare("SELECT sqlite_version() as v").get();
-  if (compareVersions(version.v, MIN_SQLITE_VERSION) < 0) {
-    errors.push({
-      kind: "version_mismatch",
-      message: `SQLite version ${version.v} is below minimum ${MIN_SQLITE_VERSION}`,
-      found: version.v,
-      required: `>= ${MIN_SQLITE_VERSION}`,
-      fix: import_os.default.platform() === "darwin" ? "brew install sqlite3 && npm rebuild better-sqlite3" : "apt-get install -y libsqlite3-dev && npm rebuild better-sqlite3"
-    });
-  }
-  for (const ext of REQUIRED_EXTENSIONS) {
-    if (!checkExtension(db2, ext)) {
-      errors.push({
-        kind: "missing_extension",
-        message: `Required SQLite extension '${ext}' is not available`,
-        required: ext,
-        fix: `Rebuild SQLite with -DSQLITE_ENABLE_${ext.toUpperCase()}=1, or use a system SQLite that includes it`
-      });
-    }
-  }
-  for (const ext of RECOMMENDED_EXTENSIONS) {
-    if (!checkExtension(db2, ext)) {
-      console.warn(`[startup] Recommended SQLite extension '${ext}' is not available. Full-text search will be disabled.`);
-    }
-  }
-  const fsType = detectFilesystemType(dbPath);
-  if (fsType) {
-    const isBanned = BANNED_FS_PREFIXES.some((prefix) => fsType.toLowerCase().includes(prefix));
-    if (isBanned) {
-      errors.push({
-        kind: "filesystem_error",
-        message: `Database path '${dbPath}' is on a network filesystem (${fsType})`,
-        path: dbPath,
-        found: fsType,
-        fix: "Move the database file to a local SSD. WAL mode requires local filesystem with reliable fsync."
-      });
-    }
-  }
-  try {
-    db2.pragma(`journal_mode = ${REQUIRED_PRAGMAS.journal_mode}`);
-    db2.pragma(`foreign_keys = ${REQUIRED_PRAGMAS.foreign_keys}`);
-    db2.pragma(`busy_timeout = ${REQUIRED_PRAGMAS.busy_timeout}`);
-    db2.pragma(`synchronous = ${REQUIRED_PRAGMAS.synchronous}`);
-    db2.pragma(`cache_size = ${REQUIRED_PRAGMAS.cache_size}`);
-    const jm = db2.pragma("journal_mode", { simple: true }).toLowerCase();
-    const ACCEPTABLE_JOURNAL_MODES = /* @__PURE__ */ new Set(["wal", "delete"]);
-    if (!ACCEPTABLE_JOURNAL_MODES.has(jm)) {
-      db2.pragma("journal_mode = DELETE");
-      const jm2 = db2.pragma("journal_mode", { simple: true }).toLowerCase();
-      if (!ACCEPTABLE_JOURNAL_MODES.has(jm2)) {
-        errors.push({
-          kind: "pragma_error",
-          message: `Failed to set journal_mode (got '${jm2}', tried WAL then DELETE)`,
-          found: jm2,
-          required: "wal or delete",
-          fix: "Ensure the database file is on a local filesystem and no other process holds an exclusive lock."
-        });
-      } else {
-        db2.pragma("synchronous = FULL");
-        console.warn(`[startup] WAL unavailable, using journal_mode=${jm2} with synchronous=FULL`);
-      }
-    }
-  } catch (err) {
-    errors.push({
-      kind: "pragma_error",
-      message: `Failed to apply required PRAGMAs: ${err.message}`,
-      fix: "Check file permissions and ensure the database is not read-only."
-    });
-  }
-  return errors;
-}
-var import_fs, import_os, import_path, MIN_SQLITE_VERSION, REQUIRED_PRAGMAS, REQUIRED_EXTENSIONS, RECOMMENDED_EXTENSIONS, BANNED_FS_PREFIXES;
-var init_startup = __esm({
-  "../agx-cloud/lib/startup.ts"() {
-    "use strict";
-    import_fs = __toESM(require("fs"));
-    import_os = __toESM(require("os"));
-    import_path = __toESM(require("path"));
-    MIN_SQLITE_VERSION = "3.35.0";
-    REQUIRED_PRAGMAS = {
-      journal_mode: "wal",
-      foreign_keys: 1,
-      busy_timeout: 5e3,
-      synchronous: 1,
-      // NORMAL — safe with WAL
-      cache_size: -64e3
-      // 64 MB (negative = KiB)
-    };
-    REQUIRED_EXTENSIONS = ["json1"];
-    RECOMMENDED_EXTENSIONS = ["fts5"];
-    BANNED_FS_PREFIXES = ["nfs", "smb", "cifs", "efs", "fuse.sshfs"];
-  }
-});
-
-// ../agx-cloud/lib/auth-mode.ts
-var LOCAL_USER;
-var init_auth_mode = __esm({
-  "../agx-cloud/lib/auth-mode.ts"() {
-    "use strict";
-    LOCAL_USER = {
-      id: "2c3cc1ca-956d-4b62-b295-4d2d3374103f",
-      email: process.env.AGX_BOARD_USER_EMAIL || "local@agx.board",
-      name: process.env.AGX_BOARD_USER_NAME || "Local Board User"
-    };
-  }
-});
-
-// ../agx-cloud/lib/sqlite-query-adapter.ts
-var sqlite_query_adapter_exports = {};
-__export(sqlite_query_adapter_exports, {
-  SqlExpression: () => SqlExpression,
-  createAdminDbClientSQLite: () => createAdminDbClientSQLite,
-  getSQLiteDb: () => getSQLiteDb,
-  sqlExpr: () => sqlExpr
-});
-function sqlExpr(expr) {
-  return new SqlExpression(expr);
-}
-function getSQLiteDb() {
-  if (_db) return _db;
-  const dbPath = process.env.SQLITE_DB_PATH || import_path3.default.join(AGX_DATA_DIR2, "agx-board.db");
-  const isNew = !import_fs3.default.existsSync(dbPath);
-  _db = new import_better_sqlite32.default(dbPath);
-  const errors = validateSQLiteEnvironment(_db, dbPath);
-  if (errors.length > 0) {
-    const msgs = errors.map((e) => `  - ${e.message}${e.fix ? ` (fix: ${e.fix})` : ""}`);
-    throw new Error(`SQLite startup validation failed:
-${msgs.join("\n")}`);
-  }
-  initSQLiteSchema(_db);
-  if (!isNew) {
-    runMigrations(_db);
-  }
-  return _db;
-}
-function initSQLiteSchema(db2) {
-  const ddlPath = import_path3.default.join(process.cwd(), "db", "sqlite", "001_agx_board_schema.sql");
-  if (!import_fs3.default.existsSync(ddlPath)) {
-    console.warn(`[sqlite] DDL not found at ${ddlPath}, skipping schema init`);
-    return;
-  }
-  const ddl = import_fs3.default.readFileSync(ddlPath, "utf-8");
-  db2.exec(ddl);
-}
-function runMigrations(db2) {
-  const tables = db2.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='teams'").all();
-  if (tables.length > 0) {
-    const cols = db2.pragma("table_info(teams)");
-    if (!cols.some((c) => c.name === "is_default")) {
-      db2.exec("ALTER TABLE teams ADD COLUMN is_default INTEGER NOT NULL DEFAULT 0");
-      db2.exec("CREATE UNIQUE INDEX IF NOT EXISTS idx_teams_default ON teams (user_id) WHERE is_default = 1");
-    }
-  }
-  const graphTables = db2.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='execution_graphs'").all();
-  if (graphTables.length > 0) {
-    const columns = db2.pragma("table_info(execution_graphs)");
-    if (!columns.some((column) => column.name === "schedule")) {
-      db2.exec("ALTER TABLE execution_graphs ADD COLUMN schedule JSON");
-    }
-  }
-  const gnTables = db2.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='graph_nodes'").all();
-  if (gnTables.length > 0) {
-    const sql = db2.prepare("SELECT sql FROM sqlite_master WHERE type='table' AND name='graph_nodes'").get()?.sql ?? "";
-    if (sql.includes("'root')") && !sql.includes("'function'")) {
-      db2.exec(`
-        CREATE TABLE graph_nodes_new (
-          graph_id TEXT NOT NULL REFERENCES execution_graphs(id) ON DELETE CASCADE,
-          node_id TEXT NOT NULL,
-          type TEXT NOT NULL,
-          status TEXT NOT NULL,
-          config JSON NOT NULL DEFAULT '{}',
-          output JSON,
-          metrics JSON,
-          PRIMARY KEY (graph_id, node_id),
-          CHECK (type IN ('work', 'gate', 'fork', 'join', 'conditional', 'root', 'function')),
-          CHECK (status IN ('pending', 'running', 'awaiting_human', 'done', 'passed', 'failed', 'blocked', 'skipped', 'stopped'))
-        );
-        INSERT INTO graph_nodes_new SELECT * FROM graph_nodes;
-        DROP TABLE graph_nodes;
-        ALTER TABLE graph_nodes_new RENAME TO graph_nodes;
-        CREATE INDEX IF NOT EXISTS idx_graph_nodes_graph_id ON graph_nodes (graph_id);
-      `);
-    }
-  }
-}
-function toSqlValue(value) {
-  if (value === void 0) return null;
-  if (value instanceof Date) return value.toISOString();
-  if (value && typeof value === "object") {
-    return JSON.stringify(value);
-  }
-  return value;
-}
-function toSqlValueForColumn(column, value) {
-  if (value === void 0) return null;
-  if (value === null) return null;
-  if (value instanceof Date) return value.toISOString();
-  if (JSON_COLUMNS.has(column)) {
-    return JSON.stringify(value);
-  }
-  return toSqlValue(value);
-}
-function parseOrValue(raw) {
-  if (raw === "true") return true;
-  if (raw === "false") return false;
-  if (raw === "null") return null;
-  return raw;
-}
-function normalizeColumns(columns) {
-  const text = (columns || "*").trim();
-  if (!text || text === "*") return { columns: ["*"], includeProjectRepos: false };
-  const includeProjectRepos = text.includes("project_repos(*)");
-  const cleaned = text.replace(/project_repos\(\*\)/g, "").split(",").map((c) => c.trim()).filter(Boolean);
-  if (cleaned.length === 0) return { columns: ["*"], includeProjectRepos };
-  return { columns: cleaned, includeProjectRepos };
-}
-function parseJsonColumns(row) {
-  if (!row || typeof row !== "object") return row;
-  const result = { ...row };
-  for (const key of Object.keys(result)) {
-    if (KNOWN_JSON_COLUMNS.has(key) && typeof result[key] === "string") {
-      try {
-        result[key] = JSON.parse(result[key]);
-      } catch {
-      }
-    }
-    if (key === "swarm" || key === "is_default" || key === "is_public" || key === "had_graph_before") {
-      if (result[key] === 0) result[key] = false;
-      else if (result[key] === 1) result[key] = true;
-    }
-  }
-  return result;
-}
-function createAdminDbClientSQLite() {
-  return {
-    from(table) {
-      return new SQLiteQueryBuilder(table);
-    },
-    auth: {
-      async getUser() {
-        return {
-          data: {
-            user: {
-              id: LOCAL_USER.id,
-              email: LOCAL_USER.email,
-              user_metadata: { name: LOCAL_USER.name, full_name: LOCAL_USER.name }
-            }
-          },
-          error: null
-        };
-      },
-      async exchangeCodeForSession() {
-        return { error: null };
-      },
-      async refreshSession() {
-        return {
-          data: {
-            session: {
-              access_token: "local-token",
-              refresh_token: "local-refresh",
-              expires_in: 3600
-            },
-            user: { id: LOCAL_USER.id, email: LOCAL_USER.email }
-          },
-          error: null
-        };
-      }
-    },
-    async rpc(fn, args) {
-      if (fn !== "check_rate_limit") {
-        return { data: null, error: { message: `Unsupported rpc: ${fn}` } };
-      }
-      const db2 = getSQLiteDb();
-      const userId = args.p_user_id;
-      const endpoint = args.p_endpoint;
-      const limit = Number(args.p_limit || 60);
-      const windowSeconds = Number(args.p_window_seconds || 60);
-      const now = /* @__PURE__ */ new Date();
-      const bucket = new Date(Math.floor(now.getTime() / (windowSeconds * 1e3)) * windowSeconds * 1e3);
-      try {
-        const sql = `
-          INSERT INTO rate_limits (user_id, endpoint, window_start, request_count)
-          VALUES (?, ?, ?, 1)
-          ON CONFLICT (user_id, endpoint, window_start)
-          DO UPDATE SET request_count = rate_limits.request_count + 1
-          RETURNING request_count
-        `;
-        const row = db2.prepare(sql).get(userId, endpoint, bucket.toISOString());
-        const count = Number(row?.request_count || 0);
-        return { data: count <= limit, error: null };
-      } catch (error) {
-        return { data: false, error };
-      }
-    },
-    channel() {
-      return {
-        on() {
-          return this;
-        },
-        subscribe(callback) {
-          if (callback) callback("SUBSCRIBED");
-          return this;
-        }
-      };
-    },
-    removeChannel() {
-    }
-  };
-}
-var import_better_sqlite32, import_fs3, import_path3, import_os3, AGX_DATA_DIR2, SqlExpression, _db, JSON_COLUMNS, SQLiteQueryBuilder, KNOWN_JSON_COLUMNS;
-var init_sqlite_query_adapter = __esm({
-  "../agx-cloud/lib/sqlite-query-adapter.ts"() {
-    "use strict";
-    import_better_sqlite32 = __toESM(require_lib());
-    import_fs3 = __toESM(require("fs"));
-    import_path3 = __toESM(require("path"));
-    import_os3 = __toESM(require("os"));
-    init_auth_mode();
-    init_startup();
-    AGX_DATA_DIR2 = process.env.AGX_DATA_DIR || import_path3.default.join(import_os3.default.homedir(), ".agx");
-    SqlExpression = class {
-      constructor(expr) {
-        this.expr = expr;
-      }
-    };
-    _db = null;
-    JSON_COLUMNS = /* @__PURE__ */ new Set([
-      "definition",
-      "depends_on",
-      "input",
-      "metadata",
-      "models",
-      "open_blockers",
-      "output",
-      "payload",
-      "run_index",
-      "stage_decisions",
-      "swarm_models"
-    ]);
-    SQLiteQueryBuilder = class {
-      constructor(table) {
-        this.operation = "select";
-        this.filters = [];
-        this.orderSpecs = [];
-        this.limitValue = null;
-        this.selectColumns = "*";
-        this.returningColumns = null;
-        this.singleMode = "none";
-        this.payload = null;
-        this.upsertOptions = null;
-        this.table = table;
-      }
-      select(columns = "*") {
-        if (this.operation === "select") {
-          this.selectColumns = columns;
-        } else {
-          this.returningColumns = columns || "*";
-        }
-        return this;
-      }
-      insert(payload) {
-        this.operation = "insert";
-        this.payload = payload;
-        return this;
-      }
-      update(payload) {
-        this.operation = "update";
-        this.payload = payload;
-        return this;
-      }
-      delete() {
-        this.operation = "delete";
-        return this;
-      }
-      upsert(payload, options) {
-        this.operation = "upsert";
-        this.payload = payload;
-        this.upsertOptions = options || {};
-        return this;
-      }
-      eq(column, value) {
-        this.filters.push({ op: "eq", column, value });
-        return this;
-      }
-      neq(column, value) {
-        this.filters.push({ op: "neq", column, value });
-        return this;
-      }
-      gt(column, value) {
-        this.filters.push({ op: "gt", column, value });
-        return this;
-      }
-      gte(column, value) {
-        this.filters.push({ op: "gte", column, value });
-        return this;
-      }
-      lt(column, value) {
-        this.filters.push({ op: "lt", column, value });
-        return this;
-      }
-      lte(column, value) {
-        this.filters.push({ op: "lte", column, value });
-        return this;
-      }
-      is(column, value) {
-        this.filters.push({ op: "is", column, value });
-        return this;
-      }
-      in(column, values) {
-        this.filters.push({ op: "in", column, value: values || [] });
-        return this;
-      }
-      contains(column, value) {
-        this.filters.push({ op: "contains", column, value });
-        return this;
-      }
-      or(expression) {
-        this.filters.push({ op: "or", expression });
-        return this;
-      }
-      order(column, options) {
-        this.orderSpecs.push({ column, ...options || {} });
-        return this;
-      }
-      limit(value) {
-        this.limitValue = value;
-        return this;
-      }
-      single() {
-        this.singleMode = "single";
-        return this.execute();
-      }
-      maybeSingle() {
-        this.singleMode = "maybeSingle";
-        return this.execute();
-      }
-      then(resolve, reject) {
-        return this.execute().then(resolve, reject);
-      }
-      // ── WHERE clause builder (SQLite dialect) ──────────────────────────────
-      buildWhere(parts, params) {
-        for (const f of this.filters) {
-          if (f.op === "or") {
-            const clauses = f.expression.split(",").map((v) => v.trim()).filter(Boolean).map((clause) => {
-              const [column, op, ...rest] = clause.split(".");
-              const raw = rest.join(".");
-              const value = parseOrValue(raw);
-              if (op === "eq") {
-                params.push(toSqlValue(value));
-                return `${column} = ?`;
-              }
-              if (op === "neq") {
-                params.push(toSqlValue(value));
-                return `${column} <> ?`;
-              }
-              if (op === "is") {
-                if (value === null) return `${column} IS NULL`;
-                params.push(toSqlValue(value));
-                return `${column} IS ?`;
-              }
-              if (op === "ilike") {
-                params.push(toSqlValue(value));
-                return `${column} LIKE ?`;
-              }
-              if (op === "like") {
-                params.push(toSqlValue(value));
-                return `${column} LIKE ?`;
-              }
-              return "1=1";
-            });
-            if (clauses.length > 0) {
-              parts.push(`(${clauses.join(" OR ")})`);
-            }
-            continue;
-          }
-          if (f.op === "eq") {
-            params.push(toSqlValue(f.value));
-            parts.push(`${f.column} = ?`);
-          } else if (f.op === "neq") {
-            params.push(toSqlValue(f.value));
-            parts.push(`${f.column} <> ?`);
-          } else if (f.op === "gt") {
-            params.push(toSqlValue(f.value));
-            parts.push(`${f.column} > ?`);
-          } else if (f.op === "gte") {
-            params.push(toSqlValue(f.value));
-            parts.push(`${f.column} >= ?`);
-          } else if (f.op === "lt") {
-            params.push(toSqlValue(f.value));
-            parts.push(`${f.column} < ?`);
-          } else if (f.op === "lte") {
-            params.push(toSqlValue(f.value));
-            parts.push(`${f.column} <= ?`);
-          } else if (f.op === "is") {
-            if (f.value === null) {
-              parts.push(`${f.column} IS NULL`);
-            } else {
-              params.push(toSqlValue(f.value));
-              parts.push(`${f.column} IS ?`);
-            }
-          } else if (f.op === "contains") {
-            const arr = (f.value || []).map(toSqlValue);
-            if (arr.length === 0) {
-              parts.push("1=1");
-            } else {
-              const placeholders = arr.map(() => "?").join(", ");
-              params.push(...arr);
-              parts.push(
-                `(SELECT COUNT(*) FROM json_each(${f.column}) WHERE json_each.value IN (${placeholders})) = ${arr.length}`
-              );
-            }
-          } else if (f.op === "in") {
-            if (!f.value || f.value.length === 0) {
-              parts.push("1=0");
-            } else {
-              const vals = (f.value || []).map(toSqlValue);
-              const placeholders = vals.map(() => "?").join(", ");
-              params.push(...vals);
-              parts.push(`${f.column} IN (${placeholders})`);
-            }
-          }
-        }
-      }
-      // ── SELECT ─────────────────────────────────────────────────────────────
-      executeSelect() {
-        try {
-          const db2 = getSQLiteDb();
-          const { columns, includeProjectRepos } = normalizeColumns(this.selectColumns);
-          const params = [];
-          const where = [];
-          this.buildWhere(where, params);
-          let sql = `SELECT ${columns.join(", ")} FROM ${this.table}`;
-          if (where.length > 0) sql += ` WHERE ${where.join(" AND ")}`;
-          if (this.orderSpecs.length > 0) {
-            const order = this.orderSpecs.map((o) => {
-              const direction = o.ascending === false ? "DESC" : "ASC";
-              if (o.nullsFirst === true) {
-                return `CASE WHEN ${o.column} IS NULL THEN 0 ELSE 1 END, ${o.column} ${direction}`;
-              }
-              if (o.nullsFirst === false) {
-                return `CASE WHEN ${o.column} IS NULL THEN 1 ELSE 0 END, ${o.column} ${direction}`;
-              }
-              return `${o.column} ${direction}`;
-            }).join(", ");
-            sql += ` ORDER BY ${order}`;
-          }
-          if (typeof this.limitValue === "number") {
-            params.push(this.limitValue);
-            sql += ` LIMIT ?`;
-          }
-          let rows = db2.prepare(sql).all(...params);
-          rows = rows.map(parseJsonColumns);
-          if (includeProjectRepos && this.table === "projects" && rows.length > 0) {
-            const ids = rows.map((r) => r.id).filter(Boolean);
-            if (ids.length > 0) {
-              const placeholders = ids.map(() => "?").join(", ");
-              const reposRows = db2.prepare(`SELECT * FROM project_repos WHERE project_id IN (${placeholders})`).all(...ids);
-              const byProject = /* @__PURE__ */ new Map();
-              for (const repo of reposRows) {
-                const list = byProject.get(repo.project_id) || [];
-                list.push(repo);
-                byProject.set(repo.project_id, list);
-              }
-              rows = rows.map((p) => ({ ...p, project_repos: byProject.get(p.id) || [] }));
-            }
-          }
-          if (this.singleMode === "single") {
-            if (rows.length === 0) {
-              return { data: null, error: { message: "No rows", code: "PGRST116" } };
-            }
-            return { data: rows[0], error: null };
-          }
-          if (this.singleMode === "maybeSingle") {
-            return { data: rows[0] || null, error: null };
-          }
-          return { data: rows, error: null };
-        } catch (error) {
-          return { data: null, error };
-        }
-      }
-      // ── INSERT / UPSERT ───────────────────────────────────────────────────
-      executeInsertOrUpsert() {
-        try {
-          const db2 = getSQLiteDb();
-          const inputRows = Array.isArray(this.payload) ? this.payload : [this.payload];
-          if (!inputRows.length) return { data: [], error: null };
-          const columns = Array.from(
-            inputRows.reduce((set, row) => {
-              for (const key of Object.keys(row || {})) set.add(key);
-              return set;
-            }, /* @__PURE__ */ new Set())
-          );
-          const values = [];
-          const groups = inputRows.map((row) => {
-            const placeholders = columns.map((col) => {
-              values.push(toSqlValueForColumn(col, row[col]));
-              return "?";
-            });
-            return `(${placeholders.join(", ")})`;
-          });
-          let sql = `INSERT INTO ${this.table} (${columns.join(", ")}) VALUES ${groups.join(", ")}`;
-          if (this.operation === "upsert") {
-            const onConflictRaw = this.upsertOptions?.onConflict || "";
-            const conflictCols = String(onConflictRaw).split(",").map((v) => v.trim()).filter(Boolean);
-            if (conflictCols.length > 0) {
-              if (this.upsertOptions?.ignoreDuplicates) {
-                sql += ` ON CONFLICT (${conflictCols.join(", ")}) DO NOTHING`;
-              } else {
-                const updates = columns.filter((c) => !conflictCols.includes(c)).map((c) => `${c} = EXCLUDED.${c}`);
-                if (updates.length > 0) {
-                  sql += ` ON CONFLICT (${conflictCols.join(", ")}) DO UPDATE SET ${updates.join(", ")}`;
-                } else {
-                  sql += ` ON CONFLICT (${conflictCols.join(", ")}) DO NOTHING`;
-                }
-              }
-            }
-          }
-          if (this.returningColumns) {
-            const { columns: retCols } = normalizeColumns(this.returningColumns);
-            sql += ` RETURNING ${retCols.join(", ")}`;
-          }
-          let resultRows;
-          if (this.returningColumns) {
-            resultRows = db2.prepare(sql).all(...values);
-            resultRows = resultRows.map(parseJsonColumns);
-          } else {
-            db2.prepare(sql).run(...values);
-            resultRows = [];
-          }
-          const data = this.returningColumns ? resultRows : null;
-          if (this.singleMode === "single" || this.singleMode === "maybeSingle") {
-            return { data: data && data[0] || null, error: null };
-          }
-          return { data, error: null };
-        } catch (error) {
-          return { data: null, error };
-        }
-      }
-      // ── UPDATE / DELETE ───────────────────────────────────────────────────
-      executeUpdateOrDelete() {
-        try {
-          const db2 = getSQLiteDb();
-          const setParams = [];
-          const whereParams = [];
-          const where = [];
-          this.buildWhere(where, whereParams);
-          let sql = "";
-          if (this.operation === "update") {
-            const keys = Object.keys(this.payload || {});
-            const assignments = keys.map((k) => {
-              const val = this.payload[k];
-              if (val instanceof SqlExpression) {
-                return `${k} = ${val.expr}`;
-              }
-              setParams.push(toSqlValueForColumn(k, val));
-              return `${k} = ?`;
-            });
-            sql = `UPDATE ${this.table} SET ${assignments.join(", ")}`;
-          } else {
-            sql = `DELETE FROM ${this.table}`;
-          }
-          if (where.length > 0) sql += ` WHERE ${where.join(" AND ")}`;
-          const params = [...setParams, ...whereParams];
-          if (this.returningColumns) {
-            const { columns: retCols } = normalizeColumns(this.returningColumns);
-            sql += ` RETURNING ${retCols.join(", ")}`;
-          }
-          let resultRows;
-          if (this.returningColumns) {
-            resultRows = db2.prepare(sql).all(...params);
-            resultRows = resultRows.map(parseJsonColumns);
-          } else {
-            db2.prepare(sql).run(...params);
-            resultRows = [];
-          }
-          const data = this.returningColumns ? resultRows : null;
-          if (this.singleMode === "single") {
-            if (!data || data.length === 0) {
-              return { data: null, error: { message: "No rows", code: "PGRST116" } };
-            }
-            return { data: data[0], error: null };
-          }
-          if (this.singleMode === "maybeSingle") {
-            return { data: data?.[0] || null, error: null };
-          }
-          return { data, error: null };
-        } catch (error) {
-          return { data: null, error };
-        }
-      }
-      // ── Execute router ────────────────────────────────────────────────────
-      async execute() {
-        if (this.operation === "select") return this.executeSelect();
-        if (this.operation === "insert" || this.operation === "upsert") return this.executeInsertOrUpsert();
-        return this.executeUpdateOrDelete();
-      }
-    };
-    KNOWN_JSON_COLUMNS = /* @__PURE__ */ new Set([
-      ...JSON_COLUMNS,
-      "depends_on",
-      "open_blockers",
-      "swarm_models",
-      "run_index",
-      "stage_decisions",
-      "definition",
-      "metadata",
-      "models",
-      "config",
-      "policy",
-      "done_criteria",
-      "outputs",
-      "task_snapshot",
-      "data_mapping"
-    ]);
-  }
-});
-
-// ../agx-cloud/lib/db-adapter.ts
-function createAdminDbClient() {
-  const { createAdminDbClientSQLite: createAdminDbClientSQLite2 } = (init_sqlite_query_adapter(), __toCommonJS(sqlite_query_adapter_exports));
-  return createAdminDbClientSQLite2();
-}
-var init_db_adapter = __esm({
-  "../agx-cloud/lib/db-adapter.ts"() {
-    init_auth_mode();
-  }
-});
-
-// ../agx-cloud/lib/dependency-helpers.ts
-function describeDependency(entry) {
-  if (entry.title) return entry.title;
-  if (entry.slug) return entry.slug;
-  if (entry.id) return entry.id;
-  return "(unknown)";
-}
-function describeStatus(entry) {
-  if (entry.stage?.toLowerCase() === "intake") return " (awaiting approval)";
-  return entry.status ? ` (${entry.status})` : null;
-}
-function formatDependencyBlockedReason(dependencies) {
-  if (!dependencies || dependencies.length === 0) {
-    return "";
-  }
-  const entries = dependencies.slice(0, MAX_DISPLAYED_DEPENDENCIES).map((entry) => `${describeDependency(entry)}${describeStatus(entry) ?? ""}`);
-  let message = `${DEPENDENCY_BLOCKED_REASON_PREFIX}: ${entries.join(", ")}`;
-  if (dependencies.length > MAX_DISPLAYED_DEPENDENCIES) {
-    message += ` +${dependencies.length - MAX_DISPLAYED_DEPENDENCIES} more`;
-  }
-  return message;
-}
-function isDependencyBlockedReason(reason) {
-  return typeof reason === "string" && reason.startsWith(DEPENDENCY_BLOCKED_REASON_PREFIX);
-}
-var DEPENDENCY_BLOCKED_REASON_PREFIX, MAX_DISPLAYED_DEPENDENCIES;
-var init_dependency_helpers = __esm({
-  "../agx-cloud/lib/dependency-helpers.ts"() {
-    DEPENDENCY_BLOCKED_REASON_PREFIX = "Waiting on dependencies";
-    MAX_DISPLAYED_DEPENDENCIES = 3;
-  }
-});
-
-// ../agx-cloud/lib/notifications/constants.ts
-var NOTIFICATION_EVENT_OPTIONS, NOTIFICATION_EVENT_VALUES;
-var init_constants = __esm({
-  "../agx-cloud/lib/notifications/constants.ts"() {
-    "use strict";
-    NOTIFICATION_EVENT_OPTIONS = [
-      {
-        value: "task.created",
-        label: "Task created",
-        description: "Fires immediately when a new task is added to the queue."
-      },
-      {
-        value: "task.stage_complete",
-        label: "Stage completed",
-        description: "Emitted whenever a stage finishes and the task advances."
-      },
-      {
-        value: "task.completed",
-        label: "Task completed",
-        description: "When the task reaches a completed status (done)."
-      },
-      {
-        value: "task.failed",
-        label: "Task failed",
-        description: "When the task may have errored, including cancellations."
-      },
-      {
-        value: "task.blocked",
-        label: "Task blocked",
-        description: "When the agent raises the task as blocked awaiting manual input."
-      }
-    ];
-    NOTIFICATION_EVENT_VALUES = NOTIFICATION_EVENT_OPTIONS.map((option) => option.value);
-  }
-});
-
-// ../agx-cloud/lib/notifications/index.ts
-function isMissingRelationError(error, relation) {
-  if (!error || typeof error !== "object") return false;
-  const code = error.code;
-  const message = typeof error.message === "string" ? error.message : "";
-  return code === "42P01" || code === "PGRST205" || message.includes(`relation "${relation}" does not exist`) || message.includes(`Could not find the table 'agx.${relation}'`) || message.includes(`Could not find the table 'public.${relation}'`);
-}
-function mapWebhookRecord(raw) {
-  const events = Array.isArray(raw.events) ? raw.events.filter((value) => typeof value === "string").map((value) => value.trim()).filter(
-    (value) => NOTIFICATION_EVENT_VALUES.includes(value)
-  ) : [];
-  return {
-    id: String(raw.id),
-    user_id: String(raw.user_id),
-    url: String(raw.url),
-    name: raw.name != null ? String(raw.name) : null,
-    events,
-    enabled: raw.enabled !== false,
-    created_at: String(raw.created_at),
-    updated_at: String(raw.updated_at)
-  };
-}
-async function handleRelationError(relation, error) {
-  if (isMissingRelationError(error, relation)) {
-    throw new SchemaNotReadyError(`Missing relation: ${relation}`);
-  }
-  throw error;
-}
-async function listNotificationWebhooks(userId) {
-  const db2 = createAdminDbClient();
-  const { data, error } = await db2.from("notification_webhooks").select("*").eq("user_id", userId).order("created_at", { ascending: false });
-  if (error) {
-    await handleRelationError("notification_webhooks", error);
-  }
-  if (!data) return [];
-  return (Array.isArray(data) ? data : [data]).map(mapWebhookRecord);
-}
-async function notifyTaskEvent(payload) {
-  if (!payload.userId) return;
-  let endpoints = [];
-  try {
-    endpoints = await listNotificationWebhooks(payload.userId);
-  } catch (error) {
-    if (error instanceof SchemaNotReadyError) {
-      console.debug("[notifications] notification_webhooks schema not ready, skipping");
-      return;
-    }
-    console.error("[notifications] failed to load webhooks", error);
-    return;
-  }
-  const targets = endpoints.filter(
-    (endpoint) => endpoint.enabled && endpoint.events.includes(payload.eventType)
-  );
-  if (!targets.length) return;
-  const timestamp = payload.timestamp || (/* @__PURE__ */ new Date()).toISOString();
-  const body = {
-    eventType: payload.eventType,
-    taskId: payload.taskId,
-    userId: payload.userId,
-    title: payload.title || null,
-    slug: payload.slug || null,
-    stage: payload.stage || null,
-    previousStage: payload.previousStage || null,
-    nextStage: payload.nextStage || null,
-    status: payload.status || null,
-    error: payload.error || null,
-    timestamp,
-    details: payload.details || {}
-  };
-  await Promise.all(
-    targets.map(async (endpoint) => {
-      try {
-        const response = await fetch(endpoint.url, {
-          method: "POST",
-          headers: { "Content-Type": "application/json" },
-          body: JSON.stringify(body)
-        });
-        if (!response.ok) {
-          console.error(
-            `[notifications] webhook ${endpoint.url} responded with ${response.status}`
-          );
-        }
-      } catch (error) {
-        console.error(`[notifications] failed to send to ${endpoint.url}`, error);
-      }
-    })
-  );
-}
-var SchemaNotReadyError;
-var init_notifications = __esm({
-  "../agx-cloud/lib/notifications/index.ts"() {
-    init_db_adapter();
-    init_constants();
-    SchemaNotReadyError = class extends Error {
-    };
-  }
-});
-
-// ../agx-cloud/lib/db.ts
-function isMissingRelationError2(error, relation) {
-  if (!error) return false;
-  const message = typeof error.message === "string" ? error.message : "";
-  return error.code === "42P01" || error.code === "PGRST205" || message.includes(`relation "${relation}" does not exist`) || message.includes(`Could not find the table 'agx.${relation}'`) || message.includes(`Could not find the table 'public.${relation}'`);
-}
-function normalizeChangedAt(value) {
-  if (typeof value === "string") {
-    const t = Date.parse(value);
-    if (Number.isFinite(t)) return new Date(t).toISOString();
-  }
-  return (/* @__PURE__ */ new Date()).toISOString();
-}
-async function getUserSettings(userId) {
-  const db2 = createAdminDbClient();
-  const { data, error } = await db2.from("user_settings").select("*").eq("user_id", userId).maybeSingle();
-  if (error) {
-    if (isMissingRelationError2(error, "user_settings")) return null;
-    throw error;
-  }
-  if (!data) return null;
-  return data;
-}
-async function upsertUserSettings(userId, input, options) {
-  const onlyIfNewer = options?.onlyIfNewer !== false;
-  const incomingChangedAt = normalizeChangedAt(input.changed_at);
-  const existing = await getUserSettings(userId);
-  if (onlyIfNewer && existing?.changed_at) {
-    const existingTs = Date.parse(existing.changed_at);
-    const incomingTs = Date.parse(incomingChangedAt);
-    if (Number.isFinite(existingTs) && Number.isFinite(incomingTs) && incomingTs <= existingTs) {
-      return { settings: existing, updated: false };
-    }
-  }
-  const payload = {
-    user_id: userId,
-    default_provider: input.default_provider ?? existing?.default_provider ?? null,
-    models: input.models ?? existing?.models ?? {},
-    provenance: input.provenance,
-    changed_at: incomingChangedAt
-  };
-  const db2 = createAdminDbClient();
-  const { error: upsertError } = await db2.from("user_settings").upsert(payload, { onConflict: "user_id" });
-  if (upsertError) throw upsertError;
-  const after = await getUserSettings(userId);
-  if (!after) throw new Error("Failed to load user_settings after upsert");
-  return { settings: after, updated: true };
-}
-function slugify(input) {
-  return input.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 40) || "task";
-}
-async function generateUniqueSlug(base, db2) {
-  let slug = slugify(base);
-  for (let i = 0; i < 5; i++) {
-    const { data, error } = await db2.from("tasks").select("id").eq("slug", slug).limit(1);
-    if (error) throw error;
-    if (!data || data.length === 0) return slug;
-    const suffix = Math.random().toString(36).slice(2, 6);
-    slug = `${slugify(base)}-${suffix}`.slice(0, 48);
-  }
-  return `${slugify(base)}-${Date.now().toString(36).slice(-4)}`.slice(0, 48);
-}
-async function generateUniqueProjectSlug(base, userId, db2, excludeProjectId) {
-  let slug = slugify(base);
-  for (let i = 0; i < 5; i++) {
-    let query = db2.from("projects").select("id").eq("slug", slug).eq("user_id", userId);
-    if (excludeProjectId) {
-      query = query.neq("id", excludeProjectId);
-    }
-    const { data, error } = await query.limit(1);
-    if (error) throw error;
-    if (!data || data.length === 0) return slug;
-    const suffix = Math.random().toString(36).slice(2, 6);
-    slug = `${slugify(base)}-${suffix}`.slice(0, 48);
-  }
-  return `${slugify(base)}-${Date.now().toString(36).slice(-4)}`.slice(0, 48);
-}
-function getDbClient(client) {
-  return client ?? createAdminDbClient();
-}
-function parseDependsOnValue(value) {
-  const trimmed = value.trim();
-  if (!trimmed) return [];
-  try {
-    const parsed = JSON.parse(trimmed);
-    if (Array.isArray(parsed)) {
-      return parsed.map((item) => String(item || "").trim()).filter(Boolean);
-    }
-  } catch {
-  }
-  return trimmed.split(",").map((item) => item.trim()).filter(Boolean);
-}
-function normalizeDependsOnInput(input) {
-  if (!input) return [];
-  let candidates;
-  if (Array.isArray(input)) {
-    candidates = input.map((item) => typeof item === "string" ? item : item === null || item === void 0 ? "" : String(item)).filter(Boolean);
-  } else if (typeof input === "string") {
-    candidates = parseDependsOnValue(input);
-  } else {
-    return [];
-  }
-  return Array.from(new Set(candidates.map((id) => id.trim()).filter(Boolean)));
-}
-function parseFrontmatter(markdown) {
-  const match = markdown.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
-  if (!match) {
-    return { frontmatter: {}, body: markdown };
-  }
-  const frontmatter = {};
-  const lines = match[1].split("\n");
-  for (const line of lines) {
-    const colonIndex = line.indexOf(":");
-    if (colonIndex > 0) {
-      const key = line.slice(0, colonIndex).trim();
-      const value = line.slice(colonIndex + 1).trim();
-      if (key === "depends_on") {
-        frontmatter[key] = parseDependsOnValue(value);
-        continue;
-      }
-      if (value === "true") frontmatter[key] = true;
-      else if (value === "false") frontmatter[key] = false;
-      else if (/^\d+$/.test(value)) frontmatter[key] = parseInt(value);
-      else frontmatter[key] = value;
-    }
-  }
-  return { frontmatter, body: match[2] };
-}
-async function ensureNoCircularDependency(taskId, dependsOn, client) {
-  if (!taskId || !dependsOn?.length) return;
-  const db2 = getDbClient(client);
-  const visited = /* @__PURE__ */ new Set();
-  const stack = [...dependsOn];
-  while (stack.length) {
-    const candidate = stack.pop();
-    if (!candidate) continue;
-    if (candidate === taskId) {
-      throw new Error("Circular dependency detected");
-    }
-    if (visited.has(candidate)) continue;
-    visited.add(candidate);
-    const { data, error } = await db2.from("tasks").select("depends_on").eq("id", candidate).maybeSingle();
-    if (error) {
-      if (error.code === "PGRST116" || error.code === "42703") continue;
-      throw error;
-    }
-    if (!data) continue;
-    const childDeps = Array.isArray(data.depends_on) ? data.depends_on : [];
-    for (const next of childDeps) {
-      if (next && !visited.has(next)) {
-        stack.push(next);
-      }
-    }
-  }
-}
-function extractTitle(markdown) {
-  const { body } = parseFrontmatter(markdown);
-  const match = body.match(/^#\s+(.+)$/m);
-  return match ? match[1] : void 0;
-}
-function normalizeDescriptionBody(markdownBody) {
-  return String(markdownBody || "").replace(/^#\s+.+(\r?\n|$)/, "").trim();
-}
-async function ensureTaskDependencyState(task, userId) {
-  const deps = Array.isArray(task.depends_on) ? task.depends_on : [];
-  if (!deps.length) return;
-  const db2 = createAdminDbClient();
-  const { data: depTasks, error } = await db2.from("tasks").select("id, title, slug, status, stage").in("id", deps);
-  if (error) return;
-  const missingDependencies = (Array.isArray(depTasks) ? depTasks : []).filter(
-    (entry) => (entry?.status || "") !== "completed"
-  );
-  if (missingDependencies.length) {
-    const reason = formatDependencyBlockedReason(missingDependencies);
-    let query = db2.from("tasks").update({ status: "blocked", blocked_reason: reason }).eq("id", task.id);
-    if (userId) query = query.eq("user_id", userId);
-    const { error: updateError } = await query;
-    if (updateError && updateError.code !== "42703") {
-      throw updateError;
-    }
-    return;
-  }
-  if (task.status === "blocked" && isDependencyBlockedReason(task.blocked_reason)) {
-    let query = db2.from("tasks").update({ status: "queued", blocked_reason: null }).eq("id", task.id);
-    if (userId) query = query.eq("user_id", userId);
-    const { error: updateError } = await query;
-    if (updateError && updateError.code !== "42703") {
-      throw updateError;
-    }
-  }
-}
-async function getTasks(userId, filters) {
-  console.log("getTasks called with userId:", userId);
-  const db2 = createAdminDbClient();
-  let query = db2.from("tasks").select("*").order("priority", { ascending: true, nullsFirst: false }).order("created_at", { ascending: false });
-  if (userId) query = query.eq("user_id", userId);
-  if (filters?.project) {
-    const isUuid = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(filters.project);
-    query = isUuid ? query.eq("project_id", filters.project) : query.eq("project", filters.project);
-  }
-  if (filters?.orphan) query = query.is("project_id", null);
-  if (filters?.status) query = query.eq("status", filters.status);
-  if (filters?.search) {
-    const term = filters.search;
-    const isUuid = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(term);
-    if (isUuid) {
-      query = query.or(`id.eq.${term},slug.ilike.%${term}%,title.ilike.%${term}%`);
-    } else {
-      query = query.or(`id.ilike.%${term}%,slug.ilike.%${term}%,title.ilike.%${term}%`);
-    }
-  }
-  const { data, error } = await query;
-  if (error) throw error;
-  const rows = data || [];
-  if (!filters?.orphan) {
-    return rows;
-  }
-  return rows.filter((task) => {
-    const projectValue = String(task.project || "").trim().toLowerCase();
-    return !projectValue || projectValue === "none";
-  });
-}
-async function getTask(id, userId) {
-  const db2 = createAdminDbClient();
-  let query = db2.from("tasks").select("*").eq("id", id);
-  if (userId) query = query.eq("user_id", userId);
-  const { data, error } = await query.single();
-  if (error) {
-    if (error.code === "PGRST116") return null;
-    throw error;
-  }
-  return data;
-}
-async function getTaskBySlug(slug, userId) {
-  const db2 = createAdminDbClient();
-  let query = db2.from("tasks").select("*").eq("slug", slug);
-  if (userId) query = query.eq("user_id", userId);
-  const { data, error } = await query.single();
-  if (error) {
-    if (error.code === "PGRST116") return null;
-    throw error;
-  }
-  return data;
-}
-async function createTask(content, userId, options) {
-  const db2 = createAdminDbClient();
-  const { frontmatter, body } = parseFrontmatter(content);
-  const swarm = typeof frontmatter.swarm === "boolean" ? frontmatter.swarm : void 0;
-  const title = options?.title || extractTitle(content);
-  const slugBase = String(frontmatter.slug || title || "task");
-  const slug = await generateUniqueSlug(slugBase, db2);
-  const projectId = options?.projectId || (typeof frontmatter.project_id === "string" ? frontmatter.project_id : void 0);
-  const workflowId = typeof frontmatter.workflow_id === "string" ? frontmatter.workflow_id : void 0;
-  let projectSlug = typeof frontmatter.project === "string" ? frontmatter.project : void 0;
-  if (!projectSlug && projectId) {
-    const { data: proj } = await db2.from("projects").select("slug").eq("id", projectId).single();
-    if (proj?.slug) projectSlug = proj.slug;
-  }
-  const hadFrontmatter = /^---\n/.test(content);
-  const provider = typeof frontmatter.provider === "string" ? frontmatter.provider : null;
-  const model = typeof frontmatter.model === "string" ? frontmatter.model : null;
-  const engine = typeof frontmatter.engine === "string" ? frontmatter.engine : null;
-  const createdBy = frontmatter.created_by === "ai" ? "ai" : "user";
-  const frontmatterDepends = normalizeDependsOnInput(frontmatter.depends_on);
-  const optionDepends = normalizeDependsOnInput(options?.dependsOn);
-  const dependsOn = optionDepends.length > 0 ? optionDepends : frontmatterDepends;
-  const insertPayload = {
-    id: (0, import_crypto.randomUUID)(),
-    content,
-    description: normalizeDescriptionBody(body),
-    title,
-    slug,
-    status: frontmatter.status || "queued",
-    stage: frontmatter.stage || "intake",
-    project: projectSlug || null,
-    ...projectId !== void 0 ? { project_id: projectId } : {},
-    ...workflowId !== void 0 ? { workflow_id: workflowId } : {},
-    priority: frontmatter.priority,
-    engine,
-    provider,
-    model,
-    swarm,
-    swarm_models: options?.swarmModels ?? null,
-    depends_on: dependsOn.length ? dependsOn : null,
-    created_by: createdBy,
-    user_id: userId,
-    // Working set fields
-    current_plan: options?.currentPlan || null,
-    open_blockers: options?.openBlockers || [],
-    next_action: options?.nextAction || null,
-    version: 1
-  };
-  await ensureNoCircularDependency(insertPayload.id, dependsOn, db2);
-  let { data, error } = await db2.from("tasks").insert(insertPayload).select().single();
-  if (error && error.code === "42703") {
-    const {
-      swarm_models,
-      swarm: swarm2,
-      workflow_id,
-      current_plan,
-      open_blockers,
-      next_action,
-      version,
-      depends_on,
-      ...fallbackPayload
-    } = insertPayload;
-    ({ data, error } = await db2.from("tasks").insert(fallbackPayload).select().single());
-  }
-  if (error) throw error;
-  if (!data) {
-    throw new Error("Failed to create task");
-  }
-  await ensureTaskDependencyState(data, userId);
-  const refreshed = await getTask(data.id, userId);
-  const taskRecord = refreshed || data;
-  const resolvedUserId = userId || taskRecord.user_id;
-  if (resolvedUserId) {
-    const eventTimestamp = taskRecord.created_at || (/* @__PURE__ */ new Date()).toISOString();
-    const details = {
-      dependsOn: Array.isArray(taskRecord.depends_on) ? taskRecord.depends_on : [],
-      project: taskRecord.project || null,
-      projectId: taskRecord.project_id || null,
-      workflowId: taskRecord.workflow_id || null,
-      createdBy: taskRecord.created_by || null
-    };
-    void notifyTaskEvent({
-      taskId: taskRecord.id,
-      userId: resolvedUserId,
-      eventType: "task.created",
-      title: taskRecord.title || null,
-      slug: taskRecord.slug || null,
-      stage: taskRecord.stage || null,
-      status: taskRecord.status || null,
-      timestamp: eventTimestamp,
-      details
-    });
-  }
-  return taskRecord;
-}
-async function updateTask(id, content, userId, options) {
-  const db2 = createAdminDbClient();
-  const { frontmatter, body } = parseFrontmatter(content);
-  const swarm = typeof frontmatter.swarm === "boolean" ? frontmatter.swarm : void 0;
-  const title = extractTitle(content);
-  const projectId = typeof frontmatter.project_id === "string" ? frontmatter.project_id : void 0;
-  const hasProvider = Object.prototype.hasOwnProperty.call(frontmatter, "provider");
-  const hasModel = Object.prototype.hasOwnProperty.call(frontmatter, "model");
-  const hasWorkflowId = Object.prototype.hasOwnProperty.call(frontmatter, "workflow_id");
-  const hasDependsOnInFrontmatter = Object.prototype.hasOwnProperty.call(frontmatter, "depends_on");
-  const dependsFromFrontmatter = normalizeDependsOnInput(frontmatter.depends_on);
-  const dependsFromOptions = normalizeDependsOnInput(options?.dependsOn);
-  const shouldUpdateDepends = options?.dependsOn !== void 0 || hasDependsOnInFrontmatter;
-  const dependsOnForUpdate = options?.dependsOn !== void 0 ? dependsFromOptions : dependsFromFrontmatter;
-  const updatePayload = {
-    content,
-    description: normalizeDescriptionBody(body),
-    title,
-    status: frontmatter.status,
-    stage: frontmatter.stage,
-    project: frontmatter.project,
-    ...projectId !== void 0 ? { project_id: projectId } : {},
-    workflow_id: hasWorkflowId ? frontmatter.workflow_id : void 0,
-    priority: frontmatter.priority,
-    engine: frontmatter.engine,
-    provider: hasProvider ? frontmatter.provider : null,
-    model: hasModel ? frontmatter.model : null,
-    swarm,
-    swarm_models: options?.swarmModels ?? void 0,
-    ...shouldUpdateDepends ? { depends_on: dependsOnForUpdate.length ? dependsOnForUpdate : null } : {},
-    updated_at: (/* @__PURE__ */ new Date()).toISOString(),
-    // Working set fields
-    current_plan: options?.currentPlan ?? void 0,
-    open_blockers: options?.openBlockers ?? void 0,
-    next_action: options?.nextAction ?? void 0
-  };
-  Object.keys(updatePayload).forEach((key) => {
-    if (updatePayload[key] === void 0) {
-      delete updatePayload[key];
-    }
-  });
-  if (shouldUpdateDepends) {
-    await ensureNoCircularDependency(id, dependsOnForUpdate, db2);
-  }
-  let query = db2.from("tasks").update({
-    ...updatePayload,
-    version: db2.rpc("increment_version")
-    // This will be used in the actual SQL via RPC or raw query if possible
-  }).eq("id", id);
-  if (userId) query = query.eq("user_id", userId);
-  if (options?.expectedVersion !== void 0) {
-    query = query.eq("version", options.expectedVersion);
-  }
-  let { data, error } = await db2.from("tasks").update({
-    ...updatePayload
-  }).eq("id", id).select().maybeSingle();
-  if (error) {
-    console.error(`[db.updateTask] error updating task ${id}:`, error);
-  }
-  if (!data && !error) {
-    console.warn(`[db.updateTask] UPDATE returned 0 rows for task ${id}, payload keys:`, Object.keys(updatePayload));
-  }
-  if (error && error.code === "42703") {
-    const {
-      swarm_models,
-      swarm: swarm2,
-      workflow_id,
-      current_plan,
-      open_blockers,
-      next_action,
-      version,
-      depends_on,
-      ...fallbackPayload
-    } = updatePayload;
-    let fallbackQuery = db2.from("tasks").update(fallbackPayload).eq("id", id);
-    if (userId) fallbackQuery = fallbackQuery.eq("user_id", userId);
-    ({ data, error } = await fallbackQuery.select().maybeSingle());
-  }
-  if (error) throw error;
-  if (!data) {
-    const fallback = await getTask(id, userId);
-    if (!fallback) throw new Error(`Task ${id} not found`);
-    return fallback;
-  }
-  await ensureTaskDependencyState(data, userId);
-  const refreshed = await getTask(data.id, userId);
-  const taskRecord = refreshed || data;
-  const resolvedUserId = userId || taskRecord.user_id;
-  if (resolvedUserId) {
-    const eventTimestamp = taskRecord.created_at || (/* @__PURE__ */ new Date()).toISOString();
-    const details = {
-      dependsOn: Array.isArray(taskRecord.depends_on) ? taskRecord.depends_on : [],
-      project: taskRecord.project || null,
-      projectId: taskRecord.project_id || null,
-      workflowId: taskRecord.workflow_id || null,
-      createdBy: taskRecord.created_by || null
-    };
-    void notifyTaskEvent({
-      taskId: taskRecord.id,
-      userId: resolvedUserId,
-      eventType: "task.created",
-      title: taskRecord.title || null,
-      slug: taskRecord.slug || null,
-      stage: taskRecord.stage || null,
-      status: taskRecord.status || null,
-      timestamp: eventTimestamp,
-      details
-    });
-  }
-  return taskRecord;
-}
-async function appendRunToIndex(taskId, runEntry, maxRuns = 25) {
-  const db2 = createAdminDbClient();
-  const { data: task, error: fetchError } = await db2.from("tasks").select("run_index").eq("id", taskId).single();
-  if (fetchError) {
-    if (fetchError?.code === "42703") return;
-    throw fetchError;
-  }
-  const runIndex = Array.isArray(task.run_index) ? task.run_index : [];
-  const updatedIndex = [runEntry, ...runIndex].slice(0, maxRuns);
-  const { error: updateError } = await db2.from("tasks").update({ run_index: updatedIndex }).eq("id", taskId);
-  if (updateError) {
-    if (updateError?.code === "42703") return;
-    throw updateError;
-  }
-}
-async function deleteTask(id, userId) {
-  const db2 = createAdminDbClient();
-  let query = db2.from("tasks").delete().eq("id", id);
-  if (userId) query = query.eq("user_id", userId);
-  const { error } = await query;
-  if (error) throw error;
-}
-async function getNextQueuedTask(engine) {
-  const db2 = createAdminDbClient();
-  let query = db2.from("tasks").select("*").eq("status", "queued").order("priority", { ascending: true, nullsFirst: false }).order("created_at", { ascending: true }).limit(1);
-  if (engine) query = query.eq("engine", engine);
-  const { data, error } = await query.single();
-  if (error) {
-    if (error.code === "PGRST116") return null;
-    throw error;
-  }
-  return data;
-}
-async function getProjects(userId) {
-  const db2 = createAdminDbClient();
-  let query = db2.from("projects").select("*, project_repos(*)");
-  if (userId) query = query.eq("user_id", userId);
-  const { data, error } = await query;
-  if (error) {
-    if (isMissingRelationError2(error, "projects")) {
-      return [];
-    }
-    throw error;
-  }
-  const projects = data || [];
-  return projects.map((project) => ({
-    ...project,
-    repos: project.project_repos ?? []
-  }));
-}
-async function getProjectBySlug(slug, userId) {
-  const db2 = createAdminDbClient();
-  let query = db2.from("projects").select("*").eq("slug", slug);
-  if (userId) query = query.eq("user_id", userId);
-  const { data, error } = await query.maybeSingle();
-  if (error) {
-    if (isMissingRelationError2(error, "projects")) {
-      return null;
-    }
-    throw error;
-  }
-  return data || null;
-}
-async function getProjectRepos(projectId) {
-  const db2 = createAdminDbClient();
-  const { data, error } = await db2.from("project_repos").select("*").eq("project_id", projectId);
-  if (error) {
-    if (isMissingRelationError2(error, "project_repos")) {
-      return [];
-    }
-    throw error;
-  }
-  return data || [];
-}
-async function getProjectWithRepos(projectIdOrSlug, userId) {
-  const db2 = createAdminDbClient();
-  const isUuid = UUID_REGEX.test(projectIdOrSlug);
-  let projectQuery = db2.from("projects").select("*");
-  if (isUuid) {
-    projectQuery = projectQuery.eq("id", projectIdOrSlug);
-  } else {
-    projectQuery = projectQuery.eq("slug", projectIdOrSlug);
-  }
-  if (userId) projectQuery = projectQuery.eq("user_id", userId);
-  const projectResult = await projectQuery.maybeSingle();
-  if (projectResult.error) {
-    if (isMissingRelationError2(projectResult.error, "projects")) {
-      return null;
-    }
-    throw projectResult.error;
-  }
-  const project = projectResult.data;
-  if (!project) return null;
-  const repos = await getProjectRepos(project.id);
-  return { ...project, repos };
-}
-async function insertProjectRepos(projectId, repos, db2) {
-  if (!repos.length) {
-    return [];
-  }
-  const payload = repos.map((repo) => ({
-    project_id: projectId,
-    name: repo.name,
-    path: repo.path ?? null,
-    notes: repo.notes ?? null
-  }));
-  const { data, error } = await db2.from("project_repos").insert(payload).select("*");
-  if (error) {
-    if (isMissingRelationError2(error, "project_repos")) {
-      return [];
-    }
-    throw error;
-  }
-  return data || [];
-}
-async function createProject(userId, input, dbClient) {
-  if (!input.name?.trim()) {
-    throw new Error("Project name is required");
-  }
-  const db2 = getDbClient(dbClient);
-  const baseSlug = input.name.trim() || "project";
-  const slug = await generateUniqueProjectSlug(baseSlug, userId, db2);
-  const payload = {
-    user_id: userId,
-    name: input.name.trim(),
-    slug,
-    description: input.description ?? null,
-    workflow_id: input.workflow_id ?? null
-  };
-  const { data: project, error } = await db2.from("projects").insert(payload).select("*").single();
-  if (error) throw error;
-  const repos = await insertProjectRepos(project.id, input.repos ?? [], db2);
-  return { ...project, repos };
-}
-async function updateProject(projectIdOrSlug, userId, updates, dbClient) {
-  const db2 = getDbClient(dbClient);
-  const isUuid = UUID_REGEX.test(projectIdOrSlug);
-  let projectId = projectIdOrSlug;
-  if (!isUuid) {
-    const project = await getProjectBySlug(projectIdOrSlug, userId);
-    if (!project) return null;
-    projectId = project.id;
-  }
-  const updatePayload = {};
-  if (typeof updates.name !== "undefined") {
-    const trimmedName = updates.name?.trim();
-    if (!trimmedName) {
-      throw new Error("Project name cannot be empty");
-    }
-    updatePayload.name = trimmedName;
-  }
-  if (typeof updates.slug !== "undefined") {
-    const trimmedSlug = updates.slug?.trim();
-    if (trimmedSlug) {
-      updatePayload.slug = trimmedSlug;
-    }
-  }
-  if (typeof updates.description !== "undefined") updatePayload.description = updates.description;
-  if (typeof updates.metadata !== "undefined") updatePayload.metadata = updates.metadata;
-  if (typeof updates.ci_cd_info !== "undefined") updatePayload.ci_cd_info = updates.ci_cd_info;
-  if (typeof updates.workflow_id !== "undefined") updatePayload.workflow_id = updates.workflow_id;
-  if (Object.keys(updatePayload).length) {
-    const { error } = await db2.from("projects").update(updatePayload).eq("id", projectId).eq("user_id", userId);
-    if (error) throw error;
-  }
-  if (updates.repos) {
-    const { error: deleteError } = await db2.from("project_repos").delete().eq("project_id", projectId);
-    if (deleteError && !isMissingRelationError2(deleteError, "project_repos")) {
-      throw deleteError;
-    }
-    await insertProjectRepos(projectId, updates.repos, db2);
-  }
-  return getProjectWithRepos(projectId, userId);
-}
-async function deleteProject(projectId, userId, dbClient) {
-  const db2 = getDbClient(dbClient);
-  const { error } = await db2.from("projects").delete().eq("id", projectId).eq("user_id", userId);
-  if (error) throw error;
-}
-async function assignOrphanTasksToProject(projectId, userId, dbClient) {
-  const db2 = getDbClient(dbClient);
-  const { data: project, error: projectError } = await db2.from("projects").select("id, slug").eq("id", projectId).eq("user_id", userId).maybeSingle();
-  if (projectError) throw projectError;
-  if (!project) {
-    throw new Error("Project not found");
-  }
-  const { data: tasks, error: tasksError } = await db2.from("tasks").select("id, project").eq("user_id", userId).is("project_id", null);
-  if (tasksError) throw tasksError;
-  const slug = String(project.slug || "").trim().toLowerCase();
-  const orphanTaskIds = (tasks || []).filter((task) => {
-    const projectValue = String(task.project || "").trim().toLowerCase();
-    return !projectValue || projectValue === "none" || projectValue === slug;
-  }).map((task) => task.id);
-  if (!orphanTaskIds.length) {
-    return { updatedCount: 0, taskIds: [] };
-  }
-  const { error: updateError } = await db2.from("tasks").update({
-    project: project.slug,
-    project_id: project.id,
-    updated_at: (/* @__PURE__ */ new Date()).toISOString()
-  }).eq("user_id", userId).is("project_id", null).in("id", orphanTaskIds);
-  if (updateError) throw updateError;
-  return { updatedCount: orphanTaskIds.length, taskIds: orphanTaskIds };
-}
-async function ensureDefaultWorkflowGraphExists(userId) {
-  const db2 = createAdminDbClient();
-  const ownerId = userId || DEFAULT_SYSTEM_USER_ID;
-  const { error: workflowError } = await db2.from("workflows").upsert(
-    {
-      id: DEFAULT_SDLC_WORKFLOW_ID,
-      user_id: ownerId,
-      name: "Default Workflow",
-      definition: {}
-    },
-    { onConflict: "id" }
-  );
-  if (workflowError) throw workflowError;
-  const { error: nodeError } = await db2.from("workflow_nodes").upsert(
-    DEFAULT_WORKFLOW_NODE_SEED.map((node) => ({
-      ...node,
-      workflow_id: DEFAULT_SDLC_WORKFLOW_ID,
-      metadata: {}
-    })),
-    { onConflict: "id" }
-  );
-  if (nodeError) throw nodeError;
-  const { error: transitionError } = await db2.from("workflow_transitions").upsert(
-    [
-      {
-        workflow_id: DEFAULT_SDLC_WORKFLOW_ID,
-        from_node_id: "00000000-0000-0000-0001-000000000001",
-        // INTAKE
-        to_node_id: "00000000-0000-0000-0001-000000000002",
-        // PROGRESS
-        condition: "done",
-        priority: 0,
-        metadata: {}
-      },
-      {
-        workflow_id: DEFAULT_SDLC_WORKFLOW_ID,
-        from_node_id: "00000000-0000-0000-0001-000000000002",
-        // PROGRESS
-        to_node_id: "00000000-0000-0000-0001-000000000003",
-        // DONE
-        condition: "done",
-        priority: 0,
-        metadata: {}
-      }
-    ],
-    { onConflict: "workflow_id,from_node_id,condition" }
-  );
-  if (transitionError) throw transitionError;
-}
-async function getWorkflows(userId) {
-  const db2 = createAdminDbClient();
-  const { data, error } = await db2.from("workflows").select("*").or(`user_id.eq.${userId},user_id.eq.00000000-0000-0000-0000-000000000000`).order("created_at", { ascending: false });
-  if (error) {
-    if (isMissingRelationError2(error, "workflows")) return [];
-    throw error;
-  }
-  return data || [];
-}
-async function getWorkflow(id, userId) {
-  const db2 = createAdminDbClient();
-  let query = db2.from("workflows").select("*").eq("id", id);
-  if (userId) {
-  }
-  const { data, error } = await query.maybeSingle();
-  if (error) {
-    if (isMissingRelationError2(error, "workflows")) return null;
-    throw error;
-  }
-  return data;
-}
-async function updateWorkflow(id, userId, updates) {
-  const db2 = createAdminDbClient();
-  const payload = { updated_at: (/* @__PURE__ */ new Date()).toISOString() };
-  if (updates.definition !== void 0) payload.definition = updates.definition;
-  if (updates.name !== void 0) payload.name = updates.name;
-  if (updates.description !== void 0) payload.description = updates.description;
-  const { data, error } = await db2.from("workflows").update(payload).eq("id", id).select().single();
-  if (error) throw error;
-  return data;
-}
-async function getWorkflowNodes(workflowId) {
-  const db2 = createAdminDbClient();
-  const { data, error } = await db2.from("workflow_nodes").select("*").eq("workflow_id", workflowId).order("position", { ascending: true });
-  if (error) {
-    if (isMissingRelationError2(error, "workflow_nodes")) return [];
-    throw error;
-  }
-  return data || [];
-}
-async function updateWorkflowNodes(workflowId, userId, updates) {
-  const db2 = createAdminDbClient();
-  if (workflowId === DEFAULT_SDLC_WORKFLOW_ID) {
-    await ensureDefaultWorkflowGraphExists(userId);
-  }
-  const wf = await getWorkflow(workflowId, userId);
-  if (!wf) throw new Error("Workflow not found");
-  if (workflowId === DEFAULT_SDLC_WORKFLOW_ID) {
-    const seedAwareRows = updates.map((node) => {
-      const seed = DEFAULT_WORKFLOW_NODE_SEED_BY_ID.get(node.id);
-      if (!seed) return null;
-      return {
-        id: node.id,
-        workflow_id: workflowId,
-        name: seed.name,
-        label: seed.label,
-        position: seed.position,
-        node_type: seed.node_type,
-        prompt: node.prompt ?? seed.prompt,
-        provider: node.provider ?? null,
-        model: node.model ?? null,
-        metadata: node.metadata ?? {}
-      };
-    }).filter((node) => Boolean(node));
-    if (seedAwareRows.length > 0) {
-      const { error } = await db2.from("workflow_nodes").upsert(seedAwareRows, { onConflict: "id" });
-      if (error) throw error;
-    }
-    return getWorkflowNodes(workflowId);
-  }
-  await Promise.all(
-    updates.map(async (node) => {
-      const payload = {};
-      if (node.prompt !== void 0) payload.prompt = node.prompt;
-      if (node.provider !== void 0) payload.provider = node.provider;
-      if (node.model !== void 0) payload.model = node.model;
-      if (node.metadata !== void 0) payload.metadata = node.metadata;
-      if (Object.keys(payload).length === 0) return;
-      const { error } = await db2.from("workflow_nodes").update(payload).eq("workflow_id", workflowId).eq("id", node.id);
-      if (error) throw error;
-    })
-  );
-  return getWorkflowNodes(workflowId);
-}
-async function getWorkflowNodeByName(workflowId, name) {
-  const db2 = createAdminDbClient();
-  const { data, error } = await db2.from("workflow_nodes").select("*").eq("workflow_id", workflowId).eq("name", name).maybeSingle();
-  if (error) {
-    if (isMissingRelationError2(error, "workflow_nodes")) return null;
-    throw error;
-  }
-  return data;
-}
-async function getWorkflowTransitions(workflowId) {
-  const db2 = createAdminDbClient();
-  const { data, error } = await db2.from("workflow_transitions").select("*").eq("workflow_id", workflowId).order("priority", { ascending: true });
-  if (error) {
-    if (isMissingRelationError2(error, "workflow_transitions")) return [];
-    throw error;
-  }
-  return data || [];
-}
-async function getWorkflowTransitionsFromNode(workflowId, fromNodeId) {
-  const db2 = createAdminDbClient();
-  const { data, error } = await db2.from("workflow_transitions").select("*").eq("workflow_id", workflowId).eq("from_node_id", fromNodeId).order("priority", { ascending: true });
-  if (error) {
-    if (isMissingRelationError2(error, "workflow_transitions")) return [];
-    throw error;
-  }
-  return data || [];
-}
-async function getWorkflowWithGraph(id, userId) {
-  const workflow = await getWorkflow(id, userId);
-  if (!workflow) return null;
-  const [nodes, transitions] = await Promise.all([
-    getWorkflowNodes(id),
-    getWorkflowTransitions(id)
-  ]);
-  return { ...workflow, nodes, transitions };
-}
-async function getTaskLogs(taskId, options = {}) {
-  const db2 = createAdminDbClient();
-  const limit = Math.max(1, Math.min(2e3, Number(options.limit ?? options.tail ?? 500)));
-  const after = typeof options.after === "string" && options.after.trim() ? options.after.trim() : null;
-  const tail = after ? null : options.tail === void 0 ? limit : Number(options.tail);
-  const useTail = tail !== null && Number.isFinite(tail) && tail > 0;
-  let query = db2.from("task_logs").select("*").eq("task_id", taskId);
-  if (options.nodeId) {
-    query = query.eq("node_id", options.nodeId);
-  }
-  if (after) {
-    query = query.gt("created_at", after).order("created_at", { ascending: true }).order("id", { ascending: true }).limit(limit);
-  } else if (useTail) {
-    query = query.order("created_at", { ascending: false }).order("id", { ascending: false }).limit(limit);
-  } else {
-    query = query.order("created_at", { ascending: true }).order("id", { ascending: true }).limit(limit);
-  }
-  const { data, error } = await query;
-  if (error) throw error;
-  const rows = data || [];
-  if (after) return rows;
-  if (useTail) return rows.slice().reverse();
-  return rows;
-}
-async function addTaskLog(taskId, content, logType, nodeId) {
-  const db2 = createAdminDbClient();
-  const { data, error } = await db2.from("task_logs").insert({ task_id: taskId, content, log_type: logType, ...nodeId ? { node_id: nodeId } : {} }).select().single();
-  if (error) throw error;
-  return data;
-}
-function normalizeTokenCount(value) {
-  const parsed = Number(value ?? 0);
-  if (!Number.isFinite(parsed)) return 0;
-  return Math.max(0, Math.round(parsed));
-}
-function normalizeCostValue(value) {
-  const parsed = Number(value ?? 0);
-  if (!Number.isFinite(parsed)) return 0;
-  return Math.max(0, parsed);
-}
-async function addTaskCostEntry(input) {
-  const db2 = createAdminDbClient();
-  const payload = {
-    task_id: input.taskId,
-    stage: input.stage,
-    provider: input.provider ?? null,
-    model: input.model ?? null,
-    input_tokens: normalizeTokenCount(input.inputTokens),
-    output_tokens: normalizeTokenCount(input.outputTokens),
-    estimated_cost: normalizeCostValue(input.estimatedCost)
-  };
-  const { data, error } = await db2.from("task_costs").insert(payload).select().single();
-  if (error) throw error;
-  return data;
-}
-async function getTaskCostEntries(taskId) {
-  const db2 = createAdminDbClient();
-  const { data, error } = await db2.from("task_costs").select("*").eq("task_id", taskId).order("created_at", { ascending: true });
-  if (error) throw error;
-  return data || [];
-}
-function summarizeTaskCosts(entries) {
-  const stageMap = {};
-  let totalInput = 0;
-  let totalOutput = 0;
-  let totalCost = 0;
-  for (const entry of entries) {
-    const stageKey = entry.stage || "unknown";
-    const input = normalizeTokenCount(entry.input_tokens);
-    const output = normalizeTokenCount(entry.output_tokens);
-    const cost = normalizeCostValue(entry.estimated_cost ?? 0);
-    totalInput += input;
-    totalOutput += output;
-    totalCost += cost;
-    const existing = stageMap[stageKey] || {
-      stage: stageKey,
-      input_tokens: 0,
-      output_tokens: 0,
-      estimated_cost: 0,
-      entries: 0
-    };
-    existing.input_tokens += input;
-    existing.output_tokens += output;
-    existing.estimated_cost += cost;
-    existing.entries += 1;
-    stageMap[stageKey] = existing;
-  }
-  const perStage = Object.values(stageMap).sort((a, b) => a.stage.localeCompare(b.stage));
-  return {
-    total_input_tokens: totalInput,
-    total_output_tokens: totalOutput,
-    total_cost: totalCost,
-    per_stage: perStage
-  };
-}
-async function getTaskCostSummary(taskId) {
-  const entries = await getTaskCostEntries(taskId);
-  return summarizeTaskCosts(entries);
-}
-async function getTaskComments(taskId) {
-  const db2 = createAdminDbClient();
-  const { data, error } = await db2.from("task_comments").select("*").eq("task_id", taskId).is("deleted_at", null).order("created_at", { ascending: true }).order("id", { ascending: true });
-  if (error) throw error;
-  return data || [];
-}
-async function addTaskComment(taskId, content, authorType, authorId) {
-  const db2 = createAdminDbClient();
-  const { data, error } = await db2.from("task_comments").insert({ task_id: taskId, content, author_type: authorType, author_id: authorId ?? null }).select().single();
-  if (error) throw error;
-  return data;
-}
-async function deleteTaskComment(commentId, userId) {
-  const db2 = createAdminDbClient();
-  const { data: comment, error: fetchError } = await db2.from("task_comments").select("author_id, author_type").eq("id", commentId).single();
-  if (fetchError) throw fetchError;
-  if (!comment) throw new Error("Comment not found");
-  if (comment.author_type !== "user" || comment.author_id !== userId) {
-    throw new Error("Unauthorized");
-  }
-  const { error } = await db2.from("task_comments").update({ deleted_at: (/* @__PURE__ */ new Date()).toISOString() }).eq("id", commentId).is("deleted_at", null);
-  if (error) throw error;
-}
-async function getLearnings(scope, scopeId, userId) {
-  const db2 = createAdminDbClient();
-  let query = db2.from("learnings").select("*").eq("scope", scope).order("created_at", { ascending: false });
-  if (scopeId) query = query.eq("scope_id", scopeId);
-  if (userId) query = query.eq("user_id", userId);
-  const { data, error } = await query;
-  if (error) throw error;
-  return data || [];
-}
-async function addLearning(scope, content, scopeId, userId) {
-  const db2 = createAdminDbClient();
-  const { data, error } = await db2.from("learnings").insert({ scope, scope_id: scopeId, content, user_id: userId }).select().single();
-  if (error) throw error;
-  return data;
-}
-async function deleteLearning(id, userId) {
-  const db2 = createAdminDbClient();
-  let query = db2.from("learnings").delete().eq("id", id);
-  if (userId) query = query.eq("user_id", userId);
-  const { error } = await query;
-  if (error) throw error;
-}
-async function getStagePrompts(userId, workflowId) {
-  const db2 = createAdminDbClient();
-  let query = db2.from("stage_prompts").select("*").eq("workflow_id", workflowId).order("stage", { ascending: true });
-  if (userId) {
-    query = query.or(`user_id.eq.${userId},is_default.eq.true`);
-  } else {
-    query = query.eq("is_default", true);
-  }
-  const { data, error } = await query;
-  if (error) throw error;
-  return data || [];
-}
-async function getStagePrompt(stage, userId, workflowId) {
-  const db2 = createAdminDbClient();
-  if (userId) {
-    const { data: userPrompt } = await db2.from("stage_prompts").select("*").eq("workflow_id", workflowId).eq("stage", stage).eq("user_id", userId).single();
-    if (userPrompt) return userPrompt;
-  }
-  const { data: defaultPrompt } = await db2.from("stage_prompts").select("*").eq("workflow_id", workflowId).eq("stage", stage).eq("is_default", true).single();
-  return defaultPrompt || null;
-}
-async function upsertStagePrompt(stage, prompt, outputs = [], userId, modelConfig, workflowId) {
-  const db2 = createAdminDbClient();
-  const payload = {
-    stage,
-    prompt,
-    outputs,
-    user_id: userId,
-    is_default: !userId,
-    workflow_id: workflowId
-  };
-  if (modelConfig) {
-    if (modelConfig.swarm !== void 0) payload.swarm = modelConfig.swarm;
-    if (modelConfig.provider !== void 0) payload.provider = modelConfig.provider;
-    if (modelConfig.model !== void 0) payload.model = modelConfig.model;
-    if (modelConfig.swarm_models !== void 0) payload.swarm_models = modelConfig.swarm_models;
-  }
-  const { data, error } = await db2.from("stage_prompts").upsert(payload, {
-    onConflict: userId ? "workflow_id,stage,user_id" : "workflow_id,stage,is_default"
-  }).select().single();
-  if (error) throw error;
-  return data;
-}
-async function deleteStagePrompt(id, userId) {
-  const db2 = createAdminDbClient();
-  let query = db2.from("stage_prompts").delete().eq("id", id);
-  if (userId) query = query.eq("user_id", userId);
-  const { error } = await query;
-  if (error) throw error;
-}
-async function getAgents(userId) {
-  const db2 = createAdminDbClient();
-  const { data, error } = await db2.from("agents").select("*").eq("user_id", userId).order("created_at", { ascending: false });
-  if (error) {
-    if (isMissingRelationError2(error, "agents")) return [];
-    throw error;
-  }
-  return data || [];
-}
-async function getAgent(id, userId) {
-  const db2 = createAdminDbClient();
-  const { data, error } = await db2.from("agents").select("*").eq("id", id).eq("user_id", userId).maybeSingle();
-  if (error) {
-    if (error.code === "PGRST116" || isMissingRelationError2(error, "agents")) return null;
-    throw error;
-  }
-  return data;
-}
-async function createAgent(userId, input) {
-  const db2 = createAdminDbClient();
-  const payload = {
-    user_id: userId,
-    name: input.name,
-    style: input.style,
-    description: input.description ?? null,
-    config: input.config ?? {}
-  };
-  const { data, error } = await db2.from("agents").insert(payload).select().single();
-  if (error) {
-    if (isMissingRelationError2(error, "agents")) {
-      throw new Error("Agents table does not exist");
-    }
-    throw error;
-  }
-  return data;
-}
-async function updateAgent(id, userId, input) {
-  const db2 = createAdminDbClient();
-  const updatePayload = { updated_at: (/* @__PURE__ */ new Date()).toISOString() };
-  if (input.name !== void 0) updatePayload.name = input.name;
-  if (input.style !== void 0) updatePayload.style = input.style;
-  if (input.description !== void 0) updatePayload.description = input.description;
-  if (input.config !== void 0) updatePayload.config = input.config;
-  if (Object.keys(updatePayload).length === 1) {
-    return getAgent(id, userId);
-  }
-  const { data, error } = await db2.from("agents").update(updatePayload).eq("id", id).eq("user_id", userId).select().single();
-  if (error) {
-    if (error.code === "PGRST116" || isMissingRelationError2(error, "agents")) return null;
-    throw error;
-  }
-  return data;
-}
-async function deleteAgent(id, userId) {
-  const db2 = createAdminDbClient();
-  const { error } = await db2.from("agents").delete().eq("id", id).eq("user_id", userId);
-  if (error) {
-    if (!isMissingRelationError2(error, "agents")) {
-      throw error;
-    }
-  }
-}
-var import_crypto, UUID_REGEX, DEFAULT_SDLC_WORKFLOW_ID, DEFAULT_SYSTEM_USER_ID, DEFAULT_WORKFLOW_NODE_SEED, DEFAULT_WORKFLOW_NODE_SEED_BY_ID;
-var init_db = __esm({
-  "../agx-cloud/lib/db.ts"() {
-    "use strict";
-    init_db_adapter();
-    init_dependency_helpers();
-    init_notifications();
-    import_crypto = require("crypto");
-    UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-    DEFAULT_SDLC_WORKFLOW_ID = "00000000-0000-0000-0000-000000000001";
-    DEFAULT_SYSTEM_USER_ID = "00000000-0000-0000-0000-000000000000";
-    DEFAULT_WORKFLOW_NODE_SEED = [
-      {
-        id: "00000000-0000-0000-0001-000000000001",
-        name: "INTAKE",
-        label: "Intake",
-        prompt: "New task. Triage, scope, and prepare for work.",
-        position: 0,
-        node_type: "step"
-      },
-      {
-        id: "00000000-0000-0000-0001-000000000002",
-        name: "PROGRESS",
-        label: "Progress",
-        prompt: "Task is actively being worked on.",
-        position: 1,
-        node_type: "step"
-      },
-      {
-        id: "00000000-0000-0000-0001-000000000003",
-        name: "DONE",
-        label: "Done",
-        prompt: "Task completed.",
-        position: 2,
-        node_type: "terminal"
-      }
-    ];
-    DEFAULT_WORKFLOW_NODE_SEED_BY_ID = new Map(
-      DEFAULT_WORKFLOW_NODE_SEED.map((node) => [node.id, node])
-    );
-  }
-});
-
-// ../agx-cloud/lib/errors.ts
-var ConflictError, RetryableError, ConcurrentModificationError;
-var init_errors = __esm({
-  "../agx-cloud/lib/errors.ts"() {
-    "use strict";
-    ConflictError = class extends Error {
-      constructor(message, opts) {
-        super(message);
-        this.name = "ConflictError";
-        this.constraint = opts?.constraint;
-        this.detail = opts?.detail;
-      }
-    };
-    RetryableError = class extends Error {
-      constructor(message, code) {
-        super(message);
-        this.name = "RetryableError";
-        this.code = code;
-      }
-    };
-    ConcurrentModificationError = class extends Error {
-      constructor(entityType, entityId, expectedVersion, actualVersion) {
-        const msg = actualVersion !== void 0 ? `Concurrent modification on ${entityType} ${entityId}: expected version ${expectedVersion}, found ${actualVersion}` : `Concurrent modification on ${entityType} ${entityId}: expected version ${expectedVersion}, row not updated`;
-        super(msg);
-        this.name = "ConcurrentModificationError";
-        this.entityType = entityType;
-        this.entityId = entityId;
-        this.expectedVersion = expectedVersion;
-        this.actualVersion = actualVersion;
-      }
-    };
-  }
-});
-
-// ../agx-cloud/lib/adapters/sqlite-adapter.ts
-var sqlite_adapter_exports = {};
-__export(sqlite_adapter_exports, {
-  SQLiteAdapter: () => SQLiteAdapter
-});
-function translateSqliteError(err) {
-  if (!(err instanceof Error)) throw err;
-  const sqliteErr = err;
-  const code = sqliteErr.code ?? "";
-  const msg = sqliteErr.message ?? "";
-  if (code === "SQLITE_CONSTRAINT_UNIQUE" || code === "SQLITE_CONSTRAINT_PRIMARYKEY" || code === "SQLITE_CONSTRAINT" && (msg.includes("UNIQUE") || msg.includes("PRIMARY KEY")) || msg.includes("UNIQUE constraint failed") || msg.includes("PRIMARY KEY constraint failed")) {
-    const constraintMatch = msg.match(/(?:UNIQUE|PRIMARY KEY) constraint failed: (.+)/);
-    throw new ConflictError(msg, {
-      constraint: constraintMatch?.[1],
-      detail: msg
-    });
-  }
-  if (code === "SQLITE_BUSY" || code === "SQLITE_LOCKED" || msg.includes("database is locked")) {
-    throw new RetryableError(msg, code || "SQLITE_BUSY");
-  }
-  throw err;
-}
-async function withErrorTranslation(fn) {
-  try {
-    return await fn();
-  } catch (err) {
-    if (err instanceof ConflictError || err instanceof RetryableError || err instanceof ConcurrentModificationError) {
-      throw err;
-    }
-    translateSqliteError(err);
-  }
-}
-var SQLiteAdapter;
-var init_sqlite_adapter = __esm({
-  "../agx-cloud/lib/adapters/sqlite-adapter.ts"() {
-    "use strict";
-    init_db();
-    init_sqlite_query_adapter();
-    init_errors();
-    SQLiteAdapter = class {
-      // ── Transactions ──────────────────────────────────────────────────────
-      async transaction(fn) {
-        const sqliteDb = getSQLiteDb();
-        sqliteDb.exec("BEGIN IMMEDIATE");
-        try {
-          const result = await fn(sqliteDb);
-          sqliteDb.exec("COMMIT");
-          return result;
-        } catch (err) {
-          try {
-            sqliteDb.exec("ROLLBACK");
-          } catch {
-          }
-          if (err instanceof ConflictError || err instanceof RetryableError || err instanceof ConcurrentModificationError) {
-            throw err;
-          }
-          translateSqliteError(err);
-        }
-      }
-      // ── Tasks ─────────────────────────────────────────────────────────────
-      getTasks(userId, filters) {
-        return getTasks(userId, filters);
-      }
-      getTask(id, userId) {
-        return getTask(id, userId);
-      }
-      getTaskBySlug(slug, userId) {
-        return getTaskBySlug(slug, userId);
-      }
-      createTask(content, userId, options) {
-        return withErrorTranslation(() => createTask(content, userId, options));
-      }
-      async updateTask(id, content, userId, options) {
-        const expectedVersion = options?.expectedVersion;
-        if (expectedVersion !== void 0) {
-          const sqliteDb2 = getSQLiteDb();
-          const result = sqliteDb2.prepare(
-            `UPDATE tasks SET version = version + 1 WHERE id = ? AND version = ?`
-          ).run(id, expectedVersion);
-          if (result.changes === 0) {
-            const row = sqliteDb2.prepare(`SELECT version FROM tasks WHERE id = ?`).get(id);
-            throw new ConcurrentModificationError(
-              "task",
-              id,
-              expectedVersion,
-              row?.version
-            );
-          }
-          const { expectedVersion: _ev, ...rest } = options ?? {};
-          return withErrorTranslation(() => updateTask(id, content, userId, rest));
-        }
-        const sqliteDb = getSQLiteDb();
-        sqliteDb.prepare(`UPDATE tasks SET version = version + 1 WHERE id = ?`).run(id);
-        return withErrorTranslation(() => updateTask(id, content, userId, options));
-      }
-      appendRunToIndex(taskId, runEntry, maxRuns) {
-        return appendRunToIndex(taskId, runEntry, maxRuns);
-      }
-      deleteTask(id, userId) {
-        return withErrorTranslation(() => deleteTask(id, userId));
-      }
-      getNextQueuedTask(engine) {
-        return getNextQueuedTask(engine);
-      }
-      ensureNoCircularDependency(taskId, dependsOn, client) {
-        return ensureNoCircularDependency(taskId, dependsOn, client);
-      }
-      // ── Projects ──────────────────────────────────────────────────────────
-      getProjects(userId) {
-        return getProjects(userId);
-      }
-      getProjectBySlug(slug, userId) {
-        return getProjectBySlug(slug, userId);
-      }
-      getProjectRepos(projectId) {
-        return getProjectRepos(projectId);
-      }
-      getProjectWithRepos(projectIdOrSlug, userId) {
-        return getProjectWithRepos(projectIdOrSlug, userId);
-      }
-      createProject(userId, input, client) {
-        return withErrorTranslation(() => createProject(userId, input, client));
-      }
-      updateProject(projectIdOrSlug, userId, updates, client) {
-        return updateProject(projectIdOrSlug, userId, updates, client);
-      }
-      deleteProject(projectId, userId, client) {
-        return withErrorTranslation(() => deleteProject(projectId, userId, client));
-      }
-      assignOrphanTasksToProject(projectId, userId, client) {
-        return assignOrphanTasksToProject(projectId, userId, client);
-      }
-      // ── Workflows ─────────────────────────────────────────────────────────
-      getWorkflows(userId) {
-        return getWorkflows(userId);
-      }
-      getWorkflow(id, userId) {
-        return getWorkflow(id, userId);
-      }
-      updateWorkflow(id, userId, updates) {
-        return updateWorkflow(id, userId, updates);
-      }
-      getWorkflowNodes(workflowId) {
-        return getWorkflowNodes(workflowId);
-      }
-      updateWorkflowNodes(workflowId, userId, updates) {
-        return updateWorkflowNodes(workflowId, userId, updates);
-      }
-      getWorkflowNodeByName(workflowId, name) {
-        return getWorkflowNodeByName(workflowId, name);
-      }
-      getWorkflowTransitions(workflowId) {
-        return getWorkflowTransitions(workflowId);
-      }
-      getWorkflowTransitionsFromNode(workflowId, fromNodeId) {
-        return getWorkflowTransitionsFromNode(workflowId, fromNodeId);
-      }
-      getWorkflowWithGraph(id, userId) {
-        return getWorkflowWithGraph(id, userId);
-      }
-      // ── Task Logs ─────────────────────────────────────────────────────────
-      getTaskLogs(taskId, options) {
-        return getTaskLogs(taskId, options);
-      }
-      addTaskLog(taskId, content, logType, nodeId) {
-        return withErrorTranslation(() => addTaskLog(taskId, content, logType, nodeId));
-      }
-      // ── Task Costs ────────────────────────────────────────────────────────
-      addTaskCostEntry(input) {
-        return withErrorTranslation(() => addTaskCostEntry(input));
-      }
-      getTaskCostEntries(taskId) {
-        return getTaskCostEntries(taskId);
-      }
-      getTaskCostSummary(taskId) {
-        return getTaskCostSummary(taskId);
-      }
-      // ── Task Comments ─────────────────────────────────────────────────────
-      getTaskComments(taskId) {
-        return getTaskComments(taskId);
-      }
-      addTaskComment(taskId, content, authorType, authorId) {
-        return withErrorTranslation(() => addTaskComment(taskId, content, authorType, authorId));
-      }
-      deleteTaskComment(commentId, userId) {
-        return withErrorTranslation(() => deleteTaskComment(commentId, userId));
-      }
-      // ── Learnings ─────────────────────────────────────────────────────────
-      getLearnings(scope, scopeId, userId) {
-        return getLearnings(scope, scopeId, userId);
-      }
-      addLearning(scope, content, scopeId, userId) {
-        return withErrorTranslation(() => addLearning(scope, content, scopeId, userId));
-      }
-      deleteLearning(id, userId) {
-        return withErrorTranslation(() => deleteLearning(id, userId));
-      }
-      // ── Stage Prompts ─────────────────────────────────────────────────────
-      getStagePrompts(userId, workflowId) {
-        return getStagePrompts(userId, workflowId);
-      }
-      getStagePrompt(stage, userId, workflowId) {
-        return getStagePrompt(stage, userId, workflowId);
-      }
-      upsertStagePrompt(stage, prompt, outputs, userId, modelConfig, workflowId) {
-        return withErrorTranslation(() => upsertStagePrompt(stage, prompt, outputs, userId, modelConfig, workflowId));
-      }
-      deleteStagePrompt(id, userId) {
-        return deleteStagePrompt(id, userId);
-      }
-      // ── Agents ────────────────────────────────────────────────────────────
-      getAgents(userId) {
-        return getAgents(userId);
-      }
-      getAgent(id, userId) {
-        return getAgent(id, userId);
-      }
-      createAgent(userId, input) {
-        return withErrorTranslation(() => createAgent(userId, input));
-      }
-      updateAgent(id, userId, input) {
-        return updateAgent(id, userId, input);
-      }
-      deleteAgent(id, userId) {
-        return deleteAgent(id, userId);
-      }
-      // ── User Settings ─────────────────────────────────────────────────────
-      getUserSettings(userId) {
-        return getUserSettings(userId);
-      }
-      upsertUserSettings(userId, input, options) {
-        return withErrorTranslation(() => upsertUserSettings(userId, input, options));
-      }
-      // ── Health ───────────────────────────────────────────────────────────
-      async healthCheck() {
-        const start = performance.now();
-        try {
-          const sqliteDb = getSQLiteDb();
-          sqliteDb.prepare("SELECT 1").get();
-          return { adapter: "sqlite", connected: true, latencyMs: Math.round(performance.now() - start) };
-        } catch {
-          return { adapter: "sqlite", connected: false, latencyMs: Math.round(performance.now() - start) };
-        }
-      }
-    };
-  }
-});
-
-// ../agx-cloud/lib/queue/sqlite-adapter.ts
-var import_better_sqlite3 = __toESM(require_lib());
-
-// ../agx-cloud/node_modules/uuid/dist-node/stringify.js
-var byteToHex = [];
-for (let i = 0; i < 256; ++i) {
-  byteToHex.push((i + 256).toString(16).slice(1));
-}
-function unsafeStringify(arr, offset = 0) {
-  return (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + "-" + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + "-" + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + "-" + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + "-" + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase();
-}
-
-// ../agx-cloud/node_modules/uuid/dist-node/rng.js
-var import_node_crypto = require("node:crypto");
-var rnds8Pool = new Uint8Array(256);
-var poolPtr = rnds8Pool.length;
-function rng() {
-  if (poolPtr > rnds8Pool.length - 16) {
-    (0, import_node_crypto.randomFillSync)(rnds8Pool);
-    poolPtr = 0;
-  }
-  return rnds8Pool.slice(poolPtr, poolPtr += 16);
-}
-
-// ../agx-cloud/node_modules/uuid/dist-node/native.js
-var import_node_crypto2 = require("node:crypto");
-var native_default = { randomUUID: import_node_crypto2.randomUUID };
-
-// ../agx-cloud/node_modules/uuid/dist-node/v4.js
-function _v4(options, buf, offset) {
-  options = options || {};
-  const rnds = options.random ?? options.rng?.() ?? rng();
-  if (rnds.length < 16) {
-    throw new Error("Random bytes length must be >= 16");
-  }
-  rnds[6] = rnds[6] & 15 | 64;
-  rnds[8] = rnds[8] & 63 | 128;
-  if (buf) {
-    offset = offset || 0;
-    if (offset < 0 || offset + 16 > buf.length) {
-      throw new RangeError(`UUID byte range ${offset}:${offset + 15} is out of buffer bounds`);
-    }
-    for (let i = 0; i < 16; ++i) {
-      buf[offset + i] = rnds[i];
-    }
-    return buf;
-  }
-  return unsafeStringify(rnds);
-}
-function v4(options, buf, offset) {
-  if (native_default.randomUUID && !buf && !options) {
-    return native_default.randomUUID();
-  }
-  return _v4(options, buf, offset);
-}
-var v4_default = v4;
-
-// ../agx-cloud/lib/queue/sqlite-adapter.ts
-var import_path2 = __toESM(require("path"));
-var import_fs2 = __toESM(require("fs"));
-var import_os2 = __toESM(require("os"));
-init_startup();
-
-// ../agx-cloud/lib/limits.ts
-var MAX_WORKERS = Number(process.env.AGX_MAX_WORKERS) || 10;
-var WRITE_QPS_WARNING_THRESHOLD = 40;
-var WRITE_QPS_CEILING = 50;
-var WRITE_RATE_SAMPLE_WINDOW_MS = 1e4;
-function assertWorkerCount(requested) {
-  if (requested > MAX_WORKERS) {
-    throw new Error(
-      `[limits] Requested ${requested} workers exceeds MAX_WORKERS (${MAX_WORKERS}). See docs/LIMITS.md \u2014 exceeding this limit risks SQLITE_BUSY errors. Set AGX_MAX_WORKERS to override (requires architecture review).`
-    );
-  }
-  if (requested < 1) {
-    throw new Error(`[limits] Worker count must be at least 1, got ${requested}.`);
-  }
-}
-var WriteRateMonitor = class {
-  timestamps = [];
-  lastWarning = 0;
-  WARNING_COOLDOWN_MS = 6e4;
-  record() {
-    this.timestamps.push(Date.now());
-  }
-  check() {
-    const now = Date.now();
-    const cutoff = now - WRITE_RATE_SAMPLE_WINDOW_MS;
-    this.timestamps = this.timestamps.filter((t) => t >= cutoff);
-    const qps = this.timestamps.length / (WRITE_RATE_SAMPLE_WINDOW_MS / 1e3);
-    const warning = qps >= WRITE_QPS_WARNING_THRESHOLD;
-    if (warning && now - this.lastWarning > this.WARNING_COOLDOWN_MS) {
-      this.lastWarning = now;
-      console.warn(
-        `[limits] Write QPS at ${qps.toFixed(1)} \u2014 approaching ceiling of ${WRITE_QPS_CEILING}. See docs/LIMITS.md for mitigation steps.`
-      );
-    }
-    return { qps, warning };
-  }
-};
-
-// ../agx-cloud/lib/queue/sqlite-adapter.ts
-var AGX_DATA_DIR = process.env.AGX_DATA_DIR || import_path2.default.join(import_os2.default.homedir(), ".agx");
-var SQLiteQueueAdapter = class {
-  constructor(dbPath) {
-    this.workers = /* @__PURE__ */ new Map();
-    this.pollingInterval = null;
-    this.writeRateInterval = null;
-    this.writeMonitor = new WriteRateMonitor();
-    this.workerId = v4_default();
-    const finalPath = dbPath || process.env.SQLITE_QUEUE_PATH || import_path2.default.join(AGX_DATA_DIR, "agx-queue.db");
-    const dir = import_path2.default.dirname(finalPath);
-    if (!import_fs2.default.existsSync(dir)) {
-      import_fs2.default.mkdirSync(dir, { recursive: true });
-    }
-    this.db = new import_better_sqlite3.default(finalPath);
-    const errors = validateSQLiteEnvironment(this.db, finalPath);
-    if (errors.length > 0) {
-      const msgs = errors.map((e) => e.message).join("; ");
-      console.error(`[SQLiteQueueAdapter] Startup validation failed: ${msgs}`);
-    }
-  }
-  async start() {
-    this.initSchema();
-    this.startPolling();
-  }
-  async stop() {
-    this.stopPolling();
-    this.db.close();
-  }
-  initSchema() {
-    this.db.exec(`
-      CREATE TABLE IF NOT EXISTS agx_jobs (
-        id TEXT PRIMARY KEY,
-        queue TEXT NOT NULL,
-        data TEXT NOT NULL,
-        status TEXT NOT NULL CHECK(status IN ('pending', 'active', 'completed', 'failed', 'retry')),
-        created_at INTEGER NOT NULL,
-        start_after INTEGER NOT NULL DEFAULT 0,
-        started_at INTEGER,
-        completed_at INTEGER,
-        failed_at INTEGER,
-        worker_id TEXT,
-        retry_count INTEGER DEFAULT 0,
-        retry_limit INTEGER DEFAULT 0,
-        priority INTEGER DEFAULT 0,
-        error TEXT
-      );
-      CREATE INDEX IF NOT EXISTS idx_jobs_fetch ON agx_jobs (queue, status, start_after, priority DESC, created_at ASC);
-    `);
-    const cols = this.db.pragma("table_info(agx_jobs)");
-    const colNames = new Set(cols.map((c) => c.name));
-    if (!colNames.has("failed_at")) {
-      this.db.exec(`ALTER TABLE agx_jobs ADD COLUMN failed_at INTEGER`);
-    }
-    if (!colNames.has("error")) {
-      this.db.exec(`ALTER TABLE agx_jobs ADD COLUMN error TEXT`);
-    }
-  }
-  async send(queue2, data, options) {
-    const id = v4_default();
-    const now = Date.now();
-    const startAfter = options?.startAfter ? options.startAfter instanceof Date ? options.startAfter.getTime() : options.startAfter : now;
-    const stmt = this.db.prepare(`
-      INSERT INTO agx_jobs (
-        id, queue, data, status, created_at, start_after, retry_limit, priority
-      ) VALUES (?, ?, ?, 'pending', ?, ?, ?, ?)
-    `);
-    stmt.run(
-      id,
-      queue2,
-      JSON.stringify(data),
-      now,
-      startAfter,
-      options?.retryLimit ?? 3,
-      options?.priority ?? 0
-    );
-    this.writeMonitor.record();
-    return id;
-  }
-  async work(queue2, handler, options) {
-    this.workers.set(queue2, {
-      handler,
-      options: options || {},
-      running: true
-    });
-  }
-  startPolling() {
-    if (this.pollingInterval) return;
-    this.pollingInterval = setInterval(() => this.poll(), 1e3);
-    this.writeRateInterval = setInterval(() => this.writeMonitor.check(), WRITE_RATE_SAMPLE_WINDOW_MS);
-  }
-  stopPolling() {
-    if (this.pollingInterval) {
-      clearInterval(this.pollingInterval);
-      this.pollingInterval = null;
-    }
-    if (this.writeRateInterval) {
-      clearInterval(this.writeRateInterval);
-      this.writeRateInterval = null;
-    }
-  }
-  poll() {
-    for (const [queue2, worker] of this.workers) {
-      if (!worker.running) continue;
-      this.processQueue(queue2, worker);
-    }
-  }
-  processQueue(queue2, worker) {
-    const batchSize = worker.options.batchSize || 1;
-    const now = Date.now();
-    const jobs = this.db.transaction(() => {
-      const candidates = this.db.prepare(`
-        SELECT id, data FROM agx_jobs
-        WHERE queue = ?
-          AND (status = 'pending' OR status = 'retry')
-          AND start_after <= ?
-        ORDER BY priority DESC, created_at ASC
-        LIMIT ?
-      `).all(queue2, now, batchSize);
-      if (candidates.length === 0) return [];
-      const ids = candidates.map((c) => c.id);
-      const markActive = this.db.prepare(`
-        UPDATE agx_jobs
-        SET status = 'active', started_at = ?, worker_id = ?
-        WHERE id = ?
-      `);
-      for (const id of ids) {
-        markActive.run(now, this.workerId, id);
-      }
-      return candidates.map((c) => ({
-        id: c.id,
-        name: queue2,
-        data: JSON.parse(c.data)
-      }));
-    })();
-    if (jobs.length > 0) {
-      this.executeJobs(jobs, worker.handler);
-    }
-  }
-  async executeJobs(jobs, handler) {
-    try {
-      await handler(jobs);
-      this.completeJobs(jobs.map((j) => j.id));
-    } catch (err) {
-      this.failJobs(jobs.map((j) => j.id), err.message || String(err));
-    }
-  }
-  completeJobs(ids) {
-    const now = Date.now();
-    const stmt = this.db.prepare(`
-      UPDATE agx_jobs
-      SET status = 'completed', completed_at = ?
-      WHERE id = ?
-    `);
-    this.db.transaction(() => {
-      for (const id of ids) stmt.run(now, id);
-    })();
-  }
-  failJobs(ids, error) {
-    const now = Date.now();
-    const stmt = this.db.prepare(`
-      SELECT id, retry_count, retry_limit FROM agx_jobs WHERE id = ?
-    `);
-    const updateRetry = this.db.prepare(`
-      UPDATE agx_jobs
-      SET status = 'retry', retry_count = retry_count + 1, 
-          start_after = ? + (retry_count * 1000 * 2), -- Exponential backoff (kinda)
-          error = ?
-      WHERE id = ?
-    `);
-    const updateFailed = this.db.prepare(`
-      UPDATE agx_jobs
-      SET status = 'failed', failed_at = ?, error = ?
-      WHERE id = ?
-    `);
-    this.db.transaction(() => {
-      for (const id of ids) {
-        const job = stmt.get(id);
-        if (job && job.retry_count < job.retry_limit) {
-          const backoff = (job.retry_count + 1) * 2e3;
-          updateRetry.run(now + backoff, error, id);
-        } else {
-          updateFailed.run(now, error, id);
-        }
-      }
-    })();
-  }
-};
-
-// ../agx-cloud/lib/queue/boss.ts
-var queue = null;
-var QUEUE_NAMES = {
-  TASK_PROCESS: "agx.task.process",
-  TASK_CLEANUP: "agx.task.cleanup"
-};
-async function getQueue() {
-  if (queue) return queue;
-  queue = new SQLiteQueueAdapter();
-  await queue.start();
-  return queue;
-}
-async function stopQueue() {
-  if (queue) {
-    await queue.stop();
-    queue = null;
-  }
-}
-
-// ../agx-cloud/lib/db-instance.ts
-function createAdapter() {
-  const { SQLiteAdapter: SQLiteAdapter2 } = (init_sqlite_adapter(), __toCommonJS(sqlite_adapter_exports));
-  return new SQLiteAdapter2();
-}
-var db = createAdapter();
-
-// ../agx-cloud/lib/orchestration/stage-machine.ts
-init_db();
-var DEFAULT_STAGE_SEQUENCE = [
-  "INTAKE",
-  "PROGRESS",
-  "DONE"
-];
-var STANDARD_STAGE_SEQUENCES = [DEFAULT_STAGE_SEQUENCE];
-function normalizeTicketType(value) {
-  if (typeof value !== "string") return "task";
-  const normalized = value.trim().toLowerCase();
-  if (normalized === "spike" || normalized === "spikes") return "spike";
-  return "task";
-}
-function getTicketType(frontmatter, markdownBody) {
-  const typeKeys = ["ticket_type", "type", "issue_type", "kind"];
-  for (const key of typeKeys) {
-    if (normalizeTicketType(frontmatter[key]) === "spike") return "spike";
-  }
-  const titleMatch = markdownBody.match(/^#\s+(.+)$/m);
-  const title = titleMatch?.[1]?.trim().toLowerCase() || "";
-  if (title.startsWith("spike:") || title.startsWith("[spike]")) {
-    return "spike";
-  }
-  return "task";
-}
-function getNextStage(currentStage, ticketType) {
-  if (ticketType === "spike") {
-    if (currentStage === "INTAKE") return "PROGRESS";
-    if (currentStage === "DONE") return null;
-    return "DONE";
-  }
-  for (const sequence of STANDARD_STAGE_SEQUENCES) {
-    const index = sequence.indexOf(currentStage);
-    if (index === -1) continue;
-    if (index >= sequence.length - 1) return null;
-    return sequence[index + 1];
-  }
-  return null;
-}
-function resolveStageTransition({
-  currentStage,
-  decision,
-  ticketType,
-  retryCount,
-  maxRetries = 3
-}) {
-  const nextStage = getNextStage(currentStage, ticketType);
-  if (decision === "done") {
-    if (nextStage) {
-      return {
-        nextStage,
-        nextStatus: "queued",
-        retryCount: 0,
-        error: null,
-        appendLog: { content: `Stage completed: ${currentStage}`, logType: "checkpoint" }
-      };
-    }
-    return {
-      nextStage: "DONE",
-      nextStatus: "completed",
-      retryCount: 0,
-      error: null,
-      appendLog: { content: `Task completed at stage ${currentStage}.`, logType: "checkpoint" }
-    };
-  }
-  if (decision === "blocked") {
-    return {
-      nextStage: currentStage,
-      nextStatus: "blocked",
-      retryCount,
-      error: null,
-      appendLog: { content: "Blocked: additional input required.", logType: "system" }
-    };
-  }
-  if (currentStage === "PROGRESS") {
-    return {
-      nextStage: "PROGRESS",
-      nextStatus: "queued",
-      retryCount: 0,
-      error: null,
-      appendLog: {
-        content: "Stage not done. Retrying in PROGRESS.",
-        logType: "system"
-      }
-    };
-  }
-  const nextRetryCount = retryCount + 1;
-  if (nextRetryCount <= maxRetries) {
-    return {
-      nextStage: currentStage,
-      nextStatus: "queued",
-      retryCount: nextRetryCount,
-      error: null,
-      appendLog: {
-        content: `Retrying (${nextRetryCount}/${maxRetries}) for stage ${currentStage}.`,
-        logType: "system"
-      }
-    };
-  }
-  return {
-    nextStage: currentStage,
-    nextStatus: "failed",
-    retryCount: nextRetryCount,
-    error: "Task failed.",
-    appendLog: { content: "Task failed.", logType: "error" }
-  };
-}
-function decisionToCondition(decision) {
-  switch (decision) {
-    case "done":
-      return "done";
-    case "blocked":
-      return "blocked";
-    case "failed":
-    case "not_done":
-      return "failed";
-    default:
-      return "done";
-  }
-}
-async function resolveWorkflowTransition({
-  workflowId,
-  currentNodeName,
-  decision,
-  retryCount,
-  maxRetries = 3
-}) {
-  if (String(currentNodeName).trim().toLowerCase() === "done") {
-    return {
-      nextNodeName: "done",
-      nextStatus: "completed",
-      retryCount: 0,
-      error: null,
-      appendLog: { content: "Task completed at done", logType: "checkpoint" },
-      nodeConfig: null
-    };
-  }
-  const currentNode = await getWorkflowNodeByName(workflowId, currentNodeName);
-  if (!currentNode) {
-    return {
-      nextNodeName: currentNodeName,
-      nextStatus: "blocked",
-      retryCount,
-      error: `Node '${currentNodeName}' not found in workflow`,
-      appendLog: { content: `Workflow error: node '${currentNodeName}' not found`, logType: "error" },
-      nodeConfig: null
-    };
-  }
-  if (currentNode.node_type === "terminal") {
-    return {
-      nextNodeName: currentNodeName,
-      nextStatus: "completed",
-      retryCount: 0,
-      error: null,
-      appendLog: { content: `Task completed at ${currentNode.label || currentNodeName}`, logType: "checkpoint" },
-      nodeConfig: currentNode
-    };
-  }
-  if (decision === "blocked") {
-    return {
-      nextNodeName: currentNodeName,
-      nextStatus: "blocked",
-      retryCount,
-      error: null,
-      appendLog: { content: "Blocked: additional input required.", logType: "system" },
-      nodeConfig: currentNode
-    };
-  }
-  const transitions = await getWorkflowTransitionsFromNode(workflowId, currentNode.id);
-  const condition = decisionToCondition(decision);
-  const matchingTransition = transitions.find((t) => t.condition === condition);
-  if (matchingTransition) {
-    const allNodes = await getWorkflowNodes(workflowId);
-    const targetNode = allNodes.find((n) => n.id === matchingTransition.to_node_id);
-    if (targetNode) {
-      const isCompleting = targetNode.node_type === "terminal";
-      return {
-        nextNodeName: targetNode.name,
-        nextStatus: isCompleting ? "completed" : "queued",
-        retryCount: 0,
-        error: null,
-        appendLog: {
-          content: decision === "done" ? `Stage completed: ${currentNode.label || currentNodeName}` : `Transition to ${targetNode.label || targetNode.name}`,
-          logType: decision === "done" ? "checkpoint" : "system"
-        },
-        nodeConfig: targetNode
-      };
-    }
-  }
-  if (decision === "done") {
-    return {
-      nextNodeName: currentNodeName,
-      nextStatus: "completed",
-      retryCount: 0,
-      error: null,
-      appendLog: { content: `Task completed at ${currentNode.label || currentNodeName}`, logType: "checkpoint" },
-      nodeConfig: currentNode
-    };
-  }
-  const nextRetryCount = retryCount + 1;
-  if (nextRetryCount <= maxRetries) {
-    return {
-      nextNodeName: currentNodeName,
-      nextStatus: "queued",
-      retryCount: nextRetryCount,
-      error: null,
-      appendLog: {
-        content: `Retrying (${nextRetryCount}/${maxRetries}) for ${currentNode.label || currentNodeName}`,
-        logType: "system"
-      },
-      nodeConfig: currentNode
-    };
-  }
-  return {
-    nextNodeName: currentNodeName,
-    nextStatus: "failed",
-    retryCount: nextRetryCount,
-    error: "Task failed after max retries.",
-    appendLog: { content: "Task failed after max retries.", logType: "error" },
-    nodeConfig: currentNode
-  };
-}
-
-// ../agx-cloud/lib/orchestrator/activities.ts
-init_db();
-
-// ../agx-cloud/lib/memory-extractor.ts
-var import_crypto2 = require("crypto");
-
-// ../agx-cloud/lib/cli-runner.ts
-var import_child_process = require("child_process");
-
-// ../agx-cloud/lib/sanitize.ts
-function createCliChunkSanitizer() {
-  let endedWithNewline = false;
-  let hasEmittedContent = false;
-  let lastNonWhitespaceChar = "";
-  const markdownBlockStartPattern = /^(?:```|~~~|#{1,6}\s|>\s|[-*+]\s|\d+\.\s)/;
-  return (value) => {
-    const normalized = value.replace(/\u001B\[[0-9;]*[A-Za-z]/g, "").replace(/\r\n/g, "\n").replace(/\r/g, "\n").replace(/[ \t]+\n/g, "\n").replace(/\n{3,}/g, "\n\n");
-    if (!normalized.trim()) {
-      if (normalized.includes("\n") && !endedWithNewline) {
-        endedWithNewline = true;
-        return "\n";
-      }
-      return "";
-    }
-    const dedupedLeadingNewlines = endedWithNewline ? normalized.replace(/^\n+/, "\n") : normalized;
-    const trimmedStart = dedupedLeadingNewlines.trimStart();
-    const startsMarkdownBlock = markdownBlockStartPattern.test(trimmedStart);
-    const needsBlockSeparator = hasEmittedContent && startsMarkdownBlock && !endedWithNewline;
-    const needsSentenceSpacing = hasEmittedContent && !endedWithNewline && !needsBlockSeparator && !/^\s/.test(dedupedLeadingNewlines) && /[.!?)]/.test(lastNonWhitespaceChar) && /^[A-Z0-9`(]/.test(dedupedLeadingNewlines);
-    const output = needsBlockSeparator ? `
-
-${dedupedLeadingNewlines}` : needsSentenceSpacing ? `
-${dedupedLeadingNewlines}` : dedupedLeadingNewlines;
-    endedWithNewline = output.endsWith("\n");
-    hasEmittedContent = hasEmittedContent || output.trim().length > 0;
-    const trailing = output.replace(/\s+$/g, "");
-    if (trailing.length > 0) {
-      lastNonWhitespaceChar = trailing[trailing.length - 1] ?? lastNonWhitespaceChar;
-    }
-    return output;
-  };
-}
-
-// ../agx-cloud/lib/cli-runner.ts
-var isNonEmptyString = (value) => typeof value === "string" && value.trim().length > 0;
-var commandExists = (bin) => {
-  try {
-    if (process.platform === "win32") {
-      return (0, import_child_process.spawnSync)("where", [bin], { encoding: "utf8" }).status === 0;
-    }
-    return (0, import_child_process.spawnSync)("bash", ["-lc", `command -v ${bin} >/dev/null 2>&1`], {
-      encoding: "utf8"
-    }).status === 0;
-  } catch {
-    return false;
-  }
-};
-var createRawParser = (onDelta) => ({
-  push: onDelta,
-  flush: () => {
-  }
-});
-var extractClaudeAssistantText = (record) => {
-  if (!record || typeof record !== "object") return "";
-  if (record.type === "assistant") {
-    const content = Array.isArray(record?.message?.content) ? record.message.content : [];
-    return content.flatMap(
-      (part) => part?.type === "text" && isNonEmptyString(part.text) ? [part.text] : []
-    ).join("");
-  }
-  const event = record?.event;
-  if (record.type === "stream_event" && event?.type === "content_block_delta" && event?.delta?.type === "text_delta" && isNonEmptyString(event?.delta?.text)) {
-    return event.delta.text;
-  }
-  return "";
-};
-var createClaudeStreamJsonParser = (onDelta) => {
-  let buffer = "";
-  let emittedCharacters = 0;
-  let sawJson = false;
-  const processLine = (line) => {
-    const trimmed = line.trim();
-    if (!trimmed) return;
-    try {
-      const parsed = JSON.parse(trimmed);
-      sawJson = true;
-      const delta = extractClaudeAssistantText(parsed);
-      if (!delta) return;
-      if (parsed?.type === "assistant" && emittedCharacters > 0) return;
-      emittedCharacters += delta.length;
-      onDelta(delta);
-    } catch {
-      if (!sawJson) onDelta(`${line}
-`);
-    }
-  };
-  return {
-    push: (chunk) => {
-      buffer += chunk;
-      while (true) {
-        const i = buffer.indexOf("\n");
-        if (i === -1) break;
-        processLine(buffer.slice(0, i));
-        buffer = buffer.slice(i + 1);
-      }
-    },
-    flush: () => {
-      if (buffer.trim()) processLine(buffer);
-      buffer = "";
-    }
-  };
-};
-var createGeminiStreamJsonParser = (onDelta) => {
-  let buffer = "";
-  let sawJson = false;
-  let accumulatedAssistantText = "";
-  const emitGeminiText = (text, isDelta) => {
-    if (!text) return;
-    if (isDelta) {
-      if (accumulatedAssistantText && text.startsWith(accumulatedAssistantText)) {
-        const suffix = text.slice(accumulatedAssistantText.length);
-        if (suffix) onDelta(suffix);
-        accumulatedAssistantText = text;
-        return;
-      }
-      onDelta(text);
-      accumulatedAssistantText += text;
-      return;
-    }
-    if (accumulatedAssistantText && text.startsWith(accumulatedAssistantText)) {
-      const suffix = text.slice(accumulatedAssistantText.length);
-      if (suffix) onDelta(suffix);
-      accumulatedAssistantText = text;
-      return;
-    }
-    if (!accumulatedAssistantText) {
-      onDelta(text);
-      accumulatedAssistantText = text;
-    }
-  };
-  const processLine = (line) => {
-    const trimmed = line.trim();
-    if (!trimmed) return;
-    try {
-      const parsed = JSON.parse(trimmed);
-      sawJson = true;
-      if (parsed?.type === "message" && parsed?.role === "assistant" && isNonEmptyString(parsed?.content)) {
-        emitGeminiText(parsed.content, parsed?.delta === true);
-      }
-    } catch {
-      if (!sawJson) onDelta(`${line}
-`);
-    }
-  };
-  return {
-    push: (chunk) => {
-      buffer += chunk;
-      while (true) {
-        const i = buffer.indexOf("\n");
-        if (i === -1) break;
-        processLine(buffer.slice(0, i));
-        buffer = buffer.slice(i + 1);
-      }
-    },
-    flush: () => {
-      if (buffer.trim()) processLine(buffer);
-      buffer = "";
-    }
-  };
-};
-var extractCodexAssistantText = (record) => {
-  if (!record || typeof record !== "object") return "";
-  if (record.type === "item.completed" && record.item?.type === "agent_message" && isNonEmptyString(record.item?.text)) {
-    return record.item.text;
-  }
-  if (record.type === "item.delta" && record.item?.type === "agent_message" && isNonEmptyString(record.delta?.text)) {
-    return record.delta.text;
-  }
-  return "";
-};
-var createCodexJsonParser = (onDelta) => {
-  let buffer = "";
-  let sawJson = false;
-  const completedItems = /* @__PURE__ */ new Set();
-  const processLine = (line) => {
-    const trimmed = line.trim();
-    if (!trimmed) return;
-    try {
-      const parsed = JSON.parse(trimmed);
-      sawJson = true;
-      if (parsed?.type === "item.completed" && isNonEmptyString(parsed?.item?.id)) {
-        if (completedItems.has(parsed.item.id)) return;
-        completedItems.add(parsed.item.id);
-      }
-      const delta = extractCodexAssistantText(parsed);
-      if (delta) onDelta(delta);
-    } catch {
-      if (!sawJson) onDelta(`${line}
-`);
-    }
-  };
-  return {
-    push: (chunk) => {
-      buffer += chunk;
-      while (true) {
-        const i = buffer.indexOf("\n");
-        if (i === -1) break;
-        processLine(buffer.slice(0, i));
-        buffer = buffer.slice(i + 1);
-      }
-    },
-    flush: () => {
-      if (buffer.trim()) processLine(buffer);
-      buffer = "";
-    }
-  };
-};
-var createThoughtFilterParser = (inner) => {
-  let buffer = "";
-  let inThought = false;
-  let thoughtStarted = false;
-  const THINK_START_PATTERNS = [
-    /^Thinking\.\.\./,
-    /^<think>/i
-  ];
-  const THINK_END_PATTERNS = [
-    /\.\.\.done thinking\.?\s*/,
-    /<\/think>/i
-  ];
-  const processBuffer = () => {
-    while (buffer.length > 0) {
-      if (inThought) {
-        let endIdx = -1;
-        let endLen = 0;
-        for (const pat of THINK_END_PATTERNS) {
-          const match = buffer.match(pat);
-          if (match && match.index !== void 0) {
-            const candidate = match.index + match[0].length;
-            if (endIdx === -1 || match.index < endIdx) {
-              endIdx = match.index;
-              endLen = match[0].length;
-            }
-          }
-        }
-        if (endIdx !== -1) {
-          buffer = buffer.slice(endIdx + endLen);
-          inThought = false;
-          buffer = buffer.replace(/^\s*\n*/, "");
-          continue;
-        }
-        return;
-      }
-      for (const pat of THINK_START_PATTERNS) {
-        const match = buffer.match(pat);
-        if (match && match.index !== void 0) {
-          const before = buffer.slice(0, match.index);
-          if (before) inner.push(before);
-          buffer = buffer.slice(match.index + match[0].length);
-          inThought = true;
-          thoughtStarted = true;
-          break;
-        }
-      }
-      if (inThought) continue;
-      const safeLen = Math.max(0, buffer.length - 30);
-      if (safeLen > 0) {
-        inner.push(buffer.slice(0, safeLen));
-        buffer = buffer.slice(safeLen);
-      }
-      return;
-    }
-  };
-  return {
-    push: (chunk) => {
-      buffer += chunk;
-      processBuffer();
-    },
-    flush: () => {
-      if (!inThought && buffer) {
-        inner.push(buffer);
-      }
-      buffer = "";
-      inner.flush();
-    }
-  };
-};
-function agxCommandForProvider({
-  provider,
-  model,
-  prompt
-}) {
-  const args = [provider, "-y", "--print", "--prompt", prompt];
-  if (model) args.push("--model", model);
-  return { command: "agx", args, parser: "raw" };
-}
-async function runCommandStreamed({
-  command,
-  args,
-  timeoutMs,
-  signal,
-  onDelta,
-  onLog,
-  onSpawn
-}) {
-  await new Promise((resolve, reject) => {
-    if (onLog) onLog("stderr", `$ ${command} ${args.map((a) => a.length > 80 ? a.slice(0, 80) + "\u2026" : a).join(" ")}
-`);
-    const child = (0, import_child_process.spawn)(command, args, {
-      stdio: ["ignore", "pipe", "pipe"],
-      env: { ...process.env, CLAUDECODE: void 0 }
-    });
-    let done = false;
-    let combinedOutput = "";
-    let timedOut = false;
-    const finalize = (error) => {
-      if (done) return;
-      done = true;
-      clearTimeout(timer);
-      if (signal) signal.removeEventListener("abort", onAbort);
-      if (error) reject(error);
-      else resolve();
-    };
-    const onAbort = () => {
-      child.kill("SIGTERM");
-      finalize(new Error("Chat request aborted."));
-    };
-    if (signal) signal.addEventListener("abort", onAbort, { once: true });
-    if (onSpawn && child.pid) onSpawn(child.pid);
-    const timer = setTimeout(() => {
-      timedOut = true;
-      child.kill("SIGKILL");
-      finalize(new Error(`CLI request timed out after ${timeoutMs}ms.`));
-    }, timeoutMs);
-    child.stdout.on("data", (data) => {
-      const chunk = data.toString();
-      combinedOutput += chunk;
-      onDelta(chunk);
-      if (onLog) onLog("stdout", chunk);
-    });
-    child.stderr.on("data", (data) => {
-      const str = data.toString();
-      combinedOutput += str;
-      if (onLog) onLog("stderr", str);
-    });
-    child.on("error", (error) => finalize(error));
-    child.on("close", (code, childSignal) => {
-      if (done || timedOut) return;
-      if (code === 0) {
-        finalize();
-        return;
-      }
-      finalize(
-        new Error(
-          `CLI command failed (exit=${code ?? "unknown"} signal=${childSignal ?? "none"}).${combinedOutput.trim() ? ` ${combinedOutput.trim()}` : ""}`
-        )
-      );
-    });
-  });
-}
-async function runCliResponse({
-  provider,
-  model,
-  prompt,
-  identity,
-  self,
-  skills,
-  systemContext,
-  signal,
-  onDelta,
-  onLog,
-  onSpawn
-}) {
-  const timeoutMs = 6e5;
-  const sanitize = createCliChunkSanitizer();
-  const wrappedOnDelta = (chunk) => {
-    const cleaned = sanitize(chunk);
-    if (cleaned) onDelta(cleaned);
-  };
-  const attempts = [];
-  const systemParts = [];
-  if (systemContext) systemParts.push(systemContext);
-  if (identity) systemParts.push(`<identity>
-${identity}
-</identity>`);
-  if (self) systemParts.push(`<self>
-${self}
-</self>`);
-  if (skills) systemParts.push(`<skills>
-${skills}
-</skills>`);
-  const systemPrompt = systemParts.length > 0 ? systemParts.join("\n\n") : void 0;
-  if (commandExists("agx")) {
-    const agxPrompt = systemPrompt ? `${systemPrompt}
-
-${prompt}` : prompt;
-    attempts.push(agxCommandForProvider({ provider, model, prompt: agxPrompt }));
-  }
-  if (attempts.length === 0) {
-    throw new Error(
-      `No CLI runner available for provider "${provider}". Install agx or provider CLI.`
-    );
-  }
-  let lastError = null;
-  for (const attempt of attempts) {
-    const baseParser = attempt.parser === "claude-stream-json" ? createClaudeStreamJsonParser(wrappedOnDelta) : attempt.parser === "codex-json" ? createCodexJsonParser(wrappedOnDelta) : attempt.parser === "gemini-stream-json" ? createGeminiStreamJsonParser(wrappedOnDelta) : createRawParser(wrappedOnDelta);
-    const parser = attempt.filterThoughts ? createThoughtFilterParser(baseParser) : baseParser;
-    try {
-      await runCommandStreamed({
-        command: attempt.command,
-        args: attempt.args,
-        timeoutMs,
-        signal,
-        onDelta: parser.push,
-        onLog,
-        onSpawn
-      });
-      parser.flush();
-      return;
-    } catch (error) {
-      lastError = error instanceof Error ? error : new Error(String(error));
-    }
-  }
-  throw lastError || new Error("CLI execution failed.");
-}
-
-// ../agx-cloud/lib/memory-extractor.ts
-init_sqlite_query_adapter();
-var VALID_TYPES = /* @__PURE__ */ new Set(["outcome", "decision", "pattern", "gotcha"]);
-var EXTRACTION_PROMPT = `You are a memory extractor for a task execution system.
-Given a completed task, extract 0-3 memories worth remembering for future tasks.
-
-Each memory must be:
-{ "memory_type": "outcome" | "decision" | "pattern" | "gotcha", "content": "one concise sentence" }
-
-- outcome: what happened (success/failure result)
-- decision: a choice that was made and why
-- pattern: a reusable approach or technique discovered
-- gotcha: a surprising pitfall or edge case encountered
-
-Return ONLY a JSON array. Return [] if nothing worth remembering.
-Do not wrap in markdown code blocks. Just raw JSON.`;
-async function extractMemories(ctx) {
-  const taskDescription = [
-    `Goal: ${ctx.goal}`,
-    `Status: ${ctx.status}`,
-    ctx.nodeOutputs ? `Node outputs: ${JSON.stringify(ctx.nodeOutputs).slice(0, 2e3)}` : null
-  ].filter(Boolean).join("\n");
-  const prompt = `${EXTRACTION_PROMPT}
-
-Task:
-${taskDescription}`;
-  let raw = "";
-  try {
-    await runCliResponse({
-      provider: "claude",
-      model: "claude-haiku-4-5-20251001",
-      prompt,
-      onDelta: (chunk) => {
-        raw += chunk;
-      }
-    });
-  } catch (err) {
-    console.warn("[memory-extractor] LLM call failed:", err);
-    return [];
-  }
-  return parseMemoryResponse(raw);
-}
-function parseMemoryResponse(raw) {
-  const trimmed = raw.trim();
-  const cleaned = trimmed.replace(/^```(?:json)?\s*/i, "").replace(/\s*```\s*$/, "").trim();
-  try {
-    const parsed = JSON.parse(cleaned);
-    if (!Array.isArray(parsed)) return [];
-    return parsed.filter(
-      (m) => typeof m === "object" && m !== null && VALID_TYPES.has(m.memory_type) && typeof m.content === "string" && m.content.trim().length > 0
-    ).slice(0, 3);
-  } catch {
-    console.warn("[memory-extractor] Failed to parse LLM response:", cleaned.slice(0, 200));
-    return [];
-  }
-}
-var VALID_TYPES_SET = /* @__PURE__ */ new Set(["outcome", "decision", "pattern", "gotcha"]);
-var MEMORY_AGENT_KEYS = [
-  "agent_id",
-  "agentId",
-  "agent",
-  "participant_id",
-  "participantId",
-  "assigned_agent",
-  "assignedAgent"
-];
-function asNonEmptyString(value) {
-  if (typeof value !== "string") return null;
-  const trimmed = value.trim();
-  return trimmed ? trimmed : null;
-}
-function resolveMemoryAgentId(input) {
-  const explicit = asNonEmptyString(input.explicitAgentId);
-  if (explicit) return explicit;
-  const frontmatter = input.frontmatter || {};
-  for (const key of MEMORY_AGENT_KEYS) {
-    const resolved = asNonEmptyString(frontmatter[key]);
-    if (resolved) return resolved;
-  }
-  return asNonEmptyString(input.defaultUserId) || "system";
-}
-async function storeMemories(taskId, agentId, memories) {
-  const db2 = getSQLiteDb();
-  const stmt = db2.prepare(
-    `INSERT OR IGNORE INTO agent_memory (id, agent_id, task_id, memory_type, content, content_hash, created_at)
-     VALUES (?, ?, ?, ?, ?, ?, ?)`
-  );
-  let inserted = 0;
-  const now = Date.now();
-  for (const mem of memories) {
-    if (!VALID_TYPES_SET.has(mem.memory_type) || !mem.content?.trim()) continue;
-    const contentHash = (0, import_crypto2.createHash)("sha256").update(mem.content.trim()).digest("hex");
-    const result = stmt.run((0, import_crypto2.randomUUID)(), agentId, taskId, mem.memory_type, mem.content.trim(), contentHash, now);
-    if (result.changes > 0) inserted++;
-  }
-  return inserted;
-}
-async function extractAndStoreMemories(taskId, agentId, ctx) {
-  const memories = await extractMemories(ctx);
-  if (memories.length === 0) return;
-  const inserted = await storeMemories(taskId, agentId, memories);
-  if (inserted > 0) {
-    console.log(`[memory-extractor] Stored ${inserted} memories for task ${taskId}`);
-  }
-}
-
-// ../agx-cloud/lib/orchestrator/activities.ts
-init_db_adapter();
-
-// ../agx-cloud/lib/orchestration/frontmatter.ts
-function stringifyFrontmatter(frontmatter) {
-  return Object.entries(frontmatter).map(([key, value]) => `${key}: ${value === null || typeof value === "undefined" ? "" : String(value)}`).join("\n");
-}
-function buildMarkdownWithFrontmatter(frontmatter, body) {
-  return `---
-${stringifyFrontmatter(frontmatter)}
----
-${body}`;
-}
-
-// ../agx-cloud/lib/dependency-manager.ts
-init_db_adapter();
-init_auth_mode();
-init_db();
-var READY_STATUS = "completed";
-function normalizeDependsOnInput2(input) {
-  if (!input) return [];
-  if (Array.isArray(input)) {
-    return Array.from(new Set(input.map((entry) => String(entry || "").trim()).filter(Boolean)));
-  }
-  if (typeof input === "string") {
-    const trimmed = input.trim();
-    if (!trimmed) return [];
-    try {
-      const parsed = JSON.parse(trimmed);
-      if (Array.isArray(parsed)) {
-        return Array.from(new Set(parsed.map((entry) => String(entry || "").trim()).filter(Boolean)));
-      }
-    } catch {
-    }
-    return Array.from(new Set(trimmed.split(",").map((entry) => entry.trim()).filter(Boolean)));
-  }
-  return [];
-}
-function extractDependsOn(record) {
-  if (!record) return [];
-  const direct = normalizeDependsOnInput2(record.depends_on);
-  if (direct.length) return direct;
-  if (typeof record.content === "string") {
-    const { frontmatter } = parseFrontmatter(record.content || "");
-    return normalizeDependsOnInput2(frontmatter.depends_on);
-  }
-  return [];
-}
-function describeDependency2(dep) {
-  return dep.title || dep.slug || dep.id || "(unknown)";
-}
-function summarizeRecord(record, id) {
-  if (!record) {
-    return { id: id || "" };
-  }
-  return {
-    id: record.id || id || "",
-    title: record.title || void 0,
-    slug: record.slug || void 0,
-    status: record.status,
-    stage: record.stage
-  };
-}
-async function fetchTasksByIds(ids, userId) {
-  if (!ids.length) return [];
-  const db2 = createAdminDbClient();
-  let query = db2.from("tasks").select("id, title, slug, status, stage").in("id", ids);
-  if (userId) {
-    query = query.eq("user_id", userId);
-  }
-  const { data } = await query;
-  const map = /* @__PURE__ */ new Map();
-  if (Array.isArray(data)) {
-    for (const row of data) {
-      if (row && row.id) {
-        map.set(row.id, summarizeRecord(row, row.id));
-      }
-    }
-  }
-  return ids.map((id) => map.get(id)).filter((dep) => !!dep);
-}
-function formatMissingDependencies(missing) {
-  if (!missing.length) return "";
-  const maxItems = 3;
-  const entries = missing.slice(0, maxItems).map((dep) => {
-    const label = describeDependency2(dep);
-    const statusLabel = dep.stage === "INTAKE" ? "awaiting approval" : dep.status || "";
-    const suffix = statusLabel ? ` (${statusLabel})` : "";
-    return `${label}${suffix}`;
-  });
-  let message = `Waiting on dependencies: ${entries.join(", ")}`;
-  if (missing.length > maxItems) {
-    message += ` +${missing.length - maxItems} more`;
-  }
-  return message;
-}
-async function getMissingDependencies(task, userId) {
-  const dependsOn = extractDependsOn(task);
-  if (!dependsOn.length) return [];
-  const records = await fetchTasksByIds(dependsOn, userId);
-  return records.filter((dep) => (dep.status || "") !== READY_STATUS);
-}
-async function attemptStartTask(taskId, userId, options) {
-  const resolvedUserId = userId || LOCAL_USER.id;
-  const task = await db.getTask(taskId, resolvedUserId);
-  if (!task) {
-    throw new Error(`Task not found: ${taskId}`);
-  }
-  const missingDependencies = await getMissingDependencies(task, resolvedUserId);
-  if (missingDependencies.length) {
-    const reason = formatMissingDependencies(missingDependencies);
-    const adminDb2 = createAdminDbClient();
-    const { error: error2 } = await adminDb2.from("tasks").update({
-      status: "blocked",
-      blocked_reason: reason,
-      updated_at: (/* @__PURE__ */ new Date()).toISOString()
-    }).eq("id", taskId);
-    if (error2 && error2.code !== "42703") {
-      throw error2;
-    }
-    return {
-      started: false,
-      missingDependencies,
-      blockedReason: reason
-    };
-  }
-  if (!options?.force && task.status === "queued" && !task.blocked_reason) {
-    return {
-      started: false,
-      missingDependencies: [],
-      alreadyQueued: true
-    };
-  }
-  const { frontmatter, body } = parseFrontmatter(task.content || "");
-  const ticketType = options?.ticketType ?? getTicketType(frontmatter, body);
-  const queue2 = await getQueue();
-  const jobId = await queue2.send(QUEUE_NAMES.TASK_PROCESS, {
-    taskId,
-    userId: resolvedUserId,
-    signal: "start",
-    ticketType
-  });
-  const adminDb = createAdminDbClient();
-  const { error } = await adminDb.from("tasks").update({
-    status: "queued",
-    blocked_reason: null,
-    updated_at: (/* @__PURE__ */ new Date()).toISOString()
-  }).eq("id", taskId);
-  if (error && error.code !== "42703") {
-    throw error;
-  }
-  return {
-    started: Boolean(jobId),
-    jobId,
-    missingDependencies: [],
-    ticketType
-  };
-}
-async function triggerDependentTasks(taskId, userId) {
-  const resolvedUserId = userId || LOCAL_USER.id;
-  const db2 = createAdminDbClient();
-  let query = db2.from("tasks").select("id").contains("depends_on", [taskId]);
-  if (userId) {
-    query = query.eq("user_id", userId);
-  }
-  const { data, error } = await query;
-  let dependentIds = Array.isArray(data) ? data.map((row) => row?.id).filter(Boolean) : [];
-  if (error && error.code === "42703") {
-    let fallbackQuery = db2.from("tasks").select("id, content");
-    if (userId) {
-      fallbackQuery = fallbackQuery.eq("user_id", userId);
-    }
-    const { data: fallbackTasks } = await fallbackQuery;
-    dependentIds = (Array.isArray(fallbackTasks) ? fallbackTasks : []).filter((row) => extractDependsOn(row).includes(taskId)).map((row) => row?.id).filter(Boolean);
-  }
-  if (!dependentIds.length) return;
-  await Promise.all(
-    dependentIds.map((dependentId) => attemptStartTask(dependentId, resolvedUserId))
-  );
-}
-
-// ../agx-cloud/lib/orchestrator/activities.ts
-init_notifications();
-function isMissingStageDecisionsError(error) {
-  if (!error || typeof error !== "object") return false;
-  const code = "code" in error ? String(error.code) : "";
-  const message = "message" in error ? String(error.message).toLowerCase() : "";
-  return (code === "PGRST204" || code === "42703") && message.includes("stage_decisions");
-}
-async function dispatchStageActivity(input) {
-  const db2 = createAdminDbClient();
-  await db2.from("tasks").update({
-    stage: input.stage,
-    status: "queued",
-    updated_at: (/* @__PURE__ */ new Date()).toISOString()
-  }).eq("id", input.taskId).eq("user_id", input.userId);
-}
-async function recordStageDecisionActivity(input) {
-  const db2 = createAdminDbClient();
-  const { data: task } = await db2.from("tasks").select("stage_decisions").eq("id", input.taskId).eq("user_id", input.userId).maybeSingle();
-  const existingStageDecisions = task?.stage_decisions && typeof task.stage_decisions === "object" ? task.stage_decisions : {};
-  const nextStageDecisions = {
-    ...existingStageDecisions,
-    [input.stage]: {
-      decision: input.decision.decision,
-      rationale: input.decision.explanation,
-      final_result: input.decision.final_result,
-      decided_at: (/* @__PURE__ */ new Date()).toISOString()
-    }
-  };
-  const { error } = await db2.from("tasks").update({
-    stage_decisions: nextStageDecisions,
-    updated_at: (/* @__PURE__ */ new Date()).toISOString()
-  }).eq("id", input.taskId).eq("user_id", input.userId);
-  if (error && !isMissingStageDecisionsError(error)) {
-    throw error;
-  }
-}
-async function applyStageTransitionActivity(input) {
-  const task = await db.getTask(input.taskId, input.userId);
-  if (!task) {
-    throw new Error(`Task ${input.taskId} not found`);
-  }
-  const previousStage = task.stage || null;
-  const eventTimestamp = (/* @__PURE__ */ new Date()).toISOString();
-  const baseNotification = {
-    taskId: input.taskId,
-    userId: input.userId,
-    title: task.title || null,
-    slug: task.slug || null,
-    timestamp: eventTimestamp
-  };
-  const { frontmatter, body } = parseFrontmatter(task.content);
-  const memoryAgentId = resolveMemoryAgentId({
-    defaultUserId: input.userId,
-    frontmatter
-  });
-  frontmatter.stage = input.nextStage;
-  frontmatter.status = input.nextStatus;
-  if (input.error) {
-    frontmatter.error = input.error;
-  } else if ("error" in frontmatter) {
-    delete frontmatter.error;
-  }
-  const updatedContent = buildMarkdownWithFrontmatter(frontmatter, body);
-  await db.updateTask(input.taskId, updatedContent, input.userId);
-  const db2 = createAdminDbClient();
-  const { error: directUpdateError } = await db2.from("tasks").update({
-    stage: input.nextStage,
-    status: input.nextStatus,
-    retry_count: input.retryCount,
-    error: input.error,
-    updated_at: (/* @__PURE__ */ new Date()).toISOString()
-  }).eq("id", input.taskId).eq("user_id", input.userId);
-  if (directUpdateError) {
-    console.error(`[applyStageTransition] direct update failed for ${input.taskId}:`, directUpdateError);
-  } else {
-    console.log(`[applyStageTransition] set ${input.taskId} to status=${input.nextStatus}, stage=${input.nextStage}`);
-  }
-  if (input.nextStatus === "completed") {
-    await db2.from("tasks").update({ completed_at: (/* @__PURE__ */ new Date()).toISOString() }).eq("id", input.taskId).eq("user_id", input.userId);
-    await triggerDependentTasks(input.taskId, input.userId);
-  }
-  if (input.nextStatus === "completed" || input.nextStatus === "failed") {
-    extractAndStoreMemories(input.taskId, memoryAgentId, {
-      goal: String(task.content || task.title || ""),
-      status: String(input.nextStatus)
-    }).catch(
-      (err) => console.warn("[applyStageTransition] Memory extraction failed:", err)
-    );
-  }
-  const shouldEmitStageComplete = input.nextStatus !== "blocked" && input.nextStatus !== "failed";
-  if (shouldEmitStageComplete) {
-    void notifyTaskEvent({
-      ...baseNotification,
-      eventType: "task.stage_complete",
-      stage: previousStage,
-      previousStage,
-      nextStage: input.nextStage,
-      status: input.nextStatus,
-      details: { nextStatus: input.nextStatus }
-    });
-  }
-  if (input.nextStatus === "completed") {
-    void notifyTaskEvent({
-      ...baseNotification,
-      eventType: "task.completed",
-      stage: input.nextStage,
-      status: input.nextStatus,
-      details: {
-        previousStage,
-        nextStage: input.nextStage
-      }
-    });
-  }
-  if (input.nextStatus === "failed") {
-    void notifyTaskEvent({
-      ...baseNotification,
-      eventType: "task.failed",
-      stage: input.nextStage,
-      status: input.nextStatus,
-      error: input.error,
-      details: {
-        previousStage
-      }
-    });
-  }
-}
-async function appendTaskLogActivity(input) {
-  await db.addTaskLog(input.taskId, input.content, input.logType);
-}
-async function appendTaskCommentActivity(input) {
-  await db.addTaskComment(input.taskId, input.content, input.authorType || "agent");
-}
-async function markCancelledActivity(input) {
-  const task = await db.getTask(input.taskId, input.userId);
-  if (!task) return;
-  const { frontmatter, body } = parseFrontmatter(task.content);
-  const memoryAgentId = resolveMemoryAgentId({
-    defaultUserId: input.userId,
-    frontmatter
-  });
-  frontmatter.status = "failed";
-  frontmatter.error = input.reason || "Cancelled";
-  const updatedContent = buildMarkdownWithFrontmatter(frontmatter, body);
-  await db.updateTask(input.taskId, updatedContent, input.userId);
-  await db.addTaskLog(input.taskId, input.reason || "Task cancelled", "error");
-  extractAndStoreMemories(input.taskId, memoryAgentId, {
-    goal: String(task.content || task.title || ""),
-    status: "failed"
-  }).catch(
-    (err) => console.warn("[markCancelled] Memory extraction failed:", err)
-  );
-  const db2 = createAdminDbClient();
-  await db2.from("tasks").update({
-    status: "failed",
-    error: input.reason || "Cancelled",
-    updated_at: (/* @__PURE__ */ new Date()).toISOString()
-  }).eq("id", input.taskId).eq("user_id", input.userId);
-  void notifyTaskEvent({
-    taskId: input.taskId,
-    userId: input.userId,
-    eventType: "task.failed",
-    title: task.title || null,
-    slug: task.slug || null,
-    stage: task.stage || null,
-    status: "failed",
-    error: input.reason || "Cancelled",
-    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-    details: {
-      previousStage: task.stage || null
-    }
-  });
-}
-
-// ../agx-cloud/lib/orchestrator/processor.ts
-async function processSingleJob(job) {
-  const { taskId, userId, signal, payload, ticketType = "task" } = job.data;
-  const task = await db.getTask(taskId, userId);
-  if (!task) {
-    console.log(`[processor] Task ${taskId} not found, skipping`);
-    return;
-  }
-  if (task.status === "completed" || task.status === "failed") {
-    console.log(`[processor] Task ${taskId} is ${task.status}, skipping`);
-    return;
-  }
-  const currentStage = task.stage;
-  switch (signal) {
-    case "start":
-      await handleStart(taskId, currentStage, userId);
-      break;
-    case "agentResult":
-      await handleAgentResult(
-        taskId,
-        currentStage,
-        userId,
-        payload,
-        ticketType,
-        task.retry_count || 0,
-        task.workflow_id && /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(task.workflow_id) ? task.workflow_id : null
-      );
-      break;
-    case "humanInput":
-      await handleHumanInput(taskId, payload);
-      break;
-    case "daemonStep":
-      await handleDaemonStep(taskId, payload);
-      break;
-    case "cancel":
-      await handleCancel(taskId, userId, payload?.reason);
-      break;
-    default:
-      console.warn(`[processor] Unknown signal: ${signal}`);
-  }
-}
-async function taskProcessor(jobs) {
-  for (const job of jobs) {
-    try {
-      await processSingleJob(job);
-    } catch (error) {
-      console.error(`[processor] Error processing job ${job.id}:`, error);
-      throw error;
-    }
-  }
-}
-async function handleStart(taskId, stage, userId) {
-  console.log(`[processor] Starting task ${taskId} at stage ${stage}`);
-  await dispatchStageActivity({ taskId, stage, userId });
-  await appendTaskLogActivity({
-    taskId,
-    content: `Task started at stage: ${stage}`,
-    logType: "system"
-  });
-}
-async function handleAgentResult(taskId, currentStage, userId, decision, ticketType, retryCount, workflowId = null) {
-  console.log(`[processor] Processing agent result for ${taskId}: ${decision.decision}`);
-  await recordStageDecisionActivity({
-    taskId,
-    stage: currentStage,
-    decision,
-    userId
-  });
-  const explicitComments = Array.isArray(decision.comments) ? decision.comments.map((entry) => String(entry || "").trim()).filter(Boolean) : [];
-  const fallbackComment = String(decision.comment || decision.log || decision.final_result || "").trim();
-  const normalizedComments = explicitComments.length > 0 ? explicitComments : fallbackComment.split("\n").map((line) => line.trim()).filter(Boolean);
-  for (const content of normalizedComments) {
-    await appendTaskCommentActivity({ taskId, content, authorType: "agent" });
-  }
-  let nextStage;
-  let nextStatus;
-  let nextRetryCount;
-  let transitionError = null;
-  let appendLog = null;
-  if (workflowId) {
-    const workflowTransition = await resolveWorkflowTransition({
-      workflowId,
-      currentNodeName: currentStage,
-      decision: decision.decision,
-      retryCount,
-      maxRetries: 3
-    });
-    nextStage = workflowTransition.nextNodeName;
-    nextStatus = workflowTransition.nextStatus;
-    nextRetryCount = workflowTransition.retryCount;
-    transitionError = workflowTransition.error;
-    appendLog = workflowTransition.appendLog;
-    console.log(`[processor] Workflow transition: ${currentStage} -> ${nextStage} (workflow: ${workflowId})`);
-  } else {
-    const transition = resolveStageTransition({
-      currentStage,
-      decision: decision.decision,
-      ticketType,
-      retryCount,
-      maxRetries: 3
-    });
-    nextStage = transition.nextStage;
-    nextStatus = transition.nextStatus;
-    nextRetryCount = transition.retryCount;
-    transitionError = transition.error;
-    appendLog = transition.appendLog;
-  }
-  await applyStageTransitionActivity({
-    taskId,
-    nextStage,
-    nextStatus,
-    retryCount: nextRetryCount,
-    error: transitionError ? decision.explanation || transitionError : null,
-    userId
-  });
-  if (appendLog) {
-    const content = appendLog.logType === "error" && decision.explanation ? decision.explanation : appendLog.logType === "system" && decision.explanation ? decision.explanation : appendLog.content;
-    await appendTaskLogActivity({
-      taskId,
-      content,
-      logType: appendLog.logType
-    });
-  }
-  console.log(`[processor] Task ${taskId} transitioned: ${currentStage} -> ${nextStage}`);
-}
-async function handleHumanInput(taskId, payload) {
-  console.log(`[processor] Recording human input for ${taskId}`);
-  await appendTaskCommentActivity({
-    taskId,
-    content: payload.content,
-    authorType: payload.authorType || "user"
-  });
-}
-async function handleDaemonStep(taskId, step) {
-  const providerSuffix = step.provider ? ` provider=${step.provider}` : "";
-  const modelSuffix = step.model ? ` model=${step.model}` : "";
-  const roleSuffix = step.role ? ` role=${step.role}` : "";
-  const iterationSuffix = typeof step.iteration === "number" ? ` iter=${step.iteration}` : "";
-  const exitSuffix = step.phase === "exit" ? ` exit=${step.exit_code}` : "";
-  const errorSuffix = step.error ? ` error=${step.error}` : "";
-  const argsSummary = Array.isArray(step.args) ? step.args.join(" ") : "";
-  const stdoutSummary = step.stdout_tail ? `
-stdout_tail:
-${step.stdout_tail}` : "";
-  const stderrSummary = step.stderr_tail ? `
-stderr_tail:
-${step.stderr_tail}` : "";
-  const content = `[execution/${step.kind || "daemon"}] ${step.phase || "event"} ${step.label || ""}${providerSuffix}${modelSuffix}${roleSuffix}${iterationSuffix}${exitSuffix}${errorSuffix}`.trim() + (argsSummary ? `
-args: ${argsSummary}` : "") + (step.duration_ms ? `
-duration_ms: ${step.duration_ms}` : "") + stdoutSummary + stderrSummary;
-  await appendTaskLogActivity({
-    taskId,
-    content,
-    logType: "system"
-  });
-}
-async function handleCancel(taskId, userId, reason) {
-  console.log(`[processor] Cancelling task ${taskId}: ${reason || "No reason"}`);
-  await markCancelledActivity({ taskId, reason, userId });
-}
-
-// ../agx-cloud/worker/index.ts
-async function main() {
-  const requestedWorkers = Number(process.env.AGX_WORKER_COUNT) || 1;
-  assertWorkerCount(requestedWorkers);
-  console.log(`[worker] Starting SQLite worker (${requestedWorkers}/${MAX_WORKERS} max)...`);
-  const queue2 = await getQueue();
-  await queue2.work(
-    QUEUE_NAMES.TASK_PROCESS,
-    taskProcessor,
-    { batchSize: 5 }
-  );
-  console.log(`[worker] Listening on queue: ${QUEUE_NAMES.TASK_PROCESS}`);
-  const shutdown = async (signal) => {
-    console.log(`[worker] Received ${signal}, shutting down...`);
-    await stopQueue();
-    process.exit(0);
-  };
-  process.on("SIGINT", () => shutdown("SIGINT"));
-  process.on("SIGTERM", () => shutdown("SIGTERM"));
-}
-main().catch((error) => {
-  console.error("[worker] Fatal error:", error);
-  process.exit(1);
-});