@karmaniverous/jeeves-watcher-openclaw 0.8.1 → 0.9.0

package/dist/cli.js

@@ -1,17 +1,1223 @@
 #!/usr/bin/env node
-import { dirname, join } from 'node:path';
-import { existsSync, mkdirSync, writeFileSync, readFileSync, renameSync } from 'node:fs';
-import require$$0$3, { join as join$1, dirname as dirname$1, resolve } from 'path';
-import require$$0$2, { existsSync as existsSync$1, rmSync, mkdirSync as mkdirSync$1, cpSync, readFileSync as readFileSync$1, writeFileSync as writeFileSync$1 } from 'fs';
+import { existsSync, readFileSync, writeFileSync, renameSync, rmSync, mkdirSync, cpSync } from 'node:fs';
+import { dirname, resolve, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import 'vm';
+import require$$0$3 from 'path';
+import require$$0$2 from 'fs';
 import require$$0 from 'constants';
 import require$$0$1 from 'stream';
 import require$$4 from 'util';
 import require$$5 from 'assert';
 import require$$2 from 'events';
-import 'node:url';
 import 'node:child_process';
-import { homedir } from 'os';
-import { fileURLToPath } from 'url';
+import { homedir } from 'node:os';
+
+/**
+ * @implements {IHooks}
+ */
+class Hooks {
+  /**
+   * @callback HookCallback
+   * @this {*|Jsep} this
+   * @param {Jsep} env
+   * @returns: void
+   */
+  /**
+   * Adds the given callback to the list of callbacks for the given hook.
+   *
+   * The callback will be invoked when the hook it is registered for is run.
+   *
+   * One callback function can be registered to multiple hooks and the same hook multiple times.
+   *
+   * @param {string|object} name The name of the hook, or an object of callbacks keyed by name
+   * @param {HookCallback|boolean} callback The callback function which is given environment variables.
+   * @param {?boolean} [first=false] Will add the hook to the top of the list (defaults to the bottom)
+   * @public
+   */
+  add(name, callback, first) {
+    if (typeof arguments[0] != 'string') {
+      // Multiple hook callbacks, keyed by name
+      for (let name in arguments[0]) {
+        this.add(name, arguments[0][name], arguments[1]);
+      }
+    } else {
+      (Array.isArray(name) ? name : [name]).forEach(function (name) {
+        this[name] = this[name] || [];
+        if (callback) {
+          this[name][first ? 'unshift' : 'push'](callback);
+        }
+      }, this);
+    }
+  }
+
+  /**
+   * Runs a hook invoking all registered callbacks with the given environment variables.
+   *
+   * Callbacks will be invoked synchronously and in the order in which they were registered.
+   *
+   * @param {string} name The name of the hook.
+   * @param {Object<string, any>} env The environment variables of the hook passed to all callbacks registered.
+   * @public
+   */
+  run(name, env) {
+    this[name] = this[name] || [];
+    this[name].forEach(function (callback) {
+      callback.call(env && env.context ? env.context : env, env);
+    });
+  }
+}
+
+/**
+ * @implements {IPlugins}
+ */
+class Plugins {
+  constructor(jsep) {
+    this.jsep = jsep;
+    this.registered = {};
+  }
+
+  /**
+   * @callback PluginSetup
+   * @this {Jsep} jsep
+   * @returns: void
+   */
+  /**
+   * Adds the given plugin(s) to the registry
+   *
+   * @param {object} plugins
+   * @param {string} plugins.name The name of the plugin
+   * @param {PluginSetup} plugins.init The init function
+   * @public
+   */
+  register(...plugins) {
+    plugins.forEach(plugin => {
+      if (typeof plugin !== 'object' || !plugin.name || !plugin.init) {
+        throw new Error('Invalid JSEP plugin format');
+      }
+      if (this.registered[plugin.name]) {
+        // already registered. Ignore.
+        return;
+      }
+      plugin.init(this.jsep);
+      this.registered[plugin.name] = plugin;
+    });
+  }
+}
+
+//     JavaScript Expression Parser (JSEP) 1.4.0
+
+class Jsep {
+  /**
+   * @returns {string}
+   */
+  static get version() {
+    // To be filled in by the template
+    return '1.4.0';
+  }
+
+  /**
+   * @returns {string}
+   */
+  static toString() {
+    return 'JavaScript Expression Parser (JSEP) v' + Jsep.version;
+  }
+  // ==================== CONFIG ================================
+  /**
+   * @method addUnaryOp
+   * @param {string} op_name The name of the unary op to add
+   * @returns {Jsep}
+   */
+  static addUnaryOp(op_name) {
+    Jsep.max_unop_len = Math.max(op_name.length, Jsep.max_unop_len);
+    Jsep.unary_ops[op_name] = 1;
+    return Jsep;
+  }
+
+  /**
+   * @method jsep.addBinaryOp
+   * @param {string} op_name The name of the binary op to add
+   * @param {number} precedence The precedence of the binary op (can be a float). Higher number = higher precedence
+   * @param {boolean} [isRightAssociative=false] whether operator is right-associative
+   * @returns {Jsep}
+   */
+  static addBinaryOp(op_name, precedence, isRightAssociative) {
+    Jsep.max_binop_len = Math.max(op_name.length, Jsep.max_binop_len);
+    Jsep.binary_ops[op_name] = precedence;
+    if (isRightAssociative) {
+      Jsep.right_associative.add(op_name);
+    } else {
+      Jsep.right_associative.delete(op_name);
+    }
+    return Jsep;
+  }
+
+  /**
+   * @method addIdentifierChar
+   * @param {string} char The additional character to treat as a valid part of an identifier
+   * @returns {Jsep}
+   */
+  static addIdentifierChar(char) {
+    Jsep.additional_identifier_chars.add(char);
+    return Jsep;
+  }
+
+  /**
+   * @method addLiteral
+   * @param {string} literal_name The name of the literal to add
+   * @param {*} literal_value The value of the literal
+   * @returns {Jsep}
+   */
+  static addLiteral(literal_name, literal_value) {
+    Jsep.literals[literal_name] = literal_value;
+    return Jsep;
+  }
+
+  /**
+   * @method removeUnaryOp
+   * @param {string} op_name The name of the unary op to remove
+   * @returns {Jsep}
+   */
+  static removeUnaryOp(op_name) {
+    delete Jsep.unary_ops[op_name];
+    if (op_name.length === Jsep.max_unop_len) {
+      Jsep.max_unop_len = Jsep.getMaxKeyLen(Jsep.unary_ops);
+    }
+    return Jsep;
+  }
+
+  /**
+   * @method removeAllUnaryOps
+   * @returns {Jsep}
+   */
+  static removeAllUnaryOps() {
+    Jsep.unary_ops = {};
+    Jsep.max_unop_len = 0;
+    return Jsep;
+  }
+
+  /**
+   * @method removeIdentifierChar
+   * @param {string} char The additional character to stop treating as a valid part of an identifier
+   * @returns {Jsep}
+   */
+  static removeIdentifierChar(char) {
+    Jsep.additional_identifier_chars.delete(char);
+    return Jsep;
+  }
+
+  /**
+   * @method removeBinaryOp
+   * @param {string} op_name The name of the binary op to remove
+   * @returns {Jsep}
+   */
+  static removeBinaryOp(op_name) {
+    delete Jsep.binary_ops[op_name];
+    if (op_name.length === Jsep.max_binop_len) {
+      Jsep.max_binop_len = Jsep.getMaxKeyLen(Jsep.binary_ops);
+    }
+    Jsep.right_associative.delete(op_name);
+    return Jsep;
+  }
+
+  /**
+   * @method removeAllBinaryOps
+   * @returns {Jsep}
+   */
+  static removeAllBinaryOps() {
+    Jsep.binary_ops = {};
+    Jsep.max_binop_len = 0;
+    return Jsep;
+  }
+
+  /**
+   * @method removeLiteral
+   * @param {string} literal_name The name of the literal to remove
+   * @returns {Jsep}
+   */
+  static removeLiteral(literal_name) {
+    delete Jsep.literals[literal_name];
+    return Jsep;
+  }
+
+  /**
+   * @method removeAllLiterals
+   * @returns {Jsep}
+   */
+  static removeAllLiterals() {
+    Jsep.literals = {};
+    return Jsep;
+  }
+  // ==================== END CONFIG ============================
+
+  /**
+   * @returns {string}
+   */
+  get char() {
+    return this.expr.charAt(this.index);
+  }
+
+  /**
+   * @returns {number}
+   */
+  get code() {
+    return this.expr.charCodeAt(this.index);
+  }
+  /**
+   * @param {string} expr a string with the passed in express
+   * @returns Jsep
+   */
+  constructor(expr) {
+    // `index` stores the character number we are currently at
+    // All of the gobbles below will modify `index` as we move along
+    this.expr = expr;
+    this.index = 0;
+  }
+
+  /**
+   * static top-level parser
+   * @returns {jsep.Expression}
+   */
+  static parse(expr) {
+    return new Jsep(expr).parse();
+  }
+
+  /**
+   * Get the longest key length of any object
+   * @param {object} obj
+   * @returns {number}
+   */
+  static getMaxKeyLen(obj) {
+    return Math.max(0, ...Object.keys(obj).map(k => k.length));
+  }
+
+  /**
+   * `ch` is a character code in the next three functions
+   * @param {number} ch
+   * @returns {boolean}
+   */
+  static isDecimalDigit(ch) {
+    return ch >= 48 && ch <= 57; // 0...9
+  }
+
+  /**
+   * Returns the precedence of a binary operator or `0` if it isn't a binary operator. Can be float.
+   * @param {string} op_val
+   * @returns {number}
+   */
+  static binaryPrecedence(op_val) {
+    return Jsep.binary_ops[op_val] || 0;
+  }
+
+  /**
+   * Looks for start of identifier
+   * @param {number} ch
+   * @returns {boolean}
+   */
+  static isIdentifierStart(ch) {
+    return ch >= 65 && ch <= 90 ||
+    // A...Z
+    ch >= 97 && ch <= 122 ||
+    // a...z
+    ch >= 128 && !Jsep.binary_ops[String.fromCharCode(ch)] ||
+    // any non-ASCII that is not an operator
+    Jsep.additional_identifier_chars.has(String.fromCharCode(ch)); // additional characters
+  }
+
+  /**
+   * @param {number} ch
+   * @returns {boolean}
+   */
+  static isIdentifierPart(ch) {
+    return Jsep.isIdentifierStart(ch) || Jsep.isDecimalDigit(ch);
+  }
+
+  /**
+   * throw error at index of the expression
+   * @param {string} message
+   * @throws
+   */
+  throwError(message) {
+    const error = new Error(message + ' at character ' + this.index);
+    error.index = this.index;
+    error.description = message;
+    throw error;
+  }
+
+  /**
+   * Run a given hook
+   * @param {string} name
+   * @param {jsep.Expression|false} [node]
+   * @returns {?jsep.Expression}
+   */
+  runHook(name, node) {
+    if (Jsep.hooks[name]) {
+      const env = {
+        context: this,
+        node
+      };
+      Jsep.hooks.run(name, env);
+      return env.node;
+    }
+    return node;
+  }
+
+  /**
+   * Runs a given hook until one returns a node
+   * @param {string} name
+   * @returns {?jsep.Expression}
+   */
+  searchHook(name) {
+    if (Jsep.hooks[name]) {
+      const env = {
+        context: this
+      };
+      Jsep.hooks[name].find(function (callback) {
+        callback.call(env.context, env);
+        return env.node;
+      });
+      return env.node;
+    }
+  }
+
+  /**
+   * Push `index` up to the next non-space character
+   */
+  gobbleSpaces() {
+    let ch = this.code;
+    // Whitespace
+    while (ch === Jsep.SPACE_CODE || ch === Jsep.TAB_CODE || ch === Jsep.LF_CODE || ch === Jsep.CR_CODE) {
+      ch = this.expr.charCodeAt(++this.index);
+    }
+    this.runHook('gobble-spaces');
+  }
+
+  /**
+   * Top-level method to parse all expressions and returns compound or single node
+   * @returns {jsep.Expression}
+   */
+  parse() {
+    this.runHook('before-all');
+    const nodes = this.gobbleExpressions();
+
+    // If there's only one expression just try returning the expression
+    const node = nodes.length === 1 ? nodes[0] : {
+      type: Jsep.COMPOUND,
+      body: nodes
+    };
+    return this.runHook('after-all', node);
+  }
+
+  /**
+   * top-level parser (but can be reused within as well)
+   * @param {number} [untilICode]
+   * @returns {jsep.Expression[]}
+   */
+  gobbleExpressions(untilICode) {
+    let nodes = [],
+      ch_i,
+      node;
+    while (this.index < this.expr.length) {
+      ch_i = this.code;
+
+      // Expressions can be separated by semicolons, commas, or just inferred without any
+      // separators
+      if (ch_i === Jsep.SEMCOL_CODE || ch_i === Jsep.COMMA_CODE) {
+        this.index++; // ignore separators
+      } else {
+        // Try to gobble each expression individually
+        if (node = this.gobbleExpression()) {
+          nodes.push(node);
+          // If we weren't able to find a binary expression and are out of room, then
+          // the expression passed in probably has too much
+        } else if (this.index < this.expr.length) {
+          if (ch_i === untilICode) {
+            break;
+          }
+          this.throwError('Unexpected "' + this.char + '"');
+        }
+      }
+    }
+    return nodes;
+  }
+
+  /**
+   * The main parsing function.
+   * @returns {?jsep.Expression}
+   */
+  gobbleExpression() {
+    const node = this.searchHook('gobble-expression') || this.gobbleBinaryExpression();
+    this.gobbleSpaces();
+    return this.runHook('after-expression', node);
+  }
+
+  /**
+   * Search for the operation portion of the string (e.g. `+`, `===`)
+   * Start by taking the longest possible binary operations (3 characters: `===`, `!==`, `>>>`)
+   * and move down from 3 to 2 to 1 character until a matching binary operation is found
+   * then, return that binary operation
+   * @returns {string|boolean}
+   */
+  gobbleBinaryOp() {
+    this.gobbleSpaces();
+    let to_check = this.expr.substr(this.index, Jsep.max_binop_len);
+    let tc_len = to_check.length;
+    while (tc_len > 0) {
+      // Don't accept a binary op when it is an identifier.
+      // Binary ops that start with a identifier-valid character must be followed
+      // by a non identifier-part valid character
+      if (Jsep.binary_ops.hasOwnProperty(to_check) && (!Jsep.isIdentifierStart(this.code) || this.index + to_check.length < this.expr.length && !Jsep.isIdentifierPart(this.expr.charCodeAt(this.index + to_check.length)))) {
+        this.index += tc_len;
+        return to_check;
+      }
+      to_check = to_check.substr(0, --tc_len);
+    }
+    return false;
+  }
+
+  /**
+   * This function is responsible for gobbling an individual expression,
+   * e.g. `1`, `1+2`, `a+(b*2)-Math.sqrt(2)`
+   * @returns {?jsep.BinaryExpression}
+   */
+  gobbleBinaryExpression() {
+    let node, biop, prec, stack, biop_info, left, right, i, cur_biop;
+
+    // First, try to get the leftmost thing
+    // Then, check to see if there's a binary operator operating on that leftmost thing
+    // Don't gobbleBinaryOp without a left-hand-side
+    left = this.gobbleToken();
+    if (!left) {
+      return left;
+    }
+    biop = this.gobbleBinaryOp();
+
+    // If there wasn't a binary operator, just return the leftmost node
+    if (!biop) {
+      return left;
+    }
+
+    // Otherwise, we need to start a stack to properly place the binary operations in their
+    // precedence structure
+    biop_info = {
+      value: biop,
+      prec: Jsep.binaryPrecedence(biop),
+      right_a: Jsep.right_associative.has(biop)
+    };
+    right = this.gobbleToken();
+    if (!right) {
+      this.throwError("Expected expression after " + biop);
+    }
+    stack = [left, biop_info, right];
+
+    // Properly deal with precedence using [recursive descent](http://www.engr.mun.ca/~theo/Misc/exp_parsing.htm)
+    while (biop = this.gobbleBinaryOp()) {
+      prec = Jsep.binaryPrecedence(biop);
+      if (prec === 0) {
+        this.index -= biop.length;
+        break;
+      }
+      biop_info = {
+        value: biop,
+        prec,
+        right_a: Jsep.right_associative.has(biop)
+      };
+      cur_biop = biop;
+
+      // Reduce: make a binary expression from the three topmost entries.
+      const comparePrev = prev => biop_info.right_a && prev.right_a ? prec > prev.prec : prec <= prev.prec;
+      while (stack.length > 2 && comparePrev(stack[stack.length - 2])) {
+        right = stack.pop();
+        biop = stack.pop().value;
+        left = stack.pop();
+        node = {
+          type: Jsep.BINARY_EXP,
+          operator: biop,
+          left,
+          right
+        };
+        stack.push(node);
+      }
+      node = this.gobbleToken();
+      if (!node) {
+        this.throwError("Expected expression after " + cur_biop);
+      }
+      stack.push(biop_info, node);
+    }
+    i = stack.length - 1;
+    node = stack[i];
+    while (i > 1) {
+      node = {
+        type: Jsep.BINARY_EXP,
+        operator: stack[i - 1].value,
+        left: stack[i - 2],
+        right: node
+      };
+      i -= 2;
+    }
+    return node;
+  }
+
+  /**
+   * An individual part of a binary expression:
+   * e.g. `foo.bar(baz)`, `1`, `"abc"`, `(a % 2)` (because it's in parenthesis)
+   * @returns {boolean|jsep.Expression}
+   */
+  gobbleToken() {
+    let ch, to_check, tc_len, node;
+    this.gobbleSpaces();
+    node = this.searchHook('gobble-token');
+    if (node) {
+      return this.runHook('after-token', node);
+    }
+    ch = this.code;
+    if (Jsep.isDecimalDigit(ch) || ch === Jsep.PERIOD_CODE) {
+      // Char code 46 is a dot `.` which can start off a numeric literal
+      return this.gobbleNumericLiteral();
+    }
+    if (ch === Jsep.SQUOTE_CODE || ch === Jsep.DQUOTE_CODE) {
+      // Single or double quotes
+      node = this.gobbleStringLiteral();
+    } else if (ch === Jsep.OBRACK_CODE) {
+      node = this.gobbleArray();
+    } else {
+      to_check = this.expr.substr(this.index, Jsep.max_unop_len);
+      tc_len = to_check.length;
+      while (tc_len > 0) {
+        // Don't accept an unary op when it is an identifier.
+        // Unary ops that start with a identifier-valid character must be followed
+        // by a non identifier-part valid character
+        if (Jsep.unary_ops.hasOwnProperty(to_check) && (!Jsep.isIdentifierStart(this.code) || this.index + to_check.length < this.expr.length && !Jsep.isIdentifierPart(this.expr.charCodeAt(this.index + to_check.length)))) {
+          this.index += tc_len;
+          const argument = this.gobbleToken();
+          if (!argument) {
+            this.throwError('missing unaryOp argument');
+          }
+          return this.runHook('after-token', {
+            type: Jsep.UNARY_EXP,
+            operator: to_check,
+            argument,
+            prefix: true
+          });
+        }
+        to_check = to_check.substr(0, --tc_len);
+      }
+      if (Jsep.isIdentifierStart(ch)) {
+        node = this.gobbleIdentifier();
+        if (Jsep.literals.hasOwnProperty(node.name)) {
+          node = {
+            type: Jsep.LITERAL,
+            value: Jsep.literals[node.name],
+            raw: node.name
+          };
+        } else if (node.name === Jsep.this_str) {
+          node = {
+            type: Jsep.THIS_EXP
+          };
+        }
+      } else if (ch === Jsep.OPAREN_CODE) {
+        // open parenthesis
+        node = this.gobbleGroup();
+      }
+    }
+    if (!node) {
+      return this.runHook('after-token', false);
+    }
+    node = this.gobbleTokenProperty(node);
+    return this.runHook('after-token', node);
+  }
+
+  /**
+   * Gobble properties of of identifiers/strings/arrays/groups.
+   * e.g. `foo`, `bar.baz`, `foo['bar'].baz`
+   * It also gobbles function calls:
+   * e.g. `Math.acos(obj.angle)`
+   * @param {jsep.Expression} node
+   * @returns {jsep.Expression}
+   */
+  gobbleTokenProperty(node) {
+    this.gobbleSpaces();
+    let ch = this.code;
+    while (ch === Jsep.PERIOD_CODE || ch === Jsep.OBRACK_CODE || ch === Jsep.OPAREN_CODE || ch === Jsep.QUMARK_CODE) {
+      let optional;
+      if (ch === Jsep.QUMARK_CODE) {
+        if (this.expr.charCodeAt(this.index + 1) !== Jsep.PERIOD_CODE) {
+          break;
+        }
+        optional = true;
+        this.index += 2;
+        this.gobbleSpaces();
+        ch = this.code;
+      }
+      this.index++;
+      if (ch === Jsep.OBRACK_CODE) {
+        node = {
+          type: Jsep.MEMBER_EXP,
+          computed: true,
+          object: node,
+          property: this.gobbleExpression()
+        };
+        if (!node.property) {
+          this.throwError('Unexpected "' + this.char + '"');
+        }
+        this.gobbleSpaces();
+        ch = this.code;
+        if (ch !== Jsep.CBRACK_CODE) {
+          this.throwError('Unclosed [');
+        }
+        this.index++;
+      } else if (ch === Jsep.OPAREN_CODE) {
+        // A function call is being made; gobble all the arguments
+        node = {
+          type: Jsep.CALL_EXP,
+          'arguments': this.gobbleArguments(Jsep.CPAREN_CODE),
+          callee: node
+        };
+      } else if (ch === Jsep.PERIOD_CODE || optional) {
+        if (optional) {
+          this.index--;
+        }
+        this.gobbleSpaces();
+        node = {
+          type: Jsep.MEMBER_EXP,
+          computed: false,
+          object: node,
+          property: this.gobbleIdentifier()
+        };
+      }
+      if (optional) {
+        node.optional = true;
+      } // else leave undefined for compatibility with esprima
+
+      this.gobbleSpaces();
+      ch = this.code;
+    }
+    return node;
+  }
+
+  /**
+   * Parse simple numeric literals: `12`, `3.4`, `.5`. Do this by using a string to
+   * keep track of everything in the numeric literal and then calling `parseFloat` on that string
+   * @returns {jsep.Literal}
+   */
+  gobbleNumericLiteral() {
+    let number = '',
+      ch,
+      chCode;
+    while (Jsep.isDecimalDigit(this.code)) {
+      number += this.expr.charAt(this.index++);
+    }
+    if (this.code === Jsep.PERIOD_CODE) {
+      // can start with a decimal marker
+      number += this.expr.charAt(this.index++);
+      while (Jsep.isDecimalDigit(this.code)) {
+        number += this.expr.charAt(this.index++);
+      }
+    }
+    ch = this.char;
+    if (ch === 'e' || ch === 'E') {
+      // exponent marker
+      number += this.expr.charAt(this.index++);
+      ch = this.char;
+      if (ch === '+' || ch === '-') {
+        // exponent sign
+        number += this.expr.charAt(this.index++);
+      }
+      while (Jsep.isDecimalDigit(this.code)) {
+        // exponent itself
+        number += this.expr.charAt(this.index++);
+      }
+      if (!Jsep.isDecimalDigit(this.expr.charCodeAt(this.index - 1))) {
+        this.throwError('Expected exponent (' + number + this.char + ')');
+      }
+    }
+    chCode = this.code;
+
+    // Check to make sure this isn't a variable name that start with a number (123abc)
+    if (Jsep.isIdentifierStart(chCode)) {
+      this.throwError('Variable names cannot start with a number (' + number + this.char + ')');
+    } else if (chCode === Jsep.PERIOD_CODE || number.length === 1 && number.charCodeAt(0) === Jsep.PERIOD_CODE) {
+      this.throwError('Unexpected period');
+    }
+    return {
+      type: Jsep.LITERAL,
+      value: parseFloat(number),
+      raw: number
+    };
+  }
+
+  /**
+   * Parses a string literal, staring with single or double quotes with basic support for escape codes
+   * e.g. `"hello world"`, `'this is\nJSEP'`
+   * @returns {jsep.Literal}
+   */
+  gobbleStringLiteral() {
+    let str = '';
+    const startIndex = this.index;
+    const quote = this.expr.charAt(this.index++);
+    let closed = false;
+    while (this.index < this.expr.length) {
+      let ch = this.expr.charAt(this.index++);
+      if (ch === quote) {
+        closed = true;
+        break;
+      } else if (ch === '\\') {
+        // Check for all of the common escape codes
+        ch = this.expr.charAt(this.index++);
+        switch (ch) {
+          case 'n':
+            str += '\n';
+            break;
+          case 'r':
+            str += '\r';
+            break;
+          case 't':
+            str += '\t';
+            break;
+          case 'b':
+            str += '\b';
+            break;
+          case 'f':
+            str += '\f';
+            break;
+          case 'v':
+            str += '\x0B';
+            break;
+          default:
+            str += ch;
+        }
+      } else {
+        str += ch;
+      }
+    }
+    if (!closed) {
+      this.throwError('Unclosed quote after "' + str + '"');
+    }
+    return {
+      type: Jsep.LITERAL,
+      value: str,
+      raw: this.expr.substring(startIndex, this.index)
+    };
+  }
+
+  /**
+   * Gobbles only identifiers
+   * e.g.: `foo`, `_value`, `$x1`
+   * Also, this function checks if that identifier is a literal:
+   * (e.g. `true`, `false`, `null`) or `this`
+   * @returns {jsep.Identifier}
+   */
+  gobbleIdentifier() {
+    let ch = this.code,
+      start = this.index;
+    if (Jsep.isIdentifierStart(ch)) {
+      this.index++;
+    } else {
+      this.throwError('Unexpected ' + this.char);
+    }
+    while (this.index < this.expr.length) {
+      ch = this.code;
+      if (Jsep.isIdentifierPart(ch)) {
+        this.index++;
+      } else {
+        break;
+      }
+    }
+    return {
+      type: Jsep.IDENTIFIER,
+      name: this.expr.slice(start, this.index)
+    };
+  }
+
+  /**
+   * Gobbles a list of arguments within the context of a function call
+   * or array literal. This function also assumes that the opening character
+   * `(` or `[` has already been gobbled, and gobbles expressions and commas
+   * until the terminator character `)` or `]` is encountered.
+   * e.g. `foo(bar, baz)`, `my_func()`, or `[bar, baz]`
+   * @param {number} termination
+   * @returns {jsep.Expression[]}
+   */
+  gobbleArguments(termination) {
+    const args = [];
+    let closed = false;
+    let separator_count = 0;
+    while (this.index < this.expr.length) {
+      this.gobbleSpaces();
+      let ch_i = this.code;
+      if (ch_i === termination) {
+        // done parsing
+        closed = true;
+        this.index++;
+        if (termination === Jsep.CPAREN_CODE && separator_count && separator_count >= args.length) {
+          this.throwError('Unexpected token ' + String.fromCharCode(termination));
+        }
+        break;
+      } else if (ch_i === Jsep.COMMA_CODE) {
+        // between expressions
+        this.index++;
+        separator_count++;
+        if (separator_count !== args.length) {
+          // missing argument
+          if (termination === Jsep.CPAREN_CODE) {
+            this.throwError('Unexpected token ,');
+          } else if (termination === Jsep.CBRACK_CODE) {
+            for (let arg = args.length; arg < separator_count; arg++) {
+              args.push(null);
+            }
+          }
+        }
+      } else if (args.length !== separator_count && separator_count !== 0) {
+        // NOTE: `&& separator_count !== 0` allows for either all commas, or all spaces as arguments
+        this.throwError('Expected comma');
+      } else {
+        const node = this.gobbleExpression();
+        if (!node || node.type === Jsep.COMPOUND) {
+          this.throwError('Expected comma');
+        }
+        args.push(node);
+      }
+    }
+    if (!closed) {
+      this.throwError('Expected ' + String.fromCharCode(termination));
+    }
+    return args;
+  }
+
+  /**
+   * Responsible for parsing a group of things within parentheses `()`
+   * that have no identifier in front (so not a function call)
+   * This function assumes that it needs to gobble the opening parenthesis
+   * and then tries to gobble everything within that parenthesis, assuming
+   * that the next thing it should see is the close parenthesis. If not,
+   * then the expression probably doesn't have a `)`
+   * @returns {boolean|jsep.Expression}
+   */
+  gobbleGroup() {
+    this.index++;
+    let nodes = this.gobbleExpressions(Jsep.CPAREN_CODE);
+    if (this.code === Jsep.CPAREN_CODE) {
+      this.index++;
+      if (nodes.length === 1) {
+        return nodes[0];
+      } else if (!nodes.length) {
+        return false;
+      } else {
+        return {
+          type: Jsep.SEQUENCE_EXP,
+          expressions: nodes
+        };
+      }
+    } else {
+      this.throwError('Unclosed (');
+    }
+  }
+
+  /**
+   * Responsible for parsing Array literals `[1, 2, 3]`
+   * This function assumes that it needs to gobble the opening bracket
+   * and then tries to gobble the expressions as arguments.
+   * @returns {jsep.ArrayExpression}
+   */
+  gobbleArray() {
+    this.index++;
+    return {
+      type: Jsep.ARRAY_EXP,
+      elements: this.gobbleArguments(Jsep.CBRACK_CODE)
+    };
+  }
+}
+
+// Static fields:
+const hooks = new Hooks();
+Object.assign(Jsep, {
+  hooks,
+  plugins: new Plugins(Jsep),
+  // Node Types
+  // ----------
+  // This is the full set of types that any JSEP node can be.
+  // Store them here to save space when minified
+  COMPOUND: 'Compound',
+  SEQUENCE_EXP: 'SequenceExpression',
+  IDENTIFIER: 'Identifier',
+  MEMBER_EXP: 'MemberExpression',
+  LITERAL: 'Literal',
+  THIS_EXP: 'ThisExpression',
+  CALL_EXP: 'CallExpression',
+  UNARY_EXP: 'UnaryExpression',
+  BINARY_EXP: 'BinaryExpression',
+  ARRAY_EXP: 'ArrayExpression',
+  TAB_CODE: 9,
+  LF_CODE: 10,
+  CR_CODE: 13,
+  SPACE_CODE: 32,
+  PERIOD_CODE: 46,
+  // '.'
+  COMMA_CODE: 44,
+  // ','
+  SQUOTE_CODE: 39,
+  // single quote
+  DQUOTE_CODE: 34,
+  // double quotes
+  OPAREN_CODE: 40,
+  // (
+  CPAREN_CODE: 41,
+  // )
+  OBRACK_CODE: 91,
+  // [
+  CBRACK_CODE: 93,
+  // ]
+  QUMARK_CODE: 63,
+  // ?
+  SEMCOL_CODE: 59,
+  // ;
+  COLON_CODE: 58,
+  // :
+
+  // Operations
+  // ----------
+  // Use a quickly-accessible map to store all of the unary operators
+  // Values are set to `1` (it really doesn't matter)
+  unary_ops: {
+    '-': 1,
+    '!': 1,
+    '~': 1,
+    '+': 1
+  },
+  // Also use a map for the binary operations but set their values to their
+  // binary precedence for quick reference (higher number = higher precedence)
+  // see [Order of operations](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Operator_Precedence)
+  binary_ops: {
+    '||': 1,
+    '??': 1,
+    '&&': 2,
+    '|': 3,
+    '^': 4,
+    '&': 5,
+    '==': 6,
+    '!=': 6,
+    '===': 6,
+    '!==': 6,
+    '<': 7,
+    '>': 7,
+    '<=': 7,
+    '>=': 7,
+    '<<': 8,
+    '>>': 8,
+    '>>>': 8,
+    '+': 9,
+    '-': 9,
+    '*': 10,
+    '/': 10,
+    '%': 10,
+    '**': 11
+  },
+  // sets specific binary_ops as right-associative
+  right_associative: new Set(['**']),
+  // Additional valid identifier chars, apart from a-z, A-Z and 0-9 (except on the starting char)
+  additional_identifier_chars: new Set(['$', '_']),
+  // Literals
+  // ----------
+  // Store the values to return for the various literals we may encounter
+  literals: {
+    'true': true,
+    'false': false,
+    'null': null
+  },
+  // Except for `this`, which is special. This could be changed to something like `'self'` as well
+  this_str: 'this'
+});
+Jsep.max_unop_len = Jsep.getMaxKeyLen(Jsep.unary_ops);
+Jsep.max_binop_len = Jsep.getMaxKeyLen(Jsep.binary_ops);
+
+// Backward Compatibility:
+const jsep = expr => new Jsep(expr).parse();
+const stdClassProps = Object.getOwnPropertyNames(class Test {});
+Object.getOwnPropertyNames(Jsep).filter(prop => !stdClassProps.includes(prop) && jsep[prop] === undefined).forEach(m => {
+  jsep[m] = Jsep[m];
+});
+jsep.Jsep = Jsep; // allows for const { Jsep } = require('jsep');
+
+const CONDITIONAL_EXP = 'ConditionalExpression';
+var ternary = {
+  name: 'ternary',
+  init(jsep) {
+    // Ternary expression: test ? consequent : alternate
+    jsep.hooks.add('after-expression', function gobbleTernary(env) {
+      if (env.node && this.code === jsep.QUMARK_CODE) {
+        this.index++;
+        const test = env.node;
+        const consequent = this.gobbleExpression();
+        if (!consequent) {
+          this.throwError('Expected expression');
+        }
+        this.gobbleSpaces();
+        if (this.code === jsep.COLON_CODE) {
+          this.index++;
+          const alternate = this.gobbleExpression();
+          if (!alternate) {
+            this.throwError('Expected expression');
+          }
+          env.node = {
+            type: CONDITIONAL_EXP,
+            test,
+            consequent,
+            alternate
+          };
+
+          // check for operators of higher priority than ternary (i.e. assignment)
+          // jsep sets || at 1, and assignment at 0.9, and conditional should be between them
+          if (test.operator && jsep.binary_ops[test.operator] <= 0.9) {
+            let newTest = test;
+            while (newTest.right.operator && jsep.binary_ops[newTest.right.operator] <= 0.9) {
+              newTest = newTest.right;
+            }
+            env.node.test = newTest.right;
+            newTest.right = env.node;
+            env.node = test;
+          }
+        } else {
+          this.throwError('Expected :');
+        }
+      }
+    });
+  }
+};
+
+// Add default plugins:
+
+jsep.plugins.register(ternary);
+
+const FSLASH_CODE = 47; // '/'
+const BSLASH_CODE = 92; // '\\'
+
+var index = {
+  name: 'regex',
+  init(jsep) {
+    // Regex literal: /abc123/ig
+    jsep.hooks.add('gobble-token', function gobbleRegexLiteral(env) {
+      if (this.code === FSLASH_CODE) {
+        const patternIndex = ++this.index;
+        let inCharSet = false;
+        while (this.index < this.expr.length) {
+          if (this.code === FSLASH_CODE && !inCharSet) {
+            const pattern = this.expr.slice(patternIndex, this.index);
+            let flags = '';
+            while (++this.index < this.expr.length) {
+              const code = this.code;
+              if (code >= 97 && code <= 122 // a...z
+              || code >= 65 && code <= 90 // A...Z
+              || code >= 48 && code <= 57) {
+                // 0-9
+                flags += this.char;
+              } else {
+                break;
+              }
+            }
+            let value;
+            try {
+              value = new RegExp(pattern, flags);
+            } catch (e) {
+              this.throwError(e.message);
+            }
+            env.node = {
+              type: jsep.LITERAL,
+              value,
+              raw: this.expr.slice(patternIndex - 1, this.index)
+            };
+
+            // allow . [] and () after regex: /regex/.test(a)
+            env.node = this.gobbleTokenProperty(env.node);
+            return env.node;
+          }
+          if (this.code === jsep.OBRACK_CODE) {
+            inCharSet = true;
+          } else if (inCharSet && this.code === jsep.CBRACK_CODE) {
+            inCharSet = false;
+          }
+          this.index += this.code === BSLASH_CODE ? 2 : 1;
+        }
+        this.throwError('Unclosed Regex');
+      }
+    });
+  }
+};
+
+const PLUS_CODE = 43; // +
+const MINUS_CODE = 45; // -
+
+const plugin = {
+  name: 'assignment',
+  assignmentOperators: new Set(['=', '*=', '**=', '/=', '%=', '+=', '-=', '<<=', '>>=', '>>>=', '&=', '^=', '|=', '||=', '&&=', '??=']),
+  updateOperators: [PLUS_CODE, MINUS_CODE],
+  assignmentPrecedence: 0.9,
+  init(jsep) {
+    const updateNodeTypes = [jsep.IDENTIFIER, jsep.MEMBER_EXP];
+    plugin.assignmentOperators.forEach(op => jsep.addBinaryOp(op, plugin.assignmentPrecedence, true));
+    jsep.hooks.add('gobble-token', function gobbleUpdatePrefix(env) {
+      const code = this.code;
+      if (plugin.updateOperators.some(c => c === code && c === this.expr.charCodeAt(this.index + 1))) {
+        this.index += 2;
+        env.node = {
+          type: 'UpdateExpression',
+          operator: code === PLUS_CODE ? '++' : '--',
+          argument: this.gobbleTokenProperty(this.gobbleIdentifier()),
+          prefix: true
+        };
+        if (!env.node.argument || !updateNodeTypes.includes(env.node.argument.type)) {
+          this.throwError(`Unexpected ${env.node.operator}`);
+        }
+      }
+    });
+    jsep.hooks.add('after-token', function gobbleUpdatePostfix(env) {
+      if (env.node) {
+        const code = this.code;
+        if (plugin.updateOperators.some(c => c === code && c === this.expr.charCodeAt(this.index + 1))) {
+          if (!updateNodeTypes.includes(env.node.type)) {
+            this.throwError(`Unexpected ${env.node.operator}`);
+          }
+          this.index += 2;
+          env.node = {
+            type: 'UpdateExpression',
+            operator: code === PLUS_CODE ? '++' : '--',
+            argument: env.node,
+            prefix: false
+          };
+        }
+      }
+    });
+    jsep.hooks.add('after-expression', function gobbleAssignment(env) {
+      if (env.node) {
+        // Note: Binaries can be chained in a single expression to respect
+        // operator precedence (i.e. a = b = 1 + 2 + 3)
+        // Update all binary assignment nodes in the tree
+        updateBinariesToAssignments(env.node);
+      }
+    });
+    function updateBinariesToAssignments(node) {
+      if (plugin.assignmentOperators.has(node.operator)) {
+        node.type = 'AssignmentExpression';
+        updateBinariesToAssignments(node.left);
+        updateBinariesToAssignments(node.right);
+      } else if (!node.operator) {
+        Object.values(node).forEach(val => {
+          if (val && typeof val === 'object') {
+            updateBinariesToAssignments(val);
+          }
+        });
+      }
+    }
+  }
+};
+
+/* eslint-disable no-bitwise -- Convenient */
+
+// register plugins
+jsep.plugins.register(index, plugin);
+jsep.addUnaryOp('typeof');
+jsep.addUnaryOp('void');
+jsep.addLiteral('null', null);
+jsep.addLiteral('undefined', undefined);
 
 var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
 
@@ -4837,7 +6043,7 @@ function requireSemver () {
 	return semver;
 }
 
-var semverExports = requireSemver();
+requireSemver();
 
 function commonjsRequire(path) {
 	throw new Error('Could not dynamically require "' + path + '". Please configure the dynamicRequireTargets or/and ignoreDynamicRequires option of @rollup/plugin-commonjs appropriately for this require call to work.');
@@ -17122,6 +18328,64 @@ ZodPromise.create;
 ZodOptional.create;
 ZodNullable.create;
 
+/**
+ * Shared file I/O helpers for managed section operations.
+ *
+ * @remarks
+ * Extracts the atomic write pattern and file-level locking into
+ * reusable utilities, eliminating duplication between
+ * `updateManagedSection` and `removeManagedSection`.
+ */
+/** Stale lock threshold in ms (2 minutes). */
+const STALE_LOCK_MS = 120_000;
+/** Default core version when none provided. */
+const DEFAULT_CORE_VERSION = '0.0.0';
+/** Lock retry options. */
+const LOCK_RETRIES = { retries: 5, minTimeout: 100, maxTimeout: 1000 };
+/**
+ * Write content to a file atomically via a temp file + rename.
+ *
+ * @param filePath - Absolute path to the target file.
+ * @param content - Content to write.
+ */
+function atomicWrite(filePath, content) {
+    const dir = dirname(filePath);
+    const tempPath = join(dir, `.${String(Date.now())}.tmp`);
+    writeFileSync(tempPath, content, 'utf-8');
+    renameSync(tempPath, filePath);
+}
+/**
+ * Execute a callback while holding a file lock.
+ *
+ * @remarks
+ * Acquires a lock on the file, executes the callback, and releases
+ * the lock in a finally block. The lock uses a 2-minute stale threshold
+ * and retries up to 5 times.
+ *
+ * @param filePath - Absolute path to the file to lock.
+ * @param fn - Async callback to execute while holding the lock.
+ */
+async function withFileLock(filePath, fn) {
+    let release;
+    try {
+        release = await properLockfileExports.lock(filePath, {
+            stale: STALE_LOCK_MS,
+            retries: LOCK_RETRIES,
+        });
+        await fn();
+    }
+    finally {
+        if (release) {
+            try {
+                await release();
+            }
+            catch {
+                // Lock already released or file deleted — safe to ignore
+            }
+        }
+    }
+}
+
 /**
  * Comment markers for managed content blocks.
  *
@@ -17148,10 +18412,6 @@ const TOOLS_MARKERS = {
  * Captures: [1] marker text, [2] version, [3] timestamp
  */
 const VERSION_STAMP_PATTERN = /<!--\s*(.+?)\s*\|\s*core:(\S+)\s*\|\s*(\S+)\s*-->/;
-/** Staleness threshold for version-stamp convergence in milliseconds. */
-const STALENESS_THRESHOLD_MS = 5 * 60 * 1000;
-/** Warning text prepended inside managed block when cleanup is needed. */
-const CLEANUP_FLAG = '> ⚠️ CLEANUP NEEDED: Orphaned Jeeves content may exist below this managed section. Review everything after the END marker and remove any content that duplicates what appears above.';
 
 /**
  * Managed section IDs and their stable ordering for TOOLS.md.
@@ -17185,61 +18445,6 @@ const SECTION_ORDER = [
     SECTION_IDS.Meta,
 ];
 
-/**
- * Similarity-based cleanup detection for orphaned managed content.
- *
- * @remarks
- * Uses Jaccard similarity on 3-word shingles (Decision 22) to detect
- * when orphaned managed content exists in the user content zone.
- */
-/** Default similarity threshold for cleanup detection. */
-const DEFAULT_THRESHOLD = 0.15;
-/**
- * Generate a set of n-word shingles from text.
- *
- * @param text - Input text.
- * @param n - Shingle size (default 3).
- * @returns Set of n-word shingles.
- */
-function shingles(text, n = 3) {
-    const words = text.toLowerCase().split(/\s+/).filter(Boolean);
-    const set = new Set();
-    for (let i = 0; i <= words.length - n; i++) {
-        set.add(words.slice(i, i + n).join(' '));
-    }
-    return set;
-}
-/**
- * Compute Jaccard similarity between two sets.
- *
- * @param a - First set.
- * @param b - Second set.
- * @returns Jaccard similarity coefficient (0 to 1).
- */
-function jaccard(a, b) {
-    if (a.size === 0 && b.size === 0)
-        return 0;
-    let intersection = 0;
-    for (const item of a) {
-        if (b.has(item))
-            intersection++;
-    }
-    return intersection / (a.size + b.size - intersection);
-}
-/**
- * Check whether user content contains orphaned managed content.
- *
- * @param managedContent - The current managed block content.
- * @param userContent - Content below the END marker.
- * @param threshold - Jaccard threshold (default 0.15).
- * @returns `true` if cleanup is needed.
- */
-function needsCleanup(managedContent, userContent, threshold = DEFAULT_THRESHOLD) {
-    if (!userContent.trim())
-        return false;
-    return jaccard(shingles(managedContent), shingles(userContent)) > threshold;
-}
-
 /**
  * Stable section ordering for managed TOOLS.md blocks.
  *
@@ -17408,149 +18613,6 @@ function formatBeginMarker(markerText, version) {
 function formatEndMarker(markerText) {
     return `<!-- ${markerText} -->`;
 }
-/**
- * Determine whether this writer should proceed based on version-stamp
- * convergence rules.
- *
- * @param myVersion - The current core library version.
- * @param existing - The existing version stamp (if any).
- * @param stalenessThresholdMs - Staleness threshold in ms (default: 5 min).
- * @returns `true` if the writer should proceed with the write.
- */
-function shouldWrite(myVersion, existing, stalenessThresholdMs = STALENESS_THRESHOLD_MS) {
-    // No existing stamp — always write
-    if (!existing)
-        return true;
-    // My version >= stamped version — always write (I'm current or newer)
-    if (semverExports.gte(myVersion, existing.version))
-        return true;
-    // My version < stamped version — check staleness
-    const stampAge = Date.now() - new Date(existing.timestamp).getTime();
-    return stampAge >= stalenessThresholdMs;
-}
-
-/**
- * Generic managed-section writer with block and section modes.
- *
- * @remarks
- * Supports two modes:
- * - `block`: Replaces the entire managed block (SOUL.md, AGENTS.md).
- * - `section`: Upserts a named H2 section within the managed block (TOOLS.md).
- *
- * Provides file-level locking, version-stamp convergence, and atomic writes.
- */
-/** Default core version when none provided. */
-const DEFAULT_VERSION = '0.0.0';
-/** Stale lock threshold in ms (2 minutes). */
-const STALE_LOCK_MS = 120_000;
-/**
- * Update a managed section in a file.
- *
- * @param filePath - Absolute path to the target file.
- * @param content - New content to write.
- * @param options - Write mode and optional configuration.
- */
-async function updateManagedSection(filePath, content, options = {}) {
-    const { mode = 'block', sectionId, markers = TOOLS_MARKERS, coreVersion = DEFAULT_VERSION, stalenessThresholdMs, } = options;
-    if (mode === 'section' && !sectionId) {
-        throw new Error('sectionId is required when mode is "section"');
-    }
-    const dir = dirname(filePath);
-    if (!existsSync(dir)) {
-        mkdirSync(dir, { recursive: true });
-    }
-    // Create file if it doesn't exist
-    if (!existsSync(filePath)) {
-        writeFileSync(filePath, '', 'utf-8');
-    }
-    let release;
-    try {
-        release = await properLockfileExports.lock(filePath, {
-            stale: STALE_LOCK_MS,
-            retries: { retries: 5, minTimeout: 100, maxTimeout: 1000 },
-        });
-        const fileContent = readFileSync(filePath, 'utf-8');
-        const parsed = parseManaged(fileContent, markers);
-        // Version-stamp convergence check (block mode only).
-        // In section mode, components always write their own sections — the version
-        // stamp governs shared content convergence, not component-specific sections.
-        if (mode === 'block' &&
-            !shouldWrite(coreVersion, parsed.versionStamp, stalenessThresholdMs)) {
-            return;
-        }
-        let newManagedBody;
-        if (mode === 'block') {
-            // Prepend H1 title if markers specify one
-            newManagedBody = markers.title
-                ? `# ${markers.title}\n\n${content}`
-                : content;
-        }
-        else {
-            // Section mode: upsert the named section
-            const sections = [...parsed.sections];
-            const existingIdx = sections.findIndex((s) => s.id === sectionId);
-            if (existingIdx >= 0) {
-                sections[existingIdx] = { id: sectionId, content };
-            }
-            else {
-                sections.push({ id: sectionId, content });
-            }
-            sortSectionsByOrder(sections);
-            const sectionText = sections
-                .map((s) => `## ${s.id}\n\n${s.content}`)
-                .join('\n\n');
-            // Prepend H1 title if markers specify one (e.g., "# Jeeves Platform Tools")
-            newManagedBody = markers.title
-                ? `# ${markers.title}\n\n${sectionText}`
-                : sectionText;
-        }
-        // Cleanup detection
-        const userContent = parsed.userContent;
-        const cleanupNeeded = needsCleanup(newManagedBody, userContent);
-        // Build the full managed block
-        const beginLine = formatBeginMarker(markers.begin, coreVersion);
-        const endLine = formatEndMarker(markers.end);
-        const parts = [];
-        if (parsed.beforeContent) {
-            parts.push(parsed.beforeContent);
-            parts.push('');
-        }
-        parts.push(beginLine);
-        if (cleanupNeeded) {
-            parts.push('');
-            parts.push(CLEANUP_FLAG);
-        }
-        parts.push('');
-        parts.push(newManagedBody);
-        parts.push('');
-        parts.push(endLine);
-        if (userContent) {
-            parts.push('');
-            parts.push(userContent);
-        }
-        parts.push('');
-        const newFileContent = parts.join('\n');
-        // Atomic write: write to temp file, then rename
-        const tempPath = join(dir, `.${String(Date.now())}.tmp`);
-        writeFileSync(tempPath, newFileContent, 'utf-8');
-        renameSync(tempPath, filePath);
-    }
-    catch (err) {
-        // Log warning but don't throw — writer cycles are periodic
-        const message = err instanceof Error ? err.message : String(err);
-        console.warn(`jeeves-core: updateManagedSection failed for ${filePath}: ${message}`);
-    }
-    finally {
-        if (release) {
-            try {
-                await release();
-            }
-            catch {
-                // Lock already released or file deleted — safe to ignore
-            }
-        }
-    }
-}
 
 /**
  * Core configuration schema and resolution.
@@ -17591,162 +18653,313 @@ objectType({
 });
 
 /**
- * CLI for installing/uninstalling the jeeves-watcher OpenClaw plugin.
+ * Remove a managed section or entire managed block from a file.
  *
- * Usage:
- *   npx \@karmaniverous/jeeves-watcher-openclaw install
- *   npx \@karmaniverous/jeeves-watcher-openclaw uninstall
+ * @remarks
+ * Supports two modes:
+ * - No `sectionId`: Remove the entire managed block (markers + content),
+ *   leaving user content intact.
+ * - With `sectionId`: Remove a specific H2 section from within the
+ *   managed block. If it was the last section, remove the entire block.
  *
- * Bypasses OpenClaw's `plugins install` command, which has a known
- * spawn EINVAL bug on Windows (https://github.com/openclaw/openclaw/issues/9224).
+ * Provides file-level locking and atomic writes (temp file + rename).
+ * Missing markers or nonexistent sections are no-ops (no error thrown).
+ */
+/**
+ * Remove a managed section or entire managed block from a file.
  *
- * Supports non-default installations via:
- *   - OPENCLAW_CONFIG env var (path to openclaw.json)
- *   - OPENCLAW_HOME env var (path to .openclaw directory)
- *   - Default: ~/.openclaw/openclaw.json
+ * @param filePath - Absolute path to the target file.
+ * @param options - Optional section ID and custom markers.
+ */
+async function removeManagedSection(filePath, options = {}) {
+    const { sectionId, markers = TOOLS_MARKERS } = options;
+    if (!existsSync(filePath))
+        return;
+    await withFileLock(filePath, () => {
+        const fileContent = readFileSync(filePath, 'utf-8');
+        const parsed = parseManaged(fileContent, markers);
+        if (!parsed.found)
+            return;
+        let newContent;
+        if (!sectionId) {
+            // Remove entire managed block
+            newContent = buildWithoutBlock(parsed.beforeContent, parsed.userContent);
+        }
+        else {
+            // Remove specific section
+            const remaining = parsed.sections.filter((s) => s.id !== sectionId);
+            if (remaining.length === parsed.sections.length) {
+                // Section not found — no-op
+                return;
+            }
+            if (remaining.length === 0) {
+                // Last section removed — remove entire block
+                newContent = buildWithoutBlock(parsed.beforeContent, parsed.userContent);
+            }
+            else {
+                // Rebuild managed block without the removed section
+                newContent = buildWithSections(parsed.beforeContent, parsed.userContent, remaining, markers, parsed.versionStamp?.version);
+            }
+        }
+        atomicWrite(filePath, newContent);
+    });
+}
+/** Build file content without the managed block. */
+function buildWithoutBlock(beforeContent, userContent) {
+    const parts = [];
+    if (beforeContent)
+        parts.push(beforeContent);
+    if (userContent) {
+        if (parts.length > 0)
+            parts.push('');
+        parts.push(userContent);
+    }
+    if (parts.length === 0)
+        return '';
+    return parts.join('\n') + '\n';
+}
+/** Rebuild file content with remaining sections. */
+function buildWithSections(beforeContent, userContent, sections, markers, coreVersion) {
+    const sorted = sortSectionsByOrder([...sections]);
+    const sectionText = sorted
+        .map((s) => `## ${s.id}\n\n${s.content}`)
+        .join('\n\n');
+    const managedBody = markers.title
+        ? `# ${markers.title}\n\n${sectionText}`
+        : sectionText;
+    const beginLine = formatBeginMarker(markers.begin, coreVersion ?? DEFAULT_CORE_VERSION);
+    const endLine = formatEndMarker(markers.end);
+    const parts = [];
+    if (beforeContent) {
+        parts.push(beforeContent);
+        parts.push('');
+    }
+    parts.push(beginLine);
+    parts.push('');
+    parts.push(managedBody);
+    parts.push('');
+    parts.push(endLine);
+    if (userContent) {
+        parts.push('');
+        parts.push(userContent);
+    }
+    parts.push('');
+    return parts.join('\n');
+}
+
+/**
+ * OpenClaw configuration helpers for plugin CLI installers.
+ *
+ * @remarks
+ * Provides resolution of OpenClaw home directory and config file path,
+ * plus idempotent config patching for plugin install/uninstall.
+ */
+/**
+ * Resolve the OpenClaw home directory.
+ *
+ * @remarks
+ * Resolution order:
+ * 1. `OPENCLAW_CONFIG` env var → dirname of the config file path
+ * 2. `OPENCLAW_HOME` env var → resolved path
+ * 3. Default: `~/.openclaw`
+ *
+ * @returns Absolute path to the OpenClaw home directory.
  */
-const PLUGIN_ID = 'jeeves-watcher-openclaw';
-/** Resolve the OpenClaw home directory. */
 function resolveOpenClawHome() {
     if (process.env.OPENCLAW_CONFIG) {
-        return dirname$1(resolve(process.env.OPENCLAW_CONFIG));
+        return dirname(resolve(process.env.OPENCLAW_CONFIG));
     }
     if (process.env.OPENCLAW_HOME) {
         return resolve(process.env.OPENCLAW_HOME);
     }
-    return join$1(homedir(), '.openclaw');
+    return join(homedir(), '.openclaw');
 }
-/** Resolve the config file path. */
+/**
+ * Resolve the OpenClaw config file path.
+ *
+ * @remarks
+ * If `OPENCLAW_CONFIG` is set, uses that directly.
+ * Otherwise defaults to `{home}/openclaw.json`.
+ *
+ * @param home - The OpenClaw home directory.
+ * @returns Absolute path to the config file.
+ */
 function resolveConfigPath(home) {
     if (process.env.OPENCLAW_CONFIG) {
         return resolve(process.env.OPENCLAW_CONFIG);
     }
-    return join$1(home, 'openclaw.json');
-}
-/** Get the package root (where this CLI lives). */
-function getPackageRoot() {
-    const thisFile = fileURLToPath(import.meta.url);
-    return resolve(dirname$1(thisFile), '..');
-}
-/** Read and parse JSON, returning null on failure. */
-function readJson(path) {
-    try {
-        return JSON.parse(readFileSync$1(path, 'utf8'));
-    }
-    catch {
-        return null;
-    }
-}
-/** Write JSON with 2-space indent + trailing newline. */
-function writeJson(path, data) {
-    writeFileSync$1(path, JSON.stringify(data, null, 2) + '\n');
+    return join(home, 'openclaw.json');
 }
 /**
  * Patch an allowlist array: add or remove the plugin ID.
- * Returns a log message if a change was made, or undefined.
+ *
+ * @returns A log message if a change was made, or undefined.
  */
-function patchAllowList(parent, key, label, mode) {
-    if (!Array.isArray(parent[key]) || parent[key].length === 0)
-        return undefined;
-    const list = parent[key];
+function patchAllowList(parent, key, label, pluginId, mode) {
     if (mode === 'add') {
-        if (!list.includes(PLUGIN_ID)) {
-            list.push(PLUGIN_ID);
-            return `Added "${PLUGIN_ID}" to ${label}`;
+        if (!Array.isArray(parent[key])) {
+            parent[key] = [pluginId];
+            return `Created ${label} with "${pluginId}"`;
+        }
+        const list = parent[key];
+        if (!list.includes(pluginId)) {
+            list.push(pluginId);
+            return `Added "${pluginId}" to ${label}`;
         }
     }
     else {
-        const filtered = list.filter((id) => id !== PLUGIN_ID);
+        if (!Array.isArray(parent[key]))
+            return undefined;
+        const list = parent[key];
+        const filtered = list.filter((id) => id !== pluginId);
         if (filtered.length !== list.length) {
             parent[key] = filtered;
-            return `Removed "${PLUGIN_ID}" from ${label}`;
+            return `Removed "${pluginId}" from ${label}`;
         }
     }
     return undefined;
 }
-/** Patch OpenClaw config for install or uninstall. Returns log messages. */
-function patchConfig(config, mode) {
+/**
+ * Patch an OpenClaw config for plugin install or uninstall.
+ *
+ * @remarks
+ * Manages `plugins.entries.{pluginId}` and `tools.alsoAllow`.
+ * Idempotent: adding twice produces no duplicates; removing when absent
+ * produces no errors.
+ *
+ * @param config - The parsed OpenClaw config object (mutated in place).
+ * @param pluginId - The plugin identifier.
+ * @param mode - Whether to add or remove the plugin.
+ * @returns Array of log messages describing changes made.
+ */
+function patchConfig(config, pluginId, mode) {
     const messages = [];
     // Ensure plugins section
     if (!config.plugins || typeof config.plugins !== 'object') {
         config.plugins = {};
     }
     const plugins = config.plugins;
-    // plugins.allow
-    const pluginAllow = patchAllowList(plugins, 'allow', 'plugins.allow', mode);
-    if (pluginAllow)
-        messages.push(pluginAllow);
     // plugins.entries
     if (!plugins.entries || typeof plugins.entries !== 'object') {
         plugins.entries = {};
     }
     const entries = plugins.entries;
     if (mode === 'add') {
-        if (!entries[PLUGIN_ID]) {
-            entries[PLUGIN_ID] = { enabled: true };
-            messages.push(`Added "${PLUGIN_ID}" to plugins.entries`);
+        if (!entries[pluginId]) {
+            entries[pluginId] = { enabled: true };
+            messages.push(`Added "${pluginId}" to plugins.entries`);
         }
     }
-    else if (PLUGIN_ID in entries) {
-        Reflect.deleteProperty(entries, PLUGIN_ID);
-        messages.push(`Removed "${PLUGIN_ID}" from plugins.entries`);
+    else if (pluginId in entries) {
+        Reflect.deleteProperty(entries, pluginId);
+        messages.push(`Removed "${pluginId}" from plugins.entries`);
+    }
+    // tools.alsoAllow
+    if (!config.tools || typeof config.tools !== 'object') {
+        config.tools = {};
     }
-    // tools.allow
-    const tools = (config.tools ?? {});
-    const toolAllow = patchAllowList(tools, 'allow', 'tools.allow', mode);
-    if (toolAllow)
-        messages.push(toolAllow);
+    const tools = config.tools;
+    const toolAlsoAllow = patchAllowList(tools, 'alsoAllow', 'tools.alsoAllow', pluginId, mode);
+    if (toolAlsoAllow)
+        messages.push(toolAlsoAllow);
     return messages;
 }
+
+/**
+ * @module plugin/constants
+ * Shared constants for the OpenClaw plugin package.
+ *
+ * @remarks
+ * Imported by both the plugin bundle (`index.ts`) and the CLI bundle
+ * (`cli.ts`). Rollup inlines these into each output independently.
+ */
+/** Plugin identifier used in OpenClaw config and extensions directory. */
+const PLUGIN_ID = 'jeeves-watcher-openclaw';
+
+/**
+ * CLI for installing/uninstalling the jeeves-watcher OpenClaw plugin.
+ *
+ * Usage:
+ *   npx \@karmaniverous/jeeves-watcher-openclaw install
+ *   npx \@karmaniverous/jeeves-watcher-openclaw uninstall
+ *
+ * Bypasses OpenClaw's `plugins install` command, which has a known
+ * spawn EINVAL bug on Windows (https://github.com/openclaw/openclaw/issues/9224).
+ *
+ * Supports non-default installations via:
+ *   - OPENCLAW_CONFIG env var (path to openclaw.json)
+ *   - OPENCLAW_HOME env var (path to .openclaw directory)
+ *   - Default: ~/.openclaw/openclaw.json
+ *
+ * @module cli
+ */
+/** Get the package root (where this CLI lives). */
+function getPackageRoot() {
+    const thisFile = fileURLToPath(import.meta.url);
+    return resolve(dirname(thisFile), '..');
+}
+/** Read and parse JSON, returning null on failure. */
+function readJson(path) {
+    try {
+        return JSON.parse(readFileSync(path, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+/** Write JSON with 2-space indent + trailing newline. */
+function writeJson(path, data) {
+    writeFileSync(path, JSON.stringify(data, null, 2) + '\n');
+}
 /** Install the plugin into OpenClaw's extensions directory. */
 function install() {
     const home = resolveOpenClawHome();
     const configPath = resolveConfigPath(home);
-    const extDir = join$1(home, 'extensions', PLUGIN_ID);
+    const extDir = join(home, 'extensions', PLUGIN_ID);
     const pkgRoot = getPackageRoot();
     console.log(`OpenClaw home:  ${home}`);
     console.log(`Config:         ${configPath}`);
     console.log(`Extensions dir: ${extDir}`);
     console.log(`Package root:   ${pkgRoot}`);
     console.log();
-    if (!existsSync$1(home)) {
+    if (!existsSync(home)) {
         console.error(`Error: OpenClaw home directory not found at ${home}`);
         console.error('Set OPENCLAW_HOME or OPENCLAW_CONFIG if using a non-default installation.');
         process.exit(1);
     }
-    if (!existsSync$1(configPath)) {
+    if (!existsSync(configPath)) {
         console.error(`Error: OpenClaw config not found at ${configPath}`);
         console.error('Set OPENCLAW_CONFIG if using a non-default config location.');
         process.exit(1);
     }
-    const pluginManifestPath = join$1(pkgRoot, 'openclaw.plugin.json');
-    if (!existsSync$1(pluginManifestPath)) {
+    const pluginManifestPath = join(pkgRoot, 'openclaw.plugin.json');
+    if (!existsSync(pluginManifestPath)) {
         console.error(`Error: openclaw.plugin.json not found at ${pluginManifestPath}`);
         process.exit(1);
     }
     // Copy package to extensions directory
     console.log('Copying plugin to extensions directory...');
-    if (existsSync$1(extDir)) {
+    if (existsSync(extDir)) {
         rmSync(extDir, { recursive: true, force: true });
     }
-    mkdirSync$1(extDir, { recursive: true });
+    mkdirSync(extDir, { recursive: true });
     for (const file of [
         'dist',
         'content',
         'openclaw.plugin.json',
         'package.json',
     ]) {
-        const src = join$1(pkgRoot, file);
-        const dest = join$1(extDir, file);
-        if (existsSync$1(src)) {
+        const src = join(pkgRoot, file);
+        const dest = join(extDir, file);
+        if (existsSync(src)) {
             cpSync(src, dest, { recursive: true });
-            console.log(`  ✓ ${file}`);
+            console.log(`  \u2713 ${file}`);
         }
     }
-    const nodeModulesSrc = join$1(pkgRoot, 'node_modules');
-    if (existsSync$1(nodeModulesSrc)) {
-        cpSync(nodeModulesSrc, join$1(extDir, 'node_modules'), { recursive: true });
-        console.log('  ✓ node_modules');
+    const nodeModulesSrc = join(pkgRoot, 'node_modules');
+    if (existsSync(nodeModulesSrc)) {
+        cpSync(nodeModulesSrc, join(extDir, 'node_modules'), { recursive: true });
+        console.log('  \u2713 node_modules');
     }
     // Patch config
     console.log();
@@ -17756,114 +18969,51 @@ function install() {
         console.error(`Error: Could not parse ${configPath}`);
         process.exit(1);
     }
-    for (const msg of patchConfig(config, 'add')) {
-        console.log(`  ✓ ${msg}`);
+    for (const msg of patchConfig(config, PLUGIN_ID, 'add')) {
+        console.log(`  \u2713 ${msg}`);
     }
     writeJson(configPath, config);
     console.log();
-    console.log('✅ Plugin installed successfully.');
+    console.log('\u2705 Plugin installed successfully.');
     console.log('   Restart the OpenClaw gateway to load the plugin.');
 }
 /** Uninstall the plugin from OpenClaw's extensions directory. */
 async function uninstall() {
     const home = resolveOpenClawHome();
     const configPath = resolveConfigPath(home);
-    const extDir = join$1(home, 'extensions', PLUGIN_ID);
+    const extDir = join(home, 'extensions', PLUGIN_ID);
     console.log(`OpenClaw home:  ${home}`);
     console.log(`Config:         ${configPath}`);
     console.log(`Extensions dir: ${extDir}`);
     console.log();
-    if (existsSync$1(extDir)) {
+    if (existsSync(extDir)) {
         rmSync(extDir, { recursive: true, force: true });
-        console.log(`✓ Removed ${extDir}`);
+        console.log(`\u2713 Removed ${extDir}`);
     }
     else {
-        console.log(`  (extensions directory not found, skipping)`);
+        console.log('  (extensions directory not found, skipping)');
     }
-    if (existsSync$1(configPath)) {
+    if (existsSync(configPath)) {
         console.log('Patching OpenClaw config...');
         const config = readJson(configPath);
         if (config) {
-            for (const msg of patchConfig(config, 'remove')) {
-                console.log(`  ✓ ${msg}`);
+            for (const msg of patchConfig(config, PLUGIN_ID, 'remove')) {
+                console.log(`  \u2713 ${msg}`);
             }
             writeJson(configPath, config);
         }
     }
-    // Clean up TOOLS.md watcher section
-    await cleanupToolsMd(home, configPath);
+    // Remove managed TOOLS.md section
+    const toolsPath = join(process.cwd(), 'TOOLS.md');
+    if (existsSync(toolsPath)) {
+        console.log('Removing managed TOOLS.md section...');
+        await removeManagedSection(toolsPath, { sectionId: 'Watcher' });
+        console.log('  \u2713 Removed Watcher section from TOOLS.md');
+    }
     console.log();
-    console.log('✅ Plugin uninstalled successfully.');
+    console.log('\u2705 Plugin uninstalled successfully.');
     console.log('   Restart the OpenClaw gateway to complete removal.');
 }
-/** Resolve the workspace directory from OpenClaw config. */
-function resolveWorkspaceDir(home, configPath) {
-    const config = readJson(configPath);
-    if (!config)
-        return null;
-    // Check agents.defaults.workspace
-    const agents = config.agents;
-    const defaults = agents?.defaults;
-    const workspace = defaults?.workspace;
-    if (workspace) {
-        return resolve(workspace.replace(/^~/, homedir()));
-    }
-    // Default workspace location
-    return join$1(home, 'workspace');
-}
-/**
- * Remove the Watcher section from TOOLS.md on uninstall.
- *
- * @remarks
- * Uses core's `parseManaged` to locate the managed block and its sections,
- * then rewrites without the Watcher section via `updateManagedSection`.
- * If the Watcher section is the only one, removes the entire managed block.
- */
-async function cleanupToolsMd(home, configPath) {
-    const workspaceDir = resolveWorkspaceDir(home, configPath);
-    if (!workspaceDir)
-        return;
-    const toolsPath = join$1(workspaceDir, 'TOOLS.md');
-    if (!existsSync$1(toolsPath))
-        return;
-    const content = readFileSync$1(toolsPath, 'utf8');
-    const parsed = parseManaged(content, TOOLS_MARKERS);
-    if (!parsed.found)
-        return;
-    const watcherSection = parsed.sections.find((s) => s.id === 'Watcher');
-    if (!watcherSection)
-        return;
-    const remaining = parsed.sections.filter((s) => s.id !== 'Watcher');
-    if (remaining.length === 0) {
-        // No sections left — remove the entire managed block.
-        const parts = [];
-        if (parsed.beforeContent)
-            parts.push(parsed.beforeContent);
-        if (parsed.userContent) {
-            if (parts.length > 0)
-                parts.push('');
-            parts.push(parsed.userContent);
-        }
-        const newContent = parts.join('\n').trim() + '\n';
-        writeFileSync$1(toolsPath, newContent);
-    }
-    else {
-        // Rewrite the managed block without the Watcher section.
-        // We write an empty string for the Watcher section; core's
-        // updateManagedSection will rebuild from the remaining sections.
-        // Actually, the cleanest approach is to rebuild the section text
-        // from the remaining sections and write the entire block.
-        const sectionText = remaining
-            .map((s) => `## ${s.id}\n\n${s.content}`)
-            .join('\n\n');
-        const body = `# ${TOOLS_MARKERS.title}\n\n${sectionText}`;
-        await updateManagedSection(toolsPath, body, {
-            mode: 'block',
-            markers: TOOLS_MARKERS,
-        });
-    }
-    console.log('\u2713 Cleaned up TOOLS.md (removed Watcher section)');
-}
 // Main
 const command = process.argv[2];
 switch (command) {
@@ -17874,7 +19024,7 @@ switch (command) {
         void uninstall();
         break;
     default:
-        console.log(`@karmaniverous/jeeves-watcher-openclaw — OpenClaw plugin installer`);
+        console.log(`@karmaniverous/jeeves-watcher-openclaw \u2014 OpenClaw plugin installer`);
         console.log();
         console.log('Usage:');
         console.log('  npx @karmaniverous/jeeves-watcher-openclaw install    Install plugin');
@@ -17894,5 +19044,3 @@ switch (command) {
         }
         break;
 }
-
-export { patchConfig };