@foothill/agent-move 1.0.6

package/packages/server/dist/index.js

@@ -0,0 +1,3544 @@
+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/index.js
+import { fileURLToPath } from "url";
+import { dirname, join as join6 } from "path";
+import Fastify from "fastify";
+import cors from "@fastify/cors";
+import websocket from "@fastify/websocket";
+import fastifyStatic from "@fastify/static";
+import { homedir } from "os";
+import { join } from "path";
+import chokidar from "chokidar";
+import { stat as stat2, open } from "fs/promises";
+import { join as join4, basename } from "path";
+import { existsSync } from "fs";
+import { join as join2 } from "path";
+import { readdir, stat } from "fs/promises";
+import { join as join3 } from "path";
+import chokidar2 from "chokidar";
+import { homedir as homedir2 } from "os";
+import { join as join5 } from "path";
+import { existsSync as existsSync2 } from "fs";
+import { EventEmitter as EventEmitter2 } from "events";
+import { EventEmitter } from "events";
+import { execSync } from "child_process";
+import { EventEmitter as EventEmitter3 } from "events";
+import { randomUUID } from "crypto";
+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 fileURLToPath2 = require_file_uri_to_path();
+    var join7 = path.join;
+    var dirname2 = 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 = join7.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 = fileURLToPath2(fileName);
+      }
+      return fileName;
+    };
+    exports.getRoot = function getRoot(file) {
+      var dir = dirname2(file), prev;
+      while (true) {
+        if (dir === ".") {
+          dir = process.cwd();
+        }
+        if (exists(join7(dir, "package.json")) || exists(join7(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 = join7(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 open2() {
+          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 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"
+};
+var JsonlParser = class {
+  parseLine(line) {
+    try {
+      const msg = JSON.parse(line);
+      return this.extractActivity(msg);
+    } catch {
+      return null;
+    }
+  }
+  extractActivity(msg) {
+    const sessionId = msg.sessionId;
+    if (msg.toolUseResult?.routing?.sender) {
+      const agentName = msg.toolUseResult.routing.sender;
+      if (msg.message?.role === "user" || msg.type === "user") {
+        return {
+          type: "text",
+          text: void 0,
+          agentName,
+          sessionId
+        };
+      }
+    }
+    if ((msg.message?.role === "user" || msg.type === "user") && msg.message?.content) {
+      const content2 = typeof msg.message.content === "string" ? msg.message.content : Array.isArray(msg.message.content) ? msg.message.content.map((b) => b.text ?? "").join("") : "";
+      if (content2.includes("<teammate-message")) {
+        const senderMatch = content2.match(/<teammate-message\s+teammate_id="([^"]+)"/);
+        if (senderMatch) {
+          return {
+            type: "text",
+            text: void 0,
+            messageSender: senderMatch[1],
+            sessionId
+          };
+        }
+      }
+    }
+    if (!msg.message?.content || !Array.isArray(msg.message.content)) {
+      return null;
+    }
+    if (msg.message.role !== "assistant") {
+      return null;
+    }
+    const content = msg.message.content;
+    for (const block of content) {
+      if (block.type === "tool_use") {
+        const toolBlock = block;
+        return {
+          type: "tool_use",
+          toolName: toolBlock.name,
+          toolInput: toolBlock.input,
+          model: msg.message.model,
+          sessionId,
+          inputTokens: msg.message.usage?.input_tokens,
+          outputTokens: msg.message.usage?.output_tokens,
+          cacheReadTokens: msg.message.usage?.cache_read_input_tokens,
+          cacheCreationTokens: msg.message.usage?.cache_creation_input_tokens
+        };
+      }
+    }
+    for (const block of content) {
+      if (block.type === "text") {
+        const textBlock = block;
+        const text = textBlock.text.trim();
+        if (text.length > 0 && text.length < 200) {
+          return {
+            type: "text",
+            text,
+            model: msg.message.model,
+            sessionId,
+            inputTokens: msg.message.usage?.input_tokens,
+            outputTokens: msg.message.usage?.output_tokens,
+            cacheReadTokens: msg.message.usage?.cache_read_input_tokens,
+            cacheCreationTokens: msg.message.usage?.cache_creation_input_tokens
+          };
+        }
+      }
+    }
+    if (msg.message.usage) {
+      return {
+        type: "token_usage",
+        inputTokens: msg.message.usage.input_tokens,
+        outputTokens: msg.message.usage.output_tokens,
+        cacheReadTokens: msg.message.usage.cache_read_input_tokens,
+        cacheCreationTokens: msg.message.usage.cache_creation_input_tokens,
+        model: msg.message.model,
+        sessionId
+      };
+    }
+    return null;
+  }
+};
+var ClaudePaths = class {
+  /**
+   * Parse a JSONL session file path to extract project info.
+   * Paths look like: ~/.claude/projects/{encoded-project-path}/{sessionId}.jsonl
+   * Subagent paths may be nested deeper.
+   */
+  parseSessionPath(filePath) {
+    const normalized = filePath.replace(/\\/g, "/");
+    const parts = normalized.split("/");
+    const projectsIdx = parts.indexOf("projects");
+    if (projectsIdx === -1 || projectsIdx + 1 >= parts.length) {
+      return {
+        projectPath: "unknown",
+        projectName: "Unknown",
+        isSubagent: false,
+        projectDir: "unknown",
+        parentSessionId: null
+      };
+    }
+    const encodedProjectName = parts[projectsIdx + 1];
+    const projectName = this.decodeProjectName(encodedProjectName);
+    const depthAfterProject = parts.length - projectsIdx - 2;
+    const isSubagent = depthAfterProject > 1;
+    const parentSessionId = isSubagent ? parts[projectsIdx + 2] : null;
+    return {
+      projectPath: encodedProjectName,
+      projectName,
+      isSubagent,
+      projectDir: encodedProjectName,
+      parentSessionId
+    };
+  }
+  /**
+   * Decode Claude Code's encoded project path format.
+   * Resolves against the filesystem to correctly handle dashes in folder names.
+   * e.g., "C--projects-fts-temp-agent-move" → "agent-move"
+   */
+  decodeProjectName(encoded) {
+    const resolved = this.resolveToFolderName(encoded);
+    if (resolved)
+      return resolved;
+    const parts = encoded.split("-").filter((p) => p.length > 0);
+    if (parts.length <= 2)
+      return parts.join("/");
+    return parts.slice(-2).join("/");
+  }
+  /**
+   * Greedily resolve the encoded path against the filesystem.
+   * Tries each dash-segment as a directory, joining multiple segments
+   * when a single one doesn't exist (to handle dashes in folder names).
+   */
+  resolveToFolderName(encoded) {
+    try {
+      let root;
+      let rest;
+      const driveMatch = encoded.match(/^([A-Za-z])--(.*)/);
+      const unixMatch = !driveMatch && encoded.match(/^-(.*)/);
+      if (driveMatch) {
+        root = driveMatch[1] + ":/";
+        rest = driveMatch[2];
+      } else if (unixMatch) {
+        root = "/";
+        rest = unixMatch[1];
+      } else {
+        return null;
+      }
+      const parts = rest.split("-").filter(Boolean);
+      let currentPath = root;
+      let lastName = "";
+      let i = 0;
+      while (i < parts.length) {
+        let found = false;
+        const maxLen = Math.min(parts.length - i, 6);
+        for (let len = 1; len <= maxLen; len++) {
+          const segment = parts.slice(i, i + len).join("-");
+          for (const prefix of ["", "."]) {
+            const testPath = join2(currentPath, prefix + segment);
+            if (existsSync(testPath)) {
+              currentPath = testPath;
+              lastName = prefix + segment;
+              i += len;
+              found = true;
+              break;
+            }
+          }
+          if (found)
+            break;
+        }
+        if (!found)
+          break;
+      }
+      return lastName || null;
+    } catch {
+      return null;
+    }
+  }
+};
+var claudePaths = new ClaudePaths();
+var SessionScanner = class {
+  claudeHome;
+  constructor(claudeHome) {
+    this.claudeHome = claudeHome;
+  }
+  /** Find all recently active JSONL session files */
+  async scan() {
+    const results = [];
+    const projectsDir = join3(this.claudeHome, "projects");
+    try {
+      const projects = await readdir(projectsDir);
+      const now = Date.now();
+      for (const project of projects) {
+        const projectDir = join3(projectsDir, project);
+        try {
+          const projectStat = await stat(projectDir);
+          if (!projectStat.isDirectory())
+            continue;
+          const files = await readdir(projectDir);
+          let newestFile = null;
+          let newestMtime = 0;
+          for (const file of files) {
+            if (!file.endsWith(".jsonl"))
+              continue;
+            const filePath = join3(projectDir, file);
+            try {
+              const fileStat = await stat(filePath);
+              if (now - fileStat.mtimeMs < config.activeThresholdMs) {
+                if (fileStat.mtimeMs > newestMtime) {
+                  newestMtime = fileStat.mtimeMs;
+                  newestFile = filePath;
+                }
+              }
+            } catch {
+            }
+          }
+          if (newestFile) {
+            results.push(newestFile);
+          }
+        } catch {
+        }
+      }
+    } catch {
+      console.log("No projects directory found \u2014 will wait for new sessions");
+    }
+    return results;
+  }
+};
+var FileWatcher = class {
+  claudeHome;
+  stateManager;
+  watcher = null;
+  byteOffsets = /* @__PURE__ */ new Map();
+  parser = new JsonlParser();
+  /** Per-file lock to prevent concurrent processFile calls for the same file */
+  fileLocks = /* @__PURE__ */ new Map();
+  constructor(claudeHome, stateManager) {
+    this.claudeHome = claudeHome;
+    this.stateManager = stateManager;
+  }
+  async start() {
+    const scanner = new SessionScanner(this.claudeHome);
+    const existingFiles = await scanner.scan();
+    for (const file of existingFiles) {
+      await this.processFile(file);
+    }
+    const pattern = join4(this.claudeHome, "projects", "**", "*.jsonl");
+    this.watcher = chokidar.watch(pattern, {
+      persistent: true,
+      ignoreInitial: true,
+      awaitWriteFinish: { stabilityThreshold: 200, pollInterval: 50 }
+    });
+    this.watcher.on("add", (filePath) => {
+      console.log(`New session file: ${filePath}`);
+      this.processFile(filePath);
+    });
+    this.watcher.on("change", (filePath) => {
+      this.processFile(filePath);
+    });
+    console.log(`Watching for JSONL files in ${this.claudeHome}/projects/`);
+  }
+  stop() {
+    this.watcher?.close();
+    this.byteOffsets.clear();
+    this.fileLocks.clear();
+  }
+  processFile(filePath) {
+    const prev = this.fileLocks.get(filePath) ?? Promise.resolve();
+    const next = prev.then(() => this.doProcessFile(filePath)).catch(() => {
+    }).finally(() => {
+      if (this.fileLocks.get(filePath) === next) {
+        this.fileLocks.delete(filePath);
+      }
+    });
+    this.fileLocks.set(filePath, next);
+  }
+  async doProcessFile(filePath) {
+    try {
+      const fileStats = await stat2(filePath);
+      const currentOffset = this.byteOffsets.get(filePath) ?? 0;
+      if (fileStats.size <= currentOffset)
+        return;
+      const handle = await open(filePath, "r");
+      try {
+        const buffer = Buffer.alloc(fileStats.size - currentOffset);
+        await handle.read(buffer, 0, buffer.length, currentOffset);
+        this.byteOffsets.set(filePath, fileStats.size);
+        const newContent = buffer.toString("utf-8");
+        const lines = newContent.split("\n").filter((l) => l.trim());
+        const sessionId = basename(filePath, ".jsonl");
+        const sessionInfo = claudePaths.parseSessionPath(filePath);
+        let hadParsedActivity = false;
+        for (const line of lines) {
+          const parsed = this.parser.parseLine(line);
+          if (parsed) {
+            hadParsedActivity = true;
+            this.stateManager.processMessage(sessionId, parsed, sessionInfo);
+          }
+        }
+        if (!hadParsedActivity && lines.length > 0) {
+          this.stateManager.heartbeat(sessionId);
+        }
+      } finally {
+        await handle.close();
+      }
+    } catch (err) {
+      if (err.code !== "ENOENT") {
+        console.error(`Error processing ${filePath}:`, err);
+      }
+    }
+  }
+};
+var import_better_sqlite3 = __toESM(require_lib(), 1);
+function getOpenCodeDbPath() {
+  const home = homedir2();
+  const candidates = [
+    join5(home, ".local", "share", "opencode", "opencode.db"),
+    // Windows fallback via LOCALAPPDATA
+    ...process.env.LOCALAPPDATA ? [join5(process.env.LOCALAPPDATA, "opencode", "opencode.db")] : [],
+    join5(home, ".opencode", "opencode.db")
+  ];
+  for (const candidate of candidates) {
+    if (existsSync2(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 DEFAULT_ANOMALY_CONFIG = {
+  tokenVelocityThreshold: 1e5,
+  retryLoopThreshold: 5,
+  stuckTimeoutSeconds: 120
+};
+var TOOL_ZONE_MAP = {
+  // Files zone
+  Read: "files",
+  Write: "files",
+  Edit: "files",
+  Patch: "files",
+  Glob: "files",
+  NotebookEdit: "files",
+  // Terminal zone
+  Bash: "terminal",
+  // Search zone
+  Grep: "search",
+  WebSearch: "search",
+  // Web zone
+  WebFetch: "web",
+  mcp__chrome_devtools__navigate_page: "web",
+  mcp__chrome_devtools__click: "web",
+  mcp__chrome_devtools__fill: "web",
+  mcp__chrome_devtools__take_screenshot: "web",
+  mcp__chrome_devtools__take_snapshot: "web",
+  mcp__chrome_devtools__evaluate_script: "web",
+  // Thinking zone
+  EnterPlanMode: "thinking",
+  ExitPlanMode: "thinking",
+  AskUserQuestion: "thinking",
+  // Messaging zone
+  SendMessage: "messaging",
+  // Tasks zone
+  TaskCreate: "tasks",
+  TaskUpdate: "tasks",
+  TaskList: "tasks",
+  TaskGet: "tasks",
+  TodoRead: "tasks",
+  TodoWrite: "tasks",
+  // Spawn zone
+  Agent: "spawn",
+  TeamCreate: "spawn",
+  TeamDelete: "spawn"
+};
+function getZoneForTool(toolName) {
+  if (toolName.startsWith("mcp__"))
+    return "web";
+  return TOOL_ZONE_MAP[toolName] ?? "thinking";
+}
+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 AGENT_PALETTES = [
+  { name: "blue", body: 4886745, outline: 2906762, highlight: 8042741, eye: 16777215, skin: 16767916 },
+  { name: "green", body: 5025616, outline: 3046706, highlight: 8505220, eye: 16777215, skin: 16767916 },
+  { name: "red", body: 15037299, outline: 12986408, highlight: 16764370, eye: 16777215, skin: 16767916 },
+  { name: "purple", body: 11225020, outline: 6953882, highlight: 13538264, eye: 16777215, skin: 16767916 },
+  { name: "orange", body: 16750592, outline: 15094016, highlight: 16764032, eye: 16777215, skin: 16767916 },
+  { name: "cyan", body: 2541274, outline: 33679, highlight: 8445674, eye: 16777215, skin: 16767916 },
+  { name: "pink", body: 15753874, outline: 12720219, highlight: 16301008, eye: 16777215, skin: 16767916 },
+  { name: "teal", body: 2533018, outline: 26972, highlight: 8440772, eye: 16777215, skin: 16767916 },
+  { name: "amber", body: 16761095, outline: 16748288, highlight: 16769154, eye: 3355443, skin: 16767916 },
+  { name: "indigo", body: 6056896, outline: 2635155, highlight: 10463450, eye: 16777215, skin: 16767916 },
+  { name: "lime", body: 10275941, outline: 5606191, highlight: 12968357, eye: 3355443, skin: 16767916 },
+  { name: "brown", body: 9268835, outline: 5125166, highlight: 12364452, eye: 16777215, skin: 16767916 }
+];
+function getProjectColorIndex(projectPath) {
+  let hash = 0;
+  for (let i = 0; i < projectPath.length; i++) {
+    hash = (hash << 5) - hash + projectPath.charCodeAt(i) | 0;
+  }
+  return Math.abs(hash) % AGENT_PALETTES.length;
+}
+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 = chokidar2.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
+    };
+  }
+};
+var COOLDOWN_MS = 6e4;
+var TOKEN_WINDOW_MS = 6e4;
+var anomalyIdCounter = 0;
+var AnomalyDetector = class extends EventEmitter {
+  agents = /* @__PURE__ */ new Map();
+  agentNames = /* @__PURE__ */ new Map();
+  config;
+  stuckInterval = null;
+  constructor(config2) {
+    super();
+    this.config = { ...DEFAULT_ANOMALY_CONFIG, ...config2 };
+  }
+  getState(agentId) {
+    let state = this.agents.get(agentId);
+    if (!state) {
+      state = {
+        lastTools: [],
+        tokenSamples: [],
+        lastActivityAt: Date.now(),
+        lastAlertAt: /* @__PURE__ */ new Map()
+      };
+      this.agents.set(agentId, state);
+    }
+    return state;
+  }
+  setAgentName(agentId, name) {
+    this.agentNames.set(agentId, name);
+  }
+  checkToolUse(agentId, toolName) {
+    const state = this.getState(agentId);
+    state.lastActivityAt = Date.now();
+    state.lastTools.push(toolName);
+    if (state.lastTools.length > 20)
+      state.lastTools.shift();
+    const threshold = this.config.retryLoopThreshold;
+    if (state.lastTools.length >= threshold) {
+      const recent = state.lastTools.slice(-threshold);
+      if (recent.every((t) => t === recent[0])) {
+        this.alert(agentId, "retry-loop", `${recent[0]} called ${threshold}+ times consecutively`, "warning", {
+          tool: recent[0],
+          consecutiveCount: threshold
+        });
+      }
+    }
+  }
+  checkTokenUsage(agentId, inputTokens, outputTokens) {
+    const state = this.getState(agentId);
+    state.lastActivityAt = Date.now();
+    const now = Date.now();
+    const total = inputTokens + outputTokens;
+    state.tokenSamples.push({ ts: now, total });
+    const cutoff = now - TOKEN_WINDOW_MS;
+    while (state.tokenSamples.length > 0 && state.tokenSamples[0].ts < cutoff) {
+      state.tokenSamples.shift();
+    }
+    if (state.tokenSamples.length >= 2) {
+      const totalTokens = state.tokenSamples.reduce((sum, s) => sum + s.total, 0);
+      const elapsed = (state.tokenSamples[state.tokenSamples.length - 1].ts - state.tokenSamples[0].ts) / 6e4;
+      if (elapsed > 0.1) {
+        const velocity = totalTokens / elapsed;
+        if (velocity >= this.config.tokenVelocityThreshold) {
+          this.alert(agentId, "token-spike", `Token velocity ${Math.round(velocity)}/min exceeds threshold`, "critical", {
+            velocity: Math.round(velocity),
+            threshold: this.config.tokenVelocityThreshold
+          });
+        }
+      }
+    }
+  }
+  checkStuck(agentId, lastActivityAt) {
+    const state = this.getState(agentId);
+    const elapsed = (Date.now() - lastActivityAt) / 1e3;
+    if (elapsed >= this.config.stuckTimeoutSeconds) {
+      this.alert(agentId, "stuck-agent", `No activity for ${Math.round(elapsed)}s`, "warning", {
+        idleSeconds: Math.round(elapsed),
+        threshold: this.config.stuckTimeoutSeconds
+      });
+    }
+    state.lastActivityAt = lastActivityAt;
+  }
+  startStuckDetection(getActiveAgents) {
+    if (this.stuckInterval)
+      return;
+    this.stuckInterval = setInterval(() => {
+      for (const agent of getActiveAgents()) {
+        if (!agent.isIdle) {
+          this.checkStuck(agent.id, agent.lastActivityAt);
+        }
+      }
+    }, 3e4);
+  }
+  removeAgent(agentId) {
+    this.agents.delete(agentId);
+    this.agentNames.delete(agentId);
+  }
+  alert(agentId, kind, message, severity, details) {
+    const state = this.getState(agentId);
+    const now = Date.now();
+    const lastAlert = state.lastAlertAt.get(kind) ?? 0;
+    if (now - lastAlert < COOLDOWN_MS)
+      return;
+    state.lastAlertAt.set(kind, now);
+    const anomaly = {
+      id: `anomaly-${++anomalyIdCounter}`,
+      agentId,
+      agentName: this.agentNames.get(agentId) ?? agentId.slice(0, 10),
+      kind,
+      message,
+      severity,
+      timestamp: now,
+      details
+    };
+    this.emit("anomaly", anomaly);
+  }
+  dispose() {
+    if (this.stuckInterval) {
+      clearInterval(this.stuckInterval);
+      this.stuckInterval = null;
+    }
+  }
+};
+var MAX_DURATION_SAMPLES = 50;
+var ToolChainTracker = class {
+  lastTool = /* @__PURE__ */ new Map();
+  transitions = /* @__PURE__ */ new Map();
+  toolCounts = /* @__PURE__ */ new Map();
+  // Hook-sourced outcome tracking
+  toolSuccesses = /* @__PURE__ */ new Map();
+  toolFailures = /* @__PURE__ */ new Map();
+  toolDurationSamples = /* @__PURE__ */ new Map();
+  /** Per-agent pending tool start: agentId → {tool, startTime} */
+  pendingStart = /* @__PURE__ */ new Map();
+  recordToolUse(agentId, toolName) {
+    this.toolCounts.set(toolName, (this.toolCounts.get(toolName) ?? 0) + 1);
+    const prev = this.lastTool.get(agentId);
+    this.lastTool.set(agentId, toolName);
+    if (prev && prev !== toolName) {
+      const key = `${prev}\u2192${toolName}`;
+      this.transitions.set(key, (this.transitions.get(key) ?? 0) + 1);
+    }
+  }
+  /** Called from hookPreToolUse — records when a tool started for duration tracking */
+  recordToolStart(agentId, toolName) {
+    this.pendingStart.set(agentId, { tool: toolName, startTime: Date.now() });
+  }
+  /** Called from hookPostToolUse — records outcome and duration */
+  recordToolOutcome(agentId, success) {
+    const pending = this.pendingStart.get(agentId);
+    if (!pending)
+      return;
+    this.pendingStart.delete(agentId);
+    const { tool, startTime } = pending;
+    const duration = Date.now() - startTime;
+    if (success) {
+      this.toolSuccesses.set(tool, (this.toolSuccesses.get(tool) ?? 0) + 1);
+    } else {
+      this.toolFailures.set(tool, (this.toolFailures.get(tool) ?? 0) + 1);
+    }
+    let samples = this.toolDurationSamples.get(tool);
+    if (!samples) {
+      samples = [];
+      this.toolDurationSamples.set(tool, samples);
+    }
+    samples.push(duration);
+    if (samples.length > MAX_DURATION_SAMPLES)
+      samples.shift();
+  }
+  resetAgent(agentId) {
+    this.lastTool.delete(agentId);
+    this.pendingStart.delete(agentId);
+  }
+  /** Migrate per-agent state from an old ID to a new canonical ID (used on agent merge). */
+  migrateAgent(fromId, toId) {
+    const last = this.lastTool.get(fromId);
+    if (last !== void 0) {
+      if (!this.lastTool.has(toId))
+        this.lastTool.set(toId, last);
+      this.lastTool.delete(fromId);
+    }
+    const pending = this.pendingStart.get(fromId);
+    if (pending !== void 0) {
+      if (!this.pendingStart.has(toId))
+        this.pendingStart.set(toId, pending);
+      this.pendingStart.delete(fromId);
+    }
+  }
+  reset() {
+    this.lastTool.clear();
+    this.transitions.clear();
+    this.toolCounts.clear();
+    this.toolSuccesses.clear();
+    this.toolFailures.clear();
+    this.toolDurationSamples.clear();
+    this.pendingStart.clear();
+  }
+  hasActiveAgents() {
+    return this.lastTool.size > 0;
+  }
+  getSnapshot() {
+    const transitions = [];
+    for (const [key, count] of this.transitions) {
+      const [from, to] = key.split("\u2192");
+      transitions.push({ from, to, count });
+    }
+    transitions.sort((a, b) => b.count - a.count);
+    const toolCounts = {};
+    for (const [tool, count] of this.toolCounts)
+      toolCounts[tool] = count;
+    const toolSuccesses = {};
+    for (const [tool, count] of this.toolSuccesses)
+      toolSuccesses[tool] = count;
+    const toolFailures = {};
+    for (const [tool, count] of this.toolFailures)
+      toolFailures[tool] = count;
+    const toolAvgDuration = {};
+    for (const [tool, samples] of this.toolDurationSamples) {
+      if (samples.length > 0) {
+        toolAvgDuration[tool] = Math.round(samples.reduce((a, b) => a + b, 0) / samples.length);
+      }
+    }
+    return {
+      transitions,
+      tools: Array.from(this.toolCounts.keys()).sort(),
+      toolCounts,
+      toolSuccesses,
+      toolFailures,
+      toolAvgDuration
+    };
+  }
+};
+var TaskGraphManager = class {
+  tasks = /* @__PURE__ */ new Map();
+  /** Per-agent-root counters to match Claude's sequential task IDs per team */
+  counters = /* @__PURE__ */ new Map();
+  /**
+   * Build a scoped key from rootSessionId + short task ID.
+   * This prevents cross-team ID collisions in the global map.
+   */
+  scopedKey(root, shortId) {
+    return `${root}::${shortId}`;
+  }
+  /**
+   * Process a tool use that may affect the task graph.
+   * Returns true if the graph changed.
+   */
+  processToolUse(agentId, agentName, toolName, toolInput, projectName, rootSessionId) {
+    const root = rootSessionId ?? agentId;
+    if (toolName === "TaskCreate") {
+      return this.handleCreate(agentId, agentName, toolInput, projectName, root);
+    }
+    if (toolName === "TaskUpdate") {
+      return this.handleUpdate(agentId, agentName, toolInput, projectName, root);
+    }
+    return false;
+  }
+  handleCreate(agentId, agentName, toolInput, projectName, root) {
+    const input = toolInput;
+    if (!input)
+      return false;
+    const count = (this.counters.get(root) ?? 0) + 1;
+    this.counters.set(root, count);
+    const shortId = String(count);
+    const key = this.scopedKey(root, shortId);
+    const subject = input.subject ?? `Task ${shortId}`;
+    const description = input.description;
+    const node = {
+      id: shortId,
+      subject,
+      description,
+      status: "pending",
+      owner: void 0,
+      agentId,
+      agentName,
+      projectName,
+      blocks: [],
+      blockedBy: [],
+      timestamp: Date.now(),
+      _rootKey: key
+    };
+    this.tasks.set(key, node);
+    return true;
+  }
+  handleUpdate(agentId, agentName, toolInput, projectName, root) {
+    const input = toolInput;
+    if (!input)
+      return false;
+    const taskId = input.taskId;
+    if (!taskId)
+      return false;
+    const key = this.scopedKey(root, taskId);
+    let task = this.tasks.get(key);
+    if (!task) {
+      task = {
+        id: taskId,
+        subject: `Task ${taskId}`,
+        status: "pending",
+        agentId,
+        agentName,
+        projectName,
+        blocks: [],
+        blockedBy: [],
+        timestamp: Date.now(),
+        _rootKey: key
+      };
+      this.tasks.set(key, task);
+    }
+    let changed = false;
+    if (input.status !== void 0) {
+      const newStatus = input.status;
+      if (["pending", "in_progress", "completed", "deleted"].includes(newStatus)) {
+        task.status = newStatus;
+        changed = true;
+      }
+    }
+    if (input.owner !== void 0) {
+      task.owner = input.owner;
+      changed = true;
+    }
+    if (input.subject !== void 0) {
+      task.subject = input.subject;
+      changed = true;
+    }
+    if (input.description !== void 0) {
+      task.description = input.description;
+      changed = true;
+    }
+    if (input.addBlocks) {
+      const blocks = input.addBlocks;
+      for (const id of blocks) {
+        if (!task.blocks.includes(id)) {
+          task.blocks.push(id);
+          changed = true;
+        }
+        const otherKey = this.scopedKey(root, id);
+        const other = this.tasks.get(otherKey);
+        if (other && !other.blockedBy.includes(taskId)) {
+          other.blockedBy.push(taskId);
+          changed = true;
+        }
+      }
+    }
+    if (input.addBlockedBy) {
+      const blockedBy = input.addBlockedBy;
+      for (const id of blockedBy) {
+        if (!task.blockedBy.includes(id)) {
+          task.blockedBy.push(id);
+          changed = true;
+        }
+        const otherKey = this.scopedKey(root, id);
+        const other = this.tasks.get(otherKey);
+        if (other && !other.blocks.includes(taskId)) {
+          other.blocks.push(taskId);
+          changed = true;
+        }
+      }
+    }
+    return changed;
+  }
+  /**
+   * Mark a task as completed (hook-sourced — TaskCompleted event).
+   * Returns true if the status actually changed.
+   */
+  processTaskCompleted(taskId, root) {
+    const key = this.scopedKey(root, taskId);
+    const task = this.tasks.get(key);
+    if (!task || task.status === "completed")
+      return false;
+    task.status = "completed";
+    return true;
+  }
+  /**
+   * Remove all tasks created by a given agent.
+   * Cleans up dependency references from remaining tasks.
+   * Returns true if any tasks were removed.
+   */
+  removeAgentTasks(agentId) {
+    const toRemove = /* @__PURE__ */ new Set();
+    for (const [key, task] of this.tasks) {
+      if (task.agentId === agentId)
+        toRemove.add(key);
+    }
+    if (toRemove.size === 0)
+      return false;
+    const removedKeys = /* @__PURE__ */ new Set();
+    for (const key of toRemove) {
+      removedKeys.add(key);
+      this.tasks.delete(key);
+    }
+    for (const [taskKey, task] of this.tasks) {
+      const root = taskKey.split("::")[0];
+      task.blocks = task.blocks.filter((id) => !removedKeys.has(`${root}::${id}`));
+      task.blockedBy = task.blockedBy.filter((id) => !removedKeys.has(`${root}::${id}`));
+    }
+    return true;
+  }
+  getSnapshot() {
+    const live = Array.from(this.tasks.values()).filter((t) => t.status !== "deleted");
+    const rootOf = (key) => key.split("::")[0];
+    const shortToRoot = /* @__PURE__ */ new Map();
+    for (const t of live) {
+      const root = rootOf(t._rootKey);
+      if (!shortToRoot.has(root))
+        shortToRoot.set(root, /* @__PURE__ */ new Map());
+      shortToRoot.get(root).set(t.id, t._rootKey);
+    }
+    return {
+      tasks: live.map((t) => {
+        const lookup = shortToRoot.get(rootOf(t._rootKey));
+        return {
+          ...t,
+          blocks: t.blocks.map((id) => lookup?.get(id) ?? id),
+          blockedBy: t.blockedBy.map((id) => lookup?.get(id) ?? id)
+        };
+      })
+    };
+  }
+};
+function resolveAgentId(sessionToAgent, sessionId) {
+  return sessionToAgent.get(sessionId) ?? sessionId;
+}
+function transferAndRemove(deps, sourceId, target, redirectSessionId) {
+  const { agents, hiddenAgents, sessionToAgent, toolChainTracker, clearTimers } = deps;
+  const source = agents.get(sourceId);
+  if (source) {
+    target.totalInputTokens += source.totalInputTokens;
+    target.totalOutputTokens += source.totalOutputTokens;
+    target.cacheReadTokens += source.cacheReadTokens;
+    target.cacheCreationTokens += source.cacheCreationTokens;
+  }
+  agents.delete(sourceId);
+  hiddenAgents.delete(sourceId);
+  clearTimers(sourceId);
+  toolChainTracker.migrateAgent(sourceId, target.id);
+  sessionToAgent.set(redirectSessionId, target.id);
+  target.isIdle = false;
+  target.isDone = false;
+  target.lastActivityAt = Date.now();
+}
+function mergeIntoNamed(deps, hiddenId, agentName) {
+  const { agents, namedAgentMap } = deps;
+  const hidden = agents.get(hiddenId);
+  if (!hidden)
+    return null;
+  const key = `${hidden.rootSessionId}:${agentName}`;
+  const existingId = namedAgentMap.get(key);
+  if (!existingId || existingId === hiddenId)
+    return null;
+  const existing = agents.get(existingId);
+  if (!existing)
+    return null;
+  transferAndRemove(deps, hiddenId, existing, hiddenId);
+  console.log(`Merged session ${hiddenId.slice(0, 12)}\u2026 into agent "${agentName}" (${existingId.slice(0, 12)}\u2026)`);
+  return existing;
+}
+function promoteAgent(deps, agentId) {
+  const { agents, hiddenAgents, identityTimers, recordTimeline, emit } = deps;
+  hiddenAgents.delete(agentId);
+  const idTimer = identityTimers.get(agentId);
+  if (idTimer)
+    clearTimeout(idTimer);
+  identityTimers.delete(agentId);
+  const agent = agents.get(agentId);
+  if (!agent)
+    return;
+  console.log(`Promoting hidden agent ${agentId.slice(0, 12)}\u2026 (name: ${agent.agentName ?? "unknown"})`);
+  const now = Date.now();
+  const spawnEvent = { type: "agent:spawn", agent: { ...agent }, timestamp: now };
+  recordTimeline(spawnEvent);
+  emit("agent:spawn", spawnEvent);
+  const updateEvent = { type: "agent:update", agent: { ...agent }, timestamp: now };
+  recordTimeline(updateEvent);
+  emit("agent:update", updateEvent);
+}
+function determineRole(_activity, sessionInfo) {
+  if (sessionInfo.isSubagent)
+    return "subagent";
+  return "main";
+}
+function determineRoleForNamed(_parentId, pendingTeam) {
+  if (pendingTeam)
+    return "team-member";
+  return "subagent";
+}
+function findParentId(agents, projectDir) {
+  for (const [id, agent] of agents) {
+    if (agent.projectPath === projectDir && agent.role === "team-lead") {
+      return id;
+    }
+  }
+  for (const [id, agent] of agents) {
+    if (agent.projectPath === projectDir && agent.role === "main") {
+      return id;
+    }
+  }
+  for (const [id, agent] of agents) {
+    if (agent.projectPath === projectDir && agent.role !== "subagent" && agent.role !== "team-member") {
+      return id;
+    }
+  }
+  return null;
+}
+function getParentTeamName(agents, rootSessionId) {
+  for (const agent of agents.values()) {
+    if (agent.rootSessionId === rootSessionId && agent.teamName) {
+      return agent.teamName;
+    }
+  }
+  return null;
+}
+var branchCache = /* @__PURE__ */ new Map();
+var CACHE_TTL = 3e4;
+var MAX_CACHE_SIZE = 100;
+function getGitBranch(projectPath) {
+  const cached = branchCache.get(projectPath);
+  if (cached && Date.now() - cached.ts < CACHE_TTL)
+    return cached.branch;
+  try {
+    const branch = execSync("git rev-parse --abbrev-ref HEAD", {
+      cwd: projectPath,
+      timeout: 5e3,
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim() || null;
+    branchCache.set(projectPath, { branch, ts: Date.now() });
+    pruneCache();
+    return branch;
+  } catch {
+    branchCache.set(projectPath, { branch: null, ts: Date.now() });
+    return null;
+  }
+}
+function pruneCache() {
+  if (branchCache.size <= MAX_CACHE_SIZE)
+    return;
+  const entries = [...branchCache.entries()].sort((a, b) => a[1].ts - b[1].ts);
+  const toRemove = entries.slice(0, branchCache.size - MAX_CACHE_SIZE);
+  for (const [key] of toRemove)
+    branchCache.delete(key);
+}
+var LONG_RUNNING_TOOLS = /* @__PURE__ */ new Set([
+  "Bash",
+  "Agent",
+  "WebFetch",
+  "WebSearch",
+  // Tools that block waiting for user input
+  "AskUserQuestion",
+  // Reasoning / extended thinking pseudo-tool (emitted for OpenCode reasoning parts)
+  "thinking",
+  // Browser/playwright tools that wait for navigation or network
+  "mcp__playwright__browser_navigate",
+  "mcp__playwright__browser_wait_for",
+  "mcp__playwright__browser_run_code",
+  "mcp__chrome-devtools__navigate_page",
+  "mcp__chrome-devtools__wait_for",
+  "mcp__chrome-devtools__evaluate_script",
+  "mcp__chrome-devtools__performance_start_trace",
+  "mcp__chrome-devtools__performance_stop_trace"
+]);
+var USER_BLOCKING_TOOLS = /* @__PURE__ */ new Set([
+  "AskUserQuestion"
+]);
+function processToolUseActivity(deps, agent, activity, now) {
+  const { pendingTool, anomalyDetector, toolChainTracker, taskGraphManager, namedAgentMap, addHistory, summarizeToolInput, queuePendingInfo, queueRecipient, emit } = deps;
+  const agentId = agent.id;
+  const toolName = activity.toolName ?? "";
+  if (LONG_RUNNING_TOOLS.has(toolName)) {
+    pendingTool.add(agentId);
+  } else {
+    pendingTool.delete(agentId);
+  }
+  agent.isWaitingForUser = USER_BLOCKING_TOOLS.has(toolName);
+  const prevZone = agent.currentZone;
+  agent.currentTool = activity.toolName ?? null;
+  agent.currentActivity = summarizeToolInput(activity.toolInput) || null;
+  agent.currentZone = getZoneForTool(activity.toolName ?? "");
+  agent.toolUseCount++;
+  anomalyDetector.setAgentName(agentId, agent.agentName ?? agent.projectName ?? agentId.slice(0, 10));
+  anomalyDetector.checkToolUse(agentId, toolName);
+  toolChainTracker.recordToolUse(agentId, toolName);
+  if (toolName === "TaskCreate" || toolName === "TaskUpdate") {
+    const graphChanged = taskGraphManager.processToolUse(agentId, agent.agentName ?? agentId.slice(0, 10), toolName, activity.toolInput, agent.projectName, agent.rootSessionId);
+    if (graphChanged) {
+      emit("taskgraph:changed", { data: taskGraphManager.getSnapshot(), timestamp: Date.now() });
+    }
+  }
+  if (agent.projectPath) {
+    agent.gitBranch = getGitBranch(agent.projectPath);
+  }
+  if (activity.toolInput) {
+    const input = activity.toolInput;
+    const filePath = input.file_path;
+    if (filePath) {
+      agent.recentFiles = [filePath, ...agent.recentFiles.filter((f) => f !== filePath)].slice(0, 10);
+    }
+  }
+  if (activity.toolName === "EnterPlanMode") {
+    agent.isPlanning = true;
+  } else if (activity.toolName === "ExitPlanMode") {
+    agent.isPlanning = false;
+  }
+  if (activity.toolName === "TeamCreate" && activity.toolInput) {
+    agent.teamName = activity.toolInput.team_name ?? null;
+    agent.role = "team-lead";
+    if (!agent.agentName) {
+      agent.agentName = "team-lead";
+    }
+    namedAgentMap.set(`${agent.rootSessionId}:team-lead`, agentId);
+  }
+  if (activity.toolName === "SendMessage") {
+    agent.currentZone = "messaging";
+    if (activity.toolInput) {
+      const input = activity.toolInput;
+      const recipient = input.recipient;
+      agent.messageTarget = recipient ?? null;
+      const senderIdentity = agent.agentName || (agent.role === "team-lead" ? "team-lead" : null);
+      if (recipient && senderIdentity) {
+        queueRecipient(agent.rootSessionId, senderIdentity, recipient);
+      }
+    }
+  } else {
+    agent.messageTarget = null;
+  }
+  if (activity.toolName === "Agent" && activity.toolInput) {
+    const input = activity.toolInput;
+    const desc = input.description ?? input.prompt ?? "";
+    const name = input.name ?? null;
+    const teamName = input.team_name ?? null;
+    queuePendingInfo(agentId, {
+      name,
+      task: desc ? desc.length > 80 ? desc.slice(0, 77) + "..." : desc : null,
+      team: teamName
+    });
+  }
+  let diffData;
+  if (activity.toolName === "Edit" && activity.toolInput) {
+    const input = activity.toolInput;
+    const fp = input.file_path ?? "";
+    const oldStr = input.old_string ?? "";
+    const newStr = input.new_string ?? "";
+    if (fp && (oldStr || newStr)) {
+      diffData = {
+        filePath: fp,
+        oldText: oldStr.length > 500 ? oldStr.slice(0, 500) + "..." : oldStr,
+        newText: newStr.length > 500 ? newStr.slice(0, 500) + "..." : newStr
+      };
+    }
+  }
+  if (diffData) {
+    agent.recentDiffs.unshift({ ...diffData, timestamp: now });
+    if (agent.recentDiffs.length > 10)
+      agent.recentDiffs.pop();
+  }
+  addHistory(agentId, {
+    timestamp: now,
+    kind: "tool",
+    tool: activity.toolName ?? void 0,
+    toolArgs: summarizeToolInput(activity.toolInput),
+    zone: agent.currentZone,
+    diff: diffData
+  });
+  if (prevZone !== agent.currentZone) {
+    addHistory(agentId, {
+      timestamp: now,
+      kind: "zone-change",
+      zone: agent.currentZone,
+      prevZone
+    });
+  }
+  if (activity.inputTokens !== void 0 || activity.outputTokens !== void 0) {
+    agent.totalInputTokens += activity.inputTokens ?? 0;
+    agent.totalOutputTokens += activity.outputTokens ?? 0;
+    agent.cacheReadTokens += activity.cacheReadTokens ?? 0;
+    agent.cacheCreationTokens += activity.cacheCreationTokens ?? 0;
+    if (activity.inputTokens !== void 0) {
+      agent.contextTokens = activity.inputTokens + (activity.cacheReadTokens ?? 0);
+      agent.contextCacheTokens = activity.cacheReadTokens ?? 0;
+    }
+  }
+}
+function processToolActivity(deps, agent, activity, now) {
+  const { pendingTool, anomalyDetector, addHistory } = deps;
+  const agentId = agent.id;
+  switch (activity.type) {
+    case "tool_use": {
+      processToolUseActivity(deps, agent, activity, now);
+      break;
+    }
+    case "text":
+      pendingTool.delete(agentId);
+      agent.isWaitingForUser = false;
+      if (activity.text) {
+        agent.speechText = activity.text;
+        agent.currentActivity = activity.text;
+        if (!agent.taskDescription) {
+          agent.taskDescription = activity.text;
+        }
+        addHistory(agentId, {
+          timestamp: now,
+          kind: "text",
+          text: activity.text
+        });
+      }
+      if (activity.inputTokens !== void 0 || activity.outputTokens !== void 0) {
+        agent.totalInputTokens += activity.inputTokens ?? 0;
+        agent.totalOutputTokens += activity.outputTokens ?? 0;
+        agent.cacheReadTokens += activity.cacheReadTokens ?? 0;
+        agent.cacheCreationTokens += activity.cacheCreationTokens ?? 0;
+        if (activity.inputTokens !== void 0) {
+          agent.contextTokens = activity.inputTokens + (activity.cacheReadTokens ?? 0);
+          agent.contextCacheTokens = activity.cacheReadTokens ?? 0;
+        }
+      }
+      break;
+    case "token_usage":
+      pendingTool.delete(agentId);
+      agent.isWaitingForUser = false;
+      agent.totalInputTokens += activity.inputTokens ?? 0;
+      agent.totalOutputTokens += activity.outputTokens ?? 0;
+      agent.cacheReadTokens += activity.cacheReadTokens ?? 0;
+      agent.cacheCreationTokens += activity.cacheCreationTokens ?? 0;
+      if (activity.inputTokens !== void 0) {
+        agent.contextTokens = activity.inputTokens + (activity.cacheReadTokens ?? 0);
+        agent.contextCacheTokens = activity.cacheReadTokens ?? 0;
+      }
+      anomalyDetector.checkTokenUsage(agentId, activity.inputTokens ?? 0, activity.outputTokens ?? 0);
+      addHistory(agentId, {
+        timestamp: now,
+        kind: "tokens",
+        inputTokens: activity.inputTokens ?? 0,
+        outputTokens: activity.outputTokens ?? 0
+      });
+      break;
+  }
+}
+var MAX_HISTORY_PER_AGENT = 500;
+var MAX_HISTORY_AGE_MS = 30 * 60 * 1e3;
+var MAX_TIMELINE_EVENTS = 5e3;
+var IDENTITY_TIMEOUT_MS = 15e3;
+var AgentStateManager = class extends EventEmitter2 {
+  agents = /* @__PURE__ */ new Map();
+  idleTimers = /* @__PURE__ */ new Map();
+  shutdownTimers = /* @__PURE__ */ new Map();
+  /** Agents with a pending tool call (waiting for result) */
+  pendingTool = /* @__PURE__ */ new Set();
+  activityHistory = /* @__PURE__ */ new Map();
+  timelineBuffer = [];
+  /** Compound queue of subagent metadata from Agent tool calls, keyed by parent agent ID */
+  pendingSubagentInfo = /* @__PURE__ */ new Map();
+  /** Maps sessionId → canonical agent ID (for merging multiple sessions into one agent) */
+  sessionToAgent = /* @__PURE__ */ new Map();
+  /** Maps rootSessionId:agentName → canonical agent ID (scoped per terminal session) */
+  namedAgentMap = /* @__PURE__ */ new Map();
+  /** Agents that are hidden pending identity confirmation — no events emitted */
+  hiddenAgents = /* @__PURE__ */ new Set();
+  /** Timers to promote hidden agents after timeout */
+  identityTimers = /* @__PURE__ */ new Map();
+  /** Queued recipient names from SendMessage calls: rootSessionId → [{sender, recipient}] */
+  pendingRecipients = /* @__PURE__ */ new Map();
+  /** Anomaly detection for token spikes, retry loops, stuck agents */
+  anomalyDetector = new AnomalyDetector();
+  /** Tool chain transition tracking */
+  toolChainTracker = new ToolChainTracker();
+  /** Task dependency graph tracking */
+  taskGraphManager = new TaskGraphManager();
+  constructor() {
+    super();
+    this.anomalyDetector.startStuckDetection(() => Array.from(this.agents.values()).filter((a) => !this.hiddenAgents.has(a.id)).map((a) => ({ id: a.id, lastActivityAt: a.lastActivityAt, isIdle: a.isIdle })));
+  }
+  getAll() {
+    return Array.from(this.agents.values()).filter((a) => !this.hiddenAgents.has(a.id));
+  }
+  get(id) {
+    return this.agents.get(id);
+  }
+  /** Flush pending subagent/recipient queues — call after initial replay to prevent stale matches */
+  flushPendingQueues() {
+    const infoCount = Array.from(this.pendingSubagentInfo.values()).reduce((n, q) => n + q.length, 0);
+    const recipientCount = Array.from(this.pendingRecipients.values()).reduce((n, q) => n + q.length, 0);
+    this.pendingSubagentInfo.clear();
+    this.pendingRecipients.clear();
+    if (infoCount + recipientCount > 0) {
+      console.log(`Flushed ${infoCount} pending subagent infos, ${recipientCount} pending recipients from replay`);
+    }
+  }
+  getHistory(agentId) {
+    return this.activityHistory.get(agentId) ?? [];
+  }
+  getTimeline() {
+    return this.timelineBuffer;
+  }
+  getToolChainSnapshot() {
+    return this.toolChainTracker.getSnapshot();
+  }
+  getTaskGraphSnapshot() {
+    return this.taskGraphManager.getSnapshot();
+  }
+  /** Check if any named agents exist for a given root session */
+  hasNamedAgentsForRoot(rootSessionId) {
+    for (const key of this.namedAgentMap.keys()) {
+      if (key.startsWith(rootSessionId + ":"))
+        return true;
+    }
+    return false;
+  }
+  recordTimeline(event) {
+    this.timelineBuffer.push({
+      type: event.type,
+      agent: { ...event.agent },
+      timestamp: event.timestamp
+    });
+    const cutoff = Date.now() - MAX_HISTORY_AGE_MS;
+    while (this.timelineBuffer.length > 0 && this.timelineBuffer[0].timestamp < cutoff) {
+      this.timelineBuffer.shift();
+    }
+    while (this.timelineBuffer.length > MAX_TIMELINE_EVENTS) {
+      this.timelineBuffer.shift();
+    }
+  }
+  addHistory(agentId, entry) {
+    let entries = this.activityHistory.get(agentId);
+    if (!entries) {
+      entries = [];
+      this.activityHistory.set(agentId, entries);
+    }
+    entries.push(entry);
+    const cutoff = Date.now() - MAX_HISTORY_AGE_MS;
+    while (entries.length > 0 && entries[0].timestamp < cutoff) {
+      entries.shift();
+    }
+    while (entries.length > MAX_HISTORY_PER_AGENT) {
+      entries.shift();
+    }
+  }
+  summarizeToolInput(input) {
+    if (!input)
+      return "";
+    try {
+      const obj = input;
+      const summary = obj.command ?? obj.file_path ?? obj.pattern ?? obj.query ?? obj.url ?? obj.content;
+      if (typeof summary === "string") {
+        return summary.length > 120 ? summary.slice(0, 117) + "..." : summary;
+      }
+      const json = JSON.stringify(input);
+      return json.length > 120 ? json.slice(0, 117) + "..." : json;
+    } catch {
+      return "";
+    }
+  }
+  /**
+   * Resolve a sessionId to its canonical agent ID.
+   */
+  resolveAgentId(sessionId) {
+    return resolveAgentId(this.sessionToAgent, sessionId);
+  }
+  /**
+   * Compute the rootSessionId for a new agent.
+   * - Main agents are their own root.
+   * - Subagents inherit from their parent (or fallback to parentId/own sessionId).
+   */
+  computeRootSessionId(sessionId, parentId, sessionInfo) {
+    if (!sessionInfo.isSubagent)
+      return sessionId;
+    if (parentId) {
+      const parent = this.agents.get(parentId);
+      return parent?.rootSessionId ?? parentId;
+    }
+    return sessionId;
+  }
+  /** Build the deps object required by identity-manager functions. */
+  get identityDeps() {
+    return {
+      agents: this.agents,
+      hiddenAgents: this.hiddenAgents,
+      sessionToAgent: this.sessionToAgent,
+      namedAgentMap: this.namedAgentMap,
+      identityTimers: this.identityTimers,
+      toolChainTracker: this.toolChainTracker,
+      clearTimers: (id) => this.clearTimers(id),
+      recordTimeline: (e) => this.recordTimeline(e),
+      emit: (event, ...args) => this.emit(event, ...args)
+    };
+  }
+  /** Build the deps object required by activity-processor functions. */
+  get activityDeps() {
+    return {
+      pendingTool: this.pendingTool,
+      anomalyDetector: this.anomalyDetector,
+      toolChainTracker: this.toolChainTracker,
+      taskGraphManager: this.taskGraphManager,
+      namedAgentMap: this.namedAgentMap,
+      addHistory: (id, entry) => this.addHistory(id, entry),
+      summarizeToolInput: (input) => this.summarizeToolInput(input),
+      queuePendingInfo: (parentId, info) => this.queuePendingInfo(parentId, info),
+      queueRecipient: (rootSessionId, sender, recipient) => this.queueRecipient(rootSessionId, sender, recipient),
+      emit: (event, ...args) => this.emit(event, ...args)
+    };
+  }
+  /**
+   * Called when ANY new bytes appear in a session's JSONL file,
+   * even if the parser doesn't extract a meaningful activity.
+   * This keeps the agent alive during long-running tool executions
+   * (e.g. Bash commands) where the tool result writes to the file
+   * but doesn't produce a ParsedActivity.
+   */
+  heartbeat(sessionId) {
+    const canonicalId = this.resolveAgentId(sessionId);
+    const agent = this.agents.get(canonicalId);
+    if (!agent || this.hiddenAgents.has(canonicalId))
+      return;
+    if (this.pendingTool.has(canonicalId)) {
+      agent.lastActivityAt = Date.now();
+      this.resetIdleTimer(canonicalId);
+    }
+  }
+  processMessage(sessionId, activity, sessionInfo) {
+    const canonicalId = this.resolveAgentId(sessionId);
+    if (canonicalId !== sessionId) {
+      const agent2 = this.agents.get(canonicalId);
+      if (agent2) {
+        this.applyActivity(agent2, activity, Date.now(), sessionInfo);
+        return;
+      }
+    }
+    let agent = this.agents.get(canonicalId);
+    const now = Date.now();
+    if (agent && this.hiddenAgents.has(canonicalId)) {
+      let discoveredName = activity.agentName ?? null;
+      if (!discoveredName && activity.messageSender) {
+        discoveredName = this.popRecipientBySender(agent.rootSessionId, activity.messageSender);
+      }
+      if (discoveredName) {
+        const merged = mergeIntoNamed(this.identityDeps, canonicalId, discoveredName);
+        if (merged) {
+          this.applyActivity(merged, activity, now, sessionInfo);
+          return;
+        }
+        agent.agentName = discoveredName;
+        const role = determineRoleForNamed(agent.parentId, null);
+        agent.role = role;
+        agent.teamName = role === "team-member" ? agent.teamName || getParentTeamName(this.agents, agent.rootSessionId) : null;
+        this.namedAgentMap.set(`${agent.rootSessionId}:${discoveredName}`, canonicalId);
+        promoteAgent(this.identityDeps, canonicalId);
+        this.applyActivity(agent, activity, now, sessionInfo);
+        return;
+      }
+      this.applyActivitySilent(agent, activity, now, sessionInfo);
+      return;
+    }
+    if (agent && activity.agentName && !agent.agentName) {
+      const key = `${agent.rootSessionId}:${activity.agentName}`;
+      const existingId = this.namedAgentMap.get(key);
+      if (existingId && existingId !== canonicalId) {
+        const existing = this.agents.get(existingId);
+        if (existing) {
+          transferAndRemove(this.identityDeps, canonicalId, existing, sessionId);
+          this.emit("agent:shutdown", {
+            type: "agent:shutdown",
+            agent: { id: canonicalId },
+            timestamp: now
+          });
+          console.log(`Late-merged agent ${canonicalId.slice(0, 12)}\u2026 into "${activity.agentName}" (${existingId.slice(0, 12)}\u2026)`);
+          this.applyActivity(existing, activity, now, sessionInfo);
+          return;
+        }
+      }
+      agent.agentName = activity.agentName;
+      const role = determineRoleForNamed(agent.parentId, null);
+      agent.role = role;
+      agent.teamName = role === "team-member" ? agent.teamName || getParentTeamName(this.agents, agent.rootSessionId) : agent.teamName;
+      this.namedAgentMap.set(key, canonicalId);
+      console.log(`Agent ${canonicalId.slice(0, 12)}\u2026 identified as "${activity.agentName}"`);
+    }
+    if (!agent) {
+      const parentId = sessionInfo.isSubagent ? sessionInfo.parentSessionId ? this.resolveAgentId(sessionInfo.parentSessionId) : findParentId(this.agents, sessionInfo.projectDir) : null;
+      const rootSessionId = this.computeRootSessionId(sessionId, parentId, sessionInfo);
+      const pendingInfo = parentId ? this.popPendingInfo(parentId) : null;
+      const taskDescription = pendingInfo?.task ?? null;
+      const pendingTeam = pendingInfo?.team ?? null;
+      let agentName = pendingInfo?.name ?? activity.agentName ?? null;
+      if (!agentName && activity.messageSender) {
+        agentName = this.popRecipientBySender(rootSessionId, activity.messageSender);
+      }
+      if (agentName) {
+        const key = `${rootSessionId}:${agentName}`;
+        const existingId = this.namedAgentMap.get(key);
+        if (existingId) {
+          const existing = this.agents.get(existingId);
+          if (existing) {
+            this.sessionToAgent.set(sessionId, existingId);
+            existing.isIdle = false;
+            existing.isDone = false;
+            existing.lastActivityAt = now;
+            console.log(`Immediate merge: session ${sessionId.slice(0, 12)}\u2026 \u2192 agent "${agentName}" (${existingId.slice(0, 12)}\u2026)`);
+            this.applyActivity(existing, activity, now, sessionInfo);
+            return;
+          }
+        }
+      }
+      const role = agentName ? determineRoleForNamed(parentId, pendingTeam) : determineRole(activity, sessionInfo);
+      const teamName = role === "team-member" ? pendingTeam || getParentTeamName(this.agents, rootSessionId) : null;
+      agent = {
+        id: sessionId,
+        sessionId,
+        rootSessionId,
+        projectPath: sessionInfo.projectPath,
+        projectName: sessionInfo.projectName,
+        agentName,
+        role,
+        parentId,
+        teamName,
+        currentZone: "spawn",
+        currentTool: null,
+        currentActivity: null,
+        messageTarget: null,
+        taskDescription,
+        speechText: null,
+        lastActivityAt: now,
+        spawnedAt: now,
+        isIdle: false,
+        isDone: false,
+        isPlanning: false,
+        isWaitingForUser: false,
+        phase: "running",
+        lastToolOutcome: null,
+        totalInputTokens: 0,
+        totalOutputTokens: 0,
+        cacheReadTokens: 0,
+        cacheCreationTokens: 0,
+        contextTokens: 0,
+        contextCacheTokens: 0,
+        model: activity.model ?? null,
+        colorIndex: getProjectColorIndex(sessionId),
+        toolUseCount: 0,
+        gitBranch: null,
+        recentFiles: [],
+        recentDiffs: []
+      };
+      this.agents.set(sessionId, agent);
+      this.sessionToAgent.set(sessionId, sessionId);
+      const shouldHide = sessionInfo.isSubagent && !agentName && this.hasNamedAgentsForRoot(rootSessionId);
+      if (shouldHide) {
+        this.hiddenAgents.add(sessionId);
+        console.log(`Hiding new session ${sessionId.slice(0, 12)}\u2026 (pending identity)`);
+        const timer = setTimeout(() => {
+          if (this.hiddenAgents.has(sessionId)) {
+            console.log(`Identity timeout for ${sessionId.slice(0, 12)}\u2026 \u2014 promoting with fallback name`);
+            promoteAgent(this.identityDeps, sessionId);
+          }
+        }, IDENTITY_TIMEOUT_MS);
+        this.identityTimers.set(sessionId, timer);
+        this.applyActivitySilent(agent, activity, now, sessionInfo);
+        return;
+      }
+      if (agentName) {
+        this.namedAgentMap.set(`${rootSessionId}:${agentName}`, sessionId);
+      }
+      this.addHistory(sessionId, { timestamp: now, kind: "spawn", zone: "spawn" });
+      const spawnEvent = { type: "agent:spawn", agent: { ...agent }, timestamp: now };
+      this.recordTimeline(spawnEvent);
+      this.emit("agent:spawn", spawnEvent);
+    }
+    this.applyActivity(agent, activity, now, sessionInfo);
+  }
+  /** Apply activity and emit update event (for visible agents) */
+  applyActivity(agent, activity, now, sessionInfo) {
+    this.mutateAgentState(agent, activity, now, sessionInfo);
+    this.resetIdleTimer(agent.id);
+    const updateEvent = { type: "agent:update", agent: { ...agent }, timestamp: now };
+    this.recordTimeline(updateEvent);
+    this.emit("agent:update", updateEvent);
+  }
+  /** Apply activity silently — no events emitted (for hidden agents) */
+  applyActivitySilent(agent, activity, now, sessionInfo) {
+    this.mutateAgentState(agent, activity, now, sessionInfo);
+  }
+  /** Mutate agent state based on activity (shared between silent and loud paths) */
+  mutateAgentState(agent, activity, now, _sessionInfo) {
+    agent.lastActivityAt = now;
+    agent.isIdle = false;
+    agent.isDone = false;
+    if (agent.phase === "idle")
+      agent.phase = "running";
+    if (activity.model) {
+      agent.model = activity.model;
+    }
+    processToolActivity(this.activityDeps, agent, activity, now);
+  }
+  queuePendingInfo(parentId, info) {
+    let queue = this.pendingSubagentInfo.get(parentId);
+    if (!queue) {
+      queue = [];
+      this.pendingSubagentInfo.set(parentId, queue);
+    }
+    queue.push(info);
+  }
+  popPendingInfo(parentId) {
+    const queue = this.pendingSubagentInfo.get(parentId);
+    if (!queue || queue.length === 0)
+      return null;
+    return queue.shift();
+  }
+  queueRecipient(rootSessionId, sender, recipient) {
+    let queue = this.pendingRecipients.get(rootSessionId);
+    if (!queue) {
+      queue = [];
+      this.pendingRecipients.set(rootSessionId, queue);
+    }
+    queue.push({ sender, recipient });
+    if (queue.length > 50)
+      queue.shift();
+  }
+  /** Pop a queued recipient name matching a specific sender */
+  popRecipientBySender(rootSessionId, sender) {
+    const queue = this.pendingRecipients.get(rootSessionId);
+    if (!queue)
+      return null;
+    const idx = queue.findIndex((e) => e.sender === sender);
+    if (idx === -1)
+      return null;
+    const entry = queue.splice(idx, 1)[0];
+    return entry.recipient;
+  }
+  clearTimers(agentId) {
+    const idle = this.idleTimers.get(agentId);
+    if (idle)
+      clearTimeout(idle);
+    this.idleTimers.delete(agentId);
+    const shutdown = this.shutdownTimers.get(agentId);
+    if (shutdown)
+      clearTimeout(shutdown);
+    this.shutdownTimers.delete(agentId);
+    const identity = this.identityTimers.get(agentId);
+    if (identity)
+      clearTimeout(identity);
+    this.identityTimers.delete(agentId);
+  }
+  resetIdleTimer(agentId) {
+    const existing = this.idleTimers.get(agentId);
+    if (existing)
+      clearTimeout(existing);
+    const existingShutdown = this.shutdownTimers.get(agentId);
+    if (existingShutdown)
+      clearTimeout(existingShutdown);
+    const timer = setTimeout(() => {
+      const agent = this.agents.get(agentId);
+      if (agent && !this.hiddenAgents.has(agentId)) {
+        if (this.pendingTool.has(agentId)) {
+          this.resetIdleTimer(agentId);
+          return;
+        }
+        agent.isIdle = true;
+        agent.isPlanning = false;
+        agent.isWaitingForUser = false;
+        agent.phase = "idle";
+        agent.currentZone = "idle";
+        agent.currentTool = null;
+        agent.currentActivity = null;
+        agent.speechText = null;
+        const ts = Date.now();
+        this.addHistory(agentId, { timestamp: ts, kind: "idle", zone: "idle" });
+        const idleEvent = {
+          type: "agent:idle",
+          agent: { ...agent },
+          timestamp: ts
+        };
+        this.recordTimeline(idleEvent);
+        this.emit("agent:idle", idleEvent);
+        this.startShutdownTimer(agentId);
+      }
+    }, config.idleTimeoutMs);
+    this.idleTimers.set(agentId, timer);
+  }
+  startShutdownTimer(agentId) {
+    const existing = this.shutdownTimers.get(agentId);
+    if (existing)
+      clearTimeout(existing);
+    const timer = setTimeout(() => {
+      const agent = this.agents.get(agentId);
+      if (agent && agent.isIdle && !agent.isDone) {
+        agent.isDone = true;
+        console.log(`Agent marked done: ${agentId} (idle for ${config.shutdownTimeoutMs / 1e3}s)`);
+        const ts = Date.now();
+        const updateEvent = { type: "agent:update", agent: { ...agent }, timestamp: ts };
+        this.recordTimeline(updateEvent);
+        this.emit("agent:update", updateEvent);
+      }
+    }, config.shutdownTimeoutMs);
+    this.shutdownTimers.set(agentId, timer);
+  }
+  removeDone() {
+    const removed = [];
+    const doneIds = [...this.agents.entries()].filter(([, a]) => a.isDone).map(([id]) => id);
+    for (const id of doneIds) {
+      if (this.agents.has(id)) {
+        removed.push(id);
+        this.shutdown(id);
+      }
+    }
+    return removed;
+  }
+  shutdown(sessionId) {
+    const childIds = [...this.agents.entries()].filter(([id, a]) => a.parentId === sessionId && id !== sessionId).map(([id]) => id);
+    this.clearTimers(sessionId);
+    this.hiddenAgents.delete(sessionId);
+    this.pendingTool.delete(sessionId);
+    const ts = Date.now();
+    this.addHistory(sessionId, { timestamp: ts, kind: "shutdown" });
+    const agent = this.agents.get(sessionId);
+    const shutdownEvent = {
+      type: "agent:shutdown",
+      agent: agent ? { ...agent } : { id: sessionId },
+      timestamp: ts
+    };
+    this.recordTimeline(shutdownEvent);
+    this.emit("agent:shutdown", shutdownEvent);
+    if (agent?.agentName) {
+      const key = `${agent.rootSessionId}:${agent.agentName}`;
+      if (this.namedAgentMap.get(key) === sessionId) {
+        this.namedAgentMap.delete(key);
+      }
+    }
+    for (const [sid, target] of this.sessionToAgent) {
+      if (target === sessionId) {
+        this.sessionToAgent.delete(sid);
+      }
+    }
+    this.agents.delete(sessionId);
+    this.activityHistory.delete(sessionId);
+    this.pendingSubagentInfo.delete(sessionId);
+    this.anomalyDetector.removeAgent(sessionId);
+    this.toolChainTracker.resetAgent(sessionId);
+    if (!this.toolChainTracker.hasActiveAgents() && this.agents.size === 0) {
+      this.toolChainTracker.reset();
+    }
+    this.emit("toolchain:changed", { data: this.toolChainTracker.getSnapshot(), timestamp: Date.now() });
+    if (agent?.rootSessionId) {
+      const rootId = agent.rootSessionId;
+      const hasRelated = [...this.agents.values()].some((a) => a.rootSessionId === rootId);
+      if (!hasRelated) {
+        this.pendingRecipients.delete(rootId);
+      }
+    }
+    if (this.taskGraphManager.removeAgentTasks(sessionId)) {
+      this.emit("taskgraph:changed", { data: this.taskGraphManager.getSnapshot(), timestamp: Date.now() });
+    }
+    for (const childId of childIds) {
+      if (this.agents.has(childId)) {
+        console.log(`Cascading shutdown: child ${childId.slice(0, 12)}\u2026 (parent ${sessionId.slice(0, 12)}\u2026 removed)`);
+        this.shutdown(childId);
+      }
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Hook-based lifecycle methods (Phase B: merge event sources)
+  // ---------------------------------------------------------------------------
+  /** Hook: new Claude Code session started */
+  hookSessionStart(sessionId, _cwd) {
+    const canonicalId = this.resolveAgentId(sessionId);
+    const agent = this.agents.get(canonicalId);
+    if (agent) {
+      agent.isIdle = false;
+      agent.isDone = false;
+      agent.phase = "running";
+      agent.lastActivityAt = Date.now();
+      this.resetIdleTimer(canonicalId);
+    }
+  }
+  /** Hook: session ended — definitively shut down the agent */
+  hookSessionEnd(sessionId) {
+    const canonicalId = this.resolveAgentId(sessionId);
+    if (this.agents.has(canonicalId)) {
+      this.shutdown(canonicalId);
+    }
+  }
+  /** Hook: user submitted a prompt — agent is now running */
+  hookUserPromptSubmit(sessionId) {
+    this.setPhase(sessionId, "running");
+  }
+  /** Hook: agent finished responding (Stop event) */
+  hookStop(sessionId, lastMessage) {
+    const canonicalId = this.resolveAgentId(sessionId);
+    const agent = this.agents.get(canonicalId);
+    if (!agent || this.hiddenAgents.has(canonicalId))
+      return;
+    agent.phase = "idle";
+    agent.isIdle = true;
+    agent.isPlanning = false;
+    agent.isWaitingForUser = false;
+    agent.currentZone = "idle";
+    agent.currentTool = null;
+    agent.currentActivity = null;
+    if (lastMessage) {
+      agent.speechText = lastMessage.length > 200 ? lastMessage.slice(0, 197) + "..." : lastMessage;
+    }
+    const now = Date.now();
+    this.addHistory(canonicalId, { timestamp: now, kind: "idle", zone: "idle" });
+    const idleEvent = { type: "agent:idle", agent: { ...agent }, timestamp: now };
+    this.recordTimeline(idleEvent);
+    this.emit("agent:idle", idleEvent);
+    this.resetIdleTimer(canonicalId);
+  }
+  /** Hook: context compaction is starting */
+  hookPreCompact(sessionId) {
+    this.setPhase(sessionId, "compacting");
+  }
+  /** Hook: tool is about to execute (PreToolUse) */
+  hookPreToolUse(sessionId, toolName, toolInput, _toolUseId) {
+    const canonicalId = this.resolveAgentId(sessionId);
+    const agent = this.agents.get(canonicalId);
+    if (!agent || this.hiddenAgents.has(canonicalId))
+      return;
+    agent.phase = "running";
+    agent.lastToolOutcome = null;
+    agent.currentTool = toolName;
+    agent.currentZone = getZoneForTool(toolName);
+    if (toolInput) {
+      agent.currentActivity = this.summarizeToolInput(toolInput);
+    }
+    agent.lastActivityAt = Date.now();
+    this.resetIdleTimer(canonicalId);
+    this.toolChainTracker.recordToolStart(canonicalId, toolName);
+    const now = Date.now();
+    const updateEvent = { type: "agent:update", agent: { ...agent }, timestamp: now };
+    this.recordTimeline(updateEvent);
+    this.emit("agent:update", updateEvent);
+  }
+  /** Hook: background task completed (TaskCompleted event) */
+  hookTaskCompleted(sessionId, taskId, taskSubject) {
+    const canonicalId = this.resolveAgentId(sessionId);
+    const agent = this.agents.get(canonicalId);
+    const root = agent?.rootSessionId ?? canonicalId;
+    const changed = this.taskGraphManager.processTaskCompleted(taskId, root);
+    if (changed) {
+      this.emit("taskgraph:changed", { data: this.taskGraphManager.getSnapshot(), timestamp: Date.now() });
+    }
+    this.emit("task:completed", {
+      taskId,
+      taskSubject: taskSubject ?? `Task ${taskId}`,
+      agentId: canonicalId
+    });
+  }
+  /** Hook: tool completed (PostToolUse = success, PostToolUseFailure = failure) */
+  hookPostToolUse(sessionId, _toolName, _toolUseId, success) {
+    const canonicalId = this.resolveAgentId(sessionId);
+    const agent = this.agents.get(canonicalId);
+    if (!agent || this.hiddenAgents.has(canonicalId))
+      return;
+    agent.lastToolOutcome = success ? "success" : "failure";
+    this.toolChainTracker.recordToolOutcome(canonicalId, success);
+    agent.lastActivityAt = Date.now();
+    this.resetIdleTimer(canonicalId);
+    const now = Date.now();
+    const updateEvent = { type: "agent:update", agent: { ...agent }, timestamp: now };
+    this.recordTimeline(updateEvent);
+    this.emit("agent:update", updateEvent);
+  }
+  setPhase(sessionId, phase) {
+    const canonicalId = this.resolveAgentId(sessionId);
+    const agent = this.agents.get(canonicalId);
+    if (!agent || this.hiddenAgents.has(canonicalId))
+      return;
+    agent.phase = phase;
+    if (phase === "running" || phase === "compacting") {
+      agent.isIdle = false;
+      agent.isDone = false;
+      agent.lastActivityAt = Date.now();
+      this.resetIdleTimer(canonicalId);
+    }
+    const now = Date.now();
+    const updateEvent = { type: "agent:update", agent: { ...agent }, timestamp: now };
+    this.recordTimeline(updateEvent);
+    this.emit("agent:update", updateEvent);
+  }
+  dispose() {
+    this.anomalyDetector.dispose();
+    this.clearAllTimers();
+  }
+  clearAllTimers() {
+    for (const timer of this.idleTimers.values())
+      clearTimeout(timer);
+    this.idleTimers.clear();
+    for (const timer of this.shutdownTimers.values())
+      clearTimeout(timer);
+    this.shutdownTimers.clear();
+    for (const timer of this.identityTimers.values())
+      clearTimeout(timer);
+    this.identityTimers.clear();
+  }
+};
+var Broadcaster = class {
+  stateManager;
+  clients = /* @__PURE__ */ new Set();
+  boundListeners = [];
+  constructor(stateManager, hookManager) {
+    this.stateManager = stateManager;
+    const track = (emitter, event, fn) => {
+      emitter.on(event, fn);
+      this.boundListeners.push({ emitter, event, fn });
+    };
+    if (hookManager) {
+      track(hookManager, "permission:request", (permission) => {
+        this.broadcast({
+          type: "permission:request",
+          permission,
+          timestamp: Date.now()
+        });
+      });
+      track(hookManager, "permission:resolved", (payload) => {
+        this.broadcast({
+          type: "permission:resolved",
+          permissionId: payload.permissionId,
+          decision: payload.decision,
+          timestamp: Date.now()
+        });
+      });
+    }
+    for (const eventType of ["agent:spawn", "agent:update", "agent:idle", "agent:shutdown"]) {
+      track(stateManager, eventType, (event) => {
+        if (eventType === "agent:shutdown") {
+          this.broadcast({
+            type: "agent:shutdown",
+            agentId: event.agent.id,
+            timestamp: event.timestamp
+          });
+        } else {
+          this.broadcast({
+            type: eventType,
+            agent: event.agent,
+            timestamp: event.timestamp
+          });
+        }
+      });
+    }
+    track(stateManager.anomalyDetector, "anomaly", (anomaly) => {
+      this.broadcast({
+        type: "anomaly:alert",
+        anomaly,
+        timestamp: Date.now()
+      });
+    });
+    track(stateManager, "toolchain:changed", (payload) => {
+      this.broadcast({
+        type: "toolchain:snapshot",
+        data: payload.data,
+        timestamp: payload.timestamp
+      });
+    });
+    track(stateManager, "taskgraph:changed", (payload) => {
+      this.broadcast({
+        type: "taskgraph:snapshot",
+        data: payload.data,
+        timestamp: payload.timestamp
+      });
+    });
+    track(stateManager, "task:completed", (payload) => {
+      this.broadcast({
+        type: "task:completed",
+        taskId: payload.taskId,
+        taskSubject: payload.taskSubject,
+        agentId: payload.agentId,
+        timestamp: Date.now()
+      });
+    });
+  }
+  addClient(ws) {
+    this.clients.add(ws);
+    ws.on("close", () => {
+      this.clients.delete(ws);
+    });
+    ws.on("error", () => {
+      this.clients.delete(ws);
+    });
+    if (ws.readyState === 1) {
+      try {
+        const fullState = {
+          type: "full_state",
+          agents: this.stateManager.getAll(),
+          timestamp: Date.now()
+        };
+        ws.send(JSON.stringify(fullState));
+        const timeline = {
+          type: "timeline:snapshot",
+          events: this.stateManager.getTimeline(),
+          timestamp: Date.now()
+        };
+        ws.send(JSON.stringify(timeline));
+        const toolchain = {
+          type: "toolchain:snapshot",
+          data: this.stateManager.getToolChainSnapshot(),
+          timestamp: Date.now()
+        };
+        ws.send(JSON.stringify(toolchain));
+        const taskgraph = {
+          type: "taskgraph:snapshot",
+          data: this.stateManager.getTaskGraphSnapshot(),
+          timestamp: Date.now()
+        };
+        ws.send(JSON.stringify(taskgraph));
+      } catch {
+        this.clients.delete(ws);
+      }
+    }
+  }
+  /** Broadcast that hook events are being received */
+  broadcastHooksStatus() {
+    this.broadcast({ type: "hooks:status", timestamp: Date.now() });
+  }
+  /** Send a message to a specific client */
+  sendToClient(ws, message) {
+    if (ws.readyState === 1) {
+      try {
+        ws.send(JSON.stringify(message));
+      } catch {
+        this.clients.delete(ws);
+      }
+    }
+  }
+  dispose() {
+    for (const { emitter, event, fn } of this.boundListeners) {
+      emitter.removeListener(event, fn);
+    }
+    this.boundListeners = [];
+    this.clients.clear();
+  }
+  broadcast(message) {
+    const data = JSON.stringify(message);
+    for (const client of this.clients) {
+      if (client.readyState === 1) {
+        try {
+          client.send(data);
+        } catch {
+          this.clients.delete(client);
+        }
+      }
+    }
+  }
+};
+function registerWsHandler(app, stateManager, broadcaster, hookManager) {
+  app.get("/ws", { websocket: true }, (socket, _req) => {
+    console.log("WebSocket client connected");
+    broadcaster.addClient(socket);
+    socket.on("message", (data) => {
+      try {
+        const msg = JSON.parse(data.toString());
+        if (msg.type === "ping") {
+          socket.send(JSON.stringify({ type: "pong" }));
+        } else if (msg.type === "request:history") {
+          const agentId = msg.agentId;
+          const entries = stateManager.getHistory(agentId);
+          socket.send(JSON.stringify({
+            type: "agent:history",
+            agentId,
+            entries,
+            timestamp: Date.now()
+          }));
+        } else if (msg.type === "request:toolchain") {
+          broadcaster.sendToClient(socket, {
+            type: "toolchain:snapshot",
+            data: stateManager.getToolChainSnapshot(),
+            timestamp: Date.now()
+          });
+        } else if (msg.type === "request:taskgraph") {
+          broadcaster.sendToClient(socket, {
+            type: "taskgraph:snapshot",
+            data: stateManager.getTaskGraphSnapshot(),
+            timestamp: Date.now()
+          });
+        } else if (hookManager && msg.type === "permission:approve") {
+          hookManager.resolvePermission(msg.permissionId, {
+            behavior: "allow",
+            updatedInput: msg.updatedInput
+          });
+        } else if (hookManager && msg.type === "permission:deny") {
+          hookManager.resolvePermission(msg.permissionId, { behavior: "deny" });
+        } else if (hookManager && msg.type === "permission:approve-always") {
+          hookManager.resolvePermission(msg.permissionId, {
+            behavior: "allow",
+            updatedPermissions: msg.rules
+          });
+        }
+      } catch {
+      }
+    });
+    socket.on("close", () => {
+      console.log("WebSocket client disconnected");
+    });
+  });
+}
+function registerApiRoutes(app, stateManager) {
+  app.get("/api/health", async () => {
+    return { status: "ok", timestamp: Date.now() };
+  });
+  app.get("/api/state", async () => {
+    return {
+      agents: stateManager.getAll(),
+      timestamp: Date.now()
+    };
+  });
+  app.post("/api/agents/clean-done", async () => {
+    const removed = stateManager.removeDone();
+    return { removed, count: removed.length };
+  });
+  app.post("/api/agents/:id/shutdown", async (req, reply) => {
+    const agent = stateManager.getAll().find((a) => a.id === req.params.id);
+    if (!agent) {
+      return reply.status(404).send({ error: "Agent not found" });
+    }
+    stateManager.shutdown(req.params.id);
+    return { removed: req.params.id };
+  });
+}
+var PERMISSION_TIMEOUT_MS = 5 * 60 * 1e3;
+var HookEventManager = class extends EventEmitter3 {
+  stateManager;
+  pending = /* @__PURE__ */ new Map();
+  constructor(stateManager) {
+    super();
+    this.stateManager = stateManager;
+  }
+  /**
+   * Main entry point for incoming hook events.
+   *
+   * - For PermissionRequest: returns a Promise that resolves when the user
+   *   decides. Fastify holds the HTTP connection open while awaiting.
+   * - For all other events: processes state updates and returns null immediately
+   *   (fire-and-forget from the HTTP handler's perspective).
+   */
+  async handleEvent(event) {
+    if (event.hook_event_name === "PermissionRequest") {
+      return this.handlePermissionRequest(event);
+    }
+    this.processLifecycleEvent(event);
+    return null;
+  }
+  /**
+   * Called by the WS handler when a client approves a permission.
+   */
+  resolvePermission(permissionId, decision) {
+    const deferred = this.pending.get(permissionId);
+    if (!deferred)
+      return;
+    clearTimeout(deferred.timeout);
+    this.pending.delete(permissionId);
+    deferred.resolve(decision);
+    this.emit("permission:resolved", { permissionId, decision: decision.behavior });
+  }
+  /** All currently pending permission requests (for sending on new WS connect) */
+  getPendingPermissions() {
+    return [];
+  }
+  dispose() {
+    for (const deferred of this.pending.values()) {
+      clearTimeout(deferred.timeout);
+    }
+    this.pending.clear();
+    this.removeAllListeners();
+  }
+  // ---------------------------------------------------------------------------
+  // Private
+  // ---------------------------------------------------------------------------
+  async handlePermissionRequest(event) {
+    const permissionId = randomUUID();
+    const permission = {
+      permissionId,
+      sessionId: event.session_id,
+      toolName: event.tool_name ?? "",
+      toolInput: event.tool_input ?? null,
+      toolUseId: event.tool_use_id ?? "",
+      permissionSuggestions: event.permission_suggestions,
+      timestamp: Date.now()
+    };
+    this.emit("permission:request", permission);
+    return new Promise((resolve) => {
+      const timeout = setTimeout(() => {
+        this.pending.delete(permissionId);
+        this.emit("permission:resolved", { permissionId, decision: "deny" });
+        resolve({
+          statusCode: 403,
+          body: buildResponse({ behavior: "deny" })
+        });
+      }, PERMISSION_TIMEOUT_MS);
+      this.pending.set(permissionId, {
+        timeout,
+        resolve: (decision) => {
+          if (decision.behavior === "deny") {
+            resolve({ statusCode: 403, body: buildResponse(decision) });
+          } else {
+            resolve({ statusCode: 200, body: buildResponse(decision) });
+          }
+        }
+      });
+    });
+  }
+  processLifecycleEvent(event) {
+    const { hook_event_name, session_id } = event;
+    switch (hook_event_name) {
+      case "SessionStart":
+        this.stateManager.hookSessionStart(session_id, event.cwd ?? "");
+        break;
+      case "SessionEnd":
+        this.stateManager.hookSessionEnd(session_id);
+        break;
+      case "UserPromptSubmit":
+        this.stateManager.hookUserPromptSubmit(session_id);
+        break;
+      case "Stop":
+        this.stateManager.hookStop(session_id, event.last_assistant_message);
+        break;
+      case "PreCompact":
+        this.stateManager.hookPreCompact(session_id);
+        break;
+      case "PreToolUse":
+        if (event.tool_name) {
+          this.stateManager.hookPreToolUse(session_id, event.tool_name, event.tool_input, event.tool_use_id ?? "");
+        }
+        break;
+      case "PostToolUse":
+        if (event.tool_name) {
+          this.stateManager.hookPostToolUse(session_id, event.tool_name, event.tool_use_id ?? "", true);
+        }
+        break;
+      case "PostToolUseFailure":
+        if (event.tool_name) {
+          this.stateManager.hookPostToolUse(session_id, event.tool_name, event.tool_use_id ?? "", false);
+        }
+        break;
+      case "TaskCompleted":
+        if (event.task_id) {
+          this.stateManager.hookTaskCompleted(session_id, event.task_id, event.task_subject);
+        }
+        break;
+      case "SubagentStart":
+        break;
+      case "SubagentStop":
+        if (event.agent_id) {
+          this.stateManager.hookSessionEnd(event.agent_id);
+        }
+        break;
+      case "Notification":
+        break;
+      case "TeammateIdle":
+        this.emit("teammate:idle", {
+          sessionId: session_id,
+          agentId: event.agent_id,
+          message: event.message
+        });
+        break;
+      case "WorktreeCreate":
+        console.log(`[hook] Worktree created: session=${session_id}`);
+        break;
+      case "WorktreeRemove":
+        console.log(`[hook] Worktree removed: session=${session_id}`);
+        break;
+      default:
+        break;
+    }
+  }
+};
+function buildResponse(decision) {
+  return {
+    hookSpecificOutput: {
+      hookEventName: "PermissionRequest",
+      decision
+    }
+  };
+}
+var __dirname = dirname(fileURLToPath(import.meta.url));
+async function main() {
+  const app = Fastify({ logger: { level: "info" } });
+  await app.register(cors, { origin: true });
+  await app.register(websocket);
+  const clientDist = join6(__dirname, "..", "..", "client", "dist");
+  await app.register(fastifyStatic, {
+    root: clientDist,
+    prefix: "/",
+    wildcard: false
+  });
+  const stateManager = new AgentStateManager();
+  const hookManager = new HookEventManager(stateManager);
+  const broadcaster = new Broadcaster(stateManager, hookManager);
+  registerWsHandler(app, stateManager, broadcaster, hookManager);
+  registerApiRoutes(app, stateManager);
+  app.post("/hook", {
+    config: { rawBody: false }
+  }, async (req, reply) => {
+    const event = req.body;
+    if (!event?.hook_event_name || !event?.session_id) {
+      console.warn("[hook] Received invalid hook payload:", JSON.stringify(req.body).slice(0, 200));
+      return reply.status(400).send({ error: "Invalid hook event" });
+    }
+    console.log(`[hook] ${event.hook_event_name} | session=${event.session_id.slice(0, 12)} | tool=${event.tool_name ?? "-"}`);
+    broadcaster.broadcastHooksStatus();
+    const result = await hookManager.handleEvent(event);
+    if (result) {
+      return reply.status(result.statusCode).send(result.body);
+    }
+    return reply.status(200).send({ ok: true });
+  });
+  app.setNotFoundHandler((_req, reply) => {
+    reply.sendFile("index.html");
+  });
+  const watchers = [
+    new FileWatcher(config.claudeHome, stateManager),
+    ...config.enableOpenCode ? [new OpenCodeWatcher(stateManager)] : []
+  ];
+  for (const w of watchers) {
+    await w.start();
+  }
+  stateManager.flushPendingQueues();
+  let actualPort = config.port;
+  for (let attempt = 0; attempt < 10; attempt++) {
+    try {
+      await app.listen({ port: actualPort, host: "127.0.0.1" });
+      break;
+    } catch (err) {
+      if (err.code === "EADDRINUSE" && attempt < 9) {
+        actualPort++;
+        continue;
+      }
+      throw err;
+    }
+  }
+  console.log(`Server listening on http://localhost:${actualPort}`);
+  const shutdown = async () => {
+    console.log("Shutting down...");
+    for (const w of watchers)
+      w.stop();
+    hookManager.dispose();
+    broadcaster.dispose();
+    stateManager.dispose();
+    await app.close();
+    process.exit(0);
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+  return { port: actualPort };
+}
+if (!process.env.__AGENT_MOVE_CLI) {
+  main().catch((err) => {
+    console.error("Failed to start server:", err);
+    process.exit(1);
+  });
+}
+export {
+  main
+};