@opencode_weave/weave 0.7.4-preview.1 → 0.7.4

package/dist/index.js

@@ -1,11 +1,814 @@
 // src/index.ts
-import { join as join13 } from "path";
+import { join as join12 } from "path";
 
 // src/config/loader.ts
-import { existsSync as existsSync2, readFileSync } from "node:fs";
-import { join as join2 } from "node:path";
-import { homedir as homedir2 } from "node:os";
-import { parse } from "jsonc-parser";
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+
+// node_modules/jsonc-parser/lib/esm/impl/scanner.js
+function createScanner(text, ignoreTrivia = false) {
+  const len = text.length;
+  let pos = 0, value = "", tokenOffset = 0, token = 16, lineNumber = 0, lineStartOffset = 0, tokenLineStartOffset = 0, prevTokenLineStartOffset = 0, scanError = 0;
+  function scanHexDigits(count, exact) {
+    let digits = 0;
+    let value2 = 0;
+    while (digits < count || !exact) {
+      let ch = text.charCodeAt(pos);
+      if (ch >= 48 && ch <= 57) {
+        value2 = value2 * 16 + ch - 48;
+      } else if (ch >= 65 && ch <= 70) {
+        value2 = value2 * 16 + ch - 65 + 10;
+      } else if (ch >= 97 && ch <= 102) {
+        value2 = value2 * 16 + ch - 97 + 10;
+      } else {
+        break;
+      }
+      pos++;
+      digits++;
+    }
+    if (digits < count) {
+      value2 = -1;
+    }
+    return value2;
+  }
+  function setPosition(newPosition) {
+    pos = newPosition;
+    value = "";
+    tokenOffset = 0;
+    token = 16;
+    scanError = 0;
+  }
+  function scanNumber() {
+    let start = pos;
+    if (text.charCodeAt(pos) === 48) {
+      pos++;
+    } else {
+      pos++;
+      while (pos < text.length && isDigit(text.charCodeAt(pos))) {
+        pos++;
+      }
+    }
+    if (pos < text.length && text.charCodeAt(pos) === 46) {
+      pos++;
+      if (pos < text.length && isDigit(text.charCodeAt(pos))) {
+        pos++;
+        while (pos < text.length && isDigit(text.charCodeAt(pos))) {
+          pos++;
+        }
+      } else {
+        scanError = 3;
+        return text.substring(start, pos);
+      }
+    }
+    let end = pos;
+    if (pos < text.length && (text.charCodeAt(pos) === 69 || text.charCodeAt(pos) === 101)) {
+      pos++;
+      if (pos < text.length && text.charCodeAt(pos) === 43 || text.charCodeAt(pos) === 45) {
+        pos++;
+      }
+      if (pos < text.length && isDigit(text.charCodeAt(pos))) {
+        pos++;
+        while (pos < text.length && isDigit(text.charCodeAt(pos))) {
+          pos++;
+        }
+        end = pos;
+      } else {
+        scanError = 3;
+      }
+    }
+    return text.substring(start, end);
+  }
+  function scanString() {
+    let result = "", start = pos;
+    while (true) {
+      if (pos >= len) {
+        result += text.substring(start, pos);
+        scanError = 2;
+        break;
+      }
+      const ch = text.charCodeAt(pos);
+      if (ch === 34) {
+        result += text.substring(start, pos);
+        pos++;
+        break;
+      }
+      if (ch === 92) {
+        result += text.substring(start, pos);
+        pos++;
+        if (pos >= len) {
+          scanError = 2;
+          break;
+        }
+        const ch2 = text.charCodeAt(pos++);
+        switch (ch2) {
+          case 34:
+            result += '"';
+            break;
+          case 92:
+            result += "\\";
+            break;
+          case 47:
+            result += "/";
+            break;
+          case 98:
+            result += "\b";
+            break;
+          case 102:
+            result += "\f";
+            break;
+          case 110:
+            result += `
+`;
+            break;
+          case 114:
+            result += "\r";
+            break;
+          case 116:
+            result += "\t";
+            break;
+          case 117:
+            const ch3 = scanHexDigits(4, true);
+            if (ch3 >= 0) {
+              result += String.fromCharCode(ch3);
+            } else {
+              scanError = 4;
+            }
+            break;
+          default:
+            scanError = 5;
+        }
+        start = pos;
+        continue;
+      }
+      if (ch >= 0 && ch <= 31) {
+        if (isLineBreak(ch)) {
+          result += text.substring(start, pos);
+          scanError = 2;
+          break;
+        } else {
+          scanError = 6;
+        }
+      }
+      pos++;
+    }
+    return result;
+  }
+  function scanNext() {
+    value = "";
+    scanError = 0;
+    tokenOffset = pos;
+    lineStartOffset = lineNumber;
+    prevTokenLineStartOffset = tokenLineStartOffset;
+    if (pos >= len) {
+      tokenOffset = len;
+      return token = 17;
+    }
+    let code = text.charCodeAt(pos);
+    if (isWhiteSpace(code)) {
+      do {
+        pos++;
+        value += String.fromCharCode(code);
+        code = text.charCodeAt(pos);
+      } while (isWhiteSpace(code));
+      return token = 15;
+    }
+    if (isLineBreak(code)) {
+      pos++;
+      value += String.fromCharCode(code);
+      if (code === 13 && text.charCodeAt(pos) === 10) {
+        pos++;
+        value += `
+`;
+      }
+      lineNumber++;
+      tokenLineStartOffset = pos;
+      return token = 14;
+    }
+    switch (code) {
+      case 123:
+        pos++;
+        return token = 1;
+      case 125:
+        pos++;
+        return token = 2;
+      case 91:
+        pos++;
+        return token = 3;
+      case 93:
+        pos++;
+        return token = 4;
+      case 58:
+        pos++;
+        return token = 6;
+      case 44:
+        pos++;
+        return token = 5;
+      case 34:
+        pos++;
+        value = scanString();
+        return token = 10;
+      case 47:
+        const start = pos - 1;
+        if (text.charCodeAt(pos + 1) === 47) {
+          pos += 2;
+          while (pos < len) {
+            if (isLineBreak(text.charCodeAt(pos))) {
+              break;
+            }
+            pos++;
+          }
+          value = text.substring(start, pos);
+          return token = 12;
+        }
+        if (text.charCodeAt(pos + 1) === 42) {
+          pos += 2;
+          const safeLength = len - 1;
+          let commentClosed = false;
+          while (pos < safeLength) {
+            const ch = text.charCodeAt(pos);
+            if (ch === 42 && text.charCodeAt(pos + 1) === 47) {
+              pos += 2;
+              commentClosed = true;
+              break;
+            }
+            pos++;
+            if (isLineBreak(ch)) {
+              if (ch === 13 && text.charCodeAt(pos) === 10) {
+                pos++;
+              }
+              lineNumber++;
+              tokenLineStartOffset = pos;
+            }
+          }
+          if (!commentClosed) {
+            pos++;
+            scanError = 1;
+          }
+          value = text.substring(start, pos);
+          return token = 13;
+        }
+        value += String.fromCharCode(code);
+        pos++;
+        return token = 16;
+      case 45:
+        value += String.fromCharCode(code);
+        pos++;
+        if (pos === len || !isDigit(text.charCodeAt(pos))) {
+          return token = 16;
+        }
+      case 48:
+      case 49:
+      case 50:
+      case 51:
+      case 52:
+      case 53:
+      case 54:
+      case 55:
+      case 56:
+      case 57:
+        value += scanNumber();
+        return token = 11;
+      default:
+        while (pos < len && isUnknownContentCharacter(code)) {
+          pos++;
+          code = text.charCodeAt(pos);
+        }
+        if (tokenOffset !== pos) {
+          value = text.substring(tokenOffset, pos);
+          switch (value) {
+            case "true":
+              return token = 8;
+            case "false":
+              return token = 9;
+            case "null":
+              return token = 7;
+          }
+          return token = 16;
+        }
+        value += String.fromCharCode(code);
+        pos++;
+        return token = 16;
+    }
+  }
+  function isUnknownContentCharacter(code) {
+    if (isWhiteSpace(code) || isLineBreak(code)) {
+      return false;
+    }
+    switch (code) {
+      case 125:
+      case 93:
+      case 123:
+      case 91:
+      case 34:
+      case 58:
+      case 44:
+      case 47:
+        return false;
+    }
+    return true;
+  }
+  function scanNextNonTrivia() {
+    let result;
+    do {
+      result = scanNext();
+    } while (result >= 12 && result <= 15);
+    return result;
+  }
+  return {
+    setPosition,
+    getPosition: () => pos,
+    scan: ignoreTrivia ? scanNextNonTrivia : scanNext,
+    getToken: () => token,
+    getTokenValue: () => value,
+    getTokenOffset: () => tokenOffset,
+    getTokenLength: () => pos - tokenOffset,
+    getTokenStartLine: () => lineStartOffset,
+    getTokenStartCharacter: () => tokenOffset - prevTokenLineStartOffset,
+    getTokenError: () => scanError
+  };
+}
+function isWhiteSpace(ch) {
+  return ch === 32 || ch === 9;
+}
+function isLineBreak(ch) {
+  return ch === 10 || ch === 13;
+}
+function isDigit(ch) {
+  return ch >= 48 && ch <= 57;
+}
+var CharacterCodes;
+(function(CharacterCodes2) {
+  CharacterCodes2[CharacterCodes2["lineFeed"] = 10] = "lineFeed";
+  CharacterCodes2[CharacterCodes2["carriageReturn"] = 13] = "carriageReturn";
+  CharacterCodes2[CharacterCodes2["space"] = 32] = "space";
+  CharacterCodes2[CharacterCodes2["_0"] = 48] = "_0";
+  CharacterCodes2[CharacterCodes2["_1"] = 49] = "_1";
+  CharacterCodes2[CharacterCodes2["_2"] = 50] = "_2";
+  CharacterCodes2[CharacterCodes2["_3"] = 51] = "_3";
+  CharacterCodes2[CharacterCodes2["_4"] = 52] = "_4";
+  CharacterCodes2[CharacterCodes2["_5"] = 53] = "_5";
+  CharacterCodes2[CharacterCodes2["_6"] = 54] = "_6";
+  CharacterCodes2[CharacterCodes2["_7"] = 55] = "_7";
+  CharacterCodes2[CharacterCodes2["_8"] = 56] = "_8";
+  CharacterCodes2[CharacterCodes2["_9"] = 57] = "_9";
+  CharacterCodes2[CharacterCodes2["a"] = 97] = "a";
+  CharacterCodes2[CharacterCodes2["b"] = 98] = "b";
+  CharacterCodes2[CharacterCodes2["c"] = 99] = "c";
+  CharacterCodes2[CharacterCodes2["d"] = 100] = "d";
+  CharacterCodes2[CharacterCodes2["e"] = 101] = "e";
+  CharacterCodes2[CharacterCodes2["f"] = 102] = "f";
+  CharacterCodes2[CharacterCodes2["g"] = 103] = "g";
+  CharacterCodes2[CharacterCodes2["h"] = 104] = "h";
+  CharacterCodes2[CharacterCodes2["i"] = 105] = "i";
+  CharacterCodes2[CharacterCodes2["j"] = 106] = "j";
+  CharacterCodes2[CharacterCodes2["k"] = 107] = "k";
+  CharacterCodes2[CharacterCodes2["l"] = 108] = "l";
+  CharacterCodes2[CharacterCodes2["m"] = 109] = "m";
+  CharacterCodes2[CharacterCodes2["n"] = 110] = "n";
+  CharacterCodes2[CharacterCodes2["o"] = 111] = "o";
+  CharacterCodes2[CharacterCodes2["p"] = 112] = "p";
+  CharacterCodes2[CharacterCodes2["q"] = 113] = "q";
+  CharacterCodes2[CharacterCodes2["r"] = 114] = "r";
+  CharacterCodes2[CharacterCodes2["s"] = 115] = "s";
+  CharacterCodes2[CharacterCodes2["t"] = 116] = "t";
+  CharacterCodes2[CharacterCodes2["u"] = 117] = "u";
+  CharacterCodes2[CharacterCodes2["v"] = 118] = "v";
+  CharacterCodes2[CharacterCodes2["w"] = 119] = "w";
+  CharacterCodes2[CharacterCodes2["x"] = 120] = "x";
+  CharacterCodes2[CharacterCodes2["y"] = 121] = "y";
+  CharacterCodes2[CharacterCodes2["z"] = 122] = "z";
+  CharacterCodes2[CharacterCodes2["A"] = 65] = "A";
+  CharacterCodes2[CharacterCodes2["B"] = 66] = "B";
+  CharacterCodes2[CharacterCodes2["C"] = 67] = "C";
+  CharacterCodes2[CharacterCodes2["D"] = 68] = "D";
+  CharacterCodes2[CharacterCodes2["E"] = 69] = "E";
+  CharacterCodes2[CharacterCodes2["F"] = 70] = "F";
+  CharacterCodes2[CharacterCodes2["G"] = 71] = "G";
+  CharacterCodes2[CharacterCodes2["H"] = 72] = "H";
+  CharacterCodes2[CharacterCodes2["I"] = 73] = "I";
+  CharacterCodes2[CharacterCodes2["J"] = 74] = "J";
+  CharacterCodes2[CharacterCodes2["K"] = 75] = "K";
+  CharacterCodes2[CharacterCodes2["L"] = 76] = "L";
+  CharacterCodes2[CharacterCodes2["M"] = 77] = "M";
+  CharacterCodes2[CharacterCodes2["N"] = 78] = "N";
+  CharacterCodes2[CharacterCodes2["O"] = 79] = "O";
+  CharacterCodes2[CharacterCodes2["P"] = 80] = "P";
+  CharacterCodes2[CharacterCodes2["Q"] = 81] = "Q";
+  CharacterCodes2[CharacterCodes2["R"] = 82] = "R";
+  CharacterCodes2[CharacterCodes2["S"] = 83] = "S";
+  CharacterCodes2[CharacterCodes2["T"] = 84] = "T";
+  CharacterCodes2[CharacterCodes2["U"] = 85] = "U";
+  CharacterCodes2[CharacterCodes2["V"] = 86] = "V";
+  CharacterCodes2[CharacterCodes2["W"] = 87] = "W";
+  CharacterCodes2[CharacterCodes2["X"] = 88] = "X";
+  CharacterCodes2[CharacterCodes2["Y"] = 89] = "Y";
+  CharacterCodes2[CharacterCodes2["Z"] = 90] = "Z";
+  CharacterCodes2[CharacterCodes2["asterisk"] = 42] = "asterisk";
+  CharacterCodes2[CharacterCodes2["backslash"] = 92] = "backslash";
+  CharacterCodes2[CharacterCodes2["closeBrace"] = 125] = "closeBrace";
+  CharacterCodes2[CharacterCodes2["closeBracket"] = 93] = "closeBracket";
+  CharacterCodes2[CharacterCodes2["colon"] = 58] = "colon";
+  CharacterCodes2[CharacterCodes2["comma"] = 44] = "comma";
+  CharacterCodes2[CharacterCodes2["dot"] = 46] = "dot";
+  CharacterCodes2[CharacterCodes2["doubleQuote"] = 34] = "doubleQuote";
+  CharacterCodes2[CharacterCodes2["minus"] = 45] = "minus";
+  CharacterCodes2[CharacterCodes2["openBrace"] = 123] = "openBrace";
+  CharacterCodes2[CharacterCodes2["openBracket"] = 91] = "openBracket";
+  CharacterCodes2[CharacterCodes2["plus"] = 43] = "plus";
+  CharacterCodes2[CharacterCodes2["slash"] = 47] = "slash";
+  CharacterCodes2[CharacterCodes2["formFeed"] = 12] = "formFeed";
+  CharacterCodes2[CharacterCodes2["tab"] = 9] = "tab";
+})(CharacterCodes || (CharacterCodes = {}));
+
+// node_modules/jsonc-parser/lib/esm/impl/string-intern.js
+var cachedSpaces = new Array(20).fill(0).map((_, index) => {
+  return " ".repeat(index);
+});
+var maxCachedValues = 200;
+var cachedBreakLinesWithSpaces = {
+  " ": {
+    "\n": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return `
+` + " ".repeat(index);
+    }),
+    "\r": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return "\r" + " ".repeat(index);
+    }),
+    "\r\n": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return `\r
+` + " ".repeat(index);
+    })
+  },
+  "\t": {
+    "\n": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return `
+` + "\t".repeat(index);
+    }),
+    "\r": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return "\r" + "\t".repeat(index);
+    }),
+    "\r\n": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return `\r
+` + "\t".repeat(index);
+    })
+  }
+};
+
+// node_modules/jsonc-parser/lib/esm/impl/parser.js
+var ParseOptions;
+(function(ParseOptions2) {
+  ParseOptions2.DEFAULT = {
+    allowTrailingComma: false
+  };
+})(ParseOptions || (ParseOptions = {}));
+function parse(text, errors = [], options = ParseOptions.DEFAULT) {
+  let currentProperty = null;
+  let currentParent = [];
+  const previousParents = [];
+  function onValue(value) {
+    if (Array.isArray(currentParent)) {
+      currentParent.push(value);
+    } else if (currentProperty !== null) {
+      currentParent[currentProperty] = value;
+    }
+  }
+  const visitor = {
+    onObjectBegin: () => {
+      const object = {};
+      onValue(object);
+      previousParents.push(currentParent);
+      currentParent = object;
+      currentProperty = null;
+    },
+    onObjectProperty: (name) => {
+      currentProperty = name;
+    },
+    onObjectEnd: () => {
+      currentParent = previousParents.pop();
+    },
+    onArrayBegin: () => {
+      const array = [];
+      onValue(array);
+      previousParents.push(currentParent);
+      currentParent = array;
+      currentProperty = null;
+    },
+    onArrayEnd: () => {
+      currentParent = previousParents.pop();
+    },
+    onLiteralValue: onValue,
+    onError: (error, offset, length) => {
+      errors.push({ error, offset, length });
+    }
+  };
+  visit(text, visitor, options);
+  return currentParent[0];
+}
+function visit(text, visitor, options = ParseOptions.DEFAULT) {
+  const _scanner = createScanner(text, false);
+  const _jsonPath = [];
+  let suppressedCallbacks = 0;
+  function toNoArgVisit(visitFunction) {
+    return visitFunction ? () => suppressedCallbacks === 0 && visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter()) : () => true;
+  }
+  function toOneArgVisit(visitFunction) {
+    return visitFunction ? (arg) => suppressedCallbacks === 0 && visitFunction(arg, _scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter()) : () => true;
+  }
+  function toOneArgVisitWithPath(visitFunction) {
+    return visitFunction ? (arg) => suppressedCallbacks === 0 && visitFunction(arg, _scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter(), () => _jsonPath.slice()) : () => true;
+  }
+  function toBeginVisit(visitFunction) {
+    return visitFunction ? () => {
+      if (suppressedCallbacks > 0) {
+        suppressedCallbacks++;
+      } else {
+        let cbReturn = visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter(), () => _jsonPath.slice());
+        if (cbReturn === false) {
+          suppressedCallbacks = 1;
+        }
+      }
+    } : () => true;
+  }
+  function toEndVisit(visitFunction) {
+    return visitFunction ? () => {
+      if (suppressedCallbacks > 0) {
+        suppressedCallbacks--;
+      }
+      if (suppressedCallbacks === 0) {
+        visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter());
+      }
+    } : () => true;
+  }
+  const onObjectBegin = toBeginVisit(visitor.onObjectBegin), onObjectProperty = toOneArgVisitWithPath(visitor.onObjectProperty), onObjectEnd = toEndVisit(visitor.onObjectEnd), onArrayBegin = toBeginVisit(visitor.onArrayBegin), onArrayEnd = toEndVisit(visitor.onArrayEnd), onLiteralValue = toOneArgVisitWithPath(visitor.onLiteralValue), onSeparator = toOneArgVisit(visitor.onSeparator), onComment = toNoArgVisit(visitor.onComment), onError = toOneArgVisit(visitor.onError);
+  const disallowComments = options && options.disallowComments;
+  const allowTrailingComma = options && options.allowTrailingComma;
+  function scanNext() {
+    while (true) {
+      const token = _scanner.scan();
+      switch (_scanner.getTokenError()) {
+        case 4:
+          handleError(14);
+          break;
+        case 5:
+          handleError(15);
+          break;
+        case 3:
+          handleError(13);
+          break;
+        case 1:
+          if (!disallowComments) {
+            handleError(11);
+          }
+          break;
+        case 2:
+          handleError(12);
+          break;
+        case 6:
+          handleError(16);
+          break;
+      }
+      switch (token) {
+        case 12:
+        case 13:
+          if (disallowComments) {
+            handleError(10);
+          } else {
+            onComment();
+          }
+          break;
+        case 16:
+          handleError(1);
+          break;
+        case 15:
+        case 14:
+          break;
+        default:
+          return token;
+      }
+    }
+  }
+  function handleError(error, skipUntilAfter = [], skipUntil = []) {
+    onError(error);
+    if (skipUntilAfter.length + skipUntil.length > 0) {
+      let token = _scanner.getToken();
+      while (token !== 17) {
+        if (skipUntilAfter.indexOf(token) !== -1) {
+          scanNext();
+          break;
+        } else if (skipUntil.indexOf(token) !== -1) {
+          break;
+        }
+        token = scanNext();
+      }
+    }
+  }
+  function parseString(isValue) {
+    const value = _scanner.getTokenValue();
+    if (isValue) {
+      onLiteralValue(value);
+    } else {
+      onObjectProperty(value);
+      _jsonPath.push(value);
+    }
+    scanNext();
+    return true;
+  }
+  function parseLiteral() {
+    switch (_scanner.getToken()) {
+      case 11:
+        const tokenValue = _scanner.getTokenValue();
+        let value = Number(tokenValue);
+        if (isNaN(value)) {
+          handleError(2);
+          value = 0;
+        }
+        onLiteralValue(value);
+        break;
+      case 7:
+        onLiteralValue(null);
+        break;
+      case 8:
+        onLiteralValue(true);
+        break;
+      case 9:
+        onLiteralValue(false);
+        break;
+      default:
+        return false;
+    }
+    scanNext();
+    return true;
+  }
+  function parseProperty() {
+    if (_scanner.getToken() !== 10) {
+      handleError(3, [], [2, 5]);
+      return false;
+    }
+    parseString(false);
+    if (_scanner.getToken() === 6) {
+      onSeparator(":");
+      scanNext();
+      if (!parseValue()) {
+        handleError(4, [], [2, 5]);
+      }
+    } else {
+      handleError(5, [], [2, 5]);
+    }
+    _jsonPath.pop();
+    return true;
+  }
+  function parseObject() {
+    onObjectBegin();
+    scanNext();
+    let needsComma = false;
+    while (_scanner.getToken() !== 2 && _scanner.getToken() !== 17) {
+      if (_scanner.getToken() === 5) {
+        if (!needsComma) {
+          handleError(4, [], []);
+        }
+        onSeparator(",");
+        scanNext();
+        if (_scanner.getToken() === 2 && allowTrailingComma) {
+          break;
+        }
+      } else if (needsComma) {
+        handleError(6, [], []);
+      }
+      if (!parseProperty()) {
+        handleError(4, [], [2, 5]);
+      }
+      needsComma = true;
+    }
+    onObjectEnd();
+    if (_scanner.getToken() !== 2) {
+      handleError(7, [2], []);
+    } else {
+      scanNext();
+    }
+    return true;
+  }
+  function parseArray() {
+    onArrayBegin();
+    scanNext();
+    let isFirstElement = true;
+    let needsComma = false;
+    while (_scanner.getToken() !== 4 && _scanner.getToken() !== 17) {
+      if (_scanner.getToken() === 5) {
+        if (!needsComma) {
+          handleError(4, [], []);
+        }
+        onSeparator(",");
+        scanNext();
+        if (_scanner.getToken() === 4 && allowTrailingComma) {
+          break;
+        }
+      } else if (needsComma) {
+        handleError(6, [], []);
+      }
+      if (isFirstElement) {
+        _jsonPath.push(0);
+        isFirstElement = false;
+      } else {
+        _jsonPath[_jsonPath.length - 1]++;
+      }
+      if (!parseValue()) {
+        handleError(4, [], [4, 5]);
+      }
+      needsComma = true;
+    }
+    onArrayEnd();
+    if (!isFirstElement) {
+      _jsonPath.pop();
+    }
+    if (_scanner.getToken() !== 4) {
+      handleError(8, [4], []);
+    } else {
+      scanNext();
+    }
+    return true;
+  }
+  function parseValue() {
+    switch (_scanner.getToken()) {
+      case 3:
+        return parseArray();
+      case 1:
+        return parseObject();
+      case 10:
+        return parseString(true);
+      default:
+        return parseLiteral();
+    }
+  }
+  scanNext();
+  if (_scanner.getToken() === 17) {
+    if (options.allowEmptyContent) {
+      return true;
+    }
+    handleError(4, [], []);
+    return false;
+  }
+  if (!parseValue()) {
+    handleError(4, [], []);
+    return false;
+  }
+  if (_scanner.getToken() !== 17) {
+    handleError(9, [], []);
+  }
+  return true;
+}
+
+// node_modules/jsonc-parser/lib/esm/main.js
+var ScanError;
+(function(ScanError2) {
+  ScanError2[ScanError2["None"] = 0] = "None";
+  ScanError2[ScanError2["UnexpectedEndOfComment"] = 1] = "UnexpectedEndOfComment";
+  ScanError2[ScanError2["UnexpectedEndOfString"] = 2] = "UnexpectedEndOfString";
+  ScanError2[ScanError2["UnexpectedEndOfNumber"] = 3] = "UnexpectedEndOfNumber";
+  ScanError2[ScanError2["InvalidUnicode"] = 4] = "InvalidUnicode";
+  ScanError2[ScanError2["InvalidEscapeCharacter"] = 5] = "InvalidEscapeCharacter";
+  ScanError2[ScanError2["InvalidCharacter"] = 6] = "InvalidCharacter";
+})(ScanError || (ScanError = {}));
+var SyntaxKind;
+(function(SyntaxKind2) {
+  SyntaxKind2[SyntaxKind2["OpenBraceToken"] = 1] = "OpenBraceToken";
+  SyntaxKind2[SyntaxKind2["CloseBraceToken"] = 2] = "CloseBraceToken";
+  SyntaxKind2[SyntaxKind2["OpenBracketToken"] = 3] = "OpenBracketToken";
+  SyntaxKind2[SyntaxKind2["CloseBracketToken"] = 4] = "CloseBracketToken";
+  SyntaxKind2[SyntaxKind2["CommaToken"] = 5] = "CommaToken";
+  SyntaxKind2[SyntaxKind2["ColonToken"] = 6] = "ColonToken";
+  SyntaxKind2[SyntaxKind2["NullKeyword"] = 7] = "NullKeyword";
+  SyntaxKind2[SyntaxKind2["TrueKeyword"] = 8] = "TrueKeyword";
+  SyntaxKind2[SyntaxKind2["FalseKeyword"] = 9] = "FalseKeyword";
+  SyntaxKind2[SyntaxKind2["StringLiteral"] = 10] = "StringLiteral";
+  SyntaxKind2[SyntaxKind2["NumericLiteral"] = 11] = "NumericLiteral";
+  SyntaxKind2[SyntaxKind2["LineCommentTrivia"] = 12] = "LineCommentTrivia";
+  SyntaxKind2[SyntaxKind2["BlockCommentTrivia"] = 13] = "BlockCommentTrivia";
+  SyntaxKind2[SyntaxKind2["LineBreakTrivia"] = 14] = "LineBreakTrivia";
+  SyntaxKind2[SyntaxKind2["Trivia"] = 15] = "Trivia";
+  SyntaxKind2[SyntaxKind2["Unknown"] = 16] = "Unknown";
+  SyntaxKind2[SyntaxKind2["EOF"] = 17] = "EOF";
+})(SyntaxKind || (SyntaxKind = {}));
+var parse2 = parse;
+var ParseErrorCode;
+(function(ParseErrorCode2) {
+  ParseErrorCode2[ParseErrorCode2["InvalidSymbol"] = 1] = "InvalidSymbol";
+  ParseErrorCode2[ParseErrorCode2["InvalidNumberFormat"] = 2] = "InvalidNumberFormat";
+  ParseErrorCode2[ParseErrorCode2["PropertyNameExpected"] = 3] = "PropertyNameExpected";
+  ParseErrorCode2[ParseErrorCode2["ValueExpected"] = 4] = "ValueExpected";
+  ParseErrorCode2[ParseErrorCode2["ColonExpected"] = 5] = "ColonExpected";
+  ParseErrorCode2[ParseErrorCode2["CommaExpected"] = 6] = "CommaExpected";
+  ParseErrorCode2[ParseErrorCode2["CloseBraceExpected"] = 7] = "CloseBraceExpected";
+  ParseErrorCode2[ParseErrorCode2["CloseBracketExpected"] = 8] = "CloseBracketExpected";
+  ParseErrorCode2[ParseErrorCode2["EndOfFileExpected"] = 9] = "EndOfFileExpected";
+  ParseErrorCode2[ParseErrorCode2["InvalidCommentToken"] = 10] = "InvalidCommentToken";
+  ParseErrorCode2[ParseErrorCode2["UnexpectedEndOfComment"] = 11] = "UnexpectedEndOfComment";
+  ParseErrorCode2[ParseErrorCode2["UnexpectedEndOfString"] = 12] = "UnexpectedEndOfString";
+  ParseErrorCode2[ParseErrorCode2["UnexpectedEndOfNumber"] = 13] = "UnexpectedEndOfNumber";
+  ParseErrorCode2[ParseErrorCode2["InvalidUnicode"] = 14] = "InvalidUnicode";
+  ParseErrorCode2[ParseErrorCode2["InvalidEscapeCharacter"] = 15] = "InvalidEscapeCharacter";
+  ParseErrorCode2[ParseErrorCode2["InvalidCharacter"] = 16] = "InvalidCharacter";
+})(ParseErrorCode || (ParseErrorCode = {}));
 
 // src/config/schema.ts
 import { z } from "zod";
@@ -101,7 +904,8 @@ var WeaveConfigSchema = z.object({
   analytics: AnalyticsConfigSchema.optional(),
   tmux: TmuxConfigSchema.optional(),
   experimental: ExperimentalConfigSchema.optional(),
-  workflows: WorkflowConfigSchema.optional()
+  workflows: WorkflowConfigSchema.optional(),
+  log_level: z.enum(["DEBUG", "INFO", "WARN", "ERROR"]).optional()
 });
 
 // src/config/merge.ts
@@ -141,30 +945,56 @@ function mergeConfigs(user, project) {
 }
 
 // src/shared/log.ts
-import * as fs from "fs";
-import * as path from "path";
-import * as os from "os";
-function getLogDir() {
-  const home = os.homedir();
-  return path.join(home, ".opencode", "logs");
+var LEVEL_PRIORITY = {
+  DEBUG: 0,
+  INFO: 1,
+  WARN: 2,
+  ERROR: 3
+};
+function parseLogLevel(value) {
+  if (value === "DEBUG" || value === "INFO" || value === "WARN" || value === "ERROR") {
+    return value;
+  }
+  return "INFO";
 }
-function resolveLogFile() {
-  const dir = getLogDir();
-  try {
-    if (!fs.existsSync(dir)) {
-      fs.mkdirSync(dir, { recursive: true });
+var activeLevel = parseLogLevel(process.env.WEAVE_LOG_LEVEL);
+var client = null;
+function setClient(c) {
+  client = c;
+}
+function setLogLevel(level) {
+  activeLevel = level;
+}
+function shouldLog(level) {
+  return LEVEL_PRIORITY[level] >= LEVEL_PRIORITY[activeLevel];
+}
+function emit(level, message, data) {
+  if (!shouldLog(level))
+    return;
+  const appRef = client?.app;
+  if (appRef && typeof appRef.log === "function") {
+    const extra = data !== undefined ? typeof data === "object" && data !== null ? data : { value: data } : undefined;
+    appRef.log({ body: { service: "weave", level: level.toLowerCase(), message, extra } }).catch(() => {});
+  } else {
+    if (level === "ERROR" || level === "WARN") {
+      console.error(`[weave:${level}] ${message}`, data ?? "");
     }
-  } catch {}
-  return path.join(dir, "weave-opencode.log");
+  }
+}
+function debug(message, data) {
+  emit("DEBUG", message, data);
+}
+function info(message, data) {
+  emit("INFO", message, data);
+}
+function warn(message, data) {
+  emit("WARN", message, data);
+}
+function error(message, data) {
+  emit("ERROR", message, data);
 }
-var LOG_FILE = resolveLogFile();
 function log(message, data) {
-  try {
-    const timestamp = new Date().toISOString();
-    const entry = `[${timestamp}] ${message}${data !== undefined ? " " + JSON.stringify(data) : ""}
-`;
-    fs.appendFileSync(LOG_FILE, entry);
-  } catch {}
+  info(message, data);
 }
 function logDelegation(event) {
   const prefix = `[delegation:${event.phase}]`;
@@ -181,38 +1011,49 @@ function readJsoncFile(filePath) {
   try {
     const text = readFileSync(filePath, "utf-8");
     const errors = [];
-    const parsed = parse(text, errors);
+    const parsed = parse2(text, errors);
     if (errors.length > 0) {
-      log(`JSONC parse warnings in ${filePath}: ${errors.length} issue(s)`);
+      warn(`JSONC parse warnings in ${filePath}: ${errors.length} issue(s)`);
     }
     return parsed ?? {};
   } catch (e) {
-    log(`Failed to read config file ${filePath}`, e);
+    error(`Failed to read config file ${filePath}`, e);
     return {};
   }
 }
 function detectConfigFile(basePath) {
   const jsoncPath = basePath + ".jsonc";
-  if (existsSync2(jsoncPath))
+  if (existsSync(jsoncPath))
     return jsoncPath;
   const jsonPath = basePath + ".json";
-  if (existsSync2(jsonPath))
+  if (existsSync(jsonPath))
     return jsonPath;
   return null;
 }
 function loadWeaveConfig(directory, _ctx, _homeDir) {
-  const userBasePath = join2(_homeDir ?? homedir2(), ".config", "opencode", "weave-opencode");
-  const projectBasePath = join2(directory, ".opencode", "weave-opencode");
+  const userBasePath = join(_homeDir ?? homedir(), ".config", "opencode", "weave-opencode");
+  const projectBasePath = join(directory, ".opencode", "weave-opencode");
   const userConfigPath = detectConfigFile(userBasePath);
   const projectConfigPath = detectConfigFile(projectBasePath);
+  debug("Loading Weave config", {
+    userConfig: userConfigPath ?? "(none)",
+    projectConfig: projectConfigPath ?? "(none)"
+  });
   const userRaw = userConfigPath ? readJsoncFile(userConfigPath) : {};
   const projectRaw = projectConfigPath ? readJsoncFile(projectConfigPath) : {};
   const merged = mergeConfigs(userRaw, projectRaw);
   const result = WeaveConfigSchema.safeParse(merged);
   if (!result.success) {
-    log("WeaveConfig validation errors — using defaults", result.error.issues);
+    error("WeaveConfig validation errors — using defaults", result.error.issues);
     return WeaveConfigSchema.parse({});
   }
+  debug("Weave config loaded successfully", {
+    hasAgentOverrides: !!result.data.agents && Object.keys(result.data.agents).length > 0,
+    disabledAgents: result.data.disabled_agents ?? [],
+    customAgents: result.data.custom_agents ? Object.keys(result.data.custom_agents) : [],
+    logLevel: result.data.log_level ?? "(default)",
+    analyticsEnabled: result.data.analytics?.enabled ?? false
+  });
   return result.data;
 }
 
@@ -510,9 +1351,9 @@ class BackgroundManager {
 }
 
 // src/managers/skill-mcp-manager.ts
-function createStdioClient(config, info) {
+function createStdioClient(config, info2) {
   const { command, args = [] } = config;
-  const { serverName, skillName } = info;
+  const { serverName, skillName } = info2;
   if (!command) {
     throw new Error(`missing 'command' field for stdio MCP server '${serverName}' in skill '${skillName}'`);
   }
@@ -541,28 +1382,28 @@ function createStdioClient(config, info) {
     }
   };
 }
-function getClientKey(info) {
-  return `${info.sessionID}:${info.skillName}:${info.serverName}`;
+function getClientKey(info2) {
+  return `${info2.sessionID}:${info2.skillName}:${info2.serverName}`;
 }
 
 class SkillMcpManager {
   clients = new Map;
-  async getOrCreateClient(info, config) {
-    const key = getClientKey(info);
+  async getOrCreateClient(info2, config) {
+    const key = getClientKey(info2);
     const existing = this.clients.get(key);
     if (existing) {
       return existing;
     }
-    const { serverName, skillName } = info;
+    const { serverName, skillName } = info2;
     if (config.type === "http") {
       throw new Error("HTTP MCP not supported in v1");
     }
     if (!config.command) {
       throw new Error(`missing 'command' field for stdio MCP server '${serverName}' in skill '${skillName}'`);
     }
-    const client = createStdioClient(config, info);
-    this.clients.set(key, client);
-    return client;
+    const client2 = createStdioClient(config, info2);
+    this.clients.set(key, client2);
+    return client2;
   }
   async disconnectSession(sessionID) {
     const prefix = `${sessionID}:`;
@@ -573,16 +1414,16 @@ class SkillMcpManager {
       }
     }
     await Promise.all(keysToRemove.map(async (key) => {
-      const client = this.clients.get(key);
-      if (client) {
-        await client.close();
+      const client2 = this.clients.get(key);
+      if (client2) {
+        await client2.close();
         this.clients.delete(key);
       }
     }));
   }
   async disconnectAll() {
-    await Promise.all(Array.from(this.clients.entries()).map(async ([key, client]) => {
-      await client.close();
+    await Promise.all(Array.from(this.clients.entries()).map(async ([key, client2]) => {
+      await client2.close();
       this.clients.delete(key);
     }));
     this.clients.clear();
@@ -590,19 +1431,19 @@ class SkillMcpManager {
   getConnectedServers() {
     return Array.from(this.clients.keys());
   }
-  isConnected(info) {
-    return this.clients.has(getClientKey(info));
+  isConnected(info2) {
+    return this.clients.has(getClientKey(info2));
   }
-  async callTool(info, config, name, args) {
+  async callTool(info2, config, name, args) {
     const maxAttempts = 3;
     let lastError = null;
     for (let attempt = 1;attempt <= maxAttempts; attempt++) {
       try {
-        const client = await this.getOrCreateClient(info, config);
-        const result = await client.callTool({ name, arguments: args });
+        const client2 = await this.getOrCreateClient(info2, config);
+        const result = await client2.callTool({ name, arguments: args });
         return result.content;
-      } catch (error) {
-        lastError = error instanceof Error ? error : new Error(String(error));
+      } catch (error2) {
+        lastError = error2 instanceof Error ? error2 : new Error(String(error2));
         if (!lastError.message.toLowerCase().includes("not connected")) {
           throw lastError;
         }
@@ -729,8 +1570,6 @@ function buildDelegationSection(disabled) {
     lines.push("- MUST use Warp for security audits when changes touch auth, crypto, certificates, tokens, signatures, input validation, secrets, passwords, sessions, CORS, CSP, .env files, or OAuth/OIDC/SAML flows — not optional.");
   }
   lines.push("- Delegate aggressively to keep your context lean");
-  lines.push("");
-  lines.push('RATIONALIZATION CHECK: If you catch yourself thinking "this is just a quick fix" but it touches 3+ files — delegate. Quick fixes that grow are the most common failure mode. When in doubt, delegate.');
   return `<Delegation>
 ${lines.join(`
 `)}
@@ -995,33 +1834,6 @@ After completing work for each task — BEFORE marking \`- [ ]\` → \`- [x]\`:
 **Gate**: Only mark complete when ALL checks pass. If ANY check fails, fix first.
 </Verification>`;
 }
-function buildTapestryVerificationGateSection() {
-  return `<VerificationGate>
-BEFORE claiming ANY status — "done", "passes", "works", "fixed", "complete":
-
-1. IDENTIFY: What command proves this claim? (test runner, build, linter, curl, etc.)
-2. RUN: Execute the command NOW — fresh, complete, in this message
-3. READ: Check exit code, count failures, read full output
-4. VERIFY: Does the output confirm the claim?
-   - YES → State the claim WITH the evidence
-   - NO → State actual status with evidence. Fix. Re-run.
-
-| Claim | Requires | NOT Sufficient |
-|-------|----------|----------------|
-| "Tests pass" | Test command output showing 0 failures | Previous run, "should pass", partial suite |
-| "Build succeeds" | Build command with exit 0 | Linter passing, "looks correct" |
-| "Bug is fixed" | Failing test now passes | "Code changed, should be fixed" |
-| "No regressions" | Full test suite output | Spot-checking a few files |
-
-RED FLAGS — if you catch yourself writing these, STOP:
-- "should", "probably", "seems to", "looks correct"
-- "Great!", "Done!", "Perfect!" before running verification
-- Claiming completion based on a previous run
-- Trusting your own Edit/Write calls without reading the result
-
-**Verification you didn't run in this message does not exist.**
-</VerificationGate>`;
-}
 function buildTapestryPostExecutionReviewSection(disabled) {
   const hasWeft = isAgentEnabled("weft", disabled);
   const hasWarp = isAgentEnabled("warp", disabled);
@@ -1067,30 +1879,6 @@ function buildTapestryExecutionSection() {
 - Report completion with evidence (test output, file paths, commands run)
 </Execution>`;
 }
-function buildTapestryDebuggingSection() {
-  return `<WhenStuck>
-When a task fails or produces unexpected results:
-
-1. **Read error messages completely** — stack traces, line numbers, exit codes. They often contain the answer.
-2. **Form a single hypothesis** — "I think X is the root cause because Y." Be specific.
-3. **Make the smallest possible change** to test that hypothesis. One variable at a time.
-4. **Verify** — did it work? If yes, continue. If no, form a NEW hypothesis.
-
-ESCALATION RULE:
-- Fix attempt #1 failed → re-read errors, try different hypothesis
-- Fix attempt #2 failed → step back, trace the data flow from source to error
-- Fix attempt #3 failed → **STOP. Do NOT attempt fix #4.**
-  - Document: what you tried, what happened, what you think the root cause is
-  - Report to the user: "Blocked after 3 attempts on task N. Here's what I've tried: [...]"
-  - This is likely an architectural issue, not a code bug. The user needs to decide.
-
-RED FLAGS — you are debugging wrong if you:
-- Propose fixes without reading the error message carefully
-- Change multiple things at once ("shotgun debugging")
-- Re-try the same approach hoping for a different result
-- Think "just one more fix" after 2 failures
-</WhenStuck>`;
-}
 function buildTapestryStyleSection() {
   return `<Style>
 - Terse status updates only
@@ -1106,10 +1894,8 @@ function composeTapestryPrompt(options = {}) {
     buildTapestrySidebarTodosSection(),
     buildTapestryPlanExecutionSection(disabled),
     buildTapestryVerificationSection(),
-    buildTapestryVerificationGateSection(),
     buildTapestryPostExecutionReviewSection(disabled),
     buildTapestryExecutionSection(),
-    buildTapestryDebuggingSection(),
     buildTapestryStyleSection()
   ];
   return sections.join(`
@@ -1270,30 +2056,6 @@ FILES FIELD: For verification-only tasks that have no associated files (e.g., "r
 - After completing a plan, tell the user: "Plan saved to \`.weave/plans/{name}.md\`. Run /start-work to begin execution."
 </Constraints>
 
-<NoPlaceholders>
-Every task must contain the actual detail an engineer needs to start working. These are PLAN FAILURES — never write them:
-
-- "TBD", "TODO", "implement later", "fill in details"
-- "Add appropriate error handling" / "add validation" / "handle edge cases"
-- "Write tests for the above" (without describing what to test)
-- "Similar to Task N" (repeat the detail — the executor may read tasks independently)
-- Steps that describe WHAT to do without specifying HOW (file paths, approach, acceptance criteria required)
-- References to types, functions, or files that aren't defined or explained in any task
-
-If you can't specify something concretely, you haven't researched enough. Go read more code.
-</NoPlaceholders>
-
-<SelfReview>
-After writing the complete plan, review it with fresh eyes:
-
-1. **Requirement coverage**: Re-read the original request. Can you point to a task for each requirement? List any gaps.
-2. **Placeholder scan**: Search your plan for any patterns from the \`<NoPlaceholders>\` list above. Fix them.
-3. **Name consistency**: Do file paths, function names, and type names used in later tasks match what you defined in earlier tasks? A function called \`createUser()\` in Task 2 but \`addUser()\` in Task 5 is a bug.
-4. **Dependency order**: Can each task be started after completing only the tasks before it? If Task 4 depends on Task 6, reorder.
-
-Fix any issues inline. Then report the plan as complete.
-</SelfReview>
-
 <Research>
 - Read relevant files before planning
 - Check existing patterns in the codebase
@@ -1422,10 +2184,9 @@ You operate in two modes depending on what you're asked to review:
 
 **Work Review** (reviewing completed implementation):
 - Read every changed file (use git diff --stat, then Read each file)
-- Do NOT trust commit messages, PR descriptions, or task completion claims — the implementer may have been optimistic or incomplete. Verify everything by reading the actual code.
-- Check spec compliance FIRST: does the code do what the task required? If it doesn't match requirements, reject before evaluating code quality.
-- Then check code quality: look for stubs, TODOs, placeholders, hardcoded values
-- Verify tests exist and test real behavior (not mocks of mocks)
+- Check the code actually does what the task required
+- Look for stubs, TODOs, placeholders, hardcoded values
+- Verify tests exist and test real behavior
 - Check for scope creep (changes outside the task spec)
 </ReviewModes>
 
@@ -1733,34 +2494,47 @@ var AGENT_MODEL_REQUIREMENTS = {
 function resolveAgentModel(agentName, options) {
   const { availableModels, agentMode, uiSelectedModel, categoryModel, overrideModel, systemDefaultModel, customFallbackChain } = options;
   const requirement = AGENT_MODEL_REQUIREMENTS[agentName];
-  if (overrideModel)
+  if (overrideModel) {
+    debug(`Model resolved for "${agentName}"`, { via: "override", model: overrideModel });
     return overrideModel;
+  }
   if (uiSelectedModel && (agentMode === "primary" || agentMode === "all")) {
+    debug(`Model resolved for "${agentName}"`, { via: "ui-selection", model: uiSelectedModel, agentMode });
     return uiSelectedModel;
   }
-  if (categoryModel && availableModels.has(categoryModel))
+  if (categoryModel && availableModels.has(categoryModel)) {
+    debug(`Model resolved for "${agentName}"`, { via: "category", model: categoryModel });
     return categoryModel;
+  }
   const fallbackChain = requirement?.fallbackChain ?? customFallbackChain;
   if (fallbackChain) {
     for (const entry of fallbackChain) {
       for (const provider of entry.providers) {
         const qualified = `${provider}/${entry.model}`;
-        if (availableModels.has(qualified))
+        if (availableModels.has(qualified)) {
+          debug(`Model resolved for "${agentName}"`, { via: "fallback-chain", model: qualified });
           return qualified;
-        if (availableModels.has(entry.model))
+        }
+        if (availableModels.has(entry.model)) {
+          debug(`Model resolved for "${agentName}"`, { via: "fallback-chain", model: entry.model });
           return entry.model;
+        }
       }
     }
   }
-  if (systemDefaultModel)
+  if (systemDefaultModel) {
+    debug(`Model resolved for "${agentName}"`, { via: "system-default", model: systemDefaultModel });
     return systemDefaultModel;
+  }
   if (fallbackChain && fallbackChain.length > 0) {
     const first = fallbackChain[0];
     if (first.providers.length > 0) {
-      return `${first.providers[0]}/${first.model}`;
+      const guessed = `${first.providers[0]}/${first.model}`;
+      debug(`Model resolved for "${agentName}" (offline best-guess — no available models matched)`, { via: "offline-guess", model: guessed });
+      return guessed;
     }
   }
-  console.warn(`[weave] No model resolved for agent "${agentName}" — falling back to default github-copilot/claude-opus-4.6`);
+  warn(`No model resolved for agent "${agentName}" — falling back to default github-copilot/claude-opus-4.6`, { agentName });
   return "github-copilot/claude-opus-4.6";
 }
 
@@ -1873,8 +2647,10 @@ function createBuiltinAgents(options = {}) {
   const disabledSet = new Set(disabledAgents);
   const result = {};
   for (const [name, factory] of Object.entries(AGENT_FACTORIES)) {
-    if (disabledSet.has(name))
+    if (disabledSet.has(name)) {
+      debug(`Builtin agent "${name}" is disabled — skipping`);
       continue;
+    }
     const override = agentOverrides[name];
     const overrideModel = override?.model;
     const resolvedModel = resolveAgentModel(name, {
@@ -1884,6 +2660,9 @@ function createBuiltinAgents(options = {}) {
       systemDefaultModel,
       overrideModel
     });
+    if (overrideModel) {
+      debug(`Builtin agent "${name}" model overridden via config`, { model: resolvedModel });
+    }
     let built;
     if (name === "loom") {
       built = createLoomAgentWithOptions(resolvedModel, disabledSet, fingerprint, customAgentMetadata);
@@ -1921,7 +2700,7 @@ function createBuiltinAgents(options = {}) {
 }
 
 // src/agents/prompt-loader.ts
-import { readFileSync as readFileSync2, existsSync as existsSync3 } from "fs";
+import { readFileSync as readFileSync2, existsSync as existsSync2 } from "fs";
 import { resolve, isAbsolute as isAbsolute2, normalize, sep } from "path";
 function loadPromptFile(promptFilePath, basePath) {
   if (isAbsolute2(promptFilePath)) {
@@ -1932,7 +2711,7 @@ function loadPromptFile(promptFilePath, basePath) {
   if (!resolvedPath.startsWith(base + sep) && resolvedPath !== base) {
     return null;
   }
-  if (!existsSync3(resolvedPath)) {
+  if (!existsSync2(resolvedPath)) {
     return null;
   }
   return readFileSync2(resolvedPath, "utf-8").trim();
@@ -1968,11 +2747,17 @@ function buildCustomAgent(name, config, options = {}) {
   }
   const { resolveSkills, disabledSkills, availableModels = new Set, systemDefaultModel, uiSelectedModel, configDir } = options;
   let prompt = config.prompt ?? "";
+  let promptSource = "inline";
   if (config.prompt_file) {
     const fileContent = loadPromptFile(config.prompt_file, configDir);
     if (fileContent) {
       prompt = fileContent;
+      promptSource = `file:${config.prompt_file}`;
+    } else {
+      promptSource = `file:${config.prompt_file} (not found — falling back to inline)`;
     }
+  } else if (config.skills?.length) {
+    promptSource = `skills:[${config.skills.join(",")}]`;
   }
   if (config.skills?.length && resolveSkills) {
     const skillContent = resolveSkills(config.skills, disabledSkills);
@@ -1995,6 +2780,13 @@ function buildCustomAgent(name, config, options = {}) {
   const displayName = config.display_name ?? name;
   registerAgentDisplayName(name, displayName);
   registerAgentNameVariants(name, displayName !== name ? [name, displayName] : undefined);
+  debug(`Custom agent "${name}" built`, {
+    model,
+    displayName,
+    mode,
+    promptSource,
+    hasPrompt: !!prompt
+  });
   const agentConfig = {
     model,
     prompt: prompt || undefined,
@@ -2062,7 +2854,7 @@ function createManagers(options) {
           }
         } catch (err) {
           if (err instanceof Error && err.message.includes("not a built-in agent")) {
-            log(`Skipping display_name override for non-builtin agent "${name}"`);
+            debug(`Skipping display_name override for non-builtin agent "${name}"`);
           } else {
             throw err;
           }
@@ -2095,8 +2887,8 @@ function createManagers(options) {
 }
 
 // src/features/skill-loader/loader.ts
-import * as path3 from "path";
-import * as os2 from "os";
+import * as path2 from "path";
+import * as os from "os";
 
 // src/features/skill-loader/opencode-client.ts
 function deriveScope(location) {
@@ -2111,11 +2903,11 @@ async function fetchSkillsFromOpenCode(serverUrl, directory) {
   try {
     response = await fetch(url, { signal: AbortSignal.timeout(3000) });
   } catch (err) {
-    log("Failed to fetch skills from OpenCode — skills will not be loaded", { url, error: String(err) });
+    error("Failed to fetch skills from OpenCode — skills will not be loaded", { url, error: String(err) });
     return [];
   }
   if (!response.ok) {
-    log("OpenCode /skill endpoint returned non-OK status — skills will not be loaded", {
+    warn("OpenCode /skill endpoint returned non-OK status — skills will not be loaded", {
       url,
       status: response.status
     });
@@ -2125,11 +2917,11 @@ async function fetchSkillsFromOpenCode(serverUrl, directory) {
   try {
     data = await response.json();
   } catch (err) {
-    log("Failed to parse skills response from OpenCode", { url, error: String(err) });
+    error("Failed to parse skills response from OpenCode", { url, error: String(err) });
     return [];
   }
   if (!Array.isArray(data)) {
-    log("Unexpected skills response shape from OpenCode — expected array", { url });
+    warn("Unexpected skills response shape from OpenCode — expected array", { url });
     return [];
   }
   const skills = [];
@@ -2148,8 +2940,8 @@ async function fetchSkillsFromOpenCode(serverUrl, directory) {
 }
 
 // src/features/skill-loader/discovery.ts
-import * as fs2 from "fs";
-import * as path2 from "path";
+import * as fs from "fs";
+import * as path from "path";
 function parseFrontmatter(text) {
   const frontmatterRegex = /^---\r?\n([\s\S]*?)\r?\n---\r?\n([\s\S]*)$/;
   const match = frontmatterRegex.exec(text);
@@ -2196,7 +2988,7 @@ function parseFrontmatter(text) {
       i++;
     }
   } catch (err) {
-    log("Failed to parse YAML frontmatter", { error: String(err) });
+    warn("Failed to parse YAML frontmatter", { error: String(err) });
     return { metadata: {}, content: text };
   }
   return { metadata, content: body };
@@ -2224,22 +3016,22 @@ function setMetadataField(metadata, key, value) {
 }
 function scanDirectory(options) {
   const { directory, scope } = options;
-  if (!fs2.existsSync(directory)) {
+  if (!fs.existsSync(directory)) {
     return [];
   }
   let entries;
   try {
-    entries = fs2.readdirSync(directory, { withFileTypes: true });
+    entries = fs.readdirSync(directory, { withFileTypes: true });
   } catch (err) {
-    log("Failed to read skills directory", { directory, error: String(err) });
+    warn("Failed to read skills directory", { directory, error: String(err) });
     return [];
   }
   const skills = [];
   for (const entry of entries) {
-    const fullPath = path2.join(directory, entry.name);
+    const fullPath = path.join(directory, entry.name);
     if (entry.isDirectory()) {
-      const skillFile = path2.join(fullPath, "SKILL.md");
-      if (fs2.existsSync(skillFile)) {
+      const skillFile = path.join(fullPath, "SKILL.md");
+      if (fs.existsSync(skillFile)) {
         const skill = loadSkillFile(skillFile, scope);
         if (skill)
           skills.push(skill);
@@ -2257,14 +3049,14 @@ function scanDirectory(options) {
 function loadSkillFile(filePath, scope) {
   let text;
   try {
-    text = fs2.readFileSync(filePath, "utf8");
+    text = fs.readFileSync(filePath, "utf8");
   } catch (err) {
-    log("Failed to read skill file", { filePath, error: String(err) });
+    warn("Failed to read skill file", { filePath, error: String(err) });
     return null;
   }
   const { metadata, content } = parseFrontmatter(text);
   if (!metadata.name) {
-    log("Skill file missing name in frontmatter — skipping", { filePath });
+    debug("Skill file missing name in frontmatter — skipping", { filePath });
     return null;
   }
   return { name: metadata.name, description: metadata.description ?? "", content, scope, path: filePath, model: metadata.model };
@@ -2292,8 +3084,8 @@ function resolveSafePath(dir, projectRoot) {
 
 // src/features/skill-loader/loader.ts
 function scanFilesystemSkills(directory, customDirs) {
-  const userDir = path3.join(os2.homedir(), ".config", "opencode", "skills");
-  const projectDir = path3.join(directory, ".opencode", "skills");
+  const userDir = path2.join(os.homedir(), ".config", "opencode", "skills");
+  const projectDir = path2.join(directory, ".opencode", "skills");
   const userSkills = scanDirectory({ directory: userDir, scope: "user" });
   const projectSkills = scanDirectory({ directory: projectDir, scope: "project" });
   const customSkills = [];
@@ -2324,7 +3116,7 @@ async function loadSkills(options) {
   const fsSkills = scanFilesystemSkills(directory, customDirs);
   const skills = mergeSkillSources(apiSkills, fsSkills);
   if (apiSkills.length === 0 && fsSkills.length > 0) {
-    log("OpenCode API returned no skills — using filesystem fallback", {
+    debug("OpenCode API returned no skills — using filesystem fallback", {
       fsSkillCount: fsSkills.length,
       fsSkillNames: fsSkills.map((s) => s.name)
     });
@@ -2382,11 +3174,11 @@ function checkContextWindow(state, thresholds = { warningPct: 0.8, criticalPct:
   const usagePct = state.maxTokens > 0 ? state.usedTokens / state.maxTokens : 0;
   if (usagePct >= thresholds.criticalPct) {
     const message = buildRecoveryMessage(state, usagePct);
-    log(`[context-window] CRITICAL ${(usagePct * 100).toFixed(1)}% used in session ${state.sessionId}`);
+    warn(`[context-window] CRITICAL ${(usagePct * 100).toFixed(1)}% used in session ${state.sessionId}`);
     return { action: "recover", usagePct, message };
   }
   if (usagePct >= thresholds.warningPct) {
-    log(`[context-window] WARNING ${(usagePct * 100).toFixed(1)}% used in session ${state.sessionId}`);
+    warn(`[context-window] WARNING ${(usagePct * 100).toFixed(1)}% used in session ${state.sessionId}`);
     return { action: "warn", usagePct, message: buildWarningMessage(usagePct) };
   }
   return { action: "none", usagePct };
@@ -2411,7 +3203,7 @@ Update the sidebar: use todowrite to create a todo (in_progress, high priority):
 }
 
 // src/hooks/write-existing-file-guard.ts
-import * as fs3 from "fs";
+import * as fs2 from "fs";
 function createWriteGuardState() {
   return { readFiles: new Set };
 }
@@ -2419,14 +3211,14 @@ function trackFileRead(state, filePath) {
   state.readFiles.add(filePath);
 }
 function checkWriteAllowed(state, filePath) {
-  if (!fs3.existsSync(filePath)) {
+  if (!fs2.existsSync(filePath)) {
     return { allowed: true };
   }
   if (state.readFiles.has(filePath)) {
     return { allowed: true };
   }
   const warning = `⚠️ Write guard: Attempting to write to '${filePath}' without reading it first. Read the file before overwriting to avoid data loss.`;
-  log(`[write-guard] BLOCKED write to unread file: ${filePath}`);
+  warn(`[write-guard] BLOCKED write to unread file: ${filePath}`);
   return { allowed: false, warning };
 }
 function createWriteGuard(state) {
@@ -2437,13 +3229,13 @@ function createWriteGuard(state) {
 }
 
 // src/hooks/rules-injector.ts
-import * as fs4 from "fs";
-import * as path4 from "path";
+import * as fs3 from "fs";
+import * as path3 from "path";
 var RULES_FILENAMES = ["AGENTS.md", ".rules", "CLAUDE.md"];
 function findRulesFile(directory) {
   for (const filename of RULES_FILENAMES) {
-    const candidate = path4.join(directory, filename);
-    if (fs4.existsSync(candidate)) {
+    const candidate = path3.join(directory, filename);
+    if (fs3.existsSync(candidate)) {
       return candidate;
     }
   }
@@ -2454,11 +3246,11 @@ function loadRulesForDirectory(directory) {
   if (!rulesFile)
     return;
   try {
-    const content = fs4.readFileSync(rulesFile, "utf8");
-    log(`[rules-injector] Loaded rules from ${rulesFile}`);
+    const content = fs3.readFileSync(rulesFile, "utf8");
+    debug(`[rules-injector] Loaded rules from ${rulesFile}`);
     return content;
   } catch {
-    log(`[rules-injector] Failed to read rules file: ${rulesFile}`);
+    warn(`[rules-injector] Failed to read rules file: ${rulesFile}`);
     return;
   }
 }
@@ -2466,7 +3258,7 @@ function shouldInjectRules(toolName) {
   return toolName === "read" || toolName === "write" || toolName === "edit";
 }
 function getDirectoryFromFilePath(filePath) {
-  return path4.dirname(path4.resolve(filePath));
+  return path3.dirname(path3.resolve(filePath));
 }
 function buildRulesInjection(rulesContent, directory) {
   return `<rules source="${directory}">
@@ -2525,7 +3317,7 @@ function buildKeywordInjection(detected) {
 function processMessageForKeywords(message, sessionId, actions) {
   const detected = detectKeywords(message, actions);
   if (detected.length > 0) {
-    log(`[keyword-detector] Detected keywords in session ${sessionId}: ${detected.map((a) => a.keyword).join(", ")}`);
+    debug(`[keyword-detector] Detected keywords in session ${sessionId}: ${detected.map((a) => a.keyword).join(", ")}`);
   }
   return buildKeywordInjection(detected);
 }
@@ -2562,15 +3354,15 @@ var WORK_STATE_FILE = "state.json";
 var WORK_STATE_PATH = `${WEAVE_DIR}/${WORK_STATE_FILE}`;
 var PLANS_DIR = `${WEAVE_DIR}/plans`;
 // src/features/work-state/storage.ts
-import { existsSync as existsSync7, readFileSync as readFileSync5, writeFileSync, unlinkSync, mkdirSync as mkdirSync2, readdirSync as readdirSync2, statSync } from "fs";
-import { join as join6, basename } from "path";
+import { existsSync as existsSync6, readFileSync as readFileSync5, writeFileSync, unlinkSync, mkdirSync, readdirSync as readdirSync2, statSync } from "fs";
+import { join as join5, basename } from "path";
 import { execSync } from "child_process";
 var UNCHECKED_RE = /^[-*]\s*\[\s*\]/gm;
 var CHECKED_RE = /^[-*]\s*\[[xX]\]/gm;
 function readWorkState(directory) {
-  const filePath = join6(directory, WEAVE_DIR, WORK_STATE_FILE);
+  const filePath = join5(directory, WEAVE_DIR, WORK_STATE_FILE);
   try {
-    if (!existsSync7(filePath))
+    if (!existsSync6(filePath))
       return null;
     const raw = readFileSync5(filePath, "utf-8");
     const parsed = JSON.parse(raw);
@@ -2588,20 +3380,20 @@ function readWorkState(directory) {
 }
 function writeWorkState(directory, state) {
   try {
-    const dir = join6(directory, WEAVE_DIR);
-    if (!existsSync7(dir)) {
-      mkdirSync2(dir, { recursive: true });
+    const dir = join5(directory, WEAVE_DIR);
+    if (!existsSync6(dir)) {
+      mkdirSync(dir, { recursive: true });
     }
-    writeFileSync(join6(dir, WORK_STATE_FILE), JSON.stringify(state, null, 2), "utf-8");
+    writeFileSync(join5(dir, WORK_STATE_FILE), JSON.stringify(state, null, 2), "utf-8");
     return true;
   } catch {
     return false;
   }
 }
 function clearWorkState(directory) {
-  const filePath = join6(directory, WEAVE_DIR, WORK_STATE_FILE);
+  const filePath = join5(directory, WEAVE_DIR, WORK_STATE_FILE);
   try {
-    if (existsSync7(filePath)) {
+    if (existsSync6(filePath)) {
       unlinkSync(filePath);
     }
     return true;
@@ -2643,12 +3435,12 @@ function getHeadSha(directory) {
   }
 }
 function findPlans(directory) {
-  const plansDir = join6(directory, PLANS_DIR);
+  const plansDir = join5(directory, PLANS_DIR);
   try {
-    if (!existsSync7(plansDir))
+    if (!existsSync6(plansDir))
       return [];
     const files = readdirSync2(plansDir).filter((f) => f.endsWith(".md")).map((f) => {
-      const fullPath = join6(plansDir, f);
+      const fullPath = join5(plansDir, f);
       const stat = statSync(fullPath);
       return { path: fullPath, mtime: stat.mtimeMs };
     }).sort((a, b) => b.mtime - a.mtime).map((f) => f.path);
@@ -2658,7 +3450,7 @@ function findPlans(directory) {
   }
 }
 function getPlanProgress(planPath) {
-  if (!existsSync7(planPath)) {
+  if (!existsSync6(planPath)) {
     return { total: 0, completed: 0, isComplete: true };
   }
   try {
@@ -2694,7 +3486,7 @@ function resumeWork(directory) {
   return writeWorkState(directory, state);
 }
 // src/features/work-state/validation.ts
-import { readFileSync as readFileSync6, existsSync as existsSync8 } from "fs";
+import { readFileSync as readFileSync6, existsSync as existsSync7 } from "fs";
 import { resolve as resolve4, sep as sep3 } from "path";
 function validatePlan(planPath, projectDir) {
   const errors = [];
@@ -2709,7 +3501,7 @@ function validatePlan(planPath, projectDir) {
     });
     return { valid: false, errors, warnings };
   }
-  if (!existsSync8(resolvedPlanPath)) {
+  if (!existsSync7(resolvedPlanPath)) {
     errors.push({
       severity: "error",
       category: "structure",
@@ -2899,7 +3691,7 @@ function validateFileReferences(content, projectDir, warnings) {
         });
         continue;
       }
-      if (!existsSync8(absolutePath)) {
+      if (!existsSync7(absolutePath)) {
         warnings.push({
           severity: "warning",
           category: "file-references",
@@ -2990,8 +3782,8 @@ var ACTIVE_INSTANCE_FILE = "active-instance.json";
 var WORKFLOWS_DIR_PROJECT = ".opencode/workflows";
 var WORKFLOWS_DIR_USER = "workflows";
 // src/features/workflow/storage.ts
-import { existsSync as existsSync9, readFileSync as readFileSync7, writeFileSync as writeFileSync2, unlinkSync as unlinkSync2, mkdirSync as mkdirSync3, readdirSync as readdirSync3 } from "fs";
-import { join as join7 } from "path";
+import { existsSync as existsSync8, readFileSync as readFileSync7, writeFileSync as writeFileSync2, unlinkSync as unlinkSync2, mkdirSync as mkdirSync2, readdirSync as readdirSync3 } from "fs";
+import { join as join6 } from "path";
 import { randomBytes } from "node:crypto";
 function generateInstanceId() {
   return `wf_${randomBytes(4).toString("hex")}`;
@@ -3027,9 +3819,9 @@ function createWorkflowInstance(definition, definitionPath, goal, sessionId) {
   };
 }
 function readWorkflowInstance(directory, instanceId) {
-  const filePath = join7(directory, WORKFLOWS_STATE_DIR, instanceId, INSTANCE_STATE_FILE);
+  const filePath = join6(directory, WORKFLOWS_STATE_DIR, instanceId, INSTANCE_STATE_FILE);
   try {
-    if (!existsSync9(filePath))
+    if (!existsSync8(filePath))
       return null;
     const raw = readFileSync7(filePath, "utf-8");
     const parsed = JSON.parse(raw);
@@ -3044,20 +3836,20 @@ function readWorkflowInstance(directory, instanceId) {
 }
 function writeWorkflowInstance(directory, instance) {
   try {
-    const dir = join7(directory, WORKFLOWS_STATE_DIR, instance.instance_id);
-    if (!existsSync9(dir)) {
-      mkdirSync3(dir, { recursive: true });
+    const dir = join6(directory, WORKFLOWS_STATE_DIR, instance.instance_id);
+    if (!existsSync8(dir)) {
+      mkdirSync2(dir, { recursive: true });
     }
-    writeFileSync2(join7(dir, INSTANCE_STATE_FILE), JSON.stringify(instance, null, 2), "utf-8");
+    writeFileSync2(join6(dir, INSTANCE_STATE_FILE), JSON.stringify(instance, null, 2), "utf-8");
     return true;
   } catch {
     return false;
   }
 }
 function readActiveInstance(directory) {
-  const filePath = join7(directory, WORKFLOWS_STATE_DIR, ACTIVE_INSTANCE_FILE);
+  const filePath = join6(directory, WORKFLOWS_STATE_DIR, ACTIVE_INSTANCE_FILE);
   try {
-    if (!existsSync9(filePath))
+    if (!existsSync8(filePath))
       return null;
     const raw = readFileSync7(filePath, "utf-8");
     const parsed = JSON.parse(raw);
@@ -3070,21 +3862,21 @@ function readActiveInstance(directory) {
 }
 function setActiveInstance(directory, instanceId) {
   try {
-    const dir = join7(directory, WORKFLOWS_STATE_DIR);
-    if (!existsSync9(dir)) {
-      mkdirSync3(dir, { recursive: true });
+    const dir = join6(directory, WORKFLOWS_STATE_DIR);
+    if (!existsSync8(dir)) {
+      mkdirSync2(dir, { recursive: true });
     }
     const pointer = { instance_id: instanceId };
-    writeFileSync2(join7(dir, ACTIVE_INSTANCE_FILE), JSON.stringify(pointer, null, 2), "utf-8");
+    writeFileSync2(join6(dir, ACTIVE_INSTANCE_FILE), JSON.stringify(pointer, null, 2), "utf-8");
     return true;
   } catch {
     return false;
   }
 }
 function clearActiveInstance(directory) {
-  const filePath = join7(directory, WORKFLOWS_STATE_DIR, ACTIVE_INSTANCE_FILE);
+  const filePath = join6(directory, WORKFLOWS_STATE_DIR, ACTIVE_INSTANCE_FILE);
   try {
-    if (existsSync9(filePath)) {
+    if (existsSync8(filePath)) {
       unlinkSync2(filePath);
     }
     return true;
@@ -3099,10 +3891,9 @@ function getActiveWorkflowInstance(directory) {
   return readWorkflowInstance(directory, pointer.instance_id);
 }
 // src/features/workflow/discovery.ts
-import * as fs5 from "fs";
-import * as path5 from "path";
-import * as os3 from "os";
-import { parse as parseJsonc } from "jsonc-parser";
+import * as fs4 from "fs";
+import * as path4 from "path";
+import * as os2 from "os";
 
 // src/features/workflow/schema.ts
 import { z as z2 } from "zod";
@@ -3140,21 +3931,21 @@ var WorkflowDefinitionSchema = z2.object({
 function loadWorkflowDefinition(filePath) {
   let raw;
   try {
-    raw = fs5.readFileSync(filePath, "utf-8");
+    raw = fs4.readFileSync(filePath, "utf-8");
   } catch (err) {
-    log("Failed to read workflow definition file", { filePath, error: String(err) });
+    error("Failed to read workflow definition file", { filePath, error: String(err) });
     return null;
   }
   let parsed;
   try {
-    parsed = parseJsonc(raw);
+    parsed = parse2(raw);
   } catch (err) {
-    log("Failed to parse workflow definition JSONC", { filePath, error: String(err) });
+    error("Failed to parse workflow definition JSONC", { filePath, error: String(err) });
     return null;
   }
   const result = WorkflowDefinitionSchema.safeParse(parsed);
   if (!result.success) {
-    log("Workflow definition failed validation", {
+    warn("Workflow definition failed validation", {
       filePath,
       errors: result.error.issues.map((i) => i.message)
     });
@@ -3163,13 +3954,13 @@ function loadWorkflowDefinition(filePath) {
   return result.data;
 }
 function scanWorkflowDirectory(directory, scope) {
-  if (!fs5.existsSync(directory))
+  if (!fs4.existsSync(directory))
     return [];
   let entries;
   try {
-    entries = fs5.readdirSync(directory, { withFileTypes: true });
+    entries = fs4.readdirSync(directory, { withFileTypes: true });
   } catch (err) {
-    log("Failed to read workflows directory", { directory, error: String(err) });
+    warn("Failed to read workflows directory", { directory, error: String(err) });
     return [];
   }
   const workflows = [];
@@ -3178,7 +3969,7 @@ function scanWorkflowDirectory(directory, scope) {
       continue;
     if (!entry.name.endsWith(".jsonc") && !entry.name.endsWith(".json"))
       continue;
-    const filePath = path5.join(directory, entry.name);
+    const filePath = path4.join(directory, entry.name);
     const definition = loadWorkflowDefinition(filePath);
     if (definition) {
       workflows.push({ definition, path: filePath, scope });
@@ -3187,8 +3978,8 @@ function scanWorkflowDirectory(directory, scope) {
   return workflows;
 }
 function discoverWorkflows(directory, customDirs) {
-  const projectDir = path5.join(directory, WORKFLOWS_DIR_PROJECT);
-  const userDir = path5.join(os3.homedir(), ".config", "opencode", WORKFLOWS_DIR_USER);
+  const projectDir = path4.join(directory, WORKFLOWS_DIR_PROJECT);
+  const userDir = path4.join(os2.homedir(), ".config", "opencode", WORKFLOWS_DIR_USER);
   const userWorkflows = scanWorkflowDirectory(userDir, "user");
   const projectWorkflows = scanWorkflowDirectory(projectDir, "project");
   const customWorkflows = [];
@@ -3310,8 +4101,8 @@ function truncateSummary(text) {
   return text.slice(0, maxLength - 3) + "...";
 }
 // src/features/workflow/completion.ts
-import { existsSync as existsSync11 } from "fs";
-import { join as join9 } from "path";
+import { existsSync as existsSync10 } from "fs";
+import { join as join8 } from "path";
 var DEFAULT_CONFIRM_KEYWORDS = ["confirmed", "approved", "continue", "done", "let's proceed", "looks good", "lgtm"];
 var VERDICT_APPROVE_RE = /\[\s*APPROVE\s*\]/i;
 var VERDICT_REJECT_RE = /\[\s*REJECT\s*\]/i;
@@ -3363,8 +4154,8 @@ function checkPlanCreated(context) {
       summary: `Plan created at ${matchingPlan}`
     };
   }
-  const directPath = join9(directory, ".weave", "plans", `${planName}.md`);
-  if (existsSync11(directPath)) {
+  const directPath = join8(directory, ".weave", "plans", `${planName}.md`);
+  if (existsSync10(directPath)) {
     return {
       complete: true,
       artifacts: { plan_path: directPath },
@@ -3379,8 +4170,8 @@ function checkPlanComplete(context) {
   if (!planName) {
     return { complete: false, reason: "plan_complete requires plan_name in completion config" };
   }
-  const planPath = join9(directory, ".weave", "plans", `${planName}.md`);
-  if (!existsSync11(planPath)) {
+  const planPath = join8(directory, ".weave", "plans", `${planName}.md`);
+  if (!existsSync10(planPath)) {
     return { complete: false, reason: `Plan file not found: ${planPath}` };
   }
   const progress = getPlanProgress(planPath);
@@ -3811,7 +4602,7 @@ ${available ? `Available workflows: ${available}` : "No workflow definitions ava
     sessionId,
     directory
   });
-  log("Workflow started", {
+  info("Workflow started", {
     workflowName: match.definition.name,
     goal,
     agent: action.agent
@@ -4176,8 +4967,8 @@ function formatValidationResults(result) {
     if (result.errors.length > 0)
       lines.push("");
     lines.push("**Warnings:**");
-    for (const warn of result.warnings) {
-      lines.push(`- [${warn.category}] ${warn.message}`);
+    for (const warn2 of result.warnings) {
+      lines.push(`- [${warn2.category}] ${warn2.message}`);
     }
   }
   return lines.join(`
@@ -4376,21 +5167,21 @@ async function resolveTodoWriter() {
 }
 
 // src/hooks/compaction-todo-preserver.ts
-function createCompactionTodoPreserver(client) {
+function createCompactionTodoPreserver(client2) {
   const snapshots = new Map;
   async function capture(sessionID) {
     try {
-      const response = await client.session.todo({ path: { id: sessionID } });
+      const response = await client2.session.todo({ path: { id: sessionID } });
       const todos = response.data ?? [];
       if (todos.length > 0) {
         snapshots.set(sessionID, todos);
-        log("[compaction-todo-preserver] Captured snapshot", {
+        debug("[compaction-todo-preserver] Captured snapshot", {
           sessionID,
           count: todos.length
         });
       }
     } catch (err) {
-      log("[compaction-todo-preserver] Failed to capture snapshot (non-fatal)", {
+      warn("[compaction-todo-preserver] Failed to capture snapshot (non-fatal)", {
         sessionID,
         error: String(err)
       });
@@ -4402,10 +5193,10 @@ function createCompactionTodoPreserver(client) {
       return;
     }
     try {
-      const response = await client.session.todo({ path: { id: sessionID } });
+      const response = await client2.session.todo({ path: { id: sessionID } });
       const currentTodos = response.data ?? [];
       if (currentTodos.length > 0) {
-        log("[compaction-todo-preserver] Todos survived compaction, skipping restore", {
+        debug("[compaction-todo-preserver] Todos survived compaction, skipping restore", {
           sessionID,
           currentCount: currentTodos.length
         });
@@ -4415,18 +5206,18 @@ function createCompactionTodoPreserver(client) {
       const todoWriter = await resolveTodoWriter();
       if (todoWriter) {
         todoWriter({ sessionID, todos: snapshot });
-        log("[compaction-todo-preserver] Restored todos via direct write", {
+        debug("[compaction-todo-preserver] Restored todos via direct write", {
           sessionID,
           count: snapshot.length
         });
       } else {
-        log("[compaction-todo-preserver] Direct write unavailable — todos cannot be restored", {
+        warn("[compaction-todo-preserver] Direct write unavailable — todos cannot be restored", {
           sessionID,
           count: snapshot.length
         });
       }
     } catch (err) {
-      log("[compaction-todo-preserver] Failed to restore todos (non-fatal)", {
+      warn("[compaction-todo-preserver] Failed to restore todos (non-fatal)", {
         sessionID,
         error: String(err)
       });
@@ -4447,7 +5238,7 @@ function createCompactionTodoPreserver(client) {
       const sessionID = props?.sessionID ?? props?.info?.id ?? "";
       if (sessionID) {
         snapshots.delete(sessionID);
-        log("[compaction-todo-preserver] Cleaned up snapshot on session delete", { sessionID });
+        debug("[compaction-todo-preserver] Cleaned up snapshot on session delete", { sessionID });
       }
       return;
     }
@@ -4459,7 +5250,7 @@ function createCompactionTodoPreserver(client) {
 }
 // src/hooks/todo-continuation-enforcer.ts
 var FINALIZE_TODOS_MARKER = "<!-- weave:finalize-todos -->";
-function createTodoContinuationEnforcer(client, options) {
+function createTodoContinuationEnforcer(client2, options) {
   const todoFinalizedSessions = new Set;
   let todoWriterPromise;
   if (options !== undefined && "todoWriterOverride" in options) {
@@ -4469,9 +5260,9 @@ function createTodoContinuationEnforcer(client, options) {
   }
   todoWriterPromise.then((writer) => {
     if (writer) {
-      log("[todo-continuation-enforcer] Direct write: available");
+      debug("[todo-continuation-enforcer] Direct write: available");
     } else {
-      log("[todo-continuation-enforcer] Direct write: unavailable, will fall back to LLM prompt");
+      debug("[todo-continuation-enforcer] Direct write: unavailable, will fall back to LLM prompt");
     }
   }).catch(() => {});
   async function checkAndFinalize(sessionID) {
@@ -4479,7 +5270,7 @@ function createTodoContinuationEnforcer(client, options) {
       return;
     }
     try {
-      const todosResponse = await client.session.todo({ path: { id: sessionID } });
+      const todosResponse = await client2.session.todo({ path: { id: sessionID } });
       const todos = todosResponse.data ?? [];
       const inProgressTodos = todos.filter((t) => t.status === "in_progress");
       if (inProgressTodos.length === 0) {
@@ -4490,14 +5281,14 @@ function createTodoContinuationEnforcer(client, options) {
       if (todoWriter) {
         const updatedTodos = todos.map((t) => t.status === "in_progress" ? { ...t, status: "completed" } : t);
         todoWriter({ sessionID, todos: updatedTodos });
-        log("[todo-continuation-enforcer] Finalized via direct write (0 tokens)", {
+        debug("[todo-continuation-enforcer] Finalized via direct write (0 tokens)", {
           sessionID,
           count: inProgressTodos.length
         });
       } else {
         const inProgressItems = inProgressTodos.map((t) => `  - "${t.content}"`).join(`
 `);
-        await client.session.promptAsync({
+        await client2.session.promptAsync({
           path: { id: sessionID },
           body: {
             parts: [
@@ -4512,14 +5303,14 @@ Use todowrite NOW to mark all of them as "completed" (or "cancelled" if abandone
             ]
           }
         });
-        log("[todo-continuation-enforcer] Finalized via LLM prompt (fallback)", {
+        debug("[todo-continuation-enforcer] Finalized via LLM prompt (fallback)", {
           sessionID,
           count: inProgressTodos.length
         });
       }
     } catch (err) {
       todoFinalizedSessions.delete(sessionID);
-      log("[todo-continuation-enforcer] Failed to check/finalize todos (non-fatal, will retry)", {
+      warn("[todo-continuation-enforcer] Failed to check/finalize todos (non-fatal, will retry)", {
         sessionID,
         error: String(err)
       });
@@ -4546,8 +5337,8 @@ Use todowrite NOW to mark all of them as "completed" (or "cancelled" if abandone
   };
 }
 // src/features/analytics/storage.ts
-import { existsSync as existsSync12, mkdirSync as mkdirSync4, appendFileSync as appendFileSync2, readFileSync as readFileSync9, writeFileSync as writeFileSync3, statSync as statSync2 } from "fs";
-import { join as join10 } from "path";
+import { existsSync as existsSync11, mkdirSync as mkdirSync3, appendFileSync, readFileSync as readFileSync9, writeFileSync as writeFileSync3, statSync as statSync2 } from "fs";
+import { join as join9 } from "path";
 
 // src/features/analytics/types.ts
 var ANALYTICS_DIR = ".weave/analytics";
@@ -4562,17 +5353,17 @@ function zeroTokenUsage() {
 // src/features/analytics/storage.ts
 var MAX_SESSION_ENTRIES = 1000;
 function ensureAnalyticsDir(directory) {
-  const dir = join10(directory, ANALYTICS_DIR);
-  mkdirSync4(dir, { recursive: true, mode: 448 });
+  const dir = join9(directory, ANALYTICS_DIR);
+  mkdirSync3(dir, { recursive: true, mode: 448 });
   return dir;
 }
 function appendSessionSummary(directory, summary) {
   try {
     const dir = ensureAnalyticsDir(directory);
-    const filePath = join10(dir, SESSION_SUMMARIES_FILE);
+    const filePath = join9(dir, SESSION_SUMMARIES_FILE);
     const line = JSON.stringify(summary) + `
 `;
-    appendFileSync2(filePath, line, { encoding: "utf-8", mode: 384 });
+    appendFileSync(filePath, line, { encoding: "utf-8", mode: 384 });
     try {
       const TYPICAL_ENTRY_BYTES = 200;
       const rotationSizeThreshold = MAX_SESSION_ENTRIES * TYPICAL_ENTRY_BYTES * 0.9;
@@ -4595,9 +5386,9 @@ function appendSessionSummary(directory, summary) {
   }
 }
 function readSessionSummaries(directory) {
-  const filePath = join10(directory, ANALYTICS_DIR, SESSION_SUMMARIES_FILE);
+  const filePath = join9(directory, ANALYTICS_DIR, SESSION_SUMMARIES_FILE);
   try {
-    if (!existsSync12(filePath))
+    if (!existsSync11(filePath))
       return [];
     const content = readFileSync9(filePath, "utf-8");
     const lines = content.split(`
@@ -4616,7 +5407,7 @@ function readSessionSummaries(directory) {
 function writeFingerprint(directory, fingerprint) {
   try {
     const dir = ensureAnalyticsDir(directory);
-    const filePath = join10(dir, FINGERPRINT_FILE);
+    const filePath = join9(dir, FINGERPRINT_FILE);
     writeFileSync3(filePath, JSON.stringify(fingerprint, null, 2), { encoding: "utf-8", mode: 384 });
     return true;
   } catch {
@@ -4624,9 +5415,9 @@ function writeFingerprint(directory, fingerprint) {
   }
 }
 function readFingerprint(directory) {
-  const filePath = join10(directory, ANALYTICS_DIR, FINGERPRINT_FILE);
+  const filePath = join9(directory, ANALYTICS_DIR, FINGERPRINT_FILE);
   try {
-    if (!existsSync12(filePath))
+    if (!existsSync11(filePath))
       return null;
     const content = readFileSync9(filePath, "utf-8");
     const parsed = JSON.parse(content);
@@ -4640,10 +5431,10 @@ function readFingerprint(directory) {
 function writeMetricsReport(directory, report) {
   try {
     const dir = ensureAnalyticsDir(directory);
-    const filePath = join10(dir, METRICS_REPORTS_FILE);
+    const filePath = join9(dir, METRICS_REPORTS_FILE);
     const line = JSON.stringify(report) + `
 `;
-    appendFileSync2(filePath, line, { encoding: "utf-8", mode: 384 });
+    appendFileSync(filePath, line, { encoding: "utf-8", mode: 384 });
     try {
       const TYPICAL_ENTRY_BYTES = 200;
       const rotationSizeThreshold = MAX_METRICS_ENTRIES * TYPICAL_ENTRY_BYTES * 0.9;
@@ -4666,9 +5457,9 @@ function writeMetricsReport(directory, report) {
   }
 }
 function readMetricsReports(directory) {
-  const filePath = join10(directory, ANALYTICS_DIR, METRICS_REPORTS_FILE);
+  const filePath = join9(directory, ANALYTICS_DIR, METRICS_REPORTS_FILE);
   try {
-    if (!existsSync12(filePath))
+    if (!existsSync11(filePath))
       return [];
     const content = readFileSync9(filePath, "utf-8");
     const lines = content.split(`
@@ -5198,7 +5989,7 @@ function generateMetricsReport(directory, state) {
         totalTokens
       });
     } catch (qualityErr) {
-      log("[analytics] Failed to calculate quality score (non-fatal)", {
+      warn("[analytics] Failed to calculate quality score (non-fatal)", {
         error: String(qualityErr)
       });
     }
@@ -5219,10 +6010,10 @@ function generateMetricsReport(directory, state) {
     };
     const written = writeMetricsReport(directory, report);
     if (!written) {
-      log("[analytics] Failed to write metrics report (non-fatal)");
+      warn("[analytics] Failed to write metrics report (non-fatal)");
       return null;
     }
-    log("[analytics] Metrics report generated", {
+    debug("[analytics] Metrics report generated", {
       plan: report.planName,
       coverage: adherence.coverage,
       precision: adherence.precision,
@@ -5230,7 +6021,7 @@ function generateMetricsReport(directory, state) {
     });
     return report;
   } catch (err) {
-    log("[analytics] Failed to generate metrics report (non-fatal)", {
+    warn("[analytics] Failed to generate metrics report (non-fatal)", {
       error: String(err)
     });
     return null;
@@ -5239,11 +6030,11 @@ function generateMetricsReport(directory, state) {
 
 // src/plugin/plugin-interface.ts
 function createPluginInterface(args) {
-  const { pluginConfig, hooks, tools, configHandler, agents, client, directory = "", tracker } = args;
+  const { pluginConfig, hooks, tools, configHandler, agents, client: client2, directory = "", tracker } = args;
   const lastAssistantMessageText = new Map;
   const lastUserMessageText = new Map;
-  const compactionPreserver = hooks.compactionTodoPreserverEnabled && client ? createCompactionTodoPreserver(client) : null;
-  const todoContinuationEnforcer = hooks.todoContinuationEnforcerEnabled && client ? createTodoContinuationEnforcer(client) : null;
+  const compactionPreserver = hooks.compactionTodoPreserverEnabled && client2 ? createCompactionTodoPreserver(client2) : null;
+  const todoContinuationEnforcer = hooks.todoContinuationEnforcerEnabled && client2 ? createTodoContinuationEnforcer(client2) : null;
   return {
     tool: tools,
     config: async (config) => {
@@ -5254,14 +6045,14 @@ function createPluginInterface(args) {
       });
       const existingAgents = config.agent ?? {};
       if (Object.keys(existingAgents).length > 0) {
-        log("[config] Merging Weave agents over existing agents", {
+        debug("[config] Merging Weave agents over existing agents", {
           existingCount: Object.keys(existingAgents).length,
           weaveCount: Object.keys(result.agents).length,
           existingKeys: Object.keys(existingAgents)
         });
         const collisions = Object.keys(result.agents).filter((key) => (key in existingAgents));
         if (collisions.length > 0) {
-          log("[config] Weave agents overriding user-defined agents with same name", {
+          info("[config] Weave agents overriding user-defined agents with same name", {
             overriddenKeys: collisions
           });
         }
@@ -5300,6 +6091,12 @@ function createPluginInterface(args) {
         const result = isWorkflowCommand ? { contextInjection: null, switchAgent: null } : hooks.startWork(promptText, sessionID);
         if (result.switchAgent && message) {
           message.agent = getAgentDisplayName(result.switchAgent);
+          debug("[start-work] Switching agent for plan execution", {
+            sessionId: sessionID,
+            agent: result.switchAgent,
+            displayName: message.agent,
+            hasContextInjection: !!result.contextInjection
+          });
         }
         if (result.contextInjection && parts) {
           const idx = parts.findIndex((p) => p.type === "text" && p.text);
@@ -5322,6 +6119,11 @@ ${result.contextInjection}`;
           const result = hooks.workflowStart(promptText, sessionID);
           if (result.switchAgent && message) {
             message.agent = getAgentDisplayName(result.switchAgent);
+            debug("[workflow] Switching agent for workflow execution", {
+              sessionId: sessionID,
+              agent: result.switchAgent,
+              displayName: message.agent
+            });
           }
           if (result.contextInjection && parts) {
             const idx = parts.findIndex((p) => p.type === "text" && p.text);
@@ -5371,6 +6173,10 @@ ${cmdResult.contextInjection}`;
             }
             if (cmdResult.switchAgent && message) {
               message.agent = getAgentDisplayName(cmdResult.switchAgent);
+              debug("[workflow] Switching agent via workflow command", {
+                agent: cmdResult.switchAgent,
+                displayName: message.agent
+              });
             }
           }
         }
@@ -5391,7 +6197,7 @@ ${cmdResult.contextInjection}`;
           const state = readWorkState(directory);
           if (state && !state.paused) {
             pauseWork(directory);
-            log("[work-continuation] Auto-paused: user message received during active plan", { sessionId: sessionID });
+            info("[work-continuation] Auto-paused: user message received during active plan", { sessionId: sessionID });
           }
         }
       }
@@ -5402,7 +6208,7 @@ ${cmdResult.contextInjection}`;
       const maxTokens = input.model?.limit?.context ?? 0;
       if (sessionId && maxTokens > 0) {
         setContextLimit(sessionId, maxTokens);
-        log("[context-window] Captured context limit", { sessionId, maxTokens });
+        debug("[context-window] Captured context limit", { sessionId, maxTokens });
       }
       if (tracker && hooks.analyticsEnabled && sessionId && input.agent) {
         tracker.setAgentName(sessionId, input.agent);
@@ -5437,7 +6243,7 @@ ${cmdResult.contextInjection}`;
           try {
             tracker.endSession(evt.properties.info.id);
           } catch (err) {
-            log("[analytics] Failed to end session (non-fatal)", { error: String(err) });
+            warn("[analytics] Failed to end session (non-fatal)", { error: String(err) });
           }
           if (directory) {
             try {
@@ -5449,29 +6255,29 @@ ${cmdResult.contextInjection}`;
                 }
               }
             } catch (err) {
-              log("[analytics] Failed to generate metrics report on session end (non-fatal)", { error: String(err) });
+              warn("[analytics] Failed to generate metrics report on session end (non-fatal)", { error: String(err) });
             }
           }
         }
       }
       if (event.type === "message.updated") {
         const evt = event;
-        const info = evt.properties?.info;
-        if (info?.role === "assistant" && info.sessionID) {
+        const info2 = evt.properties?.info;
+        if (info2?.role === "assistant" && info2.sessionID) {
           if (hooks.checkContextWindow) {
-            const inputTokens = info.tokens?.input ?? 0;
+            const inputTokens = info2.tokens?.input ?? 0;
             if (inputTokens > 0) {
-              updateUsage(info.sessionID, inputTokens);
-              const tokenState = getState(info.sessionID);
+              updateUsage(info2.sessionID, inputTokens);
+              const tokenState = getState(info2.sessionID);
               if (tokenState && tokenState.maxTokens > 0) {
                 const result = hooks.checkContextWindow({
                   usedTokens: tokenState.usedTokens,
                   maxTokens: tokenState.maxTokens,
-                  sessionId: info.sessionID
+                  sessionId: info2.sessionID
                 });
                 if (result.action !== "none") {
-                  log("[context-window] Threshold crossed", {
-                    sessionId: info.sessionID,
+                  warn("[context-window] Threshold crossed", {
+                    sessionId: info2.sessionID,
                     action: result.action,
                     usagePct: result.usagePct
                   });
@@ -5483,18 +6289,18 @@ ${cmdResult.contextInjection}`;
       }
       if (event.type === "message.updated" && tracker && hooks.analyticsEnabled) {
         const evt = event;
-        const info = evt.properties?.info;
-        if (info?.role === "assistant" && info.sessionID) {
-          if (typeof info.cost === "number" && info.cost > 0) {
-            tracker.trackCost(info.sessionID, info.cost);
+        const info2 = evt.properties?.info;
+        if (info2?.role === "assistant" && info2.sessionID) {
+          if (typeof info2.cost === "number" && info2.cost > 0) {
+            tracker.trackCost(info2.sessionID, info2.cost);
           }
-          if (info.tokens) {
-            tracker.trackTokenUsage(info.sessionID, {
-              input: info.tokens.input ?? 0,
-              output: info.tokens.output ?? 0,
-              reasoning: info.tokens.reasoning ?? 0,
-              cacheRead: info.tokens.cache?.read ?? 0,
-              cacheWrite: info.tokens.cache?.write ?? 0
+          if (info2.tokens) {
+            tracker.trackTokenUsage(info2.sessionID, {
+              input: info2.tokens.input ?? 0,
+              output: info2.tokens.output ?? 0,
+              reasoning: info2.tokens.reasoning ?? 0,
+              cacheRead: info2.tokens.cache?.read ?? 0,
+              cacheWrite: info2.tokens.cache?.write ?? 0
             });
           }
         }
@@ -5503,12 +6309,12 @@ ${cmdResult.contextInjection}`;
         const evt = event;
         if (evt.properties?.command === "session.interrupt") {
           pauseWork(directory);
-          log("[work-continuation] User interrupt detected — work paused");
+          info("[work-continuation] User interrupt detected — work paused");
           if (directory) {
             const activeWorkflow = getActiveWorkflowInstance(directory);
             if (activeWorkflow && activeWorkflow.status === "running") {
               pauseWorkflow(directory, "User interrupt");
-              log("[workflow] User interrupt detected — workflow paused");
+              info("[workflow] User interrupt detected — workflow paused");
             }
           }
         }
@@ -5530,21 +6336,21 @@ ${cmdResult.contextInjection}`;
             const lastMsg = lastAssistantMessageText.get(sessionId) ?? undefined;
             const lastUserMsg = lastUserMessageText.get(sessionId) ?? undefined;
             const result = hooks.workflowContinuation(sessionId, lastMsg, lastUserMsg);
-            if (result.continuationPrompt && client) {
+            if (result.continuationPrompt && client2) {
               try {
-                await client.session.promptAsync({
+                await client2.session.promptAsync({
                   path: { id: sessionId },
                   body: {
                     parts: [{ type: "text", text: result.continuationPrompt }],
                     ...result.switchAgent ? { agent: getAgentDisplayName(result.switchAgent) } : {}
                   }
                 });
-                log("[workflow] Injected workflow continuation prompt", {
+                debug("[workflow] Injected workflow continuation prompt", {
                   sessionId,
                   agent: result.switchAgent
                 });
               } catch (err) {
-                log("[workflow] Failed to inject workflow continuation", { sessionId, error: String(err) });
+                error("[workflow] Failed to inject workflow continuation", { sessionId, error: String(err) });
               }
               return;
             }
@@ -5556,21 +6362,21 @@ ${cmdResult.contextInjection}`;
         const sessionId = evt.properties?.sessionID ?? "";
         if (sessionId) {
           const result = hooks.workContinuation(sessionId);
-          if (result.continuationPrompt && client) {
+          if (result.continuationPrompt && client2) {
             try {
-              await client.session.promptAsync({
+              await client2.session.promptAsync({
                 path: { id: sessionId },
                 body: {
                   parts: [{ type: "text", text: result.continuationPrompt }]
                 }
               });
-              log("[work-continuation] Injected continuation prompt", { sessionId });
+              debug("[work-continuation] Injected continuation prompt", { sessionId });
               continuationFired = true;
             } catch (err) {
-              log("[work-continuation] Failed to inject continuation", { sessionId, error: String(err) });
+              error("[work-continuation] Failed to inject continuation", { sessionId, error: String(err) });
             }
           } else if (result.continuationPrompt) {
-            log("[work-continuation] continuationPrompt available but no client", { sessionId });
+            debug("[work-continuation] continuationPrompt available but no client", { sessionId });
           }
         }
       }
@@ -5674,14 +6480,14 @@ ${cmdResult.contextInjection}`;
   };
 }
 // src/features/analytics/fingerprint.ts
-import { existsSync as existsSync13, readFileSync as readFileSync12, readdirSync as readdirSync5 } from "fs";
-import { join as join12 } from "path";
+import { existsSync as existsSync12, readFileSync as readFileSync12, readdirSync as readdirSync5 } from "fs";
+import { join as join11 } from "path";
 import { arch } from "os";
 
 // src/shared/version.ts
 import { readFileSync as readFileSync11 } from "fs";
 import { fileURLToPath } from "url";
-import { dirname as dirname2, join as join11 } from "path";
+import { dirname as dirname2, join as join10 } from "path";
 var cachedVersion;
 function getWeaveVersion() {
   if (cachedVersion !== undefined)
@@ -5690,7 +6496,7 @@ function getWeaveVersion() {
     const thisDir = dirname2(fileURLToPath(import.meta.url));
     for (const rel of ["../../package.json", "../package.json"]) {
       try {
-        const pkg = JSON.parse(readFileSync11(join11(thisDir, rel), "utf-8"));
+        const pkg = JSON.parse(readFileSync11(join10(thisDir, rel), "utf-8"));
         if (pkg.name === "@opencode_weave/weave" && typeof pkg.version === "string") {
           const version = pkg.version;
           cachedVersion = version;
@@ -5795,7 +6601,7 @@ function detectStack(directory) {
   const detected = [];
   for (const marker of STACK_MARKERS) {
     for (const file of marker.files) {
-      if (existsSync13(join12(directory, file))) {
+      if (existsSync12(join11(directory, file))) {
         detected.push({
           name: marker.name,
           confidence: marker.confidence,
@@ -5806,8 +6612,8 @@ function detectStack(directory) {
     }
   }
   try {
-    const pkgPath = join12(directory, "package.json");
-    if (existsSync13(pkgPath)) {
+    const pkgPath = join11(directory, "package.json");
+    if (existsSync12(pkgPath)) {
       const pkg = JSON.parse(readFileSync12(pkgPath, "utf-8"));
       const deps = { ...pkg.dependencies, ...pkg.devDependencies };
       if (deps.react) {
@@ -5841,26 +6647,26 @@ function detectStack(directory) {
   });
 }
 function detectPackageManager(directory) {
-  if (existsSync13(join12(directory, "bun.lockb")))
+  if (existsSync12(join11(directory, "bun.lockb")))
     return "bun";
-  if (existsSync13(join12(directory, "pnpm-lock.yaml")))
+  if (existsSync12(join11(directory, "pnpm-lock.yaml")))
     return "pnpm";
-  if (existsSync13(join12(directory, "yarn.lock")))
+  if (existsSync12(join11(directory, "yarn.lock")))
     return "yarn";
-  if (existsSync13(join12(directory, "package-lock.json")))
+  if (existsSync12(join11(directory, "package-lock.json")))
     return "npm";
-  if (existsSync13(join12(directory, "package.json")))
+  if (existsSync12(join11(directory, "package.json")))
     return "npm";
   return;
 }
 function detectMonorepo(directory) {
   for (const marker of MONOREPO_MARKERS) {
-    if (existsSync13(join12(directory, marker)))
+    if (existsSync12(join11(directory, marker)))
       return true;
   }
   try {
-    const pkgPath = join12(directory, "package.json");
-    if (existsSync13(pkgPath)) {
+    const pkgPath = join11(directory, "package.json");
+    if (existsSync12(pkgPath)) {
       const pkg = JSON.parse(readFileSync12(pkgPath, "utf-8"));
       if (pkg.workspaces)
         return true;
@@ -5895,14 +6701,14 @@ function fingerprintProject(directory) {
   try {
     const fingerprint = generateFingerprint(directory);
     writeFingerprint(directory, fingerprint);
-    log("[analytics] Project fingerprinted", {
+    debug("[analytics] Project fingerprinted", {
       stack: fingerprint.stack.map((s) => s.name),
       primaryLanguage: fingerprint.primaryLanguage,
       packageManager: fingerprint.packageManager
     });
     return fingerprint;
   } catch (err) {
-    log("[analytics] Fingerprinting failed (non-fatal)", { error: String(err) });
+    warn("[analytics] Fingerprinting failed (non-fatal)", { error: String(err) });
     return null;
   }
 }
@@ -5914,14 +6720,14 @@ function getOrCreateFingerprint(directory) {
       if (existing.weaveVersion === currentVersion) {
         return existing;
       }
-      log("[analytics] Fingerprint version mismatch — regenerating", {
+      debug("[analytics] Fingerprint version mismatch — regenerating", {
         cached: existing.weaveVersion ?? "none",
         current: currentVersion
       });
     }
     return fingerprintProject(directory);
   } catch (err) {
-    log("[analytics] getOrCreateFingerprint failed (non-fatal)", { error: String(err) });
+    warn("[analytics] getOrCreateFingerprint failed (non-fatal)", { error: String(err) });
     return null;
   }
 }
@@ -6045,7 +6851,7 @@ class SessionTracker {
     };
     try {
       appendSessionSummary(this.directory, summary);
-      log("[analytics] Session summary persisted", {
+      debug("[analytics] Session summary persisted", {
         sessionId,
         totalToolCalls,
         totalDelegations: session.delegations.length,
@@ -6055,7 +6861,7 @@ class SessionTracker {
         } : {}
       });
     } catch (err) {
-      log("[analytics] Failed to persist session summary (non-fatal)", {
+      warn("[analytics] Failed to persist session summary (non-fatal)", {
         sessionId,
         error: String(err)
       });
@@ -6085,12 +6891,16 @@ function createAnalytics(directory, fingerprint) {
 // src/index.ts
 var WeavePlugin = async (ctx) => {
   const pluginConfig = loadWeaveConfig(ctx.directory, ctx);
+  setClient(ctx.client);
+  if (pluginConfig.log_level) {
+    setLogLevel(pluginConfig.log_level);
+  }
   const disabledHooks = new Set(pluginConfig.disabled_hooks ?? []);
   const isHookEnabled = (name) => !disabledHooks.has(name);
   const analyticsEnabled = pluginConfig.analytics?.enabled === true;
   const fingerprintEnabled = analyticsEnabled && pluginConfig.analytics?.use_fingerprint === true;
   const fingerprint = fingerprintEnabled ? getOrCreateFingerprint(ctx.directory) : null;
-  const configDir = join13(ctx.directory, ".opencode");
+  const configDir = join12(ctx.directory, ".opencode");
   const toolsResult = await createTools({ ctx, pluginConfig });
   const managers = createManagers({ ctx, pluginConfig, resolveSkills: toolsResult.resolveSkillsFn, fingerprint, configDir });
   const hooks = createHooks({ pluginConfig, isHookEnabled, directory: ctx.directory, analyticsEnabled });