lobstah 0.1.0

package/dist/runner.js

@@ -0,0 +1,1319 @@
+// packages/runner/src/index.ts
+import * as fs9 from "node:fs";
+import * as path7 from "node:path";
+import { fileURLToPath } from "node:url";
+
+// packages/core/dist/types.js
+var VERBS = ["working", "needs-decision", "blocked", "paused", "done", "failed"];
+var TERMINAL_VERBS = ["done", "failed"];
+
+// packages/core/dist/paths.js
+import * as os from "node:os";
+import * as path from "node:path";
+function lobstahHome() {
+  return process.env.LOBSTAH_HOME ?? path.join(os.homedir(), ".lobstah");
+}
+function laneRoot(lane) {
+  return lane === "work" ? lobstahHome() : path.join(lobstahHome(), "chores");
+}
+function laneDirs(lane) {
+  const root = laneRoot(lane);
+  return {
+    queue: path.join(root, "queue"),
+    active: path.join(root, "active"),
+    done: path.join(root, "done"),
+    state: path.join(root, "state"),
+    inbox: path.join(root, "inbox")
+  };
+}
+function statusPath(id, lane) {
+  return path.join(laneDirs(lane).state, `${id}.status`);
+}
+function eventsPath(id, lane) {
+  return path.join(laneDirs(lane).state, `${id}.events`);
+}
+function evidencePath(id, lane) {
+  return path.join(laneDirs(lane).state, `${id}.evidence`);
+}
+
+// packages/core/dist/queue.js
+import * as fs from "node:fs";
+import * as path2 from "node:path";
+function complete(id, lane) {
+  const dirs = laneDirs(lane);
+  fs.renameSync(path2.join(dirs.active, id), path2.join(dirs.done, id));
+}
+function cancelRequested(id, lane) {
+  return fs.existsSync(path2.join(laneDirs(lane).active, id, "cancel"));
+}
+
+// packages/core/dist/status.js
+import * as fs2 from "node:fs";
+function isVerb(v) {
+  return VERBS.includes(v);
+}
+function appendStatus(id, lane, verb, note) {
+  if (!isVerb(verb)) {
+    throw new Error(`invalid status verb "${verb}" \u2014 must be one of: ${VERBS.join(", ")}`);
+  }
+  const entry = { at: (/* @__PURE__ */ new Date()).toISOString(), verb, ...note ? { note } : {} };
+  fs2.appendFileSync(statusPath(id, lane), `${JSON.stringify(entry)}
+`);
+  return entry;
+}
+function readStatusLog(id, lane) {
+  const file = statusPath(id, lane);
+  if (!fs2.existsSync(file))
+    return [];
+  return fs2.readFileSync(file, "utf8").split("\n").filter(Boolean).flatMap((line) => {
+    try {
+      const parsed = JSON.parse(line);
+      return isVerb(parsed.verb) ? [parsed] : [];
+    } catch {
+      return [];
+    }
+  });
+}
+
+// packages/core/dist/events.js
+import * as fs3 from "node:fs";
+function appendEvent(id, lane, ev) {
+  fs3.appendFileSync(eventsPath(id, lane), `${JSON.stringify(ev)}
+`);
+}
+
+// packages/core/dist/evidence.js
+import * as fs4 from "node:fs";
+function readEvidence(id, lane) {
+  try {
+    return JSON.parse(fs4.readFileSync(evidencePath(id, lane), "utf8"));
+  } catch {
+    return {};
+  }
+}
+function mergeEvidence(id, lane, patch) {
+  const file = evidencePath(id, lane);
+  const tmp = `${file}.tmp-${process.pid}`;
+  fs4.writeFileSync(tmp, JSON.stringify({ ...readEvidence(id, lane), ...patch }, null, 2));
+  fs4.renameSync(tmp, file);
+}
+
+// packages/core/dist/inbox.js
+import * as fs5 from "node:fs";
+import * as path3 from "node:path";
+function inboxDir(id, lane) {
+  return path3.join(laneDirs(lane).inbox, id);
+}
+function unhandled(id, lane) {
+  const dir = inboxDir(id, lane);
+  if (!fs5.existsSync(dir))
+    return [];
+  return fs5.readdirSync(dir).filter((f) => f.endsWith(".msg")).sort().map((f) => ({ file: f, text: fs5.readFileSync(path3.join(dir, f), "utf8") }));
+}
+function acknowledge(id, lane, file) {
+  const dir = inboxDir(id, lane);
+  fs5.mkdirSync(path3.join(dir, "handled"), { recursive: true });
+  fs5.renameSync(path3.join(dir, file), path3.join(dir, "handled", file));
+}
+
+// packages/core/dist/config.js
+import * as fs6 from "node:fs";
+import * as os2 from "node:os";
+import * as path4 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 DEFAULT_LIMITS = {
+  maxConcurrent: 2,
+  choreConcurrent: 1,
+  wedgeThresholdSecs: 600,
+  maxRestartAttempts: 2,
+  wallClockSecs: 3600,
+  choreRetentionDays: 7
+};
+function configPath() {
+  return path4.join(lobstahHome(), "config.toml");
+}
+function expandHome(p) {
+  return p.startsWith("~/") ? path4.join(os2.homedir(), p.slice(2)) : p;
+}
+function loadConfig() {
+  const file = configPath();
+  const raw = fs6.existsSync(file) ? parse(fs6.readFileSync(file, "utf8")) : {};
+  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
+    };
+  }
+  return {
+    repos,
+    harness: raw.harness ?? {},
+    limits: { ...DEFAULT_LIMITS, ...raw.limits ?? {} },
+    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
+  };
+}
+function resolveDispatch(d, cfg) {
+  const repo = cfg.repos[d.repo];
+  if (!repo)
+    throw new Error(`unknown repo key "${d.repo}" \u2014 add it to ${configPath()}`);
+  const rh = repo.harness ?? {};
+  const gh = cfg.harness;
+  return {
+    harness: d.harness ?? rh.default ?? gh.default ?? "claude",
+    model: d.model ?? rh.model ?? gh.model,
+    effort: d.effort ?? rh.effort ?? gh.effort,
+    limits: {
+      wallClockSecs: cfg.limits.wallClockSecs,
+      ...d.limits ?? {}
+    },
+    env: { ...repo.env ?? {}, ...d.env ?? {} },
+    flags: d.flags ?? []
+  };
+}
+
+// packages/adapters/dist/types.js
+var AsyncQueue = class {
+  buffer = [];
+  waiters = [];
+  closed = false;
+  push(item) {
+    if (this.closed)
+      return;
+    const w = this.waiters.shift();
+    if (w)
+      w({ value: item, done: false });
+    else
+      this.buffer.push(item);
+  }
+  close() {
+    this.closed = true;
+    for (const w of this.waiters.splice(0))
+      w({ value: void 0, done: true });
+  }
+  [Symbol.asyncIterator]() {
+    return {
+      next: () => {
+        const item = this.buffer.shift();
+        if (item !== void 0)
+          return Promise.resolve({ value: item, done: false });
+        if (this.closed)
+          return Promise.resolve({ value: void 0, done: true });
+        return new Promise((resolve2) => this.waiters.push(resolve2));
+      }
+    };
+  }
+};
+var InputGate = class {
+  queue = [];
+  waiter = null;
+  ended = false;
+  send(text) {
+    this.queue.push(text);
+    this.waiter?.();
+  }
+  end() {
+    this.ended = true;
+    this.waiter?.();
+  }
+  /** Resolves with the next message, or undefined once ended and drained. */
+  async next() {
+    while (true) {
+      const msg = this.queue.shift();
+      if (msg !== void 0)
+        return msg;
+      if (this.ended)
+        return void 0;
+      await new Promise((resolve2) => this.waiter = resolve2);
+      this.waiter = null;
+    }
+  }
+};
+function now() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+
+// packages/adapters/dist/claude.js
+function flagsToExtraArgs(flags) {
+  const extra = {};
+  for (let i = 0; i < flags.length; i++) {
+    const f = flags[i];
+    if (!f?.startsWith("--"))
+      continue;
+    const next = flags[i + 1];
+    if (next !== void 0 && !next.startsWith("--")) {
+      extra[f.slice(2)] = next;
+      i++;
+    } else {
+      extra[f.slice(2)] = null;
+    }
+  }
+  return extra;
+}
+function createClaudeAdapter() {
+  return {
+    name: "claude",
+    async start(opts) {
+      const sdk = await import("@anthropic-ai/claude-agent-sdk");
+      const input = new InputGate();
+      async function* userMessages() {
+        yield {
+          type: "user",
+          message: { role: "user", content: opts.prompt },
+          parent_tool_use_id: null,
+          session_id: ""
+        };
+        while (true) {
+          const text = await input.next();
+          if (text === void 0)
+            return;
+          yield {
+            type: "user",
+            message: { role: "user", content: text },
+            parent_tool_use_id: null,
+            session_id: ""
+          };
+        }
+      }
+      const q = sdk.query({
+        prompt: userMessages(),
+        options: {
+          cwd: opts.cwd,
+          model: opts.model,
+          maxTurns: opts.limits.maxTurns,
+          resume: opts.resumeSession,
+          forkSession: opts.resumeSession ? true : void 0,
+          permissionMode: "bypassPermissions",
+          env: { ...process.env, ...opts.env },
+          extraArgs: flagsToExtraArgs(opts.flags)
+        }
+      });
+      const events = new AsyncQueue();
+      let sessionId;
+      const done = (async () => {
+        try {
+          for await (const msg of q) {
+            const at = now();
+            if (msg.type === "system" && msg.subtype === "init") {
+              sessionId = msg.session_id;
+              events.push({ at, type: "session", data: { sessionId } });
+            } else if (msg.type === "assistant") {
+              for (const block of msg.message?.content ?? []) {
+                if (block.type === "tool_use") {
+                  events.push({ at, type: "tool-start", data: { name: block.name } });
+                } else if (block.type === "text" && block.text) {
+                  events.push({ at, type: "text", data: { text: String(block.text).slice(0, 2e3) } });
+                }
+              }
+            } else if (msg.type === "user") {
+              const content = msg.message?.content;
+              if (Array.isArray(content)) {
+                for (const block of content) {
+                  if (block.type === "tool_result")
+                    events.push({ at, type: "tool-end", data: {} });
+                }
+              }
+            } else if (msg.type === "result") {
+              events.push({ at, type: "turn-end", data: { subtype: msg.subtype, costUsd: msg.total_cost_usd } });
+            }
+          }
+          return { sessionId };
+        } catch (err) {
+          const message = err instanceof Error ? err.message : String(err);
+          events.push({ at: now(), type: "error", data: { message } });
+          return { sessionId, error: message };
+        } finally {
+          events.close();
+        }
+      })();
+      return {
+        events,
+        send: (text) => input.send(text),
+        end: () => input.end(),
+        done,
+        kill: () => {
+          try {
+            q.interrupt?.();
+          } catch {
+          }
+          input.end();
+        }
+      };
+    }
+  };
+}
+
+// packages/adapters/dist/codex.js
+import * as fs7 from "node:fs";
+import * as os3 from "node:os";
+import * as path5 from "node:path";
+function isolatedCodexHome() {
+  const dir = path5.join(lobstahHome(), "codex-home");
+  fs7.mkdirSync(dir, { recursive: true });
+  const auth = path5.join(dir, "auth.json");
+  const realAuth = path5.join(os3.homedir(), ".codex", "auth.json");
+  if (!fs7.existsSync(auth) && fs7.existsSync(realAuth)) {
+    try {
+      fs7.symlinkSync(realAuth, auth);
+    } catch {
+      fs7.copyFileSync(realAuth, auth);
+    }
+  }
+  const cfg = path5.join(dir, "config.toml");
+  if (!fs7.existsSync(cfg)) {
+    fs7.writeFileSync(cfg, "# lobstah-managed: auth inherited from ~/.codex, interactive config not\n");
+  }
+  return dir;
+}
+function createCodexAdapter() {
+  return {
+    name: "codex",
+    async start(opts) {
+      const mod = await import("@openai/codex-sdk");
+      const codex = new mod.Codex({
+        env: { ...process.env, ...opts.env, CODEX_HOME: isolatedCodexHome() }
+      });
+      const threadOptions = {
+        workingDirectory: opts.cwd,
+        skipGitRepoCheck: true,
+        sandboxMode: "workspace-write",
+        approvalPolicy: "never",
+        ...opts.model ? { model: opts.model } : {},
+        ...opts.effort ? { modelReasoningEffort: opts.effort } : {}
+      };
+      const thread = opts.resumeSession ? codex.resumeThread(opts.resumeSession, threadOptions) : codex.startThread(threadOptions);
+      const input = new InputGate();
+      const events = new AsyncQueue();
+      let sessionId;
+      let lastTurnError;
+      const done = (async () => {
+        try {
+          let next = opts.prompt;
+          while (next !== void 0) {
+            const streamed = await thread.runStreamed(next);
+            for await (const ev of streamed.events) {
+              const at = now();
+              if (ev.type === "thread.started") {
+                sessionId = ev.thread_id;
+                events.push({ at, type: "session", data: { sessionId } });
+              } else if (ev.type === "turn.started") {
+                events.push({ at, type: "turn-start", data: {} });
+              } else if (ev.type === "item.started") {
+                events.push({ at, type: "tool-start", data: { name: ev.item?.type } });
+              } else if (ev.type === "item.completed") {
+                if (ev.item?.type === "agent_message" && ev.item?.text) {
+                  events.push({ at, type: "text", data: { text: String(ev.item.text).slice(0, 2e3) } });
+                } else {
+                  events.push({ at, type: "tool-end", data: { name: ev.item?.type } });
+                }
+              } else if (ev.type === "turn.failed") {
+                lastTurnError = ev.error?.message ?? "turn failed";
+                events.push({ at, type: "error", data: { message: lastTurnError } });
+              }
+            }
+            events.push({ at: now(), type: "turn-end", data: {} });
+            next = await input.next();
+          }
+          return { sessionId };
+        } catch (err) {
+          const message = lastTurnError ?? (err instanceof Error ? err.message : String(err));
+          events.push({ at: now(), type: "error", data: { message } });
+          return { sessionId, error: message };
+        } finally {
+          events.close();
+        }
+      })();
+      return {
+        events,
+        send: (text) => input.send(text),
+        end: () => input.end(),
+        done,
+        kill: () => input.end()
+      };
+    }
+  };
+}
+
+// packages/adapters/dist/index.js
+function loadAdapter(name) {
+  switch (name) {
+    case "claude":
+      return createClaudeAdapter();
+    case "codex":
+      return createCodexAdapter();
+    default:
+      throw new Error(`unknown harness "${name}" \u2014 known: claude, codex`);
+  }
+}
+
+// packages/worktree/dist/index.js
+import * as fs8 from "node:fs";
+import * as path6 from "node:path";
+import { exec, execFile } from "node:child_process";
+import { promisify } from "node:util";
+var run = promisify(execFile);
+var shell = promisify(exec);
+function worktreePath(id) {
+  return path6.join(lobstahHome(), "worktrees", id);
+}
+async function git(cwd, ...args) {
+  const { stdout } = await run("git", args, { cwd, env: process.env });
+  return stdout.trim();
+}
+async function allocate(repo, id) {
+  const dir = worktreePath(id);
+  if (fs8.existsSync(dir)) {
+    throw new Error(`worktree for ${id} already exists at ${dir} \u2014 never allocate a second`);
+  }
+  if (!fs8.existsSync(repo.path)) {
+    if (!repo.origin)
+      throw new Error(`repo path ${repo.path} missing and no origin configured`);
+    await run("git", ["clone", repo.origin, repo.path], { env: process.env });
+  }
+  await git(repo.path, "fetch", "origin", repo.trunk);
+  await git(repo.path, "worktree", "add", dir, "-b", `lobstah/${id}`, `origin/${repo.trunk}`);
+  for (const cmd of repo.setup ?? []) {
+    await shell(cmd, { cwd: dir, env: { ...process.env, ...repo.env ?? {} } });
+  }
+  return dir;
+}
+async function collectEvidence(repo, id) {
+  const dir = worktreePath(id);
+  const branch = await git(dir, "rev-parse", "--abbrev-ref", "HEAD");
+  const log = await git(dir, "log", "--oneline", `origin/${repo.trunk}..HEAD`);
+  return { branch, commits: log ? log.split("\n") : [] };
+}
+
+// packages/runner/src/contract.ts
+function buildPrompt(brief, opts) {
+  const reporting = `Report status by running \`lobstah report ${opts.id} <verb> [note]\` (verbs: ${VERBS.join(", ")}). Attach a PR URL to your final report with \`--pr <url>\`. At natural checkpoints, check for operator messages with \`lobstah inbox ${opts.id}\` \u2014 messages also arrive automatically between your turns.`;
+  const parts = [
+    `You are a dispatched coding agent supervised by lobstah. Dispatch id: ${opts.id}.`,
+    `Work only inside the current directory \u2014 it is an isolated git worktree allocated for this dispatch.`,
+    reporting,
+    `Use \`needs-decision\` when you are blocked on a question only a human can answer, then stop. New operator messages may arrive between your turns as user messages; treat them as instructions from the dispatcher.`,
+    `Commit your work with clear messages. Do not merge anything.`,
+    `--- BRIEF ---`,
+    brief
+  ];
+  if (opts.nudge) parts.push(`--- SUPERVISOR NOTE ---`, opts.nudge);
+  return parts.join("\n\n");
+}
+
+// packages/runner/src/index.ts
+function followUpSession(followUp) {
+  for (const lane of ["work", "chore"]) {
+    const ev = readEvidence(followUp, lane);
+    if (ev.sessionId) return ev.sessionId;
+  }
+  return void 0;
+}
+async function main(activeDir, lane) {
+  const id = path7.basename(activeDir);
+  const status = (verb, note) => appendStatus(id, lane, verb, note);
+  const cfg = loadConfig();
+  const descriptor = JSON.parse(fs9.readFileSync(path7.join(activeDir, "descriptor.json"), "utf8"));
+  const resolved = resolveDispatch(descriptor, cfg);
+  const repo = cfg.repos[descriptor.repo];
+  const briefFile = path7.join(activeDir, "brief.md");
+  if (!fs9.existsSync(briefFile)) fs9.writeFileSync(briefFile, descriptor.brief);
+  const brief = fs9.readFileSync(briefFile, "utf8");
+  const attempts = Number(process.env.LOBSTAH_ATTEMPTS ?? "1");
+  const runnerInfo = {
+    pid: process.pid,
+    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    attempts
+  };
+  fs9.writeFileSync(path7.join(activeDir, "runner.json"), JSON.stringify(runnerInfo, null, 2));
+  status("working", attempts > 1 ? `attempt ${attempts}` : void 0);
+  appendEvent(id, lane, { at: (/* @__PURE__ */ new Date()).toISOString(), type: "runner", data: { pid: process.pid, attempts } });
+  const wtFile = path7.join(activeDir, "worktree.json");
+  let cwd;
+  if (fs9.existsSync(wtFile)) {
+    cwd = JSON.parse(fs9.readFileSync(wtFile, "utf8")).path;
+    if (!fs9.existsSync(cwd)) throw new Error(`recorded worktree ${cwd} is gone`);
+  } else if (fs9.existsSync(worktreePath(id))) {
+    throw new Error(`unrecorded worktree already exists for ${id} \u2014 refusing to proceed`);
+  } else {
+    cwd = await allocate(repo, id);
+    fs9.writeFileSync(wtFile, JSON.stringify({ path: cwd }, null, 2));
+  }
+  const resumeSession = process.env.LOBSTAH_RESUME ?? (descriptor.followUp ? followUpSession(descriptor.followUp) : void 0);
+  const adapter = loadAdapter(resolved.harness);
+  const prompt = buildPrompt(brief, { id, nudge: process.env.LOBSTAH_NUDGE });
+  const binDir = path7.resolve(path7.dirname(fileURLToPath(import.meta.url)), "..", "..", "..", "bin");
+  const workerPath = fs9.existsSync(path7.join(binDir, "lobstah")) ? `${binDir}${path7.delimiter}${process.env.PATH ?? ""}` : void 0;
+  const run2 = await adapter.start({
+    id,
+    cwd,
+    prompt,
+    model: resolved.model,
+    effort: resolved.effort,
+    limits: resolved.limits,
+    env: {
+      ...resolved.env,
+      LOBSTAH_HOME: lobstahHome(),
+      ...workerPath ? { PATH: workerPath } : {}
+    },
+    flags: resolved.flags,
+    resumeSession
+  });
+  let wallClockHit = false;
+  const wallTimer = resolved.limits.wallClockSecs ? setTimeout(() => {
+    wallClockHit = true;
+    run2.kill();
+  }, resolved.limits.wallClockSecs * 1e3) : void 0;
+  let cancelled = false;
+  for await (const ev of run2.events) {
+    appendEvent(id, lane, ev);
+    if (ev.type === "session" && ev.data?.sessionId) {
+      mergeEvidence(id, lane, { sessionId: String(ev.data.sessionId) });
+    }
+    if (ev.type === "turn-end") {
+      if (cancelRequested(id, lane)) {
+        cancelled = true;
+        run2.kill();
+        continue;
+      }
+      const msgs = unhandled(id, lane);
+      if (msgs.length > 0) {
+        for (const m of msgs) {
+          run2.send(m.text);
+          acknowledge(id, lane, m.file);
+        }
+      } else {
+        run2.end();
+      }
+    }
+  }
+  const result = await run2.done;
+  if (wallTimer) clearTimeout(wallTimer);
+  try {
+    const gitEvidence = await collectEvidence(repo, id);
+    console.log(`[runner] git evidence: ${JSON.stringify(gitEvidence)}`);
+    mergeEvidence(id, lane, { ...gitEvidence, sessionId: result.sessionId ?? readEvidence(id, lane).sessionId });
+    console.log(`[runner] evidence after merge: ${JSON.stringify(readEvidence(id, lane))}`);
+  } catch (err) {
+    mergeEvidence(id, lane, {
+      note: `evidence collection failed: ${err instanceof Error ? err.message : String(err)}`.slice(0, 300)
+    });
+  }
+  const lastVerb = readStatusLog(id, lane).at(-1)?.verb;
+  if (cancelled) {
+    status("failed", "cancelled by operator");
+  } else if (wallClockHit) {
+    status("failed", "wall-clock limit exceeded");
+  } else if (result.error) {
+    status("failed", result.error.slice(0, 500));
+  } else if (!lastVerb || !TERMINAL_VERBS.includes(lastVerb)) {
+    status("done");
+  }
+  complete(id, lane);
+}
+var [activeDirArg, laneArg] = process.argv.slice(2);
+if (activeDirArg) {
+  const lane = laneArg === "chore" ? "chore" : "work";
+  main(activeDirArg, lane).catch((err) => {
+    const id = path7.basename(activeDirArg);
+    try {
+      appendStatus(id, lane, "failed", String(err instanceof Error ? err.message : err).slice(0, 500));
+      fs9.renameSync(activeDirArg, path7.join(laneDirs(lane).done, id));
+    } catch {
+    }
+    process.exitCode = 1;
+  });
+}
+export {
+  main
+};
+/*! Bundled license information:
+
+smol-toml/dist/date.js:
+smol-toml/dist/error.js:
+smol-toml/dist/util.js:
+smol-toml/dist/primitive.js:
+smol-toml/dist/extract.js:
+smol-toml/dist/struct.js:
+smol-toml/dist/parse.js:
+smol-toml/dist/stringify.js:
+smol-toml/dist/index.js:
+  (*!
+   * Copyright (c) Squirrel Chat et al., All rights reserved.
+   * SPDX-License-Identifier: BSD-3-Clause
+   *
+   * Redistribution and use in source and binary forms, with or without
+   * modification, are permitted provided that the following conditions are met:
+   *
+   * 1. Redistributions of source code must retain the above copyright notice, this
+   *    list of conditions and the following disclaimer.
+   * 2. Redistributions in binary form must reproduce the above copyright notice,
+   *    this list of conditions and the following disclaimer in the
+   *    documentation and/or other materials provided with the distribution.
+   * 3. Neither the name of the copyright holder nor the names of its contributors
+   *    may be used to endorse or promote products derived from this software without
+   *    specific prior written permission.
+   *
+   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+   * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+   * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+   * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+   * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+   * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+   * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+   * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+   * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+   *)
+*/