@scribed/cli 0.1.15 → 0.1.16

package/dist/index.js

@@ -47519,6 +47519,831 @@ var require_content_type = __commonJS((exports) => {
   }
 });
 
+// ../packages/agent-integrations/vendor/smol-toml.cjs
+var require_smol_toml = __commonJS((exports) => {
+  /*!
+  * 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.
+  */
+  Object.defineProperties(exports, {
+    __esModule: { value: true },
+    [Symbol.toStringTag]: { value: "Module" }
+  });
+  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 TomlDate2 extends Date {
+    #hasDate = false;
+    #hasTime = false;
+    #offset = null;
+    constructor(date8) {
+      let hasDate = true;
+      let hasTime = true;
+      let offset = "Z";
+      if (typeof date8 === "string") {
+        let match = date8.match(DATE_TIME_RE);
+        if (match) {
+          if (!match[1]) {
+            hasDate = false;
+            date8 = `0000-01-01T${date8}`;
+          }
+          hasTime = !!match[2];
+          hasTime && date8[10] === " " && (date8 = date8.replace(" ", "T"));
+          if (match[2] && +match[2] > 23)
+            date8 = "";
+          else {
+            offset = match[3] || null;
+            date8 = date8.toUpperCase();
+            if (!offset && hasTime)
+              date8 += "Z";
+          }
+        } else
+          date8 = "";
+      }
+      super(date8);
+      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;
+      return (/* @__PURE__ */ new Date(this.getTime() - offset * 60000)).toISOString().slice(0, -1) + this.#offset;
+    }
+    static wrapAsOffsetDateTime(jsDate, offset = "Z") {
+      let date8 = new TomlDate2(jsDate);
+      date8.#offset = offset;
+      return date8;
+    }
+    static wrapAsLocalDateTime(jsDate) {
+      let date8 = new TomlDate2(jsDate);
+      date8.#offset = null;
+      return date8;
+    }
+    static wrapAsLocalDate(jsDate) {
+      let date8 = new TomlDate2(jsDate);
+      date8.#hasTime = false;
+      date8.#offset = null;
+      return date8;
+    }
+    static wrapAsLocalTime(jsDate) {
+      let date8 = new TomlDate2(jsDate);
+      date8.#hasDate = false;
+      date8.#offset = null;
+      return date8;
+    }
+  };
+  function getLineColFromPtr(string5, ptr) {
+    let lines = string5.slice(0, ptr).split(/\r\n|\n|\r/g);
+    return [lines.length, lines.pop().length + 1];
+  }
+  function makeCodeBlock(string5, line, column) {
+    let lines = string5.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 l2 = lines[i - 1];
+      if (!l2)
+        continue;
+      codeblock += i.toString().padEnd(numberLen, " ");
+      codeblock += ":  ";
+      codeblock += l2;
+      codeblock += `
+`;
+      if (i === line) {
+        codeblock += " ".repeat(numberLen + column + 2);
+        codeblock += `^
+`;
+      }
+    }
+    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;
+    }
+  };
+  function indexOfNewline(str, start = 0) {
+    let idx = str.indexOf(`
+`, 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 (true) {
+      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
+    });
+  }
+  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 hex3 = ctx.s.charCodeAt(ctx.p + 1);
+            let digit = hex3 >= 48 && hex3 <= 57 ? hex3 - 48 : hex3 >= 65 && hex3 <= 70 ? hex3 - 65 + 10 : hex3 >= 97 && hex3 <= 102 ? hex3 - 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 += "\t";
+          else if (c === 110)
+            parsed += `
+`;
+          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 date8 = new TomlDate(value);
+    if (!date8.isValid())
+      throw new TomlError("invalid value", err);
+    return date8;
+  }
+  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);
+  }
+  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
+    });
+  }
+  function peekTable(key, table, meta3, type) {
+    let t = table;
+    let m = meta3;
+    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 l2 = t.length - 1;
+          t = t[l2];
+          m = m[l2].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 parse6(toml, { maxDepth = 1000, integersAsBigInt } = {}) {
+    let ctx = {
+      s: toml,
+      p: 0,
+      d: maxDepth
+    };
+    let res = {};
+    let meta3 = {};
+    let tmp;
+    let tbl = res;
+    let m = meta3;
+    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, meta3, isTableArray ? 2 : 1);
+        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 p = peekTable(parseKey(ctx), tbl, m, 0);
+        if (!p)
+          throw new TomlError("trying to redefine an already defined table or value", {
+            toml,
+            ptr: tmp
+          });
+        p[1][p[0]] = extractValue(ctx, undefined, 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;
+  }
+  var BARE_KEY = /^[a-z0-9-_]+$/i;
+  function extendedTypeOf(obj) {
+    let type = typeof obj;
+    if (type === "object") {
+      if (Array.isArray(obj))
+        return "array";
+      if (typeof obj?.getUTCDate === "function" && obj instanceof Date)
+        return "date";
+      if (globalThis.Temporal && typeof obj?.since === "function" && (obj instanceof Temporal.Instant || obj instanceof Temporal.PlainDate || obj instanceof Temporal.PlainDateTime || obj instanceof Temporal.PlainTime || obj instanceof Temporal.ZonedDateTime))
+        return "temporal";
+    }
+    return type;
+  }
+  function isArrayOfTables(obj) {
+    for (let i = 0;i < obj.length; i++)
+      if (extendedTypeOf(obj[i]) !== "object")
+        return false;
+    return obj.length != 0;
+  }
+  function formatString(s) {
+    return JSON.stringify(s).replace(/\x7f/g, "\\u007f");
+  }
+  function stringifyTemporal(temporal) {
+    return temporal.toString({
+      calendarName: "never",
+      timeZoneName: "never"
+    });
+  }
+  function stringifyValue(val, type, depth, numberAsFloat) {
+    if (depth === 0)
+      throw new Error("Could not stringify the object: maximum object depth exceeded");
+    switch (type) {
+      case "number":
+        if (isNaN(val))
+          return "nan";
+        if (val === Infinity)
+          return "inf";
+        if (val === -Infinity)
+          return "-inf";
+        if (Number.isInteger(val) && (numberAsFloat || !Number.isSafeInteger(val)))
+          return val.toFixed(1);
+      case "bigint":
+      case "boolean":
+        return val.toString();
+      case "string":
+        return formatString(val);
+      case "date":
+        if (isNaN(val.getTime()))
+          throw new TypeError("cannot serialize invalid date");
+        return val.toISOString();
+      case "object":
+        return stringifyInlineTable(val, depth, numberAsFloat);
+      case "array":
+        return stringifyArray(val, depth, numberAsFloat);
+      case "temporal":
+        return stringifyTemporal(val);
+    }
+  }
+  function stringifyInlineTable(obj, depth, numberAsFloat) {
+    let keys = Object.keys(obj);
+    if (keys.length === 0)
+      return "{}";
+    let res = "{ ";
+    for (let i = 0;i < keys.length; i++) {
+      let k = keys[i];
+      if (i)
+        res += ", ";
+      res += BARE_KEY.test(k) ? k : formatString(k);
+      res += " = ";
+      res += stringifyValue(obj[k], extendedTypeOf(obj[k]), depth - 1, numberAsFloat);
+    }
+    return res + " }";
+  }
+  function stringifyArray(array3, depth, numberAsFloat) {
+    if (array3.length === 0)
+      return "[]";
+    let res = "[ ";
+    for (let i = 0;i < array3.length; i++) {
+      if (i)
+        res += ", ";
+      if (array3[i] === null || array3[i] === undefined)
+        throw new TypeError("arrays cannot contain null or undefined values");
+      res += stringifyValue(array3[i], extendedTypeOf(array3[i]), depth - 1, numberAsFloat);
+    }
+    return res + " ]";
+  }
+  function stringifyArrayTable(array3, key, depth, numberAsFloat) {
+    if (depth === 0)
+      throw new Error("Could not stringify the object: maximum object depth exceeded");
+    let res = "";
+    for (let i = 0;i < array3.length; i++) {
+      res += `${res && `
+`}[[${key}]]
+`;
+      res += stringifyTable(0, array3[i], key, depth, numberAsFloat);
+    }
+    return res;
+  }
+  function stringifyTable(tableKey, obj, prefix, depth, numberAsFloat) {
+    if (depth === 0)
+      throw new Error("Could not stringify the object: maximum object depth exceeded");
+    let preamble = "";
+    let tables = "";
+    let keys = Object.keys(obj);
+    for (let i = 0;i < keys.length; i++) {
+      let k = keys[i];
+      if (obj[k] !== null && obj[k] !== undefined) {
+        let type = extendedTypeOf(obj[k]);
+        if (type === "symbol" || type === "function")
+          throw new TypeError(`cannot serialize values of type '${type}'`);
+        let key = BARE_KEY.test(k) ? k : formatString(k);
+        if (type === "array" && isArrayOfTables(obj[k]))
+          tables += (tables && `
+`) + stringifyArrayTable(obj[k], prefix ? `${prefix}.${key}` : key, depth - 1, numberAsFloat);
+        else if (type === "object") {
+          let tblKey = prefix ? `${prefix}.${key}` : key;
+          tables += (tables && `
+`) + stringifyTable(tblKey, obj[k], tblKey, depth - 1, numberAsFloat);
+        } else {
+          preamble += key;
+          preamble += " = ";
+          preamble += stringifyValue(obj[k], type, depth, numberAsFloat);
+          preamble += `
+`;
+        }
+      }
+    }
+    if (tableKey && (preamble || !tables))
+      preamble = preamble ? `[${tableKey}]
+${preamble}` : `[${tableKey}]`;
+    return preamble && tables ? `${preamble}
+${tables}` : preamble || tables;
+  }
+  function stringify(obj, { maxDepth = 1000, numbersAsFloat = false } = {}) {
+    if (extendedTypeOf(obj) !== "object")
+      throw new TypeError("stringify can only be called with an object");
+    let str = stringifyTable(0, obj, "", maxDepth, numbersAsFloat);
+    if (str[str.length - 1] !== `
+`)
+      return str + `
+`;
+    return str;
+  }
+  var src_default = {
+    parse: parse6,
+    stringify,
+    TomlDate,
+    TomlError
+  };
+  exports.TomlDate = TomlDate;
+  exports.TomlError = TomlError;
+  exports.default = src_default;
+  exports.parse = parse6;
+  exports.stringify = stringify;
+});
+
 // ../packages/agent-integrations/bundle.json
 var require_bundle = __commonJS((exports, module) => {
   module.exports = {
@@ -47582,6 +48407,8 @@ var require_agent_integrations = __commonJS((exports, module) => {
   var path3 = __require("node:path");
   var os = __require("node:os");
   var { createHash: createHash4, randomUUID: randomUUID8 } = __require("node:crypto");
+  var { isDeepStrictEqual } = __require("node:util");
+  var { parse: parseToml } = require_smol_toml();
   var defaultBundle = require_bundle();
   var MCP_URL = "https://app.scribed.ai/mcp";
   var PLATFORM_IDS = Object.freeze(["claude-code", "codex", "cursor"]);
@@ -47612,20 +48439,6 @@ url = "https://app.scribed.ai/mcp"
     const args = value.args;
     return args[0] === "-y" && /^@scribed\/cli@(?:latest|\d+\.\d+\.\d+)$/.test(args[1]) && args[2] === "mcp" && (args.length === 3 || args.length === 5 && args[3] === "--categories" && typeof args[4] === "string");
   }
-  function tomlTableParts(header) {
-    const parts = [];
-    const component = /\s*(?:"([^"\\]*)"|'([^']*)'|([A-Za-z0-9_-]+))\s*(\.|$)/gy;
-    let position = 0;
-    while (position < header.length) {
-      component.lastIndex = position;
-      const match = component.exec(header);
-      if (!match || match.index !== position || match[4] === "." && component.lastIndex === header.length)
-        throw new Error("Codex config has unsupported table names; manage it in Codex MCP settings.");
-      parts.push(match[1] ?? match[2] ?? match[3]);
-      position = component.lastIndex;
-    }
-    return parts;
-  }
   function versionCompare(a, b) {
     const left = a.split(".").map(Number), right = b.split(".").map(Number);
     for (let i = 0;i < 3; i++)
@@ -47727,94 +48540,59 @@ url = "https://app.scribed.ai/mcp"
   }
   function inspectCodex(file2) {
     const text6 = read(file2), source = text6 || "";
-    const managed = source.includes(CODEX_BLOCK);
-    const outside = managed ? source.replace(CODEX_BLOCK, "") : source;
-    const managedTail = managed ? source.slice(source.indexOf(CODEX_BLOCK) + CODEX_BLOCK.length).split(/^\s*\[/m)[0] : "";
-    const appendedKeys = managedTail.split(`
-`).some((line) => line.trim() && !line.trim().startsWith("#"));
-    const lines = outside.split(`
-`).map((line) => line.replace(/#.*$/, "").trim()).filter(Boolean);
-    if (lines.some((line) => line.includes('"""') || line.includes("'''"))) {
-      throw new Error("Codex config uses multiline TOML strings; use Codex MCP settings for this configuration.");
-    }
-    const seenTables = new Set, seenKeys = new Set;
-    let table = "";
-    for (const line of lines) {
-      if (line.startsWith("[")) {
-        if (!/^\[[^\[\]]+\]$/.test(line))
-          throw new Error("Codex config has unsupported tables; manage it in Codex MCP settings.");
-        const tableKey = JSON.stringify(tomlTableParts(line.slice(1, -1)));
-        if (seenTables.has(tableKey))
-          throw new Error("Codex config has duplicate tables; manage it in Codex MCP settings.");
-        seenTables.add(tableKey);
-        table = tableKey;
-        continue;
-      }
-      const assignment = /^([A-Za-z0-9_-]+|"[^"\\]+"|'[^']+')\s*=\s*(.+)$/.exec(line);
-      if (!assignment)
-        throw new Error("Codex config has unsupported syntax; manage it in Codex MCP settings.");
-      const key = `${table}:${assignment[1].replace(/["']/g, "")}`, value = assignment[2];
-      if (seenKeys.has(key))
-        throw new Error("Codex config has duplicate keys; nothing was changed.");
-      seenKeys.add(key);
-      let valid = /^(?:true|false|[+-]?(?:0|[1-9][\d_]*)(?:\.[\d_]+)?(?:[eE][+-]?\d+)?)$/.test(value) || /^'[^']*'$/.test(value);
-      if (value.startsWith('"') || value.startsWith("[")) {
-        try {
-          const parsed = JSON.parse(value);
-          valid = typeof parsed === "string" || Array.isArray(parsed);
-        } catch {
-          valid = false;
-        }
-      }
-      if (!valid)
-        throw new Error("Codex config has unsupported values; manage it in Codex MCP settings.");
-    }
-    const headers4 = [...outside.matchAll(/^\s*\[([^\]\n]+)\]\s*(?:#[^\n]*)?$/gm)].map((header) => Object.assign(header, { parts: tomlTableParts(header[1]) }));
-    const candidates = headers4.filter((match) => match.parts.length === 2 && match.parts[0] === "mcp_servers" && match.parts[1] === "scribed");
-    const dotted = lines.some((line) => !line.startsWith("[") && /^(?:["']?mcp_servers["']?\s*[.=]|["']?scribed["']?\s*=)/.test(line));
-    const nested2 = headers4.some((match) => match.parts.length > 2 && match.parts[0] === "mcp_servers" && match.parts[1] === "scribed");
-    const duplicate = (outside.match(/https:\/\/app\.scribed\.ai\/mcp/g) || []).length > (candidates.length === 1 ? 1 : 0);
-    const markerConflict = outside.includes("# BEGIN SCRIBED AGENT INTEGRATION") || outside.includes("# END SCRIBED AGENT INTEGRATION");
-    if (headers4.some((header) => header[1].includes("\\")))
-      throw new Error("Codex config contains escaped table names; manage this configuration in Codex MCP settings.");
-    let existing = null, matches = managed, fingerprint = managed ? hash2(CODEX_BLOCK) : null;
-    if (candidates.length === 1 && !managed) {
-      const candidate = candidates[0];
-      const end = headers4.find((header) => header.index > candidate.index)?.index ?? outside.length;
-      existing = outside.slice(candidate.index, end);
-      const body = existing.split(`
-`).slice(1).map((line) => line.replace(/#.*$/, "").trim()).filter(Boolean);
-      const values = {};
-      let simple = true;
-      for (const line of body) {
-        const match = /^([A-Za-z_]+)\s*=\s*(.+)$/.exec(line);
-        if (!match || Object.hasOwn(values, match[1])) {
-          simple = false;
-          break;
-        }
-        const raw = match[2];
-        try {
-          values[match[1]] = raw.startsWith("'") && raw.endsWith("'") ? raw.slice(1, -1) : JSON.parse(raw);
-        } catch {
-          simple = false;
-          break;
-        }
+    let config2;
+    try {
+      config2 = parseToml(source);
+    } catch {
+      throw new Error("Codex settings could not be read. Check the configuration in Codex MCP settings.");
+    }
+    if (config2.mcp_servers !== undefined && !object5(config2.mcp_servers)) {
+      throw new Error("Codex MCP settings must contain a server table. Manage this configuration in Codex MCP settings.");
+    }
+    const servers = config2.mcp_servers || {};
+    const compatible = (value) => object5(value) && (scribedStdio(value) || scribedUrl(value.url) && !value.command);
+    const aliases = Object.entries(servers).filter(([key, value]) => key !== "scribed" && compatible(value));
+    const entry = servers.scribed ?? (aliases.length === 1 ? aliases[0][1] : undefined);
+    const duplicate = aliases.length > (servers.scribed === undefined ? 1 : 0);
+    const nextSource = `${source}${source && !source.endsWith(`
+`) ? `
+` : ""}${source ? `
+` : ""}${CODEX_BLOCK}`;
+    const withoutScribed = (value) => {
+      const remaining = { ...value, mcp_servers: { ...value.mcp_servers } };
+      delete remaining.mcp_servers.scribed;
+      if (!Object.keys(remaining.mcp_servers).length)
+        delete remaining.mcp_servers;
+      return remaining;
+    };
+    let managed = false;
+    if (source.includes(CODEX_BLOCK) && isDeepStrictEqual(servers.scribed, { url: MCP_URL })) {
+      try {
+        const remaining = parseToml(source.replace(CODEX_BLOCK, ""));
+        if (object5(remaining.mcp_servers) && !Object.keys(remaining.mcp_servers).length)
+          delete remaining.mcp_servers;
+        managed = isDeepStrictEqual(remaining, withoutScribed(config2));
+      } catch {}
+    }
+    const markerConflict = !managed && (source.includes("# BEGIN SCRIBED AGENT INTEGRATION") || source.includes("# END SCRIBED AGENT INTEGRATION"));
+    const misleading = Object.hasOwn(config2, "mcp_servers.scribed");
+    let cannotAppend = false;
+    if (entry === undefined && !duplicate && !markerConflict && !misleading) {
+      try {
+        parseToml(nextSource);
+      } catch {
+        cannotAppend = true;
       }
-      matches = simple && (scribedUrl(values.url) && !values.command || scribedStdio(values));
-      fingerprint = hash2(existing);
     }
-    const ambiguous = dotted || nested2 || duplicate || markerConflict || appendedKeys || candidates.length > 1 || managed && candidates.length > 0;
+    const conflict = duplicate ? "Scribed has more than one connection in Codex. Keep the one you use in Codex MCP settings." : markerConflict ? "The Scribed connection was edited. Review it in Codex MCP settings before changing this setup." : misleading || cannotAppend ? "This Codex configuration needs manual setup in Codex MCP settings." : null;
     return {
       text: text6,
-      present: managed || candidates.length > 0 || ambiguous,
-      matches,
-      fingerprint,
+      present: entry !== undefined,
+      matches: compatible(entry),
+      fingerprint: managed ? hash2(CODEX_BLOCK) : null,
       expectedHash: hash2(CODEX_BLOCK),
-      conflict: ambiguous ? "Codex has an existing or ambiguous Scribed declaration; resolve it in Codex MCP settings first." : null,
-      install: () => `${source}${source && !source.endsWith(`
-`) ? `
-` : ""}${source ? `
-` : ""}${CODEX_BLOCK}`,
+      conflict,
+      install: () => nextSource,
       remove: () => source.replace(CODEX_BLOCK, "")
     };
   }
@@ -47880,25 +48658,49 @@ url = "https://app.scribed.ai/mcp"
         return { ...skill, file: file2, content, desiredHash: hash2(skill.content), owned: owned?.path === file2 ? owned : undefined };
       });
     }
+    function newerBundleVersion(definition, state) {
+      const paths = new Set(bundle.skills.map((skill) => path3.join(definition.skillsPath, skill.name, "SKILL.md")));
+      let newest;
+      for (const [id2, installed] of Object.entries(state.platforms)) {
+        if (versionCompare(installed.version, bundle.version) <= 0)
+          continue;
+        if (id2 !== definition.id && !Object.values(installed.skills).some((skill) => paths.has(skill.path)))
+          continue;
+        if (!newest || versionCompare(installed.version, newest) > 0)
+          newest = installed.version;
+      }
+      return newest;
+    }
+    function hasSharedOwnership(skill, state) {
+      if (skill.content === null)
+        return false;
+      const currentHash = hash2(skill.content);
+      return Object.values(state.platforms).some((other) => Object.values(other.skills).some((entry) => entry.path === skill.file && entry.hash === currentHash));
+    }
     function snapshot(state) {
       return { version: bundle.version, platforms: definitions.map((definition) => {
         const owned = state.platforms[definition.id];
-        const base9 = { ...definition, managed: !!owned, authentication: "not-checked", ...owned ? { version: owned.version } : {} };
+        const newerVersion = newerBundleVersion(definition, state);
+        let base9 = { ...definition, managed: !!owned, authentication: "not-checked", ...owned ? { version: owned.version } : {}, ...newerVersion ? { newerVersion } : {} };
         try {
           const config2 = inspect(definition), skills = inspectSkills(definition, owned);
-          if (!config2.present && !config2.conflict && !owned)
-            return { ...base9, state: "not-installed", detail: "Set up Scribed tools and skills for this platform." };
-          const modified = skills.some((skill) => skill.content !== null && hash2(skill.content) !== skill.desiredHash && (!skill.owned || hash2(skill.content) !== skill.owned.hash));
+          base9 = { ...base9, connectionInstalled: config2.present && config2.matches, skillsInstalled: skills.filter((skill) => skill.content !== null).length, skillsTotal: skills.length };
+          const changedProfile = owned?.config && owned.config.path !== definition.configPath || skills.some((skill) => owned?.skills?.[skill.name] && owned.skills[skill.name].path !== skill.file);
+          if (changedProfile)
+            return { ...base9, state: "conflict", detail: "Your setup uses another profile. Manage the original Scribed integration from that profile before changing it here." };
+          const modified = skills.some((skill) => skill.content !== null && hash2(skill.content) !== skill.desiredHash && (!skill.owned || hash2(skill.content) !== skill.owned.hash) && !hasSharedOwnership(skill, state));
           if (config2.conflict || config2.present && !config2.matches || owned?.config?.path === definition.configPath && config2.present && owned.config.hash !== config2.fingerprint || modified)
             return { ...base9, state: "conflict", detail: config2.conflict || "Existing Scribed configuration or skills differ. Your files were preserved." };
+          if (!config2.present && !owned)
+            return { ...base9, state: "not-installed", detail: "Add Scribed tools and skills to this platform." };
           const missing = !config2.present || skills.some((skill) => skill.content === null);
           if (missing)
-            return { ...base9, state: "needs-repair", detail: "Some configuration or skills are missing. Repair to restore them." };
-          if (owned && versionCompare(owned.version, bundle.version) < 0)
+            return { ...base9, state: "needs-repair", detail: config2.present ? "Your Scribed connection is already set up. Add the missing skills to finish." : "Restore the missing Scribed connection and skills." };
+          if (owned && !newerVersion && versionCompare(owned.version, bundle.version) < 0)
             return { ...base9, state: "update-available", detail: `Scribed skills ${bundle.version} are available.` };
-          if (skills.some((skill) => hash2(skill.content) !== skill.desiredHash) && (!owned || versionCompare(owned.version, bundle.version) <= 0))
+          if (!newerVersion && skills.some((skill) => hash2(skill.content) !== skill.desiredHash) && (!owned || versionCompare(owned.version, bundle.version) <= 0))
             return { ...base9, state: "needs-repair", detail: "Repair to refresh the Scribed skills." };
-          return { ...base9, state: "installed", detail: "Tools and skills are installed. Sign-in and workspace access are managed in this platform." };
+          return { ...base9, state: "installed", detail: newerVersion ? "A newer skills version is already installed. Update this Scribed app to manage it." : "Scribed tools and skills are already installed." };
         } catch (error51) {
           return { ...base9, state: "error", detail: message(error51) };
         }
@@ -47944,8 +48746,9 @@ url = "https://app.scribed.ai/mcp"
               throw new Error("Platform skills path changed; manage the old installation from its original profile.");
             if (config2.conflict)
               throw new Error(config2.conflict);
-            if (!removing && installed && versionCompare(installed.version, bundle.version) > 0) {
-              throw new Error(`A newer Scribed skills bundle (${installed.version}) is installed. Update this Scribed app before repairing it.`);
+            const newerVersion = newerBundleVersion(definition, state);
+            if (!removing && newerVersion) {
+              throw new Error(`A newer Scribed skills bundle (${newerVersion}) is installed or shared by another platform. Update this Scribed app before changing this setup.`);
             }
             if (removing) {
               if (installed.config && installed.config.path !== definition.configPath)
@@ -47979,13 +48782,13 @@ url = "https://app.scribed.ai/mcp"
             if (installed?.config && config2.present && installed.config.hash !== config2.fingerprint)
               throw new Error("The Scribed MCP entry was edited; it was preserved. Manage it in this platform before repairing.");
             for (const skill of skills)
-              if (skill.content !== null && hash2(skill.content) !== skill.desiredHash && (!skill.owned || hash2(skill.content) !== skill.owned.hash))
+              if (skill.content !== null && hash2(skill.content) !== skill.desiredHash && (!skill.owned || hash2(skill.content) !== skill.owned.hash) && !hasSharedOwnership(skill, state))
                 throw new Error(`The ${skill.name} skill already exists with different contents; it was preserved.`);
-            const next = { version: installed?.version || bundle.version, installedAt: installed?.installedAt || new Date().toISOString(), skills: { ...installed?.skills || {} } };
+            const next = { version: installed?.version || bundle.version, installedAt: installed?.installedAt || new Date().toISOString(), skills: { ...installed?.skills } };
             if (!config2.present || installed?.config?.path === definition.configPath && installed.config.hash === config2.fingerprint)
               next.config = { path: definition.configPath, hash: config2.expectedHash };
             for (const skill of skills) {
-              const sharedOwner = Object.values(state.platforms).some((value) => Object.values(value.skills).some((entry) => entry.path === skill.file && entry.hash === (skill.content === null ? skill.desiredHash : hash2(skill.content))));
+              const sharedOwner = hasSharedOwnership(skill, state);
               if (skill.content === null || skill.owned || sharedOwner)
                 next.skills[skill.name] = { path: skill.file, hash: skill.content === null ? skill.desiredHash : hash2(skill.content) };
             }
@@ -48029,7 +48832,10 @@ url = "https://app.scribed.ai/mcp"
       shouldOffer: () => {
         try {
           const state = receipt().value;
-          return !state.offerDismissed && !Object.keys(state.platforms).length && snapshot(state).platforms.some((platform) => !["error", "conflict"].includes(platform.state));
+          if (state.offerDismissed || Object.keys(state.platforms).length)
+            return false;
+          const platforms = snapshot(state).platforms;
+          return !platforms.some((platform) => platform.state === "installed") && platforms.some((platform) => !["error", "conflict"].includes(platform.state));
         } catch {
           return false;
         }
@@ -50090,7 +50896,7 @@ var program = new Command;
 // package.json
 var package_default = {
   name: "@scribed/cli",
-  version: "0.1.15",
+  version: "0.1.16",
   description: "Command-line client + MCP server for Scribed — CRM records, phone + texting, inbox, calendar + booking, transcriptions, HR, Vault, automations, Creative Studio, and Documents, derived from the scribed-agent tool catalog.",
   type: "module",
   license: "SEE LICENSE IN LICENSE",
@@ -75268,7 +76074,7 @@ class StreamableHTTPClientTransport {
 // package.json
 var package_default2 = {
   name: "@scribed/cli",
-  version: "0.1.15",
+  version: "0.1.16",
   description: "Command-line client + MCP server for Scribed — CRM records, phone + texting, inbox, calendar + booking, transcriptions, HR, Vault, automations, Creative Studio, and Documents, derived from the scribed-agent tool catalog.",
   type: "module",
   license: "SEE LICENSE IN LICENSE",

package/dist/mcp/server.js

@@ -70177,7 +70177,7 @@ class StdioServerTransport {
 // package.json
 var package_default = {
   name: "@scribed/cli",
-  version: "0.1.15",
+  version: "0.1.16",
   description: "Command-line client + MCP server for Scribed — CRM records, phone + texting, inbox, calendar + booking, transcriptions, HR, Vault, automations, Creative Studio, and Documents, derived from the scribed-agent tool catalog.",
   type: "module",
   license: "SEE LICENSE IN LICENSE",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scribed/cli",
-  "version": "0.1.15",
+  "version": "0.1.16",
   "description": "Command-line client + MCP server for Scribed — CRM records, phone + texting, inbox, calendar + booking, transcriptions, HR, Vault, automations, Creative Studio, and Documents, derived from the scribed-agent tool catalog.",
   "type": "module",
   "license": "SEE LICENSE IN LICENSE",
@@ -39,9 +39,9 @@
     "url": "git+https://github.com/q6th/scribed-web.git",
     "directory": "scribed-cli"
   },
-  "gitHead": "48b89c6b687ebf42e80cf1e7ffdc221ea0c44acc",
+  "gitHead": "d9feac8991f321c3d3c4b66e5065727849029426",
   "scribedRelease": {
     "repository": "q6th/scribed-web",
-    "commit": "48b89c6b687ebf42e80cf1e7ffdc221ea0c44acc"
+    "commit": "d9feac8991f321c3d3c4b66e5065727849029426"
   }
 }