@sesamespace/hivemind 0.4.2 → 0.4.3

package/dist/chunk-LRK64BAK.js

@@ -1,3601 +0,0 @@
-import {
-  SesameClient
-} from "./chunk-GPI4RU7N.js";
-import {
-  __commonJS,
-  __require,
-  __toESM
-} from "./chunk-7D4SUZUM.js";
-
-// node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/lib/parser.js
-var require_parser = __commonJS({
-  "node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/lib/parser.js"(exports2, module2) {
-    "use strict";
-    var ParserEND = 1114112;
-    var ParserError = class _ParserError extends Error {
-      /* istanbul ignore next */
-      constructor(msg, filename, linenumber) {
-        super("[ParserError] " + msg, filename, linenumber);
-        this.name = "ParserError";
-        this.code = "ParserError";
-        if (Error.captureStackTrace) Error.captureStackTrace(this, _ParserError);
-      }
-    };
-    var State = class {
-      constructor(parser) {
-        this.parser = parser;
-        this.buf = "";
-        this.returned = null;
-        this.result = null;
-        this.resultTable = null;
-        this.resultArr = null;
-      }
-    };
-    var Parser = class {
-      constructor() {
-        this.pos = 0;
-        this.col = 0;
-        this.line = 0;
-        this.obj = {};
-        this.ctx = this.obj;
-        this.stack = [];
-        this._buf = "";
-        this.char = null;
-        this.ii = 0;
-        this.state = new State(this.parseStart);
-      }
-      parse(str) {
-        if (str.length === 0 || str.length == null) return;
-        this._buf = String(str);
-        this.ii = -1;
-        this.char = -1;
-        let getNext;
-        while (getNext === false || this.nextChar()) {
-          getNext = this.runOne();
-        }
-        this._buf = null;
-      }
-      nextChar() {
-        if (this.char === 10) {
-          ++this.line;
-          this.col = -1;
-        }
-        ++this.ii;
-        this.char = this._buf.codePointAt(this.ii);
-        ++this.pos;
-        ++this.col;
-        return this.haveBuffer();
-      }
-      haveBuffer() {
-        return this.ii < this._buf.length;
-      }
-      runOne() {
-        return this.state.parser.call(this, this.state.returned);
-      }
-      finish() {
-        this.char = ParserEND;
-        let last;
-        do {
-          last = this.state.parser;
-          this.runOne();
-        } while (this.state.parser !== last);
-        this.ctx = null;
-        this.state = null;
-        this._buf = null;
-        return this.obj;
-      }
-      next(fn) {
-        if (typeof fn !== "function") throw new ParserError("Tried to set state to non-existent state: " + JSON.stringify(fn));
-        this.state.parser = fn;
-      }
-      goto(fn) {
-        this.next(fn);
-        return this.runOne();
-      }
-      call(fn, returnWith) {
-        if (returnWith) this.next(returnWith);
-        this.stack.push(this.state);
-        this.state = new State(fn);
-      }
-      callNow(fn, returnWith) {
-        this.call(fn, returnWith);
-        return this.runOne();
-      }
-      return(value) {
-        if (this.stack.length === 0) throw this.error(new ParserError("Stack underflow"));
-        if (value === void 0) value = this.state.buf;
-        this.state = this.stack.pop();
-        this.state.returned = value;
-      }
-      returnNow(value) {
-        this.return(value);
-        return this.runOne();
-      }
-      consume() {
-        if (this.char === ParserEND) throw this.error(new ParserError("Unexpected end-of-buffer"));
-        this.state.buf += this._buf[this.ii];
-      }
-      error(err) {
-        err.line = this.line;
-        err.col = this.col;
-        err.pos = this.pos;
-        return err;
-      }
-      /* istanbul ignore next */
-      parseStart() {
-        throw new ParserError("Must declare a parseStart method");
-      }
-    };
-    Parser.END = ParserEND;
-    Parser.Error = ParserError;
-    module2.exports = Parser;
-  }
-});
-
-// node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/lib/create-datetime.js
-var require_create_datetime = __commonJS({
-  "node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/lib/create-datetime.js"(exports2, module2) {
-    "use strict";
-    module2.exports = (value) => {
-      const date = new Date(value);
-      if (isNaN(date)) {
-        throw new TypeError("Invalid Datetime");
-      } else {
-        return date;
-      }
-    };
-  }
-});
-
-// node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/lib/format-num.js
-var require_format_num = __commonJS({
-  "node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/lib/format-num.js"(exports2, module2) {
-    "use strict";
-    module2.exports = (d, num) => {
-      num = String(num);
-      while (num.length < d) num = "0" + num;
-      return num;
-    };
-  }
-});
-
-// node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/lib/create-datetime-float.js
-var require_create_datetime_float = __commonJS({
-  "node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/lib/create-datetime-float.js"(exports2, module2) {
-    "use strict";
-    var f = require_format_num();
-    var FloatingDateTime = class extends Date {
-      constructor(value) {
-        super(value + "Z");
-        this.isFloating = true;
-      }
-      toISOString() {
-        const date = `${this.getUTCFullYear()}-${f(2, this.getUTCMonth() + 1)}-${f(2, this.getUTCDate())}`;
-        const time = `${f(2, this.getUTCHours())}:${f(2, this.getUTCMinutes())}:${f(2, this.getUTCSeconds())}.${f(3, this.getUTCMilliseconds())}`;
-        return `${date}T${time}`;
-      }
-    };
-    module2.exports = (value) => {
-      const date = new FloatingDateTime(value);
-      if (isNaN(date)) {
-        throw new TypeError("Invalid Datetime");
-      } else {
-        return date;
-      }
-    };
-  }
-});
-
-// node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/lib/create-date.js
-var require_create_date = __commonJS({
-  "node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/lib/create-date.js"(exports2, module2) {
-    "use strict";
-    var f = require_format_num();
-    var DateTime = global.Date;
-    var Date2 = class extends DateTime {
-      constructor(value) {
-        super(value);
-        this.isDate = true;
-      }
-      toISOString() {
-        return `${this.getUTCFullYear()}-${f(2, this.getUTCMonth() + 1)}-${f(2, this.getUTCDate())}`;
-      }
-    };
-    module2.exports = (value) => {
-      const date = new Date2(value);
-      if (isNaN(date)) {
-        throw new TypeError("Invalid Datetime");
-      } else {
-        return date;
-      }
-    };
-  }
-});
-
-// node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/lib/create-time.js
-var require_create_time = __commonJS({
-  "node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/lib/create-time.js"(exports2, module2) {
-    "use strict";
-    var f = require_format_num();
-    var Time = class extends Date {
-      constructor(value) {
-        super(`0000-01-01T${value}Z`);
-        this.isTime = true;
-      }
-      toISOString() {
-        return `${f(2, this.getUTCHours())}:${f(2, this.getUTCMinutes())}:${f(2, this.getUTCSeconds())}.${f(3, this.getUTCMilliseconds())}`;
-      }
-    };
-    module2.exports = (value) => {
-      const date = new Time(value);
-      if (isNaN(date)) {
-        throw new TypeError("Invalid Datetime");
-      } else {
-        return date;
-      }
-    };
-  }
-});
-
-// node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/lib/toml-parser.js
-var require_toml_parser = __commonJS({
-  "node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/lib/toml-parser.js"(exports, module) {
-    "use strict";
-    module.exports = makeParserClass(require_parser());
-    module.exports.makeParserClass = makeParserClass;
-    var TomlError = class _TomlError extends Error {
-      constructor(msg) {
-        super(msg);
-        this.name = "TomlError";
-        if (Error.captureStackTrace) Error.captureStackTrace(this, _TomlError);
-        this.fromTOML = true;
-        this.wrapped = null;
-      }
-    };
-    TomlError.wrap = (err) => {
-      const terr = new TomlError(err.message);
-      terr.code = err.code;
-      terr.wrapped = err;
-      return terr;
-    };
-    module.exports.TomlError = TomlError;
-    var createDateTime = require_create_datetime();
-    var createDateTimeFloat = require_create_datetime_float();
-    var createDate = require_create_date();
-    var createTime = require_create_time();
-    var CTRL_I = 9;
-    var CTRL_J = 10;
-    var CTRL_M = 13;
-    var CTRL_CHAR_BOUNDARY = 31;
-    var CHAR_SP = 32;
-    var CHAR_QUOT = 34;
-    var CHAR_NUM = 35;
-    var CHAR_APOS = 39;
-    var CHAR_PLUS = 43;
-    var CHAR_COMMA = 44;
-    var CHAR_HYPHEN = 45;
-    var CHAR_PERIOD = 46;
-    var CHAR_0 = 48;
-    var CHAR_1 = 49;
-    var CHAR_7 = 55;
-    var CHAR_9 = 57;
-    var CHAR_COLON = 58;
-    var CHAR_EQUALS = 61;
-    var CHAR_A = 65;
-    var CHAR_E = 69;
-    var CHAR_F = 70;
-    var CHAR_T = 84;
-    var CHAR_U = 85;
-    var CHAR_Z = 90;
-    var CHAR_LOWBAR = 95;
-    var CHAR_a = 97;
-    var CHAR_b = 98;
-    var CHAR_e = 101;
-    var CHAR_f = 102;
-    var CHAR_i = 105;
-    var CHAR_l = 108;
-    var CHAR_n = 110;
-    var CHAR_o = 111;
-    var CHAR_r = 114;
-    var CHAR_s = 115;
-    var CHAR_t = 116;
-    var CHAR_u = 117;
-    var CHAR_x = 120;
-    var CHAR_z = 122;
-    var CHAR_LCUB = 123;
-    var CHAR_RCUB = 125;
-    var CHAR_LSQB = 91;
-    var CHAR_BSOL = 92;
-    var CHAR_RSQB = 93;
-    var CHAR_DEL = 127;
-    var SURROGATE_FIRST = 55296;
-    var SURROGATE_LAST = 57343;
-    var escapes = {
-      [CHAR_b]: "\b",
-      [CHAR_t]: "	",
-      [CHAR_n]: "\n",
-      [CHAR_f]: "\f",
-      [CHAR_r]: "\r",
-      [CHAR_QUOT]: '"',
-      [CHAR_BSOL]: "\\"
-    };
-    function isDigit(cp) {
-      return cp >= CHAR_0 && cp <= CHAR_9;
-    }
-    function isHexit(cp) {
-      return cp >= CHAR_A && cp <= CHAR_F || cp >= CHAR_a && cp <= CHAR_f || cp >= CHAR_0 && cp <= CHAR_9;
-    }
-    function isBit(cp) {
-      return cp === CHAR_1 || cp === CHAR_0;
-    }
-    function isOctit(cp) {
-      return cp >= CHAR_0 && cp <= CHAR_7;
-    }
-    function isAlphaNumQuoteHyphen(cp) {
-      return cp >= CHAR_A && cp <= CHAR_Z || cp >= CHAR_a && cp <= CHAR_z || cp >= CHAR_0 && cp <= CHAR_9 || cp === CHAR_APOS || cp === CHAR_QUOT || cp === CHAR_LOWBAR || cp === CHAR_HYPHEN;
-    }
-    function isAlphaNumHyphen(cp) {
-      return cp >= CHAR_A && cp <= CHAR_Z || cp >= CHAR_a && cp <= CHAR_z || cp >= CHAR_0 && cp <= CHAR_9 || cp === CHAR_LOWBAR || cp === CHAR_HYPHEN;
-    }
-    var _type = /* @__PURE__ */ Symbol("type");
-    var _declared = /* @__PURE__ */ Symbol("declared");
-    var hasOwnProperty = Object.prototype.hasOwnProperty;
-    var defineProperty = Object.defineProperty;
-    var descriptor = { configurable: true, enumerable: true, writable: true, value: void 0 };
-    function hasKey(obj, key) {
-      if (hasOwnProperty.call(obj, key)) return true;
-      if (key === "__proto__") defineProperty(obj, "__proto__", descriptor);
-      return false;
-    }
-    var INLINE_TABLE = /* @__PURE__ */ Symbol("inline-table");
-    function InlineTable() {
-      return Object.defineProperties({}, {
-        [_type]: { value: INLINE_TABLE }
-      });
-    }
-    function isInlineTable(obj) {
-      if (obj === null || typeof obj !== "object") return false;
-      return obj[_type] === INLINE_TABLE;
-    }
-    var TABLE = /* @__PURE__ */ Symbol("table");
-    function Table() {
-      return Object.defineProperties({}, {
-        [_type]: { value: TABLE },
-        [_declared]: { value: false, writable: true }
-      });
-    }
-    function isTable(obj) {
-      if (obj === null || typeof obj !== "object") return false;
-      return obj[_type] === TABLE;
-    }
-    var _contentType = /* @__PURE__ */ Symbol("content-type");
-    var INLINE_LIST = /* @__PURE__ */ Symbol("inline-list");
-    function InlineList(type) {
-      return Object.defineProperties([], {
-        [_type]: { value: INLINE_LIST },
-        [_contentType]: { value: type }
-      });
-    }
-    function isInlineList(obj) {
-      if (obj === null || typeof obj !== "object") return false;
-      return obj[_type] === INLINE_LIST;
-    }
-    var LIST = /* @__PURE__ */ Symbol("list");
-    function List() {
-      return Object.defineProperties([], {
-        [_type]: { value: LIST }
-      });
-    }
-    function isList(obj) {
-      if (obj === null || typeof obj !== "object") return false;
-      return obj[_type] === LIST;
-    }
-    var _custom;
-    try {
-      const utilInspect = eval("require('util').inspect");
-      _custom = utilInspect.custom;
-    } catch (_) {
-    }
-    var _inspect = _custom || "inspect";
-    var BoxedBigInt = class {
-      constructor(value) {
-        try {
-          this.value = global.BigInt.asIntN(64, value);
-        } catch (_) {
-          this.value = null;
-        }
-        Object.defineProperty(this, _type, { value: INTEGER });
-      }
-      isNaN() {
-        return this.value === null;
-      }
-      /* istanbul ignore next */
-      toString() {
-        return String(this.value);
-      }
-      /* istanbul ignore next */
-      [_inspect]() {
-        return `[BigInt: ${this.toString()}]}`;
-      }
-      valueOf() {
-        return this.value;
-      }
-    };
-    var INTEGER = /* @__PURE__ */ Symbol("integer");
-    function Integer(value) {
-      let num = Number(value);
-      if (Object.is(num, -0)) num = 0;
-      if (global.BigInt && !Number.isSafeInteger(num)) {
-        return new BoxedBigInt(value);
-      } else {
-        return Object.defineProperties(new Number(num), {
-          isNaN: { value: function() {
-            return isNaN(this);
-          } },
-          [_type]: { value: INTEGER },
-          [_inspect]: { value: () => `[Integer: ${value}]` }
-        });
-      }
-    }
-    function isInteger(obj) {
-      if (obj === null || typeof obj !== "object") return false;
-      return obj[_type] === INTEGER;
-    }
-    var FLOAT = /* @__PURE__ */ Symbol("float");
-    function Float(value) {
-      return Object.defineProperties(new Number(value), {
-        [_type]: { value: FLOAT },
-        [_inspect]: { value: () => `[Float: ${value}]` }
-      });
-    }
-    function isFloat(obj) {
-      if (obj === null || typeof obj !== "object") return false;
-      return obj[_type] === FLOAT;
-    }
-    function tomlType(value) {
-      const type = typeof value;
-      if (type === "object") {
-        if (value === null) return "null";
-        if (value instanceof Date) return "datetime";
-        if (_type in value) {
-          switch (value[_type]) {
-            case INLINE_TABLE:
-              return "inline-table";
-            case INLINE_LIST:
-              return "inline-list";
-            /* istanbul ignore next */
-            case TABLE:
-              return "table";
-            /* istanbul ignore next */
-            case LIST:
-              return "list";
-            case FLOAT:
-              return "float";
-            case INTEGER:
-              return "integer";
-          }
-        }
-      }
-      return type;
-    }
-    function makeParserClass(Parser) {
-      class TOMLParser extends Parser {
-        constructor() {
-          super();
-          this.ctx = this.obj = Table();
-        }
-        /* MATCH HELPER */
-        atEndOfWord() {
-          return this.char === CHAR_NUM || this.char === CTRL_I || this.char === CHAR_SP || this.atEndOfLine();
-        }
-        atEndOfLine() {
-          return this.char === Parser.END || this.char === CTRL_J || this.char === CTRL_M;
-        }
-        parseStart() {
-          if (this.char === Parser.END) {
-            return null;
-          } else if (this.char === CHAR_LSQB) {
-            return this.call(this.parseTableOrList);
-          } else if (this.char === CHAR_NUM) {
-            return this.call(this.parseComment);
-          } else if (this.char === CTRL_J || this.char === CHAR_SP || this.char === CTRL_I || this.char === CTRL_M) {
-            return null;
-          } else if (isAlphaNumQuoteHyphen(this.char)) {
-            return this.callNow(this.parseAssignStatement);
-          } else {
-            throw this.error(new TomlError(`Unknown character "${this.char}"`));
-          }
-        }
-        // HELPER, this strips any whitespace and comments to the end of the line
-        // then RETURNS. Last state in a production.
-        parseWhitespaceToEOL() {
-          if (this.char === CHAR_SP || this.char === CTRL_I || this.char === CTRL_M) {
-            return null;
-          } else if (this.char === CHAR_NUM) {
-            return this.goto(this.parseComment);
-          } else if (this.char === Parser.END || this.char === CTRL_J) {
-            return this.return();
-          } else {
-            throw this.error(new TomlError("Unexpected character, expected only whitespace or comments till end of line"));
-          }
-        }
-        /* ASSIGNMENT: key = value */
-        parseAssignStatement() {
-          return this.callNow(this.parseAssign, this.recordAssignStatement);
-        }
-        recordAssignStatement(kv) {
-          let target = this.ctx;
-          let finalKey = kv.key.pop();
-          for (let kw of kv.key) {
-            if (hasKey(target, kw) && (!isTable(target[kw]) || target[kw][_declared])) {
-              throw this.error(new TomlError("Can't redefine existing key"));
-            }
-            target = target[kw] = target[kw] || Table();
-          }
-          if (hasKey(target, finalKey)) {
-            throw this.error(new TomlError("Can't redefine existing key"));
-          }
-          if (isInteger(kv.value) || isFloat(kv.value)) {
-            target[finalKey] = kv.value.valueOf();
-          } else {
-            target[finalKey] = kv.value;
-          }
-          return this.goto(this.parseWhitespaceToEOL);
-        }
-        /* ASSSIGNMENT expression, key = value possibly inside an inline table */
-        parseAssign() {
-          return this.callNow(this.parseKeyword, this.recordAssignKeyword);
-        }
-        recordAssignKeyword(key) {
-          if (this.state.resultTable) {
-            this.state.resultTable.push(key);
-          } else {
-            this.state.resultTable = [key];
-          }
-          return this.goto(this.parseAssignKeywordPreDot);
-        }
-        parseAssignKeywordPreDot() {
-          if (this.char === CHAR_PERIOD) {
-            return this.next(this.parseAssignKeywordPostDot);
-          } else if (this.char !== CHAR_SP && this.char !== CTRL_I) {
-            return this.goto(this.parseAssignEqual);
-          }
-        }
-        parseAssignKeywordPostDot() {
-          if (this.char !== CHAR_SP && this.char !== CTRL_I) {
-            return this.callNow(this.parseKeyword, this.recordAssignKeyword);
-          }
-        }
-        parseAssignEqual() {
-          if (this.char === CHAR_EQUALS) {
-            return this.next(this.parseAssignPreValue);
-          } else {
-            throw this.error(new TomlError('Invalid character, expected "="'));
-          }
-        }
-        parseAssignPreValue() {
-          if (this.char === CHAR_SP || this.char === CTRL_I) {
-            return null;
-          } else {
-            return this.callNow(this.parseValue, this.recordAssignValue);
-          }
-        }
-        recordAssignValue(value) {
-          return this.returnNow({ key: this.state.resultTable, value });
-        }
-        /* COMMENTS: #...eol */
-        parseComment() {
-          do {
-            if (this.char === Parser.END || this.char === CTRL_J) {
-              return this.return();
-            }
-          } while (this.nextChar());
-        }
-        /* TABLES AND LISTS, [foo] and [[foo]] */
-        parseTableOrList() {
-          if (this.char === CHAR_LSQB) {
-            this.next(this.parseList);
-          } else {
-            return this.goto(this.parseTable);
-          }
-        }
-        /* TABLE [foo.bar.baz] */
-        parseTable() {
-          this.ctx = this.obj;
-          return this.goto(this.parseTableNext);
-        }
-        parseTableNext() {
-          if (this.char === CHAR_SP || this.char === CTRL_I) {
-            return null;
-          } else {
-            return this.callNow(this.parseKeyword, this.parseTableMore);
-          }
-        }
-        parseTableMore(keyword) {
-          if (this.char === CHAR_SP || this.char === CTRL_I) {
-            return null;
-          } else if (this.char === CHAR_RSQB) {
-            if (hasKey(this.ctx, keyword) && (!isTable(this.ctx[keyword]) || this.ctx[keyword][_declared])) {
-              throw this.error(new TomlError("Can't redefine existing key"));
-            } else {
-              this.ctx = this.ctx[keyword] = this.ctx[keyword] || Table();
-              this.ctx[_declared] = true;
-            }
-            return this.next(this.parseWhitespaceToEOL);
-          } else if (this.char === CHAR_PERIOD) {
-            if (!hasKey(this.ctx, keyword)) {
-              this.ctx = this.ctx[keyword] = Table();
-            } else if (isTable(this.ctx[keyword])) {
-              this.ctx = this.ctx[keyword];
-            } else if (isList(this.ctx[keyword])) {
-              this.ctx = this.ctx[keyword][this.ctx[keyword].length - 1];
-            } else {
-              throw this.error(new TomlError("Can't redefine existing key"));
-            }
-            return this.next(this.parseTableNext);
-          } else {
-            throw this.error(new TomlError("Unexpected character, expected whitespace, . or ]"));
-          }
-        }
-        /* LIST [[a.b.c]] */
-        parseList() {
-          this.ctx = this.obj;
-          return this.goto(this.parseListNext);
-        }
-        parseListNext() {
-          if (this.char === CHAR_SP || this.char === CTRL_I) {
-            return null;
-          } else {
-            return this.callNow(this.parseKeyword, this.parseListMore);
-          }
-        }
-        parseListMore(keyword) {
-          if (this.char === CHAR_SP || this.char === CTRL_I) {
-            return null;
-          } else if (this.char === CHAR_RSQB) {
-            if (!hasKey(this.ctx, keyword)) {
-              this.ctx[keyword] = List();
-            }
-            if (isInlineList(this.ctx[keyword])) {
-              throw this.error(new TomlError("Can't extend an inline array"));
-            } else if (isList(this.ctx[keyword])) {
-              const next = Table();
-              this.ctx[keyword].push(next);
-              this.ctx = next;
-            } else {
-              throw this.error(new TomlError("Can't redefine an existing key"));
-            }
-            return this.next(this.parseListEnd);
-          } else if (this.char === CHAR_PERIOD) {
-            if (!hasKey(this.ctx, keyword)) {
-              this.ctx = this.ctx[keyword] = Table();
-            } else if (isInlineList(this.ctx[keyword])) {
-              throw this.error(new TomlError("Can't extend an inline array"));
-            } else if (isInlineTable(this.ctx[keyword])) {
-              throw this.error(new TomlError("Can't extend an inline table"));
-            } else if (isList(this.ctx[keyword])) {
-              this.ctx = this.ctx[keyword][this.ctx[keyword].length - 1];
-            } else if (isTable(this.ctx[keyword])) {
-              this.ctx = this.ctx[keyword];
-            } else {
-              throw this.error(new TomlError("Can't redefine an existing key"));
-            }
-            return this.next(this.parseListNext);
-          } else {
-            throw this.error(new TomlError("Unexpected character, expected whitespace, . or ]"));
-          }
-        }
-        parseListEnd(keyword) {
-          if (this.char === CHAR_RSQB) {
-            return this.next(this.parseWhitespaceToEOL);
-          } else {
-            throw this.error(new TomlError("Unexpected character, expected whitespace, . or ]"));
-          }
-        }
-        /* VALUE string, number, boolean, inline list, inline object */
-        parseValue() {
-          if (this.char === Parser.END) {
-            throw this.error(new TomlError("Key without value"));
-          } else if (this.char === CHAR_QUOT) {
-            return this.next(this.parseDoubleString);
-          }
-          if (this.char === CHAR_APOS) {
-            return this.next(this.parseSingleString);
-          } else if (this.char === CHAR_HYPHEN || this.char === CHAR_PLUS) {
-            return this.goto(this.parseNumberSign);
-          } else if (this.char === CHAR_i) {
-            return this.next(this.parseInf);
-          } else if (this.char === CHAR_n) {
-            return this.next(this.parseNan);
-          } else if (isDigit(this.char)) {
-            return this.goto(this.parseNumberOrDateTime);
-          } else if (this.char === CHAR_t || this.char === CHAR_f) {
-            return this.goto(this.parseBoolean);
-          } else if (this.char === CHAR_LSQB) {
-            return this.call(this.parseInlineList, this.recordValue);
-          } else if (this.char === CHAR_LCUB) {
-            return this.call(this.parseInlineTable, this.recordValue);
-          } else {
-            throw this.error(new TomlError("Unexpected character, expecting string, number, datetime, boolean, inline array or inline table"));
-          }
-        }
-        recordValue(value) {
-          return this.returnNow(value);
-        }
-        parseInf() {
-          if (this.char === CHAR_n) {
-            return this.next(this.parseInf2);
-          } else {
-            throw this.error(new TomlError('Unexpected character, expected "inf", "+inf" or "-inf"'));
-          }
-        }
-        parseInf2() {
-          if (this.char === CHAR_f) {
-            if (this.state.buf === "-") {
-              return this.return(-Infinity);
-            } else {
-              return this.return(Infinity);
-            }
-          } else {
-            throw this.error(new TomlError('Unexpected character, expected "inf", "+inf" or "-inf"'));
-          }
-        }
-        parseNan() {
-          if (this.char === CHAR_a) {
-            return this.next(this.parseNan2);
-          } else {
-            throw this.error(new TomlError('Unexpected character, expected "nan"'));
-          }
-        }
-        parseNan2() {
-          if (this.char === CHAR_n) {
-            return this.return(NaN);
-          } else {
-            throw this.error(new TomlError('Unexpected character, expected "nan"'));
-          }
-        }
-        /* KEYS, barewords or basic, literal, or dotted */
-        parseKeyword() {
-          if (this.char === CHAR_QUOT) {
-            return this.next(this.parseBasicString);
-          } else if (this.char === CHAR_APOS) {
-            return this.next(this.parseLiteralString);
-          } else {
-            return this.goto(this.parseBareKey);
-          }
-        }
-        /* KEYS: barewords */
-        parseBareKey() {
-          do {
-            if (this.char === Parser.END) {
-              throw this.error(new TomlError("Key ended without value"));
-            } else if (isAlphaNumHyphen(this.char)) {
-              this.consume();
-            } else if (this.state.buf.length === 0) {
-              throw this.error(new TomlError("Empty bare keys are not allowed"));
-            } else {
-              return this.returnNow();
-            }
-          } while (this.nextChar());
-        }
-        /* STRINGS, single quoted (literal) */
-        parseSingleString() {
-          if (this.char === CHAR_APOS) {
-            return this.next(this.parseLiteralMultiStringMaybe);
-          } else {
-            return this.goto(this.parseLiteralString);
-          }
-        }
-        parseLiteralString() {
-          do {
-            if (this.char === CHAR_APOS) {
-              return this.return();
-            } else if (this.atEndOfLine()) {
-              throw this.error(new TomlError("Unterminated string"));
-            } else if (this.char === CHAR_DEL || this.char <= CTRL_CHAR_BOUNDARY && this.char !== CTRL_I) {
-              throw this.errorControlCharInString();
-            } else {
-              this.consume();
-            }
-          } while (this.nextChar());
-        }
-        parseLiteralMultiStringMaybe() {
-          if (this.char === CHAR_APOS) {
-            return this.next(this.parseLiteralMultiString);
-          } else {
-            return this.returnNow();
-          }
-        }
-        parseLiteralMultiString() {
-          if (this.char === CTRL_M) {
-            return null;
-          } else if (this.char === CTRL_J) {
-            return this.next(this.parseLiteralMultiStringContent);
-          } else {
-            return this.goto(this.parseLiteralMultiStringContent);
-          }
-        }
-        parseLiteralMultiStringContent() {
-          do {
-            if (this.char === CHAR_APOS) {
-              return this.next(this.parseLiteralMultiEnd);
-            } else if (this.char === Parser.END) {
-              throw this.error(new TomlError("Unterminated multi-line string"));
-            } else if (this.char === CHAR_DEL || this.char <= CTRL_CHAR_BOUNDARY && this.char !== CTRL_I && this.char !== CTRL_J && this.char !== CTRL_M) {
-              throw this.errorControlCharInString();
-            } else {
-              this.consume();
-            }
-          } while (this.nextChar());
-        }
-        parseLiteralMultiEnd() {
-          if (this.char === CHAR_APOS) {
-            return this.next(this.parseLiteralMultiEnd2);
-          } else {
-            this.state.buf += "'";
-            return this.goto(this.parseLiteralMultiStringContent);
-          }
-        }
-        parseLiteralMultiEnd2() {
-          if (this.char === CHAR_APOS) {
-            return this.return();
-          } else {
-            this.state.buf += "''";
-            return this.goto(this.parseLiteralMultiStringContent);
-          }
-        }
-        /* STRINGS double quoted */
-        parseDoubleString() {
-          if (this.char === CHAR_QUOT) {
-            return this.next(this.parseMultiStringMaybe);
-          } else {
-            return this.goto(this.parseBasicString);
-          }
-        }
-        parseBasicString() {
-          do {
-            if (this.char === CHAR_BSOL) {
-              return this.call(this.parseEscape, this.recordEscapeReplacement);
-            } else if (this.char === CHAR_QUOT) {
-              return this.return();
-            } else if (this.atEndOfLine()) {
-              throw this.error(new TomlError("Unterminated string"));
-            } else if (this.char === CHAR_DEL || this.char <= CTRL_CHAR_BOUNDARY && this.char !== CTRL_I) {
-              throw this.errorControlCharInString();
-            } else {
-              this.consume();
-            }
-          } while (this.nextChar());
-        }
-        recordEscapeReplacement(replacement) {
-          this.state.buf += replacement;
-          return this.goto(this.parseBasicString);
-        }
-        parseMultiStringMaybe() {
-          if (this.char === CHAR_QUOT) {
-            return this.next(this.parseMultiString);
-          } else {
-            return this.returnNow();
-          }
-        }
-        parseMultiString() {
-          if (this.char === CTRL_M) {
-            return null;
-          } else if (this.char === CTRL_J) {
-            return this.next(this.parseMultiStringContent);
-          } else {
-            return this.goto(this.parseMultiStringContent);
-          }
-        }
-        parseMultiStringContent() {
-          do {
-            if (this.char === CHAR_BSOL) {
-              return this.call(this.parseMultiEscape, this.recordMultiEscapeReplacement);
-            } else if (this.char === CHAR_QUOT) {
-              return this.next(this.parseMultiEnd);
-            } else if (this.char === Parser.END) {
-              throw this.error(new TomlError("Unterminated multi-line string"));
-            } else if (this.char === CHAR_DEL || this.char <= CTRL_CHAR_BOUNDARY && this.char !== CTRL_I && this.char !== CTRL_J && this.char !== CTRL_M) {
-              throw this.errorControlCharInString();
-            } else {
-              this.consume();
-            }
-          } while (this.nextChar());
-        }
-        errorControlCharInString() {
-          let displayCode = "\\u00";
-          if (this.char < 16) {
-            displayCode += "0";
-          }
-          displayCode += this.char.toString(16);
-          return this.error(new TomlError(`Control characters (codes < 0x1f and 0x7f) are not allowed in strings, use ${displayCode} instead`));
-        }
-        recordMultiEscapeReplacement(replacement) {
-          this.state.buf += replacement;
-          return this.goto(this.parseMultiStringContent);
-        }
-        parseMultiEnd() {
-          if (this.char === CHAR_QUOT) {
-            return this.next(this.parseMultiEnd2);
-          } else {
-            this.state.buf += '"';
-            return this.goto(this.parseMultiStringContent);
-          }
-        }
-        parseMultiEnd2() {
-          if (this.char === CHAR_QUOT) {
-            return this.return();
-          } else {
-            this.state.buf += '""';
-            return this.goto(this.parseMultiStringContent);
-          }
-        }
-        parseMultiEscape() {
-          if (this.char === CTRL_M || this.char === CTRL_J) {
-            return this.next(this.parseMultiTrim);
-          } else if (this.char === CHAR_SP || this.char === CTRL_I) {
-            return this.next(this.parsePreMultiTrim);
-          } else {
-            return this.goto(this.parseEscape);
-          }
-        }
-        parsePreMultiTrim() {
-          if (this.char === CHAR_SP || this.char === CTRL_I) {
-            return null;
-          } else if (this.char === CTRL_M || this.char === CTRL_J) {
-            return this.next(this.parseMultiTrim);
-          } else {
-            throw this.error(new TomlError("Can't escape whitespace"));
-          }
-        }
-        parseMultiTrim() {
-          if (this.char === CTRL_J || this.char === CHAR_SP || this.char === CTRL_I || this.char === CTRL_M) {
-            return null;
-          } else {
-            return this.returnNow();
-          }
-        }
-        parseEscape() {
-          if (this.char in escapes) {
-            return this.return(escapes[this.char]);
-          } else if (this.char === CHAR_u) {
-            return this.call(this.parseSmallUnicode, this.parseUnicodeReturn);
-          } else if (this.char === CHAR_U) {
-            return this.call(this.parseLargeUnicode, this.parseUnicodeReturn);
-          } else {
-            throw this.error(new TomlError("Unknown escape character: " + this.char));
-          }
-        }
-        parseUnicodeReturn(char) {
-          try {
-            const codePoint = parseInt(char, 16);
-            if (codePoint >= SURROGATE_FIRST && codePoint <= SURROGATE_LAST) {
-              throw this.error(new TomlError("Invalid unicode, character in range 0xD800 - 0xDFFF is reserved"));
-            }
-            return this.returnNow(String.fromCodePoint(codePoint));
-          } catch (err) {
-            throw this.error(TomlError.wrap(err));
-          }
-        }
-        parseSmallUnicode() {
-          if (!isHexit(this.char)) {
-            throw this.error(new TomlError("Invalid character in unicode sequence, expected hex"));
-          } else {
-            this.consume();
-            if (this.state.buf.length >= 4) return this.return();
-          }
-        }
-        parseLargeUnicode() {
-          if (!isHexit(this.char)) {
-            throw this.error(new TomlError("Invalid character in unicode sequence, expected hex"));
-          } else {
-            this.consume();
-            if (this.state.buf.length >= 8) return this.return();
-          }
-        }
-        /* NUMBERS */
-        parseNumberSign() {
-          this.consume();
-          return this.next(this.parseMaybeSignedInfOrNan);
-        }
-        parseMaybeSignedInfOrNan() {
-          if (this.char === CHAR_i) {
-            return this.next(this.parseInf);
-          } else if (this.char === CHAR_n) {
-            return this.next(this.parseNan);
-          } else {
-            return this.callNow(this.parseNoUnder, this.parseNumberIntegerStart);
-          }
-        }
-        parseNumberIntegerStart() {
-          if (this.char === CHAR_0) {
-            this.consume();
-            return this.next(this.parseNumberIntegerExponentOrDecimal);
-          } else {
-            return this.goto(this.parseNumberInteger);
-          }
-        }
-        parseNumberIntegerExponentOrDecimal() {
-          if (this.char === CHAR_PERIOD) {
-            this.consume();
-            return this.call(this.parseNoUnder, this.parseNumberFloat);
-          } else if (this.char === CHAR_E || this.char === CHAR_e) {
-            this.consume();
-            return this.next(this.parseNumberExponentSign);
-          } else {
-            return this.returnNow(Integer(this.state.buf));
-          }
-        }
-        parseNumberInteger() {
-          if (isDigit(this.char)) {
-            this.consume();
-          } else if (this.char === CHAR_LOWBAR) {
-            return this.call(this.parseNoUnder);
-          } else if (this.char === CHAR_E || this.char === CHAR_e) {
-            this.consume();
-            return this.next(this.parseNumberExponentSign);
-          } else if (this.char === CHAR_PERIOD) {
-            this.consume();
-            return this.call(this.parseNoUnder, this.parseNumberFloat);
-          } else {
-            const result = Integer(this.state.buf);
-            if (result.isNaN()) {
-              throw this.error(new TomlError("Invalid number"));
-            } else {
-              return this.returnNow(result);
-            }
-          }
-        }
-        parseNoUnder() {
-          if (this.char === CHAR_LOWBAR || this.char === CHAR_PERIOD || this.char === CHAR_E || this.char === CHAR_e) {
-            throw this.error(new TomlError("Unexpected character, expected digit"));
-          } else if (this.atEndOfWord()) {
-            throw this.error(new TomlError("Incomplete number"));
-          }
-          return this.returnNow();
-        }
-        parseNoUnderHexOctBinLiteral() {
-          if (this.char === CHAR_LOWBAR || this.char === CHAR_PERIOD) {
-            throw this.error(new TomlError("Unexpected character, expected digit"));
-          } else if (this.atEndOfWord()) {
-            throw this.error(new TomlError("Incomplete number"));
-          }
-          return this.returnNow();
-        }
-        parseNumberFloat() {
-          if (this.char === CHAR_LOWBAR) {
-            return this.call(this.parseNoUnder, this.parseNumberFloat);
-          } else if (isDigit(this.char)) {
-            this.consume();
-          } else if (this.char === CHAR_E || this.char === CHAR_e) {
-            this.consume();
-            return this.next(this.parseNumberExponentSign);
-          } else {
-            return this.returnNow(Float(this.state.buf));
-          }
-        }
-        parseNumberExponentSign() {
-          if (isDigit(this.char)) {
-            return this.goto(this.parseNumberExponent);
-          } else if (this.char === CHAR_HYPHEN || this.char === CHAR_PLUS) {
-            this.consume();
-            this.call(this.parseNoUnder, this.parseNumberExponent);
-          } else {
-            throw this.error(new TomlError("Unexpected character, expected -, + or digit"));
-          }
-        }
-        parseNumberExponent() {
-          if (isDigit(this.char)) {
-            this.consume();
-          } else if (this.char === CHAR_LOWBAR) {
-            return this.call(this.parseNoUnder);
-          } else {
-            return this.returnNow(Float(this.state.buf));
-          }
-        }
-        /* NUMBERS or DATETIMES  */
-        parseNumberOrDateTime() {
-          if (this.char === CHAR_0) {
-            this.consume();
-            return this.next(this.parseNumberBaseOrDateTime);
-          } else {
-            return this.goto(this.parseNumberOrDateTimeOnly);
-          }
-        }
-        parseNumberOrDateTimeOnly() {
-          if (this.char === CHAR_LOWBAR) {
-            return this.call(this.parseNoUnder, this.parseNumberInteger);
-          } else if (isDigit(this.char)) {
-            this.consume();
-            if (this.state.buf.length > 4) this.next(this.parseNumberInteger);
-          } else if (this.char === CHAR_E || this.char === CHAR_e) {
-            this.consume();
-            return this.next(this.parseNumberExponentSign);
-          } else if (this.char === CHAR_PERIOD) {
-            this.consume();
-            return this.call(this.parseNoUnder, this.parseNumberFloat);
-          } else if (this.char === CHAR_HYPHEN) {
-            return this.goto(this.parseDateTime);
-          } else if (this.char === CHAR_COLON) {
-            return this.goto(this.parseOnlyTimeHour);
-          } else {
-            return this.returnNow(Integer(this.state.buf));
-          }
-        }
-        parseDateTimeOnly() {
-          if (this.state.buf.length < 4) {
-            if (isDigit(this.char)) {
-              return this.consume();
-            } else if (this.char === CHAR_COLON) {
-              return this.goto(this.parseOnlyTimeHour);
-            } else {
-              throw this.error(new TomlError("Expected digit while parsing year part of a date"));
-            }
-          } else {
-            if (this.char === CHAR_HYPHEN) {
-              return this.goto(this.parseDateTime);
-            } else {
-              throw this.error(new TomlError("Expected hyphen (-) while parsing year part of date"));
-            }
-          }
-        }
-        parseNumberBaseOrDateTime() {
-          if (this.char === CHAR_b) {
-            this.consume();
-            return this.call(this.parseNoUnderHexOctBinLiteral, this.parseIntegerBin);
-          } else if (this.char === CHAR_o) {
-            this.consume();
-            return this.call(this.parseNoUnderHexOctBinLiteral, this.parseIntegerOct);
-          } else if (this.char === CHAR_x) {
-            this.consume();
-            return this.call(this.parseNoUnderHexOctBinLiteral, this.parseIntegerHex);
-          } else if (this.char === CHAR_PERIOD) {
-            return this.goto(this.parseNumberInteger);
-          } else if (isDigit(this.char)) {
-            return this.goto(this.parseDateTimeOnly);
-          } else {
-            return this.returnNow(Integer(this.state.buf));
-          }
-        }
-        parseIntegerHex() {
-          if (isHexit(this.char)) {
-            this.consume();
-          } else if (this.char === CHAR_LOWBAR) {
-            return this.call(this.parseNoUnderHexOctBinLiteral);
-          } else {
-            const result = Integer(this.state.buf);
-            if (result.isNaN()) {
-              throw this.error(new TomlError("Invalid number"));
-            } else {
-              return this.returnNow(result);
-            }
-          }
-        }
-        parseIntegerOct() {
-          if (isOctit(this.char)) {
-            this.consume();
-          } else if (this.char === CHAR_LOWBAR) {
-            return this.call(this.parseNoUnderHexOctBinLiteral);
-          } else {
-            const result = Integer(this.state.buf);
-            if (result.isNaN()) {
-              throw this.error(new TomlError("Invalid number"));
-            } else {
-              return this.returnNow(result);
-            }
-          }
-        }
-        parseIntegerBin() {
-          if (isBit(this.char)) {
-            this.consume();
-          } else if (this.char === CHAR_LOWBAR) {
-            return this.call(this.parseNoUnderHexOctBinLiteral);
-          } else {
-            const result = Integer(this.state.buf);
-            if (result.isNaN()) {
-              throw this.error(new TomlError("Invalid number"));
-            } else {
-              return this.returnNow(result);
-            }
-          }
-        }
-        /* DATETIME */
-        parseDateTime() {
-          if (this.state.buf.length < 4) {
-            throw this.error(new TomlError("Years less than 1000 must be zero padded to four characters"));
-          }
-          this.state.result = this.state.buf;
-          this.state.buf = "";
-          return this.next(this.parseDateMonth);
-        }
-        parseDateMonth() {
-          if (this.char === CHAR_HYPHEN) {
-            if (this.state.buf.length < 2) {
-              throw this.error(new TomlError("Months less than 10 must be zero padded to two characters"));
-            }
-            this.state.result += "-" + this.state.buf;
-            this.state.buf = "";
-            return this.next(this.parseDateDay);
-          } else if (isDigit(this.char)) {
-            this.consume();
-          } else {
-            throw this.error(new TomlError("Incomplete datetime"));
-          }
-        }
-        parseDateDay() {
-          if (this.char === CHAR_T || this.char === CHAR_SP) {
-            if (this.state.buf.length < 2) {
-              throw this.error(new TomlError("Days less than 10 must be zero padded to two characters"));
-            }
-            this.state.result += "-" + this.state.buf;
-            this.state.buf = "";
-            return this.next(this.parseStartTimeHour);
-          } else if (this.atEndOfWord()) {
-            return this.returnNow(createDate(this.state.result + "-" + this.state.buf));
-          } else if (isDigit(this.char)) {
-            this.consume();
-          } else {
-            throw this.error(new TomlError("Incomplete datetime"));
-          }
-        }
-        parseStartTimeHour() {
-          if (this.atEndOfWord()) {
-            return this.returnNow(createDate(this.state.result));
-          } else {
-            return this.goto(this.parseTimeHour);
-          }
-        }
-        parseTimeHour() {
-          if (this.char === CHAR_COLON) {
-            if (this.state.buf.length < 2) {
-              throw this.error(new TomlError("Hours less than 10 must be zero padded to two characters"));
-            }
-            this.state.result += "T" + this.state.buf;
-            this.state.buf = "";
-            return this.next(this.parseTimeMin);
-          } else if (isDigit(this.char)) {
-            this.consume();
-          } else {
-            throw this.error(new TomlError("Incomplete datetime"));
-          }
-        }
-        parseTimeMin() {
-          if (this.state.buf.length < 2 && isDigit(this.char)) {
-            this.consume();
-          } else if (this.state.buf.length === 2 && this.char === CHAR_COLON) {
-            this.state.result += ":" + this.state.buf;
-            this.state.buf = "";
-            return this.next(this.parseTimeSec);
-          } else {
-            throw this.error(new TomlError("Incomplete datetime"));
-          }
-        }
-        parseTimeSec() {
-          if (isDigit(this.char)) {
-            this.consume();
-            if (this.state.buf.length === 2) {
-              this.state.result += ":" + this.state.buf;
-              this.state.buf = "";
-              return this.next(this.parseTimeZoneOrFraction);
-            }
-          } else {
-            throw this.error(new TomlError("Incomplete datetime"));
-          }
-        }
-        parseOnlyTimeHour() {
-          if (this.char === CHAR_COLON) {
-            if (this.state.buf.length < 2) {
-              throw this.error(new TomlError("Hours less than 10 must be zero padded to two characters"));
-            }
-            this.state.result = this.state.buf;
-            this.state.buf = "";
-            return this.next(this.parseOnlyTimeMin);
-          } else {
-            throw this.error(new TomlError("Incomplete time"));
-          }
-        }
-        parseOnlyTimeMin() {
-          if (this.state.buf.length < 2 && isDigit(this.char)) {
-            this.consume();
-          } else if (this.state.buf.length === 2 && this.char === CHAR_COLON) {
-            this.state.result += ":" + this.state.buf;
-            this.state.buf = "";
-            return this.next(this.parseOnlyTimeSec);
-          } else {
-            throw this.error(new TomlError("Incomplete time"));
-          }
-        }
-        parseOnlyTimeSec() {
-          if (isDigit(this.char)) {
-            this.consume();
-            if (this.state.buf.length === 2) {
-              return this.next(this.parseOnlyTimeFractionMaybe);
-            }
-          } else {
-            throw this.error(new TomlError("Incomplete time"));
-          }
-        }
-        parseOnlyTimeFractionMaybe() {
-          this.state.result += ":" + this.state.buf;
-          if (this.char === CHAR_PERIOD) {
-            this.state.buf = "";
-            this.next(this.parseOnlyTimeFraction);
-          } else {
-            return this.return(createTime(this.state.result));
-          }
-        }
-        parseOnlyTimeFraction() {
-          if (isDigit(this.char)) {
-            this.consume();
-          } else if (this.atEndOfWord()) {
-            if (this.state.buf.length === 0) throw this.error(new TomlError("Expected digit in milliseconds"));
-            return this.returnNow(createTime(this.state.result + "." + this.state.buf));
-          } else {
-            throw this.error(new TomlError("Unexpected character in datetime, expected period (.), minus (-), plus (+) or Z"));
-          }
-        }
-        parseTimeZoneOrFraction() {
-          if (this.char === CHAR_PERIOD) {
-            this.consume();
-            this.next(this.parseDateTimeFraction);
-          } else if (this.char === CHAR_HYPHEN || this.char === CHAR_PLUS) {
-            this.consume();
-            this.next(this.parseTimeZoneHour);
-          } else if (this.char === CHAR_Z) {
-            this.consume();
-            return this.return(createDateTime(this.state.result + this.state.buf));
-          } else if (this.atEndOfWord()) {
-            return this.returnNow(createDateTimeFloat(this.state.result + this.state.buf));
-          } else {
-            throw this.error(new TomlError("Unexpected character in datetime, expected period (.), minus (-), plus (+) or Z"));
-          }
-        }
-        parseDateTimeFraction() {
-          if (isDigit(this.char)) {
-            this.consume();
-          } else if (this.state.buf.length === 1) {
-            throw this.error(new TomlError("Expected digit in milliseconds"));
-          } else if (this.char === CHAR_HYPHEN || this.char === CHAR_PLUS) {
-            this.consume();
-            this.next(this.parseTimeZoneHour);
-          } else if (this.char === CHAR_Z) {
-            this.consume();
-            return this.return(createDateTime(this.state.result + this.state.buf));
-          } else if (this.atEndOfWord()) {
-            return this.returnNow(createDateTimeFloat(this.state.result + this.state.buf));
-          } else {
-            throw this.error(new TomlError("Unexpected character in datetime, expected period (.), minus (-), plus (+) or Z"));
-          }
-        }
-        parseTimeZoneHour() {
-          if (isDigit(this.char)) {
-            this.consume();
-            if (/\d\d$/.test(this.state.buf)) return this.next(this.parseTimeZoneSep);
-          } else {
-            throw this.error(new TomlError("Unexpected character in datetime, expected digit"));
-          }
-        }
-        parseTimeZoneSep() {
-          if (this.char === CHAR_COLON) {
-            this.consume();
-            this.next(this.parseTimeZoneMin);
-          } else {
-            throw this.error(new TomlError("Unexpected character in datetime, expected colon"));
-          }
-        }
-        parseTimeZoneMin() {
-          if (isDigit(this.char)) {
-            this.consume();
-            if (/\d\d$/.test(this.state.buf)) return this.return(createDateTime(this.state.result + this.state.buf));
-          } else {
-            throw this.error(new TomlError("Unexpected character in datetime, expected digit"));
-          }
-        }
-        /* BOOLEAN */
-        parseBoolean() {
-          if (this.char === CHAR_t) {
-            this.consume();
-            return this.next(this.parseTrue_r);
-          } else if (this.char === CHAR_f) {
-            this.consume();
-            return this.next(this.parseFalse_a);
-          }
-        }
-        parseTrue_r() {
-          if (this.char === CHAR_r) {
-            this.consume();
-            return this.next(this.parseTrue_u);
-          } else {
-            throw this.error(new TomlError("Invalid boolean, expected true or false"));
-          }
-        }
-        parseTrue_u() {
-          if (this.char === CHAR_u) {
-            this.consume();
-            return this.next(this.parseTrue_e);
-          } else {
-            throw this.error(new TomlError("Invalid boolean, expected true or false"));
-          }
-        }
-        parseTrue_e() {
-          if (this.char === CHAR_e) {
-            return this.return(true);
-          } else {
-            throw this.error(new TomlError("Invalid boolean, expected true or false"));
-          }
-        }
-        parseFalse_a() {
-          if (this.char === CHAR_a) {
-            this.consume();
-            return this.next(this.parseFalse_l);
-          } else {
-            throw this.error(new TomlError("Invalid boolean, expected true or false"));
-          }
-        }
-        parseFalse_l() {
-          if (this.char === CHAR_l) {
-            this.consume();
-            return this.next(this.parseFalse_s);
-          } else {
-            throw this.error(new TomlError("Invalid boolean, expected true or false"));
-          }
-        }
-        parseFalse_s() {
-          if (this.char === CHAR_s) {
-            this.consume();
-            return this.next(this.parseFalse_e);
-          } else {
-            throw this.error(new TomlError("Invalid boolean, expected true or false"));
-          }
-        }
-        parseFalse_e() {
-          if (this.char === CHAR_e) {
-            return this.return(false);
-          } else {
-            throw this.error(new TomlError("Invalid boolean, expected true or false"));
-          }
-        }
-        /* INLINE LISTS */
-        parseInlineList() {
-          if (this.char === CHAR_SP || this.char === CTRL_I || this.char === CTRL_M || this.char === CTRL_J) {
-            return null;
-          } else if (this.char === Parser.END) {
-            throw this.error(new TomlError("Unterminated inline array"));
-          } else if (this.char === CHAR_NUM) {
-            return this.call(this.parseComment);
-          } else if (this.char === CHAR_RSQB) {
-            return this.return(this.state.resultArr || InlineList());
-          } else {
-            return this.callNow(this.parseValue, this.recordInlineListValue);
-          }
-        }
-        recordInlineListValue(value) {
-          if (this.state.resultArr) {
-            const listType = this.state.resultArr[_contentType];
-            const valueType = tomlType(value);
-            if (listType !== valueType) {
-              throw this.error(new TomlError(`Inline lists must be a single type, not a mix of ${listType} and ${valueType}`));
-            }
-          } else {
-            this.state.resultArr = InlineList(tomlType(value));
-          }
-          if (isFloat(value) || isInteger(value)) {
-            this.state.resultArr.push(value.valueOf());
-          } else {
-            this.state.resultArr.push(value);
-          }
-          return this.goto(this.parseInlineListNext);
-        }
-        parseInlineListNext() {
-          if (this.char === CHAR_SP || this.char === CTRL_I || this.char === CTRL_M || this.char === CTRL_J) {
-            return null;
-          } else if (this.char === CHAR_NUM) {
-            return this.call(this.parseComment);
-          } else if (this.char === CHAR_COMMA) {
-            return this.next(this.parseInlineList);
-          } else if (this.char === CHAR_RSQB) {
-            return this.goto(this.parseInlineList);
-          } else {
-            throw this.error(new TomlError("Invalid character, expected whitespace, comma (,) or close bracket (])"));
-          }
-        }
-        /* INLINE TABLE */
-        parseInlineTable() {
-          if (this.char === CHAR_SP || this.char === CTRL_I) {
-            return null;
-          } else if (this.char === Parser.END || this.char === CHAR_NUM || this.char === CTRL_J || this.char === CTRL_M) {
-            throw this.error(new TomlError("Unterminated inline array"));
-          } else if (this.char === CHAR_RCUB) {
-            return this.return(this.state.resultTable || InlineTable());
-          } else {
-            if (!this.state.resultTable) this.state.resultTable = InlineTable();
-            return this.callNow(this.parseAssign, this.recordInlineTableValue);
-          }
-        }
-        recordInlineTableValue(kv) {
-          let target = this.state.resultTable;
-          let finalKey = kv.key.pop();
-          for (let kw of kv.key) {
-            if (hasKey(target, kw) && (!isTable(target[kw]) || target[kw][_declared])) {
-              throw this.error(new TomlError("Can't redefine existing key"));
-            }
-            target = target[kw] = target[kw] || Table();
-          }
-          if (hasKey(target, finalKey)) {
-            throw this.error(new TomlError("Can't redefine existing key"));
-          }
-          if (isInteger(kv.value) || isFloat(kv.value)) {
-            target[finalKey] = kv.value.valueOf();
-          } else {
-            target[finalKey] = kv.value;
-          }
-          return this.goto(this.parseInlineTableNext);
-        }
-        parseInlineTableNext() {
-          if (this.char === CHAR_SP || this.char === CTRL_I) {
-            return null;
-          } else if (this.char === Parser.END || this.char === CHAR_NUM || this.char === CTRL_J || this.char === CTRL_M) {
-            throw this.error(new TomlError("Unterminated inline array"));
-          } else if (this.char === CHAR_COMMA) {
-            return this.next(this.parseInlineTable);
-          } else if (this.char === CHAR_RCUB) {
-            return this.goto(this.parseInlineTable);
-          } else {
-            throw this.error(new TomlError("Invalid character, expected whitespace, comma (,) or close bracket (])"));
-          }
-        }
-      }
-      return TOMLParser;
-    }
-  }
-});
-
-// node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/parse-pretty-error.js
-var require_parse_pretty_error = __commonJS({
-  "node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/parse-pretty-error.js"(exports2, module2) {
-    "use strict";
-    module2.exports = prettyError;
-    function prettyError(err, buf) {
-      if (err.pos == null || err.line == null) return err;
-      let msg = err.message;
-      msg += ` at row ${err.line + 1}, col ${err.col + 1}, pos ${err.pos}:
-`;
-      if (buf && buf.split) {
-        const lines = buf.split(/\n/);
-        const lineNumWidth = String(Math.min(lines.length, err.line + 3)).length;
-        let linePadding = " ";
-        while (linePadding.length < lineNumWidth) linePadding += " ";
-        for (let ii = Math.max(0, err.line - 1); ii < Math.min(lines.length, err.line + 2); ++ii) {
-          let lineNum = String(ii + 1);
-          if (lineNum.length < lineNumWidth) lineNum = " " + lineNum;
-          if (err.line === ii) {
-            msg += lineNum + "> " + lines[ii] + "\n";
-            msg += linePadding + "  ";
-            for (let hh = 0; hh < err.col; ++hh) {
-              msg += " ";
-            }
-            msg += "^\n";
-          } else {
-            msg += lineNum + ": " + lines[ii] + "\n";
-          }
-        }
-      }
-      err.message = msg + "\n";
-      return err;
-    }
-  }
-});
-
-// node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/parse-string.js
-var require_parse_string = __commonJS({
-  "node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/parse-string.js"(exports2, module2) {
-    "use strict";
-    module2.exports = parseString;
-    var TOMLParser = require_toml_parser();
-    var prettyError = require_parse_pretty_error();
-    function parseString(str) {
-      if (global.Buffer && global.Buffer.isBuffer(str)) {
-        str = str.toString("utf8");
-      }
-      const parser = new TOMLParser();
-      try {
-        parser.parse(str);
-        return parser.finish();
-      } catch (err) {
-        throw prettyError(err, str);
-      }
-    }
-  }
-});
-
-// node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/parse-async.js
-var require_parse_async = __commonJS({
-  "node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/parse-async.js"(exports2, module2) {
-    "use strict";
-    module2.exports = parseAsync;
-    var TOMLParser = require_toml_parser();
-    var prettyError = require_parse_pretty_error();
-    function parseAsync(str, opts) {
-      if (!opts) opts = {};
-      const index = 0;
-      const blocksize = opts.blocksize || 40960;
-      const parser = new TOMLParser();
-      return new Promise((resolve4, reject) => {
-        setImmediate(parseAsyncNext, index, blocksize, resolve4, reject);
-      });
-      function parseAsyncNext(index2, blocksize2, resolve4, reject) {
-        if (index2 >= str.length) {
-          try {
-            return resolve4(parser.finish());
-          } catch (err) {
-            return reject(prettyError(err, str));
-          }
-        }
-        try {
-          parser.parse(str.slice(index2, index2 + blocksize2));
-          setImmediate(parseAsyncNext, index2 + blocksize2, blocksize2, resolve4, reject);
-        } catch (err) {
-          reject(prettyError(err, str));
-        }
-      }
-    }
-  }
-});
-
-// node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/parse-stream.js
-var require_parse_stream = __commonJS({
-  "node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/parse-stream.js"(exports2, module2) {
-    "use strict";
-    module2.exports = parseStream;
-    var stream = __require("stream");
-    var TOMLParser = require_toml_parser();
-    function parseStream(stm) {
-      if (stm) {
-        return parseReadable(stm);
-      } else {
-        return parseTransform(stm);
-      }
-    }
-    function parseReadable(stm) {
-      const parser = new TOMLParser();
-      stm.setEncoding("utf8");
-      return new Promise((resolve4, reject) => {
-        let readable;
-        let ended = false;
-        let errored = false;
-        function finish() {
-          ended = true;
-          if (readable) return;
-          try {
-            resolve4(parser.finish());
-          } catch (err) {
-            reject(err);
-          }
-        }
-        function error(err) {
-          errored = true;
-          reject(err);
-        }
-        stm.once("end", finish);
-        stm.once("error", error);
-        readNext();
-        function readNext() {
-          readable = true;
-          let data;
-          while ((data = stm.read()) !== null) {
-            try {
-              parser.parse(data);
-            } catch (err) {
-              return error(err);
-            }
-          }
-          readable = false;
-          if (ended) return finish();
-          if (errored) return;
-          stm.once("readable", readNext);
-        }
-      });
-    }
-    function parseTransform() {
-      const parser = new TOMLParser();
-      return new stream.Transform({
-        objectMode: true,
-        transform(chunk, encoding, cb) {
-          try {
-            parser.parse(chunk.toString(encoding));
-          } catch (err) {
-            this.emit("error", err);
-          }
-          cb();
-        },
-        flush(cb) {
-          try {
-            this.push(parser.finish());
-          } catch (err) {
-            this.emit("error", err);
-          }
-          cb();
-        }
-      });
-    }
-  }
-});
-
-// node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/parse.js
-var require_parse = __commonJS({
-  "node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/parse.js"(exports2, module2) {
-    "use strict";
-    module2.exports = require_parse_string();
-    module2.exports.async = require_parse_async();
-    module2.exports.stream = require_parse_stream();
-    module2.exports.prettyError = require_parse_pretty_error();
-  }
-});
-
-// node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/stringify.js
-var require_stringify = __commonJS({
-  "node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/stringify.js"(exports2, module2) {
-    "use strict";
-    module2.exports = stringify;
-    module2.exports.value = stringifyInline;
-    function stringify(obj) {
-      if (obj === null) throw typeError("null");
-      if (obj === void 0) throw typeError("undefined");
-      if (typeof obj !== "object") throw typeError(typeof obj);
-      if (typeof obj.toJSON === "function") obj = obj.toJSON();
-      if (obj == null) return null;
-      const type = tomlType2(obj);
-      if (type !== "table") throw typeError(type);
-      return stringifyObject("", "", obj);
-    }
-    function typeError(type) {
-      return new Error("Can only stringify objects, not " + type);
-    }
-    function arrayOneTypeError() {
-      return new Error("Array values can't have mixed types");
-    }
-    function getInlineKeys(obj) {
-      return Object.keys(obj).filter((key) => isInline(obj[key]));
-    }
-    function getComplexKeys(obj) {
-      return Object.keys(obj).filter((key) => !isInline(obj[key]));
-    }
-    function toJSON(obj) {
-      let nobj = Array.isArray(obj) ? [] : Object.prototype.hasOwnProperty.call(obj, "__proto__") ? { ["__proto__"]: void 0 } : {};
-      for (let prop of Object.keys(obj)) {
-        if (obj[prop] && typeof obj[prop].toJSON === "function" && !("toISOString" in obj[prop])) {
-          nobj[prop] = obj[prop].toJSON();
-        } else {
-          nobj[prop] = obj[prop];
-        }
-      }
-      return nobj;
-    }
-    function stringifyObject(prefix, indent, obj) {
-      obj = toJSON(obj);
-      var inlineKeys;
-      var complexKeys;
-      inlineKeys = getInlineKeys(obj);
-      complexKeys = getComplexKeys(obj);
-      var result = [];
-      var inlineIndent = indent || "";
-      inlineKeys.forEach((key) => {
-        var type = tomlType2(obj[key]);
-        if (type !== "undefined" && type !== "null") {
-          result.push(inlineIndent + stringifyKey(key) + " = " + stringifyAnyInline(obj[key], true));
-        }
-      });
-      if (result.length > 0) result.push("");
-      var complexIndent = prefix && inlineKeys.length > 0 ? indent + "  " : "";
-      complexKeys.forEach((key) => {
-        result.push(stringifyComplex(prefix, complexIndent, key, obj[key]));
-      });
-      return result.join("\n");
-    }
-    function isInline(value) {
-      switch (tomlType2(value)) {
-        case "undefined":
-        case "null":
-        case "integer":
-        case "nan":
-        case "float":
-        case "boolean":
-        case "string":
-        case "datetime":
-          return true;
-        case "array":
-          return value.length === 0 || tomlType2(value[0]) !== "table";
-        case "table":
-          return Object.keys(value).length === 0;
-        /* istanbul ignore next */
-        default:
-          return false;
-      }
-    }
-    function tomlType2(value) {
-      if (value === void 0) {
-        return "undefined";
-      } else if (value === null) {
-        return "null";
-      } else if (typeof value === "bigint" || Number.isInteger(value) && !Object.is(value, -0)) {
-        return "integer";
-      } else if (typeof value === "number") {
-        return "float";
-      } else if (typeof value === "boolean") {
-        return "boolean";
-      } else if (typeof value === "string") {
-        return "string";
-      } else if ("toISOString" in value) {
-        return isNaN(value) ? "undefined" : "datetime";
-      } else if (Array.isArray(value)) {
-        return "array";
-      } else {
-        return "table";
-      }
-    }
-    function stringifyKey(key) {
-      var keyStr = String(key);
-      if (/^[-A-Za-z0-9_]+$/.test(keyStr)) {
-        return keyStr;
-      } else {
-        return stringifyBasicString(keyStr);
-      }
-    }
-    function stringifyBasicString(str) {
-      return '"' + escapeString(str).replace(/"/g, '\\"') + '"';
-    }
-    function stringifyLiteralString(str) {
-      return "'" + str + "'";
-    }
-    function numpad(num, str) {
-      while (str.length < num) str = "0" + str;
-      return str;
-    }
-    function escapeString(str) {
-      return str.replace(/\\/g, "\\\\").replace(/[\b]/g, "\\b").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\f/g, "\\f").replace(/\r/g, "\\r").replace(/([\u0000-\u001f\u007f])/, (c) => "\\u" + numpad(4, c.codePointAt(0).toString(16)));
-    }
-    function stringifyMultilineString(str) {
-      let escaped = str.split(/\n/).map((str2) => {
-        return escapeString(str2).replace(/"(?="")/g, '\\"');
-      }).join("\n");
-      if (escaped.slice(-1) === '"') escaped += "\\\n";
-      return '"""\n' + escaped + '"""';
-    }
-    function stringifyAnyInline(value, multilineOk) {
-      let type = tomlType2(value);
-      if (type === "string") {
-        if (multilineOk && /\n/.test(value)) {
-          type = "string-multiline";
-        } else if (!/[\b\t\n\f\r']/.test(value) && /"/.test(value)) {
-          type = "string-literal";
-        }
-      }
-      return stringifyInline(value, type);
-    }
-    function stringifyInline(value, type) {
-      if (!type) type = tomlType2(value);
-      switch (type) {
-        case "string-multiline":
-          return stringifyMultilineString(value);
-        case "string":
-          return stringifyBasicString(value);
-        case "string-literal":
-          return stringifyLiteralString(value);
-        case "integer":
-          return stringifyInteger(value);
-        case "float":
-          return stringifyFloat(value);
-        case "boolean":
-          return stringifyBoolean(value);
-        case "datetime":
-          return stringifyDatetime(value);
-        case "array":
-          return stringifyInlineArray(value.filter((_) => tomlType2(_) !== "null" && tomlType2(_) !== "undefined" && tomlType2(_) !== "nan"));
-        case "table":
-          return stringifyInlineTable(value);
-        /* istanbul ignore next */
-        default:
-          throw typeError(type);
-      }
-    }
-    function stringifyInteger(value) {
-      return String(value).replace(/\B(?=(\d{3})+(?!\d))/g, "_");
-    }
-    function stringifyFloat(value) {
-      if (value === Infinity) {
-        return "inf";
-      } else if (value === -Infinity) {
-        return "-inf";
-      } else if (Object.is(value, NaN)) {
-        return "nan";
-      } else if (Object.is(value, -0)) {
-        return "-0.0";
-      }
-      var chunks = String(value).split(".");
-      var int = chunks[0];
-      var dec = chunks[1] || 0;
-      return stringifyInteger(int) + "." + dec;
-    }
-    function stringifyBoolean(value) {
-      return String(value);
-    }
-    function stringifyDatetime(value) {
-      return value.toISOString();
-    }
-    function isNumber(type) {
-      return type === "float" || type === "integer";
-    }
-    function arrayType(values) {
-      var contentType = tomlType2(values[0]);
-      if (values.every((_) => tomlType2(_) === contentType)) return contentType;
-      if (values.every((_) => isNumber(tomlType2(_)))) return "float";
-      return "mixed";
-    }
-    function validateArray(values) {
-      const type = arrayType(values);
-      if (type === "mixed") {
-        throw arrayOneTypeError();
-      }
-      return type;
-    }
-    function stringifyInlineArray(values) {
-      values = toJSON(values);
-      const type = validateArray(values);
-      var result = "[";
-      var stringified = values.map((_) => stringifyInline(_, type));
-      if (stringified.join(", ").length > 60 || /\n/.test(stringified)) {
-        result += "\n  " + stringified.join(",\n  ") + "\n";
-      } else {
-        result += " " + stringified.join(", ") + (stringified.length > 0 ? " " : "");
-      }
-      return result + "]";
-    }
-    function stringifyInlineTable(value) {
-      value = toJSON(value);
-      var result = [];
-      Object.keys(value).forEach((key) => {
-        result.push(stringifyKey(key) + " = " + stringifyAnyInline(value[key], false));
-      });
-      return "{ " + result.join(", ") + (result.length > 0 ? " " : "") + "}";
-    }
-    function stringifyComplex(prefix, indent, key, value) {
-      var valueType = tomlType2(value);
-      if (valueType === "array") {
-        return stringifyArrayOfTables(prefix, indent, key, value);
-      } else if (valueType === "table") {
-        return stringifyComplexTable(prefix, indent, key, value);
-      } else {
-        throw typeError(valueType);
-      }
-    }
-    function stringifyArrayOfTables(prefix, indent, key, values) {
-      values = toJSON(values);
-      validateArray(values);
-      var firstValueType = tomlType2(values[0]);
-      if (firstValueType !== "table") throw typeError(firstValueType);
-      var fullKey = prefix + stringifyKey(key);
-      var result = "";
-      values.forEach((table) => {
-        if (result.length > 0) result += "\n";
-        result += indent + "[[" + fullKey + "]]\n";
-        result += stringifyObject(fullKey + ".", indent, table);
-      });
-      return result;
-    }
-    function stringifyComplexTable(prefix, indent, key, value) {
-      var fullKey = prefix + stringifyKey(key);
-      var result = "";
-      if (getInlineKeys(value).length > 0) {
-        result += indent + "[" + fullKey + "]\n";
-      }
-      return result + stringifyObject(fullKey + ".", indent, value);
-    }
-  }
-});
-
-// node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/toml.js
-var require_toml = __commonJS({
-  "node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/toml.js"(exports2) {
-    "use strict";
-    exports2.parse = require_parse();
-    exports2.stringify = require_stringify();
-  }
-});
-
-// packages/runtime/src/llm-client.ts
-var LLMClient = class {
-  baseUrl;
-  model;
-  maxTokens;
-  temperature;
-  apiKey;
-  constructor(config) {
-    this.baseUrl = config.base_url;
-    this.model = config.model;
-    this.maxTokens = config.max_tokens;
-    this.temperature = config.temperature;
-    this.apiKey = config.api_key ?? "";
-  }
-  async chat(messages) {
-    const resp = await fetch(`${this.baseUrl}/chat/completions`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        ...this.apiKey ? { Authorization: `Bearer ${this.apiKey}` } : {}
-      },
-      body: JSON.stringify({
-        model: this.model,
-        messages,
-        max_tokens: this.maxTokens,
-        temperature: this.temperature
-      })
-    });
-    if (!resp.ok) {
-      const body = await resp.text();
-      throw new Error(`LLM request failed: ${resp.status} ${body}`);
-    }
-    const data = await resp.json();
-    return {
-      content: data.choices[0].message.content,
-      model: data.model,
-      usage: data.usage
-    };
-  }
-};
-
-// packages/runtime/src/memory-client.ts
-var MemoryClient = class {
-  baseUrl;
-  topK;
-  constructor(config) {
-    this.baseUrl = config.daemon_url;
-    this.topK = config.top_k;
-  }
-  async storeEpisode(input) {
-    const resp = await fetch(`${this.baseUrl}/episodes`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify(input)
-    });
-    if (!resp.ok) {
-      throw new Error(`Memory store failed: ${resp.status} ${await resp.text()}`);
-    }
-    return resp.json();
-  }
-  async search(query, context, limit) {
-    const params = new URLSearchParams({ q: query });
-    if (context) params.set("context", context);
-    params.set("limit", String(limit ?? this.topK));
-    const resp = await fetch(`${this.baseUrl}/search?${params}`);
-    if (!resp.ok) {
-      throw new Error(`Memory search failed: ${resp.status} ${await resp.text()}`);
-    }
-    const data = await resp.json();
-    return data.episodes;
-  }
-  async getContext(name) {
-    const resp = await fetch(`${this.baseUrl}/contexts/${encodeURIComponent(name)}`);
-    if (!resp.ok) {
-      throw new Error(`Get context failed: ${resp.status} ${await resp.text()}`);
-    }
-    return resp.json();
-  }
-  async createContext(name, description = "") {
-    const resp = await fetch(`${this.baseUrl}/contexts`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ name, description })
-    });
-    if (!resp.ok) {
-      throw new Error(`Create context failed: ${resp.status} ${await resp.text()}`);
-    }
-  }
-  async deleteContext(name) {
-    const resp = await fetch(`${this.baseUrl}/contexts/${encodeURIComponent(name)}`, {
-      method: "DELETE"
-    });
-    if (!resp.ok) {
-      throw new Error(`Delete context failed: ${resp.status} ${await resp.text()}`);
-    }
-  }
-  async listContexts() {
-    const resp = await fetch(`${this.baseUrl}/contexts`);
-    if (!resp.ok) {
-      throw new Error(`List contexts failed: ${resp.status} ${await resp.text()}`);
-    }
-    const data = await resp.json();
-    return data.contexts;
-  }
-  async searchCrossContext(query, limit) {
-    const params = new URLSearchParams({ q: query });
-    params.set("limit", String(limit ?? this.topK));
-    const resp = await fetch(`${this.baseUrl}/search/cross-context?${params}`);
-    if (!resp.ok) {
-      throw new Error(`Cross-context search failed: ${resp.status} ${await resp.text()}`);
-    }
-    const data = await resp.json();
-    return data.results;
-  }
-  async shareEpisode(episodeId, targetContext) {
-    const resp = await fetch(`${this.baseUrl}/episodes/${encodeURIComponent(episodeId)}/share`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ target_context: targetContext })
-    });
-    if (!resp.ok) {
-      throw new Error(`Share episode failed: ${resp.status} ${await resp.text()}`);
-    }
-  }
-  async runPromotion(contextName) {
-    const params = new URLSearchParams();
-    if (contextName) params.set("context", contextName);
-    const resp = await fetch(`${this.baseUrl}/promotion/run?${params}`, {
-      method: "POST"
-    });
-    if (!resp.ok) {
-      throw new Error(`Promotion failed: ${resp.status} ${await resp.text()}`);
-    }
-    return resp.json();
-  }
-  async getL3Knowledge(contextName) {
-    const resp = await fetch(
-      `${this.baseUrl}/promotion/l3?context=${encodeURIComponent(contextName)}`
-    );
-    if (!resp.ok) {
-      throw new Error(`Get L3 failed: ${resp.status} ${await resp.text()}`);
-    }
-    const data = await resp.json();
-    return data.entries;
-  }
-  async setContextScoring(contextName, halfLifeHours) {
-    const resp = await fetch(
-      `${this.baseUrl}/contexts/${encodeURIComponent(contextName)}/scoring`,
-      {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ half_life_hours: halfLifeHours })
-      }
-    );
-    if (!resp.ok) {
-      throw new Error(`Set scoring failed: ${resp.status} ${await resp.text()}`);
-    }
-  }
-  async recordAccess(episodeId) {
-    const resp = await fetch(`${this.baseUrl}/episodes/${encodeURIComponent(episodeId)}/access`, {
-      method: "POST"
-    });
-    if (!resp.ok) {
-      throw new Error(`Record access failed: ${resp.status} ${await resp.text()}`);
-    }
-  }
-  async recordCoAccess(episodeIds) {
-    const resp = await fetch(`${this.baseUrl}/episodes/co-access`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ episode_ids: episodeIds })
-    });
-    if (!resp.ok) {
-      throw new Error(`Co-access failed: ${resp.status} ${await resp.text()}`);
-    }
-  }
-  // Task engine methods
-  async createTask(input) {
-    const resp = await fetch(`${this.baseUrl}/tasks`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify(input)
-    });
-    if (!resp.ok) {
-      throw new Error(`Create task failed: ${resp.status} ${await resp.text()}`);
-    }
-    return resp.json();
-  }
-  async listTasks(contextName, status) {
-    const params = new URLSearchParams({ context: contextName });
-    if (status) params.set("status", status);
-    const resp = await fetch(`${this.baseUrl}/tasks?${params}`);
-    if (!resp.ok) {
-      throw new Error(`List tasks failed: ${resp.status} ${await resp.text()}`);
-    }
-    const data = await resp.json();
-    return data.tasks;
-  }
-  async updateTask(taskId, updates) {
-    const resp = await fetch(`${this.baseUrl}/tasks/${encodeURIComponent(taskId)}`, {
-      method: "PATCH",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify(updates)
-    });
-    if (!resp.ok) {
-      throw new Error(`Update task failed: ${resp.status} ${await resp.text()}`);
-    }
-    return resp.json();
-  }
-  async getNextTask(contextName) {
-    const resp = await fetch(`${this.baseUrl}/tasks/next?context=${encodeURIComponent(contextName)}`);
-    if (!resp.ok) {
-      if (resp.status === 404) return null;
-      throw new Error(`Get next task failed: ${resp.status} ${await resp.text()}`);
-    }
-    return resp.json();
-  }
-  async healthCheck() {
-    try {
-      const resp = await fetch(`${this.baseUrl}/health`);
-      return resp.ok;
-    } catch {
-      return false;
-    }
-  }
-};
-
-// packages/runtime/src/context.ts
-var SWITCH_PATTERNS = [
-  /^switch\s+to\s+(\S+)/i,
-  /^context:\s*(\S+)/i,
-  /^@(\S+)\s/,
-  /^working\s+on\s+(\S+)/i
-];
-var ContextManager = class {
-  contexts = /* @__PURE__ */ new Map();
-  activeContext = "global";
-  memory;
-  constructor(memory) {
-    this.memory = memory;
-    this.contexts.set("global", {
-      name: "global",
-      description: "Global context \u2014 identity, preferences, cross-cutting knowledge",
-      created_at: (/* @__PURE__ */ new Date()).toISOString(),
-      last_active: (/* @__PURE__ */ new Date()).toISOString()
-    });
-  }
-  async createContext(name, description = "") {
-    if (this.contexts.has(name)) {
-      return this.contexts.get(name);
-    }
-    const metadata = {
-      name,
-      description,
-      created_at: (/* @__PURE__ */ new Date()).toISOString(),
-      last_active: (/* @__PURE__ */ new Date()).toISOString()
-    };
-    this.contexts.set(name, metadata);
-    try {
-      await this.memory.createContext(name, description);
-    } catch (err) {
-      console.error(`Failed to register context '${name}' with daemon:`, err.message);
-    }
-    return metadata;
-  }
-  async deleteContext(name) {
-    if (name === "global") {
-      console.error("Cannot delete global context");
-      return false;
-    }
-    if (!this.contexts.has(name)) {
-      return false;
-    }
-    this.contexts.delete(name);
-    if (this.activeContext === name) {
-      this.activeContext = "global";
-    }
-    try {
-      await this.memory.deleteContext(name);
-    } catch (err) {
-      console.error(`Failed to delete context '${name}' from daemon:`, err.message);
-    }
-    return true;
-  }
-  listContexts() {
-    return Array.from(this.contexts.values());
-  }
-  getContext(name) {
-    return this.contexts.get(name);
-  }
-  getActiveContext() {
-    return this.activeContext;
-  }
-  switchContext(name) {
-    const previousContext = this.activeContext;
-    const isNew = !this.contexts.has(name);
-    if (isNew) {
-      this.contexts.set(name, {
-        name,
-        description: "",
-        created_at: (/* @__PURE__ */ new Date()).toISOString(),
-        last_active: (/* @__PURE__ */ new Date()).toISOString()
-      });
-    }
-    this.activeContext = name;
-    this.touchContext(name);
-    return { previousContext, activeContext: name, isNew };
-  }
-  /**
-   * Parse a message and determine if it's a context switch command.
-   * Returns the context name if a switch is detected, null otherwise.
-   */
-  parseContextSwitch(message) {
-    for (const pattern of SWITCH_PATTERNS) {
-      const match = message.match(pattern);
-      if (match) {
-        return match[1].toLowerCase();
-      }
-    }
-    return null;
-  }
-  /**
-   * Infer context from message content by checking known context names.
-   * Returns the best matching context or current active context.
-   */
-  inferContext(message) {
-    const lower = message.toLowerCase();
-    for (const [name] of this.contexts) {
-      if (name === "global") continue;
-      if (lower.includes(name.toLowerCase())) {
-        return name;
-      }
-    }
-    return this.activeContext;
-  }
-  /**
-   * Route a message: check for explicit switch, then infer context.
-   * Returns the resolved context name and whether a switch happened.
-   */
-  routeMessage(message) {
-    const switchTarget = this.parseContextSwitch(message);
-    if (switchTarget) {
-      const result = this.switchContext(switchTarget);
-      return { context: switchTarget, switched: true, switchedTo: result.activeContext };
-    }
-    const inferred = this.inferContext(message);
-    if (inferred !== this.activeContext) {
-      this.touchContext(inferred);
-      return { context: inferred, switched: false };
-    }
-    this.touchContext(this.activeContext);
-    return { context: this.activeContext, switched: false };
-  }
-  /**
-   * Returns contexts that should be searched: active context + global.
-   */
-  getSearchContexts() {
-    const contexts = [this.activeContext];
-    if (this.activeContext !== "global") {
-      contexts.push("global");
-    }
-    return contexts;
-  }
-  hasContext(name) {
-    return this.contexts.has(name);
-  }
-  touchContext(name) {
-    const ctx = this.contexts.get(name);
-    if (ctx) {
-      ctx.last_active = (/* @__PURE__ */ new Date()).toISOString();
-    }
-  }
-};
-
-// packages/runtime/src/task-engine.ts
-var TaskEngine = class {
-  contextName;
-  memory;
-  constructor(options) {
-    this.contextName = options.contextName;
-    this.memory = options.memory;
-  }
-  async addTask(title, description, blockedBy = []) {
-    return this.memory.createTask({
-      context_name: this.contextName,
-      title,
-      description,
-      status: "planned",
-      blocked_by: blockedBy
-    });
-  }
-  async listTasks(status) {
-    return this.memory.listTasks(this.contextName, status);
-  }
-  async startTask(taskId) {
-    return this.memory.updateTask(taskId, { status: "active" });
-  }
-  async completeTask(taskId) {
-    return this.memory.updateTask(taskId, { status: "complete" });
-  }
-  async archiveTask(taskId) {
-    return this.memory.updateTask(taskId, { status: "archived" });
-  }
-  async getNextTask() {
-    return this.memory.getNextTask(this.contextName);
-  }
-  async pickAndStartNextTask() {
-    const next = await this.getNextTask();
-    if (next) {
-      return this.startTask(next.id);
-    }
-    return null;
-  }
-  setContext(contextName) {
-    this.contextName = contextName;
-  }
-  /**
-   * Parse a task command from a chat message.
-   * Returns the action and parsed parameters, or null if not a task command.
-   */
-  static parseTaskCommand(message) {
-    const lower = message.trim().toLowerCase();
-    const addMatch = message.match(/^(?:add|create)\s+task[:\s]+(.+)/i);
-    if (addMatch) {
-      return { action: "add", title: addMatch[1].trim() };
-    }
-    if (/^list\s+tasks/i.test(lower)) {
-      const statusMatch = lower.match(/list\s+tasks\s+(\w+)/);
-      return { action: "list", statusFilter: statusMatch?.[1] };
-    }
-    const completeMatch = message.match(/^complete\s+task\s+(\S+)/i);
-    if (completeMatch) {
-      return { action: "complete", taskId: completeMatch[1] };
-    }
-    const startMatch = message.match(/^start\s+task\s+(\S+)/i);
-    if (startMatch) {
-      return { action: "start", taskId: startMatch[1] };
-    }
-    if (/^next\s+task/i.test(lower)) {
-      return { action: "next" };
-    }
-    const archiveMatch = message.match(/^archive\s+task\s+(\S+)/i);
-    if (archiveMatch) {
-      return { action: "archive", taskId: archiveMatch[1] };
-    }
-    return null;
-  }
-};
-
-// packages/runtime/src/prompt.ts
-import { readFileSync, existsSync, readdirSync } from "fs";
-import { resolve } from "path";
-var charterCache = null;
-function loadCharter(path) {
-  if (charterCache && charterCache.path === path) return charterCache.content;
-  if (!existsSync(path)) return "";
-  const content = readFileSync(path, "utf-8");
-  charterCache = { path, content };
-  return content;
-}
-var WORKSPACE_FILE_PRIORITY = [
-  "SOUL.md",
-  // Who the agent is (personality, values)
-  "IDENTITY.md",
-  // Name, avatar, creature type
-  "AGENTS.md",
-  // Operating instructions
-  "USER.md",
-  // About the human(s)
-  "TOOLS.md"
-  // Tool-specific notes
-];
-var workspaceCache = null;
-var WORKSPACE_CACHE_TTL_MS = 6e4;
-function loadWorkspaceFiles(dir) {
-  const now = Date.now();
-  if (workspaceCache && workspaceCache.dir === dir && now - workspaceCache.loadedAt < WORKSPACE_CACHE_TTL_MS) {
-    return workspaceCache.files;
-  }
-  const files = /* @__PURE__ */ new Map();
-  if (!existsSync(dir)) return files;
-  for (const filename of WORKSPACE_FILE_PRIORITY) {
-    const filePath = resolve(dir, filename);
-    if (existsSync(filePath)) {
-      try {
-        files.set(filename, readFileSync(filePath, "utf-8"));
-      } catch {
-      }
-    }
-  }
-  try {
-    const entries = readdirSync(dir);
-    for (const entry of entries) {
-      if (entry.endsWith(".md") && !files.has(entry) && !entry.startsWith(".")) {
-        const filePath = resolve(dir, entry);
-        try {
-          files.set(entry, readFileSync(filePath, "utf-8"));
-        } catch {
-        }
-      }
-    }
-  } catch {
-  }
-  workspaceCache = { dir, files, loadedAt: now };
-  const names = [...files.keys()].join(", ");
-  if (files.size > 0) {
-    console.log(`[workspace] Loaded ${files.size} files: ${names}`);
-  }
-  return files;
-}
-function buildSystemPrompt(config, episodes, contextName = "global", l3Knowledge = []) {
-  let prompt = `You are ${config.name}. ${config.personality}
-`;
-  if (config.workspace) {
-    const wsFiles = loadWorkspaceFiles(config.workspace);
-    if (wsFiles.size > 0) {
-      prompt += "\n# Workspace Context\n";
-      for (const [filename, content] of wsFiles) {
-        prompt += `
-## ${filename}
-${content}
-`;
-      }
-    }
-  }
-  if (config.team_charter && !config.workspace) {
-    const charter = loadCharter(config.team_charter);
-    if (charter) {
-      prompt += `
-${charter}
-`;
-    }
-  }
-  prompt += `
-## Communication
-Messages are prefixed with [sender_handle]: or [sender_handle in group chat]: to tell you who's talking.
-In group chats, multiple people (humans and agents) may be present. Address them by name when relevant.
-Don't repeat or quote these prefixes in your responses \u2014 just respond naturally.
-If you decide not to respond to a group message, reply with exactly: __SKIP__
-`;
-  if (contextName !== "global") {
-    prompt += `
-## Active Context: ${contextName}
-You are currently working in the "${contextName}" project context.
-`;
-  }
-  if (l3Knowledge.length > 0) {
-    prompt += "\n## Established Knowledge (learned patterns)\n\n";
-    for (const entry of l3Knowledge) {
-      prompt += `- ${entry.content}
-`;
-    }
-  }
-  if (episodes.length > 0) {
-    prompt += "\n## Relevant memories from previous conversations\n\n";
-    for (const ep of episodes) {
-      const timeAgo = formatTimeAgo(ep.timestamp);
-      const ctxLabel = ep.context_name !== contextName ? ` [from: ${ep.context_name}]` : "";
-      prompt += `[${timeAgo}]${ctxLabel} ${ep.role}: ${ep.content}
-`;
-    }
-    prompt += "\nUse these memories naturally \u2014 reference past conversations when relevant, but don't force it.\n";
-  }
-  return prompt;
-}
-function buildMessages(systemPrompt, conversationHistory, currentMessage) {
-  return [
-    { role: "system", content: systemPrompt },
-    ...conversationHistory,
-    { role: "user", content: currentMessage }
-  ];
-}
-function formatTimeAgo(timestamp) {
-  const date = new Date(timestamp);
-  const now = /* @__PURE__ */ new Date();
-  const diffMs = now.getTime() - date.getTime();
-  const diffMins = Math.floor(diffMs / 6e4);
-  const diffHours = Math.floor(diffMs / 36e5);
-  const diffDays = Math.floor(diffMs / 864e5);
-  if (diffMins < 1) return "just now";
-  if (diffMins < 60) return `${diffMins}m ago`;
-  if (diffHours < 24) return `${diffHours}h ago`;
-  if (diffDays < 7) return `${diffDays}d ago`;
-  return date.toLocaleDateString();
-}
-
-// packages/runtime/src/agent.ts
-var Agent = class {
-  config;
-  llm;
-  memory;
-  contextManager;
-  // Per-context conversation histories
-  conversationHistories = /* @__PURE__ */ new Map();
-  messageCount = 0;
-  PROMOTION_INTERVAL = 10;
-  // Run promotion every N messages
-  constructor(config, contextName = "global") {
-    this.config = config;
-    this.llm = new LLMClient(config.llm);
-    this.memory = new MemoryClient(config.memory);
-    this.contextManager = new ContextManager(this.memory);
-    if (contextName !== "global") {
-      this.contextManager.switchContext(contextName);
-    }
-  }
-  async processMessage(userMessage) {
-    const specialResult = await this.handleSpecialCommand(userMessage);
-    if (specialResult) return specialResult;
-    const routing = this.contextManager.routeMessage(userMessage);
-    const contextName = routing.context;
-    if (routing.switched) {
-      try {
-        await this.memory.createContext(contextName);
-      } catch {
-      }
-    }
-    if (!this.conversationHistories.has(contextName)) {
-      this.conversationHistories.set(contextName, []);
-    }
-    const conversationHistory = this.conversationHistories.get(contextName);
-    const relevantEpisodes = await this.memory.search(userMessage, contextName, this.config.memory.top_k).catch((err) => {
-      console.error("Memory search failed, continuing without context:", err.message);
-      return [];
-    });
-    if (relevantEpisodes.length > 0) {
-      const episodeIds = relevantEpisodes.map((e) => e.id);
-      this.memory.recordCoAccess(episodeIds).catch(() => {
-      });
-      for (const ep of relevantEpisodes) {
-        this.memory.recordAccess(ep.id).catch(() => {
-        });
-      }
-    }
-    const l3Knowledge = await this.memory.getL3Knowledge(contextName).catch(() => []);
-    const systemPrompt = buildSystemPrompt(this.config.agent, relevantEpisodes, contextName, l3Knowledge);
-    const messages = buildMessages(systemPrompt, conversationHistory, userMessage);
-    const response = await this.llm.chat(messages);
-    conversationHistory.push(
-      { role: "user", content: userMessage },
-      { role: "assistant", content: response.content }
-    );
-    if (conversationHistory.length > 40) {
-      const trimmed = conversationHistory.slice(-40);
-      this.conversationHistories.set(contextName, trimmed);
-    }
-    await this.storeEpisodes(contextName, userMessage, response.content);
-    this.messageCount++;
-    if (this.messageCount % this.PROMOTION_INTERVAL === 0) {
-      this.memory.runPromotion(contextName).catch((err) => {
-        console.error("Promotion run failed:", err.message);
-      });
-    }
-    return {
-      content: response.content,
-      model: response.model,
-      context: contextName,
-      contextSwitched: routing.switched
-    };
-  }
-  async storeEpisodes(contextName, userMessage, assistantResponse) {
-    try {
-      await Promise.all([
-        this.memory.storeEpisode({
-          context_name: contextName,
-          role: "user",
-          content: userMessage
-        }),
-        this.memory.storeEpisode({
-          context_name: contextName,
-          role: "assistant",
-          content: assistantResponse
-        })
-      ]);
-    } catch (err) {
-      console.error("Failed to store episodes:", err.message);
-    }
-  }
-  async handleSpecialCommand(message) {
-    const activeCtx = this.contextManager.getActiveContext();
-    const searchAllMatch = message.match(/^(?:search\s+all|cross-context\s+search)[:\s]+(.+)/i);
-    if (searchAllMatch) {
-      const query = searchAllMatch[1].trim();
-      try {
-        const results = await this.memory.searchCrossContext(query);
-        let response = "## Cross-Context Search Results\n\n";
-        if (results.length === 0) {
-          response += "No results found across any context.";
-        } else {
-          for (const group of results) {
-            response += `### Context: ${group.context}
-`;
-            for (const ep of group.episodes) {
-              response += `- [${ep.role}] ${ep.content.slice(0, 200)}${ep.content.length > 200 ? "..." : ""} (score: ${ep.score.toFixed(3)})
-`;
-            }
-            response += "\n";
-          }
-        }
-        return { content: response, model: "system", context: activeCtx };
-      } catch (err) {
-        return { content: `Cross-context search failed: ${err.message}`, model: "system", context: activeCtx };
-      }
-    }
-    const shareMatch = message.match(/^share\s+(\S+)\s+with\s+(\S+)/i);
-    if (shareMatch) {
-      const episodeId = shareMatch[1];
-      const targetContext = shareMatch[2];
-      try {
-        await this.memory.shareEpisode(episodeId, targetContext);
-        return { content: `Shared episode ${episodeId} with context "${targetContext}".`, model: "system", context: activeCtx };
-      } catch (err) {
-        return { content: `Failed to share: ${err.message}`, model: "system", context: activeCtx };
-      }
-    }
-    const taskCmd = TaskEngine.parseTaskCommand(message);
-    if (taskCmd) {
-      const engine = new TaskEngine({ contextName: activeCtx, memory: this.memory });
-      try {
-        switch (taskCmd.action) {
-          case "add": {
-            const task = await engine.addTask(taskCmd.title || "Untitled", taskCmd.description || "");
-            return { content: `Task created: [${task.id.slice(0, 8)}] ${task.title} (status: ${task.status})`, model: "system", context: activeCtx };
-          }
-          case "list": {
-            const tasks = await engine.listTasks(taskCmd.statusFilter);
-            if (tasks.length === 0) {
-              return { content: `No tasks${taskCmd.statusFilter ? ` with status "${taskCmd.statusFilter}"` : ""} in context "${activeCtx}".`, model: "system", context: activeCtx };
-            }
-            let response = `## Tasks in ${activeCtx}
-
-`;
-            for (const t of tasks) {
-              const blockedBy = Array.isArray(t.blocked_by) ? t.blocked_by : JSON.parse(String(t.blocked_by) || "[]");
-              const blockedStr = blockedBy.length > 0 ? ` (blocked by: ${blockedBy.map((b) => b.slice(0, 8)).join(", ")})` : "";
-              response += `- [${t.status}] ${t.id.slice(0, 8)}: ${t.title}${blockedStr}
-`;
-            }
-            return { content: response, model: "system", context: activeCtx };
-          }
-          case "start": {
-            const task = await engine.startTask(taskCmd.taskId);
-            return { content: task ? `Task ${taskCmd.taskId.slice(0, 8)} started.` : "Task not found.", model: "system", context: activeCtx };
-          }
-          case "complete": {
-            const task = await engine.completeTask(taskCmd.taskId);
-            return { content: task ? `Task ${taskCmd.taskId.slice(0, 8)} completed.` : "Task not found.", model: "system", context: activeCtx };
-          }
-          case "archive": {
-            const task = await engine.archiveTask(taskCmd.taskId);
-            return { content: task ? `Task ${taskCmd.taskId.slice(0, 8)} archived.` : "Task not found.", model: "system", context: activeCtx };
-          }
-          case "next": {
-            const task = await engine.pickAndStartNextTask();
-            if (task) {
-              return { content: `Picked up next task: [${task.id.slice(0, 8)}] ${task.title}`, model: "system", context: activeCtx };
-            }
-            return { content: "No available tasks to pick up.", model: "system", context: activeCtx };
-          }
-        }
-      } catch (err) {
-        return { content: `Task command failed: ${err.message}`, model: "system", context: activeCtx };
-      }
-    }
-    return null;
-  }
-  getMemoryClient() {
-    return this.memory;
-  }
-  getContextManager() {
-    return this.contextManager;
-  }
-  setContext(name) {
-    this.contextManager.switchContext(name);
-  }
-  getActiveContext() {
-    return this.contextManager.getActiveContext();
-  }
-};
-
-// packages/runtime/src/config.ts
-var import_toml = __toESM(require_toml(), 1);
-import { readFileSync as readFileSync2, existsSync as existsSync2 } from "fs";
-import { resolve as resolve2, dirname } from "path";
-function defaultWorkerConfig() {
-  return {
-    enabled: false,
-    primary_url: "http://localhost:3000",
-    worker_port: 3100,
-    worker_id: `worker-${process.pid}`,
-    max_contexts: 4,
-    task_poll_interval_ms: 5e3,
-    status_report_interval_ms: 15e3
-  };
-}
-function deepMerge(target, source) {
-  const result = { ...target };
-  for (const key of Object.keys(source)) {
-    if (source[key] && typeof source[key] === "object" && !Array.isArray(source[key]) && target[key] && typeof target[key] === "object") {
-      result[key] = deepMerge(target[key], source[key]);
-    } else if (source[key] !== void 0 && source[key] !== "") {
-      result[key] = source[key];
-    }
-  }
-  return result;
-}
-function loadConfig(path) {
-  const raw = readFileSync2(path, "utf-8");
-  let parsed = (0, import_toml.parse)(raw);
-  const configDir = dirname(path);
-  const localPath = resolve2(configDir, "local.toml");
-  if (existsSync2(localPath)) {
-    const localRaw = readFileSync2(localPath, "utf-8");
-    const localParsed = (0, import_toml.parse)(localRaw);
-    parsed = deepMerge(parsed, localParsed);
-    console.log(`[config] Merged overrides from ${localPath}`);
-  }
-  if (process.env.AGENT_NAME) {
-    parsed.agent.name = process.env.AGENT_NAME;
-  }
-  if (process.env.LLM_API_KEY) {
-    parsed.llm.api_key = process.env.LLM_API_KEY;
-  }
-  if (process.env.LLM_BASE_URL) {
-    parsed.llm.base_url = process.env.LLM_BASE_URL;
-  }
-  if (process.env.SESAME_API_KEY) {
-    parsed.sesame.api_key = process.env.SESAME_API_KEY;
-  }
-  if (process.env.MEMORY_DAEMON_URL) {
-    parsed.memory.daemon_url = process.env.MEMORY_DAEMON_URL;
-  }
-  if (process.env.WORKER_PRIMARY_URL) {
-    if (!parsed.worker) parsed.worker = defaultWorkerConfig();
-    parsed.worker.primary_url = process.env.WORKER_PRIMARY_URL;
-  }
-  if (process.env.WORKER_PORT) {
-    if (!parsed.worker) parsed.worker = defaultWorkerConfig();
-    parsed.worker.worker_port = parseInt(process.env.WORKER_PORT, 10);
-  }
-  if (process.env.WORKER_ID) {
-    if (!parsed.worker) parsed.worker = defaultWorkerConfig();
-    parsed.worker.worker_id = process.env.WORKER_ID;
-  }
-  if (parsed.agent.workspace && !parsed.agent.workspace.startsWith("/")) {
-    const configDir2 = dirname(path);
-    parsed.agent.workspace = resolve2(configDir2, "..", parsed.agent.workspace);
-  }
-  return parsed;
-}
-
-// packages/runtime/src/sesame.ts
-import { readFileSync as readFileSync3 } from "fs";
-import { resolve as resolve3, dirname as dirname2 } from "path";
-import { fileURLToPath } from "url";
-var RUNTIME_VERSION = "unknown";
-try {
-  const __dirname = dirname2(fileURLToPath(import.meta.url));
-  const pkg = JSON.parse(readFileSync3(resolve3(__dirname, "../package.json"), "utf-8"));
-  RUNTIME_VERSION = pkg.version ?? "unknown";
-} catch {
-}
-var SesameClient2 = class {
-  config;
-  sdk;
-  messageHandler = null;
-  upgradeHandler = null;
-  agentId = null;
-  channels = /* @__PURE__ */ new Map();
-  typingIntervals = /* @__PURE__ */ new Map();
-  constructor(config) {
-    this.config = config;
-    this.sdk = new SesameClient({
-      apiUrl: config.api_url.replace(/\/api\/v1$/, ""),
-      wsUrl: config.ws_url,
-      apiKey: config.api_key
-    });
-  }
-  onMessage(handler) {
-    this.messageHandler = handler;
-  }
-  onUpgrade(handler) {
-    this.upgradeHandler = handler;
-  }
-  async connect() {
-    const manifest = await this.sdk.getManifest();
-    this.agentId = manifest.agent.id;
-    console.log(`[sesame] Authenticated as ${manifest.agent.handle} (${this.agentId})`);
-    for (const ch of manifest.channels) {
-      this.channels.set(ch.id, { kind: ch.kind, name: ch.name ?? void 0 });
-      const label = ch.name || ch.id.slice(0, 8);
-      console.log(`[sesame] Channel: ${label} (${ch.kind})`);
-    }
-    this.updatePresence("online", { emoji: "\u{1F7E2}" });
-    this.sdk.on("upgrade.request", (event) => {
-      console.log(`[sesame] Upgrade request received: ${event.packageName}@${event.targetVersion}`);
-      if (this.upgradeHandler) {
-        this.upgradeHandler({
-          targetVersion: event.targetVersion,
-          packageName: event.packageName,
-          requestedBy: event.requestedBy,
-          requestId: event.requestId
-        });
-      }
-    });
-    this.sdk.on("control", (event) => {
-      console.log(`[sesame] Control event: ${event.action}`, event.payload);
-    });
-    this.sdk.on("message", (event) => {
-      const msg = event.data || event.message || event;
-      const senderId = msg.senderId || msg.sender?.id;
-      if (senderId === this.agentId) return;
-      if (!this.messageHandler || !msg.content) return;
-      const channelInfo = this.channels.get(msg.channelId);
-      this.messageHandler({
-        id: msg.id || "unknown",
-        channelId: msg.channelId || "unknown",
-        channelKind: channelInfo?.kind || "dm",
-        content: msg.content,
-        author: {
-          id: senderId || "unknown",
-          handle: msg.senderHandle || msg.metadata?.senderHandle || "unknown"
-        },
-        timestamp: msg.createdAt || (/* @__PURE__ */ new Date()).toISOString()
-      });
-    });
-    await this.sdk.connect();
-    console.log("[sesame] WebSocket connected");
-    const ws = this.sdk.ws;
-    if (ws?.readyState === 1) {
-      ws.send(JSON.stringify({ type: "meta", runtime: "hivemind", version: RUNTIME_VERSION }));
-      console.log(`[sesame] Reported version: hivemind@${RUNTIME_VERSION}`);
-    }
-  }
-  // ── Typing Indicators ──
-  /**
-   * Start sending typing indicators for a channel.
-   * Sends immediately, then every 2.5s until stopTyping() is called.
-   */
-  startTyping(channelId) {
-    if (this.typingIntervals.has(channelId)) return;
-    this.sdk.sendTyping(channelId);
-    const interval = setInterval(() => {
-      this.sdk.sendTyping(channelId);
-    }, 2500);
-    this.typingIntervals.set(channelId, interval);
-  }
-  /**
-   * Stop sending typing indicators for a channel.
-   */
-  stopTyping(channelId) {
-    const interval = this.typingIntervals.get(channelId);
-    if (interval) {
-      clearInterval(interval);
-      this.typingIntervals.delete(channelId);
-    }
-  }
-  /**
-   * Stop all active typing indicators.
-   */
-  stopAllTyping() {
-    for (const [channelId, interval] of this.typingIntervals) {
-      clearInterval(interval);
-    }
-    this.typingIntervals.clear();
-  }
-  // ── Presence ──
-  /**
-   * Update agent presence/status.
-   * @param status - "online" | "thinking" | "working" | "idle" | "offline"
-   * @param options - Optional detail text, progress (0-100), emoji
-   */
-  updatePresence(status, options) {
-    if (typeof this.sdk.updatePresence === "function") {
-      this.sdk.updatePresence(status, options);
-    } else {
-      const ws = this.sdk.ws;
-      if (ws?.readyState === 1) {
-        ws.send(JSON.stringify({ type: "status", status, ...options }));
-      }
-    }
-  }
-  // ── Read Receipts ──
-  /**
-   * Mark a channel as read up to a given sequence number.
-   */
-  async markRead(channelId, seq) {
-    await this.sdk.markRead(channelId, seq);
-  }
-  // ── Messages ──
-  async sendMessage(channelId, content) {
-    await this.sdk.sendMessage(channelId, { content });
-  }
-  getAgentId() {
-    return this.agentId;
-  }
-  getChannelInfo(channelId) {
-    return this.channels.get(channelId);
-  }
-  disconnect() {
-    this.stopAllTyping();
-    this.updatePresence("offline");
-    this.sdk.disconnect();
-  }
-};
-
-// packages/runtime/src/pipeline.ts
-import { execSync } from "child_process";
-async function startPipeline(configPath) {
-  const config = loadConfig(configPath);
-  console.log(`[hivemind] Starting ${config.agent.name} (pid ${process.pid})`);
-  const memory = new MemoryClient(config.memory);
-  const memoryOk = await memory.healthCheck();
-  if (!memoryOk) {
-    console.warn("[hivemind] Memory daemon unreachable at", config.memory.daemon_url);
-    console.warn("[hivemind] Continuing without persistent memory \u2014 episodes will not be stored");
-  } else {
-    console.log("[hivemind] Memory daemon connected");
-  }
-  const agent = new Agent(config);
-  console.log(`[hivemind] Context manager initialized (active: ${agent.getActiveContext()})`);
-  if (config.sesame.api_key) {
-    await startSesameLoop(config, agent);
-  } else {
-    console.log("[hivemind] No Sesame API key configured \u2014 running in stdin mode");
-    await startStdinLoop(agent);
-  }
-}
-async function startSesameLoop(config, agent) {
-  const sesame = new SesameClient2(config.sesame);
-  let shuttingDown = false;
-  const shutdown = (signal) => {
-    if (shuttingDown) return;
-    shuttingDown = true;
-    console.log(`
-[hivemind] Received ${signal}, shutting down...`);
-    try {
-      sesame.updatePresence("offline", { emoji: "\u2B58" });
-      sesame.disconnect();
-      console.log("[hivemind] Sesame disconnected cleanly");
-    } catch (err) {
-      console.error("[hivemind] Error during disconnect:", err.message);
-    }
-    process.exit(0);
-  };
-  process.on("SIGTERM", () => shutdown("SIGTERM"));
-  process.on("SIGINT", () => shutdown("SIGINT"));
-  sesame.onUpgrade(async (req) => {
-    console.log(`[hivemind] Upgrade requested: ${req.packageName}@${req.targetVersion} (by ${req.requestedBy})`);
-    sesame.updatePresence("working", { detail: `Upgrading to ${req.targetVersion}`, emoji: "\u2B06\uFE0F" });
-    try {
-      const target = req.targetVersion === "latest" ? req.packageName : `${req.packageName}@${req.targetVersion}`;
-      console.log(`[hivemind] Running: npm install -g ${target}`);
-      execSync(`npm install -g ${target}`, { stdio: "inherit", timeout: 12e4 });
-      console.log("[hivemind] Package updated successfully");
-      console.log(`[hivemind] Upgrade to ${req.targetVersion} complete. Restarting...`);
-      sesame.updatePresence("working", { detail: "Restarting after upgrade", emoji: "\u{1F504}" });
-      try {
-        execSync("launchctl kickstart -k gui/$(id -u)/com.hivemind.agent", { timeout: 1e4 });
-      } catch {
-        console.log("[hivemind] Exiting for restart...");
-        process.exit(0);
-      }
-    } catch (err) {
-      console.error(`[hivemind] Upgrade failed: ${err.message}`);
-      sesame.updatePresence("online", { detail: "Upgrade failed", emoji: "\u274C" });
-    }
-  });
-  sesame.onMessage(async (msg) => {
-    if (shuttingDown) return;
-    console.log(`[sesame] ${msg.author.handle} (${msg.channelKind}): ${msg.content}`);
-    sesame.startTyping(msg.channelId);
-    sesame.updatePresence("thinking", { detail: `Replying to ${msg.author.handle}`, emoji: "\u{1F4AD}" });
-    try {
-      const prefix = msg.channelKind === "group" ? `[${msg.author.handle} in group chat]: ` : `[${msg.author.handle}]: `;
-      const response = await agent.processMessage(prefix + msg.content);
-      sesame.stopTyping(msg.channelId);
-      if (response.content.trim() === "__SKIP__") {
-        console.log(`[sesame] ${config.agent.name}: skipped (${msg.author.handle} in ${msg.channelKind})`);
-        sesame.updatePresence("online", { emoji: "\u{1F7E2}" });
-        return;
-      }
-      const ctxPrefix = response.contextSwitched ? `[switched to ${response.context}] ` : "";
-      await sesame.sendMessage(msg.channelId, ctxPrefix + response.content);
-      console.log(`[sesame] ${config.agent.name} (${response.context}): ${response.content.slice(0, 100)}...`);
-      sesame.updatePresence("online", { emoji: "\u{1F7E2}" });
-    } catch (err) {
-      sesame.stopTyping(msg.channelId);
-      sesame.updatePresence("online", { emoji: "\u{1F7E2}" });
-      console.error("[sesame] Error processing message:", err.message);
-    }
-  });
-  await sesame.connect();
-  console.log("[hivemind] Listening for Sesame messages");
-  await new Promise(() => {
-  });
-}
-async function startStdinLoop(agent) {
-  const readline = await import("readline");
-  const rl = readline.createInterface({
-    input: process.stdin,
-    output: process.stdout
-  });
-  console.log("[hivemind] Ready. Type a message (Ctrl+C to exit)");
-  console.log("[hivemind] Commands: 'switch to <name>', 'list contexts', 'create context <name>'\n");
-  rl.on("line", async (line) => {
-    const input = line.trim();
-    if (!input) return;
-    if (input.toLowerCase() === "list contexts") {
-      const contexts = agent.getContextManager().listContexts();
-      console.log("\nContexts:");
-      for (const ctx of contexts) {
-        const active = ctx.name === agent.getActiveContext() ? " (active)" : "";
-        console.log(`  - ${ctx.name}${active}: ${ctx.description || "(no description)"}`);
-      }
-      console.log();
-      return;
-    }
-    const createMatch = input.match(/^create context (\S+)\s*(.*)?$/i);
-    if (createMatch) {
-      const name = createMatch[1];
-      const desc = createMatch[2] || "";
-      await agent.getContextManager().createContext(name, desc);
-      console.log(`
-Created context: ${name}
-`);
-      return;
-    }
-    try {
-      const response = await agent.processMessage(input);
-      if (response.contextSwitched) {
-        console.log(`
-[switched to context: ${response.context}]`);
-      }
-      console.log(`
-${response.content}
-`);
-    } catch (err) {
-      console.error("Error:", err.message);
-    }
-  });
-  return new Promise((resolve4) => {
-    rl.on("close", resolve4);
-  });
-}
-
-// packages/runtime/src/fleet/worker-server.ts
-import { createServer } from "http";
-var WorkerServer = class {
-  server = null;
-  workerId;
-  port;
-  startTime;
-  assignedContexts = /* @__PURE__ */ new Map();
-  activeContext = null;
-  currentTask = null;
-  maxContexts;
-  memoryDaemonUrl;
-  ollamaUrl;
-  onAssignCallback = null;
-  onSyncPushCallback = null;
-  constructor(opts) {
-    this.workerId = opts.workerId;
-    this.port = opts.port;
-    this.startTime = Date.now();
-    this.maxContexts = opts.maxContexts ?? 4;
-    this.memoryDaemonUrl = opts.memoryDaemonUrl ?? null;
-    this.ollamaUrl = opts.ollamaUrl ?? null;
-  }
-  /** Start listening. */
-  async start() {
-    return new Promise((resolve4, reject) => {
-      this.server = createServer((req, res) => this.handleRequest(req, res));
-      this.server.on("error", reject);
-      this.server.listen(this.port, () => resolve4());
-    });
-  }
-  /** Stop the server. */
-  async stop() {
-    return new Promise((resolve4) => {
-      if (!this.server) {
-        resolve4();
-        return;
-      }
-      this.server.close(() => resolve4());
-    });
-  }
-  getPort() {
-    return this.port;
-  }
-  getAssignedContexts() {
-    return Array.from(this.assignedContexts.keys());
-  }
-  setActiveContext(name) {
-    this.activeContext = name;
-  }
-  setCurrentTask(taskId) {
-    this.currentTask = taskId;
-  }
-  /** Register a callback for when a new context is assigned. */
-  onContextAssigned(cb) {
-    this.onAssignCallback = cb;
-  }
-  /** Register a handler for incoming sync push requests from Primary. */
-  onSyncPush(cb) {
-    this.onSyncPushCallback = cb;
-  }
-  // --- Request Router ---
-  async handleRequest(req, res) {
-    const url = new URL(req.url ?? "/", `http://localhost:${this.port}`);
-    const path = url.pathname;
-    const method = req.method ?? "GET";
-    try {
-      if (method === "GET" && path === "/health") {
-        return this.handleHealth(res);
-      }
-      if (method === "POST" && path === "/assign") {
-        const body = await readBody(req);
-        return this.handleAssign(body, res);
-      }
-      if (method === "DELETE" && path.startsWith("/assign/")) {
-        const contextName = decodeURIComponent(path.slice("/assign/".length));
-        return this.handleUnassign(contextName, res);
-      }
-      if (method === "GET" && path === "/status") {
-        return this.handleStatus(res);
-      }
-      if (method === "POST" && path === "/sync/push") {
-        const body = await readBody(req);
-        return this.handleSyncPush(body, res);
-      }
-      sendJson(res, 404, { error: "Not found" });
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      sendJson(res, 500, { error: msg });
-    }
-  }
-  // --- Handlers ---
-  handleHealth(res) {
-    const uptimeMs = Date.now() - this.startTime;
-    const body = {
-      worker_id: this.workerId,
-      status: "healthy",
-      uptime_seconds: Math.floor(uptimeMs / 1e3),
-      assigned_contexts: Array.from(this.assignedContexts.keys()),
-      active_context: this.activeContext,
-      memory_daemon_ok: this.memoryDaemonUrl !== null,
-      ollama_ok: this.ollamaUrl !== null
-    };
-    sendJson(res, 200, body);
-  }
-  handleAssign(raw, res) {
-    const req = JSON.parse(raw);
-    if (this.assignedContexts.size >= this.maxContexts) {
-      const body2 = {
-        context_name: req.context_name,
-        accepted: false,
-        reason: "Worker at max context capacity"
-      };
-      sendJson(res, 200, body2);
-      return;
-    }
-    const assignment = {
-      context_name: req.context_name,
-      context_description: req.context_description,
-      assigned_at: (/* @__PURE__ */ new Date()).toISOString()
-    };
-    this.assignedContexts.set(req.context_name, assignment);
-    if (this.onAssignCallback) {
-      this.onAssignCallback(req.context_name, req.context_description);
-    }
-    const body = {
-      context_name: req.context_name,
-      accepted: true
-    };
-    sendJson(res, 200, body);
-  }
-  handleUnassign(contextName, res) {
-    const existed = this.assignedContexts.delete(contextName);
-    if (this.activeContext === contextName) {
-      this.activeContext = null;
-      this.currentTask = null;
-    }
-    sendJson(res, existed ? 200 : 404, {
-      context_name: contextName,
-      removed: existed
-    });
-  }
-  handleStatus(res) {
-    const report = {
-      activity: this.currentTask ? "working" : "idle",
-      current_context: this.activeContext,
-      current_task: this.currentTask
-    };
-    sendJson(res, 200, report);
-  }
-  async handleSyncPush(raw, res) {
-    if (!this.onSyncPushCallback) {
-      sendJson(res, 501, { error: "Sync push handler not registered" });
-      return;
-    }
-    const req = JSON.parse(raw);
-    const result = await this.onSyncPushCallback(req);
-    sendJson(res, 200, result);
-  }
-};
-function readBody(req) {
-  return new Promise((resolve4, reject) => {
-    const chunks = [];
-    req.on("data", (chunk) => chunks.push(chunk));
-    req.on("end", () => resolve4(Buffer.concat(chunks).toString("utf-8")));
-    req.on("error", reject);
-  });
-}
-function sendJson(res, status, body) {
-  const payload = JSON.stringify(body);
-  res.writeHead(status, {
-    "Content-Type": "application/json",
-    "Content-Length": Buffer.byteLength(payload)
-  });
-  res.end(payload);
-}
-
-// packages/runtime/src/fleet/worker-protocol.ts
-var WORKER_API_PREFIX = "/workers";
-var PRIMARY_ROUTES = {
-  register: `${WORKER_API_PREFIX}/register`,
-  status: (workerId) => `${WORKER_API_PREFIX}/${encodeURIComponent(workerId)}/status`,
-  syncPull: `${WORKER_API_PREFIX}/sync/pull`
-};
-var WORKER_ROUTES = {
-  health: "/health",
-  assign: "/assign",
-  unassign: (contextName) => `/assign/${encodeURIComponent(contextName)}`,
-  status: "/status",
-  syncPush: "/sync/push"
-};
-var DEFAULT_HEALTH_INTERVAL_MS = 3e4;
-var HEALTH_TIMEOUT_MS = 5e3;
-var DEFAULT_SYNC_INTERVAL_MS = 6e4;
-
-// packages/runtime/src/worker.ts
-var WorkerRuntime = class {
-  config;
-  workerConfig;
-  server;
-  memory;
-  agent;
-  taskPollTimer = null;
-  statusReportTimer = null;
-  registeredWorkerId = null;
-  running = false;
-  executing = false;
-  constructor(opts) {
-    this.config = opts.config;
-    this.workerConfig = opts.workerConfig;
-    this.server = new WorkerServer({
-      workerId: this.workerConfig.worker_id,
-      port: this.workerConfig.worker_port,
-      maxContexts: this.workerConfig.max_contexts,
-      memoryDaemonUrl: this.config.memory.daemon_url,
-      ollamaUrl: this.config.ollama.base_url
-    });
-    this.memory = new MemoryClient(this.config.memory);
-    this.agent = new Agent(this.config);
-  }
-  /**
-   * Start the worker: HTTP server, register with Primary, begin task loop.
-   */
-  async start() {
-    this.running = true;
-    this.server.onContextAssigned((contextName, description) => {
-      console.log(`[worker] Context assigned: "${contextName}" \u2014 ${description || "(no description)"}`);
-      this.memory.createContext(contextName, description).catch((err) => {
-        console.warn(`[worker] Failed to create context "${contextName}" in daemon:`, err.message);
-      });
-    });
-    await this.server.start();
-    console.log(`[worker] HTTP server listening on port ${this.workerConfig.worker_port}`);
-    const memoryOk = await this.memory.healthCheck();
-    if (memoryOk) {
-      console.log("[worker] Local memory daemon connected");
-    } else {
-      console.warn("[worker] Memory daemon unreachable at", this.config.memory.daemon_url);
-      console.warn("[worker] Continuing \u2014 episodes will not be stored until daemon is available");
-    }
-    await this.registerWithPrimary();
-    this.startTaskLoop();
-    this.startStatusReporting();
-    console.log("[worker] Ready \u2014 waiting for context assignments");
-  }
-  /**
-   * Stop the worker gracefully.
-   */
-  async stop() {
-    this.running = false;
-    if (this.taskPollTimer) {
-      clearInterval(this.taskPollTimer);
-      this.taskPollTimer = null;
-    }
-    if (this.statusReportTimer) {
-      clearInterval(this.statusReportTimer);
-      this.statusReportTimer = null;
-    }
-    await this.server.stop();
-    console.log("[worker] Stopped");
-  }
-  /**
-   * Register this worker with the Primary node.
-   */
-  async registerWithPrimary() {
-    const workerUrl = `http://localhost:${this.workerConfig.worker_port}`;
-    const registration = {
-      url: workerUrl,
-      capabilities: {
-        max_contexts: this.workerConfig.max_contexts,
-        has_ollama: true,
-        has_memory_daemon: true,
-        available_models: [this.config.memory.embedding_model]
-      }
-    };
-    try {
-      const resp = await fetch(
-        `${this.workerConfig.primary_url}${PRIMARY_ROUTES.register}`,
-        {
-          method: "POST",
-          headers: { "Content-Type": "application/json" },
-          body: JSON.stringify(registration)
-        }
-      );
-      if (!resp.ok) {
-        console.error(`[worker] Registration failed: ${resp.status} ${await resp.text()}`);
-        return null;
-      }
-      const result = await resp.json();
-      this.registeredWorkerId = result.worker_id;
-      console.log(`[worker] Registered with Primary as ${result.worker_id}`);
-      return result;
-    } catch (err) {
-      console.error("[worker] Could not reach Primary at", this.workerConfig.primary_url);
-      console.error("[worker] Will continue in standalone mode \u2014 retry registration manually");
-      return null;
-    }
-  }
-  /**
-   * Start the task execution polling loop.
-   * Iterates assigned contexts and picks up tasks from each queue.
-   */
-  startTaskLoop() {
-    this.taskPollTimer = setInterval(() => {
-      if (!this.running || this.executing) return;
-      this.executeNextTask().catch((err) => {
-        console.error("[worker] Task execution error:", err.message);
-      });
-    }, this.workerConfig.task_poll_interval_ms);
-  }
-  /**
-   * Find and execute the next available task across all assigned contexts.
-   */
-  async executeNextTask() {
-    const contexts = this.server.getAssignedContexts();
-    if (contexts.length === 0) return;
-    for (const contextName of contexts) {
-      const engine = new TaskEngine({ contextName, memory: this.memory });
-      const task = await engine.getNextTask();
-      if (task) {
-        this.executing = true;
-        try {
-          this.server.setActiveContext(contextName);
-          this.server.setCurrentTask(task.id);
-          console.log(`[worker] Executing task [${task.id.slice(0, 8)}] "${task.title}" in context "${contextName}"`);
-          await engine.startTask(task.id);
-          this.agent.setContext(contextName);
-          try {
-            await this.memory.createContext(contextName);
-          } catch {
-          }
-          const taskPrompt = buildTaskPrompt(task.title, task.description);
-          const response = await this.agent.processMessage(taskPrompt);
-          console.log(`[worker] Task [${task.id.slice(0, 8)}] completed. Response: ${response.content.slice(0, 100)}...`);
-          await engine.completeTask(task.id);
-          await this.reportStatus("working", contextName, task.id);
-        } catch (err) {
-          console.error(`[worker] Task [${task.id.slice(0, 8)}] failed:`, err.message);
-          await this.reportStatus("error", contextName, task.id, err.message);
-        } finally {
-          this.executing = false;
-          this.server.setCurrentTask(null);
-        }
-        return;
-      }
-    }
-    if (this.server.getAssignedContexts().length > 0) {
-      this.server.setActiveContext(null);
-      this.server.setCurrentTask(null);
-    }
-  }
-  /**
-   * Periodically report status back to Primary.
-   */
-  startStatusReporting() {
-    this.statusReportTimer = setInterval(() => {
-      if (!this.running || !this.registeredWorkerId) return;
-      const contexts = this.server.getAssignedContexts();
-      if (contexts.length === 0) return;
-      this.reportStatus(
-        this.executing ? "working" : "idle",
-        this.executing ? contexts[0] : null,
-        null
-      ).catch(() => {
-      });
-    }, this.workerConfig.status_report_interval_ms);
-  }
-  /**
-   * Send a status report to the Primary.
-   */
-  async reportStatus(activity, currentContext, currentTask, error) {
-    if (!this.registeredWorkerId) return;
-    const report = {
-      activity,
-      current_context: currentContext,
-      current_task: currentTask,
-      error
-    };
-    try {
-      const statusUrl = `${this.workerConfig.primary_url}${PRIMARY_ROUTES.status(this.registeredWorkerId)}`;
-      await fetch(statusUrl, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify(report)
-      });
-    } catch {
-    }
-  }
-  // --- Accessors for testing ---
-  getServer() {
-    return this.server;
-  }
-  getAgent() {
-    return this.agent;
-  }
-  getMemoryClient() {
-    return this.memory;
-  }
-  isRunning() {
-    return this.running;
-  }
-  isExecuting() {
-    return this.executing;
-  }
-  getRegisteredWorkerId() {
-    return this.registeredWorkerId;
-  }
-};
-function buildTaskPrompt(title, description) {
-  let prompt = `[TASK] ${title}`;
-  if (description) {
-    prompt += `
-
-${description}`;
-  }
-  prompt += "\n\nPlease work on this task. Use your memory and knowledge to provide a thorough response.";
-  return prompt;
-}
-async function startWorker(config) {
-  if (!config.worker || !config.worker.enabled) {
-    throw new Error("Worker mode is not enabled in config. Set [worker] enabled = true.");
-  }
-  const runtime = new WorkerRuntime({
-    config,
-    workerConfig: config.worker
-  });
-  await runtime.start();
-  return runtime;
-}
-
-export {
-  LLMClient,
-  MemoryClient,
-  ContextManager,
-  TaskEngine,
-  buildSystemPrompt,
-  buildMessages,
-  Agent,
-  loadConfig,
-  SesameClient2 as SesameClient,
-  startPipeline,
-  PRIMARY_ROUTES,
-  WORKER_ROUTES,
-  DEFAULT_HEALTH_INTERVAL_MS,
-  HEALTH_TIMEOUT_MS,
-  DEFAULT_SYNC_INTERVAL_MS,
-  WorkerServer,
-  WorkerRuntime,
-  startWorker
-};
-//# sourceMappingURL=chunk-LRK64BAK.js.map