@omnidev-ai/cli 0.4.0 → 0.5.1

package/dist/shared/chunk-7txw9v1e.js

@@ -0,0 +1,3017 @@
+#!/usr/bin/env node
+import { createRequire } from "node:module";
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// ../core/dist/shared/chunk-1dqs11h6.js
+import { createRequire as createRequire2 } from "node:module";
+
+// ../core/dist/index.js
+import { buildCommand, buildRouteMap } from "@stricli/core";
+import { existsSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+import { existsSync as existsSync2, readdirSync as readdirSync2 } from "node:fs";
+import { basename, join as join2 } from "node:path";
+import { existsSync as existsSync7, readdirSync as readdirSync6 } from "node:fs";
+import { join as join6 } from "node:path";
+import { existsSync as existsSync3 } from "node:fs";
+
+// ../../node_modules/.bun/smol-toml@1.6.0/node_modules/smol-toml/dist/error.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.
+ */
+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 += `
+`;
+    if (i === line) {
+      codeblock += " ".repeat(numberLen + column + 2);
+      codeblock += `^
+`;
+    }
+  }
+  return codeblock;
+}
+
+class TomlError 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/.bun/smol-toml@1.6.0/node_modules/smol-toml/dist/util.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.
+ */
+function isEscaped(str, ptr) {
+  let i = 0;
+  while (str[ptr - ++i] === "\\")
+    ;
+  return --i && i % 2;
+}
+function indexOfNewline(str, start = 0, end = str.length) {
+  let idx = str.indexOf(`
+`, start);
+  if (str[idx - 1] === "\r")
+    idx--;
+  return idx <= end ? idx : -1;
+}
+function skipComment(str, ptr) {
+  for (let i = ptr;i < str.length; i++) {
+    let c = str[i];
+    if (c === `
+`)
+      return i;
+    if (c === "\r" && str[i + 1] === `
+`)
+      return i + 1;
+    if (c < " " && c !== "\t" || c === "") {
+      throw new TomlError("control characters are not allowed in comments", {
+        toml: str,
+        ptr
+      });
+    }
+  }
+  return str.length;
+}
+function skipVoid(str, ptr, banNewLines, banComments) {
+  let c;
+  while ((c = str[ptr]) === " " || c === "\t" || !banNewLines && (c === `
+` || c === "\r" && str[ptr + 1] === `
+`))
+    ptr++;
+  return banComments || c !== "#" ? ptr : skipVoid(str, skipComment(str, ptr), banNewLines);
+}
+function skipUntil(str, ptr, sep, end, banNewLines = false) {
+  if (!end) {
+    ptr = indexOfNewline(str, ptr);
+    return ptr < 0 ? str.length : ptr;
+  }
+  for (let i = ptr;i < str.length; i++) {
+    let c = str[i];
+    if (c === "#") {
+      i = indexOfNewline(str, i);
+    } else if (c === sep) {
+      return i + 1;
+    } else if (c === end || banNewLines && (c === `
+` || c === "\r" && str[i + 1] === `
+`)) {
+      return i;
+    }
+  }
+  throw new TomlError("cannot find end of structure", {
+    toml: str,
+    ptr
+  });
+}
+function getStringEnd(str, seek) {
+  let first = str[seek];
+  let target = first === str[seek + 1] && str[seek + 1] === str[seek + 2] ? str.slice(seek, seek + 3) : first;
+  seek += target.length - 1;
+  do
+    seek = str.indexOf(target, ++seek);
+  while (seek > -1 && first !== "'" && isEscaped(str, seek));
+  if (seek > -1) {
+    seek += target.length;
+    if (target.length > 1) {
+      if (str[seek] === first)
+        seek++;
+      if (str[seek] === first)
+        seek++;
+    }
+  }
+  return seek;
+}
+
+// ../../node_modules/.bun/smol-toml@1.6.0/node_modules/smol-toml/dist/date.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.
+ */
+var DATE_TIME_RE = /^(\d{4}-\d{2}-\d{2})?[T ]?(?:(\d{2}):\d{2}(?::\d{2}(?:\.\d+)?)?)?(Z|[-+]\d{2}:\d{2})?$/i;
+
+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 * 60000);
+    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/.bun/smol-toml@1.6.0/node_modules/smol-toml/dist/primitive.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.
+ */
+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_]/;
+var ESCAPE_REGEX = /^[0-9a-f]{2,8}$/i;
+var ESC_MAP = {
+  b: "\b",
+  t: "\t",
+  n: `
+`,
+  f: "\f",
+  r: "\r",
+  e: "\x1B",
+  '"': '"',
+  "\\": "\\"
+};
+function parseString(str, ptr = 0, endPtr = str.length) {
+  let isLiteral = str[ptr] === "'";
+  let isMultiline = str[ptr++] === str[ptr] && str[ptr] === str[ptr + 1];
+  if (isMultiline) {
+    endPtr -= 2;
+    if (str[ptr += 2] === "\r")
+      ptr++;
+    if (str[ptr] === `
+`)
+      ptr++;
+  }
+  let tmp = 0;
+  let isEscape;
+  let parsed = "";
+  let sliceStart = ptr;
+  while (ptr < endPtr - 1) {
+    let c = str[ptr++];
+    if (c === `
+` || c === "\r" && str[ptr] === `
+`) {
+      if (!isMultiline) {
+        throw new TomlError("newlines are not allowed in strings", {
+          toml: str,
+          ptr: ptr - 1
+        });
+      }
+    } else if (c < " " && c !== "\t" || c === "") {
+      throw new TomlError("control characters are not allowed in strings", {
+        toml: str,
+        ptr: ptr - 1
+      });
+    }
+    if (isEscape) {
+      isEscape = false;
+      if (c === "x" || c === "u" || c === "U") {
+        let code = str.slice(ptr, ptr += c === "x" ? 2 : c === "u" ? 4 : 8);
+        if (!ESCAPE_REGEX.test(code)) {
+          throw new TomlError("invalid unicode escape", {
+            toml: str,
+            ptr: tmp
+          });
+        }
+        try {
+          parsed += String.fromCodePoint(parseInt(code, 16));
+        } catch {
+          throw new TomlError("invalid unicode escape", {
+            toml: str,
+            ptr: tmp
+          });
+        }
+      } else if (isMultiline && (c === `
+` || c === " " || c === "\t" || c === "\r")) {
+        ptr = skipVoid(str, ptr - 1, true);
+        if (str[ptr] !== `
+` && str[ptr] !== "\r") {
+          throw new TomlError("invalid escape: only line-ending whitespace may be escaped", {
+            toml: str,
+            ptr: tmp
+          });
+        }
+        ptr = skipVoid(str, ptr);
+      } else if (c in ESC_MAP) {
+        parsed += ESC_MAP[c];
+      } else {
+        throw new TomlError("unrecognized escape sequence", {
+          toml: str,
+          ptr: tmp
+        });
+      }
+      sliceStart = ptr;
+    } else if (!isLiteral && c === "\\") {
+      tmp = ptr - 1;
+      isEscape = true;
+      parsed += str.slice(sliceStart, tmp);
+    }
+  }
+  return parsed + str.slice(sliceStart, endPtr - 1);
+}
+function parseValue(value, toml, ptr, integersAsBigInt) {
+  if (value === "true")
+    return true;
+  if (value === "false")
+    return false;
+  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", {
+        toml,
+        ptr
+      });
+    }
+    value = value.replace(/_/g, "");
+    let numeric = +value;
+    if (isNaN(numeric)) {
+      throw new TomlError("invalid number", {
+        toml,
+        ptr
+      });
+    }
+    if (isInt) {
+      if ((isInt = !Number.isSafeInteger(numeric)) && !integersAsBigInt) {
+        throw new TomlError("integer value cannot be represented losslessly", {
+          toml,
+          ptr
+        });
+      }
+      if (isInt || integersAsBigInt === true)
+        numeric = BigInt(value);
+    }
+    return numeric;
+  }
+  const date = new TomlDate(value);
+  if (!date.isValid()) {
+    throw new TomlError("invalid value", {
+      toml,
+      ptr
+    });
+  }
+  return date;
+}
+
+// ../../node_modules/.bun/smol-toml@1.6.0/node_modules/smol-toml/dist/extract.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.
+ */
+function sliceAndTrimEndOf(str, startPtr, endPtr) {
+  let value = str.slice(startPtr, endPtr);
+  let commentIdx = value.indexOf("#");
+  if (commentIdx > -1) {
+    skipComment(str, commentIdx);
+    value = value.slice(0, commentIdx);
+  }
+  return [value.trimEnd(), commentIdx];
+}
+function extractValue(str, ptr, end, depth, integersAsBigInt) {
+  if (depth === 0) {
+    throw new TomlError("document contains excessively nested structures. aborting.", {
+      toml: str,
+      ptr
+    });
+  }
+  let c = str[ptr];
+  if (c === "[" || c === "{") {
+    let [value, endPtr2] = c === "[" ? parseArray(str, ptr, depth, integersAsBigInt) : parseInlineTable(str, ptr, depth, integersAsBigInt);
+    if (end) {
+      endPtr2 = skipVoid(str, endPtr2);
+      if (str[endPtr2] === ",")
+        endPtr2++;
+      else if (str[endPtr2] !== end) {
+        throw new TomlError("expected comma or end of structure", {
+          toml: str,
+          ptr: endPtr2
+        });
+      }
+    }
+    return [value, endPtr2];
+  }
+  let endPtr;
+  if (c === '"' || c === "'") {
+    endPtr = getStringEnd(str, ptr);
+    let parsed = parseString(str, ptr, endPtr);
+    if (end) {
+      endPtr = skipVoid(str, endPtr);
+      if (str[endPtr] && str[endPtr] !== "," && str[endPtr] !== end && str[endPtr] !== `
+` && str[endPtr] !== "\r") {
+        throw new TomlError("unexpected character encountered", {
+          toml: str,
+          ptr: endPtr
+        });
+      }
+      endPtr += +(str[endPtr] === ",");
+    }
+    return [parsed, endPtr];
+  }
+  endPtr = skipUntil(str, ptr, ",", end);
+  let slice = sliceAndTrimEndOf(str, ptr, endPtr - +(str[endPtr - 1] === ","));
+  if (!slice[0]) {
+    throw new TomlError("incomplete key-value declaration: no value specified", {
+      toml: str,
+      ptr
+    });
+  }
+  if (end && slice[1] > -1) {
+    endPtr = skipVoid(str, ptr + slice[1]);
+    endPtr += +(str[endPtr] === ",");
+  }
+  return [
+    parseValue(slice[0], str, ptr, integersAsBigInt),
+    endPtr
+  ];
+}
+
+// ../../node_modules/.bun/smol-toml@1.6.0/node_modules/smol-toml/dist/struct.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.
+ */
+var KEY_PART_RE = /^[a-zA-Z0-9-_]+[ \t]*$/;
+function parseKey(str, ptr, end = "=") {
+  let dot = ptr - 1;
+  let parsed = [];
+  let endPtr = str.indexOf(end, ptr);
+  if (endPtr < 0) {
+    throw new TomlError("incomplete key-value: cannot find end of key", {
+      toml: str,
+      ptr
+    });
+  }
+  do {
+    let c = str[ptr = ++dot];
+    if (c !== " " && c !== "\t") {
+      if (c === '"' || c === "'") {
+        if (c === str[ptr + 1] && c === str[ptr + 2]) {
+          throw new TomlError("multiline strings are not allowed in keys", {
+            toml: str,
+            ptr
+          });
+        }
+        let eos = getStringEnd(str, ptr);
+        if (eos < 0) {
+          throw new TomlError("unfinished string encountered", {
+            toml: str,
+            ptr
+          });
+        }
+        dot = str.indexOf(".", eos);
+        let strEnd = str.slice(eos, dot < 0 || dot > endPtr ? endPtr : dot);
+        let newLine = indexOfNewline(strEnd);
+        if (newLine > -1) {
+          throw new TomlError("newlines are not allowed in keys", {
+            toml: str,
+            ptr: ptr + dot + newLine
+          });
+        }
+        if (strEnd.trimStart()) {
+          throw new TomlError("found extra tokens after the string part", {
+            toml: str,
+            ptr: eos
+          });
+        }
+        if (endPtr < eos) {
+          endPtr = str.indexOf(end, eos);
+          if (endPtr < 0) {
+            throw new TomlError("incomplete key-value: cannot find end of key", {
+              toml: str,
+              ptr
+            });
+          }
+        }
+        parsed.push(parseString(str, ptr, eos));
+      } else {
+        dot = str.indexOf(".", ptr);
+        let part = str.slice(ptr, 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: str,
+            ptr
+          });
+        }
+        parsed.push(part.trimEnd());
+      }
+    }
+  } while (dot + 1 && dot < endPtr);
+  return [parsed, skipVoid(str, endPtr + 1, true, true)];
+}
+function parseInlineTable(str, ptr, depth, integersAsBigInt) {
+  let res = {};
+  let seen = new Set;
+  let c;
+  ptr++;
+  while ((c = str[ptr++]) !== "}" && c) {
+    if (c === ",") {
+      throw new TomlError("expected value, found comma", {
+        toml: str,
+        ptr: ptr - 1
+      });
+    } else if (c === "#")
+      ptr = skipComment(str, ptr);
+    else if (c !== " " && c !== "\t" && c !== `
+` && c !== "\r") {
+      let k;
+      let t = res;
+      let hasOwn = false;
+      let [key, keyEndPtr] = parseKey(str, ptr - 1);
+      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: str,
+            ptr
+          });
+        }
+        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: str,
+          ptr
+        });
+      }
+      let [value, valueEndPtr] = extractValue(str, keyEndPtr, "}", depth - 1, integersAsBigInt);
+      seen.add(value);
+      t[k] = value;
+      ptr = valueEndPtr;
+    }
+  }
+  if (!c) {
+    throw new TomlError("unfinished table encountered", {
+      toml: str,
+      ptr
+    });
+  }
+  return [res, ptr];
+}
+function parseArray(str, ptr, depth, integersAsBigInt) {
+  let res = [];
+  let c;
+  ptr++;
+  while ((c = str[ptr++]) !== "]" && c) {
+    if (c === ",") {
+      throw new TomlError("expected value, found comma", {
+        toml: str,
+        ptr: ptr - 1
+      });
+    } else if (c === "#")
+      ptr = skipComment(str, ptr);
+    else if (c !== " " && c !== "\t" && c !== `
+` && c !== "\r") {
+      let e = extractValue(str, ptr - 1, "]", depth - 1, integersAsBigInt);
+      res.push(e[0]);
+      ptr = e[1];
+    }
+  }
+  if (!c) {
+    throw new TomlError("unfinished array encountered", {
+      toml: str,
+      ptr
+    });
+  }
+  return [res, ptr];
+}
+
+// ../../node_modules/.bun/smol-toml@1.6.0/node_modules/smol-toml/dist/parse.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.
+ */
+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 = 1000, integersAsBigInt } = {}) {
+  let res = {};
+  let meta = {};
+  let tbl = res;
+  let m = meta;
+  for (let ptr = skipVoid(toml, 0);ptr < toml.length; ) {
+    if (toml[ptr] === "[") {
+      let isTableArray = toml[++ptr] === "[";
+      let k = parseKey(toml, ptr += +isTableArray, "]");
+      if (isTableArray) {
+        if (toml[k[1] - 1] !== "]") {
+          throw new TomlError("expected end of table declaration", {
+            toml,
+            ptr: k[1] - 1
+          });
+        }
+        k[1]++;
+      }
+      let p = peekTable(k[0], res, meta, isTableArray ? 2 : 1);
+      if (!p) {
+        throw new TomlError("trying to redefine an already defined table or value", {
+          toml,
+          ptr
+        });
+      }
+      m = p[2];
+      tbl = p[1];
+      ptr = k[1];
+    } else {
+      let k = parseKey(toml, ptr);
+      let p = peekTable(k[0], tbl, m, 0);
+      if (!p) {
+        throw new TomlError("trying to redefine an already defined table or value", {
+          toml,
+          ptr
+        });
+      }
+      let v = extractValue(toml, k[1], undefined, maxDepth, integersAsBigInt);
+      p[1][p[0]] = v[0];
+      ptr = v[1];
+    }
+    ptr = skipVoid(toml, ptr, true);
+    if (toml[ptr] && toml[ptr] !== `
+` && toml[ptr] !== "\r") {
+      throw new TomlError("each key-value declaration must be followed by an end-of-line", {
+        toml,
+        ptr
+      });
+    }
+    ptr = skipVoid(toml, ptr);
+  }
+  return res;
+}
+
+// ../../node_modules/.bun/smol-toml@1.6.0/node_modules/smol-toml/dist/stringify.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.
+ */
+
+// ../../node_modules/.bun/smol-toml@1.6.0/node_modules/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.
+ */
+
+// ../core/dist/index.js
+import { existsSync as existsSync4, readdirSync as readdirSync3 } from "node:fs";
+import { basename as basename2, join as join3 } from "node:path";
+import { existsSync as existsSync5, readdirSync as readdirSync4 } from "node:fs";
+import { join as join4 } from "node:path";
+import { existsSync as existsSync6, readdirSync as readdirSync5 } from "node:fs";
+import { join as join5 } from "node:path";
+import { existsSync as existsSync8 } from "node:fs";
+import { existsSync as existsSync9, mkdirSync } from "node:fs";
+import { existsSync as existsSync10 } from "node:fs";
+import { cp, mkdir, readdir, readFile, rm, stat, writeFile } from "node:fs/promises";
+import { join as join7 } from "node:path";
+import { existsSync as existsSync11 } from "node:fs";
+import { existsSync as existsSync12 } from "node:fs";
+import { existsSync as existsSync13, mkdirSync as mkdirSync2, rmSync } from "node:fs";
+import { existsSync as existsSync14, mkdirSync as mkdirSync3 } from "node:fs";
+import { spawn } from "node:child_process";
+import { mkdirSync as mkdirSync4 } from "node:fs";
+function parseSimpleYamlFrontmatter(yaml) {
+  const result = {};
+  for (const line of yaml.split(`
+`)) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) {
+      continue;
+    }
+    const colonIndex = trimmed.indexOf(":");
+    if (colonIndex === -1) {
+      continue;
+    }
+    const rawKey = trimmed.slice(0, colonIndex).trim();
+    let value = trimmed.slice(colonIndex + 1).trim();
+    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+      value = value.slice(1, -1);
+    }
+    const key = rawKey.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase());
+    result[key] = value;
+  }
+  return result;
+}
+function parseFrontmatterWithMarkdown(content) {
+  const match = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/s);
+  if (!match?.[1] || match[2] === undefined) {
+    return null;
+  }
+  const frontmatter = parseSimpleYamlFrontmatter(match[1]);
+  const markdown = match[2];
+  return { frontmatter, markdown };
+}
+async function loadCommands(capabilityPath, capabilityId) {
+  const commandsDir = join(capabilityPath, "commands");
+  if (!existsSync(commandsDir)) {
+    return [];
+  }
+  const commands = [];
+  const entries = readdirSync(commandsDir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
+  for (const entry of entries) {
+    if (entry.isDirectory()) {
+      const commandPath = join(commandsDir, entry.name, "COMMAND.md");
+      if (existsSync(commandPath)) {
+        const command = await parseCommandFile(commandPath, capabilityId);
+        commands.push(command);
+      }
+    }
+  }
+  return commands;
+}
+async function parseCommandFile(filePath, capabilityId) {
+  const content = await Bun.file(filePath).text();
+  const parsed = parseFrontmatterWithMarkdown(content);
+  if (!parsed) {
+    throw new Error(`Invalid COMMAND.md format at ${filePath}: missing YAML frontmatter`);
+  }
+  const frontmatter = parsed.frontmatter;
+  const prompt = parsed.markdown;
+  if (!frontmatter.name || !frontmatter.description) {
+    throw new Error(`Invalid COMMAND.md at ${filePath}: name and description required`);
+  }
+  const result = {
+    name: frontmatter.name,
+    description: frontmatter.description,
+    prompt: prompt.trim(),
+    capabilityId
+  };
+  if (frontmatter.allowedTools) {
+    result.allowedTools = frontmatter.allowedTools;
+  }
+  return result;
+}
+async function loadDocs(capabilityPath, capabilityId) {
+  const docs = [];
+  const definitionPath = join2(capabilityPath, "definition.md");
+  if (existsSync2(definitionPath)) {
+    const content = await Bun.file(definitionPath).text();
+    docs.push({
+      name: "definition",
+      content: content.trim(),
+      capabilityId
+    });
+  }
+  const docsDir = join2(capabilityPath, "docs");
+  if (existsSync2(docsDir)) {
+    const entries = readdirSync2(docsDir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
+    for (const entry of entries) {
+      if (entry.isFile() && entry.name.endsWith(".md")) {
+        const docPath = join2(docsDir, entry.name);
+        const content = await Bun.file(docPath).text();
+        docs.push({
+          name: basename(entry.name, ".md"),
+          content: content.trim(),
+          capabilityId
+        });
+      }
+    }
+  }
+  return docs;
+}
+var ENV_FILE = ".omni/.env";
+async function loadEnvironment() {
+  const env = {};
+  if (existsSync3(ENV_FILE)) {
+    const content = await Bun.file(ENV_FILE).text();
+    for (const line of content.split(`
+`)) {
+      const trimmed = line.trim();
+      if (trimmed && !trimmed.startsWith("#")) {
+        const eqIndex = trimmed.indexOf("=");
+        if (eqIndex > 0) {
+          const key = trimmed.slice(0, eqIndex).trim();
+          const value = trimmed.slice(eqIndex + 1).trim();
+          const unquotedValue = value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'") ? value.slice(1, -1) : value;
+          env[key] = unquotedValue;
+        }
+      }
+    }
+  }
+  const processEnv = {};
+  for (const [key, value] of Object.entries(process.env)) {
+    if (value !== undefined) {
+      processEnv[key] = value;
+    }
+  }
+  return { ...env, ...processEnv };
+}
+function validateEnv(declarations, env, capabilityId) {
+  const missing = [];
+  for (const [key, decl] of Object.entries(declarations)) {
+    const declaration = decl;
+    const value = env[key] ?? declaration.default;
+    if (declaration.required && !value) {
+      missing.push(key);
+    }
+  }
+  if (missing.length > 0) {
+    throw new Error(`Missing required environment variable${missing.length > 1 ? "s" : ""} for capability "${capabilityId}": ${missing.join(", ")}. ` + `Set ${missing.length > 1 ? "them" : "it"} in .omni/.env or as environment variable${missing.length > 1 ? "s" : ""}.`);
+  }
+}
+function isSecretEnvVar(key, declarations) {
+  const decl = declarations[key];
+  return decl?.secret === true;
+}
+function parseOmniConfig(tomlContent) {
+  try {
+    return parse(tomlContent);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Invalid TOML in config: ${message}`);
+  }
+}
+function validateCapabilityConfig(parsed) {
+  const cap = parsed["capability"];
+  if (typeof cap !== "object" || cap === null) {
+    throw new Error("capability.id is required in capability.toml");
+  }
+  const capability = cap;
+  if (typeof capability["id"] !== "string") {
+    throw new Error("capability.id is required in capability.toml");
+  }
+  if (typeof capability["name"] !== "string") {
+    throw new Error("capability.name is required in capability.toml");
+  }
+  if (typeof capability["version"] !== "string") {
+    throw new Error("capability.version is required in capability.toml");
+  }
+}
+function parseCapabilityConfig(tomlContent) {
+  try {
+    const parsed = parse(tomlContent);
+    validateCapabilityConfig(parsed);
+    return parsed;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Invalid capability.toml: ${message}`);
+  }
+}
+async function loadRules(capabilityPath, capabilityId) {
+  const rulesDir = join3(capabilityPath, "rules");
+  if (!existsSync4(rulesDir)) {
+    return [];
+  }
+  const rules = [];
+  const entries = readdirSync3(rulesDir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
+  for (const entry of entries) {
+    if (entry.isFile() && entry.name.endsWith(".md")) {
+      const rulePath = join3(rulesDir, entry.name);
+      const content = await Bun.file(rulePath).text();
+      rules.push({
+        name: basename2(entry.name, ".md"),
+        content: content.trim(),
+        capabilityId
+      });
+    }
+  }
+  return rules;
+}
+async function writeRules(rules, docs = []) {
+  const instructionsPath = ".omni/instructions.md";
+  const rulesContent = generateRulesContent(rules, docs);
+  let content;
+  if (existsSync4(instructionsPath)) {
+    content = await Bun.file(instructionsPath).text();
+  } else {
+    content = `# OmniDev Instructions
+
+## Project Description
+<!-- TODO: Add 2-3 sentences describing your project -->
+[Describe what this project does and its main purpose]
+
+<!-- BEGIN OMNIDEV GENERATED CONTENT - DO NOT EDIT BELOW THIS LINE -->
+<!-- END OMNIDEV GENERATED CONTENT -->
+`;
+  }
+  const beginMarker = "<!-- BEGIN OMNIDEV GENERATED CONTENT - DO NOT EDIT BELOW THIS LINE -->";
+  const endMarker = "<!-- END OMNIDEV GENERATED CONTENT -->";
+  const beginIndex = content.indexOf(beginMarker);
+  const endIndex = content.indexOf(endMarker);
+  if (beginIndex === -1 || endIndex === -1) {
+    content += `
+
+${beginMarker}
+${rulesContent}
+${endMarker}
+`;
+  } else {
+    content = content.substring(0, beginIndex + beginMarker.length) + `
+` + rulesContent + `
+` + content.substring(endIndex);
+  }
+  await Bun.write(instructionsPath, content);
+}
+function generateRulesContent(rules, docs = []) {
+  if (rules.length === 0 && docs.length === 0) {
+    return `<!-- This section is automatically updated when capabilities change -->
+
+## Capabilities
+
+No capabilities enabled yet. Run \`omnidev capability enable <name>\` to enable capabilities.`;
+  }
+  let content = `<!-- This section is automatically updated when capabilities change -->
+
+## Capabilities
+
+`;
+  if (docs.length > 0) {
+    content += `### Documentation
+
+`;
+    for (const doc of docs) {
+      content += `#### ${doc.name} (from ${doc.capabilityId})
+
+${doc.content}
+
+`;
+    }
+  }
+  if (rules.length > 0) {
+    content += `### Rules
+
+`;
+    for (const rule of rules) {
+      content += `#### ${rule.name} (from ${rule.capabilityId})
+
+${rule.content}
+
+`;
+    }
+  }
+  return content.trim();
+}
+async function loadSkills(capabilityPath, capabilityId) {
+  const skillsDir = join4(capabilityPath, "skills");
+  if (!existsSync5(skillsDir)) {
+    return [];
+  }
+  const skills = [];
+  const entries = readdirSync4(skillsDir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
+  for (const entry of entries) {
+    if (entry.isDirectory()) {
+      const skillPath = join4(skillsDir, entry.name, "SKILL.md");
+      if (existsSync5(skillPath)) {
+        const skill = await parseSkillFile(skillPath, capabilityId);
+        skills.push(skill);
+      }
+    }
+  }
+  return skills;
+}
+async function parseSkillFile(filePath, capabilityId) {
+  const content = await Bun.file(filePath).text();
+  const parsed = parseFrontmatterWithMarkdown(content);
+  if (!parsed) {
+    throw new Error(`Invalid SKILL.md format at ${filePath}: missing YAML frontmatter`);
+  }
+  const frontmatter = parsed.frontmatter;
+  const instructions = parsed.markdown;
+  if (!frontmatter.name || !frontmatter.description) {
+    throw new Error(`Invalid SKILL.md at ${filePath}: name and description required`);
+  }
+  return {
+    name: frontmatter.name,
+    description: frontmatter.description,
+    instructions: instructions.trim(),
+    capabilityId
+  };
+}
+async function loadSubagents(capabilityPath, capabilityId) {
+  const subagentsDir = join5(capabilityPath, "subagents");
+  if (!existsSync6(subagentsDir)) {
+    return [];
+  }
+  const subagents = [];
+  const entries = readdirSync5(subagentsDir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
+  for (const entry of entries) {
+    if (entry.isDirectory()) {
+      const subagentPath = join5(subagentsDir, entry.name, "SUBAGENT.md");
+      if (existsSync6(subagentPath)) {
+        const subagent = await parseSubagentFile(subagentPath, capabilityId);
+        subagents.push(subagent);
+      }
+    }
+  }
+  return subagents;
+}
+async function parseSubagentFile(filePath, capabilityId) {
+  const content = await Bun.file(filePath).text();
+  const parsed = parseFrontmatterWithMarkdown(content);
+  if (!parsed) {
+    throw new Error(`Invalid SUBAGENT.md format at ${filePath}: missing YAML frontmatter`);
+  }
+  const frontmatter = parsed.frontmatter;
+  const systemPrompt = parsed.markdown;
+  if (!frontmatter.name || !frontmatter.description) {
+    throw new Error(`Invalid SUBAGENT.md at ${filePath}: name and description required`);
+  }
+  const result = {
+    name: frontmatter.name,
+    description: frontmatter.description,
+    systemPrompt: systemPrompt.trim(),
+    capabilityId
+  };
+  if (frontmatter.tools) {
+    result.tools = parseCommaSeparatedList(frontmatter.tools);
+  }
+  if (frontmatter.disallowedTools) {
+    result.disallowedTools = parseCommaSeparatedList(frontmatter.disallowedTools);
+  }
+  if (frontmatter.model) {
+    result.model = frontmatter.model;
+  }
+  if (frontmatter.permissionMode) {
+    result.permissionMode = frontmatter.permissionMode;
+  }
+  if (frontmatter.skills) {
+    result.skills = parseCommaSeparatedList(frontmatter.skills);
+  }
+  if (frontmatter.hooks) {
+    result.hooks = frontmatter.hooks;
+  }
+  return result;
+}
+function parseCommaSeparatedList(value) {
+  return value.split(",").map((item) => item.trim()).filter(Boolean);
+}
+var CAPABILITIES_DIR = ".omni/capabilities";
+async function discoverCapabilities() {
+  const capabilities = [];
+  if (existsSync7(CAPABILITIES_DIR)) {
+    const entries = readdirSync6(CAPABILITIES_DIR, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        const entryPath = join6(CAPABILITIES_DIR, entry.name);
+        const configPath = join6(entryPath, "capability.toml");
+        if (existsSync7(configPath)) {
+          capabilities.push(entryPath);
+        }
+      }
+    }
+  }
+  return capabilities;
+}
+async function loadCapabilityConfig(capabilityPath) {
+  const configPath = join6(capabilityPath, "capability.toml");
+  const content = await Bun.file(configPath).text();
+  const config = parseCapabilityConfig(content);
+  return config;
+}
+async function importCapabilityExports(capabilityPath) {
+  const indexPath = join6(capabilityPath, "index.ts");
+  if (!existsSync7(indexPath)) {
+    return {};
+  }
+  try {
+    const absolutePath = join6(process.cwd(), indexPath);
+    const module = await import(absolutePath);
+    return module;
+  } catch (error) {
+    const errorMessage = String(error);
+    if (errorMessage.includes("Cannot find module")) {
+      const match = errorMessage.match(/Cannot find module '([^']+)'/);
+      const missingModule = match ? match[1] : "unknown";
+      throw new Error(`Missing dependency '${missingModule}' for capability at ${capabilityPath}.
+If this is a project-specific capability, install dependencies or remove it from .omni/capabilities/`);
+    }
+    throw new Error(`Failed to import capability at ${capabilityPath}: ${error}`);
+  }
+}
+async function loadTypeDefinitions(capabilityPath) {
+  const typesPath = join6(capabilityPath, "types.d.ts");
+  if (!existsSync7(typesPath)) {
+    return;
+  }
+  return Bun.file(typesPath).text();
+}
+function convertSkillExports(skillExports, capabilityId) {
+  return skillExports.map((skillExport) => {
+    const exportObj = skillExport;
+    const lines = exportObj.skillMd.split(`
+`);
+    let name = "unnamed";
+    let description = "";
+    let instructions = exportObj.skillMd;
+    if (lines[0]?.trim() === "---") {
+      const endIndex = lines.findIndex((line, i) => i > 0 && line.trim() === "---");
+      if (endIndex > 0) {
+        const frontmatter = lines.slice(1, endIndex);
+        instructions = lines.slice(endIndex + 1).join(`
+`).trim();
+        for (const line of frontmatter) {
+          const match = line.match(/^(\w+):\s*(.+)$/);
+          if (match?.[1] && match[2]) {
+            const key = match[1];
+            const value = match[2];
+            if (key === "name") {
+              name = value.replace(/^["']|["']$/g, "");
+            } else if (key === "description") {
+              description = value.replace(/^["']|["']$/g, "");
+            }
+          }
+        }
+      }
+    }
+    return {
+      name,
+      description,
+      instructions,
+      capabilityId
+    };
+  });
+}
+function convertRuleExports(ruleExports, capabilityId) {
+  return ruleExports.map((ruleExport, index) => {
+    return {
+      name: `rule-${index + 1}`,
+      content: String(ruleExport).trim(),
+      capabilityId
+    };
+  });
+}
+function convertDocExports(docExports, capabilityId) {
+  return docExports.map((docExport) => {
+    const exportObj = docExport;
+    return {
+      name: exportObj.title,
+      content: exportObj.content.trim(),
+      capabilityId
+    };
+  });
+}
+function convertSubagentExports(subagentExports, capabilityId) {
+  return subagentExports.map((subagentExport) => {
+    const exportObj = subagentExport;
+    const lines = exportObj.subagentMd.split(`
+`);
+    let name = "unnamed";
+    let description = "";
+    let systemPrompt = exportObj.subagentMd;
+    let tools;
+    let disallowedTools;
+    let model;
+    let permissionMode;
+    let skills;
+    if (lines[0]?.trim() === "---") {
+      const endIndex = lines.findIndex((line, i) => i > 0 && line.trim() === "---");
+      if (endIndex > 0) {
+        const frontmatter = lines.slice(1, endIndex);
+        systemPrompt = lines.slice(endIndex + 1).join(`
+`).trim();
+        for (const line of frontmatter) {
+          const match = line.match(/^(\w+):\s*(.+)$/);
+          if (match?.[1] && match[2]) {
+            const key = match[1];
+            const value = match[2].replace(/^["']|["']$/g, "");
+            switch (key) {
+              case "name":
+                name = value;
+                break;
+              case "description":
+                description = value;
+                break;
+              case "tools":
+                tools = value.split(",").map((t) => t.trim());
+                break;
+              case "disallowedTools":
+                disallowedTools = value.split(",").map((t) => t.trim());
+                break;
+              case "model":
+                model = value;
+                break;
+              case "permissionMode":
+                permissionMode = value;
+                break;
+              case "skills":
+                skills = value.split(",").map((s) => s.trim());
+                break;
+            }
+          }
+        }
+      }
+    }
+    const result = {
+      name,
+      description,
+      systemPrompt,
+      capabilityId
+    };
+    if (tools)
+      result.tools = tools;
+    if (disallowedTools)
+      result.disallowedTools = disallowedTools;
+    if (model) {
+      result.model = model;
+    }
+    if (permissionMode) {
+      result.permissionMode = permissionMode;
+    }
+    if (skills)
+      result.skills = skills;
+    return result;
+  });
+}
+function convertCommandExports(commandExports, capabilityId) {
+  return commandExports.map((commandExport) => {
+    const exportObj = commandExport;
+    const lines = exportObj.commandMd.split(`
+`);
+    let name = "unnamed";
+    let description = "";
+    let prompt = exportObj.commandMd;
+    let allowedTools;
+    if (lines[0]?.trim() === "---") {
+      const endIndex = lines.findIndex((line, i) => i > 0 && line.trim() === "---");
+      if (endIndex > 0) {
+        const frontmatter = lines.slice(1, endIndex);
+        prompt = lines.slice(endIndex + 1).join(`
+`).trim();
+        for (const line of frontmatter) {
+          const match = line.match(/^(\w+):\s*(.+)$/);
+          if (match?.[1] && match[2]) {
+            const key = match[1];
+            const value = match[2].replace(/^["']|["']$/g, "");
+            switch (key) {
+              case "name":
+                name = value;
+                break;
+              case "description":
+                description = value;
+                break;
+              case "allowedTools":
+              case "allowed-tools":
+                allowedTools = value;
+                break;
+            }
+          }
+        }
+      }
+    }
+    const result = {
+      name,
+      description,
+      prompt,
+      capabilityId
+    };
+    if (allowedTools) {
+      result.allowedTools = allowedTools;
+    }
+    return result;
+  });
+}
+async function loadCapability(capabilityPath, env) {
+  const config = await loadCapabilityConfig(capabilityPath);
+  const id = config.capability.id;
+  if (config.env) {
+    validateEnv(config.env, env, id);
+  }
+  const exports = await importCapabilityExports(capabilityPath);
+  const exportsAny = exports;
+  const skills = "skills" in exports && Array.isArray(exportsAny.skills) ? convertSkillExports(exportsAny.skills, id) : await loadSkills(capabilityPath, id);
+  const rules = "rules" in exports && Array.isArray(exportsAny.rules) ? convertRuleExports(exportsAny.rules, id) : await loadRules(capabilityPath, id);
+  const docs = "docs" in exports && Array.isArray(exportsAny.docs) ? convertDocExports(exportsAny.docs, id) : await loadDocs(capabilityPath, id);
+  const subagents = "subagents" in exports && Array.isArray(exportsAny.subagents) ? convertSubagentExports(exportsAny.subagents, id) : await loadSubagents(capabilityPath, id);
+  const commands = "commands" in exports && Array.isArray(exportsAny.commands) ? convertCommandExports(exportsAny.commands, id) : await loadCommands(capabilityPath, id);
+  const typeDefinitionsFromExports = "typeDefinitions" in exports && typeof exportsAny.typeDefinitions === "string" ? exportsAny.typeDefinitions : undefined;
+  const typeDefinitions = typeDefinitionsFromExports !== undefined ? typeDefinitionsFromExports : await loadTypeDefinitions(capabilityPath);
+  const gitignore = "gitignore" in exports && Array.isArray(exportsAny.gitignore) ? exportsAny.gitignore : undefined;
+  const result = {
+    id,
+    path: capabilityPath,
+    config,
+    skills,
+    rules,
+    docs,
+    subagents,
+    commands,
+    exports
+  };
+  if (typeDefinitions !== undefined) {
+    result.typeDefinitions = typeDefinitions;
+  }
+  if (gitignore !== undefined) {
+    result.gitignore = gitignore;
+  }
+  return result;
+}
+var CONFIG_PATH = "omni.toml";
+var LOCAL_CONFIG = "omni.local.toml";
+function mergeConfigs(base, override) {
+  const merged = { ...base, ...override };
+  merged.env = { ...base.env, ...override.env };
+  merged.profiles = { ...base.profiles };
+  for (const [name, profile] of Object.entries(override.profiles || {})) {
+    merged.profiles[name] = {
+      ...base.profiles?.[name] || {},
+      ...profile
+    };
+  }
+  if (base.mcps || override.mcps) {
+    merged.mcps = { ...base.mcps, ...override.mcps };
+  }
+  return merged;
+}
+async function loadConfig() {
+  let baseConfig = {};
+  let localConfig = {};
+  if (existsSync8(CONFIG_PATH)) {
+    const content = await Bun.file(CONFIG_PATH).text();
+    baseConfig = parseOmniConfig(content);
+  }
+  if (existsSync8(LOCAL_CONFIG)) {
+    const content = await Bun.file(LOCAL_CONFIG).text();
+    localConfig = parseOmniConfig(content);
+  }
+  return mergeConfigs(baseConfig, localConfig);
+}
+async function writeConfig(config) {
+  const content = generateConfigToml(config);
+  await Bun.write(CONFIG_PATH, content);
+}
+function generateConfigToml(config) {
+  const lines = [];
+  lines.push("# =============================================================================");
+  lines.push("# OmniDev Configuration");
+  lines.push("# =============================================================================");
+  lines.push("# This file defines your project's capabilities, profiles, and settings.");
+  lines.push("#");
+  lines.push("# Files:");
+  lines.push("#   • omni.toml - Main config (commit to share with team)");
+  lines.push("#   • omni.local.toml - Local overrides (add to .gitignore)");
+  lines.push("#   • omni.lock.toml - Version lock file (commit for reproducibility)");
+  lines.push("#");
+  lines.push("# Quick start:");
+  lines.push("#   1. Add capability sources to [capabilities.sources]");
+  lines.push("#   2. Reference them in your profiles");
+  lines.push("#   3. Run: omnidev sync");
+  lines.push("#   4. Switch profiles: omnidev profile use <name>");
+  lines.push("");
+  if (config.project) {
+    lines.push(`project = "${config.project}"`);
+    lines.push("");
+  }
+  if (config.providers?.enabled && config.providers.enabled.length > 0) {
+    lines.push("# AI providers to enable (claude, codex, or both)");
+    lines.push("[providers]");
+    lines.push(`enabled = [${config.providers.enabled.map((p) => `"${p}"`).join(", ")}]`);
+    lines.push("");
+  }
+  lines.push("# =============================================================================");
+  lines.push("# Environment Variables");
+  lines.push("# =============================================================================");
+  lines.push("# Global environment variables available to all capabilities.");
+  lines.push("# Use ${VAR_NAME} syntax to reference shell environment variables.");
+  lines.push("#");
+  if (config.env && Object.keys(config.env).length > 0) {
+    lines.push("[env]");
+    for (const [key, value] of Object.entries(config.env)) {
+      lines.push(`${key} = "${value}"`);
+    }
+  } else {
+    lines.push("# [env]");
+    lines.push('# DATABASE_URL = "${DATABASE_URL}"');
+    lines.push('# API_KEY = "${MY_API_KEY}"');
+  }
+  lines.push("");
+  lines.push("# =============================================================================");
+  lines.push("# Capability Sources");
+  lines.push("# =============================================================================");
+  lines.push("# Fetch capabilities from Git repositories. On sync, these are");
+  lines.push("# cloned/updated and made available to your profiles.");
+  lines.push("#");
+  lines.push("# [capabilities.sources]");
+  lines.push("# # GitHub shorthand (uses latest commit)");
+  lines.push('# tasks = "github:example-org/tasks-capability"');
+  lines.push("#");
+  lines.push("# # Version pinning (recommended for production)");
+  lines.push('# ralph = { source = "github:example-org/ralph", ref = "v1.2.0" }');
+  lines.push("#");
+  lines.push("# # Other Git sources");
+  lines.push('# private = "git@github.com:company/private-cap.git"');
+  lines.push('# gitlab = "https://gitlab.com/user/capability.git"');
+  lines.push("");
+  lines.push("# =============================================================================");
+  lines.push("# MCP Servers");
+  lines.push("# =============================================================================");
+  lines.push("# Define MCP servers that automatically become capabilities.");
+  lines.push('# Reference in profiles using the MCP name directly, e.g. capabilities = ["filesystem"]');
+  lines.push("#");
+  lines.push("# [mcps.filesystem]");
+  lines.push('# command = "npx"');
+  lines.push('# args = ["-y", "@modelcontextprotocol/server-filesystem", "/path/to/dir"]');
+  lines.push('# transport = "stdio"  # stdio (default), sse, or http');
+  lines.push("#");
+  lines.push("# [mcps.database]");
+  lines.push('# command = "node"');
+  lines.push('# args = ["./servers/database.js"]');
+  lines.push('# cwd = "./mcp-servers"');
+  lines.push("# [mcps.database.env]");
+  lines.push('# DB_URL = "${DATABASE_URL}"');
+  lines.push("");
+  lines.push("# =============================================================================");
+  lines.push("# Always Enabled Capabilities");
+  lines.push("# =============================================================================");
+  lines.push("# Capabilities that load in ALL profiles, regardless of profile config.");
+  lines.push("# Useful for essential tools needed everywhere.");
+  lines.push("#");
+  lines.push('# always_enabled_capabilities = ["git-tools", "linting"]');
+  lines.push("");
+  lines.push("# =============================================================================");
+  lines.push("# Profiles");
+  lines.push("# =============================================================================");
+  lines.push("# Define different capability sets for different workflows.");
+  lines.push("# Switch profiles with: omnidev profile use <name>");
+  lines.push("");
+  if (config.profiles && Object.keys(config.profiles).length > 0) {
+    for (const [name, profile] of Object.entries(config.profiles)) {
+      lines.push(`[profiles.${name}]`);
+      const capabilities = profile.capabilities ?? [];
+      if (capabilities.length > 0) {
+        lines.push(`capabilities = [${capabilities.map((id) => `"${id}"`).join(", ")}]`);
+      } else {
+        lines.push("capabilities = []");
+      }
+      lines.push("");
+    }
+  }
+  return lines.join(`
+`);
+}
+var STATE_DIR = ".omni/state";
+var ACTIVE_PROFILE_PATH = `${STATE_DIR}/active-profile`;
+async function readActiveProfileState() {
+  if (!existsSync9(ACTIVE_PROFILE_PATH)) {
+    return null;
+  }
+  try {
+    const content = await Bun.file(ACTIVE_PROFILE_PATH).text();
+    const trimmed = content.trim();
+    return trimmed || null;
+  } catch {
+    return null;
+  }
+}
+async function writeActiveProfileState(profileName) {
+  mkdirSync(STATE_DIR, { recursive: true });
+  await Bun.write(ACTIVE_PROFILE_PATH, profileName);
+}
+async function clearActiveProfileState() {
+  if (existsSync9(ACTIVE_PROFILE_PATH)) {
+    const file = Bun.file(ACTIVE_PROFILE_PATH);
+    await file.delete();
+  }
+}
+async function getActiveProfile() {
+  const stateProfile = await readActiveProfileState();
+  if (stateProfile) {
+    return stateProfile;
+  }
+  const config = await loadConfig();
+  return config.active_profile ?? null;
+}
+async function setActiveProfile(name) {
+  await writeActiveProfileState(name);
+}
+function resolveEnabledCapabilities(config, profileName) {
+  const profile = profileName ? config.profiles?.[profileName] : config.profiles?.[config.active_profile ?? "default"];
+  const profileCapabilities = profile?.capabilities ?? [];
+  const alwaysEnabled = config.always_enabled_capabilities ?? [];
+  return [...new Set([...alwaysEnabled, ...profileCapabilities])];
+}
+async function loadProfileConfig(profileName) {
+  const config = await loadConfig();
+  return config.profiles?.[profileName];
+}
+async function setProfile(profileName, profileConfig) {
+  const config = await loadConfig();
+  if (!config.profiles) {
+    config.profiles = {};
+  }
+  config.profiles[profileName] = profileConfig;
+  await writeConfig(config);
+}
+async function getEnabledCapabilities() {
+  const config = await loadConfig();
+  const activeProfile = await getActiveProfile() ?? config.active_profile ?? "default";
+  return resolveEnabledCapabilities(config, activeProfile);
+}
+async function enableCapability(capabilityId) {
+  const config = await loadConfig();
+  const activeProfile = await getActiveProfile() ?? config.active_profile ?? "default";
+  if (!config.profiles) {
+    config.profiles = {};
+  }
+  if (!config.profiles[activeProfile]) {
+    config.profiles[activeProfile] = { capabilities: [] };
+  }
+  const capabilities = new Set(config.profiles[activeProfile].capabilities ?? []);
+  capabilities.add(capabilityId);
+  config.profiles[activeProfile].capabilities = Array.from(capabilities);
+  await writeConfig(config);
+}
+async function disableCapability(capabilityId) {
+  const config = await loadConfig();
+  const activeProfile = await getActiveProfile() ?? config.active_profile ?? "default";
+  if (!config.profiles?.[activeProfile]) {
+    return;
+  }
+  const capabilities = new Set(config.profiles[activeProfile].capabilities ?? []);
+  capabilities.delete(capabilityId);
+  config.profiles[activeProfile].capabilities = Array.from(capabilities);
+  await writeConfig(config);
+}
+async function buildCapabilityRegistry() {
+  const env = await loadEnvironment();
+  const enabledIds = await getEnabledCapabilities();
+  const capabilityPaths = await discoverCapabilities();
+  const capabilities = new Map;
+  for (const path of capabilityPaths) {
+    try {
+      const cap = await loadCapability(path, env);
+      if (enabledIds.includes(cap.id)) {
+        capabilities.set(cap.id, cap);
+      }
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      console.warn(`Warning: Skipping capability at ${path}`);
+      console.warn(`  ${errorMessage}`);
+    }
+  }
+  return {
+    capabilities,
+    getCapability: (id) => capabilities.get(id),
+    getAllCapabilities: () => [...capabilities.values()],
+    getAllSkills: () => [...capabilities.values()].flatMap((c) => c.skills),
+    getAllRules: () => [...capabilities.values()].flatMap((c) => c.rules),
+    getAllDocs: () => [...capabilities.values()].flatMap((c) => c.docs)
+  };
+}
+var OMNI_LOCAL = ".omni";
+var SKILL_DIRS = ["skills", "skill"];
+var AGENT_DIRS = ["agents", "agent", "subagents", "subagent"];
+var COMMAND_DIRS = ["commands", "command"];
+var RULE_DIRS = ["rules", "rule"];
+var DOC_DIRS = ["docs", "doc", "documentation"];
+var SKILL_FILES = ["SKILL.md", "skill.md", "Skill.md"];
+var AGENT_FILES = ["AGENT.md", "agent.md", "Agent.md", "SUBAGENT.md", "subagent.md"];
+var COMMAND_FILES = ["COMMAND.md", "command.md", "Command.md"];
+function parseSourceConfig(source) {
+  if (typeof source === "string") {
+    let sourceUrl = source;
+    let ref;
+    if (source.startsWith("github:") && source.includes("#")) {
+      const parts = source.split("#");
+      sourceUrl = parts[0] ?? source;
+      ref = parts[1];
+    }
+    const result = { source: sourceUrl };
+    if (ref) {
+      result.ref = ref;
+    }
+    return result;
+  }
+  return source;
+}
+function sourceToGitUrl(source) {
+  if (source.startsWith("github:")) {
+    const repo = source.replace("github:", "");
+    return `https://github.com/${repo}.git`;
+  }
+  return source;
+}
+function getSourceCapabilityPath(id) {
+  return join7(OMNI_LOCAL, "capabilities", id);
+}
+function getLockFilePath() {
+  return "omni.lock.toml";
+}
+async function loadLockFile() {
+  const lockPath = getLockFilePath();
+  if (!existsSync10(lockPath)) {
+    return { capabilities: {} };
+  }
+  try {
+    const content = await readFile(lockPath, "utf-8");
+    const parsed = parse(content);
+    const capabilities = parsed["capabilities"];
+    return {
+      capabilities: capabilities || {}
+    };
+  } catch {
+    return { capabilities: {} };
+  }
+}
+function stringifyLockFile(lockFile) {
+  const lines = [];
+  for (const [id, entry] of Object.entries(lockFile.capabilities)) {
+    lines.push(`[capabilities.${id}]`);
+    lines.push(`source = "${entry.source}"`);
+    lines.push(`version = "${entry.version}"`);
+    if (entry.commit) {
+      lines.push(`commit = "${entry.commit}"`);
+    }
+    if (entry.ref) {
+      lines.push(`ref = "${entry.ref}"`);
+    }
+    lines.push(`updated_at = "${entry.updated_at}"`);
+    lines.push("");
+  }
+  return lines.join(`
+`);
+}
+async function saveLockFile(lockFile) {
+  const lockPath = getLockFilePath();
+  await mkdir(join7(OMNI_LOCAL, "capabilities"), { recursive: true });
+  const header = `# Auto-generated by OmniDev - DO NOT EDIT
+# Records installed capability versions for reproducibility
+# Last updated: ${new Date().toISOString()}
+
+`;
+  const content = header + stringifyLockFile(lockFile);
+  await writeFile(lockPath, content, "utf-8");
+}
+async function getRepoCommit(repoPath) {
+  const proc = Bun.spawn(["git", "rev-parse", "HEAD"], {
+    cwd: repoPath,
+    stdout: "pipe",
+    stderr: "pipe"
+  });
+  const output = await new Response(proc.stdout).text();
+  await proc.exited;
+  return output.trim();
+}
+function shortCommit(commit) {
+  return commit.substring(0, 7);
+}
+async function cloneRepo(gitUrl, targetPath, ref) {
+  await mkdir(join7(targetPath, ".."), { recursive: true });
+  const args = ["clone", "--depth", "1"];
+  if (ref) {
+    args.push("--branch", ref);
+  }
+  args.push(gitUrl, targetPath);
+  const proc = Bun.spawn(["git", ...args], {
+    stdout: "pipe",
+    stderr: "pipe"
+  });
+  await proc.exited;
+  if (proc.exitCode !== 0) {
+    const stderr = await new Response(proc.stderr).text();
+    throw new Error(`Failed to clone ${gitUrl}: ${stderr}`);
+  }
+}
+async function fetchRepo(repoPath, ref) {
+  const fetchProc = Bun.spawn(["git", "fetch", "--depth", "1", "origin"], {
+    cwd: repoPath,
+    stdout: "pipe",
+    stderr: "pipe"
+  });
+  await fetchProc.exited;
+  const currentCommit = await getRepoCommit(repoPath);
+  const targetRef = ref || "HEAD";
+  const lsProc = Bun.spawn(["git", "ls-remote", "origin", targetRef], {
+    cwd: repoPath,
+    stdout: "pipe",
+    stderr: "pipe"
+  });
+  const lsOutput = await new Response(lsProc.stdout).text();
+  await lsProc.exited;
+  const remoteCommit = lsOutput.split("\t")[0];
+  if (currentCommit === remoteCommit) {
+    return false;
+  }
+  const pullProc = Bun.spawn(["git", "pull", "--ff-only"], {
+    cwd: repoPath,
+    stdout: "pipe",
+    stderr: "pipe"
+  });
+  await pullProc.exited;
+  return true;
+}
+function hasCapabilityToml(dirPath) {
+  return existsSync10(join7(dirPath, "capability.toml"));
+}
+async function shouldWrapDirectory(dirPath) {
+  if (existsSync10(join7(dirPath, ".claude-plugin", "plugin.json"))) {
+    return true;
+  }
+  const allDirs = [...SKILL_DIRS, ...AGENT_DIRS, ...COMMAND_DIRS, ...RULE_DIRS, ...DOC_DIRS];
+  for (const dirName of allDirs) {
+    const checkPath = join7(dirPath, dirName);
+    if (existsSync10(checkPath)) {
+      const stats = await stat(checkPath);
+      if (stats.isDirectory()) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+async function findMatchingDirs(basePath, names) {
+  for (const name of names) {
+    const dirPath = join7(basePath, name);
+    if (existsSync10(dirPath)) {
+      const stats = await stat(dirPath);
+      if (stats.isDirectory()) {
+        return dirPath;
+      }
+    }
+  }
+  return null;
+}
+async function findContentItems(dirPath, filePatterns) {
+  const items = [];
+  if (!existsSync10(dirPath)) {
+    return items;
+  }
+  const entries = (await readdir(dirPath, { withFileTypes: true })).sort((a, b) => a.name.localeCompare(b.name));
+  for (const entry of entries) {
+    const entryPath = join7(dirPath, entry.name);
+    if (entry.isDirectory()) {
+      for (const pattern of filePatterns) {
+        if (existsSync10(join7(entryPath, pattern))) {
+          items.push({
+            name: entry.name,
+            path: entryPath,
+            isFolder: true
+          });
+          break;
+        }
+      }
+    } else if (entry.isFile() && entry.name.endsWith(".md")) {
+      const name = entry.name.replace(/\.md$/i, "");
+      items.push({
+        name,
+        path: entryPath,
+        isFolder: false
+      });
+    }
+  }
+  return items;
+}
+async function parsePluginJson(dirPath) {
+  const pluginJsonPath = join7(dirPath, ".claude-plugin", "plugin.json");
+  if (!existsSync10(pluginJsonPath)) {
+    return null;
+  }
+  try {
+    const content = await readFile(pluginJsonPath, "utf-8");
+    const data = JSON.parse(content);
+    const result = {
+      name: data.name,
+      version: data.version,
+      description: data.description
+    };
+    if (data.author) {
+      result.author = {
+        name: data.author.name,
+        email: data.author.email
+      };
+    }
+    return result;
+  } catch (error) {
+    console.warn(`Failed to parse plugin.json in ${dirPath}:`, error);
+    return null;
+  }
+}
+async function readReadmeDescription(dirPath) {
+  const readmePath = join7(dirPath, "README.md");
+  if (!existsSync10(readmePath)) {
+    return null;
+  }
+  try {
+    const content = await readFile(readmePath, "utf-8");
+    const lines = content.split(`
+`);
+    let description = "";
+    let inCodeBlock = false;
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (trimmed.startsWith("```")) {
+        inCodeBlock = !inCodeBlock;
+        continue;
+      }
+      if (inCodeBlock || trimmed.startsWith("#") || trimmed.length === 0 || trimmed.startsWith("![")) {
+        continue;
+      }
+      description += (description ? " " : "") + trimmed;
+      if (description.length >= 200) {
+        break;
+      }
+    }
+    if (description.length > 200) {
+      description = `${description.substring(0, 197)}...`;
+    }
+    return description || null;
+  } catch (error) {
+    console.warn(`Failed to read README.md in ${dirPath}:`, error);
+    return null;
+  }
+}
+async function discoverContent(repoPath) {
+  const result = {
+    skills: [],
+    agents: [],
+    commands: [],
+    rulesDir: null,
+    docsDir: null
+  };
+  const skillsDir = await findMatchingDirs(repoPath, SKILL_DIRS);
+  if (skillsDir) {
+    result.skills = await findContentItems(skillsDir, SKILL_FILES);
+  }
+  const agentsDir = await findMatchingDirs(repoPath, AGENT_DIRS);
+  if (agentsDir) {
+    result.agents = await findContentItems(agentsDir, AGENT_FILES);
+  }
+  const commandsDir = await findMatchingDirs(repoPath, COMMAND_DIRS);
+  if (commandsDir) {
+    result.commands = await findContentItems(commandsDir, COMMAND_FILES);
+  }
+  result.rulesDir = await findMatchingDirs(repoPath, RULE_DIRS);
+  result.docsDir = await findMatchingDirs(repoPath, DOC_DIRS);
+  return result;
+}
+async function generateCapabilityToml(id, repoPath, source, commit, content) {
+  const shortHash = shortCommit(commit);
+  const pluginMeta = await parsePluginJson(repoPath);
+  const readmeDesc = await readReadmeDescription(repoPath);
+  let description;
+  if (pluginMeta?.description) {
+    description = pluginMeta.description;
+  } else if (readmeDesc) {
+    description = readmeDesc;
+  } else {
+    const parts = [];
+    if (content.skills.length > 0) {
+      parts.push(`${content.skills.length} skill${content.skills.length > 1 ? "s" : ""}`);
+    }
+    if (content.agents.length > 0) {
+      parts.push(`${content.agents.length} agent${content.agents.length > 1 ? "s" : ""}`);
+    }
+    if (content.commands.length > 0) {
+      parts.push(`${content.commands.length} command${content.commands.length > 1 ? "s" : ""}`);
+    }
+    description = parts.length > 0 ? `${parts.join(", ")}` : `Wrapped from ${source}`;
+  }
+  const name = pluginMeta?.name || `${id} (wrapped)`;
+  const version = pluginMeta?.version || shortHash;
+  const repoUrl = source.startsWith("github:") ? `https://github.com/${source.replace("github:", "")}` : source;
+  let tomlContent = `# Auto-generated by OmniDev - DO NOT EDIT
+# This capability was wrapped from an external repository
+
+[capability]
+id = "${id}"
+name = "${name}"
+version = "${version}"
+description = "${description}"
+`;
+  if (pluginMeta?.author?.name || pluginMeta?.author?.email) {
+    tomlContent += `
+[capability.author]
+`;
+    if (pluginMeta.author.name) {
+      tomlContent += `name = "${pluginMeta.author.name}"
+`;
+    }
+    if (pluginMeta.author.email) {
+      tomlContent += `email = "${pluginMeta.author.email}"
+`;
+    }
+  }
+  tomlContent += `
+[capability.metadata]
+repository = "${repoUrl}"
+wrapped = true
+commit = "${commit}"
+`;
+  await writeFile(join7(repoPath, "capability.toml"), tomlContent, "utf-8");
+}
+async function fetchGitCapabilitySource(id, config, options) {
+  const gitUrl = sourceToGitUrl(config.source);
+  const targetPath = getSourceCapabilityPath(id);
+  let updated = false;
+  let commit;
+  let repoPath;
+  if (config.path) {
+    const tempPath = join7(OMNI_LOCAL, "_temp", `${id}-repo`);
+    if (existsSync10(join7(tempPath, ".git"))) {
+      if (!options?.silent) {
+        console.log(`  Checking ${id}...`);
+      }
+      updated = await fetchRepo(tempPath, config.ref);
+      commit = await getRepoCommit(tempPath);
+    } else {
+      if (!options?.silent) {
+        console.log(`  Cloning ${id} from ${config.source}...`);
+      }
+      await mkdir(join7(tempPath, ".."), { recursive: true });
+      await cloneRepo(gitUrl, tempPath, config.ref);
+      commit = await getRepoCommit(tempPath);
+      updated = true;
+    }
+    const sourcePath = join7(tempPath, config.path);
+    if (!existsSync10(sourcePath)) {
+      throw new Error(`Path not found in repository: ${config.path}`);
+    }
+    if (existsSync10(targetPath)) {
+      await rm(targetPath, { recursive: true });
+    }
+    await mkdir(join7(targetPath, ".."), { recursive: true });
+    await cp(sourcePath, targetPath, { recursive: true });
+    repoPath = targetPath;
+  } else {
+    if (existsSync10(join7(targetPath, ".git"))) {
+      if (!options?.silent) {
+        console.log(`  Checking ${id}...`);
+      }
+      updated = await fetchRepo(targetPath, config.ref);
+      commit = await getRepoCommit(targetPath);
+    } else {
+      if (!options?.silent) {
+        console.log(`  Cloning ${id} from ${config.source}...`);
+      }
+      await cloneRepo(gitUrl, targetPath, config.ref);
+      commit = await getRepoCommit(targetPath);
+      updated = true;
+    }
+    repoPath = targetPath;
+  }
+  let needsWrap = false;
+  if (!hasCapabilityToml(repoPath)) {
+    needsWrap = await shouldWrapDirectory(repoPath);
+  }
+  if (needsWrap) {
+    const content = await discoverContent(repoPath);
+    await generateCapabilityToml(id, repoPath, config.source, commit, content);
+    if (!options?.silent) {
+      const parts = [];
+      if (content.skills.length > 0)
+        parts.push(`${content.skills.length} skills`);
+      if (content.agents.length > 0)
+        parts.push(`${content.agents.length} agents`);
+      if (content.commands.length > 0)
+        parts.push(`${content.commands.length} commands`);
+      if (parts.length > 0) {
+        console.log(`    Wrapped: ${parts.join(", ")}`);
+      }
+    }
+  }
+  let version = shortCommit(commit);
+  const pkgJsonPath = join7(repoPath, "package.json");
+  if (existsSync10(pkgJsonPath)) {
+    try {
+      const pkgJson = JSON.parse(await readFile(pkgJsonPath, "utf-8"));
+      if (pkgJson.version) {
+        version = pkgJson.version;
+      }
+    } catch {}
+  }
+  return {
+    id,
+    path: targetPath,
+    version,
+    commit,
+    updated,
+    wrapped: needsWrap
+  };
+}
+async function fetchCapabilitySource(id, sourceConfig, options) {
+  const config = parseSourceConfig(sourceConfig);
+  return fetchGitCapabilitySource(id, config, options);
+}
+function generateMcpCapabilityTomlContent(id, mcpConfig) {
+  let tomlContent = `# Auto-generated by OmniDev from omni.toml [mcps] section - DO NOT EDIT
+
+[capability]
+id = "${id}"
+name = "${id} (MCP)"
+version = "1.0.0"
+description = "MCP server defined in omni.toml"
+
+[capability.metadata]
+wrapped = true
+generated_from_omni_toml = true
+
+[mcp]
+command = "${mcpConfig.command}"
+`;
+  if (mcpConfig.args && mcpConfig.args.length > 0) {
+    tomlContent += `args = ${JSON.stringify(mcpConfig.args)}
+`;
+  }
+  if (mcpConfig.transport) {
+    tomlContent += `transport = "${mcpConfig.transport}"
+`;
+  }
+  if (mcpConfig.cwd) {
+    tomlContent += `cwd = "${mcpConfig.cwd}"
+`;
+  }
+  if (mcpConfig.env && Object.keys(mcpConfig.env).length > 0) {
+    tomlContent += `
+[mcp.env]
+`;
+    for (const [key, value] of Object.entries(mcpConfig.env)) {
+      tomlContent += `${key} = "${value}"
+`;
+    }
+  }
+  return tomlContent;
+}
+async function generateMcpCapabilityToml(id, mcpConfig, targetPath) {
+  const tomlContent = generateMcpCapabilityTomlContent(id, mcpConfig);
+  await writeFile(join7(targetPath, "capability.toml"), tomlContent, "utf-8");
+}
+async function isGeneratedMcpCapability(capabilityDir) {
+  const tomlPath = join7(capabilityDir, "capability.toml");
+  if (!existsSync10(tomlPath)) {
+    console.warn("no capability.toml found in", capabilityDir);
+    return false;
+  }
+  try {
+    const content = await readFile(tomlPath, "utf-8");
+    const parsed = parse(content);
+    const capability = parsed["capability"];
+    const metadata = capability?.["metadata"];
+    return metadata?.["generated_from_omni_toml"] === true;
+  } catch {
+    return false;
+  }
+}
+async function cleanupStaleMcpCapabilities(currentMcpIds) {
+  const capabilitiesDir = join7(OMNI_LOCAL, "capabilities");
+  if (!existsSync10(capabilitiesDir)) {
+    return;
+  }
+  const entries = await readdir(capabilitiesDir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.isDirectory()) {
+      const capDir = join7(capabilitiesDir, entry.name);
+      const isGenerated = await isGeneratedMcpCapability(capDir);
+      if (isGenerated && !currentMcpIds.has(entry.name)) {
+        await rm(capDir, { recursive: true });
+      }
+    }
+  }
+}
+async function generateMcpCapabilities(config) {
+  if (!config.mcps || Object.keys(config.mcps).length === 0) {
+    await cleanupStaleMcpCapabilities(new Set);
+    return;
+  }
+  const mcpCapabilitiesDir = join7(OMNI_LOCAL, "capabilities");
+  const currentMcpIds = new Set;
+  for (const [id, mcpConfig] of Object.entries(config.mcps)) {
+    const targetPath = join7(mcpCapabilitiesDir, id);
+    currentMcpIds.add(id);
+    await mkdir(targetPath, { recursive: true });
+    await generateMcpCapabilityToml(id, mcpConfig, targetPath);
+  }
+  await cleanupStaleMcpCapabilities(currentMcpIds);
+}
+async function fetchAllCapabilitySources(config, options) {
+  await generateMcpCapabilities(config);
+  const sources = config.capabilities?.sources;
+  if (!sources || Object.keys(sources).length === 0) {
+    return [];
+  }
+  if (!options?.silent) {
+    console.log("Fetching capability sources...");
+  }
+  const results = [];
+  const lockFile = await loadLockFile();
+  let lockUpdated = false;
+  for (const [id, source] of Object.entries(sources)) {
+    try {
+      const result = await fetchCapabilitySource(id, source, options);
+      results.push(result);
+      const lockEntry = {
+        source: typeof source === "string" ? source : source.source,
+        version: result.version,
+        updated_at: new Date().toISOString()
+      };
+      const gitConfig = parseSourceConfig(source);
+      if (result.commit) {
+        lockEntry.commit = result.commit;
+      }
+      if (gitConfig.ref) {
+        lockEntry.ref = gitConfig.ref;
+      }
+      const existing = lockFile.capabilities[id];
+      const hasChanged = !existing || existing.commit !== result.commit;
+      if (hasChanged) {
+        lockFile.capabilities[id] = lockEntry;
+        lockUpdated = true;
+        if (!options?.silent && result.updated) {
+          const oldVersion = existing?.version || "new";
+          console.log(`  ${result.wrapped ? "+" : "~"} ${id}: ${oldVersion} -> ${result.version}`);
+        }
+      }
+    } catch (error) {
+      console.error(`  Failed to fetch ${id}: ${error}`);
+    }
+  }
+  if (lockUpdated) {
+    await saveLockFile(lockFile);
+  }
+  if (!options?.silent && results.length > 0) {
+    const updated = results.filter((r) => r.updated).length;
+    if (updated > 0) {
+      console.log(`  Updated ${updated} capability source(s)`);
+    } else {
+      console.log(`  All ${results.length} source(s) up to date`);
+    }
+  }
+  return results;
+}
+async function checkForUpdates(config) {
+  const sources = config.capabilities?.sources;
+  if (!sources || Object.keys(sources).length === 0) {
+    return [];
+  }
+  const lockFile = await loadLockFile();
+  const updates = [];
+  for (const [id, source] of Object.entries(sources)) {
+    const sourceConfig = parseSourceConfig(source);
+    const targetPath = getSourceCapabilityPath(id);
+    const existing = lockFile.capabilities[id];
+    const gitConfig = sourceConfig;
+    if (!existsSync10(join7(targetPath, ".git"))) {
+      updates.push({
+        id,
+        source: gitConfig.source,
+        currentVersion: "not installed",
+        latestVersion: "unknown",
+        hasUpdate: true
+      });
+      continue;
+    }
+    const fetchProc = Bun.spawn(["git", "fetch", "--depth", "1", "origin"], {
+      cwd: targetPath,
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    await fetchProc.exited;
+    const targetRef = gitConfig.ref || "HEAD";
+    const lsProc = Bun.spawn(["git", "ls-remote", "origin", targetRef], {
+      cwd: targetPath,
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    const lsOutput = await new Response(lsProc.stdout).text();
+    await lsProc.exited;
+    const remoteCommit = lsOutput.split("\t")[0] || "";
+    const currentCommit = existing?.commit || "";
+    updates.push({
+      id,
+      source: gitConfig.source,
+      currentVersion: existing?.version || (currentCommit ? shortCommit(currentCommit) : "unknown"),
+      latestVersion: remoteCommit ? shortCommit(remoteCommit) : "unknown",
+      hasUpdate: currentCommit !== remoteCommit
+    });
+  }
+  return updates;
+}
+var PROVIDER_CONFIG_PATH = ".omni/provider.toml";
+async function loadProviderConfig() {
+  if (!existsSync11(PROVIDER_CONFIG_PATH)) {
+    return { provider: "claude" };
+  }
+  const content = await Bun.file(PROVIDER_CONFIG_PATH).text();
+  const parsed = parse(content);
+  return parsed;
+}
+async function writeProviderConfig(config) {
+  const lines = [];
+  lines.push("# OmniDev Provider Configuration");
+  lines.push("# Selected AI provider(s) for this project");
+  lines.push("#");
+  lines.push("# This file controls which AI provider(s) you're using:");
+  lines.push("#   - claude: Generates .claude/claude.md instruction file");
+  lines.push("#   - codex:  Generates AGENTS.md instruction file");
+  lines.push("#   - both:   Generates both instruction files");
+  lines.push("");
+  if (config.providers && config.providers.length > 1) {
+    lines.push("# Multiple providers enabled");
+    lines.push(`providers = [${config.providers.map((p) => `"${p}"`).join(", ")}]`);
+  } else if (config.providers && config.providers.length === 1) {
+    lines.push("# Single provider");
+    lines.push(`provider = "${config.providers[0]}"`);
+  } else if (config.provider) {
+    lines.push("# Single provider");
+    lines.push(`provider = "${config.provider}"`);
+  } else {
+    lines.push("# Default: Claude");
+    lines.push('provider = "claude"');
+  }
+  await Bun.write(PROVIDER_CONFIG_PATH, `${lines.join(`
+`)}
+`);
+}
+function parseProviderFlag(flag) {
+  const lower = flag.toLowerCase();
+  if (lower === "both") {
+    return ["claude", "codex"];
+  }
+  if (lower === "claude" || lower === "codex") {
+    return [lower];
+  }
+  throw new Error(`Invalid provider: ${flag}. Must be 'claude', 'codex', or 'both'.`);
+}
+var MCP_JSON_PATH = ".mcp.json";
+async function readMcpJson() {
+  if (!existsSync12(MCP_JSON_PATH)) {
+    return { mcpServers: {} };
+  }
+  try {
+    const content = await Bun.file(MCP_JSON_PATH).text();
+    const parsed = JSON.parse(content);
+    return {
+      mcpServers: parsed.mcpServers || {}
+    };
+  } catch {
+    return { mcpServers: {} };
+  }
+}
+async function writeMcpJson(config) {
+  await Bun.write(MCP_JSON_PATH, JSON.stringify(config, null, 2));
+}
+function buildMcpServerConfig(mcp) {
+  const config = {
+    command: mcp.command
+  };
+  if (mcp.args) {
+    config.args = mcp.args;
+  }
+  if (mcp.env) {
+    config.env = mcp.env;
+  }
+  return config;
+}
+async function syncMcpJson(capabilities2, previousManifest, options = {}) {
+  const mcpJson = await readMcpJson();
+  const previouslyManagedMcps = new Set;
+  for (const resources of Object.values(previousManifest.capabilities)) {
+    for (const mcpName of resources.mcps) {
+      previouslyManagedMcps.add(mcpName);
+    }
+  }
+  for (const serverName of previouslyManagedMcps) {
+    delete mcpJson.mcpServers[serverName];
+  }
+  let addedCount = 0;
+  for (const cap of capabilities2) {
+    if (cap.config.mcp) {
+      mcpJson.mcpServers[cap.id] = buildMcpServerConfig(cap.config.mcp);
+      addedCount++;
+    }
+  }
+  await writeMcpJson(mcpJson);
+  if (!options.silent) {
+    console.log(`  - .mcp.json (${addedCount} MCP server(s))`);
+  }
+}
+var MANIFEST_PATH = ".omni/state/manifest.json";
+var CURRENT_VERSION = 1;
+async function loadManifest() {
+  if (!existsSync13(MANIFEST_PATH)) {
+    return {
+      version: CURRENT_VERSION,
+      syncedAt: new Date().toISOString(),
+      capabilities: {}
+    };
+  }
+  const content = await Bun.file(MANIFEST_PATH).text();
+  return JSON.parse(content);
+}
+async function saveManifest(manifest) {
+  mkdirSync2(".omni/state", { recursive: true });
+  await Bun.write(MANIFEST_PATH, JSON.stringify(manifest, null, 2));
+}
+function buildManifestFromCapabilities(capabilities2) {
+  const manifest = {
+    version: CURRENT_VERSION,
+    syncedAt: new Date().toISOString(),
+    capabilities: {}
+  };
+  for (const cap of capabilities2) {
+    const resources = {
+      skills: cap.skills.map((s) => s.name),
+      rules: cap.rules.map((r) => r.name),
+      commands: cap.commands.map((c) => c.name),
+      subagents: cap.subagents.map((s) => s.name),
+      mcps: cap.config.mcp ? [cap.id] : []
+    };
+    manifest.capabilities[cap.id] = resources;
+  }
+  return manifest;
+}
+async function cleanupStaleResources(previousManifest, currentCapabilityIds) {
+  const result = {
+    deletedSkills: [],
+    deletedRules: [],
+    deletedCommands: [],
+    deletedSubagents: [],
+    deletedMcps: []
+  };
+  for (const [capId, resources] of Object.entries(previousManifest.capabilities)) {
+    if (currentCapabilityIds.has(capId)) {
+      continue;
+    }
+    for (const skillName of resources.skills) {
+      const skillDir = `.claude/skills/${skillName}`;
+      if (existsSync13(skillDir)) {
+        rmSync(skillDir, { recursive: true });
+        result.deletedSkills.push(skillName);
+      }
+    }
+    for (const ruleName of resources.rules) {
+      const rulePath = `.cursor/rules/omnidev-${ruleName}.mdc`;
+      if (existsSync13(rulePath)) {
+        rmSync(rulePath);
+        result.deletedRules.push(ruleName);
+      }
+    }
+  }
+  return result;
+}
+var STATE_DIR2 = ".omni/state";
+var PROVIDERS_PATH = `${STATE_DIR2}/providers.json`;
+var DEFAULT_PROVIDERS = ["claude-code"];
+async function readEnabledProviders() {
+  if (!existsSync14(PROVIDERS_PATH)) {
+    return DEFAULT_PROVIDERS;
+  }
+  try {
+    const content = await Bun.file(PROVIDERS_PATH).text();
+    const state = JSON.parse(content);
+    return state.enabled.length > 0 ? state.enabled : DEFAULT_PROVIDERS;
+  } catch {
+    return DEFAULT_PROVIDERS;
+  }
+}
+async function writeEnabledProviders(providers) {
+  mkdirSync3(STATE_DIR2, { recursive: true });
+  const state = { enabled: providers };
+  await Bun.write(PROVIDERS_PATH, JSON.stringify(state, null, 2));
+}
+async function enableProvider(providerId) {
+  const current = await readEnabledProviders();
+  if (!current.includes(providerId)) {
+    await writeEnabledProviders([...current, providerId]);
+  }
+}
+async function disableProvider(providerId) {
+  const current = await readEnabledProviders();
+  const filtered = current.filter((p) => p !== providerId);
+  await writeEnabledProviders(filtered);
+}
+async function isProviderEnabled(providerId) {
+  const current = await readEnabledProviders();
+  return current.includes(providerId);
+}
+async function installCapabilityDependencies(silent) {
+  const { existsSync: existsSync15, readdirSync: readdirSync7 } = await import("node:fs");
+  const { join: join8 } = await import("node:path");
+  const capabilitiesDir = ".omni/capabilities";
+  if (!existsSync15(capabilitiesDir)) {
+    return;
+  }
+  const entries = readdirSync7(capabilitiesDir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (!entry.isDirectory()) {
+      continue;
+    }
+    const capabilityPath = join8(capabilitiesDir, entry.name);
+    const packageJsonPath = join8(capabilityPath, "package.json");
+    if (!existsSync15(packageJsonPath)) {
+      continue;
+    }
+    if (!silent) {
+      console.log(`Installing dependencies for ${capabilityPath}...`);
+    }
+    await new Promise((resolve, reject) => {
+      const proc = spawn("bun", ["install"], {
+        cwd: capabilityPath,
+        stdio: silent ? "ignore" : "inherit"
+      });
+      proc.on("close", (code) => {
+        if (code === 0) {
+          resolve();
+        } else {
+          reject(new Error(`Failed to install dependencies for ${capabilityPath}`));
+        }
+      });
+      proc.on("error", (error) => {
+        reject(error);
+      });
+    });
+  }
+}
+async function buildSyncBundle(options) {
+  const silent = options?.silent ?? false;
+  const config = await loadConfig();
+  await fetchAllCapabilitySources(config, { silent });
+  await installCapabilityDependencies(silent);
+  const registry = await buildCapabilityRegistry();
+  const capabilities2 = registry.getAllCapabilities();
+  const skills = registry.getAllSkills();
+  const rules = registry.getAllRules();
+  const docs = registry.getAllDocs();
+  const commands = capabilities2.flatMap((c) => c.commands);
+  const subagents = capabilities2.flatMap((c) => c.subagents);
+  const instructionsContent = generateInstructionsContent(rules, docs);
+  const bundle = {
+    capabilities: capabilities2,
+    skills,
+    rules,
+    docs,
+    commands,
+    subagents,
+    instructionsPath: ".omni/instructions.md",
+    instructionsContent
+  };
+  return { bundle };
+}
+async function syncAgentConfiguration(options) {
+  const silent = options?.silent ?? false;
+  const adapters = options?.adapters ?? [];
+  if (!silent) {
+    console.log("Syncing agent configuration...");
+  }
+  const { bundle } = await buildSyncBundle({ silent });
+  const capabilities2 = bundle.capabilities;
+  const previousManifest = await loadManifest();
+  const currentCapabilityIds = new Set(capabilities2.map((c) => c.id));
+  const cleanupResult = await cleanupStaleResources(previousManifest, currentCapabilityIds);
+  if (!silent && (cleanupResult.deletedSkills.length > 0 || cleanupResult.deletedRules.length > 0)) {
+    console.log("Cleaned up stale resources:");
+    if (cleanupResult.deletedSkills.length > 0) {
+      console.log(`  - Removed ${cleanupResult.deletedSkills.length} skill(s): ${cleanupResult.deletedSkills.join(", ")}`);
+    }
+    if (cleanupResult.deletedRules.length > 0) {
+      console.log(`  - Removed ${cleanupResult.deletedRules.length} rule(s): ${cleanupResult.deletedRules.join(", ")}`);
+    }
+  }
+  for (const capability of capabilities2) {
+    const defaultExport = capability.exports.default;
+    if (defaultExport && typeof defaultExport.sync === "function") {
+      try {
+        await defaultExport.sync();
+      } catch (error) {
+        console.error(`Error running sync hook for ${capability.id}:`, error);
+      }
+    } else if (capability.config.sync?.on_sync) {
+      const syncFnName = capability.config.sync.on_sync;
+      const syncFn = capability.exports[syncFnName];
+      if (typeof syncFn === "function") {
+        try {
+          await syncFn();
+        } catch (error) {
+          console.error(`Error running sync hook for ${capability.id}:`, error);
+        }
+      }
+    }
+  }
+  mkdirSync4(".omni", { recursive: true });
+  await writeRules(bundle.rules, bundle.docs);
+  await syncMcpJson(capabilities2, previousManifest, { silent });
+  const newManifest = buildManifestFromCapabilities(capabilities2);
+  await saveManifest(newManifest);
+  if (adapters.length > 0) {
+    const config = await loadConfig();
+    const ctx = {
+      projectRoot: process.cwd(),
+      config
+    };
+    for (const adapter of adapters) {
+      try {
+        const result = await adapter.sync(bundle, ctx);
+        if (!silent && result.filesWritten.length > 0) {
+          console.log(`  - ${adapter.displayName}: ${result.filesWritten.length} files`);
+        }
+      } catch (error) {
+        console.error(`Error running ${adapter.displayName} adapter:`, error);
+      }
+    }
+  }
+  if (!silent) {
+    console.log("✓ Synced:");
+    console.log(`  - .omni/instructions.md (${bundle.docs.length} docs, ${bundle.rules.length} rules)`);
+    if (adapters.length > 0) {
+      console.log(`  - Provider adapters: ${adapters.map((a) => a.displayName).join(", ")}`);
+    }
+  }
+  return {
+    capabilities: capabilities2.map((c) => c.id),
+    skillCount: bundle.skills.length,
+    ruleCount: bundle.rules.length,
+    docCount: bundle.docs.length
+  };
+}
+function generateInstructionsContent(rules, docs) {
+  if (rules.length === 0 && docs.length === 0) {
+    return `## Capabilities
+
+No capabilities enabled yet. Run \`omnidev capability enable <name>\` to enable capabilities.`;
+  }
+  let content = `## Capabilities
+
+`;
+  if (docs.length > 0) {
+    content += `### Documentation
+
+`;
+    for (const doc of docs) {
+      content += `#### ${doc.name} (from ${doc.capabilityId})
+
+${doc.content}
+
+`;
+    }
+  }
+  if (rules.length > 0) {
+    content += `### Rules
+
+`;
+    for (const rule of rules) {
+      content += `#### ${rule.name} (from ${rule.capabilityId})
+
+${rule.content}
+
+`;
+    }
+  }
+  return content.trim();
+}
+function generateAgentsTemplate() {
+  return `# Project Instructions
+
+<!-- Add your project-specific instructions here -->
+
+## OmniDev
+
+@import .omni/instructions.md
+`;
+}
+function generateClaudeTemplate() {
+  return `# Project Instructions
+
+<!-- Add your project-specific instructions here -->
+
+## OmniDev
+
+@import .omni/instructions.md
+`;
+}
+function generateInstructionsTemplate() {
+  return `# OmniDev Instructions
+
+## Project Description
+<!-- TODO: Add 2-3 sentences describing your project -->
+[Describe what this project does and its main purpose]
+
+## How OmniDev Works
+
+OmniDev manages capability content for your project. Capabilities can provide:
+
+- Skills (for agent workflows)
+- Rules (for guardrails and conventions)
+- Docs (reference material)
+- Commands and subagents (optional)
+
+Enable capabilities with:
+
+\`\`\`
+omnidev capability enable <capability-id>
+\`\`\`
+
+OmniDev will automatically sync enabled capabilities into your workspace. If you want to force a refresh:
+
+\`\`\`
+omnidev sync
+\`\`\`
+
+<!-- BEGIN OMNIDEV GENERATED CONTENT - DO NOT EDIT BELOW THIS LINE -->
+<!-- This section is automatically updated by 'omnidev agents sync' -->
+
+## Capabilities
+
+No capabilities enabled yet. Run \`omnidev capability enable <name>\` to enable capabilities.
+
+<!-- END OMNIDEV GENERATED CONTENT -->
+`;
+}
+function getActiveProviders(config) {
+  if (config.providers)
+    return config.providers;
+  if (config.provider)
+    return [config.provider];
+  return ["claude"];
+}
+function debug(message, data) {
+  if (process.env["OMNIDEV_DEBUG"] !== "1") {
+    return;
+  }
+  const timestamp = new Date().toISOString();
+  let logLine;
+  if (data !== undefined) {
+    logLine = `[${timestamp}] [omnidev] ${message} ${JSON.stringify(data, null, 2)}`;
+  } else {
+    logLine = `[${timestamp}] [omnidev] ${message}`;
+  }
+  console.log(logLine);
+}
+var version = "0.1.0";
+function getVersion() {
+  return version;
+}
+export {
+  writeRules,
+  writeProviderConfig,
+  writeMcpJson,
+  writeEnabledProviders,
+  writeConfig,
+  writeActiveProfileState,
+  version,
+  validateEnv,
+  syncMcpJson,
+  syncAgentConfiguration,
+  sourceToGitUrl,
+  setProfile,
+  setActiveProfile,
+  saveManifest,
+  saveLockFile,
+  resolveEnabledCapabilities,
+  readMcpJson,
+  readEnabledProviders,
+  readActiveProfileState,
+  parseSourceConfig,
+  parseProviderFlag,
+  parseOmniConfig,
+  parseCapabilityConfig,
+  loadSubagents,
+  loadSkills,
+  loadRules,
+  loadProviderConfig,
+  loadProfileConfig,
+  loadManifest,
+  loadLockFile,
+  loadEnvironment,
+  loadDocs,
+  loadConfig,
+  loadCommands,
+  loadCapabilityConfig,
+  loadCapability,
+  isSecretEnvVar,
+  isProviderEnabled,
+  installCapabilityDependencies,
+  getVersion,
+  getSourceCapabilityPath,
+  getLockFilePath,
+  getEnabledCapabilities,
+  getActiveProviders,
+  getActiveProfile,
+  generateInstructionsTemplate,
+  generateClaudeTemplate,
+  generateAgentsTemplate,
+  fetchCapabilitySource,
+  fetchAllCapabilitySources,
+  enableProvider,
+  enableCapability,
+  discoverCapabilities,
+  disableProvider,
+  disableCapability,
+  debug,
+  clearActiveProfileState,
+  cleanupStaleResources,
+  checkForUpdates,
+  buildSyncBundle,
+  buildRouteMap,
+  buildManifestFromCapabilities,
+  buildCommand,
+  buildCapabilityRegistry
+};
+export { __toESM, __require, discoverCapabilities, loadCapabilityConfig, loadConfig, writeConfig, getActiveProfile, setActiveProfile, resolveEnabledCapabilities, getEnabledCapabilities, enableCapability, disableCapability, readEnabledProviders, writeEnabledProviders, enableProvider, disableProvider, syncAgentConfiguration, generateInstructionsTemplate, debug };