lobstah-openclaw-plugin 0.7.2 → 0.7.4

package/dist/index.js

@@ -2,9 +2,9 @@
 import { definePluginEntry } from "openclaw/plugin-sdk/core";
 
 // apps/node/src/tools.ts
-import * as fs6 from "node:fs";
-import * as path4 from "node:path";
-import { randomUUID } from "node:crypto";
+import * as fs7 from "node:fs";
+import * as path5 from "node:path";
+import { randomUUID as randomUUID2 } from "node:crypto";
 
 // packages/core/dist/types.js
 var VERBS = ["working", "needs-decision", "blocked", "paused", "done", "failed"];
@@ -14,6 +14,10 @@ var TERMINAL_VERBS = ["done", "failed"];
 import * as os from "node:os";
 import * as path from "node:path";
 import * as fs from "node:fs";
+import { randomUUID } from "node:crypto";
+function uniqueTempPath(file) {
+  return `${file}.tmp-${process.pid}-${randomUUID()}`;
+}
 function lobstahHome() {
   return process.env.LOBSTAH_HOME ?? path.join(os.homedir(), ".lobstah");
 }
@@ -84,7 +88,7 @@ function reconcile({ log, lastEventAt: lastEventAt2, now = Date.now(), busyThres
 
 // packages/core/dist/queue.js
 function atomicWrite(file, content) {
-  const tmp = `${file}.tmp-${process.pid}-${Date.now()}`;
+  const tmp = uniqueTempPath(file);
   fs3.writeFileSync(tmp, content);
   fs3.renameSync(tmp, file);
 }
@@ -119,6 +123,729 @@ function requestCancel(id, lane) {
 }
 
 // packages/core/dist/config.js
+import * as fs4 from "node:fs";
+import * as os2 from "node:os";
+import * as path3 from "node:path";
+
+// node_modules/.pnpm/smol-toml@1.8.0/node_modules/smol-toml/dist/date.js
+var DATE_TIME_RE = /^(\d{4}-\d{2}-\d{2})?[T ]?(?:(\d{2}):\d{2}(?::\d{2}(?:\.\d+)?)?)?(Z|[-+]\d{2}:\d{2})?$/i;
+var TomlDate = class _TomlDate extends Date {
+  #hasDate = false;
+  #hasTime = false;
+  #offset = null;
+  constructor(date) {
+    let hasDate = true;
+    let hasTime = true;
+    let offset = "Z";
+    if (typeof date === "string") {
+      let match = date.match(DATE_TIME_RE);
+      if (match) {
+        if (!match[1]) {
+          hasDate = false;
+          date = `0000-01-01T${date}`;
+        }
+        hasTime = !!match[2];
+        hasTime && date[10] === " " && (date = date.replace(" ", "T"));
+        if (match[2] && +match[2] > 23) {
+          date = "";
+        } else {
+          offset = match[3] || null;
+          date = date.toUpperCase();
+          if (!offset && hasTime)
+            date += "Z";
+        }
+      } else {
+        date = "";
+      }
+    }
+    super(date);
+    if (!isNaN(this.getTime())) {
+      this.#hasDate = hasDate;
+      this.#hasTime = hasTime;
+      this.#offset = offset;
+    }
+  }
+  isDateTime() {
+    return this.#hasDate && this.#hasTime;
+  }
+  isLocal() {
+    return !this.#hasDate || !this.#hasTime || !this.#offset;
+  }
+  isDate() {
+    return this.#hasDate && !this.#hasTime;
+  }
+  isTime() {
+    return this.#hasTime && !this.#hasDate;
+  }
+  isValid() {
+    return this.#hasDate || this.#hasTime;
+  }
+  toISOString() {
+    let iso = super.toISOString();
+    if (this.isDate())
+      return iso.slice(0, 10);
+    if (this.isTime())
+      return iso.slice(11, 23);
+    if (this.#offset === null)
+      return iso.slice(0, -1);
+    if (this.#offset === "Z")
+      return iso;
+    let offset = +this.#offset.slice(1, 3) * 60 + +this.#offset.slice(4, 6);
+    offset = this.#offset[0] === "-" ? offset : -offset;
+    let offsetDate = new Date(this.getTime() - offset * 6e4);
+    return offsetDate.toISOString().slice(0, -1) + this.#offset;
+  }
+  static wrapAsOffsetDateTime(jsDate, offset = "Z") {
+    let date = new _TomlDate(jsDate);
+    date.#offset = offset;
+    return date;
+  }
+  static wrapAsLocalDateTime(jsDate) {
+    let date = new _TomlDate(jsDate);
+    date.#offset = null;
+    return date;
+  }
+  static wrapAsLocalDate(jsDate) {
+    let date = new _TomlDate(jsDate);
+    date.#hasTime = false;
+    date.#offset = null;
+    return date;
+  }
+  static wrapAsLocalTime(jsDate) {
+    let date = new _TomlDate(jsDate);
+    date.#hasDate = false;
+    date.#offset = null;
+    return date;
+  }
+};
+
+// node_modules/.pnpm/smol-toml@1.8.0/node_modules/smol-toml/dist/error.js
+function getLineColFromPtr(string, ptr) {
+  let lines = string.slice(0, ptr).split(/\r\n|\n|\r/g);
+  return [lines.length, lines.pop().length + 1];
+}
+function makeCodeBlock(string, line, column) {
+  let lines = string.split(/\r\n|\n|\r/g);
+  let codeblock = "";
+  let numberLen = (Math.log10(line + 1) | 0) + 1;
+  for (let i = line - 1; i <= line + 1; i++) {
+    let l = lines[i - 1];
+    if (!l)
+      continue;
+    codeblock += i.toString().padEnd(numberLen, " ");
+    codeblock += ":  ";
+    codeblock += l;
+    codeblock += "\n";
+    if (i === line) {
+      codeblock += " ".repeat(numberLen + column + 2);
+      codeblock += "^\n";
+    }
+  }
+  return codeblock;
+}
+var TomlError = class extends Error {
+  line;
+  column;
+  codeblock;
+  constructor(message, options) {
+    const [line, column] = getLineColFromPtr(options.toml, options.ptr);
+    const codeblock = makeCodeBlock(options.toml, line, column);
+    super(`Invalid TOML document: ${message}
+
+${codeblock}`, options);
+    this.line = line;
+    this.column = column;
+    this.codeblock = codeblock;
+  }
+};
+
+// node_modules/.pnpm/smol-toml@1.8.0/node_modules/smol-toml/dist/util.js
+function indexOfNewline(str, start = 0) {
+  let idx = str.indexOf("\n", start);
+  if (str.charCodeAt(idx - 1) === 13)
+    idx--;
+  return idx;
+}
+function skipComment(ctx) {
+  for (; ctx.p < ctx.s.length; ctx.p++) {
+    let c = ctx.s.charCodeAt(ctx.p);
+    if (c === 10)
+      break;
+    if (c === 13 && ctx.s.charCodeAt(ctx.p + 1) === 10) {
+      ctx.p++;
+      break;
+    }
+    if (c < 32 && c !== 9 || c === 127) {
+      throw new TomlError("control characters are not allowed in comments", {
+        toml: ctx.s,
+        ptr: ctx.p
+      });
+    }
+  }
+}
+function skipVoid(ctx, banNewLines, banComments) {
+  let c;
+  while (1) {
+    while ((c = ctx.s.charCodeAt(ctx.p)) === 32 || c === 9 || !banNewLines && (c === 10 || c === 13 && ctx.s.charCodeAt(ctx.p + 1) === 10))
+      ctx.p++;
+    if (banComments || c !== 35)
+      break;
+    skipComment(ctx);
+  }
+}
+function skipUntil(ctx, sep, end) {
+  let ptr = ctx.p;
+  if (!end) {
+    ptr = indexOfNewline(ctx.s, ptr);
+    ctx.p = ptr < 0 ? ctx.s.length : ptr;
+    return;
+  }
+  for (; ctx.p < ctx.s.length; ctx.p++) {
+    let c = ctx.s.charCodeAt(ctx.p);
+    if (c === 35) {
+      skipComment(ctx);
+    } else if (c === end || c === sep) {
+      return;
+    }
+  }
+  throw new TomlError("cannot find end of structure", {
+    toml: ctx.s,
+    ptr
+  });
+}
+
+// node_modules/.pnpm/smol-toml@1.8.0/node_modules/smol-toml/dist/primitive.js
+var INT_REGEX = /^((0x[0-9a-fA-F](_?[0-9a-fA-F])*)|(([+-]|0[ob])?\d(_?\d)*))$/;
+var FLOAT_REGEX = /^[+-]?\d(_?\d)*(\.\d(_?\d)*)?([eE][+-]?\d(_?\d)*)?$/;
+var LEADING_ZERO = /^[+-]?0[0-9_]/;
+function parseString(ctx) {
+  let start = ctx.p;
+  let c = ctx.s.charCodeAt(ctx.p++);
+  let first = c;
+  let isLiteral = c === 39;
+  let isMultiline = c === ctx.s.charCodeAt(ctx.p) && c === ctx.s.charCodeAt(ctx.p + 1);
+  if (isMultiline) {
+    if ((c = ctx.s.charCodeAt(ctx.p += 2)) === 10)
+      ctx.p++;
+    else if (c === 13 && ctx.s.charCodeAt(ctx.p + 1) === 10)
+      ctx.p += 2;
+  }
+  let parsed = "";
+  let sliceStart = ctx.p;
+  let state = 0;
+  for (; ctx.p < ctx.s.length; ctx.p++) {
+    c = ctx.s.charCodeAt(ctx.p);
+    if (isMultiline && (c === 10 || c === 13 && ctx.s.charCodeAt(ctx.p + 1) === 10)) {
+      state = state && 3;
+    } else if (c < 32 && c !== 9 || c === 127) {
+      throw new TomlError("control characters are not allowed in strings", {
+        toml: ctx.s,
+        ptr: ctx.p
+      });
+    } else if ((!state || state === 3) && c === first && (!isMultiline || ctx.s.charCodeAt(ctx.p + 1) === first && ctx.s.charCodeAt(ctx.p + 2) === first)) {
+      if (isMultiline) {
+        if (ctx.s.charCodeAt(ctx.p + 3) === first)
+          ctx.p++;
+        if (ctx.s.charCodeAt(ctx.p + 3) === first)
+          ctx.p++;
+      }
+      if (!state)
+        parsed += ctx.s.slice(sliceStart, ctx.p);
+      ctx.p += isMultiline ? 3 : 1;
+      return parsed;
+    } else if (!state) {
+      if (!isLiteral && c === 92) {
+        parsed += ctx.s.slice(sliceStart, sliceStart = ctx.p);
+        state = 1;
+      }
+    } else if (state === 1) {
+      if (c === 120 || c === 117 || c === 85) {
+        let value = 0;
+        let len = c === 120 ? 2 : c === 117 ? 4 : 8;
+        for (let j = 0; j < len; j++, ctx.p++) {
+          let hex = ctx.s.charCodeAt(ctx.p + 1);
+          let digit = (
+            /* 0-9 */
+            hex >= 48 && hex <= 57 ? hex - 48 : (
+              /* A-F */
+              hex >= 65 && hex <= 70 ? hex - 65 + 10 : (
+                /* a-f */
+                hex >= 97 && hex <= 102 ? hex - 97 + 10 : -1
+              )
+            )
+          );
+          if (digit < 0)
+            throw new TomlError("invalid non-hex character in unicode escape", { toml: ctx.s, ptr: ctx.p + 1 });
+          value = value << 4 | digit;
+        }
+        if (value < 0 || value > 1114111 || value >= 55296 && value <= 57343) {
+          throw new TomlError("invalid unicode escape", { toml: ctx.s, ptr: ctx.p });
+        }
+        parsed += String.fromCodePoint(value);
+        sliceStart = ctx.p + 1;
+        state = 0;
+      } else if (c === 32 || c === 9) {
+        state = 2;
+      } else {
+        if (c === 98)
+          parsed += "\b";
+        else if (c === 116)
+          parsed += "	";
+        else if (c === 110)
+          parsed += "\n";
+        else if (c === 102)
+          parsed += "\f";
+        else if (c === 114)
+          parsed += "\r";
+        else if (c === 101)
+          parsed += "\x1B";
+        else if (c === 34)
+          parsed += '"';
+        else if (c === 92)
+          parsed += "\\";
+        else
+          throw new TomlError("unrecognized escape sequence", { toml: ctx.s, ptr: ctx.p });
+        sliceStart = ctx.p + 1;
+        state = 0;
+      }
+    } else if (c !== 32 && c !== 9) {
+      if (state === 2) {
+        throw new TomlError("invalid escape: only line-ending whitespace may be escaped", {
+          toml: ctx.s,
+          ptr: sliceStart
+        });
+      }
+      state = !isLiteral && c === 92 ? 1 : 0;
+      sliceStart = ctx.p;
+    }
+  }
+  throw new TomlError("unfinished string", { toml: ctx.s, ptr: start });
+}
+function sliceAndTrimEndOf(ctx, start, end) {
+  let value = ctx.s.slice(start, end);
+  let commentIdx = value.indexOf("#");
+  if (commentIdx > 0) {
+    skipComment({ s: value, p: commentIdx, d: 0 });
+    value = value.slice(0, commentIdx);
+  }
+  return value.trimEnd();
+}
+function parseValue(ctx, integersAsBigInt, end) {
+  let ptr = ctx.p;
+  let err = { toml: ctx.s, ptr };
+  skipUntil(ctx, 44, end);
+  let value = sliceAndTrimEndOf(ctx, ptr, ctx.p);
+  if (!value)
+    throw new TomlError("incomplete declaration: value expected", err);
+  if (value === "-inf")
+    return -Infinity;
+  if (value === "inf" || value === "+inf")
+    return Infinity;
+  if (value === "nan" || value === "+nan" || value === "-nan")
+    return NaN;
+  if (value === "-0")
+    return integersAsBigInt ? 0n : 0;
+  let isInt = INT_REGEX.test(value);
+  if (isInt || FLOAT_REGEX.test(value)) {
+    if (LEADING_ZERO.test(value)) {
+      throw new TomlError("leading zeroes are not allowed", err);
+    }
+    value = value.replace(/_/g, "");
+    let numeric = +value;
+    if (isNaN(numeric)) {
+      throw new TomlError("invalid number", err);
+    }
+    if (isInt) {
+      if ((isInt = !Number.isSafeInteger(numeric)) && !integersAsBigInt) {
+        throw new TomlError("integer value cannot be represented losslessly", err);
+      }
+      if (isInt || integersAsBigInt === true)
+        numeric = BigInt(value);
+    }
+    return numeric;
+  }
+  const date = new TomlDate(value);
+  if (!date.isValid())
+    throw new TomlError("invalid value", err);
+  return date;
+}
+
+// node_modules/.pnpm/smol-toml@1.8.0/node_modules/smol-toml/dist/extract.js
+function extractValue(ctx, end, integersAsBigInt) {
+  let ptr = ctx.p;
+  let c = ctx.s.charCodeAt(ptr);
+  if (c === 91 || c === 123) {
+    if (!ctx.d--) {
+      throw new TomlError("document contains excessively nested structures. aborting.", {
+        toml: ctx.s,
+        ptr
+      });
+    }
+    let value = c === 91 ? parseArray(ctx, integersAsBigInt) : parseInlineTable(ctx, integersAsBigInt);
+    ctx.d++;
+    return value;
+  }
+  if (c === 34 || c === 39) {
+    return parseString(ctx);
+  }
+  if (c === 116) {
+    if (ctx.s.charCodeAt(++ctx.p) !== 114 || ctx.s.charCodeAt(++ctx.p) !== 117 || ctx.s.charCodeAt(++ctx.p) !== 101)
+      throw new TomlError("invalid value", { toml: ctx.s, ptr });
+    ctx.p++;
+    return true;
+  }
+  if (c === 102) {
+    if (ctx.s.charCodeAt(++ctx.p) !== 97 || ctx.s.charCodeAt(++ctx.p) !== 108 || ctx.s.charCodeAt(++ctx.p) !== 115 || ctx.s.charCodeAt(++ctx.p) !== 101)
+      throw new TomlError("invalid value", { toml: ctx.s, ptr });
+    ctx.p++;
+    return false;
+  }
+  return parseValue(ctx, integersAsBigInt, end);
+}
+
+// node_modules/.pnpm/smol-toml@1.8.0/node_modules/smol-toml/dist/struct.js
+var KEY_PART_RE = /^[a-zA-Z0-9-_]+[ \t]*$/;
+function parseKey(ctx, end = "=") {
+  let start = ctx.p;
+  let dot = start - 1;
+  let parsed = [];
+  let endPtr = ctx.s.indexOf(end, start);
+  if (endPtr < 0) {
+    throw new TomlError("incomplete key-value: cannot find end of key", {
+      toml: ctx.s,
+      ptr: start
+    });
+  }
+  do {
+    let c = ctx.s.charCodeAt(ctx.p = ++dot);
+    if (c !== 32 && c !== 9) {
+      if (c === 34 || c === 39) {
+        if (c === ctx.s.charCodeAt(ctx.p + 1) && c === ctx.s.charCodeAt(ctx.p + 2)) {
+          throw new TomlError("multiline strings are not allowed in keys", {
+            toml: ctx.s,
+            ptr: ctx.p
+          });
+        }
+        let part = parseString(ctx);
+        dot = ctx.s.indexOf(".", ctx.p);
+        let strEnd = ctx.s.slice(ctx.p, dot < 0 || dot > endPtr ? endPtr : dot);
+        let newLine = indexOfNewline(strEnd);
+        if (newLine > -1) {
+          throw new TomlError("newlines are not allowed in keys", {
+            toml: ctx.s,
+            ptr: newLine
+          });
+        }
+        if (strEnd.trimStart()) {
+          throw new TomlError("found extra tokens after the string part", {
+            toml: ctx.s,
+            ptr: ctx.p
+          });
+        }
+        if (endPtr < ctx.p) {
+          endPtr = ctx.s.indexOf(end, ctx.p);
+          if (endPtr < 0) {
+            throw new TomlError("incomplete key-value: cannot find end of key", {
+              toml: ctx.s,
+              ptr: start
+            });
+          }
+        }
+        parsed.push(part);
+      } else {
+        dot = ctx.s.indexOf(".", ctx.p);
+        let part = ctx.s.slice(ctx.p, dot < 0 || dot > endPtr ? endPtr : dot);
+        if (!KEY_PART_RE.test(part)) {
+          throw new TomlError("only letter, numbers, dashes and underscores are allowed in keys", {
+            toml: ctx.s,
+            ptr: ctx.p
+          });
+        }
+        parsed.push(part.trimEnd());
+      }
+    }
+  } while (dot + 1 && dot < endPtr);
+  ctx.p = endPtr + 1;
+  skipVoid(ctx, true, true);
+  return parsed;
+}
+function parseInlineTable(ctx, integersAsBigInt) {
+  let res = {};
+  let seen = /* @__PURE__ */ new Set();
+  let c;
+  ctx.p++;
+  while (ctx.p < ctx.s.length) {
+    skipVoid(ctx);
+    if ((c = ctx.s.charCodeAt(ctx.p)) === 125) {
+      ctx.p++;
+      return res;
+    }
+    let k;
+    let t = res;
+    let hasOwn = false;
+    let p = ctx.p;
+    let key = parseKey(ctx);
+    for (let i = 0; i < key.length; i++) {
+      if (i)
+        t = hasOwn ? t[k] : t[k] = {};
+      k = key[i];
+      if ((hasOwn = Object.hasOwn(t, k)) && (typeof t[k] !== "object" || seen.has(t[k]))) {
+        throw new TomlError("trying to redefine an already defined value", {
+          toml: ctx.s,
+          ptr: p
+        });
+      }
+      if (!hasOwn && k === "__proto__") {
+        Object.defineProperty(t, k, { enumerable: true, configurable: true, writable: true });
+      }
+    }
+    if (hasOwn) {
+      throw new TomlError("trying to redefine an already defined value", {
+        toml: ctx.s,
+        ptr: ctx.p
+      });
+    }
+    let value = extractValue(ctx, 125, integersAsBigInt);
+    seen.add(t[k] = value);
+    skipVoid(ctx);
+    if ((c = ctx.s.charCodeAt(ctx.p++)) === 125) {
+      return res;
+    }
+    if (c !== 44) {
+      throw new TomlError("expected comma or end of structure", { toml: ctx.s, ptr: ctx.p - 1 });
+    }
+  }
+  throw new TomlError("unfinished table encountered", {
+    toml: ctx.s,
+    ptr: ctx.p
+  });
+}
+function parseArray(ctx, integersAsBigInt) {
+  let res = [];
+  let c;
+  ctx.p++;
+  while (ctx.p < ctx.s.length) {
+    skipVoid(ctx);
+    if ((c = ctx.s.charCodeAt(ctx.p)) === 93) {
+      ctx.p++;
+      return res;
+    }
+    res.push(extractValue(ctx, 93, integersAsBigInt));
+    skipVoid(ctx);
+    if ((c = ctx.s.charCodeAt(ctx.p++)) === 93) {
+      return res;
+    }
+    if (c !== 44) {
+      throw new TomlError("expected comma or end of structure", { toml: ctx.s, ptr: ctx.p - 1 });
+    }
+  }
+  throw new TomlError("unfinished array encountered", {
+    toml: ctx.s,
+    ptr: ctx.p
+  });
+}
+
+// node_modules/.pnpm/smol-toml@1.8.0/node_modules/smol-toml/dist/parse.js
+function peekTable(key, table, meta, type) {
+  let t = table;
+  let m = meta;
+  let k;
+  let hasOwn = false;
+  let state;
+  for (let i = 0; i < key.length; i++) {
+    if (i) {
+      t = hasOwn ? t[k] : t[k] = {};
+      m = (state = m[k]).c;
+      if (type === 0 && (state.t === 1 || state.t === 2)) {
+        return null;
+      }
+      if (state.t === 2) {
+        let l = t.length - 1;
+        t = t[l];
+        m = m[l].c;
+      }
+    }
+    k = key[i];
+    if ((hasOwn = Object.hasOwn(t, k)) && m[k]?.t === 0 && m[k]?.d) {
+      return null;
+    }
+    if (!hasOwn) {
+      if (k === "__proto__") {
+        Object.defineProperty(t, k, { enumerable: true, configurable: true, writable: true });
+        Object.defineProperty(m, k, { enumerable: true, configurable: true, writable: true });
+      }
+      m[k] = {
+        t: i < key.length - 1 && type === 2 ? 3 : type,
+        d: false,
+        i: 0,
+        c: {}
+      };
+    }
+  }
+  state = m[k];
+  if (state.t !== type && !(type === 1 && state.t === 3)) {
+    return null;
+  }
+  if (type === 2) {
+    if (!state.d) {
+      state.d = true;
+      t[k] = [];
+    }
+    t[k].push(t = {});
+    state.c[state.i++] = state = { t: 1, d: false, i: 0, c: {} };
+  }
+  if (state.d) {
+    return null;
+  }
+  state.d = true;
+  if (type === 1) {
+    t = hasOwn ? t[k] : t[k] = {};
+  } else if (type === 0 && hasOwn) {
+    return null;
+  }
+  return [k, t, state.c];
+}
+function parse(toml, { maxDepth = 1e3, integersAsBigInt } = {}) {
+  let ctx = { s: toml, p: 0, d: maxDepth };
+  let res = {};
+  let meta = {};
+  let tmp;
+  let tbl = res;
+  let m = meta;
+  skipVoid(ctx);
+  while (ctx.p < toml.length) {
+    if (toml.charCodeAt(ctx.p) === 91) {
+      let isTableArray = toml.charCodeAt(++ctx.p) === 91;
+      tmp = ctx.p += +isTableArray;
+      let k = parseKey(ctx, "]");
+      if (isTableArray) {
+        if (toml.charCodeAt(ctx.p - 1) !== 93) {
+          throw new TomlError("expected end of table declaration", {
+            toml,
+            ptr: ctx.p - 1
+          });
+        }
+        ctx.p++;
+      }
+      let p = peekTable(
+        k,
+        res,
+        meta,
+        isTableArray ? 2 : 1
+        /* Type.EXPLICIT */
+      );
+      if (!p) {
+        throw new TomlError("trying to redefine an already defined table or value", {
+          toml,
+          ptr: tmp
+        });
+      }
+      m = p[2];
+      tbl = p[1];
+    } else {
+      tmp = ctx.p;
+      let k = parseKey(ctx);
+      let p = peekTable(
+        k,
+        tbl,
+        m,
+        0
+        /* Type.DOTTED */
+      );
+      if (!p) {
+        throw new TomlError("trying to redefine an already defined table or value", {
+          toml,
+          ptr: tmp
+        });
+      }
+      p[1][p[0]] = extractValue(ctx, void 0, integersAsBigInt);
+    }
+    skipVoid(ctx, true);
+    if (ctx.p < toml.length && (tmp = toml.charCodeAt(ctx.p)) !== 10 && tmp !== 13) {
+      throw new TomlError("each key-value declaration must be followed by an end-of-line", {
+        toml,
+        ptr: ctx.p
+      });
+    }
+    skipVoid(ctx);
+  }
+  return res;
+}
+
+// packages/core/dist/config.js
+var POOL_NAME = /^[A-Za-z0-9_-]+$/;
+function parsePools(raw, repos) {
+  const out = {};
+  if (raw === void 0)
+    return out;
+  if (!raw || typeof raw !== "object" || Array.isArray(raw))
+    throw new Error(`[pools] must be a table of pools in ${configPath()}`);
+  for (const [name, p] of Object.entries(raw)) {
+    const where = `[pools.${name}] in ${configPath()}`;
+    if (!POOL_NAME.test(name))
+      throw new Error(`${where}: a pool name may use letters, digits, "-" and "_" only`);
+    const repo = String(p?.repo ?? "");
+    if (!repos[repo])
+      throw new Error(`${where}: repo "${repo}" is not a configured [repos.<key>]`);
+    const size = p.size ?? 1;
+    if (typeof size !== "number" || !Number.isInteger(size) || size < 1)
+      throw new Error(`${where}: size must be a positive integer`);
+    const overflow = p.overflow ?? "headless";
+    if (overflow !== "headless" && overflow !== "queue")
+      throw new Error(`${where}: overflow must be "headless" or "queue"`);
+    out[name] = { repo, size, overflow };
+  }
+  return out;
+}
+var BRIEF_KINDS = ["conflict", "checks", "review", "ciFix", "rebase"];
+function parseBriefHooks(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw))
+    return void 0;
+  const out = {};
+  for (const kind of [...BRIEF_KINDS, "all"]) {
+    const text2 = raw[kind];
+    if (typeof text2 === "string" && text2.trim())
+      out[kind] = text2.trim();
+  }
+  return Object.keys(out).length ? out : void 0;
+}
+var ATTENTION_KINDS = ["question", "decision", "landed", "pr:draft", "pr:review", "pr:checks", "pr:conflict", "pr:ready", "report", "stack-ready"];
+var DEFAULT_ATTENTION_KINDS = ["question", "decision", "pr:ready", "pr:review", "pr:conflict", "pr:checks"];
+function parseAttentionKinds(raw) {
+  if (raw === void 0)
+    return [...DEFAULT_ATTENTION_KINDS];
+  if (!Array.isArray(raw)) {
+    throw new Error(`attentionKinds must be an array of kinds (${ATTENTION_KINDS.join(", ")}) in ${configPath()}`);
+  }
+  for (const k of raw) {
+    if (!ATTENTION_KINDS.includes(k)) {
+      throw new Error(`attentionKinds: unknown kind "${String(k)}" in ${configPath()} \u2014 valid kinds: ${ATTENTION_KINDS.join(", ")}`);
+    }
+  }
+  return [...new Set(raw)];
+}
+function parseSoak(raw) {
+  const soak = { ...DEFAULT_SOAK, ...raw ?? {} };
+  if (soak.terminal !== void 0 && soak.terminal !== "terminal" && soak.terminal !== "iterm") {
+    throw new Error(`soak.terminal: unknown terminal "${String(soak.terminal)}" in ${configPath()} \u2014 use "terminal" or "iterm"`);
+  }
+  return soak;
+}
+var DEFAULT_SOAK = {
+  deferSecs: 90,
+  claimIdleNoticeSecs: 180,
+  ttlSecs: 1800,
+  beat: true,
+  pausedTtlSecs: 86400,
+  signOffGraceSecs: 600
+};
+var DEFAULT_HELM = {
+  ttlSecs: 1800,
+  reportSecs: 900,
+  armGraceSecs: 5
+};
+var DEFAULT_GLASS = { port: 4949 };
+var DEFAULT_WATCH = { maxForksPerCycle: 3, autoRepair: true, conflicts: true, checks: true, maxRepairsPerPr: 2, maxRepairsWithoutProgress: 2, repairSettleSecs: 600, repairCooldownSecs: 0, repairTrapWaitSecs: 600 };
 var DEFAULT_LIMITS = {
   maxConcurrent: 2,
   choreConcurrent: 1,
@@ -137,14 +864,82 @@ var DEFAULT_LIMITS = {
   reuseWorktree: true,
   releaseOnMerge: false
 };
+function configPath() {
+  return path3.join(lobstahHome(), "config.toml");
+}
+function expandHome(p) {
+  return p.startsWith("~/") ? path3.join(os2.homedir(), p.slice(2)) : p;
+}
+function loadConfig() {
+  const file = configPath();
+  const raw = fs4.existsSync(file) ? parse(fs4.readFileSync(file, "utf8")) : {};
+  const watch = { ...DEFAULT_WATCH, ...raw.watch ?? {} };
+  if (typeof watch.repairCooldownSecs !== "number" || !Number.isFinite(watch.repairCooldownSecs) || watch.repairCooldownSecs < 0) {
+    throw new Error(`[watch].repairCooldownSecs must be a non-negative number in ${configPath()}`);
+  }
+  const readySettleSecs = raw.readySettleSecs ?? 600;
+  if (typeof readySettleSecs !== "number" || !Number.isFinite(readySettleSecs) || readySettleSecs < 0) {
+    throw new Error(`readySettleSecs must be a non-negative number in ${configPath()}`);
+  }
+  const reposRaw = raw.repos ?? {};
+  const repos = {};
+  for (const [key, r] of Object.entries(reposRaw)) {
+    repos[key] = {
+      path: expandHome(String(r.path ?? "")),
+      origin: r.origin ? String(r.origin) : void 0,
+      trunk: String(r.trunk ?? "main"),
+      setup: Array.isArray(r.setup) ? r.setup.map(String) : void 0,
+      env: r.env ?? void 0,
+      harness: r.harness ?? void 0,
+      pickup: r.pickup === void 0 ? void 0 : Boolean(r.pickup),
+      scratch: Array.isArray(r.scratch) ? r.scratch.map(String) : void 0,
+      pushEarly: r.pushEarly === void 0 ? void 0 : Boolean(r.pushEarly),
+      draftPr: r.draftPr === void 0 ? void 0 : Boolean(r.draftPr),
+      checkpointOnStop: r.checkpointOnStop === void 0 ? void 0 : Boolean(r.checkpointOnStop),
+      humanGateChecks: Array.isArray(r.humanGateChecks) ? r.humanGateChecks.map(String).filter(Boolean) : void 0,
+      briefHooks: parseBriefHooks(r.briefHooks),
+      poolKeep: Array.isArray(r.poolKeep) ? r.poolKeep.map(String).filter(Boolean) : void 0
+    };
+  }
+  const groundsRaw = raw.grounds ?? {};
+  const grounds = {};
+  for (const [key, g] of Object.entries(groundsRaw)) {
+    grounds[key] = { repos: Array.isArray(g.repos) ? g.repos.map(String) : [] };
+  }
+  return {
+    repos,
+    harness: raw.harness ?? {},
+    limits: { ...DEFAULT_LIMITS, ...raw.limits ?? {} },
+    soak: parseSoak(raw.soak),
+    helm: { ...DEFAULT_HELM, ...raw.helm ?? {} },
+    glass: { ...DEFAULT_GLASS, ...raw.glass ?? {} },
+    watch,
+    grounds,
+    pools: parsePools(raw.pools, repos),
+    notifyCommand: raw.notifyCommand ? String(raw.notifyCommand) : void 0,
+    notifyVerbs: Array.isArray(raw.notifyVerbs) ? raw.notifyVerbs.map(String) : void 0,
+    remindSecs: raw.remindSecs !== void 0 ? Number(raw.remindSecs) : void 0,
+    readySettleSecs,
+    attentionKinds: parseAttentionKinds(raw.attentionKinds)
+  };
+}
 
 // packages/core/dist/pr.js
 var PR_VIEW_FIELDS = "title,state,isDraft,isCrossRepository,headRefOid,baseRefName,baseRefOid,headRefName,mergeStateStatus,reviewDecision,statusCheckRollup,mergedAt,closedAt,updatedAt,reviews";
 var PR_VIEW_FIELDS_NO_CHECKS = PR_VIEW_FIELDS.split(",").filter((f) => f !== "statusCheckRollup").join(",");
 
+// packages/core/dist/worktrees.js
+var WARM_LOCK_MAX_MS = 15 * 6e4;
+
 // packages/core/dist/disk.js
 var GB = 1024 ** 3;
 
+// packages/core/dist/pools.js
+var POOL_WARM_MAX_MS = 60 * 6e4;
+var POOL_RETRY_MS = 10 * 6e4;
+var POOL_FETCH_MS = 10 * 6e4;
+var POOL_RECHECK_MS = 5 * 6e4;
+
 // packages/core/dist/decisions.js
 var DECISION_DETAIL_MAX = 64 * 1024;
 var ANSWER_TYPES = {
@@ -169,35 +964,35 @@ var ANSWER_TYPES = {
 var ANSWER_EXTENSIONS = Object.keys(ANSWER_TYPES);
 
 // packages/core/dist/inbox.js
-import * as fs4 from "node:fs";
-import * as path3 from "node:path";
+import * as fs5 from "node:fs";
+import * as path4 from "node:path";
 var metaName = (file) => file.replace(/\.msg$/, ".meta.json");
 function inboxDir(id, lane) {
-  return path3.join(laneDirs(lane).inbox, id);
+  return path4.join(laneDirs(lane).inbox, id);
 }
 function sendMessage(id, lane, text2, from, attachments = []) {
   const dir = inboxDir(id, lane);
-  fs4.mkdirSync(path3.join(dir, "handled"), { recursive: true });
-  const existing = fs4.readdirSync(dir).filter((f) => f.endsWith(".msg")).length;
-  const handled = fs4.readdirSync(path3.join(dir, "handled")).filter((f) => f.endsWith(".msg")).length;
+  fs5.mkdirSync(path4.join(dir, "handled"), { recursive: true });
+  const existing = fs5.readdirSync(dir).filter((f) => f.endsWith(".msg")).length;
+  const handled = fs5.readdirSync(path4.join(dir, "handled")).filter((f) => f.endsWith(".msg")).length;
   const name = `${String(existing + handled + 1).padStart(3, "0")}.msg`;
-  const tmp = path3.join(dir, `.tmp-${process.pid}-${Date.now()}`);
+  const tmp = uniqueTempPath(path4.join(dir, name));
   if (from !== void 0 || attachments.length > 0) {
     const meta = { from: from ?? "unknown", at: (/* @__PURE__ */ new Date()).toISOString(), ...attachments.length ? { attachments } : {} };
     const metaTmp = `${tmp}.meta`;
-    fs4.writeFileSync(metaTmp, JSON.stringify(meta, null, 2));
-    fs4.renameSync(metaTmp, path3.join(dir, metaName(name)));
+    fs5.writeFileSync(metaTmp, JSON.stringify(meta, null, 2));
+    fs5.renameSync(metaTmp, path4.join(dir, metaName(name)));
   }
-  fs4.writeFileSync(tmp, text2);
-  fs4.renameSync(tmp, path3.join(dir, name));
+  fs5.writeFileSync(tmp, text2);
+  fs5.renameSync(tmp, path4.join(dir, name));
   return name;
 }
 
 // packages/core/dist/events.js
-import * as fs5 from "node:fs";
+import * as fs6 from "node:fs";
 function lastEventAt(id, lane) {
   try {
-    return fs5.statSync(eventsPath(id, lane)).mtimeMs;
+    return fs6.statSync(eventsPath(id, lane)).mtimeMs;
   } catch {
     return void 0;
   }
@@ -233,7 +1028,7 @@ function text(payload, details = {}) {
 function findLane(id) {
   for (const lane of ["work", "chore"]) {
     const d = laneDirs(lane);
-    if (fs6.existsSync(path4.join(d.active, id)) || fs6.existsSync(path4.join(d.queue, `${id}.json`)) || fs6.existsSync(path4.join(d.done, id)) || fs6.existsSync(path4.join(d.state, `${id}.status`))) {
+    if (fs7.existsSync(path5.join(d.active, id)) || fs7.existsSync(path5.join(d.queue, `${id}.json`)) || fs7.existsSync(path5.join(d.done, id)) || fs7.existsSync(path5.join(d.state, `${id}.status`))) {
       return lane;
     }
   }
@@ -259,29 +1054,40 @@ function dispatchTool() {
         harness: { type: "string", enum: ["claude", "codex"] },
         model: { type: "string" },
         effort: { type: "string" },
-        followUp: { type: "string", description: "Earlier dispatch UUID whose session to fork" }
+        followUp: { type: "string", description: "Earlier dispatch UUID whose session to fork" },
+        pool: {
+          type: "string",
+          description: "Worktree pool from the host config ([pools.<name>]): run in a warm pool worktree with a fresh session. repo defaults to the pool's repo."
+        }
       },
-      required: ["repo", "brief"],
+      required: ["brief"],
       additionalProperties: false
     },
     async execute(_id, params) {
       ensureLayout();
-      const repo = param(params, "repo");
+      const poolName = param(params, "pool");
+      const pool = poolName !== void 0 ? loadConfig().pools[poolName] : void 0;
+      if (poolName !== void 0 && !pool) throw new Error(`lobstah_dispatch: unknown pool "${poolName}"`);
+      if (pool && param(params, "repo") !== void 0 && param(params, "repo") !== pool.repo) {
+        throw new Error(`lobstah_dispatch: pool ${poolName} serves repo ${pool.repo}, not ${param(params, "repo")}`);
+      }
+      const repo = param(params, "repo") ?? pool?.repo;
       const brief = param(params, "brief");
-      if (!repo || !brief) throw new Error("lobstah_dispatch requires repo and brief");
+      if (!repo || !brief) throw new Error("lobstah_dispatch requires brief, and repo or pool");
       const d = {
-        id: randomUUID(),
+        id: randomUUID2(),
         repo,
         brief,
         harness: param(params, "harness"),
         model: param(params, "model"),
         effort: param(params, "effort"),
-        followUp: param(params, "followUp")
+        followUp: param(params, "followUp"),
+        ...poolName !== void 0 ? { pool: poolName } : {}
       };
       if (d.harness) d.harnessExplicit = true;
       if (d.model) d.modelExplicit = true;
       enqueue(d, "work");
-      return text(toonKV({ id: d.id, repo, queued: (/* @__PURE__ */ new Date()).toISOString() }), { id: d.id });
+      return text(toonKV({ id: d.id, repo, ...d.pool ? { pool: d.pool } : {}, queued: (/* @__PURE__ */ new Date()).toISOString() }), { id: d.id });
     }
   };
 }
@@ -305,7 +1111,7 @@ function statusTool() {
         return text(toonKV({ id, lane, state, lastNote: log.at(-1)?.note }), { id, state });
       }
       const rows = ["work", "chore"].flatMap(
-        (lane) => fs6.readdirSync(laneDirs(lane).active).filter((f) => !f.startsWith(".")).map((did) => ({ id: did, lane, state: stateOf(did, lane) }))
+        (lane) => fs7.readdirSync(laneDirs(lane).active).filter((f) => !f.startsWith(".")).map((did) => ({ id: did, lane, state: stateOf(did, lane) }))
       );
       return text(toonTable("active", rows, ["id", "lane", "state"]), { count: rows.length });
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lobstah-openclaw-plugin",
-  "version": "0.7.2",
+  "version": "0.7.4",
   "description": "OpenClaw plugin for lobstah: gives fleet agents dispatch/status/send/cancel tools and operators a /lobstah command.",
   "license": "MIT",
   "author": "aequitas labs LLC",