@foothill/agent-move 1.0.6

package/packages/server/dist/watcher/opencode/opencode-watcher.js

@@ -0,0 +1,1292 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// dist/watcher/opencode/opencode-watcher.js
+import chokidar from "chokidar";
+import { homedir } from "os";
+import { join } from "path";
+import { homedir as homedir2 } from "os";
+import { join as join2 } from "path";
+import { existsSync } from "fs";
+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 __require2 = /* @__PURE__ */ ((x) => typeof __require !== "undefined" ? __require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof __require !== "undefined" ? __require : a)[b]
+}) : x)(function(x) {
+  if (typeof __require !== "undefined") return __require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require22() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+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 require_util = __commonJS({
+  "../../node_modules/better-sqlite3/lib/util.js"(exports) {
+    "use strict";
+    exports.getBooleanOption = (options, key) => {
+      let value = false;
+      if (key in options && typeof (value = options[key]) !== "boolean") {
+        throw new TypeError(`Expected the "${key}" option to be a boolean`);
+      }
+      return value;
+    };
+    exports.cppdb = /* @__PURE__ */ Symbol();
+    exports.inspect = /* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom");
+  }
+});
+var require_sqlite_error = __commonJS({
+  "../../node_modules/better-sqlite3/lib/sqlite-error.js"(exports, module) {
+    "use strict";
+    var descriptor = { value: "SqliteError", writable: true, enumerable: false, configurable: true };
+    function SqliteError(message, code) {
+      if (new.target !== SqliteError) {
+        return new SqliteError(message, code);
+      }
+      if (typeof code !== "string") {
+        throw new TypeError("Expected second argument to be a string");
+      }
+      Error.call(this, message);
+      descriptor.value = "" + message;
+      Object.defineProperty(this, "message", descriptor);
+      Error.captureStackTrace(this, SqliteError);
+      this.code = code;
+    }
+    Object.setPrototypeOf(SqliteError, Error);
+    Object.setPrototypeOf(SqliteError.prototype, Error.prototype);
+    Object.defineProperty(SqliteError.prototype, "name", descriptor);
+    module.exports = SqliteError;
+  }
+});
+var require_file_uri_to_path = __commonJS({
+  "../../node_modules/file-uri-to-path/index.js"(exports, module) {
+    var sep = __require2("path").sep || "/";
+    module.exports = fileUriToPath;
+    function fileUriToPath(uri) {
+      if ("string" != typeof uri || uri.length <= 7 || "file://" != uri.substring(0, 7)) {
+        throw new TypeError("must pass in a file:// URI to convert to a file path");
+      }
+      var rest = decodeURI(uri.substring(7));
+      var firstSlash = rest.indexOf("/");
+      var host = rest.substring(0, firstSlash);
+      var path = rest.substring(firstSlash + 1);
+      if ("localhost" == host) host = "";
+      if (host) {
+        host = sep + sep + host;
+      }
+      path = path.replace(/^(.+)\|/, "$1:");
+      if (sep == "\\") {
+        path = path.replace(/\//g, "\\");
+      }
+      if (/^.+\:/.test(path)) {
+      } else {
+        path = sep + path;
+      }
+      return host + path;
+    }
+  }
+});
+var require_bindings = __commonJS({
+  "../../node_modules/bindings/bindings.js"(exports, module) {
+    var fs = __require2("fs");
+    var path = __require2("path");
+    var fileURLToPath = require_file_uri_to_path();
+    var join3 = path.join;
+    var dirname = path.dirname;
+    var exists = fs.accessSync && function(path2) {
+      try {
+        fs.accessSync(path2);
+      } catch (e) {
+        return false;
+      }
+      return true;
+    } || fs.existsSync || path.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 = exports.getRoot(exports.getFileName());
+      }
+      if (path.extname(opts.bindings) != ".node") {
+        opts.bindings += ".node";
+      }
+      var requireFunc = typeof __webpack_require__ === "function" ? __non_webpack_require__ : __require2;
+      var tries = [], i = 0, l = opts.try.length, n, b, err;
+      for (; i < l; i++) {
+        n = join3.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;
+    }
+    module.exports = exports = bindings;
+    exports.getFileName = function getFileName(calling_file) {
+      var origPST = Error.prepareStackTrace, origSTL = Error.stackTraceLimit, dummy = {}, fileName;
+      Error.stackTraceLimit = 10;
+      Error.prepareStackTrace = function(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;
+    };
+    exports.getRoot = function getRoot(file) {
+      var dir = dirname(file), prev;
+      while (true) {
+        if (dir === ".") {
+          dir = process.cwd();
+        }
+        if (exists(join3(dir, "package.json")) || exists(join3(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 = join3(dir, "..");
+      }
+    };
+  }
+});
+var require_wrappers = __commonJS({
+  "../../node_modules/better-sqlite3/lib/methods/wrappers.js"(exports) {
+    "use strict";
+    var { cppdb } = require_util();
+    exports.prepare = function prepare(sql) {
+      return this[cppdb].prepare(sql, this, false);
+    };
+    exports.exec = function exec(sql) {
+      this[cppdb].exec(sql);
+      return this;
+    };
+    exports.close = function close() {
+      this[cppdb].close();
+      return this;
+    };
+    exports.loadExtension = function loadExtension(...args) {
+      this[cppdb].loadExtension(...args);
+      return this;
+    };
+    exports.defaultSafeIntegers = function defaultSafeIntegers(...args) {
+      this[cppdb].defaultSafeIntegers(...args);
+      return this;
+    };
+    exports.unsafeMode = function unsafeMode(...args) {
+      this[cppdb].unsafeMode(...args);
+      return this;
+    };
+    exports.getters = {
+      name: {
+        get: function name() {
+          return this[cppdb].name;
+        },
+        enumerable: true
+      },
+      open: {
+        get: function open() {
+          return this[cppdb].open;
+        },
+        enumerable: true
+      },
+      inTransaction: {
+        get: function inTransaction() {
+          return this[cppdb].inTransaction;
+        },
+        enumerable: true
+      },
+      readonly: {
+        get: function readonly() {
+          return this[cppdb].readonly;
+        },
+        enumerable: true
+      },
+      memory: {
+        get: function memory() {
+          return this[cppdb].memory;
+        },
+        enumerable: true
+      }
+    };
+  }
+});
+var require_transaction = __commonJS({
+  "../../node_modules/better-sqlite3/lib/methods/transaction.js"(exports, module) {
+    "use strict";
+    var { cppdb } = require_util();
+    var controllers = /* @__PURE__ */ new WeakMap();
+    module.exports = function transaction(fn) {
+      if (typeof fn !== "function") throw new TypeError("Expected first argument to be a function");
+      const db = this[cppdb];
+      const controller = getController(db, this);
+      const { apply } = Function.prototype;
+      const properties = {
+        default: { value: wrapTransaction(apply, fn, db, controller.default) },
+        deferred: { value: wrapTransaction(apply, fn, db, controller.deferred) },
+        immediate: { value: wrapTransaction(apply, fn, db, controller.immediate) },
+        exclusive: { value: wrapTransaction(apply, fn, db, controller.exclusive) },
+        database: { value: this, enumerable: true }
+      };
+      Object.defineProperties(properties.default.value, properties);
+      Object.defineProperties(properties.deferred.value, properties);
+      Object.defineProperties(properties.immediate.value, properties);
+      Object.defineProperties(properties.exclusive.value, properties);
+      return properties.default.value;
+    };
+    var getController = (db, self) => {
+      let controller = controllers.get(db);
+      if (!controller) {
+        const shared = {
+          commit: db.prepare("COMMIT", self, false),
+          rollback: db.prepare("ROLLBACK", self, false),
+          savepoint: db.prepare("SAVEPOINT `	_bs3.	`", self, false),
+          release: db.prepare("RELEASE `	_bs3.	`", self, false),
+          rollbackTo: db.prepare("ROLLBACK TO `	_bs3.	`", self, false)
+        };
+        controllers.set(db, controller = {
+          default: Object.assign({ begin: db.prepare("BEGIN", self, false) }, shared),
+          deferred: Object.assign({ begin: db.prepare("BEGIN DEFERRED", self, false) }, shared),
+          immediate: Object.assign({ begin: db.prepare("BEGIN IMMEDIATE", self, false) }, shared),
+          exclusive: Object.assign({ begin: db.prepare("BEGIN EXCLUSIVE", self, false) }, shared)
+        });
+      }
+      return controller;
+    };
+    var wrapTransaction = (apply, fn, db, { begin, commit, rollback, savepoint, release, rollbackTo }) => function sqliteTransaction() {
+      let before, after, undo;
+      if (db.inTransaction) {
+        before = savepoint;
+        after = release;
+        undo = rollbackTo;
+      } else {
+        before = begin;
+        after = commit;
+        undo = rollback;
+      }
+      before.run();
+      try {
+        const result = apply.call(fn, this, arguments);
+        if (result && typeof result.then === "function") {
+          throw new TypeError("Transaction function cannot return a promise");
+        }
+        after.run();
+        return result;
+      } catch (ex) {
+        if (db.inTransaction) {
+          undo.run();
+          if (undo !== rollback) after.run();
+        }
+        throw ex;
+      }
+    };
+  }
+});
+var require_pragma = __commonJS({
+  "../../node_modules/better-sqlite3/lib/methods/pragma.js"(exports, module) {
+    "use strict";
+    var { getBooleanOption, cppdb } = require_util();
+    module.exports = function pragma(source, options) {
+      if (options == null) options = {};
+      if (typeof source !== "string") throw new TypeError("Expected first argument to be a string");
+      if (typeof options !== "object") throw new TypeError("Expected second argument to be an options object");
+      const simple = getBooleanOption(options, "simple");
+      const stmt = this[cppdb].prepare(`PRAGMA ${source}`, this, true);
+      return simple ? stmt.pluck().get() : stmt.all();
+    };
+  }
+});
+var require_backup = __commonJS({
+  "../../node_modules/better-sqlite3/lib/methods/backup.js"(exports, module) {
+    "use strict";
+    var fs = __require2("fs");
+    var path = __require2("path");
+    var { promisify } = __require2("util");
+    var { cppdb } = require_util();
+    var fsAccess = promisify(fs.access);
+    module.exports = async function backup(filename, options) {
+      if (options == null) options = {};
+      if (typeof filename !== "string") throw new TypeError("Expected first argument to be a string");
+      if (typeof options !== "object") throw new TypeError("Expected second argument to be an options object");
+      filename = filename.trim();
+      const attachedName = "attached" in options ? options.attached : "main";
+      const handler = "progress" in options ? options.progress : null;
+      if (!filename) throw new TypeError("Backup filename cannot be an empty string");
+      if (filename === ":memory:") throw new TypeError('Invalid backup filename ":memory:"');
+      if (typeof attachedName !== "string") throw new TypeError('Expected the "attached" option to be a string');
+      if (!attachedName) throw new TypeError('The "attached" option cannot be an empty string');
+      if (handler != null && typeof handler !== "function") throw new TypeError('Expected the "progress" option to be a function');
+      await fsAccess(path.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);
+          }
+        });
+      });
+    };
+  }
+});
+var require_serialize = __commonJS({
+  "../../node_modules/better-sqlite3/lib/methods/serialize.js"(exports, module) {
+    "use strict";
+    var { cppdb } = require_util();
+    module.exports = function serialize(options) {
+      if (options == null) options = {};
+      if (typeof options !== "object") throw new TypeError("Expected first argument to be an options object");
+      const attachedName = "attached" in options ? options.attached : "main";
+      if (typeof attachedName !== "string") throw new TypeError('Expected the "attached" option to be a string');
+      if (!attachedName) throw new TypeError('The "attached" option cannot be an empty string');
+      return this[cppdb].serialize(attachedName);
+    };
+  }
+});
+var require_function = __commonJS({
+  "../../node_modules/better-sqlite3/lib/methods/function.js"(exports, module) {
+    "use strict";
+    var { getBooleanOption, cppdb } = require_util();
+    module.exports = function defineFunction(name, options, fn) {
+      if (options == null) options = {};
+      if (typeof options === "function") {
+        fn = options;
+        options = {};
+      }
+      if (typeof name !== "string") throw new TypeError("Expected first argument to be a string");
+      if (typeof fn !== "function") throw new TypeError("Expected last argument to be a function");
+      if (typeof options !== "object") throw new TypeError("Expected second argument to be an options object");
+      if (!name) throw new TypeError("User-defined function name cannot be an empty string");
+      const safeIntegers = "safeIntegers" in options ? +getBooleanOption(options, "safeIntegers") : 2;
+      const deterministic = getBooleanOption(options, "deterministic");
+      const directOnly = getBooleanOption(options, "directOnly");
+      const varargs = getBooleanOption(options, "varargs");
+      let argCount = -1;
+      if (!varargs) {
+        argCount = fn.length;
+        if (!Number.isInteger(argCount) || argCount < 0) throw new TypeError("Expected function.length to be a positive integer");
+        if (argCount > 100) throw new RangeError("User-defined functions cannot have more than 100 arguments");
+      }
+      this[cppdb].function(fn, name, argCount, safeIntegers, deterministic, directOnly);
+      return this;
+    };
+  }
+});
+var require_aggregate = __commonJS({
+  "../../node_modules/better-sqlite3/lib/methods/aggregate.js"(exports, module) {
+    "use strict";
+    var { getBooleanOption, cppdb } = require_util();
+    module.exports = function defineAggregate(name, options) {
+      if (typeof name !== "string") throw new TypeError("Expected first argument to be a string");
+      if (typeof options !== "object" || options === null) throw new TypeError("Expected second argument to be an options object");
+      if (!name) throw new TypeError("User-defined function name cannot be an empty string");
+      const start = "start" in options ? options.start : null;
+      const step = getFunctionOption(options, "step", true);
+      const inverse = getFunctionOption(options, "inverse", false);
+      const result = getFunctionOption(options, "result", false);
+      const safeIntegers = "safeIntegers" in options ? +getBooleanOption(options, "safeIntegers") : 2;
+      const deterministic = getBooleanOption(options, "deterministic");
+      const directOnly = getBooleanOption(options, "directOnly");
+      const varargs = getBooleanOption(options, "varargs");
+      let argCount = -1;
+      if (!varargs) {
+        argCount = Math.max(getLength(step), inverse ? getLength(inverse) : 0);
+        if (argCount > 0) argCount -= 1;
+        if (argCount > 100) throw new RangeError("User-defined functions cannot have more than 100 arguments");
+      }
+      this[cppdb].aggregate(start, step, inverse, result, name, argCount, safeIntegers, deterministic, directOnly);
+      return this;
+    };
+    var getFunctionOption = (options, key, 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");
+    };
+  }
+});
+var require_table = __commonJS({
+  "../../node_modules/better-sqlite3/lib/methods/table.js"(exports, module) {
+    "use strict";
+    var { cppdb } = require_util();
+    module.exports = function defineTable(name, factory) {
+      if (typeof name !== "string") throw new TypeError("Expected first argument to be a string");
+      if (!name) throw new TypeError("Virtual table module name cannot be an empty string");
+      let eponymous = false;
+      if (typeof factory === "object" && factory !== null) {
+        eponymous = true;
+        factory = defer(parseTableDefinition(factory, "used", name));
+      } else {
+        if (typeof factory !== "function") throw new TypeError("Expected second argument to be a function or a table definition object");
+        factory = wrapFactory(factory);
+      }
+      this[cppdb].table(factory, name, eponymous);
+      return this;
+    };
+    function wrapFactory(factory) {
+      return function virtualTableFactory(moduleName, databaseName, tableName, ...args) {
+        const thisObject = {
+          module: moduleName,
+          database: databaseName,
+          table: tableName
+        };
+        const def = apply.call(factory, thisObject, args);
+        if (typeof def !== "object" || def === null) {
+          throw new TypeError(`Virtual table module "${moduleName}" did not return a table definition object`);
+        }
+        return parseTableDefinition(def, "returned", moduleName);
+      };
+    }
+    function parseTableDefinition(def, verb, moduleName) {
+      if (!hasOwnProperty.call(def, "rows")) {
+        throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition without a "rows" property`);
+      }
+      if (!hasOwnProperty.call(def, "columns")) {
+        throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition without a "columns" property`);
+      }
+      const rows = def.rows;
+      if (typeof rows !== "function" || Object.getPrototypeOf(rows) !== GeneratorFunctionPrototype) {
+        throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with an invalid "rows" property (should be a generator function)`);
+      }
+      let columns = def.columns;
+      if (!Array.isArray(columns) || !(columns = [...columns]).every((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;
+  }
+});
+var require_inspect = __commonJS({
+  "../../node_modules/better-sqlite3/lib/methods/inspect.js"(exports, module) {
+    "use strict";
+    var DatabaseInspection = function Database2() {
+    };
+    module.exports = function inspect(depth, opts) {
+      return Object.assign(new DatabaseInspection(), this);
+    };
+  }
+});
+var require_database = __commonJS({
+  "../../node_modules/better-sqlite3/lib/database.js"(exports, module) {
+    "use strict";
+    var fs = __require2("fs");
+    var path = __require2("path");
+    var util = require_util();
+    var SqliteError = require_sqlite_error();
+    var DEFAULT_ADDON;
+    function Database2(filenameGiven, options) {
+      if (new.target == null) {
+        return new Database2(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__ : __require2;
+        addon = requireFunc(path.resolve(nativeBinding).replace(/(\.node)?$/, ".node"));
+      } else {
+        addon = nativeBinding;
+      }
+      if (!addon.isInitialized) {
+        addon.setErrorConstructor(SqliteError);
+        addon.isInitialized = true;
+      }
+      if (!anonymous && !filename.startsWith("file:") && !fs.existsSync(path.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();
+    Database2.prototype.prepare = wrappers.prepare;
+    Database2.prototype.transaction = require_transaction();
+    Database2.prototype.pragma = require_pragma();
+    Database2.prototype.backup = require_backup();
+    Database2.prototype.serialize = require_serialize();
+    Database2.prototype.function = require_function();
+    Database2.prototype.aggregate = require_aggregate();
+    Database2.prototype.table = require_table();
+    Database2.prototype.loadExtension = wrappers.loadExtension;
+    Database2.prototype.exec = wrappers.exec;
+    Database2.prototype.close = wrappers.close;
+    Database2.prototype.defaultSafeIntegers = wrappers.defaultSafeIntegers;
+    Database2.prototype.unsafeMode = wrappers.unsafeMode;
+    Database2.prototype[util.inspect] = require_inspect();
+    module.exports = Database2;
+  }
+});
+var require_lib = __commonJS({
+  "../../node_modules/better-sqlite3/lib/index.js"(exports, module) {
+    "use strict";
+    module.exports = require_database();
+    module.exports.SqliteError = require_sqlite_error();
+  }
+});
+var import_better_sqlite3 = __toESM(require_lib(), 1);
+var config = {
+  port: parseInt(process.env.AGENT_MOVE_PORT || "3333", 10),
+  claudeHome: join(homedir(), ".claude"),
+  idleTimeoutMs: 45e3,
+  /** How long after going idle before an agent is automatically shutdown/removed */
+  shutdownTimeoutMs: 30 * 60 * 1e3,
+  // 30 minutes
+  /** How recently a session file must be modified to be considered "active" on startup */
+  activeThresholdMs: 10 * 60 * 1e3,
+  // 10 minutes
+  /** Enable OpenCode session watching (auto-detected if storage dir exists) */
+  enableOpenCode: process.env.AGENT_MOVE_OPENCODE !== "false"
+};
+function getOpenCodeDbPath() {
+  const home = homedir2();
+  const candidates = [
+    join2(home, ".local", "share", "opencode", "opencode.db"),
+    // Windows fallback via LOCALAPPDATA
+    ...process.env.LOCALAPPDATA ? [join2(process.env.LOCALAPPDATA, "opencode", "opencode.db")] : [],
+    join2(home, ".opencode", "opencode.db")
+  ];
+  for (const candidate of candidates) {
+    if (existsSync(candidate))
+      return candidate;
+  }
+  return null;
+}
+function parseOpenCodeSession(row) {
+  const segments = row.directory.replace(/\\/g, "/").split("/").filter(Boolean);
+  const projectName = segments[segments.length - 1] || "opencode";
+  return {
+    // Use the actual directory as projectPath so getGitBranch() gets a valid cwd.
+    // projectDir uses the project_id hash to group agents belonging to the same project.
+    projectPath: row.directory || row.project_id,
+    projectName,
+    isSubagent: !!row.parent_id,
+    projectDir: row.project_id,
+    parentSessionId: row.parent_id ? `oc:${row.parent_id}` : null
+  };
+}
+var TOOL_NAME_MAP = {
+  // OpenCode lowercase → canonical PascalCase
+  read: "Read",
+  write: "Write",
+  edit: "Edit",
+  patch: "Patch",
+  glob: "Glob",
+  bash: "Bash",
+  grep: "Grep",
+  websearch: "WebSearch",
+  webfetch: "WebFetch",
+  todoread: "TodoRead",
+  todowrite: "TodoWrite"
+};
+function normalizeToolName(name) {
+  return TOOL_NAME_MAP[name] ?? name;
+}
+function normalizeToolInput(input) {
+  if (!("filePath" in input) && !("oldString" in input) && !("newString" in input) && !("replaceAll" in input)) {
+    return input;
+  }
+  const out = { ...input };
+  if ("filePath" in out) {
+    out.file_path = out.filePath;
+    delete out.filePath;
+  }
+  if ("oldString" in out) {
+    out.old_string = out.oldString;
+    delete out.oldString;
+  }
+  if ("newString" in out) {
+    out.new_string = out.newString;
+    delete out.newString;
+  }
+  if ("replaceAll" in out) {
+    out.replace_all = out.replaceAll;
+    delete out.replaceAll;
+  }
+  return out;
+}
+var ZONES = [
+  // Row 0
+  {
+    id: "search",
+    label: "Search",
+    description: "Grep, WebSearch \u2014 Research & lookup",
+    icon: "\u{1F4DA}",
+    color: 15381256,
+    colStart: 0,
+    colSpan: 5,
+    rowStart: 0,
+    rowSpan: 1,
+    x: 0,
+    y: 0,
+    width: 0,
+    height: 0
+  },
+  {
+    id: "terminal",
+    label: "Terminal",
+    description: "Bash commands \u2014 Server room",
+    icon: "\u{1F4BB}",
+    color: 2278750,
+    colStart: 5,
+    colSpan: 3,
+    rowStart: 0,
+    rowSpan: 1,
+    x: 0,
+    y: 0,
+    width: 0,
+    height: 0
+  },
+  {
+    id: "web",
+    label: "Web",
+    description: "WebFetch, Browser \u2014 Network hub",
+    icon: "\u{1F310}",
+    color: 9133302,
+    colStart: 8,
+    colSpan: 4,
+    rowStart: 0,
+    rowSpan: 1,
+    x: 0,
+    y: 0,
+    width: 0,
+    height: 0
+  },
+  // Row 1
+  {
+    id: "files",
+    label: "Files",
+    description: "Read, Write, Edit, Glob \u2014 File storage",
+    icon: "\u{1F4C1}",
+    color: 3900150,
+    colStart: 0,
+    colSpan: 4,
+    rowStart: 1,
+    rowSpan: 1,
+    x: 0,
+    y: 0,
+    width: 0,
+    height: 0
+  },
+  {
+    id: "thinking",
+    label: "Thinking",
+    description: "Planning, Questions \u2014 Conference area",
+    icon: "\u{1F4AD}",
+    color: 16347926,
+    colStart: 4,
+    colSpan: 5,
+    rowStart: 1,
+    rowSpan: 1,
+    x: 0,
+    y: 0,
+    width: 0,
+    height: 0
+  },
+  {
+    id: "messaging",
+    label: "Messaging",
+    description: "SendMessage, Teams \u2014 Chat & relax",
+    icon: "\u{1F4AC}",
+    color: 15485081,
+    colStart: 9,
+    colSpan: 3,
+    rowStart: 1,
+    rowSpan: 1,
+    x: 0,
+    y: 0,
+    width: 0,
+    height: 0
+  },
+  // Row 2
+  {
+    id: "spawn",
+    label: "Spawn",
+    description: "Agent spawn/despawn \u2014 Entry portal",
+    icon: "\u{1F300}",
+    color: 11032055,
+    colStart: 0,
+    colSpan: 3,
+    rowStart: 2,
+    rowSpan: 1,
+    x: 0,
+    y: 0,
+    width: 0,
+    height: 0
+  },
+  {
+    id: "idle",
+    label: "Idle",
+    description: "Idle agents rest here \u2014 Kitchen & lounge",
+    icon: "\u2615",
+    color: 7041664,
+    colStart: 3,
+    colSpan: 5,
+    rowStart: 2,
+    rowSpan: 1,
+    x: 0,
+    y: 0,
+    width: 0,
+    height: 0
+  },
+  {
+    id: "tasks",
+    label: "Tasks",
+    description: "TaskCreate, TaskUpdate \u2014 Kanban & planning",
+    icon: "\u{1F4CB}",
+    color: 1357990,
+    colStart: 8,
+    colSpan: 4,
+    rowStart: 2,
+    rowSpan: 1,
+    x: 0,
+    y: 0,
+    width: 0,
+    height: 0
+  }
+];
+var ZONE_MAP = new Map(ZONES.map((z) => [z.id, z]));
+var OpenCodeParser = class {
+  /**
+   * Convert an OpenCode part JSON object into a ParsedActivity.
+   * All tool names and input field names are normalized to canonical form
+   * so downstream code (activity-processor, TOOL_ZONE_MAP, etc.) needs no
+   * agent-specific branches.
+   *
+   * Returns null for parts that carry no actionable activity.
+   */
+  parsePart(partData, messageData) {
+    if (partData.type === "tool") {
+      const tool = partData;
+      if (tool.state.status === "pending")
+        return null;
+      const rawInput = tool.state.input ?? {};
+      return {
+        type: "tool_use",
+        toolName: normalizeToolName(tool.tool),
+        toolInput: normalizeToolInput(rawInput),
+        agentName: messageData?.agent,
+        model: messageData?.modelID
+      };
+    }
+    if (partData.type === "text") {
+      const text = partData;
+      if (text.synthetic)
+        return null;
+      const trimmed = text.text?.trim() ?? "";
+      if (trimmed.length === 0 || trimmed.length >= 200)
+        return null;
+      return {
+        type: "text",
+        text: trimmed,
+        agentName: messageData?.agent,
+        model: messageData?.modelID
+      };
+    }
+    if (partData.type === "reasoning") {
+      const reasoning = partData;
+      const trimmed = reasoning.text?.trim() ?? "";
+      return {
+        type: "tool_use",
+        toolName: "thinking",
+        toolInput: trimmed.length > 0 ? { thought: trimmed.slice(0, 120) } : void 0,
+        agentName: messageData?.agent,
+        model: messageData?.modelID
+      };
+    }
+    return null;
+  }
+  /**
+   * Emit token usage from an assistant message row.
+   * Called once per assistant message.
+   */
+  parseTokenUsage(messageData) {
+    if (messageData.role !== "assistant")
+      return null;
+    const t = messageData.tokens;
+    if (!t?.input && !t?.output)
+      return null;
+    return {
+      type: "token_usage",
+      inputTokens: t.input,
+      outputTokens: t.output,
+      cacheReadTokens: t.cache?.read,
+      cacheCreationTokens: t.cache?.write,
+      model: messageData.modelID,
+      agentName: messageData.agent
+    };
+  }
+};
+var OpenCodeWatcher = class {
+  stateManager;
+  watcher = null;
+  db = null;
+  parser = new OpenCodeParser();
+  /** Timestamp watermark for incremental polling (ms) */
+  lastMessageTs = 0;
+  /** Tracks time_created (not time_updated) so each part is processed exactly once */
+  lastPartCreatedTs = 0;
+  /** sessionId → SessionInfo cache */
+  sessions = /* @__PURE__ */ new Map();
+  /** messageId → parsed message data cache */
+  messages = /* @__PURE__ */ new Map();
+  /** callID → true — deduplicates tool_use per tool invocation */
+  seenCallIds = /* @__PURE__ */ new Set();
+  /** row id → true — deduplicates text/token events */
+  seenIds = /* @__PURE__ */ new Set();
+  // Prepared statements (initialised after DB opens)
+  stmtAllSessions;
+  stmtRecentSessions;
+  stmtMessagesBySession;
+  stmtPartsBySession;
+  stmtNewMessages;
+  stmtNewParts;
+  constructor(stateManager) {
+    this.stateManager = stateManager;
+  }
+  async start() {
+    const activeThresholdMs = config.activeThresholdMs;
+    const dbPath = getOpenCodeDbPath();
+    if (!dbPath) {
+      console.log("[opencode] No database found \u2014 OpenCode not installed or not yet used");
+      return;
+    }
+    console.log(`[opencode] Database found at ${dbPath}`);
+    try {
+      this.db = new import_better_sqlite3.default(dbPath, { readonly: true, fileMustExist: true });
+      this.prepareStatements();
+    } catch (err) {
+      console.error("[opencode] Failed to open database:", err);
+      return;
+    }
+    this.loadAllSessions();
+    this.replayRecentSessions(activeThresholdMs);
+    if (this.lastMessageTs === 0)
+      this.lastMessageTs = Date.now() - 5e3;
+    if (this.lastPartCreatedTs === 0)
+      this.lastPartCreatedTs = Date.now() - 5e3;
+    const walPath = dbPath + "-wal";
+    this.watcher = chokidar.watch(walPath, {
+      persistent: true,
+      ignoreInitial: true,
+      usePolling: true,
+      interval: 500,
+      disableGlobbing: true
+    });
+    this.watcher.on("change", () => this.poll());
+    this.watcher.on("add", () => this.poll());
+    console.log("[opencode] Watching for new activity");
+  }
+  stop() {
+    this.watcher?.close();
+    this.db?.close();
+    this.sessions.clear();
+    this.messages.clear();
+    this.seenCallIds.clear();
+    this.seenIds.clear();
+  }
+  // ── Prepared statements ────────────────────────────────────────────────────
+  prepareStatements() {
+    const db = this.db;
+    this.stmtAllSessions = db.prepare("SELECT id, directory, parent_id, title, project_id FROM session");
+    this.stmtRecentSessions = db.prepare("SELECT id, directory, parent_id, title, project_id FROM session WHERE time_updated > ?");
+    this.stmtMessagesBySession = db.prepare("SELECT id, session_id, time_updated, data FROM message WHERE session_id = ? ORDER BY time_created");
+    this.stmtPartsBySession = db.prepare("SELECT id, message_id, session_id, time_created, time_updated, data FROM part WHERE session_id = ? ORDER BY time_created");
+    this.stmtNewMessages = db.prepare("SELECT id, session_id, time_updated, data FROM message WHERE time_updated > ? ORDER BY time_updated");
+    this.stmtNewParts = db.prepare("SELECT id, message_id, session_id, time_created, time_updated, data FROM part WHERE time_created > ? ORDER BY time_created");
+  }
+  // ── Session cache ──────────────────────────────────────────────────────────
+  loadAllSessions() {
+    const rows = this.stmtAllSessions.all();
+    for (const row of rows) {
+      this.sessions.set(row.id, parseOpenCodeSession(row));
+    }
+  }
+  // ── Startup replay ─────────────────────────────────────────────────────────
+  replayRecentSessions(activeThresholdMs) {
+    const cutoff = Date.now() - activeThresholdMs;
+    const recent = this.stmtRecentSessions.all(cutoff);
+    if (recent.length === 0)
+      return;
+    console.log(`[opencode] Replaying ${recent.length} recent session(s)`);
+    for (const session of recent) {
+      this.sessions.set(session.id, parseOpenCodeSession(session));
+      this.replaySession(session.id);
+    }
+  }
+  replaySession(sessionId) {
+    const messages = this.stmtMessagesBySession.all(sessionId);
+    for (const msg of messages) {
+      this.processMessageRow(msg);
+      if (msg.time_updated > this.lastMessageTs)
+        this.lastMessageTs = msg.time_updated;
+    }
+    const parts = this.stmtPartsBySession.all(sessionId);
+    for (const part of parts) {
+      this.processPartRow(part);
+      if (part.time_created > this.lastPartCreatedTs)
+        this.lastPartCreatedTs = part.time_created;
+    }
+  }
+  // ── Live polling ───────────────────────────────────────────────────────────
+  poll() {
+    if (!this.db)
+      return;
+    try {
+      const newSessions = this.stmtRecentSessions.all(Date.now() - 6e4);
+      for (const row of newSessions) {
+        if (!this.sessions.has(row.id)) {
+          this.sessions.set(row.id, parseOpenCodeSession(row));
+          console.log(`[opencode] New session: ${row.id.slice(0, 20)} (${row.directory})`);
+        }
+      }
+      const newMessages = this.stmtNewMessages.all(this.lastMessageTs);
+      for (const msg of newMessages) {
+        this.processMessageRow(msg);
+        if (msg.time_updated > this.lastMessageTs)
+          this.lastMessageTs = msg.time_updated;
+      }
+      const newParts = this.stmtNewParts.all(this.lastPartCreatedTs);
+      for (const part of newParts) {
+        this.processPartRow(part);
+        if (part.time_created > this.lastPartCreatedTs)
+          this.lastPartCreatedTs = part.time_created;
+      }
+    } catch (err) {
+      console.error("[opencode] Poll error:", err);
+    }
+  }
+  // ── Row processors ─────────────────────────────────────────────────────────
+  processMessageRow(row) {
+    let data;
+    try {
+      data = JSON.parse(row.data);
+    } catch {
+      return;
+    }
+    this.messages.set(row.id, data);
+    const seenKey = "msg:" + row.id;
+    if (this.seenIds.has(seenKey))
+      return;
+    this.seenIds.add(seenKey);
+    const activity = this.parser.parseTokenUsage(data);
+    if (!activity)
+      return;
+    const sessionInfo = this.getSessionInfo(row.session_id);
+    this.stateManager.processMessage(this.prefixed(row.session_id), activity, sessionInfo);
+  }
+  processPartRow(row) {
+    let data;
+    try {
+      data = JSON.parse(row.data);
+    } catch {
+      return;
+    }
+    const messageData = this.messages.get(row.message_id);
+    if (data.type === "step-start" || data.type === "step-finish") {
+      if (this.seenIds.has(row.id))
+        return;
+      this.seenIds.add(row.id);
+      this.stateManager.heartbeat(this.prefixed(row.session_id));
+      return;
+    }
+    if (data.type === "tool" && data.callID) {
+      if (this.seenCallIds.has(data.callID))
+        return;
+      this.seenCallIds.add(data.callID);
+    } else {
+      if (this.seenIds.has(row.id))
+        return;
+      this.seenIds.add(row.id);
+    }
+    const activity = this.parser.parsePart(data, messageData);
+    if (!activity)
+      return;
+    const sessionInfo = this.getSessionInfo(row.session_id);
+    this.stateManager.processMessage(this.prefixed(row.session_id), activity, sessionInfo);
+  }
+  // ── Helpers ────────────────────────────────────────────────────────────────
+  getSessionInfo(sessionId) {
+    const cached = this.sessions.get(sessionId);
+    if (cached)
+      return cached;
+    this.loadAllSessions();
+    return this.sessions.get(sessionId) ?? this.fallbackSession();
+  }
+  prefixed(id) {
+    return id.startsWith("oc:") ? id : `oc:${id}`;
+  }
+  fallbackSession() {
+    return {
+      projectPath: "opencode",
+      projectName: "opencode",
+      isSubagent: false,
+      projectDir: "opencode",
+      parentSessionId: null
+    };
+  }
+};
+export {
+  OpenCodeWatcher
+};